stunted 0.0.1 → 0.0.2

data/.gitignore

@@ -6,3 +6,5 @@ doc
 Gemfile.lock
 rdoc
 pkg/*
+.idea
+TAGS

data/README.md

@@ -9,3 +9,9 @@ written by other people.
 
 Documentation is in the [wiki](https://github.com/marick/stunted/wiki).
 There is a mailing list for [functional programming in Ruby](http://groups.google.com/group/rubyfoopers).
+
+Contributors:
+
+* Brian Marick
+* Edward Monical-Vuylsteke
+* Lar Van Der Jagt

data/Rakefile

@@ -7,14 +7,6 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-  test.rcov_opts << '--exclude "gems/*"'
-end
-
 task :default => :test
 
 require 'rdoc/task'

data/lib/stunted.rb

@@ -1,3 +1,7 @@
 require "stunted/version"
 require "stunted/chaining"
+require 'stunted/shapeable'
+require 'stunted/hash-array'
 require "stunted/functional-hash"
+require "stunted/stutils"
+require "stunted/mocking"

data/lib/stunted/chaining.rb

@@ -8,6 +8,7 @@ module Stunted
       if fn
         define_method(name) { fn }
       else
+        puts "Lambda rigamarole could be just { block }"
         define_method(name) { lambda(&block) }  # Todo: why is this lambda rigamarole required?
       end
       module_function name if respond_to?(:module_function, true) 

data/lib/stunted/functional-hash.rb

@@ -1,6 +1,8 @@
 module Stunted
 
   class FunctionalHash < Hash
+    include Shapeable
+    extend ShapeableClassMethods
 
     def initialize(hash = {})
       hash.each do | k, v |
@@ -32,6 +34,10 @@ module Stunted
     end
     alias_method :+, :merge
 
+    def transform(symbol)
+      merge(symbol => yield(self[symbol]))
+    end
+
     def change_within(*args)
       if (args.first.is_a? Hash)
         merge(args.first)
@@ -71,23 +77,11 @@ module Stunted
       self.class[*keys.zip(self.values_at(*keys)).flatten(1)]
     end
 
-    def self.shaped_class(*shapes)
-      klass = Class.new(self)
-      shapes.each do | mod | 
-        klass.send(:include, mod)
-      end
-      klass
-    end
-
     def self.make_maker(*shapes)
       klass = shaped_class(*shapes)
       ->(inits={}) { klass.new(inits) }
     end
 
-    def become(*shapes)
-      self.class.shaped_class(*shapes).new(self)
-    end
-
     def component(hash)   # For now, just one pair
       field = hash.keys.first
       shape = hash.values.first
@@ -104,20 +98,4 @@ module Stunted
     private :[]=, :clear, :delete, :delete_if
   end
 
-
-  module FHUtil
-    def F(hash = {})
-      FunctionalHash.new(hash)
-    end
-
-    def Fonly(tuples)
-      F(tuples.first)
-    end
-
-    def Fall(tuples)
-      tuples.map { | row | F(row) }
-    end
-  end
-
-
 end

data/lib/stunted/hash-array.rb

@@ -0,0 +1,20 @@
+module Stunted
+  class HashArray < Array
+    include Shapeable
+    extend ShapeableClassMethods
+
+    def collapse_and_aggregate(*keys)
+      keys.reduce(first) do | accumulator, key |
+        collection = collect(&key)
+        collection = yield(collection) if block_given?
+        accumulator.merge(key => collection)
+      end
+    end
+
+    def segregate_by_key(key)
+      group_by(&key).values.collect do | inner | 
+        self.class.new(inner)
+      end
+    end
+  end
+end

data/lib/stunted/mocking.rb

@@ -0,0 +1,21 @@
+class Module
+    def with_replacement_methods(hash)
+      old_pairs = hash.collect do | key, value |
+        old_method = instance_method(key)
+        define_method(key, value)      
+        [key, old_method]
+      end
+      yield
+    ensure
+      old_pairs.each { | pair | define_method(*pair) }
+    end
+end
+
+module Stunted
+
+  class FunctionalHash
+    def with_replacement_methods(hash, &block)
+      self.class.with_replacement_methods(hash, &block)
+    end
+  end
+end

data/lib/stunted/shapeable.rb

@@ -0,0 +1,18 @@
+module Stunted
+  module ShapeableClassMethods
+    def shaped_class(*shapes)
+      klass = Class.new(self)
+      shapes.each do | mod | 
+        klass.send(:include, mod)
+      end
+      klass
+    end
+  end
+
+  module Shapeable
+    def become(*shapes)
+      return self if shapes.empty?
+      self.class.shaped_class(*shapes).new(self)
+    end
+  end
+end

data/lib/stunted/stutils.rb

@@ -0,0 +1,27 @@
+module Stunted
+  module Stutils
+    def F(hash = {}, *shapes)
+      FunctionalHash.new(hash).become(*shapes)
+    end
+
+    def Fonly(tuples, *shapes)
+      F(tuples.first, *shapes)
+    end
+
+    def Fall(tuples, *args)
+      first = args.first
+      if first.is_a?(Hash)
+        array_shapes = first[:array] || []
+        hash_shapes = first[:hash] || []
+      else
+        hash_shapes = args
+        array_shapes = []
+      end
+      HashArray.new(tuples.map { | row | F(row, *hash_shapes) }).
+                become(*array_shapes)
+    end
+  end
+
+  Stutil = Stutils unless defined?(Stutil) # Backward compatibility
+  FHUtil = Stutils unless defined?(FHUtil) # Backward compatibility
+end

data/lib/stunted/version.rb

@@ -1,3 +1,3 @@
 module Stunted
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/stunted.gemspec

@@ -20,11 +20,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "hamster"
-
   s.add_development_dependency "shoulda", ">= 0"
-  s.add_development_dependency "assert2"
-  s.add_development_dependency "bundler", "~> 1.0.0"
+  s.add_development_dependency "bundler"
   s.add_development_dependency "jeweler", "~> 1.6.4"
-  s.add_development_dependency "rcov", ">= 0"
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency "wrong"
 end

data/test/functional-hash-test.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 class FunctionalHashTest < Test::Unit::TestCase
   include Stunted
-  include Stunted::FHUtil
+  include Stunted::Stutils
   
 
   context "non-lazy behavior" do
@@ -24,7 +24,9 @@ class FunctionalHashTest < Test::Unit::TestCase
     end
   end
 
+
   context "lazy behavior" do
+    puts "==== What is the behavior with procs good for?"
     should "take procs as arguments and evaluate them on demand" do
       @sut = FunctionalHash.new(:a => lambda { @global })
       @global = 33
@@ -86,7 +88,17 @@ class FunctionalHashTest < Test::Unit::TestCase
       assert { empty.object_id != sut.object_id }
     end
 
-    context "changing within" do
+    should "allow transformations of particular key values" do
+      sut = FunctionalHash.new(value: 5)
+      new_sut = sut.transform(:value) { | value | value * 3 }
+      assert { new_sut.value == 15 }
+
+      sut = FunctionalHash.new("string-key" => 1)
+      new_sut = sut.transform("string-key") { | value | value * 3 }
+      assert { new_sut["string-key"] == 3 }
+    end
+
+    context "removing within" do
       setup do 
         @hashlike = F(:val => 3,
                       :other => "other",
@@ -104,7 +116,7 @@ class FunctionalHashTest < Test::Unit::TestCase
       end
 
       should "allow nesting" do
-        actual = @hashlike.change_within(:nested, val => 44)
+        actual = @hashlike.change_within(:nested, :val => 44)
         assert { actual.is_a?(FunctionalHash) }
         assert { actual.val == 3 }
         assert { actual.nested.val == 44 }
@@ -112,7 +124,7 @@ class FunctionalHashTest < Test::Unit::TestCase
       end
 
       should "allow n levels of nesting" do
-        actual = @hashlike.change_within(:nested, :nested, val => 444)
+        actual = @hashlike.change_within(:nested, :nested, :val => 444)
         assert { actual.is_a?(FunctionalHash) }
         assert { actual.val == 3 }
         assert { actual.nested.val == 33 }
@@ -261,6 +273,9 @@ class FunctionalHashTest < Test::Unit::TestCase
       end
         
     end
+
+
+
   end
 end
 

data/test/hash-array-tests.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+class HashArrayTest < Test::Unit::TestCase
+  include Stunted
+  include Stunted::Stutils
+  
+  context "collapsing a hash-array into one hash" do
+    should "aggregate named key values into an array" do
+      input = Fall([ {:id => 33, :name => "fred"},
+                     {:id => 33, :name => "betsy"} ])
+      
+      actual = input.collapse_and_aggregate(:name)
+      expected = {:id => 33, :name => ["fred", "betsy"]}
+      assert { actual == expected }
+    end
+
+    should "aggregate allow multiple keys" do
+      input = Fall([ {:id => 33, :name => "fred", :hair => 3},
+                     {:id => 33, :name => "betsy", :hair => 44} ])
+      
+      actual = input.collapse_and_aggregate(:name, :hair)
+      expected = {:id => 33, :name => ["fred", "betsy"], :hair => [3, 44]}
+      assert { actual == expected }
+    end
+
+    should "silently do the wrong thing if non-constant keys are not named" do 
+      input = Fall([ {:id => 33, :name => "fred", :hair => 3},
+                     {:id => 33, :name => "betsy", :hair => 44} ])
+      actual = input.collapse_and_aggregate(:name)
+      deny { actual.hair == [3, 44] }
+    end
+
+    should "take a block that can be used to process the arrays" do 
+      input = Fall([ {:id => 33, :name => "fred", :hair => 3},
+                     {:id => 33, :name => "betsy", :hair => 44},
+                     {:id => 33, :name => "fred", :hair => 44},
+                     {:id => 33, :name => "betsy", :hair => 3}])
+      actual = input.collapse_and_aggregate(:name, :hair) { | a | a.sort.uniq }
+      expected = {:id => 33, :name => ["betsy", "fred"], :hair => [3, 44]}
+      assert { actual == expected }
+    end
+  end
+
+  context "segregation by keys" do 
+    setup do 
+      @input = Fall([ {:id => 1, :name => "fred"},
+                      {:id => 2, :name => "betsy"},
+                      {:id => 1, :name => "dawn"} ])
+
+      @actual = @input.segregate_by_key(:id)
+      @expected = [ [ {:id => 1, :name => "fred"},
+                      {:id => 1, :name => "dawn"} ],
+                    [ {:id => 2, :name => "betsy"} ] ]
+    end
+
+    should "produce an array of arrays" do 
+      assert { @actual == @expected }
+    end
+
+    should "make the inner arrays HashArrays" do 
+      assert { @actual.first.is_a?(Stunted::HashArray) } 
+    end
+  end
+
+  context "shapeability" do 
+    module ArrayShaped
+      def neg_count; -count; end
+    end
+
+    should "also apply to hash arrays" do 
+      assert { Fall([ {:a => 1}]).become(ArrayShaped).neg_count == -1 }
+    end
+  end
+end

data/test/helper.rb

@@ -9,11 +9,12 @@ rescue Bundler::BundlerError => e
 end
 require 'test/unit'
 require 'shoulda'
-require 'assert2'
+require 'wrong'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'stunted'
 
 class Test::Unit::TestCase
+  include Wrong
 end

data/test/mocking-tests.rb

@@ -0,0 +1,118 @@
+require 'helper'
+
+class FunctionalHashTest < Test::Unit::TestCase
+  include Stunted
+  include Stunted::Stutils
+
+  context "mocking out methods via a class" do
+    class ClassWithMethods < FunctionalHash
+      def my_method; "value of unmocked method"; end
+    end
+
+    should "be able to temporarily replace a module's instance methods" do 
+      ClassWithMethods.with_replacement_methods(my_method: -> { "replaced value" }) do
+        assert { ClassWithMethods.new.my_method == "replaced value" }
+      end
+      assert { ClassWithMethods.new.my_method == "value of unmocked method"  }
+    end
+
+    should "undo the replacement no matter what" do
+      assert_raises(Exception) do
+        ClassWithMethods.with_replacement_methods(my_method: -> { "replaced value" }) do
+          raise Exception.new("boom")
+        end
+      end
+      assert { ClassWithMethods.new.my_method == "value of unmocked method"  }
+    end
+
+    should "keep the modified instance methods for all versions of the object" do 
+      ClassWithMethods.with_replacement_methods(my_method: -> a { merge(value: self.value * a) }) do 
+        first = ClassWithMethods.new(value: 1)
+        second = first.my_method(5)
+        third = second.my_method(10)
+
+        assert { second.value == 5 }
+        assert { third.value == 50 }
+      end
+    end
+
+    should "The overriding of the method ends at the end of the block" do
+      initial = "declared local"
+      ClassWithMethods.with_replacement_methods(my_method: -> a { merge(value: self.value * a)}) do
+        initial = ClassWithMethods.new
+      end
+      assert { initial.my_method == "value of unmocked method"  }
+    end
+
+  end
+
+  module ModuleWithMethods
+    def my_method; "value of unmocked method"; end
+  end
+
+  context "mocking out methods on a module" do
+    class ClassWithIncludedMethods < FunctionalHash
+      include ModuleWithMethods
+    end
+
+    should "be able to temporarily replace a module's instance methods" do 
+      ModuleWithMethods.with_replacement_methods(my_method: -> { "replaced value" }) do
+        assert { ClassWithIncludedMethods.new.my_method == "replaced value" }
+      end
+      assert { ClassWithIncludedMethods.new.my_method == "value of unmocked method"  }
+    end
+  end
+
+  context 'mocking out methods for a "made" class' do
+    maker = FunctionalHash.make_maker(ModuleWithMethods)
+
+    should "be able to temporarily replace a made class's instance methods" do 
+      maker.().class.with_replacement_methods(my_method: -> { "replaced value" }) do
+        assert { maker.().my_method == "replaced value" }
+      end
+      assert { maker.().my_method == "value of unmocked method"  }
+    end
+
+    should "The overriding of the method ends at the end of the block" do
+      initial = "declared local"
+      ClassWithMethods.with_replacement_methods(my_method: -> a { merge(value: self.value * a)}) do
+        initial = ClassWithMethods.new
+      end
+      assert { initial.my_method == "value of unmocked method"  }
+    end
+  end
+
+  context "mocking particular objects" do 
+    should "be able to apply the mock function to an object, not just a module." do
+      object = ClassWithMethods.new
+      object.with_replacement_methods(my_method: -> { "replaced value" }) do
+        assert { object.my_method == "replaced value" }
+      end
+      assert { object.my_method == "value of unmocked method"  }
+    end
+
+    should_eventually "changing one object's methods doesn't affect another's" do
+      mocked = ClassWithMethods.new
+      unmocked = ClassWithMethods.new
+      mocked.with_replacement_methods(my_method: -> { "replaced value" }) do
+        assert { unmocked.my_method == "value of unmocked method" }
+      end
+    end
+
+  end
+
+  context "mocking out lambdas attached to a class" do 
+    class ClassWithLambdas < FunctionalHash
+      extend Stunted::Defn
+      defn :my_lambda, -> { "value of unmocked lambda" }
+    end
+
+    should_eventually "be able to temporarily replace a module's `defn`ed lambdas" do 
+      ClassWithLambdas.with_replacement_methods(my_lambda: -> { "replaced value" }) do
+        assert { ClassWithLambdas.new.my_lambda.() == "replaced value" }
+      end
+      assert { ClassWithLambdas.new.my_lambda.() == "value of unmocked lambda"  }
+    end
+
+  end
+end

data/test/shapeable-tests.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+class ShapeableTests < Test::Unit::TestCase
+  include Stunted
+  include Stunted::Stutils
+
+  # Mostly tested through use in including classes
+
+  module Shapely
+  end
+  
+  should "normally return a new class" do
+    # For some reason, putting this inside an `assert` makes test hang.
+    klass = FunctionalHash.new.become(Shapely).class
+    # The test library hangs if it tries to print a class created by
+    # Class.new
+    test = (klass == FunctionalHash);                deny { test }
+    test = klass.ancestors.include?(FunctionalHash); assert { test } 
+  end
+
+  should "not return a new class if there is nothing to become" do
+    # For some reason, putting this inside an `assert` makes test hang.
+    klass = FunctionalHash.new.become().class
+    test = (klass == FunctionalHash);                assert { test }
+  end
+
+end
+

data/test/stutils-test.rb

@@ -0,0 +1,83 @@
+require 'helper'
+
+class StutilsTest < Test::Unit::TestCase
+  include Stunted
+  include Stunted::Stutils
+
+  module Upable
+    def up; "up!"; end
+  end
+
+  module Downable
+    def down; "down!"; end
+  end
+
+  context "F" do
+    should "create a functional hash" do
+      # Only is a function that's not on the real Hash
+      assert { F(:a => 1, :b => 2).only(:a).is_a? FunctionalHash }
+    end
+
+    should "allow shape to be specified" do
+      h = F({}, Upable, Downable)
+      assert { h.up == "up!" }
+      assert { h.down == "down!" }
+    end
+  end
+
+  context "Fonly" do 
+    should "create a functional hash from within an array" do
+      h = Fonly([{}], Upable, Downable)
+      assert { h.is_a? FunctionalHash }
+      assert { h.up == "up!" }
+      assert { h.down == "down!" }
+    end
+  end
+
+  context "Fall" do 
+    should "create a HashArray wrapping Functional Hashes" do
+      a = Fall([{}])
+      assert { a.is_a?(HashArray) }
+      assert { a.first.is_a?(FunctionalHash) }
+    end
+
+    should "shape the hash entries if given one or more arguments" do
+      a = Fall([{}], Upable)
+      assert {a.first.respond_to?(:up) }
+      deny {a.first.respond_to?(:down) }
+
+      a = Fall([{}], Upable, Downable)
+      assert {a.first.respond_to?(:up) }
+      assert {a.first.respond_to?(:down) }
+    end
+
+    should "allow the shape of the array to be given" do
+      a = Fall([{}], :array => Upable)
+      assert {a.up == "up!" }
+      deny   {a.first.respond_to?(:up) }
+    end
+
+    should "allow more than one shape for the array" do 
+      a = Fall([{}], :array => [Upable, Downable])
+      assert {a.up == "up!" }
+      assert {a.down == "down!" }
+    end
+
+    should "allow both array and hash to be shaped" do 
+      a = Fall([{}], :array => Upable, :hash => Downable)
+      assert {a.respond_to?(:up) }
+      deny   {a.respond_to?(:down) }
+      assert {a.first.respond_to?(:down) }
+      deny   {a.first.respond_to?(:up) }
+    end
+
+    should "allow both array and hash to be shaped with multiple shapes" do 
+      a = Fall([{}], :array => [Upable, Downable], :hash => [Upable, Downable])
+      assert {a.respond_to?(:up) }
+      assert {a.respond_to?(:down) }
+      assert {a.first.respond_to?(:down) }
+      assert {a.first.respond_to?(:up) }
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stunted
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-19 00:00:00.000000000Z
+date: 2012-04-20 00:00:00.000000000Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: hamster
-  requirement: &2156591000 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: *2156591000
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &2156590360 !ruby/object:Gem::Requirement
+  requirement: &2153385740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156590360
+  version_requirements: *2153385740
 - !ruby/object:Gem::Dependency
-  name: assert2
-  requirement: &2156395500 !ruby/object:Gem::Requirement
+  name: bundler
+  requirement: &2153385340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,32 +32,32 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156395500
+  version_requirements: *2153385340
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: &2156394280 !ruby/object:Gem::Requirement
+  name: jeweler
+  requirement: &2153384800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *2156394280
+  version_requirements: *2153384800
 - !ruby/object:Gem::Dependency
-  name: jeweler
-  requirement: &2156393420 !ruby/object:Gem::Requirement
+  name: test-unit
+  requirement: &2153384380 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.6.4
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156393420
+  version_requirements: *2153384380
 - !ruby/object:Gem::Dependency
-  name: rcov
-  requirement: &2156392760 !ruby/object:Gem::Requirement
+  name: wrong
+  requirement: &2153383860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156392760
+  version_requirements: *2153383860
 description: Support code for functional programming
 email: marick@exampler.com
 executables: []
@@ -100,12 +89,20 @@ files:
 - lib/stunted.rb
 - lib/stunted/chaining.rb
 - lib/stunted/functional-hash.rb
+- lib/stunted/hash-array.rb
+- lib/stunted/mocking.rb
+- lib/stunted/shapeable.rb
+- lib/stunted/stutils.rb
 - lib/stunted/version.rb
 - stunted.gemspec
 - test/chainable-tests.rb
 - test/defn-tests.rb
 - test/functional-hash-test.rb
+- test/hash-array-tests.rb
 - test/helper.rb
+- test/mocking-tests.rb
+- test/shapeable-tests.rb
+- test/stutils-test.rb
 homepage: http://github.com/marick/stunted
 licenses:
 - MIT
@@ -135,4 +132,8 @@ test_files:
 - test/chainable-tests.rb
 - test/defn-tests.rb
 - test/functional-hash-test.rb
+- test/hash-array-tests.rb
 - test/helper.rb
+- test/mocking-tests.rb
+- test/shapeable-tests.rb
+- test/stutils-test.rb