Module: QB::Util

Defined in:
lib/qb/util.rb,
lib/qb/util/bundler.rb,
lib/qb/util/resource.rb,
lib/qb/util/decorators.rb,
lib/qb/util/docker_mixin.rb more...

Overview

Definitions

Defined Under Namespace

Modules: Bundler, Decorators, DockerMixin Classes: Resource

Class Method Summary collapse

Class Method Details

.contract_path(path) ⇒ Pathname

do kind of the opposite of File.expand_path -- turn the home dir into ~ and the current dir into .

Parameters:

  • path (Pathname | String) —

    to contract.

Returns:

  • (Pathname) —

    contracted path.

[View source]

79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/qb/util.rb', line 79

def self.contract_path path
  contracted = if path.start_with? Dir.pwd
    path.sub Dir.pwd, '.'
  elsif path.start_with? ENV['HOME']
    path.sub ENV['HOME'], '~'
  else
    path
  end
  
  Pathname.new contracted
end

.find_up(filename, from = Pathname.pwd, raise_on_not_found: true) ⇒ Pathname?

Find filename in from or closest parent directory.

Parameters:

  • filename (String) —

    name of file to search for.

  • from (Pathname) (defaults to: Pathname.pwd) —

    (Pathname.pwd) directory to start from.

  • raise_on_not_found: (Boolean) (defaults to: true) —

    When true, a FSStateError will be raised if no file is found (default behavior).

    This is something of a legacy behavior - I think it would be better to have find_up return nil in that case and add a find_up! method that raises on not found. But I'm not going to do it right now.

Returns:

  • (Pathname) —

    Pathname of found file.

  • (nil) —

    If no file is found and the raise_on_not_found option is false.

Raises:

  • (QB::FSStateError) —

    If file is not found in from or any of it's parent directories and the raise_on_not_found option is true (default behavior).

[View source]

118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/qb/util.rb', line 118

def self.find_up filename, from = Pathname.pwd, raise_on_not_found: true
  path = from + filename
  
  return from if path.exist?
  
  parent = from.parent
  
  if from == parent
    if raise_on_not_found
      raise "not found in current or any parent directories: #{ filename }"
    else
      return nil
    end
  end
  
  return find_up filename, parent, raise_on_not_found: raise_on_not_found
end

.find_yaml_file!(dirs:, basename:, exts: QB::YAML_FILE_EXTS) ⇒ ::Pathname

Find a YAML file given it's basename and a list of directories to search, raising if it's not found.

Parameters:

  • dirs (::Array<::Pathname | ::String>) —

    Directories to look in; searched in order.

  • basename (::String) —

    Extension-less name of file.

  • exts (::Array<::String>) (defaults to: QB::YAML_FILE_EXTS) —

    YAML extensions. Will be normalized to have a '.' prefix if they don't already.

Returns:

  • (::Pathname) —

    Path to the first found file.

Raises:

  • (FSStateError<checked: ::Array<::String>>) —

    If a file was not found across any of the dirs and exts.

[View source]

156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/qb/util.rb', line 156

def self.find_yaml_file! dirs:, basename:, exts: QB::YAML_FILE_EXTS
  exts = exts.map { |ext|
    if ext.start_with?( '.' )
      ext
    else
      '.' + ext
    end
  }
  
  checked = []
  
  dirs.each do |dir|
    exts.each do |ext|
      path = ::Pathname.new File.join( dir, "#{ basename }#{ ext }" )
      
      return path if path.file?
      
      checked << path
    end
  end
  
  file_pattern = \
    "#{ basename }.{#{ exts.map { |ext| ext[ 1..-1 ] }.join ',' }"
  
  # If we haven't returned, we didn't find shit
  raise FSStateError.new "File `#{ file_pattern }` not found",
    checked: checked.map( &:to_s )
end

.resolve(*segments) ⇒ Pathname

Returns absolute resolved path.

Returns:

  • (Pathname) —

    absolute resolved path.

[View source]

57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/qb/util.rb', line 57

def self.resolve *segments
  joined = Pathname.new ''
  
  ([Dir.pwd] + segments).reverse.each_with_index {|segment, index|
    joined = Pathname.new(segment).join joined
    return joined if joined.absolute?
  }
  
  # shouldn't ever happen
  raise "resolution failed: #{ segments.inspect }"
end

.words(string) ⇒ Array<String>

Split a string into 'words' for word-based matching

Returns:

  • (Array<String>) —

    Array of non-empty words in string.

[View source]

38
39
40
 
# File 'lib/qb/util.rb', line 38

def self.words string
  string.words
end

.words_slice?(full_string, input, &is_match) ⇒ Boolean

Returns:

  • (Boolean)
[View source]

43
44
45
 
# File 'lib/qb/util.rb', line 43

def self.words_slice? full_string, input, &is_match
  full_string.words.slice? input.words, &is_match
end

.words_start_with?(full_string, input) ⇒ Boolean

see if words from an input match words

Returns:

  • (Boolean)
[View source]

49
50
51
52
53
 
# File 'lib/qb/util.rb', line 49

def self.words_start_with? full_string, input
  words_slice? full_string, input do |full_string_word, input_word|
    full_string_word.start_with? input_word
  end
end