ianwhite-pickle 0.1.1 → 0.1.2

data/lib/pickle/parser/matchers.rb

@@ -0,0 +1,75 @@
+module Pickle
+  class Parser
+    module Matchers
+      def match_ordinal
+        '(?:\d+(?:st|nd|rd|th))'
+      end
+  
+      def match_index
+        "(?:first|last|#{match_ordinal})"
+      end
+  
+      def match_prefix
+        '(?:(?:1|a|an|another|the|that) )'
+      end
+  
+      def match_quoted
+        '(?:[^\\"]|\\.)*'
+      end
+  
+      def match_label
+        "(?::? \"#{match_quoted}\")"
+      end
+
+      def match_field
+        "(?:\\w+: \"#{match_quoted}\")"
+      end
+  
+      def match_fields
+        "(?:#{match_field}, )*#{match_field}"
+      end
+  
+      def match_mapping
+        config.mappings.any? ? "(?:#{config.mappings.map(&:search).join('|')})" : ""
+      end
+  
+      def match_factory
+        "(?:#{config.factory_names.map{|n| n.gsub('_','[_ ]')}.join('|')})"
+      end
+  
+      def match_indexed_model
+        "(?:(?:#{match_index} )?#{match_factory})"
+      end
+  
+      def match_labeled_model
+        "(?:#{match_factory}#{match_label})"
+      end
+  
+      def match_model
+        "(?:#{match_mapping}|#{match_prefix}?(?:#{match_indexed_model}|#{match_labeled_model}))"
+      end
+  
+      # create capture analogues of match methods
+      instance_methods.select{|m| m =~ /^match_/}.each do |method|
+        eval <<-end_eval                   
+          def #{method.sub('match_', 'capture_')}         # def capture_field
+            "(" + #{method} + ")"                         #   "(" + match_field + ")"
+          end                                             # end
+        end_eval
+      end
+  
+      # special capture methods
+      def capture_number_in_ordinal
+        '(?:(\d+)(?:st|nd|rd|th))'
+      end
+  
+      def capture_name_in_label
+        "(?::? \"(#{match_quoted})\")"
+      end
+  
+      def capture_key_and_value_in_field
+        "(?:(\\w+): \"(#{match_quoted})\")"
+      end
+    end
+  end
+end

data/lib/pickle/parser/with_session.rb

@@ -0,0 +1,24 @@
+module Pickle
+  class Parser
+    # add ability to parse model names as fields, using a session
+    module WithSession
+      def self.included(parser_class)
+        parser_class.alias_method_chain :parse_field, :model
+      end
+
+      attr_accessor :session
+
+      def match_field
+        "(?:\\w+: (?:#{match_model}|\"#{match_quoted}\"))"
+      end
+
+      def parse_field_with_model(field)
+        if session && field =~ /^(\w+): #{capture_model}$/
+          {$1 => session.model($2)}
+        else
+          parse_field_without_model(field)
+        end
+      end    
+    end
+  end
+end

data/lib/pickle/session.rb

@@ -1,19 +1,22 @@
 module Pickle
   class Session
-    include Parser
-    
+    def initialize(options = {})
+      self.parser = options[:parser] || Pickle.parser
+      @config = options[:config] || parser.config
+    end
+
     def create_model(a_model_name, fields = nil)
-      factory, name = *parse_model(a_model_name)
-      raise ArgumentError, "Can't create a model with an ordinal (e.g. 1st user)" if name.is_a?(Integer)
-      record = Factory(factory, parse_fields(fields))
-      store_model(factory, name, record)
+      factory, label = *parser.parse_model(a_model_name)
+      raise ArgumentError, "Can't create with an ordinal (e.g. 1st user)" if label.is_a?(Integer)
+      record = config.factories[factory].create(parser.parse_fields(fields))
+      store_model(factory, label, record)
     end
 
     def find_model(a_model_name, fields)
-      model, name = *parse_model(a_model_name)
+      model, name = *parser.parse_model(a_model_name)
       raise ArgumentError, "Can't find a model with an ordinal (e.g. 1st user)" if name.is_a?(Integer)
       model_class = model.classify.constantize
-      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, parse_fields(fields)))
+      if record = model_class.find(:first, :conditions => convert_models_to_attributes(model_class, parser.parse_fields(fields)))
         store_model(model, name, record)
       else
         raise ActiveRecord::RecordNotFound, "Couldn't find #{model} with #{fields}"
@@ -21,8 +24,8 @@ module Pickle
     end
     
     # return the original model stored by create_model or find_model
-    def original_model(a_model_name)
-      factory, name_or_index = *parse_model(a_model_name)
+    def created_model(a_model_name)
+      factory, name_or_index = *parser.parse_model(a_model_name)
       
       if name_or_index.blank?
         models_by_factory(factory).last
@@ -34,13 +37,13 @@ module Pickle
     end
 
     # predicate version which raises no errors
-    def original_model?(a_model_name)
-      (original_model(a_model_name) rescue nil) ? true : false
+    def created_model?(a_model_name)
+      (created_model(a_model_name) rescue nil) ? true : false
     end
     
     # return a newly selected model
     def model(a_model_name)
-      if model = original_model(a_model_name)
+      if model = created_model(a_model_name)
         model.class.find(model.id) or raise ActiveRecord::RecordNotFound, "model: #{a_model_name} could not be found in the database"
       end
     end
@@ -51,27 +54,25 @@ module Pickle
     end
     
     # return all original models of specified type
-    def original_models(factory)
+    def created_models(factory)
       models_by_factory(factory)
     end
       
     # return all models of specified type (freshly selected from the database)
     def models(factory)
-      original_models(factory).map do |model|
+      created_models(factory).map do |model|
         model.class.find(model.id)
       end
     end
     
-    def parse_field_with_model(field)
-      if field =~ /^(\w+): (#{Match::Model})$/
-        {$1 => model($2)}
-      else
-        parse_field_without_model(field)
-      end
+  protected
+    attr_reader :parser, :config
+  
+    def parser=(parser)
+      parser.session = self
+      @parser = parser
     end
-    alias_method_chain :parse_field, :model
-
-  private
+    
     def convert_models_to_attributes(ar_class, attrs)
       attrs.each do |key, val|
         if val.is_a?(ActiveRecord::Base) && ar_class.column_names.include?("#{key}_id")
@@ -94,7 +95,7 @@ module Pickle
     
     # if the factory name != the model name, store under both names
     def store_model(factory, name, record)
-      store_record(canonical(record.class.name), name, record) if canonical(record.class.name) != factory
+      store_record(parser.canonical(record.class.name), name, record) if parser.canonical(record.class.name) != factory
       store_record(factory, name, record)
     end
 

data/lib/pickle/version.rb

@@ -0,0 +1,9 @@
+module Pickle
+  module Version
+    Major = 0
+    Minor = 1
+    Tiny  = 2
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+end

data/rails_generators/pickle/pickle_generator.rb

@@ -0,0 +1,19 @@
+class PickleGenerator < Rails::Generator::Base
+  def initialize(*args)
+    super(*args)
+    File.exists?('features/support/env.rb') or raise "features/support/env.rb not found, try running script/generate cucumber"
+  end
+  
+  def manifest
+    record do |m|
+      m.directory File.join('features/step_definitions')
+      m.template 'pickle_steps.rb', File.join('features/step_definitions', "pickle_steps.rb")
+      current_env = File.read('features/support/env.rb')
+      if current_env.include?("require 'pickle'")
+        logger.skipped "features/support/env.rb, as it already requires pickle"
+      else
+        m.template 'env.rb', File.join('features/support', "env.rb"), :assigns => {:current_env => current_env}, :collision => :force
+      end
+    end
+  end
+end

data/rails_generators/pickle/templates/env.rb

@@ -0,0 +1,9 @@
+<%= current_env %>
+# to configure pickle, uncomment the following lines
+# require 'pickle/config'
+# Pickle.config do |pickle|
+#   pickle.adaptors = [:machinist]
+#   pickle.map 'I', 'myself', 'me', 'my', :to => 'user: "me"'
+# end
+
+require 'pickle'

data/rails_generators/pickle/templates/pickle_steps.rb

@@ -0,0 +1,23 @@
+# this file generated by script/generate pickle
+
+Given(/^#{CaptureModel} exists$/) do |name|
+  create_model(name)
+end
+
+Given(/^#{CaptureModel} exists with #{CaptureFields}$/) do |name, fields|
+  create_model(name, fields)
+end
+
+Then(/^#{CaptureModel} should exist with #{CaptureFields}$/) do |name, fields|
+  find_model(name, fields).should be_present
+end
+
+Then(/^#{CaptureModel} should (?:be|have) (?:an? )?([\w ]+)$/) do |name, predicate|
+  predicate_method = predicate.gsub(' ', '_')
+  model(name).should send("be_#{predicate_method}")
+end
+
+Then(/^#{CaptureModel} should not (?:be|have) (?:an? )?([\w ]+)$/) do |name, predicate|
+  predicate_method = predicate.gsub(' ', '_')
+  model(name).should_not send("be_#{predicate_method}")
+end

data/spec/lib/pickle_adapter_spec.rb

@@ -0,0 +1,128 @@
+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
+      Factory.stub!(:factories).and_return(:one => nil, :two => nil)
+    end
+    
+    describe ".factories" do
+      it "should create one for each factory" do
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(:one).once
+        Pickle::Adapter::FactoryGirl.should_receive(:new).with(:two).once
+        Pickle::Adapter::FactoryGirl.factories
+      end
+      
+      describe ".new(:factory_name)" do
+        before do
+          @factory = Pickle::Adapter::FactoryGirl.new(:one)
+        end
+        
+        it "should have name of factory key" do
+          @factory.name.should == 'one'
+        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

@@ -1,46 +1,100 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+require 'pickle/config'
 
 describe Pickle::Config do
   before do
-    # zero pickle config before each example
-    [:names, :model_names, :factory_names, :mappings].each do |config_var|
-      instance_variable_set "@orig_#{config_var}", Pickle::Config.send(config_var)
-      Pickle::Config.send("#{config_var}=", nil)
+    @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
   
-  after do
-    # restore pickle config back after each example
-    [:model_names, :factory_names, :names, :mappings].each do |config_var|
-      Pickle::Config.send "#{config_var}=", instance_variable_get("@orig_#{config_var}")
+  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 "#factory_names should be keys of #factories" do
+    @config.should_receive(:factories).and_return('one' => nil, 'two' => nil)
+    @config.factory_names.sort.should == ['one', 'two'].sort
   end
   
-  it ":factory_names should default to stringified keys of Factory.factories" do
-    Factory.factories.should_receive(:keys).and_return([:one, :two])
-    Pickle::Config.factory_names.should == ['one', 'two']
+  it "#mappings should default to []" do
+    @config.mappings.should == []
+  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
   
-  it ":model_names should default to directory listing of app/models excluding observers" do
-    models_path = "#{RAILS_ROOT}/app/models"
-    Dir.should_receive(:[]).with("#{models_path}/**/*.rb").and_return([
-      "#{models_path}/one.rb",
-      "#{models_path}/one/a.rb",
-      "#{models_path}/one/b.rb",
-      "#{models_path}/one/b/i.rb",
-      "#{models_path}/one_observer.rb",
-      "#{models_path}/two.rb"
-    ])
-    Pickle::Config.model_names.should == ['one', 'one/a', 'one/b', 'one/b/i', 'two']
+  describe "#map 'foo', 'bar' :to => 'faz'" do
+    before do
+      @config.map 'foo', 'bar', :to => 'faz'
+    end
+    
+    it "should create OpenStruct(search: '(?:foo|bar)', replace: 'faz') mapping" do
+      @config.mappings.first.should == OpenStruct.new(:search => '(?:foo|bar)', :replace => 'faz')
+    end
   end
   
-  it ":names should default to set (Array) :factory and :model names" do
-    Pickle::Config.factory_names = ['one', 'two']
-    Pickle::Config.model_names = ['two', 'one/a', 'one/b']
-    Pickle::Config.names.sort.should == ['one', 'one/a', 'one/b', 'two']
+  it "#configure(&block) should execiute on self" do
+    @config.should_receive(:foo).with(:bar)
+    @config.configure do |c|
+      c.foo :bar
+    end
   end
   
-  it ":mappings should default to []" do
-    Pickle::Config.mappings.should == []
+  describe "Pickle.config" do
+    it "should refer to same object" do
+      Pickle.config.should == Pickle.config
+    end
+    
+    it "called with (&block) should execute on the config" do
+      Pickle.config.should_receive(:foo).with(:bar)
+      Pickle.config do |c|
+        c.foo :bar
+      end
+    end
   end
 end