rucursive 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format Fuubar

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rucursive.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2012 Wes Morgan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 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.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new

data/lib/rucursive.rb

@@ -0,0 +1,8 @@
+require "rucursive/version"
+require "rucursive/core_ext"
+
+module Rucursive
+  def self.included(base)
+    Object.send :include, Rucursive::CoreExt::Object
+  end
+end

data/lib/rucursive/core_ext.rb

@@ -0,0 +1,132 @@
+module Rucursive
+  module CoreExt
+    module Object
+      def compound?
+        is_a?(Array) || is_a?(Hash)
+      end
+
+      ##
+      # Recursively traverse a compound data structure and call a supplied
+      # block on each value or key/value pair, allowing it to modify the
+      # returned data structure as it goes. It does NOT modify the existing
+      # data structure.
+      #
+      # Required arguments: A block that is called on each element of the data
+      #                     structure
+      #
+      # Return value: A new data structure including any modifications made by
+      #               the supplied block.
+      def recurse(&block)
+        if is_a?(Array)
+          map do |o|
+            if o.compound?
+              o.recurse(&block)
+            else
+              block.call(o.dup) if block.arity == 1
+              block.call(nil, o.dup) if block.arity == 2
+              block.call(nil, o.dup, :array) if block.arity == 3
+            end
+          end
+        elsif is_a?(Hash)
+          new_hash = {}
+          each_pair do |k,v|
+            if v.compound?
+              result = block.call(k, v.dup.freeze) if block.arity == 2
+              result = block.call(k, v.dup.freeze, :hash) if block.arity == 3
+              if result.is_a?(Hash)
+                new_key = result.keys.first
+              elsif result.is_a?(Array)
+                new_key = result.first
+              else
+                new_key = result
+              end
+              new_hash[new_key] = v.recurse(&block)
+            else
+              begin
+                v_param = v.dup
+              rescue
+                v_param = v
+              end
+              result = block.call(k, v_param) if block.arity == 2
+              result = block.call(k, v_param, :hash) if block.arity == 3
+              if result.is_a?(Hash)
+                new_hash.merge! result
+              elsif result.is_a?(Array)
+                new_hash[result.first] = result.second
+              else
+                new_hash[result] = v
+              end
+            end
+          end
+          new_hash
+        else
+          self
+        end
+      end
+
+      ##
+      # Just like Object#recurse when called on a Hash, but only passes the
+      # values to the supplied block, rather than the keys and values.
+      # Behaves the same as Object#recurse on Arrays.
+      def recurse_values(&block)
+        if is_a?(Array)
+          map do |o|
+            if o.compound?
+              o.recurse_values(&block)
+            else
+              block.call o
+            end
+          end
+        elsif is_a?(Hash)
+          new_hash = {}
+          each_pair do |k,v|
+            if v.compound?
+              new_hash[k] = v.recurse_values(&block)
+            else
+              new_hash[k] = block.call v
+            end
+          end
+          new_hash
+        else
+          self
+        end
+      end
+
+      ##
+      # Just like Object#recurse when called on a Hash, but only passes the
+      # keys to the supplied block, rather than the keys and values.
+      # Recurses through Arrays looking for Hashes, since Arrays don't really
+      # have keys.
+      def recurse_keys(&block)
+        if is_a?(Array)
+          map do |o|
+            if o.compound?
+              o.recurse_keys(&block)
+            else
+              o
+            end
+          end
+        elsif is_a?(Hash)
+          new_hash = {}
+          keys.each do |k|
+            new_key = block.call k
+            new_hash[new_key] = self[k]
+          end
+          new_hash.each_pair do |k,v|
+            if v.is_a?(Hash)
+              new_hash[k] = v.recurse_keys(&block)
+            elsif v.is_a?(Array)
+              new_ary = v.map do |o|
+                o.is_a?(Hash) ? o.recurse_keys(&block) : o
+              end
+              new_hash[k] = new_ary
+            end
+          end
+          new_hash
+        else
+          self
+        end
+      end
+    end
+  end
+end

data/lib/rucursive/version.rb

@@ -0,0 +1,3 @@
+module Rucursive
+  VERSION = "1.0.0"
+end

data/rucursive.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rucursive/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rucursive"
+  s.version     = Rucursive::VERSION
+  s.authors     = ["Wes Morgan"]
+  s.email       = ["cap10morgan@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Recursively traverses data structures}
+  s.description = %q{Recursively traverses data structures (Hash & Array currently)}
+
+  s.rubyforge_project = "rucursive"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "fuubar"
+end

data/spec/core_ext_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Rucursive::CoreExt do
+  describe Rucursive::CoreExt::Object do
+    context "top-level Object class" do
+      it "should respond to #compound?" do
+        Object.new.should respond_to(:compound?)
+      end
+
+      it "should respond to #recurse" do
+        Object.new.should respond_to(:recurse)
+      end
+    end
+
+    describe "#compound?" do
+      it "should return true for a Hash" do
+        Hash.new.should be_compound
+      end
+
+      it "should return true for an Array" do
+        Array.new.should be_compound
+      end
+
+      it "should return false for a String" do
+        String.new.should_not be_compound
+      end
+
+      it "should return false for a Fixnum" do
+        1.should_not be_compound
+      end
+    end
+
+    describe "#recurse" do
+      it "should call the block on every key,value pair in a Hash" do
+        hash = { foo: 'bar', baz: 'qux', gabba: { key1: 'val1', key2: 'val2' } }
+        expectation = hash.expects(:recurse)
+        hash.each_pair do |k,v|
+          expectation.yields(k).yields(v)
+        end
+        hash[:gabba].each_pair do |k,v|
+          expectation.yields(k).yields(v)
+        end
+        hash.recurse { |k,v| }
+      end
+
+      it "should call the block on every item in an array" do
+        ary = [ :foo, 42, 'bar', [ :baz, 0, 'qux' ] ]
+        expectation = ary.expects(:recurse)
+        ary.each do |o|
+          expectation.yields(o)
+        end
+        ary[3].each do |o|
+          expectation.yields(o)
+        end
+        ary.recurse { |o| }
+      end
+
+      it "should call the block on everything in a complex data structure" do
+        data = {
+          foo: [ 1, 2, 3, { 4 => 5, 6 => 7 } ],
+          bar: {
+            colors: [
+              {'red' => 'green'},{'yellow' => 'violet'},{'blue' => 'orange'}
+            ],
+            cars: {
+              good: ['Altima', 'Prius', 'Volt'],
+              bad: ['Suburban', 'Excursion', 'Grand Cherokee']
+            }
+          }
+        }
+        expectation = data.expects(:recurse)
+        data.each_pair do |k,v|
+          expectation.yields(k).yields(v)
+        end
+        data[:foo].each do |o|
+          expectation.yields(o)
+        end
+        data[:foo][3].each do |k,v|
+          expectation.yields(k).yields(v)
+        end
+        data[:bar].each_pair do |k,v|
+          expectation.yields(k).yields(v)
+        end
+        data[:bar][:colors].each do |c|
+          expectation.yields(c)
+          c.each_pair do |k,v|
+            expectation.yields(k).yields(v)
+          end
+        end
+        data[:bar][:cars].each do |k,v|
+          expectation.yields(k).yields(v)
+          v.each do |c|
+            expectation.yields(c)
+          end
+        end
+        data.recurse { |k,v| }
+      end
+    end
+
+    # TODO: Add tests for recurse_values & recurse_keys
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.join(File.basename(__FILE__), '..', 'lib'))
+require 'rucursive'
+
+RSpec.configure do |c|
+  c.mock_with :mocha
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: rucursive
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Wes Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70296505944240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70296505944240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70296505943820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70296505943820
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70296505943400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70296505943400
+- !ruby/object:Gem::Dependency
+  name: fuubar
+  requirement: &70296505942960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70296505942960
+description: Recursively traverses data structures (Hash & Array currently)
+email:
+- cap10morgan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- Rakefile
+- lib/rucursive.rb
+- lib/rucursive/core_ext.rb
+- lib/rucursive/version.rb
+- rucursive.gemspec
+- spec/core_ext_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2942571688483705688
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2942571688483705688
+requirements: []
+rubyforge_project: rucursive
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Recursively traverses data structures
+test_files:
+- spec/core_ext_spec.rb
+- spec/spec_helper.rb