qualitysmith_extensions 0.0.49 → 0.0.60

data/lib/qualitysmith_extensions/colored/toggleability.rb

@@ -15,6 +15,7 @@ gem 'qualitysmith_extensions'
 require 'qualitysmith_extensions/module/guard_method'
 
 class String
+  @@colorize_enabled = true   # Default to enabled
   def colorize_with_toggleability(string, options = {})
     if @@colorize_enabled
       colorize_without_toggleability(string, options)

data/lib/qualitysmith_extensions/enumerable/select_until.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+# Alias for:
+require 'qualitysmith_extensions/enumerable/select_while'
+

data/lib/qualitysmith_extensions/enumerable/select_while.rb

@@ -0,0 +1,109 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+
+module Enumerable
+  # Returns an array containing all _consecutive_ elements of +enum+ for which +block+ is not false, starting at the first element.
+  # So it is very much like select, only it stops searching as soon as <tt>block</tt> ceases to be true. (That means it will stop searching immediately if the first element doesn't match.)
+  #
+  # This might be preferable to +select+, for example, if:
+  # * you have a very large collection of elements
+  # * the desired elements are expected to all be consecutively occuring and are all at the beginning of the collection
+  # * it would be costly to continue iterating all the way to the very end
+  #
+  # This is probably only useful for collections that have some kind of predictable ordering (such as Arrays).
+  #
+  # AKA: select_top_elements_that_match
+  #
+  def select_until(inclusive = false, &block)
+    selected = []
+    inclusive ? (
+      each do |item|
+        selected << item
+        break if block.call(item)
+      end
+    ) : (
+      each do |item|
+        break if block.call(item)
+        selected << item
+      end
+    )
+    selected
+  end
+
+  def select_while(&block)
+    selected = []
+    each do |item|
+      break if !block.call(item)
+      selected << item
+    end
+    selected
+  end
+end
+
+
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TheTest < Test::Unit::TestCase
+  def test_1
+    assert_equal [1, 2], (1..4).select_while {|i| i <= 2}
+    assert_equal [1, 2], (1..4).select_until {|i| i == 3}
+  end
+
+  def test_not_same_as_select
+    # Ah, yes, it behaves the same as select in *this* simple case:
+    assert_equal [1, 2], (1..4).select {|i| i <= 2}
+
+    # But what about _this_ one... hmm?
+    assert_equal [1, 2],       [1, 2, 3, 2, 1].select_while {|i| i <= 2}
+    assert_equal [1, 2, 2, 1], [1, 2, 3, 2, 1].select {|i| i <= 2}          # Not the same! Keyword: _consecutive_.
+
+    # Or _this_ one...
+    assert_equal [1, 2, 1],  [1, 2, 1, 99, 2].select_while {|i| i <= 2}
+    assert_equal [1, 2],     [1, 2, 1, 99, 2].select {|i| i <= 2}.uniq    # Even this isn't the same.
+  end
+
+  def test_inclusive_option
+    assert_equal [
+      'def cabbage',
+      '  :cabbage',
+    ], [
+      'def cabbage',
+      '  :cabbage',
+      'end',
+    ].select_until {|line| line =~ /end/}
+    # Not far enough. We actually want to *include* that last element.
+
+    assert_equal [
+      'def cabbage',
+      '  :cabbage',
+      'end',
+    ], [
+      'def cabbage',
+      '  :cabbage',
+      'end',
+      'def carrot',
+      '  :carrot',
+      'end',
+    ].select_until(true) {|line| line =~ /end/}
+  end
+end
+=end
+
+

data/lib/qualitysmith_extensions/exception/inspect_with_backtrace.rb

@@ -13,7 +13,11 @@ require 'facets/core/module/alias_method_chain'
 class Exception
   # Use this if you want to output an exception with all the details that you'd *normally* see if the exception went unrescued
   # (since exception.inspect/p exception doesn't provide a backtrace!) 
+  #
   # This is mostly useful if you rescue an exception, want to print or log it and then re-raise it...
+  #
+  # Use inspect_without_backtrace if you want to access the previous behavior (<tt>#<MissingSourceFile: no such file to load -- whatever></tt>).
+  #
   def inspect_with_backtrace
     exception.class.name + ": " + exception.message + "\n" +
       exception.backtrace.map {|v| '  ' + v}.join( "\n" )

data/lib/qualitysmith_extensions/kernel/require_all.rb

@@ -13,19 +13,30 @@ require_local '../file/exact_match_regexp'
 
 module Kernel
 
-  # Recursively <tt>require</tt>s all Ruby files in <tt>base_dir</tt> or any of its subdirectories.
+  # <tt>require</tt>s all Ruby files specified by <tt>what</tt>, but not matching any of the exclude filters.
+  # * If <tt>what</tt> is a string, recursively <tt>require</tt>s all Ruby files in the directory named <tt>what</tt> or any of its subdirectories.
+  # * If <tt>what</tt> is a FileList, <tt>require</tt>s all Ruby files that match the <tt>what</tt> FileList.
+  #
+  # Options:
   # <tt>:exclude</tt>:       An array of regular expressions or glob patterns that will be passed to FileList#exclude. If you specify this option, a file will not be included if it matches *any* of these patterns.
   # <tt>:exclude_files</tt>: An array of filenames to exclude. These will be matched exactly, so if you tell it to exclude 'bar.rb', 'foobar.rb' will _not_ be excluded.
   #
-  # Note:
-  #
   # Examples:
   #   require_all 'lib/', :exclude => [/ignore/, /bogus/]   # will require 'lib/a.rb', 'lib/long/path/b.rb', but not 'lib/ignore/c.rb'
   #   require_all File.dirname(__FILE__), :exclude_files => ['blow_up_stuff.rb']
-  def require_all(base_dir, options = {})
-    base_dir += '/' unless base_dir[-1].chr == '/'
-    exclusions = nil
-    files = FileList[base_dir + "**/*.rb"]
+  def require_all(what, options = {})
+    files, exclusions = [nil]*2
+
+    case what
+      when String
+        base_dir = what
+        base_dir += '/' unless base_dir[-1].chr == '/'
+        files = FileList[base_dir + "**/*.rb"]
+      when FileList
+        files = what
+      else
+        raise ArgumentError.new("Expected a String or a FileList")
+    end
     files = files.exclude(*exclusions)                                       if (exclusions = options.delete(:exclude))
     files = files.exclude(*exclusions.map {|a| File.exact_match_regexp(a) }) if (exclusions = options.delete(:exclude_files))
 
@@ -35,6 +46,22 @@ module Kernel
     end
   end
 
+  # <tt>require</tt>s all Ruby files in +dir+ (relative to <tt>File.dirname(__FILE__)</tt>) or any of its subdirectories.
+  #
+  # This is just a shortcut for this:
+  #   require_all File.join(File.dirname(__FILE__), dir)
+  #
+  # All of the +options+ available for +require_all+ are still available here.
+  #
+  def require_local_all(dir = './', options = {})
+    raise ArgumentError.new("dir must be a String") unless dir.is_a?(String)
+    local_dir = File.dirname( caller[0] )
+    require_all(
+      File.join(local_dir, dir),
+      options
+    )
+  end
+
 end
 
 #  _____         _
@@ -51,6 +78,7 @@ require 'English'
 class TheTest < Test::Unit::TestCase
   def setup
     @base_dir = "#{Dir.tmpdir}/require_all_test"
+    @base_local_dir = File.dirname(__FILE__) # To allow testing of require_local_all. But tests should put everything in "#{@base_local_dir}/require_all_test" to avoid clutter or name conflicts with other files!
     FileUtils.mkdir              @base_dir
     @deep_dir = "really/really/deep/subdir"
     $loaded = []
@@ -58,6 +86,7 @@ class TheTest < Test::Unit::TestCase
   end
   def teardown
     FileUtils.rm_rf @base_dir
+    FileUtils.rm_rf "#{@base_local_dir}/require_all_test"
   end
 
 
@@ -99,14 +128,30 @@ class TheTest < Test::Unit::TestCase
     assert_equal ['require_me.rb'], $loaded
   end
 
+  def test_require_local_all
+    create_ruby_file 'require_all_test/lib/require_me.rb', @base_local_dir
+    create_ruby_file 'require_all_test/lib/please_ignore_me.rb', @base_local_dir
+
+    require_local_all 'require_all_test/lib', :exclude => [/ignore/]
+    assert_equal ['require_all_test/lib/require_me.rb'], $loaded
+  end
+
   def test_exclude_pattern_with_directory
     create_ruby_file 'subdir/test/assert_even.rb'
     create_ruby_file 'subdir/test/assert_odd.rb'
 
-    require_all File.dirname(@base_dir), :exclude => [/[^|\/]test/]
+    require_all File.dirname(@base_dir), :exclude => [/(^|\/)test/]
     assert_equal [], $loaded
   end
 
+  def test_passing_a_FileList
+    create_ruby_file 'subdir/junk/pretty_much_useless.rb'
+    create_ruby_file 'subdir/not_junk/good_stuff.rb'
+
+    require_all FileList[File.dirname(@base_dir) + "/**/*.rb"], :exclude => [/(^|\/)junk/]
+    assert_equal ['subdir/not_junk/good_stuff.rb'], $loaded
+  end
+
   def test_exclude_filename
     create_ruby_file 'yes.rb'
     create_ruby_file 'all.rb'
@@ -125,11 +170,16 @@ class TheTest < Test::Unit::TestCase
     assert_equal ['yes.rb'], $loaded
   end
 
-  def create_ruby_file(file_name)
+  #-------------------------------------------------------------------------------------------------------------------------------
+  # Helpers
+
+  def create_ruby_file(file_name, base_dir = @base_dir)
+    # use dirname instead?
     if file_name =~ /(.*)\//
-      FileUtils.mkdir_p @base_dir + '/' + $1
+      FileUtils.mkdir_p base_dir + '/' + $1
     end
-    File.open(@base_dir + '/' + file_name, "w") {|f| f.puts "$loaded << '#{file_name}'"}
+    path = base_dir + '/' + file_name
+    File.open(path, "w") {|f| f.puts "$loaded << '#{file_name}'"}
   end
 
 end

data/lib/qualitysmith_extensions/kernel/require_local_all.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+# Alias for:
+require 'qualitysmith_extensions/kernel/require_all'
+

data/lib/qualitysmith_extensions/module/alias_method_chain.rb

@@ -0,0 +1,165 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 the Rails people; QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+require 'rubygems'
+gem 'facets'
+#require 'facets/core/module/alias_method_chain'    # Doesn't support blocks or I'd use it.
+require 'facets/core/kernel/singleton_class'
+
+
+# /usr/lib/ruby/gems/1.8/gems/activesupport-1.4.2/lib/active_support/core_ext/module/aliasing.rb
+class Module
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+    alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
+    alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+  end
+end
+# end /usr/lib/ruby/gems/1.8/gems/activesupport-1.4.2/lib/active_support/core_ext/module/aliasing.rb
+
+class Module
+
+  def alias_method_chain_with_prevent_repeat_aliasing(target, feature, &block)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+
+    aliased_target, punctuation = target.to_s.sub(/([?!])$/, ''), $1
+    target_without_feature = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    #puts "#{target} is #{method_defined?(target)}"
+    alias_method_chain_without_prevent_repeat_aliasing(target, feature, &block) unless method_defined?(target_without_feature)
+  end
+  alias_method_chain :alias_method_chain, :prevent_repeat_aliasing
+
+  # If you pass <tt>:create_target => true</tt> as one of the +options+:
+  # * Guarantees that <tt>alias_method_chain target, feature</tt> will work even if the target method has not been defined yet.
+  #   If the target method doesn't exist yet, an empty (no-op) target method will be created.
+  # * This could come in handy for callback methods (method_added, method_missing, etc.), for instane, when you don't know if that
+  #   particular callback method has been defined or not.
+  # * You want your alias_method_chain to wrap the existing method if there *is* an existing method, but to <b>not break</b> in 
+  #   the case that the method _doesn't_ exist.
+  def alias_method_chain_with_target_need_not_exist(target, feature, options = {}, &block)
+    create_target = options.delete(:create_target)
+    
+    if create_target && true #!self.methods.include?(target)
+      self.send :define_method, target do |*args|
+        # Intentionally empty
+      end
+    end
+
+    alias_method_chain_without_target_need_not_exist(target, feature, &block)
+  end
+  alias_method_chain :alias_method_chain, :target_need_not_exist
+end
+
+
+
+=begin test
+require 'test/unit'
+
+class Test_alias_method_chain_basic < Test::Unit::TestCase
+
+  class X
+    def foo?
+      'foo?'
+    end
+    def foo_with_feature?
+      foo_without_feature? + '_with_feature'
+    end
+  end
+
+  def test_question_mark
+    name, punctuation = nil, nil
+    X.instance_eval do
+      alias_method_chain :foo?, :feature do |a, b|
+        name, punctuation = a, b
+      end
+    end
+
+    assert_equal 'foo?_with_feature', X.new.foo?
+    assert_equal 'foo', name
+    assert_equal '?', punctuation
+  end
+
+  class Y
+    def foo!
+      'foo!'
+    end
+    def foo_with_feature!
+      foo_without_feature! + '_with_feature'
+    end
+  end
+
+  def test_exclamation_mark
+    name, punctuation = nil, nil
+    Y.instance_eval do
+      alias_method_chain :foo!, :feature do |a, b|
+        name, punctuation = a, b
+      end
+    end
+
+    assert_equal 'foo!_with_feature', Y.new.foo!
+    assert_equal 'foo', name
+    assert_equal '!', punctuation
+  end
+
+end
+
+class Test_alias_method_chain_with_prevent_repeat_aliasing < Test::Unit::TestCase
+
+  class X
+    def foo
+      'foo'
+    end
+    def foo_with_feature
+      foo_without_feature + '_with_feature'
+    end
+    alias_method_chain :foo, :feature
+    alias_method_chain :foo, :feature   # We want to test that this won't cause an infinite recursion (stack overflow).
+  end
+
+  def test_1
+    assert_equal 'foo_with_feature', X.new.foo
+  end
+
+end
+
+
+class Test_alias_method_chain_with_target_need_not_exist < Test::Unit::TestCase
+
+  # Let's assume that we are *re*-opening X here, and at this point we *don't know* if it has a foo method or not.
+  # Also, we *don't want to care*. We just want to add to the chain if the method exists, or *create* the chain
+  # if it does not yet.
+  class X
+    def foo_with_feature
+      # *Don't* do this if you're using :create_target => true:
+      #   foo_without_feature + '_with_feature'
+      # If you're using :create_target => true, then you are pretty much saying "I don't know anything about thhe target method".
+      # Yet the previous statement shows that you expect it to return a String. You can't do that. You can't pretend to know
+      # anything about it's return value. It will always be nil if alias_method_chain created an empty method for you.
+      # But, it may be something else if it already existed and alias_method_chain did *not* create an empty method for you.
+
+      # The safest thing to do is to just call it and pay not attention to its return value. (Or at least *consider* the
+      # possibility that it may be nil.)
+
+      foo_without_feature
+      'feature was successfully added'
+    end
+    alias_method_chain :foo, :feature, :create_target => true
+  end
+
+  def test_1
+    assert_equal 'feature was successfully added', X.new.foo
+    assert_equal 'feature was successfully added', X.new.foo { 'test that it works with a block' }
+  end
+end
+=end

data/lib/qualitysmith_extensions/module/create.rb

@@ -166,13 +166,13 @@ class ModuleCreationHelperTest < Test::Unit::TestCase
   def test_no_options_for_class
     klass = Class.create(:Foo)
     assert_equal Object, klass.superclass
-    assert_equal Object, klass.namespace
+    assert_equal Object, klass.namespace_module
     assert Object.const_defined?('Foo')
   end
   
   def test_no_options_for_module
     mod = Module.create(:FooMod)
-    assert_equal Object, mod.namespace
+    assert_equal Object, mod.namespace_module
     assert Object.const_defined?('FooMod')
   end
   
@@ -187,34 +187,34 @@ class ModuleCreationHelperTest < Test::Unit::TestCase
   def test_superclass
     klass = Class.create(:Bar, :superclass => BaseClass)
     assert_equal BaseClass, klass.superclass
-    assert_equal Object, klass.namespace
+    assert_equal Object, klass.namespace_module
     assert Object.const_defined?('Bar')
   end
   
   def test_namespace_for_class
     klass = Class.create(:Baz, :namespace => Namespace)
     assert_equal Object, klass.superclass
-    assert_equal Namespace, klass.namespace
+    assert_equal Namespace, klass.namespace_module
     assert Namespace.const_defined?('Baz')
   end
   
   def test_namespace_for_class__namespace_as_part_of_name
     klass = Class.create(:'Namespace::Baz')
     assert_equal Object, klass.superclass
-    assert_equal Namespace, klass.namespace
+    assert_equal Namespace, klass.namespace_module
     assert Namespace.const_defined?('Baz')
   end
   
   def test_namespace_for_module
     mod = Module.create(:BazMod, :namespace => Namespace)
-    assert_equal Namespace, mod.namespace
+    assert_equal Namespace, mod.namespace_module
     assert Namespace.const_defined?('BazMod')
   end
   
   def test_superclass_and_namespace
     klass = Class.create(:Biz, :superclass => BaseClass, :namespace => Namespace)
     assert_equal BaseClass, klass.superclass
-    assert_equal Namespace, klass.namespace
+    assert_equal Namespace, klass.namespace_module
     assert Namespace.const_defined?('Biz')
   end
   

data/lib/qualitysmith_extensions/module/malias_method_chain.rb

@@ -0,0 +1,92 @@
+#--
+# Author::    Tyler Rick
+# Copyright:: Copyright (c) 2007 QualitySmith, Inc.
+# License::   Ruby License
+# Submit to Facets?:: Yes.
+# Developer notes::
+# Changes::
+#++
+
+require 'rubygems'
+gem 'facets'
+require 'facets/core/kernel/singleton_class'
+require 'qualitysmith_extensions/module/alias_method_chain'
+
+class Module
+
+  # Same as <tt>Module#alias_method_chain</tt>, only it works for modules/classes
+  #
+  #   class X
+  #     def self.foo
+  #       'foo'
+  #     end
+  #     malias_method_chain :foo, :feature
+  #   end
+  #
+  # Note: You could always do the same thing with <tt>Module#alias_method_chain</tt> by simply doing this:
+  #
+  #   class << self
+  #     alias_method_chain :foo, :feature
+  #   end
+  #
+  def malias_method_chain(target, feature, *args)
+    # Strip out punctuation on predicates or bang methods since
+    # e.g. target?_without_feature is not a valid method name.
+
+    singleton_class.instance_eval do
+      alias_method_chain target, feature, *args
+    end
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+require 'test/unit'
+
+class TestHowYouWouldDoItWithPlain_alias_method_chain < Test::Unit::TestCase
+
+  class X
+    def self.foo
+      'foo'
+    end
+    def self.foo_with_feature
+      foo_without_feature + '_with_feature'
+    end
+    class << self
+      alias_method_chain :foo, :feature
+    end
+  end
+
+  def test_001
+    assert_equal 'foo_with_feature', X.foo
+  end
+
+end
+
+class Test_malias_method_chain < Test::Unit::TestCase
+
+  class Y
+    def self.foo
+      'foo'
+    end
+    def self.foo_with_feature
+      foo_without_feature + '_with_feature'
+    end
+    malias_method_chain :foo, :feature
+  end
+
+  def test_001
+    assert_equal 'foo_with_feature', Y.foo
+  end
+
+end
+
+=end
+

data/lib/qualitysmith_extensions/module/namespace.rb

@@ -5,6 +5,7 @@
 # Submit to Facets?:: Yes.
 # Developer notes::
 # Changes::
+# * 0.0.52: Renamed namespace to namespace_module to avoid conflicting with Facets' Module#namespace and Rake's namespace
 #++
 
 
@@ -16,7 +17,7 @@ require 'qualitysmith_extensions/module/split'
 class Module
   # Return the module which contains this one; if this is a root module, such as
   # +::MyModule+, then Object is returned.
-  def namespace
+  def namespace_module
     namespace_name = name.split('::')[0..-2].join('::')
     namespace_name.empty? ? Object : namespace_name.constantize
   end
@@ -31,7 +32,7 @@ class Module
   def self.dirname(module_or_name)
     case module_or_name
       when Module
-        module_or_name.namespace.name
+        module_or_name.namespace_module.name
       when Symbol
         Module.split_name(module_or_name)[0..-2].join('::')
       when String
@@ -66,14 +67,14 @@ module OuterModule::MiddleModule::InnerModule; end
 class NamespaceTest < Test::Unit::TestCase
   module InnerModule; end
   def test_1
-    assert_equal Object, OuterModule.namespace
+    assert_equal Object, OuterModule.namespace_module
   end
   def test_nesting
     assert_equal OuterModule::MiddleModule, 
-                 OuterModule::MiddleModule::InnerModule.namespace
+                 OuterModule::MiddleModule::InnerModule.namespace_module
   end
   def test_nesting_2
-    assert_equal NamespaceTest, InnerModule.namespace
+    assert_equal NamespaceTest, InnerModule.namespace_module
   end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: qualitysmith_extensions
 version: !ruby/object:Gem::Version 
-  version: 0.0.49
-date: 2007-05-24 00:00:00 -07:00
+  version: 0.0.60
+date: 2007-06-05 00:00:00 -07:00
 summary: A collection of reusable Ruby methods developed by QualitySmith.
 require_paths: 
 - lib
@@ -48,6 +48,7 @@ files:
 - lib/qualitysmith_extensions/kernel/simulate_input.rb
 - lib/qualitysmith_extensions/kernel/die.rb
 - lib/qualitysmith_extensions/kernel/require_once.rb
+- lib/qualitysmith_extensions/kernel/require_local_all.rb
 - lib/qualitysmith_extensions/kernel/example_printer.rb
 - lib/qualitysmith_extensions/kernel/all.rb
 - lib/qualitysmith_extensions/kernel/filter_output.rb
@@ -83,11 +84,13 @@ files:
 - lib/qualitysmith_extensions/module/module_methods.rb
 - lib/qualitysmith_extensions/module/alias_method.rb
 - lib/qualitysmith_extensions/module/namespace.rb
+- lib/qualitysmith_extensions/module/malias_method_chain.rb
 - lib/qualitysmith_extensions/module/includable_once.rb
 - lib/qualitysmith_extensions/module/parents.rb
 - lib/qualitysmith_extensions/module/dirname.rb
 - lib/qualitysmith_extensions/module/basename.rb
 - lib/qualitysmith_extensions/module/create_setter.rb
+- lib/qualitysmith_extensions/module/alias_method_chain.rb
 - lib/qualitysmith_extensions/module/attribute_accessors.rb
 - lib/qualitysmith_extensions/module/create.rb
 - lib/qualitysmith_extensions/module/bool_attr_accessor.rb
@@ -96,6 +99,8 @@ files:
 - lib/qualitysmith_extensions/module/class_methods.rb
 - lib/qualitysmith_extensions/symbol/constantize.rb
 - lib/qualitysmith_extensions/symbol/match.rb
+- lib/qualitysmith_extensions/enumerable/select_while.rb
+- lib/qualitysmith_extensions/enumerable/select_until.rb
 - lib/qualitysmith_extensions/enumerable/enum.rb
 - lib/qualitysmith_extensions/hash/to_query_string.rb
 - lib/qualitysmith_extensions/hash/all.rb