module HamlLint::Utils

A miscellaneous set of utility functions.

Public Instance Methods

any_glob_matches?(globs_or_glob, file) click to toggle source

Returns whether a glob pattern (or any of a list of patterns) matches the specified file.

This is defined here so our file globbing options are consistent everywhere we perform globbing.

@param glob [String, Array] @param file [String] @return [Boolean]

# File lib/haml_lint/utils.rb, line 18
def any_glob_matches?(globs_or_glob, file)
  get_abs_and_rel_path(file).any? do |path|
    Array(globs_or_glob).any? do |glob|
      ::File.fnmatch?(glob, path,
                      ::File::FNM_PATHNAME | # Wildcards don't match path separators
                      ::File::FNM_DOTMATCH)  # `*` wildcard matches dotfiles
    end
  end
end
camel_case(str) click to toggle source

Converts a string containing underscores/hyphens/spaces into CamelCase.

@param str [String] @return [String]

# File lib/haml_lint/utils.rb, line 91
def camel_case(str)
  str.split(/_|-| /).map { |part| part.sub(/^\w/, &:upcase) }.join
end
count_consecutive(items, offset = 0) { |items| ... } click to toggle source

Count the number of consecutive items satisfying the given {Proc}.

@param items [Array] @param offset [Fixnum] index to start searching from @yield [item] Passes item to the provided block. @yieldparam item [Object] Item to evaluate as matching criteria for

inclusion

@yieldreturn [Boolean] whether to include the item @return [Integer]

# File lib/haml_lint/utils.rb, line 132
def count_consecutive(items, offset = 0)
  count = 1
  count += 1 while (offset + count < items.count) && yield(items[offset + count])
  count
end
extract_interpolated_values(text) { |eval('"' + dumped_interpolated_str + '"'), line| ... } click to toggle source

Yields interpolated values within a block of text.

@param text [String] @yield Passes interpolated code and line number that code appears on in

the text.

@yieldparam interpolated_code [String] code that was interpolated @yieldparam line [Integer] line number code appears on in text

# File lib/haml_lint/utils.rb, line 54
def extract_interpolated_values(text) # rubocop:disable Metrics/AbcSize
  dumped_text = text.dump
  newline_positions = extract_substring_positions(dumped_text, '\\\n')

  Haml::Util.handle_interpolation(dumped_text) do |scan|
    line = (newline_positions.find_index { |marker| scan.pos <= marker } ||
            newline_positions.size) + 1

    escape_count = (scan[2].size - 1) / 2
    break unless escape_count.even?

    dumped_interpolated_str = Haml::Util.balance(scan, '{', '}', 1)[0][0...-1]

    # Hacky way to turn a dumped string back into a regular string
    yield [eval('"' + dumped_interpolated_str + '"'), line] # rubocop:disable Security/Eval
  end
end
extract_substring_positions(text, substr) click to toggle source

Returns indexes of all occurrences of a substring within a string.

Note, this will not return overlaping substrings, so searching for “aa” in “aaa” will only find one substring, not two.

@param text [String] the text to search @param substr [String] the substring to search for @return [Array<Integer>] list of indexes where the substring occurs

# File lib/haml_lint/utils.rb, line 80
def extract_substring_positions(text, substr)
  positions = []
  scanner = StringScanner.new(text)
  positions << scanner.pos while scanner.scan(/(.*?)#{substr}/)
  positions
end
for_consecutive_items(items, satisfies, min_consecutive = 2) { |items| ... } click to toggle source

Find all consecutive items satisfying the given block of a minimum size, yielding each group of consecutive items to the provided block.

@param items [Array] @param satisfies [Proc] function that takes an item and returns true/false @param min_consecutive [Fixnum] minimum number of consecutive items before

yielding the group

@yield Passes list of consecutive items all matching the criteria defined

by the `satisfies` {Proc} to the provided block

@yieldparam group [Array] List of consecutive items @yieldreturn [Boolean] block should return whether item matches criteria

for inclusion
# File lib/haml_lint/utils.rb, line 107
def for_consecutive_items(items, satisfies, min_consecutive = 2)
  current_index = -1

  while (current_index += 1) < items.count
    next unless satisfies[items[current_index]]

    count = count_consecutive(items, current_index, &satisfies)
    next unless count >= min_consecutive

    # Yield the chunk of consecutive items
    yield items[current_index...(current_index + count)]

    current_index += count # Skip this patch of consecutive items to find more
  end
end
get_abs_and_rel_path(path) click to toggle source

Returns an array of two items, the first being the absolute path, the second the relative path.

The relative path is relative to the current working dir. The path passed can be either relative or absolute.

@param path [String] Path to get absolute and relative path of @return [Array<String>] Absolute and relative path

# File lib/haml_lint/utils.rb, line 36
def get_abs_and_rel_path(path)
  original_path = Pathname.new(path)
  root_dir_path = Pathname.new(File.expand_path(Dir.pwd))

  if original_path.absolute?
    [path, original_path.relative_path_from(root_dir_path)]
  else
    [root_dir_path + original_path, path]
  end
end
with_environment(env) { || ... } click to toggle source

Calls a block of code with a modified set of environment variables, restoring them once the code has executed.

@param env [Hash] environment variables to set

# File lib/haml_lint/utils.rb, line 142
def with_environment(env)
  old_env = {}
  env.each do |var, value|
    old_env[var] = ENV[var.to_s]
    ENV[var.to_s] = value
  end

  yield
ensure
  old_env.each { |var, value| ENV[var.to_s] = value }
end