spigot 0.1.0 → 0.2.0

data/spec/spigot/map/definition_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Spigot::Map::Definition do
+  let(:resource){Spigot::Map::Resource.new(:user)}
+
+  context '#initialize' do
+    it 'assigns variables' do
+      subject = Spigot::Map::Definition.new(:foo, 'bar')
+      subject.instance_variable_get(:@name).should_not be_nil
+      subject.instance_variable_get(:@value).should_not be_nil
+    end
+
+    context '#with a block' do
+      it 'assigns parse' do
+        subject = Spigot::Map::Definition.new(:foo, 'bar'){'baz'}
+        subject.instance_variable_get(:@parse).should_not be_nil
+      end
+    end
+  end
+
+  context '#define' do
+
+    it 'returns a definition with the given key and value' do
+      subject = Spigot::Map::Definition.define(resource, :foo, 'bar')
+      subject.instance_variable_get(:@name).should eq(:foo)
+      subject.instance_variable_get(:@value).should eq('bar')
+    end
+
+    it 'accepts a block of definitions' do
+      subject = Spigot::Map::Definition.define(resource, :foo) do
+        bar :baz
+        qux :mjw
+      end
+      subject.instance_variable_get(:@parse).should be_nil
+      subject.instance_variable_get(:@children).length.should eq(2)
+    end
+
+    it 'assigns a parse block' do
+      subject = Spigot::Map::Definition.define(resource, :foo){|val| "formatted-#{val}" }
+      subject.instance_variable_get(:@parse).should_not be_nil
+      subject.instance_variable_get(:@children).length.should eq(0)
+    end
+  end
+
+end

data/spec/spigot/map/resource_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Spigot::Map::Resource do
+  let(:subject){Spigot::Map::Resource.new(:user){ username :login }}
+
+  context '#initialize' do
+    it 'assigns a name' do
+      subject.instance_variable_get(:@name).should eq(:user)
+    end
+
+    it 'does not require a block' do
+      expect{
+        Spigot::Map::Resource.new(:user)
+      }.to_not raise_error(ArgumentError)
+    end
+
+    it 'builds definitions included in block' do
+      Spigot::Map::Definition.should_receive(:define)
+      subject #=> Evaluate the let statement
+    end
+  end
+
+  context '#method_missing' do
+    before do
+      subject
+      Spigot::Map::Definition.should_receive(:define)
+    end
+
+    it 'builds a definition for missing methods' do
+      subject.username :login
+    end
+
+    it 'allows for assignment' do
+      subject.username = :login
+    end
+  end
+
+  context '.options' do
+    let(:subject){Spigot::Map::Resource.new(:user){ options{ primary_key :foo } }}
+
+    it 'sets the options' do
+      options = subject.instance_variable_get(:@options)
+      options.primary_key.should eq(:foo)
+    end
+  end
+
+  context '.to_hash' do
+    it 'returns a hash of resources' do
+      subject.to_hash.should be_a_kind_of(Hash)
+    end
+
+    it 'returns the resource values' do
+      subject.to_hash[:user][:username].should eq(:login)
+    end
+  end
+
+end

data/spec/spigot/map/service_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Spigot::Map::Service do
+  let(:klass){ Spigot::Map::Service }
+  let(:subject){ klass.new(:github) }
+
+  before{ Spigot::Map::Base.new }
+
+  context '#initialize' do
+    it 'assigns a name' do
+      subject.name.should eq(:github)
+    end
+
+    it 'initializes an empty array of resources' do
+      subject.resources.should eq([])
+    end
+  end
+
+  context '#service' do
+    it 'works with a block' do
+      Spigot::Map::Service.should_receive(:new).with(:github)
+
+      klass.service(:github){'foo'}
+    end
+
+    it 'works without a block' do
+      Spigot::Map::Service.should_receive(:new).with(:github)
+      expect{
+        klass.service(:github)
+      }.to_not raise_error(ArgumentError)
+    end
+
+    it 'adds the created service to the current map' do
+      Spigot.config.map.should_receive(:update)
+      klass.service(:github)
+    end
+
+    context 'duplicate services' do
+      let(:service){Spigot::Map::Service.new(:github)}
+      before do
+        Spigot.config.map.update(:github, service)
+      end
+
+      it 'uses an existing service if already defined' do
+        service.should_receive(:instance_eval)
+        Spigot.config.map.should_receive(:update).with(:github, service)
+        klass.service(:github){'foo'}
+      end
+
+      it 'does not duplicate services' do
+        klass.service(:github)
+        Spigot.config.map.services.length.should eq(1)
+      end
+    end
+  end
+
+  context '.resource' do
+    it 'builds a resource' do
+      Spigot::Map::Resource.should_receive(:new).with(:user)
+      subject.resource(:user){'foo'}
+    end
+
+    it 'does not require a block' do
+      expect{
+        subject.resource(:user)
+      }.to_not raise_error(ArgumentError)
+    end
+  end
+
+  context '.reset' do
+    it 'resets the resources' do
+      subject.resource(:user)
+      expect{
+        subject.reset
+      }.to change{subject.resources.length}.by(-1)
+    end
+  end
+
+  context '.[]' do
+    it 'returns the resource by name' do
+      subject.resource(:user)
+      user = subject[:user]
+      user.should be_a_kind_of(Spigot::Map::Resource)
+      user.instance_variable_get(:@name).should eq(:user)
+    end
+  end
+
+end

data/spec/spigot/translator_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Spigot::Translator do
-
   context '#initialize' do
+    before{ Spigot::Mapping::User.basic }
     it 'requires a service' do
       expect{
         Spigot::Translator.new(nil, Struct)
@@ -22,22 +22,18 @@ describe Spigot::Translator do
     end
   end
 
-  context '#format' do
-    let(:subject){Spigot::Translator.new(:github, User.new, {a: '1'})}
-
-    context 'with a missing map' do
-      it 'raises error with a missing file' do
-        expect {
-          subject.format
-        }.to raise_error(Spigot::MissingServiceError)
-      end
+  context '.id' do
+    let(:subject){ Spigot::Translator.new(:github, User.new, 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
-      before do
-        subject.stubs(:translation_file).returns("missing:\n  foo: 'bar'")
-      end
-
+      let(:subject){ Spigot::Translator.new(:github, User.new, Spigot::Data::User.basic) }
       it 'raises error with a missing resource map' do
         expect{
           subject.format
@@ -45,86 +41,106 @@ describe Spigot::Translator do
       end
     end
 
-    context 'with a symbol keyed map' do
-      let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.basic_user)}
-
-      context 'with a basic mapping' do
-        with_mapping(:basic_user, Spigot::Mapping::User.symbolized)
+    context 'with a valid resource map' do
+      context 'with a simple map' do
+        let(:data){ Spigot::Data::User.basic }
+        let(:subject){ Spigot::Translator.new(:github, User.new, 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})
+        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
-    end
-
-    context 'and a valid resource map' do
-      with_mapping(:basic_user, Spigot::Mapping::User.basic)
-
-      it 'returns empty hash from nil data' do
-        expect(subject.format).to eq({})
-      end
-    end
 
-    context 'with basic user data' do
-      let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.basic_user)}
+      context 'with a nested map' do
+        let(:data){ Spigot::Data::User.nested }
+        let(:subject){ Spigot::Translator.new(:github, User.new, data) }
+        before{ Spigot::Mapping::User.nested }
 
-      context 'with a basic mapping' do
-        with_mapping(:basic_user, Spigot::Mapping::User.basic)
-
-        it 'reads one layer' do
-          expect(subject.format).to eq({'name' => 'Dean Martin', 'username' => 'classyasfuck'})
+        it 'traverses into the nested hash' do
+          expect(subject.format).to eq({
+            name: 'Dean Martin',
+            username: 'classyasfuck',
+            contact: 'dino@amore.io'
+          })
         end
       end
 
-      context 'with a mapping containing nested data' do
-        let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.nested_user)}
-        with_mapping(:basic_user, Spigot::Mapping::User.nested)
+      context "nested twice" do
+        let(:data){Spigot::Data::User.double_nested}
+        let(:subject){Spigot::Translator.new(:github, User.new, data)}
+        before{ Spigot::Mapping::User.nested_twice }
 
-        it 'traverses into the nested hash' do
+        it 'traverses multiple levels' do
           expect(subject.format).to eq({
-            'name' => 'Dean Martin',
-            'username' => 'classyasfuck',
-            'contact' => 'dino@amore.io'
+            name: 'Dean Martin',
+            ip: "127.0.0.1",
+            username: 'classyasfuck',
+            contact: 'dino@amore.io'
           })
         end
+      end
 
-        context 'twice' do
-          with_mapping(:basic_user, Spigot::Mapping::User.nested_twice)
-          let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.double_nested_user)}
+      context 'with an array of values' do
+        let(:data){Spigot::Data::User.array}
+        let(:subject){Spigot::Translator.new(:github, User.new, data)}
+        before{ Spigot::Mapping::User.basic }
 
-          it 'traverses multiple levels' do
-            expect(subject.format.values).to include(*['Dean Martin','classyasfuck','dino@amore.io'])
-          end
+        it 'returns an array of formatted data' do
+          subject.format.should eq([
+            {name: "Dean Martin", username: "classyasfuck"},
+            {name: "Frank Sinatra", username: "livetilidie"}
+          ])
         end
       end
-    end
 
-    context 'with an array of values' do
-      let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.user_array)}
-      with_mapping(:basic_user, Spigot::Mapping::User.basic)
+      context 'with a nested array of values' do
+        let(:data){ Spigot::Data::User.nested_array }
+        let(:subject){Spigot::Translator.new(:github, User.new, data)}
+        before{ Spigot::Mapping::User.nested_array }
 
-      it 'returns an array of formatted data' do
-        expect(subject.format.length).to eq(2)
-        expect(subject.format.map{|u| u['name']}).to include('Dean Martin', 'Frank Sinatra')
+        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"}]
+          })
+        end
       end
-    end
 
-    context 'with a nested array of values' do
-      let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.nested_user_array)}
-      with_mapping(:basic_user, Spigot::Mapping::User.nested_array)
+      context 'with a namedspaced resource' do
+        let(:data){ Spigot::Data::Post.basic }
+        let(:subject){Spigot::Translator.new(:github, Wrapper::Post.new, data)}
+        before{ Spigot::Mapping::Post.basic }
 
-      it 'handles a nested array of values' do
-        expect(subject.format.keys).to include('name', 'users', 'user_count')
-        expect(subject.format['users']).to be_a(Array)
+        it 'accesses the wrapper/post key' do
+          subject.format.should eq({
+            title: 'Brief Article',
+            description: 'lorem ipsum'
+          })
+        end
       end
-    end
 
-    context 'with a namedspaced resource' do
-      let(:subject){Spigot::Translator.new(:github, Wrapper::Post.new, Spigot::ApiData.post)}
-      with_mapping(:namespaced_post, Spigot::Mapping::Post.namespaced)
+      context 'with an interpolated value' do
+        let(:data){ Spigot::Data::User.basic }
+        let(:subject){ Spigot::Translator.new(:github, User.new, data) }
+        before{ Spigot::Mapping::User.interpolated }
+        it 'reads one layer' do
+          expect(subject.format).to eq({name: 'Dean Martin', username: '@classyasfuck'})
+        end
+      end
 
-      it 'accesses the wrapper/post key' do
-        expect(subject.format).to eq({'title' => 'Regular Article', 'description' => 'dolor sit amet'})
+      context 'with a nested interpolated value' do
+        let(:data){ Spigot::Data::User.nested }
+        let(:subject){ Spigot::Translator.new(:github, User.new, 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'})
+        end
       end
     end
   end
@@ -137,75 +153,56 @@ describe Spigot::Translator do
     end
   end
 
-  context '#id' do
-    let(:subject){Spigot::Translator.new(:github, User.new, {id: '123'})}
-
-    it 'returns the value at the foreign_key' do
-      subject.stubs(:foreign_key).returns('id')
-      subject.id.should eq('123')
-    end
-  end
-
   context '#conditions' do
-    let(:subject){Spigot::Translator.new(:github, User.new, Spigot::ApiData.user)}
-    with_mapping(:user_with_conditions, Spigot::Mapping::User.with_options)
-
-    it 'should return a hash' do
-      previous_translations = Spigot.config.translations
-      Spigot.configure{|c| c.translations = Spigot::Mapping::User.with_options }
-      subject.conditions.should eq({"username"=>"classyasfuck"})
-      Spigot.configure{|c| c.translations = previous_translations }
+    let(:data){ Spigot::Data::User.basic }
+    let(:subject){Spigot::Translator.new(:github, User.new, data)}
+
+    context 'without conditions specified' do
+      before{ Spigot::Mapping::User.basic }
+      it 'should return a hash' do
+        subject.conditions.should eq({'github_id' => nil})
+      end
     end
 
     context 'with conditions specified' do
-      with_mapping(:user_with_conditions, 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", "name"=>"Dean Martin"})
+        subject.conditions.should eq({username: "classyasfuck"})
       end
 
       it 'can specify only one key' do
-        subject.conditions.should eq({"username"=>"classyasfuck", "name"=>"Dean Martin"})
+        subject.conditions.should eq({username: "classyasfuck"})
       end
     end
   end
 
   context '#options' do
-    let(:subject){Spigot::Translator.new(:github, User.new, {remote_id: '987'})}
+    let(:subject){ Spigot::Translator.new(:github, User.new, {remote_id: '987'}) }
 
     context 'without options provided' do
-      with_mapping(:basic_user, Spigot::Mapping::User.basic)
-
-      context 'defaults' do
-        it '#primary_key is the name of the service _id' do
-          subject.primary_key.should eq('github_id')
-        end
+      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
+      it '#foreign_key is id' do
+        subject.foreign_key.should eq('id')
       end
     end
 
     context 'with options provided' do
-      with_mapping(:user_with_options, Spigot::Mapping::User.with_options)
-
-      it 'reads the options from the spigot key' do
-        subject.options.should eq(Spigot::Mapping::User.with_options['user']['spigot'])
+      before{ Spigot::Mapping::User.with_options }
+      it 'reads a primary key from the mapping' do
+        subject.primary_key.should eq(:username)
       end
 
-      context '#primary_key' do
-        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
 
-      context '#foreign_key' do
-        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
-
 end