spbtv_pickle 0.5.1

data/spec/pickle/config_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Pickle::Config do
+  before do
+    @config = Pickle::Config.new
+  end
+
+  it "#adapters should default to :machinist, :factory_girl, :orm" do
+    expect(@config.adapters).to eq([:machinist, :factory_girl, :fabrication, :orm])
+  end
+
+  it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::Orm" do
+    expect(@config.adapter_classes).to eq([Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::Fabrication, Pickle::Adapter::Orm])
+  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
+      expect(@config.adapter_classes).to eq([Pickle::Adapter::Machinist, SomeAdapter])
+    end
+  end
+
+  describe "#factories" do
+    it "should call adaptor.factories for each adaptor" do
+      expect(Pickle::Adapter::Machinist).to receive(:factories).and_return([])
+      expect(Pickle::Adapter::FactoryGirl).to receive(:factories).and_return([])
+      expect(Pickle::Adapter::Fabrication).to receive(:factories).and_return([])
+      expect(Pickle::Adapter::Orm).to receive(:factories).and_return([])
+      @config.factories
+    end
+
+    it "should aggregate factories into a hash using factory name as key" do
+      expect(Pickle::Adapter::Machinist).to receive(:factories).and_return([@machinist = double('machinist', :name => 'machinist')])
+      expect(Pickle::Adapter::FactoryGirl).to receive(:factories).and_return([@factory_girl = double('factory_girl', :name => 'factory_girl')])
+      expect(Pickle::Adapter::Fabrication).to receive(:factories).and_return([@fabrication = double('fabrication', :name => 'fabrication')])
+      expect(Pickle::Adapter::Orm).to receive(:factories).and_return([@orm = double('orm', :name => 'orm')])
+      expect(@config.factories).to eq({'machinist' => @machinist, 'factory_girl' => @factory_girl, 'fabrication' => @fabrication, 'orm' => @orm})
+    end
+
+    it "should give preference to adaptors first in the list" do
+      expect(Pickle::Adapter::Machinist).to receive(:factories).and_return([@machinist_one = double('one', :name => 'one')])
+      expect(Pickle::Adapter::FactoryGirl).to receive(:factories).and_return([@factory_girl_one = double('one', :name => 'one'), @factory_girl_two = double('two', :name => 'two')])
+      expect(Pickle::Adapter::Fabrication).to receive(:factories).and_return([@fabrication_one = double('one', :name => 'one'), @fabrication_three = double('three', :name => 'three')])
+      expect(Pickle::Adapter::Orm).to receive(:factories).and_return([@orm_two = double('two', :name => 'two'), @orm_four = double('four', :name => 'four')])
+      expect(@config.factories).to eq({'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @fabrication_three, 'four' => @orm_four})
+    end
+  end
+
+  it "#mappings should default to []" do
+    expect(@config.mappings).to eq([])
+  end
+
+  describe '#predicates' do
+    it "should be list of all non object ? public instance methods + columns methods of Adapter.model_classes" do
+      class1 = double('Class1',
+                    :public_instance_methods => ['nope', 'foo?', 'bar?'],
+                    :column_names => ['one', 'two'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
+      class2 = double('Class2',
+                    :public_instance_methods => ['not', 'foo?', 'faz?'],
+                    :column_names => ['two', 'three'],
+                    :const_get => ::ActiveRecord::Base::PickleAdapter
+      )
+      allow(Pickle::Adapter).to receive(:model_classes).and_return([class1, class2])
+
+      expect(@config.predicates.to_set).to eq(['foo?', 'faz?', 'bar?', 'one', 'two', 'three'].to_set)
+    end
+
+    it "should be overridable" do
+      @config.predicates = %w(lame?)
+      expect(@config.predicates).to eq(%w(lame?))
+    end
+  end
+
+  describe "#map 'foo', :to => 'faz'" do
+    before do
+      @config.map 'foo', :to => 'faz'
+    end
+
+    it "should create Mapping('foo', 'faz') mapping" do
+      @config.mappings.first.tap do |mapping|
+        expect(mapping).to be_kind_of Pickle::Config::Mapping
+        expect(mapping.search).to eq('foo')
+        expect(mapping.replacement).to eq('faz')
+      end
+    end
+  end
+
+  describe "#map 'foo', 'bar' :to => 'faz'" do
+    before do
+      @config.map 'foo', 'bar', :to => 'faz'
+    end
+
+    it "should create 2 mappings" do
+      expect(@config.mappings.first).to eq(Pickle::Config::Mapping.new('foo', 'faz'))
+      expect(@config.mappings.last).to eq(Pickle::Config::Mapping.new('bar', 'faz'))
+    end
+  end
+
+  it "#configure(&block) should execiute on self" do
+    expect(@config).to receive(:foo).with(:bar)
+    @config.configure do |c|
+      c.foo :bar
+    end
+  end
+end

data/spec/pickle/email/parser_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+require 'pickle/email/parser'
+
+describe Pickle::Email::Parser do
+  include Pickle::Parser::Matchers
+  include Pickle::Email::Parser
+  
+  describe "#match_email" do
+    it "should match 'the email'" do
+      expect('the email').to match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the first email'" do
+      expect('the first email').to match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the last email'" do
+      expect('the last email').to match(/^#{match_email}$/)
+    end
+    
+    it "should match 'the 3rd email'" do
+      expect('the 3rd email').to match(/^#{match_email}$/)
+    end
+    
+    it "should match 'an email'" do
+      expect('an email').to match(/^#{match_email}$/)
+    end
+  end
+  
+  it "#capture_email should just capture match_email" do
+    expect(capture_email).to eq("(#{match_email})")
+  end
+  
+  describe "#capture_index_in_email" do
+    it "should extract the '2nd' from 'the 2nd email'" do
+      match = 'the 2nd email'.match(/^#{capture_index_in_email}$/)
+      expect(match[1]).to eq('2nd')
+    end
+    
+    it "should extract nil from 'the email'" do
+      match = 'the email'.match(/^#{capture_index_in_email}$/)
+      expect(match[1]).to eq(nil)
+    end
+    
+    it "should extract the 'last' from 'the last email'" do
+      match = 'the last email'.match(/^#{capture_index_in_email}$/)
+      expect(match[1]).to eq('last')
+    end
+  end
+end

data/spec/pickle/email_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+require 'pickle/email'
+require 'pickle/email/parser'
+require 'action_mailer'
+
+describe Pickle::Email do
+  include Pickle::Session
+  include Pickle::Email
+  include Pickle::Email::Parser
+
+  before do
+    @email1 = double("Email 1")
+    @email2 = double("Email 2")
+    allow(ActionMailer::Base).to receive(:deliveries).and_return([@email1, @email2])
+    if defined?(ActiveRecord::Base)
+      allow(ActiveRecord::Base::PickleAdapter).to receive(:model_classes).and_return([])
+    end
+  end
+
+  describe "#emails" do
+    it "should return ordered deliveries" do
+      expect(emails).to eq([@email1, @email2])
+    end
+
+    describe "(after)" do
+      before do
+        emails
+      end
+
+      it "#email('the email') should return the last delivery" do
+        expect(email('the email')).to eq(@email2)
+      end
+
+      it "#email('the 1st email') should return the first delivery" do
+        expect(email('the 1st email')).to eq(@email1)
+      end
+
+      it "#email('the first email') should return the first delivery" do
+        expect(email('the first email')).to eq(@email1)
+      end
+
+      it "#email('the 2nd email') should return the second delivery" do
+        expect(email('the 2nd email')).to eq(@email2)
+      end
+
+      it "#email('the last email') should return the second delivery" do
+        expect(email('the last email')).to eq(@email2)
+      end
+
+      it "#email2('the 3rd email') should be nil" do
+        expect(email('the 3rd email')).to eq(nil)
+      end
+    end
+
+    describe "when email1 is to fred & joe, and email2 is to joe" do
+      before do
+        allow(@email1).to receive(:to).and_return(['fred@gmail.com', 'joe@gmail.com'])
+        allow(@email2).to receive(:to).and_return('joe@gmail.com')
+      end
+
+      it "#emails('to: \"fred@gmail.com\"') should just return email1" do
+        expect(emails('to: "fred@gmail.com"')).to eq([@email1])
+      end
+
+      describe "after #emails('to: \"fred@gmail.com\"')" do
+        before do
+          emails('to: "fred@gmail.com"')
+        end
+
+        it "#email('first') should be #email('last')" do
+          expect(email('first email')).to eq(email('last email'))
+          expect(email('first email')).to eq(@email1)
+        end
+
+        it "#email('the email', 'to: \"blah\") should be nil" do
+          expect(email('the email', 'to: "blah"')).to eq(nil)
+        end
+
+        it "#email('the email', 'to: \"fred@gmail.com\") should be email1" do
+          expect(email('the email', 'to: "fred@gmail.com"')).to eq(@email1)
+        end
+      end
+
+      it "#emails('to: \"joe@gmail.com\"') should return both emails" do
+        expect(emails('to: "joe@gmail.com"')).to eq([@email1, @email2])
+      end
+
+      describe "and emails have subjects 'email1', 'email2'" do
+        before do
+          allow(@email1).to receive(:subject).and_return('email1')
+          allow(@email2).to receive(:subject).and_return('email2')
+        end
+
+        it "#emails('to: \"joe@gmail.com\", subject: \"email1\"') should return email1" do
+          expect(emails('to: "joe@gmail.com", subject: "email1"')).to eq([@email1])
+        end
+
+        it "#emails('to: \"fred@gmail.com\", subject: \"email2\"') should return empty array" do
+          expect(emails('to: "fred@gmail.com", subject: "email2"')).to eq([])
+        end
+      end
+    end
+  end
+
+  describe "#save_and_open_emails" do
+    before do
+      allow(self).to receive(:open_in_browser)
+      allow(self).to receive(:emails).and_return(["Contents of Email 1"])
+      @now = "2008-01-01".to_time
+      allow(Time).to receive(:now).and_return(@now)
+    end
+
+    it "should call #emails to get emails" do
+      expect(self).to receive(:emails).and_return([])
+      save_and_open_emails
+    end
+
+    describe "when emails have been already been found" do
+      before { @emails = [] }
+
+      it "should not call #emails" do
+        expect(self).not_to receive(:emails)
+        save_and_open_emails
+      end
+    end
+
+    it "should create a file in Rails/tmp with the emails in it" do
+      save_and_open_emails
+      expect(File.read("pickle-email-#{@now.to_i}.html")).to eq("<h1>Email 1</h1><pre>Contents of Email 1</pre><hr />")
+    end
+
+    it "should call open_in_browser on created tmp file" do
+      expect(self).to receive(:open_in_browser).with("pickle-email-#{@now.to_i}.html")
+      save_and_open_emails
+    end
+  end
+
+  describe "following links in emails" do
+    let(:body) { 'some text <a href="http://example.com/page">example page</a> more text' }
+
+    before do
+      allow(self).to receive(:open_in_browser)
+    end
+
+    shared_examples_for 'an email with links' do
+      it "should find a link for http://example.com/page" do
+        expect(self).to receive(:visit).with('http://example.com/page')
+        visit_in_email(@email1, 'http://example.com/page')
+      end
+
+      it "should find a link for \"example page\"" do
+        expect(self).to receive(:visit).with('http://example.com/page')
+        visit_in_email(@email1, 'example page')
+      end
+
+      it "should follow the first link in an email" do
+        expect(self).to receive(:visit).with('http://example.com/page')
+        click_first_link_in_email(@email1)
+      end
+
+      it "should not raise an error when the email body is not a string, but needs to_s [#26]" do
+        allow(self).to receive(:visit)
+        allow(@email1).to receive(:body).and_return(:a_string_body)
+        expect { click_first_link_in_email(@email1) }.not_to raise_error
+      end
+    end
+
+    describe "non multi-part emails" do
+      before do
+        allow(@email1).to receive(:multipart?).and_return(false)
+        allow(@email1).to receive(:body).and_return(body)
+      end
+
+      it_behaves_like 'an email with links'
+    end
+
+    context "multi-part emails" do
+      before do
+        allow(@email1).to receive(:multipart?).and_return(true)
+        allow(@email1).to receive_message_chain(:html_part, :body).and_return(body)
+      end
+
+      it_behaves_like 'an email with links'
+    end
+  end
+end

data/spec/pickle/parser/matchers_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Pickle::Parser::Matchers do
+  include Pickle::Parser::Matchers
+
+  describe "(config: [factories: user, car, fast_car] [predicates: name, status, fancy?, super_fancy?, has_style?, has_super_style?]" do
+    def config
+      @config ||= Pickle::Config.new do |c|
+        c.factories = {
+          'user'      => double('factory'),
+          'car'       => double('factory'),
+          'fast_car'  => double('factory')
+        }
+        c.predicates = %w(name status fancy? super_fancy? has_style? has_super_style?)
+      end
+    end
+  
+    describe "Match atoms" do
+      def self.atom_should_match(atom, strings)
+        Array(strings).each do |string|
+          it "#{atom} should match '#{string}'" do
+            expect(string).to 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
+            expect(string).not_to 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"', 'quoted_baz: "words \"in quotes\""', 'boolean: false', 'boolean: true', 'numeric: 10', 'numeric: 12.5', 'numeric: +10', 'numeric: +12.5', 'numeric: -10', 'numeric: -12.5', 'nil_field: nil']
+      atom_should_not_match :match_field, ['foo bar: "this aint workin"', 'not_numeric: --10', 'not_numeric: -ten']
+  
+      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', 'style', 'super style', 'super_style']
+      atom_should_not_match :match_predicate, ['nameo', 'increment', 'not a predicate', 'has style']
+    
+      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
+      expect(self).to receive(:match_field).and_return('MATCH_FIELD')
+      expect(capture_field).to eq('(MATCH_FIELD)')
+    end
+  end
+end

data/spec/pickle/parser_spec.rb

@@ -0,0 +1,165 @@
+require '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
+    expect{ Pickle::Parser.new }.to raise_error(ArgumentError)
+  end
+  
+  describe "when a 'user' factory exists in config" do
+    before do
+      allow(@parser.config).to receive(:factories).and_return('user' => double('User'))
+    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
+          expect('a user exists').to match(@regexp)
+        end
+      
+        it "should caputure 'a user' from  'a user exists'" do
+          expect('a user exists'.match(@regexp)[1]).to eq('a user')
+        end
+      end
+    end
+  
+    describe '#parse_field' do
+      it "should return {'a' => 'b'} for 'a: \"b\"'" do
+        expect(@parser.parse_field('a: "b"')).to eq({'a' => 'b'})
+      end
+  
+      it "should raise error for invalid field 'a : b'" do
+        expect { @parser.parse_field('a : b') }.to raise_error(ArgumentError)
+      end
+    end
+  
+    describe '#parse_fields' do
+      it 'should return {} for blank argument' do
+        expect(@parser.parse_fields(nil)).to eq({})
+        expect(@parser.parse_fields('')).to eq({})
+      end
+    
+      it 'should raise error for invalid argument' do
+        expect { @parser.parse_fields('foo foo') }.to raise_error(ArgumentError)
+      end
+    
+      it '(\'foo: "bar"\') should == { "foo" => "bar"}' do
+        expect(@parser.parse_fields('foo: "bar"')).to eq({ "foo" => "bar"})
+      end
+
+      it '(\'foo: "something \"quoted\""\') should == { "foo" => "bar"}' do
+        expect(@parser.parse_fields('foo: "something \"quoted\""')).to eq({ "foo" => 'something "quoted"' })
+      end
+    
+      it '("bool: true") should == { "bool" => true}' do
+        expect(@parser.parse_fields('bool: true')).to eq({"bool" => true})
+      end
+    
+      it '("bool: false") should == { "bool" => false}' do
+        expect(@parser.parse_fields('bool: false')).to eq({"bool" => false})
+      end
+    
+      it '("int: 10") should == { "int" => 10 }' do
+        expect(@parser.parse_fields('int: 10')).to eq({"int" => 10})
+      end
+
+      it '("float: 10.1") should == { "float" => 10.1 }' do
+        expect(@parser.parse_fields('float: 10.1')).to eq({"float" => 10.1})
+      end
+
+      it '(\'foo: "bar", bar_man: "wonga wonga", baz_woman: "one \"two\" three", gump: 123\') should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}' do
+        expect(@parser.parse_fields('foo: "bar", bar_man: "wonga wonga", baz_woman: "one \"two\" three", gump: 123')).to eq({"foo" => "bar", "bar_man" => "wonga wonga", "baz_woman" => "one \"two\" three", "gump" => 123})
+      end
+    end
+  
+    describe '#parse_model' do
+      it '("a user") should == ["user", ""]' do
+        expect(@parser.parse_model("a user")).to eq(["user", ""])
+      end
+  
+      it '("the user") should == ["user", ""]' do
+        expect(@parser.parse_model("the user")).to eq(["user", ""])
+      end
+  
+      it '("1 user") should == ["user", ""]' do
+        expect(@parser.parse_model("1 user")).to eq(["user", ""])
+      end
+    
+      it '(\'an user: "jim jones"\') should == ["user", "jim_jones"]' do
+        expect(@parser.parse_model('an user: "jim jones"')).to eq(["user", "jim_jones"])
+      end
+    
+      it '(\'that user: "herbie"\') should == ["user", "herbie"]' do
+        expect(@parser.parse_model('that user: "herbie"')).to eq(["user", "herbie"])
+      end
+    
+      it '(\'the 12th user\') should == ["user", 11]' do
+        expect(@parser.parse_model('the 12th user')).to eq(["user", 11])
+      end
+  
+      it '(\'the last user\') should == ["user", -1]' do
+        expect(@parser.parse_model('the last user')).to eq(["user", -1])
+      end
+    
+      it '("the first user") should == ["user", 0]' do
+        expect(@parser.parse_model('the first user')).to eq(["user", 0])
+      end
+  
+      it '("the 1st user") should == ["user", 0]' do
+        expect(@parser.parse_model('the 1st user')).to eq(["user", 0])
+      end
+    end
+  
+    describe "#parse_index" do
+      it '("1st") should == 0' do
+        expect(@parser.parse_index("1st")).to eq(0)
+      end
+  
+      it '("24th") should == 23' do
+        expect(@parser.parse_index("24th")).to eq(23)
+      end
+      it '("first") should == 0' do
+        expect(@parser.parse_index("first")).to eq(0)
+      end
+    
+      it '("last") should == -1' do
+        expect(@parser.parse_index("last")).to eq(-1)
+      end
+    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)
+        allow(@parser.config).to receive(:factories).and_return('user' => double('User'))
+      end
+
+      it "'I' should match /\#{match_model}/" do
+        expect('I').to match(/#{@parser.match_model}/)
+      end
+  
+      it "'myself' should match /\#{match_model}/" do
+        expect('myself').to match(/#{@parser.match_model}/)
+      end
+  
+      it "parse_model('I') should == ['user', 'me']" do
+        expect(@parser.parse_model('I')).to eq(["user", "me"])
+      end
+
+      it "parse_model('myself') should == ['user', 'me']" do
+        expect(@parser.parse_model('myself')).to eq(["user", "me"])
+      end
+    end
+  end
+end