Module: Middleman::Util

Defined in:
lib/middleman-core/util.rb

Defined Under Namespace

Classes: Cache

Class Method Summary collapse

Class Method Details

.all_files_under(*paths) ⇒ Array

Get a recusive list of files inside a set of paths. Works with symlinks.

Parameters:

  • path —

    A path string or Pathname

Returns:

  • (Array) —

    An array of filenames



136
137
138
139
140
141
142
143
144
 
# File 'lib/middleman-core/util.rb', line 136

def self.all_files_under(*paths)
  paths.flatten!
  paths.map! { |p| Pathname(p) }
  files = paths.select { |p| p.file? }
  paths.select {|p| p.directory? }.each do |dir|
    files << all_files_under(dir.children)
  end
  files.flatten
end

.binary?(filename) ⇒ Boolean

Whether the source file is binary.

Parameters:

  • filename (String) —

    The file to check.

Returns:

  • (Boolean) 


24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/middleman-core/util.rb', line 24

def self.binary?(filename)
  ext = File.extname(filename)
  return true if ext == '.svgz'
  return false if Tilt.registered?(ext.sub('.',''))

  ext = ".#{ext}" unless ext.to_s[0] == ?.
  mime = ::Rack::Mime.mime_type(ext, nil) 
  unless mime
    binary_bytes = [0, 1, 2, 3, 4, 5, 6, 11, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31]
    s = File.read(filename, 4096) || ''        
    s.each_byte do |c|
      return true if binary_bytes.include?(c)          
    end
    return false
  end
  return false if mime.start_with?('text/')
  return false if mime.include?('xml')
  return false if mime.include?('json')
  return false if mime.include?('javascript')
  true
end

.extract_response_text(response) ⇒ String

Extract the text of a Rack response as a string. Useful for extensions implemented as Rack middleware.

Parameters:

  • response —

    The response from #call

Returns:

  • (String) —

    The whole response as a string.



103
104
105
106
107
108
109
110
 
# File 'lib/middleman-core/util.rb', line 103

def self.extract_response_text(response)
  # The rack spec states all response bodies must respond to each
  result = ''
  response.each do |part, s|
    result << part
  end
  result
end

.instrument(name, payload = {}, &block) ⇒ Object

Facade for ActiveSupport/Notification



58
59
60
61
 
# File 'lib/middleman-core/util.rb', line 58

def self.instrument(name, payload={}, &block)
  name << ".middleman" unless name =~ /\.middleman$/
  ::ActiveSupport::Notifications.instrument(name, payload, &block)
end

.logger(*args) ⇒ Middleman::Logger

The logger

Returns:



49
50
51
52
53
54
55
 
# File 'lib/middleman-core/util.rb', line 49

def self.logger(*args)
  if !@_logger || args.length > 0
    @_logger = ::Middleman::Logger.new(*args)
  end

  @_logger
end

.normalize_path(path) ⇒ String

Normalize a path to not include a leading slash

Parameters:

  • path (String)

Returns:

  • (String) 


88
89
90
91
 
# File 'lib/middleman-core/util.rb', line 88

def self.normalize_path(path)
  # The tr call works around a bug in Ruby's Unicode handling
  path.sub(%r{^/}, "").tr('','')
end

.path_match(matcher, path) ⇒ Boolean

Takes a matcher, which can be a literal string or a string containing glob expressions, or a regexp, or a proc, or anything else that responds to #match or #call, and returns whether or not the given path matches that matcher.

Parameters:

  • matcher —

    A matcher string/regexp/proc/etc

  • path —

    A path as a string

Returns:

  • (Boolean) —

    Whether the path matches the matcher



121
122
123
124
125
126
127
128
129
 
# File 'lib/middleman-core/util.rb', line 121

def self.path_match(matcher, path)
  if matcher.respond_to? :match
    matcher.match path
  elsif matcher.respond_to? :call
    matcher.call path
  else
    File.fnmatch(matcher.to_s, path)
  end
end

.recursively_enhance(data) ⇒ Thor::CoreExt::HashWithIndifferentAccess

Recursively convert a normal Hash into a HashWithIndifferentAccess

Parameters:

  • data (Hash) —

    Normal hash

Returns:

  • (Thor::CoreExt::HashWithIndifferentAccess) 


68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/middleman-core/util.rb', line 68

def self.recursively_enhance(data)
  if data.is_a? Hash
    data = ::Thor::CoreExt::HashWithIndifferentAccess.new(data)
    data.each do |key, val|
      data[key] = recursively_enhance(val)
    end
    data
  elsif data.is_a? Array
    data.each_with_index do |val, i|
      data[i] = recursively_enhance(val)
    end
    data
  else
    data
  end
end

.strip_leading_slash(path) ⇒ Object

This is a separate method from normalize_path in case we change how we normalize paths



95
96
97
 
# File 'lib/middleman-core/util.rb', line 95

def self.strip_leading_slash(path)
  path.sub(%r{^/}, "")
end