schlick-pickle 0.1.5.1

data/spec/lib/pickle_adapter_spec.rb

@@ -0,0 +1,134 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Adapter do
+  it ".factories should raise NotImplementedError" do
+    lambda{ Pickle::Adapter.factories }.should raise_error(NotImplementedError)
+  end
+  
+  it "#create should raise NotImplementedError" do
+    lambda{ Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
+  end
+  
+  it ".model_classes should not include CGI::Session::ActiveRecordStore" do
+    Pickle::Adapter.model_classes.should_not include(CGI::Session::ActiveRecordStore)
+  end
+  
+  describe '::ActiveRecord' do
+    before do
+      # set up a fake object space
+      @klass1 = mock('One', :name => 'One')
+      @klass2 = mock('One::Two', :name => 'One::Two')
+      Pickle::Adapter::ActiveRecord.stub!(:model_classes).and_return([@klass1, @klass2])
+    end
+    
+    describe ".factories" do
+      it "should create one for each active record class" do
+        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass1).once
+        Pickle::Adapter::ActiveRecord.should_receive(:new).with(@klass2).once
+        Pickle::Adapter::ActiveRecord.factories
+      end
+      
+      describe ".new(Class)" do
+        before do
+          @factory = Pickle::Adapter::ActiveRecord.new(@klass2)
+        end
+        
+        it "should have underscored (s/_) name of Class as #name" do
+          @factory.name.should == 'one_two'
+        end
+        
+        it "#create(attrs) should call Class.create!(attrs)" do
+          @klass2.should_receive(:create!).with({:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+  end
+  
+  describe '::FactoryGirl' do
+    before do
+      # set up a fake object space
+      @factory1 = mock('factory1', :factory_name => :one, :build_class => (@class1 = mock('Class1')))
+      @factory2 = mock('factory2', :factory_name => :two, :build_class => (@class2 = mock('Class2')))
+      Factory.stub!(:factories).and_return(:factory1 => @factory1, :factory2 => @factory2)
+    end
+    
+    describe ".factories" do
+      it "should create one for each factory" do
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory1).once
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory2).once
+        Pickle::Adapter::FactoryGirl.factories
+      end
+      
+      describe ".new(factory)" do
+        before do
+          @factory = Pickle::Adapter::FactoryGirl.new(@factory1)
+        end
+        
+        it "should have name of factory_name" do
+          @factory.name.should == 'one'
+        end
+        
+        it "should have klass of build_class" do
+          @factory.klass.should == @class1
+        end
+        
+        it "#create(attrs) should call Factory(<:key>, attrs)" do
+          Factory.should_receive(:create).with("one", {:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+  end
+  
+  describe '::Machinist' do
+    before do
+      # set up a fake object space
+      @klass1 = mock('One', :name => 'One', :make => true, :make_unsaved => true)
+      @klass1.instance_variable_set('@blueprint', true)
+      @klass2 = mock('Two', :name => 'Two')
+      @klass3 = mock('Two::Sub', :name => 'Two::Sub', :make_special => true, :make => true, :make_unsaved => true)
+      @klass3.instance_variable_set('@blueprint', true)
+      Pickle::Adapter::Machinist.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+    end
+    
+    describe ".factories" do
+      it "should create one for each machinist make method, except make_unsaved" do
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass1, 'make').once
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, 'make').once
+        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, 'make_special').once
+        Pickle::Adapter::Machinist.factories
+      end
+      
+      describe ".new(Class, 'make')" do
+        before do
+          @factory = Pickle::Adapter::Machinist.new(@klass1, 'make')
+        end
+        
+        it "should have underscored (s/_) name of Class as #name" do
+          @factory.name.should == 'one'
+        end
+        
+        it "#create(attrs) should call Class.make(attrs)" do
+          @klass1.should_receive(:make).with({:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+      
+      describe ".new(Class, 'make_special')" do
+        before do
+          @factory = Pickle::Adapter::Machinist.new(@klass3, 'make_special')
+        end
+        
+        it "should have 'special_<Class name>' as #name" do
+          @factory.name.should == 'special_two_sub'
+        end
+        
+        it "#create(attrs) should call Class.make_special(attrs)" do
+          @klass3.should_receive(:make_special).with({:key => "val"})
+          @factory.create(:key => "val")
+        end
+      end
+    end
+  end
+end

data/spec/lib/pickle_config_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Config do
+  before do
+    @config = Pickle::Config.new
+  end
+  
+  it "#adapters should default to :machinist, :factory_girl, :active_record" do
+    @config.adapters.should == [:machinist, :factory_girl, :active_record]
+  end
+  
+  it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::ActiveRecord" do
+    @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::ActiveRecord]
+  end
+  
+  describe "setting adapters to [:machinist, SomeAdapter]" do
+    class SomeAdapter; end
+    
+    before do
+      @config.adapters = [:machinist, SomeAdapter]
+    end
+    
+    it "#adapter_classes should be Adapter::Machinist, SomeAdapter" do
+      @config.adapter_classes.should == [Pickle::Adapter::Machinist, SomeAdapter]
+    end
+  end
+  
+  describe "#factories" do
+    it "should call adaptor.factories for each adaptor" do
+      Pickle::Adapter::Machinist.should_receive(:factories).and_return([])
+      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([])
+      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([])
+      @config.factories
+    end
+    
+    it "should aggregate factories into a hash using factory name as key" do
+      Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist = mock('machinist', :name => 'machinist')])
+      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl = mock('factory_girl', :name => 'factory_girl')])
+      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([@active_record = mock('active_record', :name => 'active_record')])
+      @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'active_record' => @active_record}
+    end
+    
+    it "should give preference to adaptors first in the list" do
+      Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist_one = mock('one', :name => 'one')])
+      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl_one = mock('one', :name => 'one'), @factory_girl_two = mock('two', :name => 'two')])
+      Pickle::Adapter::ActiveRecord.should_receive(:factories).and_return([@active_record_two = mock('two', :name => 'two'), @active_record_three = mock('three', :name => 'three')])
+      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @active_record_three}
+    end
+  end
+  
+  it "#mappings should default to []" do
+    @config.mappings.should == []
+  end
+
+  describe '#predicates' do
+    it "should be list of all non object ? public instance methods + columns methods of Adapter.model_classes" do
+      class1 = mock('Class1', :public_instance_methods => ['nope', 'foo?', 'bar?'], :column_names => ['one', 'two'])
+      class2 = mock('Class2', :public_instance_methods => ['not', 'foo?', 'faz?'], :column_names => ['two', 'three'])
+      Pickle::Adapter.stub!(:model_classes).and_return([class1, class2])
+      
+      @config.predicates.to_set.should == ['foo?', 'faz?', 'bar?', 'one', 'two', 'three'].to_set
+    end
+    
+    it "should be overridable" do
+      @config.predicates = %w(lame?)
+      @config.predicates.should == %w(lame?)
+    end
+  end
+  
+  describe "#map 'foo', :to => 'faz'" do
+    before do
+      @config.map 'foo', :to => 'faz'
+    end
+    
+    it "should create OpenStruct(search: 'foo', replace: 'faz') mapping" do
+      @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replace => 'faz')
+    end
+  end
+  
+  describe "#map 'foo', 'bar' :to => 'faz'" do
+    before do
+      @config.map 'foo', 'bar', :to => 'faz'
+    end
+    
+    it "should create 2 mappings" do
+      @config.mappings.first.should == OpenStruct.new(:search => 'foo', :replace => 'faz')
+      @config.mappings.last.should == OpenStruct.new(:search => 'bar', :replace => 'faz')
+    end
+  end
+  
+  it "#configure(&block) should execiute on self" do
+    @config.should_receive(:foo).with(:bar)
+    @config.configure do |c|
+      c.foo :bar
+    end
+  end
+end

data/spec/lib/pickle_injector_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Injector do
+  describe ".inject Pickle::Session, :into => <a class>" do
+    before do
+      klass = Class.new
+      Pickle::Injector.inject Pickle::Session, :into => klass
+      @object = klass.new
+    end
+    
+    it "object should respond_to Pickle:Session methods" do
+      @object.should respond_to(:model)
+      @object.should respond_to(:create_model)
+      @object.should respond_to(:find_model)
+    end
+    
+    it "object.model (a pickle method) should call object.pickle_session.model" do
+      @object.pickle_session.should_receive(:model).with('a user')
+      @object.model('a user')
+    end
+  end
+end

data/spec/lib/pickle_parser_matchers_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Parser::Matchers do
+  include Pickle::Parser::Matchers
+
+  describe "(config: [factories: user, car, fast_car] [predicates: name, status, fancy?, super_fancy?]" do
+    def config
+      @config ||= Pickle::Config.new do |c|
+        c.factories = {
+          'user'      => mock('factory'),
+          'car'       => mock('factory'),
+          'fast_car'  => mock('factory')
+        }
+        c.predicates = %w(name status fancy? super_fancy?)
+      end
+    end
+  
+    describe "Match atoms" do
+      def self.atom_should_match(atom, strings)
+        Array(strings).each do |string|
+          it "#{atom} should match '#{string}'" do
+            string.should match(/^#{send atom}$/)
+          end
+        end
+      end
+
+      def self.atom_should_not_match(atom, strings)
+        Array(strings).each do |string|
+          it "#{atom} should NOT match '#{string}'" do
+            string.should_not match(/^#{send atom}$/)
+          end
+        end
+      end
+  
+      atom_should_match     :match_ordinal, ['1st', '2nd', '23rd', '104th']
+      atom_should_not_match :match_ordinal, ['1', '2']
+
+      atom_should_match     :match_index, ['first', 'last', '23rd', '104th']
+      atom_should_not_match :match_index, ['1', '2', 'foo']
+
+      atom_should_match     :match_label, [': "gday"', ': "gday mate"']
+      atom_should_not_match :match_label, [': "gday""', ': gday']
+  
+      atom_should_match     :match_field, ['foo: "this is the life"', 'bar_man: "and so is this"', 'boolean: false', 'boolean: true', 'numeric: 10', 'numeric: 12.5']
+      atom_should_not_match :match_field, ['foo bar: "this aint workin"']
+  
+      atom_should_match     :match_fields, ['foo: "bar"', 'foo: "bar", baz: "bah"']
+      atom_should_not_match :match_fields, ['foo bar: "baz"', 'email: "a", password: "b", and password_confirmation: "c"']
+
+      atom_should_match     :match_model, ['a user', '1st fast car', 'the 23rd fast_car', 'the user: "fred flinstone"']
+      atom_should_not_match :match_model, ['a giraffe', 'a 1st faster car: "jim"', 'an event created']
+  
+      atom_should_match     :match_predicate, ['name', 'status', 'fancy', 'super fancy', 'super_fancy']
+      atom_should_not_match :match_predicate, ['nameo', 'increment', 'not a predicate']
+    
+      atom_should_match     :match_factory, ['user', 'fast car', 'fast_car', 'car']
+      atom_should_not_match :match_factory, ['users', 'faster car', 'event created']
+    
+      atom_should_match     :match_plural_factory, ['users', 'fast cars']
+      atom_should_not_match :match_plural_factory, ['usereres', 'fasts cars']
+    end
+  end
+  
+  describe "capture methods" do
+    it "capture_field should == '(' + match_field + ')'" do
+      should_receive(:match_field).and_return('MATCH_FIELD')
+      capture_field.should == '(MATCH_FIELD)'
+    end
+  end
+end

data/spec/lib/pickle_parser_spec.rb

@@ -0,0 +1,154 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Parser do
+  before do
+    @parser = Pickle::Parser.new(:config => Pickle::Config.new)
+  end
+  
+  it "should raise error when created with no config" do
+    lambda{ Pickle::Parser.new }.should raise_error(ArgumentError)
+  end
+  
+  describe 'misc regexps' do
+    describe '/^#{capture_model} exists/' do
+      before do
+        @regexp = /^(#{@parser.capture_model}) exists$/
+      end
+      
+      it "should match 'a user exists'" do
+        'a user exists'.should match(@regexp)
+      end
+      
+      it "should caputure 'a user' from  'a user exists'" do
+        'a user exists'.match(@regexp)[1].should == 'a user'
+      end
+    end
+  end
+  
+  describe '#parse_field' do
+    it "should return {'a' => 'b'} for 'a: \"b\"'" do
+      @parser.parse_field('a: "b"').should == {'a' => 'b'}
+    end
+  
+    it "should raise error for invalid field 'a : b'" do
+      lambda { @parser.parse_field('a : b') }.should raise_error(ArgumentError)
+    end
+  end
+  
+  describe '#parse_fields' do
+    it 'should return {} for blank argument' do
+      @parser.parse_fields(nil).should == {}
+      @parser.parse_fields('').should == {}
+    end
+    
+    it 'should raise error for invalid argument' do
+      lambda { @parser.parse_fields('foo foo') }.should raise_error(ArgumentError)
+    end
+    
+    it '(\'foo: "bar"\') should == { "foo" => "bar"}' do
+      @parser.parse_fields('foo: "bar"').should == { "foo" => "bar"}
+    end
+    
+    it '("bool: true") should == { "bool" => true}' do
+      @parser.parse_fields('bool: true').should == {"bool" => true}
+    end
+    
+    it '("bool: false") should == { "bool" => false}' do
+      @parser.parse_fields('bool: false').should == {"bool" => false}
+    end
+    
+    it '("int: 10") should == { "int" => 10 }' do
+      @parser.parse_fields('int: 10').should == {"int" => 10}
+    end
+
+    it '("float: 10.1") should == { "float" => 10.1 }' do
+      @parser.parse_fields('float: 10.1').should == {"float" => 10.1}
+    end
+
+    it '(\'foo: "bar", bar_man: "wonga wonga", gump: 123\') should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}' do
+      @parser.parse_fields('foo: "bar", bar_man: "wonga wonga", gump: 123').should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}
+    end
+  end
+  
+  describe '#parse_model' do
+    it '("a user") should == ["user", ""]' do
+      @parser.parse_model("a user").should == ["user", ""]
+    end
+  
+    it '("the user") should == ["user", ""]' do
+      @parser.parse_model("the user").should == ["user", ""]
+    end
+  
+    it '("1 fast car") should == ["fast_car", ""]' do
+      @parser.parse_model("1 fast car").should == ["fast_car", ""]
+    end
+    
+    it '(\'an user: "jim jones"\') should == ["user", "jim_jones"]' do
+      @parser.parse_model('an user: "jim jones"').should == ["user", "jim_jones"]
+    end
+    
+    it '(\'that fast car: "herbie"\') should == ["fast_car", "herbie"]' do
+      @parser.parse_model('that fast car: "herbie"').should == ["fast_car", "herbie"]
+    end
+    
+    it '(\'the 12th user\') should == ["user", 11]' do
+      @parser.parse_model('the 12th user').should == ["user", 11]
+    end
+  
+    it '(\'the last user\') should == ["user", -1]' do
+      @parser.parse_model('the last user').should == ["user", -1]
+    end
+    
+    it '("the first user") should == ["user", 0]' do
+      @parser.parse_model('the first user').should == ["user", 0]
+    end
+  
+    it '("the 1st user") should == ["user", 0]' do
+      @parser.parse_model('the 1st user').should == ["user", 0]
+    end
+  end
+  
+  describe "#parse_index" do
+    it '("1st") should == 0' do
+      @parser.parse_index("1st").should == 0
+    end
+  
+    it '("24th") should == 23' do
+      @parser.parse_index("24th").should == 23
+    end
+    it '("first") should == 0' do
+      @parser.parse_index("first").should == 0
+    end
+    
+    it '("last") should == -1' do
+      @parser.parse_index("last").should == -1
+    end
+  end
+  
+  describe "customised mappings" do
+    describe "config maps 'I|myself' to 'user: \"me\"'" do
+      before do
+        @config = Pickle::Config.new do |c|
+          c.map 'I', 'myself', :to => 'user: "me"'
+        end
+        @parser = Pickle::Parser.new(:config => @config)
+      end
+
+      it "'I' should match /\#{match_model}/" do
+        'I'.should match(/#{@parser.match_model}/)
+      end
+    
+      it "'myself' should match /\#{match_model}/" do
+        'myself'.should match(/#{@parser.match_model}/)
+      end
+    
+      it "parse_model('I') should == ['user', 'me']" do
+        @parser.parse_model('I').should == ["user", "me"]
+      end
+
+      it "parse_model('myself') should == ['user', 'me']" do
+        @parser.parse_model('myself').should == ["user", "me"]
+      end
+    end
+  end
+end