gorillib 0.4.1pre → 0.4.2pre

data/lib/gorillib/exception/confidence.rb

@@ -1,17 +0,0 @@
-module Kernel
-  def assert(value, message="Assertion failed", error=StandardError)
-    raise error, message, caller unless value
-  end
-end
-
-class NullObject
-  def method_missing(*args, &block)
-    self
-  end
-
-  def nil?; true; end
-end
-
-def Maybe(value)
-  value.nil? ? NullObject.new : value
-end

data/lib/gorillib/io/system_helpers.rb

@@ -1,30 +0,0 @@
-module Gorillib::CheckedPopen
-  module_function
-
-  def checked_popen(command, mode, fail_action, io_class=IO)
-    check_child_exit_status do
-      io_class.popen(command, mode) do |process|
-        yield(process)
-      end
-    end
-  rescue Errno::EPIPE
-    fail_action.call
-  end
-
-  # @private
-  NO_EXIT_STATUS = OpenStruct.new(:exitstatus => 0)
-
-  def check_child_exit_status
-    result = yield
-    status = $? || NO_EXIT_STATUS
-    unless [0, 172].include?(status.exitstatus)
-      raise ArgumentError, "Command exited with status '#{status.exitstatus}'"
-    end
-    result
-  end
-
-end
-
-::IO.class_eval do
-  include Gorillib::CheckedPopen
-end

data/lib/gorillib/model/record_schema.rb

@@ -1,9 +0,0 @@
-module Gorillib
-  module Model
-    class RecordSchema
-      field :name, String
-      field :doc,  String
-      field :type, Factory
-    end
-  end
-end

data/lib/gorillib/utils/stub_module.rb

@@ -1,33 +0,0 @@
-# spec/spec_helper_lite.rb
-
-# Conditionally creates empty or "stub" modules only if
-# a) they are not already defined; and
-# b) they are not auto-loadable.
-#
-# From http://objectsonrails.com/#sec-7-1
-#
-# @example Faking out ActiveModel
-#    # ...
-#    require_relative '../spec_helper_lite'
-#    stub_module 'ActiveModel::Conversion'
-#    stub_module 'ActiveModel::Naming'
-#    require_relative '../../app/models/post'
-#    # ...
-#
-def stub_module(full_name)
-  # Uses #const_get to attempt to reference the given module. If the module is
-  # defined, or if calling #const_get causes it to be auto-loaded, the method
-  # does nothing more. But if #const_get fails to turn up the module, it defines
-  # an anonymous empty module to act as a placeholder.
-  full_name.to_s.split(/::/).inject(Object) do |context, name|
-    begin
-      context.const_get(name)
-    rescue NameError
-      context.const_set(name, Module.new)
-    end
-  end
-end
-
-
-# refute
-# does_not_allow

data/spec/array/average_spec.rb

@@ -1,24 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/array/average'
-
-describe Array do
-  describe '#average' do
-    context 'on non-float array element' do
-      it 'raises error' do
-        expect { [0.0, :b, 1.0].average }.should raise_error(ArgumentError)
-      end
-    end
-
-    context 'with empty' do
-      it 'returns nil' do
-        [].average.should be_nil
-      end
-    end
-
-    context 'given a numerical array' do
-      it 'returns the average of the elements' do
-        (1..10).to_a.average.should == 5.5
-      end
-    end
-  end
-end

data/spec/array/sorted_median_spec.rb

@@ -1,18 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/array/sorted_median'
-
-describe Array do
-  describe '#sorted_median' do
-    context 'with empty' do
-      it 'returns nil' do
-        [].sorted_median.should be_nil
-      end
-    end
-
-    context 'given any array' do
-      it 'returns the middle element of odd-sized arrays' do
-        ("a".."y").to_a.sorted_median.should == "m"
-      end
-    end
-  end
-end

data/spec/array/sorted_percentile_spec.rb

@@ -1,24 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/array/sorted_percentile'
-
-describe Array do
-  describe '#sorted_percentile' do
-    context 'with empty' do
-      it 'returns nil' do
-        [].sorted_percentile(0.0).should be_nil
-      end
-    end
-
-    context 'given any array' do
-      it 'returns the element closest to the given percentile' do
-        ("a".."y").to_a.sorted_percentile(  0.0).should == "a"
-        ("a".."y").to_a.sorted_percentile( 50.0).should == "m"
-        ("a".."y").to_a.sorted_percentile(100.0).should == "y"
-      end
-    end
-
-    # (Please do not define behavior for two elements equally close to
-    # a given percentile.)
-
-  end
-end

data/spec/array/sorted_sample_spec.rb

@@ -1,28 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/array/sorted_sample'
-
-describe Array do
-  describe '#sorted_median' do
-    context 'with empty' do
-      it 'returns an empty array' do
-        [].sorted_sample(1).should be_empty
-      end
-    end
-
-    context 'given an undersized array' do
-      it 'does not return the same element more than once' do
-        ("a".."z").to_a.sorted_sample(27).should == ("a".."z").to_a
-      end
-    end
-
-    context 'given any array' do
-      it ('returns a sample of the given size as close to evenly ' \
-          'distributed over the array as possible') do
-        sample = (1..100).to_a.sorted_sample(26)
-        deltas = sample[0..-2].zip(sample[1..-1]).map{|a,b| b-a}
-        deltas.max.should <= 4
-        deltas.min.should >= 3
-      end
-    end
-  end
-end

data/spec/gorillib/metaprogramming/aliasing_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-require 'gorillib/metaprogramming/aliasing'
-
-module BarMethodAliaser
-  def self.included(foo_class)
-    foo_class.class_eval do
-      include BarMethods
-      alias_method_chain :bar, :baz
-    end
-  end
-end
-
-module BarMethods
-  def bar_with_baz
-    bar_without_baz << '_with_baz'
-  end
-
-  def quux_with_baz!
-    quux_without_baz! << '_with_baz'
-  end
-
-  def quux_with_baz?
-    false
-  end
-
-  def quux_with_baz=(v)
-    send(:quux_without_baz=, v) << '_with_baz'
-  end
-
-  def duck_with_orange
-    duck_without_orange << '_with_orange'
-  end
-end
-
-describe 'metaprogramming', :metaprogramming_spec => true do
-  before do
-    Object.const_set :FooClassWithBarMethod, Class.new{ def bar() 'bar' end }
-    @instance = FooClassWithBarMethod.new
-  end
-
-  after do
-    Object.instance_eval { remove_const :FooClassWithBarMethod }
-  end
-
-  describe 'alias_method_chain' do
-
-    it 'does not have an effect if already provided by another library.' unless ENV['QUIET_RSPEC']
-
-    it 'creates a with_ and without_ method that chain' do
-      @instance.should respond_to(:bar)
-      feature_aliases = [:bar_with_baz, :bar_without_baz]
-
-      feature_aliases.each do |method|
-        @instance.should_not respond_to(method)
-      end
-      @instance.bar.should == 'bar'
-
-      FooClassWithBarMethod.class_eval{ include BarMethodAliaser }
-      feature_aliases.each do |method|
-        @instance.should respond_to(method)
-      end
-      @instance.bar.should == 'bar_with_baz'
-      @instance.bar_without_baz.should == 'bar'
-    end
-
-    it 'with bang' do
-      FooClassWithBarMethod.class_eval do
-        def quux!; 'quux' end
-      end
-
-      @instance.should_not respond_to(:quux_with_baz!)
-      FooClassWithBarMethod.class_eval do
-        include BarMethodAliaser
-        alias_method_chain :quux!, :baz
-      end
-      @instance.should respond_to(:quux_with_baz!)
-
-      @instance.quux!.should == 'quux_with_baz'
-      @instance.quux_without_baz!.should == 'quux'
-    end
-
-    it 'with same names between predicates and bang methods' do
-      FooClassWithBarMethod.class_eval do
-        def quux!; 'quux!' end
-        def quux?; true end
-        def quux=(v); 'quux=' end
-      end
-
-      @instance.should_not respond_to(:quux_with_baz!)
-      @instance.should_not respond_to(:quux_with_baz?)
-      @instance.should_not respond_to(:quux_with_baz=)
-
-      FooClassWithBarMethod.class_eval { include BarMethodAliaser }
-      @instance.should respond_to(:quux_with_baz!)
-      @instance.should respond_to(:quux_with_baz?)
-      @instance.should respond_to(:quux_with_baz=)
-
-      FooClassWithBarMethod.alias_method_chain :quux!, :baz
-      @instance.quux!.should == 'quux!_with_baz'
-      @instance.quux_without_baz!.should == 'quux!'
-
-      FooClassWithBarMethod.alias_method_chain :quux?, :baz
-      @instance.quux?.should == false
-      @instance.quux_without_baz?.should == true
-
-      FooClassWithBarMethod.alias_method_chain :quux=, :baz
-      @instance.send(:quux=, 1234).should == 'quux=_with_baz'
-      @instance.send(:quux_without_baz=, 1234).should == 'quux='
-    end
-
-    it 'with_feature_punctuation' do
-      FooClassWithBarMethod.class_eval do
-        def quux; 'quux' end
-        def quux?; 'quux?' end
-        include BarMethodAliaser
-        alias_method_chain :quux, :baz!
-      end
-
-      @instance.quux_with_baz!.should == 'quux_with_baz'
-
-      lambda{ FooClassWithBarMethod.alias_method_chain :quux?, :baz! }.should raise_error(NameError)
-    end
-
-    it 'yields target and punctuation' do
-      args = nil
-      FooClassWithBarMethod.class_eval do
-        def quux?; end
-        include BarMethods
-
-        FooClassWithBarMethod.alias_method_chain :quux?, :baz do |target, punctuation|
-          args = [target, punctuation]
-        end
-      end
-
-      args.should_not be_nil
-      args[0].should == 'quux'
-      args[1].should == '?'
-    end
-
-    it 'preserves private method status' do
-      FooClassWithBarMethod.class_eval do
-        def duck; 'duck' end
-        include BarMethodAliaser
-        private :duck
-        alias_method_chain :duck, :orange
-      end
-
-      lambda{ @instance.duck }.should raise_error(NoMethodError)
-
-      @instance.instance_eval{ duck }.should == 'duck_with_orange'
-      FooClassWithBarMethod.should be_private_method_defined(:duck)
-    end
-
-    it 'preserves protected method status' do
-      FooClassWithBarMethod.class_eval do
-        def duck; 'duck' end
-        include BarMethodAliaser
-        protected :duck
-        alias_method_chain :duck, :orange
-      end
-
-      lambda{ @instance.duck }.should raise_error(NoMethodError)
-
-      @instance.instance_eval{ duck }.should == 'duck_with_orange'
-      FooClassWithBarMethod.should be_protected_method_defined(:duck)
-    end
-
-    it 'preserves public method status' do
-      FooClassWithBarMethod.class_eval do
-        def duck; 'duck' end
-        include BarMethodAliaser
-        public :duck
-        alias_method_chain :duck, :orange
-      end
-
-      @instance.duck.should == 'duck_with_orange'
-      FooClassWithBarMethod.should be_public_method_defined(:duck)
-    end
-  end
-end

data/spec/gorillib/model/record/factories_spec.rb

@@ -1,335 +0,0 @@
-require 'spec_helper'
-
-require 'gorillib/object/blank'
-require 'gorillib/object/try_dup'
-require 'gorillib/hash/slice'
-require 'gorillib/metaprogramming/class_attribute'
-require 'gorillib/string/inflector'
-#
-require 'gorillib/collection'
-require 'gorillib/model/factories'
-
-describe '', :model_spec => true do
-  let(:mock_factory){ Gorillib::Factory::BaseFactory.new }
-
-  def test_factory(*args, &block)
-    described_class.new(*args, &block)
-  end
-
-  describe Gorillib::Factory do
-    describe 'Factory()' do
-      it 'turns a proc into an ApplyProcFactory' do
-        ff = Gorillib::Factory( ->(obj){ "bob says #{obj}" } )
-        ff.receive(3).should == "bob says 3"
-      end
-      it 'returns anything that responds to #receive directly' do
-        ff = Object.new ; ff.define_singleton_method(:receive){}
-        Gorillib::Factory(ff).should equal(ff)
-      end
-      it 'returns a factory directly' do
-        ff = Gorillib::Factory::SymbolFactory.new
-        Gorillib::Factory(ff).should equal(ff)
-      end
-      it 'does not look up factory **classes**' do
-        ->{ Gorillib::Factory(Gorillib::Factory::SymbolFactory) }.should raise_error(ArgumentError, /Don\'t know which factory makes/)
-      end
-      it 'looks up factories by typename' do
-        Gorillib::Factory(:symbol   ).should be_a(Gorillib::Factory::SymbolFactory)
-        Gorillib::Factory(:identical).should == (::Whatever)
-      end
-      it 'looks up factories by class' do
-        Gorillib::Factory(Symbol).should be_a(Gorillib::Factory::SymbolFactory)
-        Gorillib::Factory(String).should be_a(Gorillib::Factory::StringFactory)
-      end
-      it 'calls Gorillib::Factory.receive' do
-        x = mock
-        Gorillib::Factory.should_receive(:receive).with(x)
-        Gorillib::Factory(x)
-      end
-    end
-  end
-
-  shared_examples_for :it_converts do |conversion_mapping|
-    non_native_ok = conversion_mapping.delete(:non_native_ok)
-    conversion_mapping.each do |obj, expected_result|
-      it "#{obj.inspect} to #{expected_result.inspect}" do
-        subject.native?(  obj).should be_false
-        subject.blankish?(obj).should be_false
-        actual_result = subject.receive(obj)
-        actual_result.should  eql(expected_result)
-        unless non_native_ok then subject.native?(actual_result).should be_true  ; end
-      end
-    end
-  end
-
-  shared_examples_for :it_considers_native do |*native_objs|
-    it native_objs.inspect do
-      native_objs.each do |obj|
-        subject.native?(  obj).should be_true
-        actual_result = subject.receive(obj)
-        actual_result.should equal(obj)
-      end
-    end
-  end
-
-  shared_examples_for :it_considers_blankish do |*blankish_objs|
-    it blankish_objs.inspect do
-      blankish_objs.each do |obj|
-        subject.blankish?(obj).should be_true
-        subject.receive(obj).should be_nil
-      end
-    end
-  end
-
-  shared_examples_for :it_is_a_mismatch_for do |*mismatched_objs|
-    it mismatched_objs.inspect do
-      mismatched_objs.each do |obj|
-        ->{ subject.receive(obj) }.should raise_error(Gorillib::Factory::FactoryMismatchError)
-      end
-    end
-  end
-
-  shared_examples_for :it_is_registered_as do |*keys|
-    it "the factory for #{keys}" do
-      keys.each do |key|
-        Gorillib::Factory(key).should be_a(described_class)
-      end
-      its_factory = Gorillib::Factory(keys.first)
-      Gorillib::Factory.send(:factories).to_hash.select{|key,val| val.equal?(its_factory) }.keys.should == keys
-    end
-  end
-
-  # __________________________________________________________________________
-  #
-  #
-  #
-  describe Gorillib::Factory::StringFactory do
-    it_behaves_like :it_considers_native,   'foo', ''
-    it_behaves_like :it_converts,           :foo => 'foo', 3 => '3', false => "false", [] => "[]"
-    it_behaves_like :it_considers_blankish, nil
-    it_behaves_like :it_is_registered_as, :string, String
-    its(:typename){ should == :string }
-  end
-
-  describe Gorillib::Factory::SymbolFactory do
-    it_behaves_like :it_considers_native,   :foo, :"symbol :with weird chars"
-    it_behaves_like :it_converts,           'foo' => :foo
-    it_behaves_like :it_considers_blankish, nil, ""
-    it_behaves_like :it_is_a_mismatch_for,  3, false, []
-    it_behaves_like :it_is_registered_as, :symbol, Symbol
-    its(:typename){ should == :symbol }
-  end
-
-  describe Gorillib::Factory::RegexpFactory do
-    it_behaves_like :it_considers_native,   /foo/, //
-    it_behaves_like :it_converts,           'foo' => /foo/,  ".*" => /.*/
-    it_behaves_like :it_considers_blankish, nil, ""
-    it_behaves_like :it_is_a_mismatch_for,  :foo, 3, false, []
-    it_behaves_like :it_is_registered_as, :regexp, Regexp
-    its(:typename){ should == :regexp }
-  end
-
-  describe Gorillib::Factory::IntegerFactory do
-    it_behaves_like :it_considers_native,   1, -1
-    it_behaves_like :it_converts,           'one' => 0, '3blindmice' => 3, "0x10" => 0
-    it_behaves_like :it_converts,           '1.0' => 1, '1'  => 1,    "0" => 0, "0L" => 0, "1_234_567" => 1234567, "1_234_567.0" => 1234567
-    it_behaves_like :it_converts,            1.0  => 1, 1.234567e6 => 1234567, Complex(1,0) => 1
-    it_behaves_like :it_considers_blankish, nil, ""
-    it_behaves_like :it_is_a_mismatch_for,  :foo, false, [], Complex(1,3)
-    it_behaves_like :it_is_registered_as, :int, :integer, Integer
-    its(:typename){ should == :integer }
-  end
-
-  describe Gorillib::Factory::FloatFactory do
-    it_behaves_like :it_considers_native,   1.0, 1.234567e6
-    it_behaves_like :it_converts,           'one' => 0.0, '3blindmice' => 3.0, "0x10" => 0.0
-    it_behaves_like :it_converts,           '1.0' => 1.0, '1' => 1.0, "0" => 0.0, "0L" => 0.0, "1_234_567" => 1234567.0, "1_234_567.0" => 1234567.0
-    it_behaves_like :it_converts,                          1  => 1.0, -1 => -1.0, Complex(1,0) => 1.0
-    it_behaves_like :it_considers_blankish, nil, ""
-    it_behaves_like :it_is_a_mismatch_for,  :foo, false, []
-    it_behaves_like :it_is_registered_as, :float, Float
-    its(:typename){ should == :float }
-  end
-
-  describe Gorillib::Factory::ComplexFactory do
-    cplx0 = Complex(0) ; cplx1 = Complex(1) ; cplx1f = Complex(1.0) ;
-    it_behaves_like :it_considers_native,   Complex(1,3), Complex(1,0)
-    it_behaves_like :it_converts,           'one' => cplx0,  '3blindmice' => Complex(3), "0x10" => cplx0
-    it_behaves_like :it_converts,           '1.0' => cplx1f, '1' => cplx1, '0' => cplx0, '0L' => cplx0, '1_234_567' => Complex(1234567), '1_234_567.0' => Complex(1234567.0)
-    it_behaves_like :it_converts,            1.0 => cplx1f,   1 => cplx1,  -1 => Complex(-1), Rational(3,2) => Complex(Rational(3,2),0)
-    it_behaves_like :it_considers_blankish, nil, ""
-    it_behaves_like :it_is_a_mismatch_for,  :foo, false, []
-    it_behaves_like :it_is_registered_as, :complex, Complex
-    its(:typename){ should == :complex }
-  end
-
-  describe Gorillib::Factory::RationalFactory do
-    rat_0 = Rational(0) ; rat1 = Rational(1) ; rat3_2 = Rational(3, 2) ;
-    it_behaves_like :it_considers_native,   Rational(1, 3), Rational(1, 7)
-    it_behaves_like :it_converts,           'one' => rat_0,  '3blindmice' => Rational(3), "0x10" => rat_0
-    it_behaves_like :it_converts,           '1.5' => rat3_2, '1' => rat1, '0' => rat_0, '0L' => rat_0, '1_234_567' => Rational(1234567), '1_234_567.0' => Rational(1234567)
-    it_behaves_like :it_converts,            1.5  => rat3_2,  1  => rat1,  -1 => Rational(-1), Complex(1.5) => rat3_2
-    it_behaves_like :it_considers_blankish, nil, ""
-    it_behaves_like :it_is_a_mismatch_for,  :foo, false, [], Complex(1.5,3)
-    it_behaves_like :it_is_registered_as, :rational, Rational
-    its(:typename){ should == :rational }
-  end
-
-  describe Gorillib::Factory::BooleanFactory do
-    it_behaves_like :it_considers_native,   true, false
-    it_behaves_like :it_considers_blankish, nil
-    it_behaves_like :it_converts,           "false" => false, :false => false
-    it_behaves_like :it_converts,           "true" => true,   :true  => true, [] => true, :foo => true, [] => true, Complex(1.5,3) => true, Object.new => true
-    it_behaves_like :it_is_registered_as, :boolean
-    its(:typename){ should == :boolean }
-  end
-
-  describe ::Whatever do
-    it_behaves_like :it_considers_native,   true, false, nil, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
-    it "it is itself the factory for :identical and :whatever" do
-      keys = [Whatever, :identical, :whatever]
-      keys.each do |key|
-        Gorillib::Factory(key).should equal(described_class)
-      end
-      its_factory = ::Whatever
-      Gorillib::Factory.send(:factories).to_hash.select{|key,val| val.equal?(its_factory) }.keys.should == keys
-    end
-  end
-  describe Gorillib::Factory::IdenticalFactory do
-    it{ described_class.should equal(Whatever) }
-  end
-
-  describe Gorillib::Factory::ModuleFactory do
-    it_behaves_like :it_considers_blankish, nil
-    it_behaves_like :it_considers_native,  Module, Module.new, Class, Class.new, Object, String, BasicObject
-    it_behaves_like :it_is_a_mismatch_for, true, false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' },             Complex(1,3), Object.new
-    it_behaves_like :it_is_registered_as, :module, Module
-    its(:typename){ should == :module }
-  end
-
-  describe Gorillib::Factory::ClassFactory do
-    it_behaves_like :it_considers_blankish, nil
-    it_behaves_like :it_considers_native,  Module, Class, Class.new, Object, String, BasicObject
-    it_behaves_like :it_is_a_mismatch_for, true, false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
-    it_behaves_like :it_is_registered_as, :class, Class
-    its(:typename){ should == :class }
-  end
-
-  describe Gorillib::Factory::NilFactory do
-    it_behaves_like :it_considers_native,  nil
-    it_behaves_like :it_is_a_mismatch_for, true, false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
-    it_behaves_like :it_is_registered_as, :nil, NilClass
-    its(:typename){ should == :nil_class }
-  end
-
-  describe Gorillib::Factory::TrueFactory do
-    it_behaves_like :it_considers_native,  true
-    it_behaves_like :it_is_a_mismatch_for,       false, 3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
-    it_behaves_like :it_is_registered_as, :true, TrueClass
-  end
-
-  describe Gorillib::Factory::FalseFactory do
-    it_behaves_like :it_considers_native,  false
-    it_behaves_like :it_is_a_mismatch_for, true,        3, '', 'a string', :a_symbol, [], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
-    it_behaves_like :it_is_registered_as, :false, FalseClass
-  end
-
-  describe Gorillib::Factory::RangeFactory do
-    it_behaves_like :it_considers_blankish, nil, []
-    it_behaves_like :it_considers_native,  (1..2), ('a'..'z')
-    it_behaves_like :it_is_a_mismatch_for, true,        3, '', 'a string', :a_symbol, [1,2], {}, ->(){ 'a proc' }, Module.new, Complex(1,3), Object.new
-    it_behaves_like :it_is_registered_as, :range, Range
-    its(:typename){ should == :range }
-  end
-
-  # __________________________________________________________________________
-
-  # hand it a collection with entries 1, 2, 3 please
-  shared_examples_for :an_enumerable_factory do
-    it "accepts a factory for its items" do
-      mock_factory.should_receive(:receive).with(1)
-      mock_factory.should_receive(:receive).with(2)
-      mock_factory.should_receive(:receive).with(3)
-      factory = test_factory(:items => mock_factory)
-      factory.receive( collection_123 )
-    end
-    it "can generate an empty collection" do
-      subject.empty_product.should == empty_collection
-    end
-    it "lets you override the empty collection" do
-      ep = mock; ep.should_receive(:try_dup).and_return 'hey'
-      subject = test_factory(:empty_product => ep)
-      subject.empty_product.should == 'hey'
-      subject = test_factory(:empty_product => ->{ 'yo' })
-      subject.empty_product.should == 'yo'
-    end
-  end
-
-  describe Gorillib::Factory::HashFactory do
-    let(:collection_123){   { 'a' => 1, :b => 2, 'c' => 3 } }
-    let(:empty_collection){ {} }
-
-    it_behaves_like :it_considers_blankish, nil
-    it_behaves_like :it_converts, { {} => {}, { "a" => 2 } => { 'a' => 2 }, { :a => 2 } => { :a => 2 }, :non_native_ok => true }
-    it_behaves_like :it_is_a_mismatch_for, [1,2,3]
-    it_behaves_like :an_enumerable_factory
-
-    it 'follows examples' do
-      test_factory.receive(collection_123).should == { 'a' => 1, :b => 2, 'c' => 3}
-      test_factory(:keys  => :symbol).receive({'a' => 'x', :b => 'y', 'c' => :z}).should == {:a  => 'x', :b => 'y', :c  => :z}
-      test_factory(:items => :symbol).receive({'a' => 'x', :b => 'y', 'c' => :z}).should == {'a' => :x,  :b => :y,  'c' => :z}
-      autov_factory = test_factory(:empty_product => Hash.new{|h,k| h[k] = {} })
-      result = autov_factory.receive({:a => :b})  ; result.should == { :a => :b }
-      result[:flanger][:modacity] = 11            ; result.should == { :a => :b,  :flanger => { :modacity => 11 }}
-      result2 = autov_factory.receive({:x => :y}) ; result2.should == { :x => :y } ; result.should == { :a => :b,  :flanger => { :modacity => 11 }}
-    end
-
-    it "accepts a factory for the keys" do
-      mock_factory.should_receive(:receive).with(3).and_return("converted!")
-      factory = test_factory(:keys => mock_factory)
-      factory.receive( { 3 => 4 } ).should == { 'converted!' => 4 }
-    end
-    it_behaves_like :it_is_registered_as, :hash, Hash
-    its(:typename){ should == :hash }
-  end
-
-  describe Gorillib::Factory::ArrayFactory do
-    let(:collection_123){ [1,2,3] }
-    let(:empty_collection){ [] }
-
-    it 'follows examples' do
-      test_factory.receive([1,2,3]).should == [1,2,3]
-      test_factory(:items         => :symbol).receive(['a', 'b', :c]).should == [:a, :b, :c]
-      test_factory(:empty_product => [1,2,3]).receive([:a,  :b,  :c]).should == [1, 2, 3, :a, :b, :c]
-    end
-
-    it_behaves_like :it_considers_blankish, nil
-    it_behaves_like :it_converts, { [] => [], {} => [], [1,2,3] => [1,2,3], {:a => :b} => [[:a, :b]], [:a] => [:a], [[]] => [[]], :non_native_ok => true }
-    it_behaves_like :an_enumerable_factory
-    it_behaves_like :it_is_registered_as, :array, Array
-    its(:typename){ should == :array }
-  end
-
-  describe Gorillib::Factory::SetFactory do
-    let(:collection_123){   Set.new([1,2,3]) }
-    let(:empty_collection){ Set.new }
-
-    it 'follows examples' do
-      test_factory.receive([1,2,3]).should == collection_123
-      test_factory(:items  => :symbol).receive(['a', 'b', :c]).should == [:a, :b, :c].to_set
-      test_factory(:empty_product => [1,2,3].to_set).receive([:a,  :b,  :c]).should == [1, 2, 3, :a, :b, :c].to_set
-
-      has_an_empty_array = test_factory.receive( [[]] )
-      has_an_empty_array.should == Set.new( [[]] )
-      has_an_empty_array.first.should == []
-      has_an_empty_array.size.should  == 1
-    end
-
-    it_behaves_like :it_considers_blankish, nil
-    it_behaves_like :it_converts, { [] => Set.new, {} => Set.new, [1,2,3] => [1,2,3].to_set, {:a => :b} => Set.new({:a => :b}), [:a] => [:a].to_set, :non_native_ok => true }
-    it_behaves_like :an_enumerable_factory
-    it_behaves_like :it_is_registered_as, :set, Set
-    its(:typename){ should == :set }
-  end
-
-end