tfg_support 0.2.1 → 1.0.0

data/.rspec

@@ -0,0 +1 @@
+--debugger

data/.ruby-gemset

@@ -0,0 +1 @@
+thefrontiergroup-support

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p392

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in tfg_support.gemspec
-gemspec
+gemspec

data/LICENSE.txt

@@ -19,4 +19,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,48 +1,33 @@
-# TfgSupport
+# TFG::Support
+
+A collection of handy helpers and extentions to the Ruby core library.
+Should only contain application-nonspecific code that is of general use.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'tfg_support'
+```ruby
+gem "tfg_support"
+```
 
 And then execute:
 
-    $ bundle
-
-## Usage
-
-Provides some useful extentions to ruby classes.
-
-### [Hash] (http://ruby-doc.org/core-2.0/Hash.html)
-
-#### #deep
-
-Allows access to hashes nested with in other hashes.
-
-Replace
-
-    value = some_hash[:foo][:bar][:baz] if some_hash[:foo] && some_hash[:foo][:bar]
-
-with
-
-    value = hash.deep[:foo, :bar, :baz]
+```sh
+$ bundle
+```
 
-also works for setting. New hashes will be created for missing keys.
+This gem does not depend on `active_support`, however, if you with to use `Hash#with_indifferent_equality` you must ensure that `active_support` is loaded before `tfg_support`.
 
-    hash = {:foo=>{:bar=>{:baz=>:fizz}}}
-    hash.deep[:foo, :bar, :baz] = :frob
-    hash.deep[:foo, :missing_key, :baz] = :frob
+## Documentation
 
-    hash
-     => {:foo=>{:bar=>{:baz=>:frob}, :missing_key=>{:baz=>:frob}}}
+The codebase is documented using `yard`.
 
-### [String] (http://ruby-doc.org/core-2.0/String.html)
+Documentation can be viewed in the source tree or at [RubyDoc](http://rubydoc.info/github/thefrontiergroup/thefrontiergroup-tfg_support/master/frames).
 
-#### to_boolean
+## Versioning
 
-Converts strings `'true' 't' 'yes' 'y' '1'` to `true`
-and `'false' 'f' 'no' 'n' '0'` to `false`
+This project uses [Semantic Versioning](http://semver.org).
 
 ## Contributing
 
@@ -50,4 +35,4 @@ and `'false' 'f' 'no' 'n' '0'` to `false`
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+5. Create a Pull Request

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require "bundler/gem_tasks"

data/lib/tfg/support/core_ext/hash/deep.rb

@@ -0,0 +1,30 @@
+require "tfg/support/deep_hash_accessor"
+
+class Hash
+  # Allows chaining of keys through nested hashes.
+  #
+  # ```ruby
+  # hash = {foo: true, bar: {baz: {qux: false}}}
+  #
+  # hash.deep[:foo] #=> true
+  # hash.deep[:bar, :baz, :qux] #=> false
+  # ```
+  #
+  # When the chain of keys is incomplete `nil` will be returned.
+  #
+  # ```ruby
+  # hash[:bar, :qux] #=> nil
+  # ```
+  #
+  # Assignment is also possible, and the key chain will be created
+  # if needed.
+  #
+  # ```ruby
+  # hash = {}
+  # hash[:foo, :bar] = true
+  # hash #=> {foo: {bar: true}}
+  # ```
+  def deep
+    TFG::Support::DeepHashAccessor.new(self)
+  end
+end

data/lib/tfg/support/core_ext/hash/map_values.rb

@@ -0,0 +1,32 @@
+class Hash
+  # Allows you to map the values of a hash. The original
+  # keys will be retained.
+  # 
+  # ```ruby
+  # {foo: 1, bar: 2}.map_values {|value| value * 2 } #=> {foo: 2, bar: 4}
+  # ```
+  #
+  # The original hash is not mutated.
+  def map_values
+    Hash.new.tap do |result|
+      self.each do |key, value|
+        result[key] = yield(value)
+      end
+    end
+  end
+
+  # The same as {Hash#map_values}, except mutates and returns the original hash.
+  # 
+  # ```ruby
+  # hash = {foo: 1, bar: 2}
+  # hash.map_values {|value| value * 2 }
+  # hash #=> {foo: 2, bar: 4}
+  # ```
+  def map_values!
+    self.tap do |hash|
+      hash.each do |key, value|
+        hash[key] = yield(value)
+      end
+    end
+  end
+end

data/lib/tfg/support/core_ext/hash/with_indifferent_equality.rb

@@ -0,0 +1,27 @@
+if defined? ActiveSupport
+  class Hash
+    # Will return a new hash that does not differentiate
+    # between string and symbol keys for equality.
+    #
+    # ```ruby
+    # {a: 1} == {"a" => 1}.with_indifferent_equality #=> true
+    # ```
+    def with_indifferent_equality
+      TFG::Support::HashWithIndifferentEquality.new(self)
+    end
+
+    # Aliased to original {Hash#==}.
+    alias_method :old_double_equals, :==
+
+    # Check equality of hashes, considering if difference
+    # between string and symbol keys should be observed.
+    # See {Hash#with_indifferent_equality}.
+    def ==(other)
+      if other.is_a?(TFG::Support::HashWithIndifferentEquality)
+        other == self
+      else
+        old_double_equals(other)
+      end
+    end
+  end
+end

data/lib/tfg/support/core_ext/hash.rb

@@ -0,0 +1,3 @@
+Dir[File.expand_path("../hash/**/*.rb", __FILE__)].each do |file|
+  require file
+end

data/lib/tfg/support/core_ext/object/as.rb

@@ -0,0 +1,37 @@
+class Object
+  # The method #as allows you to take an object and use it in a block. If
+  # you return a non-nil value, #as will return that value, otherwise the
+  # original object is returned.
+  #
+  # This is particularly useful with super.
+  #
+  # ```ruby
+  # def overridden_method
+  #   super.as |value|
+  #     if value.is_a? String
+  #       Array.wrap(value)
+  #     end
+  #   end
+  # end
+  # ```
+  #
+  # Is equivalent to:
+  #
+  # ```ruby
+  # def overridden_method
+  #   _overridden_method = super
+  #
+  #   if _overridden_method.is_a? String
+  #     Array.wrap(_overridden_method)
+  #   else
+  #     _overridden_method
+  #   end
+  # end
+  # ```
+  def _as
+    result = yield(self)
+    result.nil? ? self : result
+  end
+
+  alias_method :as, :_as
+end

data/lib/tfg/support/core_ext/object.rb

@@ -0,0 +1,3 @@
+Dir[File.expand_path("../object/**/*.rb", __FILE__)].each do |file|
+  require file
+end

data/lib/tfg/support/core_ext/string/to_boolean.rb

@@ -0,0 +1,21 @@
+class String
+  # Attempts to cast the string to `true` or `false`. This is done
+  # by comparison with known truthy and falsey values.
+  #
+  # ```ruby
+  # "Yes".to_boolean #=> true
+  # "1".to_boolean #=> true
+  #
+  # "NO".to_boolean #=> false
+  # "FaLsE".to_boolean #=> false
+  # ```
+  #
+  # @raise ArgumentError when the string does not match either a
+  #   truthey or falsey value.
+  def to_boolean
+    return true if self =~ (/\A(true|t|yes|y|1)\Z/i)
+    return false if self =~ (/\A(false|f|no|n|0)\Z/i)
+
+    raise ArgumentError.new("String \"#{self}\" cannot be cast to boolean.")
+  end
+end

data/lib/tfg/support/core_ext/string.rb

@@ -0,0 +1,3 @@
+Dir[File.expand_path("../string/**/*.rb", __FILE__)].each do |file|
+  require file
+end

data/lib/tfg/support/deep_hash_accessor.rb

@@ -0,0 +1,34 @@
+module TFG
+  module Support
+    class DeepHashAccessor
+      def initialize(hash)
+        self.hash = hash
+      end
+
+      def [](*keys)
+        head, *tail = keys
+
+        if tail.empty?
+          hash[head]
+        else
+          hash[head].deep[*tail] if hash[head]
+        end
+      end
+
+      def []=(*keys, value)
+        head, *tail = keys
+
+        if tail.empty?
+          hash[head] = value
+        else
+          hash[head] ||= Hash.new
+          hash[head].deep[*tail] = value
+        end
+      end
+
+      private
+
+      attr_accessor :hash
+    end
+  end
+end

data/lib/tfg/support/hash_with_indifferent_equality.rb

@@ -0,0 +1,31 @@
+module TFG
+  module Support
+    class HashWithIndifferentEquality < BasicObject
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def is_a?(klass)
+        if klass == ::TFG::Support::HashWithIndifferentEquality
+          return true
+        else
+          super
+        end
+      end
+
+      def ==(other)
+        if other.is_a?(::Hash)
+          @hash.with_indifferent_access == other.with_indifferent_access
+        else
+          @hash == other
+        end
+      end
+
+      private
+
+      def method_missing(name, *args, &block)
+        @hash.public_send(name, *args, &block)
+      end
+    end
+  end
+end

data/lib/tfg/support/sequence.rb

@@ -0,0 +1,22 @@
+module TFG
+  module Support
+    class Sequence
+      def initialize(first, generator)
+        self.first = first
+        self.generator = generator
+      end
+
+      def next
+        if previous
+          self.previous = generator.call(previous)
+        else
+          self.previous = first
+        end
+      end
+
+      private
+
+      attr_accessor :first, :previous, :generator
+    end
+  end
+end

data/lib/tfg/support/version.rb

@@ -0,0 +1,5 @@
+module TFG
+  module Support
+    VERSION = "1.0.0"
+  end
+end

data/lib/tfg_support.rb

@@ -1,9 +1,17 @@
-require "tfg_support/version"
+require "tfg/support/version"
 
-module TfgSupport
-  autoload :DeepHashAccessor, "tfg_support/deep_hash_accessor"
-  autoload :Sequence, "tfg_support/sequence"
+if defined? ActiveSupport
+  require "active_support/core_ext/hash/indifferent_access"
 end
 
-require "tfg_support/hash"
-require "tfg_support/string"
+module TFG
+  module Support
+    autoload :DeepHashAccessor, "tfg/support/deep_hash_accessor"
+    autoload :Sequence, "tfg/support/sequence"
+    autoload :HashWithIndifferentEquality, "tfg/support/hash_with_indifferent_equality"
+  end
+end
+
+Dir[File.expand_path("../tfg/support/core_ext/**/*.rb", __FILE__)].each do |file|
+  require file
+end

data/spec/spec_helper.rb

@@ -1 +1,2 @@
-require "tfg_support"
+require "active_support"
+require "tfg_support"

data/spec/tfg/support/core_ext/hash/deep_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe Hash do
+  subject(:hash) { Hash.new }
+
+  describe "#deep" do
+    subject(:deep) { hash.deep }
+
+    specify { expect(deep).to be_a TFG::Support::DeepHashAccessor }
+    specify { expect(deep.send(:hash)).to eq hash }
+  end
+end

data/spec/tfg/support/core_ext/hash/map_values_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Hash do
+  let(:hash) { {foo: 1, bar: 2, baz: 3, qux: 4} }
+
+  describe "#map_values" do
+    subject(:map_values) { hash.map_values {|arg| arg * 2 } }
+
+    specify { expect(map_values).to eq({foo: 2, bar: 4, baz: 6, qux: 8}) }
+    specify { expect{|block| hash.map_values(&block) }.to yield_successive_args(1, 2, 3, 4) }
+
+    specify { expect{ map_values }.to_not change{ hash } }
+  end
+
+  describe "#map_values!" do
+    subject(:map_values!) { hash.map_values! {|arg| arg * 2 } }
+
+    specify { expect(map_values!).to eq({foo: 2, bar: 4, baz: 6, qux: 8}) }
+    specify { expect{|block| hash.map_values!(&block) }.to yield_successive_args(1, 2, 3, 4) }
+
+    specify { expect{ map_values! }.to change{ hash } }
+  end
+end

data/spec/tfg/support/core_ext/hash/with_indifferent_equality_spec.rb

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Hash do
+  subject(:hash) { {a: 1, b: 2} }
+
+  describe "#with_indifferent_equality" do
+    subject(:with_indifferent_equality) { hash.with_indifferent_equality }
+
+    specify { expect(with_indifferent_equality).to_not equal hash }
+  end
+
+  describe "#==" do
+    subject(:call) { hash == other }
+
+    context "with normal hashes" do
+      context "with different keys" do
+        let(:other) { {"a" => 1, "b" => 2} }
+
+        specify { expect(call).to be_false }
+      end
+
+      context "with the same keys" do
+        let(:other) { hash.dup }
+
+        specify { expect(call).to be_true }
+      end
+    end
+
+    context "with two indifferent hashes" do
+      let(:hash) { {a: 1, b: 2}.with_indifferent_equality }
+
+      context "with different keys" do
+        let(:other) { {"a" => 1, "b" => 2}.with_indifferent_equality }
+
+        specify { expect(call).to be_true }
+      end
+
+      context "with the same keys" do
+        let(:other) { {a: 1, b: 2}.with_indifferent_equality }
+
+        specify { expect(call).to be_true }
+      end
+    end
+
+    context "with one indifferent hash" do
+      context "with different keys" do
+        let(:other) { {"a" => 1, "b" => 2}.with_indifferent_equality }
+
+        specify { expect(call).to be_true }
+      end
+
+      context "with the same keys" do
+        let(:other) { {a: 1, b: 2}.with_indifferent_equality }
+
+        specify { expect(call).to be_true }
+      end
+    end
+  end
+end

data/spec/tfg/support/core_ext/object/as_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Object do
+  subject(:object) { Object.new }
+
+  describe "#as" do
+    let(:as) { object.as(&block) }
+
+    specify { expect{|block| object.as(&block) }.to yield_with_args(object) }
+
+    context "when the block returns nil" do
+      let(:block) { Proc.new {|arg| nil } }
+
+      specify { expect(as).to eq object }
+    end
+
+    context "when the block does not return nil" do
+      let(:block_return) { Object.new }
+      let(:block) { Proc.new {|arg| block_return } }
+
+      specify { expect(as).to eq block_return }
+    end
+  end
+end

data/spec/tfg/support/core_ext/string/to_boolean_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe String do
+  describe "#to_boolean" do
+    subject(:to_boolean) { string.to_boolean }
+
+    true_cases = %w(true TRUE True t T yes YES Yes y Y 1)
+    false_cases = %w(false FALSE False f F no NO No n N 0)
+
+    true_cases.each do |string|
+      context "for #{string}" do
+        let(:string) { string }
+
+        specify { expect(to_boolean).to be_true }
+      end
+    end
+
+    false_cases.each do |string|
+      context "for #{string}" do
+        let(:string) { string }
+
+        specify { expect(to_boolean).to be_false }
+      end
+    end
+
+    context "for other values" do
+      let(:string) { "bob" }
+
+      specify { expect{to_boolean}.to raise_error(ArgumentError) }
+    end
+  end
+end

data/spec/tfg/support/deep_hash_accessor_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe TFG::Support::DeepHashAccessor do
+  let(:hash) { Hash.new }
+
+  subject(:accessor) { TFG::Support::DeepHashAccessor.new(hash) }
+
+  describe "#[]" do
+    context "with a single argument" do
+      subject(:call) { accessor[:foo] }
+
+      context "when the key is present" do
+        let(:hash) { {foo: :bar} }
+
+        specify { expect(call).to eq :bar }
+      end
+
+      context "when the key is not present" do
+        specify { expect(call).to be_nil }
+      end
+    end
+
+    context "with multiple arguments" do
+      subject(:call) { accessor[:foo, :bar, :baz] }
+
+      context "when key chain is present" do
+        let(:hash) { {foo: {bar: {baz: :qux}}} }
+
+        specify { expect(call).to eq :qux }
+      end
+
+      context "when key chain is not present" do
+        let(:hash) { {foo: {baz: {bar: :qux}}} }
+
+        specify { expect(call).to be_nil }
+      end
+    end
+  end
+
+  describe "#[]=" do
+    context "with a single argument" do
+      subject(:call) { accessor[:foo] = :bar }
+
+      context "when the key is present" do
+        specify { call; expect(hash[:foo]).to eq :bar }
+      end
+    end
+
+    context "with multiple arguments" do
+      subject(:call) { accessor[:foo, :bar, :baz] = :qux }
+
+      context "when key chain is present" do
+        let(:hash) { {foo: {bar: {}}} }
+
+        specify { call; expect(hash[:foo][:bar][:baz]).to eq :qux }
+      end
+
+      context "when key chain is not present" do
+        specify { call; expect(hash[:foo][:bar][:baz]).to eq :qux }
+      end
+    end
+  end
+end

data/spec/tfg/support/hash_with_indifferent_equality_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe TFG::Support::HashWithIndifferentEquality do
+  let(:hash) { Hash.new }
+
+  subject(:hash_with_indifferent_equality) { TFG::Support::HashWithIndifferentEquality.new(hash) }
+
+  describe "#is_a?" do
+    subject(:is_a?) { hash_with_indifferent_equality.is_a?(klass) }
+
+    context "with TFG::Support::HashWithIndifferentEquality" do
+      let(:klass) { TFG::Support::HashWithIndifferentEquality }
+
+      specify { expect(is_a?).to be_true }
+    end
+
+    context "with Hash" do
+      let(:klass) { TFG::Support::HashWithIndifferentEquality }
+
+      specify { expect(is_a?).to be_true }
+    end
+  end
+end

data/spec/tfg/support/sequence_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe TFG::Support::Sequence do
+  subject(:sequence) { TFG::Support::Sequence.new(first, generator) }
+
+  describe "#next" do
+    let(:first) { Object.new }
+    let(:second) { Object.new }
+    let(:generator) { double("generator", call: second) }
+
+    subject(:call) { sequence.next }
+
+    context "on the first call" do
+      specify { expect(call).to eq first }
+      specify { call; expect(generator).to_not have_received(:call) }
+    end
+
+    context "on susequent calls" do
+      before { sequence.next }
+
+      specify { expect(call).to eq second }
+      specify { call; expect(generator).to have_received(:call).with(first) }
+    end
+  end
+end 

data/tfg_support.gemspec

@@ -1,24 +1,28 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'tfg_support/version'
+require 'tfg/support/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "tfg_support"
-  spec.version       = TfgSupport::VERSION
+  spec.version       = TFG::Support::VERSION
   spec.authors       = ["Courtney de Lautour"]
   spec.email         = ["clautour@thefrontiergroup.com.au"]
   spec.description   = %q{A collection of helper methods / extensions for Ruby}
   spec.summary       = %q{A collection of helper methods / extensions for Ruby}
-  spec.homepage      = "https://github.com/Amerdrix/TFG-support"
+  spec.homepage      = "https://github.com/thefrontiergroup/thefrontiergroup-support"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "redcarpet"
+  spec.add_development_dependency "debugger"
+  spec.add_development_dependency "active_support"
 end

metadata

@@ -1,55 +1,126 @@
 --- !ruby/object:Gem::Specification
 name: tfg_support
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
+  prerelease: 
 platform: ruby
 authors:
 - Courtney de Lautour
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-10 00:00:00.000000000 Z
+date: 2013-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A collection of helper methods / extensions for Ruby
@@ -60,45 +131,69 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- .yardopts
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/tfg/support/core_ext/hash.rb
+- lib/tfg/support/core_ext/hash/deep.rb
+- lib/tfg/support/core_ext/hash/map_values.rb
+- lib/tfg/support/core_ext/hash/with_indifferent_equality.rb
+- lib/tfg/support/core_ext/object.rb
+- lib/tfg/support/core_ext/object/as.rb
+- lib/tfg/support/core_ext/string.rb
+- lib/tfg/support/core_ext/string/to_boolean.rb
+- lib/tfg/support/deep_hash_accessor.rb
+- lib/tfg/support/hash_with_indifferent_equality.rb
+- lib/tfg/support/sequence.rb
+- lib/tfg/support/version.rb
 - lib/tfg_support.rb
-- lib/tfg_support/deep_hash_accessor.rb
-- lib/tfg_support/hash.rb
-- lib/tfg_support/sequence.rb
-- lib/tfg_support/string.rb
-- lib/tfg_support/version.rb
-- spec/hash_spec.rb
 - spec/spec_helper.rb
-- spec/string_spec.rb
+- spec/tfg/support/core_ext/hash/deep_spec.rb
+- spec/tfg/support/core_ext/hash/map_values_spec.rb
+- spec/tfg/support/core_ext/hash/with_indifferent_equality_spec.rb
+- spec/tfg/support/core_ext/object/as_spec.rb
+- spec/tfg/support/core_ext/string/to_boolean_spec.rb
+- spec/tfg/support/deep_hash_accessor_spec.rb
+- spec/tfg/support/hash_with_indifferent_equality_spec.rb
+- spec/tfg/support/sequence_spec.rb
 - tfg_support.gemspec
-homepage: https://github.com/Amerdrix/TFG-support
+homepage: https://github.com/thefrontiergroup/thefrontiergroup-support
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.25
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: A collection of helper methods / extensions for Ruby
 test_files:
-- spec/hash_spec.rb
 - spec/spec_helper.rb
-- spec/string_spec.rb
+- spec/tfg/support/core_ext/hash/deep_spec.rb
+- spec/tfg/support/core_ext/hash/map_values_spec.rb
+- spec/tfg/support/core_ext/hash/with_indifferent_equality_spec.rb
+- spec/tfg/support/core_ext/object/as_spec.rb
+- spec/tfg/support/core_ext/string/to_boolean_spec.rb
+- spec/tfg/support/deep_hash_accessor_spec.rb
+- spec/tfg/support/hash_with_indifferent_equality_spec.rb
+- spec/tfg/support/sequence_spec.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 1fd20eeadffb493510c56f4399e5b3f907cd62dc
-  data.tar.gz: e44d25eeaea0df82581593ae50e46d08a7bfc797
-SHA512:
-  metadata.gz: 726f4e9f18a233b327753eca18db1ecdfbe47559b8a1405cf79b458c85d94b9aa1ab3732d4e4e008b6ffc0490e44ff72c909ad66166b2d0add984744841fcbac
-  data.tar.gz: 0408bb9d52d278d78dae9948cd3adc5bb212614b84e6723ac73015d7e32c229d4135ba444bc1d20259eddc8a98544886df7ec74a93289f21350afac412e93904

data/lib/tfg_support/deep_hash_accessor.rb

@@ -1,35 +0,0 @@
-module TfgSupport
-  class DeepHashAccessor
-
-    def initialize(hash)
-      @hash = hash
-    end
-
-    def [](*keys)
-      target = @hash
-
-      keys.each do |key|
-        return nil unless target.respond_to?(:[])
-        target = target[key]
-      end
-      target
-    end
-
-    def []=(*keys)
-      value = keys.pop()
-      set_key = keys.pop()
-
-      target = @hash
-      keys.each do |key|
-        hash = target[key]
-        if hash.nil?
-          hash = {}
-          target[key] = hash
-        end
-        target = hash
-      end
-
-      target[set_key] = value
-    end
-  end
-end

data/lib/tfg_support/hash.rb

@@ -1,5 +0,0 @@
-class Hash
-  def deep()
-    TfgSupport::DeepHashAccessor.new(self)
-  end
-end

data/lib/tfg_support/sequence.rb

@@ -1,16 +0,0 @@
-module TfgSupport
-  class Sequence
-
-    def initialize(args, &block)
-      @current_value, @generator = args, block
-    end
-
-    # return the next element in the sequence
-
-    def next
-      @current_value = @generator.call(@current_value) if @called
-      @called = true
-      @current_value
-    end
-  end
-end

data/lib/tfg_support/string.rb

@@ -1,8 +0,0 @@
-class String
-  def to_boolean
-    return true if self =~ (/\A(true|t|yes|y|1)\Z/i)
-    return false if self =~ (/\A(false|f|no|n|0)\Z/i)
-
-    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
-  end
-end

data/lib/tfg_support/version.rb

@@ -1,3 +0,0 @@
-module TfgSupport
-  VERSION = "0.2.1"
-end

data/spec/hash_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe Hash do
-
-  subject(:hash) do
-    {
-        shallow_key: :single_value,
-        deep_key:
-            {
-                nested_key: :nested_value
-            }
-    }
-  end
-
-  describe "#deep[]" do
-    describe "with single argument" do
-
-      subject(:index) { hash.deep[:shallow_key] }
-
-      it "returns the value of the key" do
-        should eq :single_value
-      end
-    end
-
-    describe "with multiple arguments" do
-
-      subject(:index) { hash.deep[:deep_key, :nested_key] }
-
-      it "returns the value of the key for the nested hash" do
-        should eq :nested_value
-      end
-    end
-
-    describe "when a key is not present" do
-
-      subject(:index) { hash.deep[:deep_key, :missing_key, :nested_key] }
-
-      it "returns nil" do
-        should be nil
-      end
-    end
-  end
-
-  describe "#deep[]=" do
-    before :each do
-      deep_set
-    end
-
-    describe "with single argument" do
-      subject(:deep_set) { hash.deep[:shallow_key]= :new_value }
-
-      it "sets the key of the original hash" do
-        hash[:shallow_key].should eq :new_value
-      end
-    end
-
-    describe "with multiple arguments" do
-
-      subject(:deep_set) { hash.deep[:deep_key, :nested_key]= :new_value }
-
-      it "sets the key of the nested hash" do
-        hash[:deep_key][:nested_key].should eq :new_value
-      end
-    end
-
-    describe "when a key is not present" do
-
-      subject(:deep_set) { hash.deep[:deep_key, :missing_key, :nested_key]= :new_value }
-
-      it "creates a new hash for the missing key" do
-        hash[:deep_key][:missing_key][:nested_key].should eq :new_value
-      end
-    end
-  end
-end
-

data/spec/string_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe String do
-
-  describe "#to_boolean" do
-    subject(:to_boolean) { str.to_boolean }
-
-    true_cases = %w(true trUe t yes y 1)
-    false_cases = %w(false faLse f no n 0)
-
-    true_cases.each do |str|
-      context "when #{str}" do
-        let(:str) { str }
-        it("returns true") { should eq true }
-      end
-    end
-
-    false_cases.each do |str|
-      context "when #{str}" do
-        let(:str) { str }
-        it("returns false") { should eq false }
-      end
-    end
-
-    context "when something else" do
-      let(:str) { "bob" }
-      it("raises an argument error") { expect { to_boolean }.to raise_error(ArgumentError) }
-    end
-  end
-
-end