spigot 0.2.2 → 0.3.0

data/spec/spigot/translator_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 
 describe Spigot::Translator do
   context '#initialize' do
-    before{ Spigot::Mapping::User.basic }
+    before { Spigot::Mapping::User.basic }
     it 'does not require a service' do
-      expect{
+      expect {
         Spigot::Translator.new(Struct, nil)
       }.to_not raise_error(Spigot::InvalidServiceError)
     end
 
     it 'requires a resource' do
-      expect{
+      expect {
         Spigot::Translator.new(nil, :github)
       }.to raise_error(Spigot::InvalidResourceError)
     end
@@ -22,20 +22,11 @@ describe Spigot::Translator do
     end
   end
 
-  context '.id' do
-    let(:subject){ Spigot::Translator.new(User.new, :github, Spigot::Data::User.basic) }
-    before{ Spigot::Mapping::User.basic }
-    it 'returns the value at the foreign_key' do
-      subject.stubs(:foreign_key).returns('id')
-      subject.id.should eq('123')
-    end
-  end
-
   context '.format' do
     context 'with a missing resource map' do
-      let(:subject){ Spigot::Translator.new(User.new, :github, Spigot::Data::User.basic) }
+      let(:subject) { Spigot::Translator.new(User.new, :github, Spigot::Data::User.basic) }
       it 'raises error with a missing resource map' do
-        expect{
+        expect {
           subject.format
         }.to raise_error(Spigot::MissingResourceError)
       end
@@ -43,23 +34,23 @@ describe Spigot::Translator do
 
     context 'with a valid resource map' do
       context 'with a simple map' do
-        let(:data){ Spigot::Data::User.basic }
-        let(:subject){ Spigot::Translator.new(User.new, :github, data) }
-        before{ Spigot::Mapping::User.basic }
+        let(:data) { Spigot::Data::User.basic }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        before { Spigot::Mapping::User.basic }
         it 'returns empty hash from nil data' do
           subject.data = {}
-          expect(subject.format).to eq({name: nil, username: nil})
+          expect(subject.format).to eq(name: nil, username: nil)
         end
 
         it 'reads one layer' do
-          expect(subject.format).to eq({name: 'Dean Martin', username: 'classyasfuck'})
+          expect(subject.format).to eq(name: 'Dean Martin', username: 'classyasfuck')
         end
       end
 
       context 'with a nested map' do
-        let(:data){ Spigot::Data::User.nested }
-        let(:subject){ Spigot::Translator.new(User.new, :github, data) }
-        before{ Spigot::Mapping::User.nested }
+        let(:data) { Spigot::Data::User.nested }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        before { Spigot::Mapping::User.nested }
 
         it 'traverses into the nested hash' do
           expect(subject.format).to eq({
@@ -70,15 +61,15 @@ describe Spigot::Translator do
         end
       end
 
-      context "nested twice" do
-        let(:data){Spigot::Data::User.double_nested}
-        let(:subject){Spigot::Translator.new(User.new, :github, data)}
-        before{ Spigot::Mapping::User.nested_twice }
+      context 'nested twice' do
+        let(:data) { Spigot::Data::User.double_nested }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        before { Spigot::Mapping::User.nested_twice }
 
         it 'traverses multiple levels' do
           expect(subject.format).to eq({
             name: 'Dean Martin',
-            ip: "127.0.0.1",
+            ip: '127.0.0.1',
             username: 'classyasfuck',
             contact: 'dino@amore.io'
           })
@@ -86,36 +77,39 @@ describe Spigot::Translator do
       end
 
       context 'with an array of values' do
-        let(:data){Spigot::Data::User.array}
-        let(:subject){Spigot::Translator.new(User.new, :github, data)}
-        before{ Spigot::Mapping::User.basic }
+        let(:data) { Spigot::Data::User.array }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        before { Spigot::Mapping::User.basic }
 
         it 'returns an array of formatted data' do
           subject.format.should eq([
-            {name: "Dean Martin", username: "classyasfuck"},
-            {name: "Frank Sinatra", username: "livetilidie"}
+            { name: 'Dean Martin', username: 'classyasfuck' },
+            { name: 'Frank Sinatra', username: 'livetilidie' }
           ])
         end
       end
 
       context 'with a nested array of values' do
-        let(:data){ Spigot::Data::User.nested_array }
-        let(:subject){Spigot::Translator.new(User.new, :github, data)}
-        before{ Spigot::Mapping::User.nested_array }
+        let(:data) { Spigot::Data::User.nested_array }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        before { Spigot::Mapping::User.nested_array }
 
         it 'handles a nested array of values' do
           subject.format.should eq({
             name: 'Rockafella',
             user_count: 2,
-            users: [{name: "Dean Martin", username: "classyasfuck"}, {name: "Frank Sinatra", username: "livetilidie"}]
+            users: [
+              { name: 'Dean Martin', username: 'classyasfuck' },
+              { name: 'Frank Sinatra', username: 'livetilidie' }
+            ]
           })
         end
       end
 
       context 'with a namedspaced resource' do
-        let(:data){ Spigot::Data::Post.basic }
-        let(:subject){Spigot::Translator.new(Wrapper::Post.new, :github, data)}
-        before{ Spigot::Mapping::Post.basic }
+        let(:data) { Spigot::Data::Post.basic }
+        let(:subject) { Spigot::Translator.new(Wrapper::Post.new, :github, data) }
+        before { Spigot::Mapping::Post.basic }
 
         it 'accesses the wrapper/post key' do
           subject.format.should eq({
@@ -126,29 +120,30 @@ describe Spigot::Translator do
       end
 
       context 'with an interpolated value' do
-        let(:data){ Spigot::Data::User.basic }
-        let(:subject){ Spigot::Translator.new(User.new, :github, data) }
-        before{ Spigot::Mapping::User.interpolated }
+        let(:data) { Spigot::Data::User.basic }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        before { Spigot::Mapping::User.interpolated }
         it 'reads one layer' do
-          expect(subject.format).to eq({name: 'Dean Martin', username: '@classyasfuck'})
+          expect(subject.format).to eq(name: 'Dean Martin', username: '@classyasfuck')
         end
       end
 
       context 'with a nested interpolated value' do
-        let(:data){ Spigot::Data::User.nested }
-        let(:subject){ Spigot::Translator.new(User.new, :github, data) }
-        before{ Spigot::Mapping::User.nested_interpolation }
+        let(:data) { Spigot::Data::User.nested }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        before { Spigot::Mapping::User.nested_interpolation }
         it 'reads one layer' do
-          expect(subject.format).to eq({name: 'Dean Martin', contact: 'dino@amore.io', username: '@classyasfuck'})
+          result = { name: 'Dean Martin', contact: 'dino@amore.io', username: '@classyasfuck' }
+          expect(subject.format).to eq(result)
         end
       end
 
       context 'without a service' do
-        let(:data){ Spigot::Data::User.basic }
-        let(:subject){ Spigot::Translator.new(User.new, nil, data) }
-        before{ Spigot::Mapping::User.serviceless }
+        let(:data) { Spigot::Data::User.basic }
+        let(:subject) { Spigot::Translator.new(User.new, nil, data) }
+        before { Spigot::Mapping::User.serviceless }
         it 'reads one layer' do
-          expect(subject.format).to eq({name: 'Dean Martin', username: 'classyasfuck'})
+          expect(subject.format).to eq(name: 'Dean Martin', username: 'classyasfuck')
         end
 
         it 'does not use the any definition with an invalid service' do
@@ -160,96 +155,100 @@ describe Spigot::Translator do
       end
 
       context 'multiple resources without a service' do
-        before{ Spigot::Mapping::User.multiple_serviceless }
+        before { Spigot::Mapping::User.multiple_serviceless }
         it 'reads one layer' do
           user = Spigot::Translator.new(User.new, nil, Spigot::Data::User.basic)
           post = Spigot::Translator.new(Post.new, nil, Spigot::Data::Post.basic)
 
-          expect(user.format).to eq({name: 'Dean Martin', username: 'classyasfuck'})
-          expect(post.format).to eq({headline: 'Brief Article', body: 'lorem ipsum'})
+          expect(user.format).to eq(name: 'Dean Martin', username: 'classyasfuck')
+          expect(post.format).to eq(headline: 'Brief Article', body: 'lorem ipsum')
         end
       end
 
       context 'with and without service' do
-        before{ Spigot::Mapping::User.service_and_serviceless }
+        before { Spigot::Mapping::User.service_and_serviceless }
         it 'prefers the service definition' do
           service = Spigot::Translator.new(User.new, :github, Spigot::Data::User.basic)
           no_service = Spigot::Translator.new(User.new, nil, Spigot::Data::User.basic)
 
-          expect(service.format).to eq({name: 'classyasfuck', username: 'Dean Martin'})
-          expect(no_service.format).to eq({name: 'Dean Martin', username: 'classyasfuck'})
+          expect(service.format).to eq(name: 'classyasfuck', username: 'Dean Martin')
+          expect(no_service.format).to eq(name: 'Dean Martin', username: 'classyasfuck')
         end
       end
 
       context 'with an abridged definition' do
-        let(:data){ Spigot::Data::User.basic }
-        let(:subject){ Spigot::Translator.new(User.new, nil, data) }
-        before{ Spigot::Mapping::User.abridged }
+        let(:data) { Spigot::Data::User.basic }
+        let(:subject) { Spigot::Translator.new(User.new, nil, data) }
+        before { Spigot::Mapping::User.abridged }
         it 'reads one layer' do
-          expect(subject.format).to eq({name: 'Dean Martin', username: 'classyasfuck'})
+          expect(subject.format).to eq(name: 'Dean Martin', username: 'classyasfuck')
         end
       end
     end
   end
 
-  context '#lookup' do
-    let(:subject){Spigot::Translator.new(User.new, :github, {a: '1'})}
-
-    it 'returns the value at a given key' do
-      subject.lookup(:a).should eq('1')
-    end
-  end
-
   context '#conditions' do
-    let(:data){ Spigot::Data::User.basic }
-    let(:subject){Spigot::Translator.new(User.new, :github, data)}
+    let(:data) { Spigot::Data::User.basic }
+    let(:subject) { Spigot::Translator.new(User.new, :github, data) }
 
     context 'without conditions specified' do
-      before{ Spigot::Mapping::User.basic }
+      before { Spigot::Mapping::User.basic }
       it 'should return a hash' do
-        subject.conditions.should eq({'github_id' => nil})
+        subject.conditions.should eq('github_id' => nil)
       end
     end
 
     context 'with conditions specified' do
-      before{ Spigot::Mapping::User.with_conditions }
+      before { Spigot::Mapping::User.with_conditions }
       it 'can specify the keys used in the map options' do
-        subject.conditions.should eq({username: "classyasfuck"})
+        subject.conditions.should eq(username: 'classyasfuck')
       end
 
       it 'can specify only one key' do
-        subject.conditions.should eq({username: "classyasfuck"})
+        subject.conditions.should eq(username: 'classyasfuck')
+      end
+
+      context 'with an array of data' do
+        let(:data) { Spigot::Data::User.array }
+        let(:subject) { Spigot::Translator.new(User.new, :github, data) }
+        it 'can specify an array of values' do
+          subject.conditions.should eq(username: %w(classyasfuck livetilidie))
+        end
       end
     end
   end
 
   context '#options' do
-    let(:subject){ Spigot::Translator.new(User.new, :github, {remote_id: '987'}) }
+    let(:subject) { Spigot::Translator.new(User.new, :github, remote_id: '987') }
 
     context 'without options provided' do
-      before{ Spigot::Mapping::User.basic }
+      before { Spigot::Mapping::User.basic }
       it '#primary_key is the name of the service_id' do
         subject.primary_key.should eq('github_id')
       end
-
-      it '#foreign_key is id' do
-        subject.foreign_key.should eq('id')
-      end
     end
 
     context 'with options provided' do
-      before{ Spigot::Mapping::User.with_options }
+      before { Spigot::Mapping::User.with_options }
       it 'reads a primary key from the mapping' do
         subject.primary_key.should eq(:username)
       end
 
-      it 'reads a foreign key from the mapping' do
-        subject.foreign_key.should eq(:login)
-      end
-
       it 'reads options' do
         subject.options.should be_a_kind_of(Spigot::Map::Option)
       end
     end
   end
+
+  context '#resource_map' do
+    let(:subject) { Spigot::Translator.new(User.new) }
+    context 'without a service' do
+      before { Spigot::Mapping::User.basic }
+      it 'raises a missing resource error' do
+        expect {
+          subject.resource_map
+        }.to raise_error(Spigot::MissingResourceError)
+      end
+    end
+  end
 end

data/spigot.gemspec

@@ -9,21 +9,20 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Matthew Werner"]
   spec.email         = ["m@mjw.io"]
   spec.description   = %q{Spigot provides a clean interface translating API data into context relevant objects}
-  spec.summary       = spec.description
-  spec.homepage      = "http://github.com/mwerner/spigot"
+  spec.summary       = 'Spigot is a tool to parse and format data for the creation of ruby objects'
+  spec.homepage      = "http://mwerner.github.io/spigot/"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   spec.test_files    = Dir.glob("spec/**/*")
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'activerecord'
+  spec.add_dependency 'activerecord', '~> 3.0'
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "hashie"
-  spec.add_development_dependency "simplecov"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "mocha"
-  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "bundler",   '~> 1.3'
+  spec.add_development_dependency "rake",      '~> 10.0'
+  spec.add_development_dependency "hashie",    '~> 2.0'
+  spec.add_development_dependency "simplecov", '~> 0.7'
+  spec.add_development_dependency "rspec",     '~> 2.13'
+  spec.add_development_dependency "sqlite3",   '~> 1.3'
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: spigot
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Matthew Werner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-11 00:00:00.000000000 Z
+date: 2014-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -42,86 +42,72 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.13'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 description: Spigot provides a clean interface translating API data into context relevant
   objects
 email:
@@ -137,10 +123,10 @@ files:
 - Rakefile
 - examples/active_record.rb
 - examples/model.rb
+- examples/multi_resource.rb
 - lib/spigot.rb
 - lib/spigot/active_record.rb
 - lib/spigot/base.rb
-- lib/spigot/config/spigot/github.yml
 - lib/spigot/configuration.rb
 - lib/spigot/errors.rb
 - lib/spigot/map/base.rb
@@ -153,6 +139,7 @@ files:
 - lib/spigot/record.rb
 - lib/spigot/translator.rb
 - lib/spigot/version.rb
+- script/active_record.rb
 - script/console.rb
 - spec/fixtures/data/active_user.rb
 - spec/fixtures/data/post.rb
@@ -168,13 +155,13 @@ files:
 - spec/spigot/map/definition_spec.rb
 - spec/spigot/map/resource_spec.rb
 - spec/spigot/map/service_spec.rb
+- spec/spigot/patch_spec.rb
 - spec/spigot/proxy_spec.rb
 - spec/spigot/record_spec.rb
 - spec/spigot/spigot_spec.rb
 - spec/spigot/translator_spec.rb
-- spec/support/active_record.rb
 - spigot.gemspec
-homepage: http://github.com/mwerner/spigot
+homepage: http://mwerner.github.io/spigot/
 licenses:
 - MIT
 metadata: {}
@@ -194,11 +181,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
-summary: Spigot provides a clean interface translating API data into context relevant
-  objects
+summary: Spigot is a tool to parse and format data for the creation of ruby objects
 test_files:
 - spec/fixtures/data/active_user.rb
 - spec/fixtures/data/post.rb
@@ -214,8 +200,8 @@ test_files:
 - spec/spigot/map/definition_spec.rb
 - spec/spigot/map/resource_spec.rb
 - spec/spigot/map/service_spec.rb
+- spec/spigot/patch_spec.rb
 - spec/spigot/proxy_spec.rb
 - spec/spigot/record_spec.rb
 - spec/spigot/spigot_spec.rb
 - spec/spigot/translator_spec.rb
-- spec/support/active_record.rb