pickle 0.5.0 → 0.5.1

data/features/step_definitions/email_steps.rb

@@ -27,37 +27,39 @@ When(/^(?:I|they) click the first link in #{capture_email}$/) do |email_ref|
 end
 
 Then(/^(\d)+ emails? should be delivered to (.*)$/) do |count, to|
-  expect(emails("to: \"#{email_for(to)}\"").size).to eq(count.to_i)
+  actual = emails("to: \"#{email_for(to)}\"").size
+  expect(actual).to eq(count.to_i), "Expected #{count} emails but encountered #{actual} delivered to #{to}"
 end
 
 Then(/^(\d)+ emails? should be delivered with #{capture_fields}$/) do |count, fields|
-  expect(emails(fields).size).to eq(count.to_i)
+  actual = emails(fields).size
+  expect(actual).to eq(count.to_i), "Expected #{count} emails but encountered #{actual} to be delivered with #{fields}"
 end
 
 Then(/^#{capture_email} should be delivered to (.+)$/) do |email_ref, to|
-  expect(email(email_ref, "to: \"#{email_for(to)}\"")).not_to be_nil
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).not_to be_nil, "Failed to find #{email_ref} delivered to: #{to}"
 end
 
 Then(/^#{capture_email} should not be delivered to (.+)$/) do |email_ref, to|
-  expect(email(email_ref, "to: \"#{email_for(to)}\"")).to be_nil
+  expect(email(email_ref, "to: \"#{email_for(to)}\"")).to be_nil, "Unexpectedly found #{email_ref} delivered to: #{to}"
 end
 
 Then(/^#{capture_email} should have #{capture_fields}$/) do |email_ref, fields|
-  expect(email(email_ref, fields)).not_to be_nil
+  expect(email(email_ref, fields)).not_to be_nil, "Failed to find #{fields} in #{email_ref}"
 end
 
 Then(/^#{capture_email} should contain "(.*)"$/) do |email_ref, text|
-  expect(email(email_ref).body).to match(/#{text}/)
+  expect(email(email_ref).body).to match(/#{text}/), "Failed to find \"#{text}\" in #{email_ref}"
 end
 
 Then(/^#{capture_email} should not contain "(.*)"$/) do |email_ref, text|
-  expect(email(email_ref).body).not_to match(/#{text}/)
+  expect(email(email_ref).body).not_to match(/#{text}/), "Unexpectedly found \"#{text}\" in #{email_ref}"
 end
 
 Then(/^#{capture_email} should link to (.+)$/) do |email_ref, page|
-  expect(email(email_ref).body).to match(/#{path_to(page)}/)
+  expect(email(email_ref).body).to match(/#{path_to(page)}/), "Failed to find link to #{page} in #{email_ref}"
 end
 
 Then(/^show me the emails?$/) do
-   save_and_open_emails
+  save_and_open_emails
 end

data/features/step_definitions/pickle_steps.rb

@@ -7,7 +7,7 @@ end
 
 # create n models
 Given(/^(\d+) #{capture_plural_factory} exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
-  count.to_i.times { create_model(plural_factory.singularize, fields) }
+  create_models(count, plural_factory.singularize, fields)
 end
 
 # create models from a table
@@ -26,10 +26,15 @@ Then(/^#{capture_model} should not exist(?: with #{capture_fields})?$/) do |name
 end
 
 # find models with a table
-Then(/^the following #{capture_plural_factory} should exists?:?$/) do |plural_factory, table|
+Then(/^the following #{capture_plural_factory} should exist:?$/) do |plural_factory, table|
   expect(find_models_from_table(plural_factory, table)).not_to be_any(&:nil?)
 end
 
+# not find models with a table
+Then(/^the following #{capture_plural_factory} should not exists?:?$/) do |plural_factory, table|
+  find_models_from_table(plural_factory, table).should be_all(&:nil?)
+end
+
 # find exactly n models
 Then(/^(\d+) #{capture_plural_factory} should exist(?: with #{capture_fields})?$/) do |count, plural_factory, fields|
   expect(find_models(plural_factory.singularize, fields).size).to eq(count.to_i)
@@ -60,7 +65,7 @@ Then(/^#{capture_model} should not be #{capture_model}(?:'s)? (\w+)$/) do |targe
   expect(model!(owner).send(association)).not_to eq(model!(target))
 end
 
-# assert model.predicate? 
+# assert model.predicate?
 Then(/^#{capture_model} should (?:be|have) (?:an? )?#{capture_predicate}$/) do |name, predicate|
   if model!(name).respond_to?("has_#{predicate.gsub(' ', '_')}")
     expect(model!(name)).to send("have_#{predicate.gsub(' ', '_')}")
@@ -83,7 +88,7 @@ end
 Then(/^#{capture_model}'s (\w+) (should(?: not)?) be #{capture_value}$/) do |name, attribute, expectation, expected|
   actual_value  = model(name).send(attribute)
   expectation   = expectation.gsub("should", "to").gsub(" ", "_")
-  
+
   case expected
   when 'nil', 'true', 'false'
     expect(actual_value).send(expectation, eq(eval(expected)))

data/lib/pickle.rb

@@ -14,13 +14,13 @@ module Pickle
     def config
       @config ||= Config.new
     end
-    
+
     def configure(&block)
       config.configure(&block)
     end
-  
+
     def parser(options = {})
       @parser ||= Parser.new({:config => config}.merge(options))
     end
   end
-end
+end

data/lib/pickle/adapter.rb

@@ -70,7 +70,7 @@ module Pickle
       def find_all_models(klass, conditions)
         klass.const_get(:PickleAdapter).find_all_models(klass, conditions)
       end
-      
+
       def create_model(klass, attributes)
         klass.const_get(:PickleAdapter).create_model(klass, attributes)
       end
@@ -104,16 +104,20 @@ module Pickle
       def self.factories
         if defined? ::FactoryGirl
           factories = []
-          ::FactoryGirl.factories.each {|v| factories << new(v)}
+          ::FactoryGirl.factories.each do |factory|
+            factory.names.each do |name|
+              factories << new(factory, name)
+            end
+          end
           factories
         else
           (::Factory.factories.values rescue []).map {|factory| new(factory)}
         end
       end
 
-      def initialize(factory)
+      def initialize(factory, factory_name)
         if defined? ::FactoryGirl
-          @klass, @name = factory.build_class, factory.name.to_s
+          @klass, @name = factory.build_class, factory_name.to_s
         else
           @klass, @name = factory.build_class, factory.factory_name.to_s
         end
@@ -126,6 +130,14 @@ module Pickle
           Factory(@name, attrs)
         end
       end
+
+      def build(attrs = {})
+        if defined? ::FactoryGirl
+          ::FactoryGirl.build(@name, attrs)
+        else
+          Factory.build(@name, attrs)
+        end
+      end
     end
 
     # fabrication adapter

data/lib/pickle/adapters/active_record.rb

@@ -18,10 +18,10 @@ class ActiveRecord::Base
 
     # Gets a list of the available models for this adapter
     def self.model_classes
-      begin
-        klasses = ::ActiveRecord::Base.__send__(:descendants) # Rails 3
-      rescue
-        klasses = ::ActiveRecord::Base.__send__(:subclasses) # Rails 2
+      if ::ActiveRecord::Base.respond_to?(:descendants)
+        klasses = ::ActiveRecord::Base.descendants  # Rails 3, 4
+      else
+        klasses = ::ActiveRecord::Base.subclasses   # Rails 2
       end
 
       klasses.select do |klass|
@@ -41,14 +41,24 @@ class ActiveRecord::Base
 
     # Find the first instance matching conditions
     def self.find_first_model(klass, conditions)
-      klass.find(:first, :conditions => conditions)
+      if defined? ::ActiveRecord::Relation
+        klass.where(conditions).first           # Rails 3, 4
+      else
+        klass.find(:first,
+                   :conditions => conditions)   # Rails 2
+      end
     end
 
     # Find all models matching conditions
     def self.find_all_models(klass, conditions)
-      klass.find(:all, :conditions => conditions)
+      if defined? ::ActiveRecord::Relation
+        klass.where(conditions)                 # Rails 3, 4
+      else
+        klass.find(:all,
+                   :conditions => conditions)   # Rails 2
+      end
     end
-    
+
     # Create a model using attributes
     def self.create_model(klass, attributes)
       klass.create!(attributes)

data/lib/pickle/adapters/data_mapper.rb

@@ -33,7 +33,7 @@ module DataMapper::Resource
     def self.find_all_models(klass, conditions)
       klass.all(conditions)
     end
-    
+
     # Create a model using attributes
     def self.create_model(klass, attributes)
       klass.create(attributes)

data/lib/pickle/adapters/mongoid.rb

@@ -12,7 +12,9 @@ module Mongoid
 
       # Gets a list of the available models for this adapter
       def self.model_classes
-        ObjectSpace.each_object(Class).to_a.select {|klass| klass.ancestors.include? Mongoid::Document}
+        ObjectSpace.each_object(Class).to_a.select do |klass|
+          klass.name && klass.ancestors.include?(Mongoid::Document)
+        end
       end
 
       # get a list of column names for a given class
@@ -27,12 +29,20 @@ module Mongoid
 
       # Find the first instance matching conditions
       def self.find_first_model(klass, conditions)
-        klass.first(:conditions => conditions)
+        if defined? ::Mongoid::Criteria
+          klass.where(conditions).first
+        else
+          klass.first(:conditions => conditions)
+        end
       end
 
       # Find all models matching conditions
       def self.find_all_models(klass, conditions)
-        klass.all(:conditions => conditions)
+        if defined? ::Mongoid::Criteria
+          klass.where(conditions).to_a
+        else
+          klass.all(:conditions => conditions)
+        end
       end
 
       # Create a model with given attributes

data/lib/pickle/config.rb

@@ -1,29 +1,29 @@
 module Pickle
   class Config
     attr_writer :adapters, :factories, :mappings, :predicates
-    
+
     def initialize(&block)
       configure(&block) if block_given?
     end
-    
+
     def configure(&block)
       yield(self)
     end
-    
+
     def adapters
       @adapters ||= [:machinist, :factory_girl, :fabrication, :orm]
     end
-    
+
     def adapter_classes
       adapters.map {|a| a.is_a?(Class) ? a : "pickle/adapter/#{a}".classify.constantize}
     end
-    
+
     def factories
       @factories ||= adapter_classes.reverse.inject({}) do |factories, adapter|
         factories.merge(adapter.factories.inject({}){|h, f| h.merge(f.name => f)})
       end
     end
-    
+
     def predicates
       @predicates ||= Pickle::Adapter.model_classes.map do |k|
         k.public_instance_methods.select {|m| m =~ /\?$/} + Pickle::Adapter.column_names(k)
@@ -32,11 +32,11 @@ module Pickle
 
     class Mapping < Struct.new(:search, :replacement)
     end
-    
+
     def mappings
       @mappings ||= []
     end
-    
+
     # Usage: map 'me', 'myself', 'I', :to => 'user: "me"'
     def map(*args)
       options = args.extract_options!

data/lib/pickle/email.rb

@@ -31,7 +31,7 @@ module Pickle
   protected
     def open_in_browser(path) # :nodoc
       require "launchy"
-      Launchy::Browser.run(path)
+      Launchy.open(path)
     rescue LoadError
       warn "Sorry, you need to install launchy to open emails: `gem install launchy`"
     end
@@ -64,13 +64,23 @@ module Pickle
 
     # e.g. Click here in  <a href="http://confirm">Click here</a>
     def parse_email_for_anchor_text_link(email, link_text)
-      if match_data = email.body.match(%r{<a[^>]*href=['"]?([^'"]*)['"]?[^>]*?>[^<]*?#{link_text}[^<]*?</a>})
+      if email.multipart?
+        body = email.html_part.body
+      else
+        body = email.body
+      end
+      if match_data = body.match(%r{<a[^>]*href=['"]?([^'"]*)['"]?[^>]*?>[^<]*?#{link_text}[^<]*?</a>})
         match_data[1]
       end
     end
 
     def links_in_email(email, protos=['http', 'https'])
-      URI.extract(email.body.to_s, protos)
+      if email.multipart?
+        body = email.html_part.body
+      else
+        body = email.body
+      end
+      URI.extract(body.to_s, protos)
     end
 
   end

data/lib/pickle/email/parser.rb

@@ -9,10 +9,10 @@ module Pickle
       def capture_email
         "(#{match_email})"
       end
-      
+
       def capture_index_in_email
         "(?:#{match_prefix}?(?:#{capture_index} )?email)"
       end
     end
   end
-end
+end

data/lib/pickle/parser.rb

@@ -3,13 +3,13 @@ require 'pickle/parser/matchers'
 module Pickle
   class Parser
     include Matchers
-    
+
     attr_reader :config
-    
+
     def initialize(options = {})
       @config = options[:config] || raise(ArgumentError, "Parser.new requires a :config")
     end
-    
+
     # given a string like 'foo: "bar", bar: "baz"' returns {"foo" => "bar", "bar" => "baz"}
     def parse_fields(fields)
       if fields.blank?
@@ -19,10 +19,10 @@ module Pickle
           m.merge(parse_field(match[0]))
         end
       else
-        raise ArgumentError, "The fields string is not in the correct format.\n\n'#{fields}' did not match: #{match_fields}" 
+        raise ArgumentError, "The fields string is not in the correct format.\n\n'#{fields}' did not match: #{match_fields}"
       end
     end
-    
+
     # given a string like 'foo: expr' returns {key => value}
     def parse_field(field)
       if field =~ /^#{capture_key_and_value_in_field}$/
@@ -31,12 +31,12 @@ module Pickle
         raise ArgumentError, "The field argument is not in the correct format.\n\n'#{field}' did not match: #{match_field}"
       end
     end
-    
+
     # returns really underscored name
     def canonical(str)
       str.to_s.underscore.gsub(' ','_').gsub('/','_')
     end
-    
+
     # return [factory_name, name or integer index]
     def parse_model(model_name)
       apply_mappings!(model_name)
@@ -46,7 +46,7 @@ module Pickle
         [canonical($1), canonical($2)]
       end
     end
-  
+
     def parse_index(index)
       case index
       when nil, '', 'last' then -1
@@ -62,4 +62,4 @@ module Pickle
       end
     end
   end
-end
+end

data/lib/pickle/parser/matchers.rb

@@ -4,19 +4,19 @@ module Pickle
       def match_ordinal
         '(?:\d+(?:st|nd|rd|th))'
       end
-  
+
       def match_index
         "(?:first|last|#{match_ordinal})"
       end
-  
+
       def match_prefix
         '(?:(?:a|an|another|the|that) )'
       end
-  
+
       def match_quoted
         '(?:\\\\"|[^\\"]|\\.)*'
       end
-  
+
       def match_label
         "(?::? \"#{match_quoted}\")"
       end
@@ -28,60 +28,60 @@ module Pickle
       def match_field
         "(?:\\w+: #{match_value})"
       end
-  
+
       def match_fields
         "(?:#{match_field}, )*#{match_field}"
       end
-  
+
       def match_mapping
         "(?:#{config.mappings.map(&:search).join('|')})"
       end
-  
+
       def match_factory
         "(?:#{config.factories.keys.map{|n| n.gsub('_','[_ ]')}.join('|')})"
       end
-      
+
       def match_plural_factory
         "(?:#{config.factories.keys.map{|n| n.pluralize.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
-  
+
       def match_predicate
         "(?:#{config.predicates.map{|m| m.to_s.sub(/^has_/,'').sub(/\?$/,'').gsub('_','[_ ]')}.join('|')})"
       end
-      
+
       # create capture analogues of match methods
       instance_methods.select{|m| m =~ /^match_/}.each do |method|
-        eval <<-end_eval                   
+        eval <<-end_eval
           def #{method.to_s.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+): #{capture_value})"
       end
     end
   end
-end
+end