data-provider 0.1.0 → 0.2.0

data/lib/data_provider.rb

@@ -1,2 +1,3 @@
 require 'data_provider/provider'
+require 'data_provider/container'
 require 'data_provider/base'

data/spec/base_spec.rb

@@ -0,0 +1,818 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe DataProvider::Base do
+  # Example implementation of DataProvider::Base
+  class ProviderClass
+    include DataProvider::Base
+
+    provider :sum, :requires => [:array] do
+      sum = 0
+
+      given(:array).each do |number|
+        sum += number.to_i
+      end
+
+      sum
+    end
+
+    provider :static do
+      'StaticValue'
+    end
+
+    provider :billy do
+      take([:identification, :fullname])
+    end
+
+    provider [:identification, :firstname] do
+      'Billy'
+    end
+
+    provider [:identification, :lastname] do
+      'Bragg'
+    end
+
+    provider [:identification, :fullname] do
+      "#{scoped_take(:firstname)} #{scoped_take(:lastname)}"
+    end
+
+    provider [:identification, :identifier] do
+      take(:firstname)
+    end
+
+    provider :fullname do
+      'Stephen William Bragg'
+    end
+
+    provider [:identification, :id] do
+      take(:fullname)
+    end
+
+    provider [:identification, :ID] do
+      take(:id)
+    end
+  end
+
+  let(:provider){
+    ProviderClass.new(:data => {:array => [1,2,4]})
+  }
+
+  describe "Class level" do
+    describe "#has_provider?" do
+      it 'tells if the specified provider exists' do
+        expect(ProviderClass.respond_to?(:has_provider?)).to eq true
+        expect(ProviderClass.has_provider?(:sum)).to eq true
+        expect(ProviderClass.has_provider?(:divid)).to eq false
+      end
+    end
+
+    describe "#has_providers_with_scope?" do
+      let(:klass){
+        Class.new Object do
+          include DataProvider::Base
+          provider [:a, :b ,:c]
+          provider :unscoped
+        end
+      }
+
+      it "return true if there are providers defined with an array identifier that start with the given prefix" do
+        expect(klass.has_providers_with_scope?(:unscoped)).to eq false
+        expect(klass.has_providers_with_scope?(:a)).to eq true
+        expect(klass.has_providers_with_scope?([:a, :b])).to eq true
+        # scope means prefix, identfier may not be exactly the given array
+        expect(klass.has_providers_with_scope?([:a, :b, :c])).to eq false
+      end
+    end
+
+    describe "#provides" do
+      class SimpleProviders
+        include DataProvider::Base
+        provides({
+          :name => 'Paddy',
+          'instrument' => :bass,
+        })
+      end
+
+      it "lets you request all currently available simple providers when called without a parameter" do
+        expect(SimpleProviders.provides).to eq({
+          :name => 'Paddy',
+          'instrument' => :bass
+        })
+      end
+
+      it "lets you define simple providers" do
+        expect(SimpleProviders.new.take(:name)).to eq 'Paddy'
+        expect(SimpleProviders.new.take('instrument')).to eq :bass
+      end
+
+      it "works with has_provider?" do
+        expect(SimpleProviders.has_provider?(:name)).to eq true
+        expect(SimpleProviders.new.has_provider?('name')).to eq false
+        expect(SimpleProviders.has_provider?('instrument')).to eq true
+        expect(SimpleProviders.new.has_provider?(:instrument)).to eq false
+      end
+
+      it "lets you overwrite existing simple providers" do
+        SimpleProviders.provides({:name => 'Erik'})
+        expect(SimpleProviders.new.take(:name)).to eq 'Erik'
+      end
+
+      it "lets you write linked notation" do
+        expect(SimpleProviders.provides({:name => 'Lane'}).new.take(:name)).to eq 'Lane'
+      end
+
+      it "works with lambdas" do
+        expect(SimpleProviders.provides(:name => lambda{ 'Patrick' }).new.take(:name)).to eq 'Patrick'
+      end
+
+      it "works with Procs" do
+        expect(SimpleProviders.provides(:name => Proc.new{ 'St. Patrick' }).new.take(:name)).to eq 'St. Patrick'
+      end
+    end
+
+    describe "#add" do
+      module OddProviders
+        include DataProvider::Base
+        provides({1 => 'one'})
+        provider :three do 3 end
+      end
+
+      module OddOverwriteProviders
+        include DataProvider::Base
+        provides({1 => 'Uno', :five => 555})
+        provider :three do :tres end
+      end
+
+      class BasicProviders
+        include DataProvider::Base
+        provides({2 => '1'})
+        provider :four do '4' end
+        add OddProviders
+      end
+
+      it "lets you add providers from another module" do
+        expect(BasicProviders.has_provider?(1)).to eq true
+        expect(BasicProviders.has_provider?(2)).to eq true
+        expect(BasicProviders.has_provider?(:three)).to eq true
+        expect(BasicProviders.has_provider?(:four)).to eq true
+        # expect(BasicProviders.new.take(1)).to eq 'one'
+        expect(BasicProviders.new.take(:three)).to eq 3
+      end
+
+      it "lets you add providers from another module at runtime" do
+        expect(BasicProviders.has_provider?(:five)).to eq false
+        BasicProviders.add(OddOverwriteProviders)
+        expect(BasicProviders.has_provider?(:five)).to eq true
+      end
+
+      # for the following test the providers of OddOverwriteProviders
+      # have already been added (by the previous test)
+      it "lets overwrite providers" do
+        expect(BasicProviders.new.take(1)).to eq 'Uno'
+        expect(BasicProviders.new.take(:three)).to eq :tres
+      end
+
+      it "includes providers which can be overwritten" do
+        klass = Class.new(Object) do
+          include DataProvider::Base
+          add OddProviders
+          provider :three do '33' end
+        end
+
+        expect(klass.new.take(:three)).to eq '33'
+      end
+
+      it "can be used in modules, latest provider always overwrites the previous" do
+        m1 = Module.new do
+          include DataProvider::Base
+
+          # this provider should get overwritten by the m2 version
+          provider :aa do 'aa1' end
+        end
+
+        m2 = Module.new do
+          include DataProvider::Base
+          add m1
+
+          # this provider should overwrite the m1 version
+          provider :aa do 'aa2' end
+        end
+
+        c = Class.new(Object) do
+          include DataProvider::Base
+
+          # this provider gets overwritten when we do the add call below
+          provider :aa do 'aa3' end
+
+          add m2
+        end
+
+        expect(c.new.take(:aa)).to eq 'aa2'
+      end
+
+      it "includes a module as well, so normal methods are added as well" do
+        m = Module.new do
+          include DataProvider::Base
+          provider :mprovider do mfunc end
+          def mfunc
+            'Methodized!'
+          end
+        end
+
+        c = Class.new(Object) do
+          include DataProvider::Base
+          add m
+
+          def cfunc1
+            take(:cprovider)
+          end
+
+          provider :cprovider do cfunc2 end
+
+          def cfunc2
+            take :mprovider
+          end
+        end
+
+        expect(c.new.cfunc1).to eq 'Methodized!'
+      end
+    end
+
+    describe "#add_scoped" do
+      module ChildProviders
+        include DataProvider::Base
+        provider :name do "child" end
+      end
+
+      module GrandchildProviders
+        include DataProvider::Base
+        provider :name do "grandchild" end
+        provider [:age] do 1 end
+        provides({
+          :mommy => 'Wilma',
+          :daddy => 'Fret'
+        })
+
+        provider :mobility do
+          'crawling'
+        end
+
+        provider :movement do
+          take(:mobility)
+        end
+
+        provider :symbol do
+          'Symbol provider'
+        end
+
+        provider :sym do
+          take(:symbol)
+        end
+
+        provider ['string'] do
+          'String provider: ' + take(:symbol)
+        end
+      end
+
+      class ProviderKlass
+        include DataProvider::Base
+        provider :parent do 'parent' end
+        add_scoped ChildProviders, :scope => :child
+        add_scoped GrandchildProviders, :scope => [:child, :child]
+      end
+
+      it 'let you array-prefix the providers of an included module' do
+        expect(ProviderKlass.has_provider?(:parent)).to eq true
+        expect(ProviderKlass.has_provider?(:name)).to eq false
+        expect(ProviderKlass.has_provider?([:child, :name])).to eq true
+        expect(ProviderKlass.has_provider?([:child, :age])).to eq false
+        expect(ProviderKlass.has_provider?([:child, :child, :name])).to eq true
+        expect(ProviderKlass.has_provider?([:child, :child, :age])).to eq true
+        expect(ProviderKlass.has_provider?([:child, :child, :mommy])).to eq true
+        expect(ProviderKlass.has_provider?([:child, :child, :daddy])).to eq true
+        expect(ProviderKlass.new.take([:child, :name])).to eq 'child'
+        expect(ProviderKlass.new.take([:child, :child, :name])).to eq 'grandchild'
+        expect(ProviderKlass.new.take([:child, :child, :age])).to eq 1
+        expect(ProviderKlass.new.take([:child, :child, :mommy])).to eq 'Wilma'
+        expect(ProviderKlass.new.take([:child, :child, :daddy])).to eq 'Fret'
+      end
+
+      it "#take acts like #scoped_take inside providers works for add_scoped modules as well" do
+        expect( ProviderKlass.new.take([:child, :child, :mobility]) ).to eq 'crawling'
+        expect( ProviderKlass.new.take([:child, :child, :movement]) ).to eq 'crawling'
+      end
+
+      it "doesn't act up when mixing symbols and strings in array identifiers" do
+        expect( ProviderKlass.new.take([:child, :child, 'string']) ).to eq 'String provider: Symbol provider'
+      end
+
+      it "lets #take act like #scoped_take recursively" do
+        expect( ProviderKlass.new.take([:child, :child, :sym]) ).to eq 'Symbol provider'
+      end
+
+      it 'respect provider order/priority' do
+        m1 = Module.new do
+          include DataProvider::Base
+          provider 'version' do 1 end
+        end
+
+        m2 = Module.new do
+          include DataProvider::Base
+          add m1
+          provider 'version' do 2 end
+        end
+
+        c = Class.new(Object) do
+          include DataProvider::Base
+          provider 'version' do 0 end
+          provider ['module', 'version'] do -1 end
+          add_scoped m2, :scope => 'module'
+        end
+
+        expect(c.new.try_take('version')).to eq 0
+        expect(c.new.try_take(['module', 'version'])).to eq 2
+      end
+
+      it 'works recursively' do
+        m1 = Module.new do
+          include DataProvider::Base
+          provider ['name'] do 'Johnny Blaze' end
+        end
+
+        expect(m1.provider_identifiers).to eq [['name']]
+
+        m2 = Module.new do
+          include DataProvider::Base
+          # this next line adds the provider ['name'] to m2
+          add m1
+        end
+
+        expect(m2.provider_identifiers).to eq [['name']]
+
+        m3 = Module.new do
+          include DataProvider::Base
+          # this provider will end up like ['creatures', 'name'] in c1
+          provider ['name'] do 'Mr. Nobody' end
+          # the next line adds the provider ['person', 'name'] to m3
+          add_scoped m2, :scope => 'person'
+        end
+
+        # providers are internally added in reverse order
+        expect(m3.provider_identifiers).to eq [['person', 'name'], ['name']]
+
+        c1 = Class.new(Object) do
+          include DataProvider::Base
+          # the next line will add the provides ['creatures', 'name'] and ['creatures', 'person', 'name']
+          add_scoped m3, :scope => 'creatures'
+        end
+
+        expect(c1.has_provider?('name')).to eq false
+        expect(c1.has_provider?(['name'])).to eq false
+        expect(c1.has_provider?(['person', 'name'])).to eq false
+        expect(c1.has_provider?(['creatures', 'person', 'name'])).to eq true
+        expect(c1.new.take(['creatures', 'person', 'name'])).to eq 'Johnny Blaze'
+      end
+
+      it "doesn't affect the added module" do
+        m1 = Module.new do
+          include DataProvider::Base
+          provider ['name'] do 'Johnny Blaze' end
+        end
+
+        expect(m1.provider_identifiers).to eq [['name']]
+
+        c1 = Class.new(Object) do
+          include DataProvider::Base
+          add_scoped m1, :scope => 'prefix'
+        end
+
+        expect(m1.provider_identifiers).to eq [['name']]
+      end
+    end
+
+    describe "provider_missing" do
+      it "lets you define a default fallback provider" do
+        klass = Class.new Object do
+          include DataProvider::Base
+          provider_missing do
+            "This provider don't exist!"
+          end
+        end
+
+        expect(klass.has_provider?(:message)).to eq false
+        expect(klass.new.take(:message)).to eq "This provider don't exist!"
+      end
+
+      it "provides the missing provider id through the private missing_provider method" do
+        klass = Class.new Object do
+          include DataProvider::Base
+          provider_missing do
+            "Missing #{missing_provider}"
+          end
+        end
+
+        expect(klass.new.take(:something)).to eq 'Missing something'
+        expect{klass.new.missing_provider}.to raise_error(NoMethodError)
+      end
+
+      it 'calls the fallback provider when using try_take with an unknown provider' do
+        klass = Class.new Object do
+          include DataProvider::Base
+          provider_missing do
+            "fallback_#{missing_provider}"
+          end
+        end
+
+        expect(klass.new.try_take(:cool)).to eq 'fallback_cool'
+      end     
+    end
+
+    describe "fallback_provider?" do
+      it "lets you know if a fallback provider has been registered" do
+        klass = Class.new Object do
+          include DataProvider::Base
+        end
+
+        expect(klass.fallback_provider?).to eq false
+
+        klass.provider_missing do
+          "New fallback!"
+        end
+
+        expect(klass.fallback_provider?).to eq true
+      end
+    end
+  end
+
+  describe "Instance level" do
+    describe "#has_provider?" do
+      it 'tells if the instance knows the specified provider' do
+        expect(provider.has_provider?(:sum)).to be true
+        expect(provider.has_provider?(:static)).to be true
+        expect(provider.has_provider?(:modulus)).to be false
+      end
+    end
+
+    describe "#has_providers_with_scope?" do
+      let(:klass){
+        Class.new Object do
+          include DataProvider::Base
+          provider [:a, :b ,:c]
+          provider :unscoped
+        end
+      }
+
+      it "return true if there are providers defined with an array identifier that start with the given prefix" do
+        expect(klass.new.has_providers_with_scope?(:unscoped)).to eq false
+        expect(klass.new.has_providers_with_scope?(:a)).to eq true
+        expect(klass.new.has_providers_with_scope?([:a, :b])).to eq true
+        # scope means prefix, identfier may not be exactly the given array
+        expect(klass.new.has_providers_with_scope?([:a, :b, :c])).to eq false
+      end
+    end
+
+    describe "#take" do
+      it 'lets you take data from a data provider instance' do
+        expect(provider.take(:sum)).to eq 7
+        expect(provider.take(:static)).to eq 'StaticValue'
+      end
+
+      it 'raise a ProviderMissingException when attempting to take from unknown provider' do
+        expect{provider.take(:unknown)}.to raise_error(DataProvider::ProviderMissingException)
+        expect{provider.take([:identification, :foo])}.to raise_error(DataProvider::ProviderMissingException)
+      end
+
+      it 'works from within a provider block' do
+        expect(provider.take(:billy)).to eq 'Billy Bragg'
+      end
+
+      it "acts like #scoped_take when used inside a provider and the specified provider isn't available" do
+        expect(provider.take([:identification, :id])).to eq 'Stephen William Bragg'
+        expect(provider.take([:identification, :identifier])).to eq 'Billy'
+      end
+
+      it "can act like #scoped_take recursively" do
+        expect(provider.take([:identification, :ID])).to eq 'Stephen William Bragg'
+      end
+
+      it "executes providers with the Base-class instance as scope" do
+        klass = Class.new(Object) do
+          include DataProvider::Base
+          provider :klasss do self.class end
+        end
+
+        instance = klass.new
+        expect(instance.take(:klasss)).to eq klass
+      end
+    end
+
+    describe "#try_take" do
+      it "acts like #take when the specified provider is present" do
+        expect(provider.try_take(:sum)).to eq 7
+      end
+
+      it "returns nil when the specified provider is not found" do
+        expect(provider.try_take(:square_root)).to eq nil
+      end
+
+      it "executes providers with the Base-class instance as scope" do
+        klass = Class.new(Object) do
+          include DataProvider::Base
+          provider :klasss do self.class end
+        end
+
+        instance = klass.new
+        expect(instance.try_take(:klasss)).to eq klass
+      end
+    end
+
+    describe "#scope" do
+      let(:klass){
+        Class.new Object do
+          include DataProvider::Base
+          provider [:a, :b] do
+            'woeha!'
+          end
+          provider [:a, :b ,:c] do
+            scope
+          end
+
+          provider [:a, :b ,:eq] do
+            take scope
+          end
+        end
+      }
+
+      it 'gives providers the current scope' do
+        expect(klass.new.take([:a,:b,:c])).to eq [:a,:b]
+      end
+
+      it "can be used by providers to call the 'parent provider'" do
+        expect(klass.new.take([:a,:b,:eq])).to eq klass.new.take([:a,:b])
+      end
+    end
+
+    describe "#scoped_take" do
+      it 'lets a provider call providers within its own scope' do
+        expect(provider.take([:identification, :fullname])).to eq 'Billy Bragg'
+      end
+      # it 'lets attribute providers'
+    end
+
+    describe "#give" do
+      it "lets you give data, creating a new data provider instance" do
+        updated_provider = provider.give :array => [1,80]
+        expect(provider.take(:sum)).to eq 7
+        expect(updated_provider.take(:sum)).to eq 81
+      end
+
+      it "returns an instance of its own class" do
+        expect(provider.give(:what => :ever).class).to eq provider.class
+      end
+
+      it "allows for linked notation" do
+        expect(provider.give(:array => [7, -3]).take(:sum)).to eq 4
+      end
+
+      it "has an add_scope alias" do
+        expect(provider.add_scope(:array => [400, 20]).take(:sum)).to eq 420
+      end
+
+      it "has an add_data alias" do
+        expect(provider.add_data(:array => [400, 20]).take(:sum)).to eq 420
+      end
+    end
+
+    describe "#give!" do
+      it "lets you update the current provider with additional data" do
+        prov = ProviderClass.new(:data => {:array => [1,1,90]})
+        expect(prov.take(:sum)).to eq 92
+        prov.give!(:array => [3,90])
+        expect(prov.take(:sum)).to eq 93
+      end
+
+      it "returns self" do
+        expect(provider.give!(:some => 'thing')).to be provider
+      end
+
+      it "allows for linked notation" do
+        expect(provider.give.give!(:array => [-1, -4]).take(:sum)).to eq -5
+      end
+
+      it "has an add_scope! alias" do
+        newprovider = provider.add_scope
+        newprovider.add_scope!(:array => [-1, -4])
+        expect(newprovider.given(:array)).to eq [-1,-4]
+        expect(newprovider.take(:sum)).to eq -5
+      end
+
+      it "has an add_data! alias" do
+        scoped_provider = provider.add_data(:array => []).add_data!(:array => [5, 5])
+        expect(scoped_provider.get_data(:array)).to eq [5,5]
+        expect(scoped_provider.take(:sum)).to eq 10
+      end
+    end
+
+    describe '#got?' do
+      it "returns if the specified piece of data is given" do
+        obj = ProviderClass.new(:data => {:name => 'John'})
+        expect( obj.got?(:lastname) ).to be false
+        expect( obj.got?(:name) ).to be true
+        expect( obj.give(:lastname => 'Doe').got?(:lastname) ).to be true
+      end
+
+      it "has an 'has_data?' alias" do
+        obj = ProviderClass.new(:data => {:name => 'John'})
+        expect( obj.has_data?(:lastname) ).to be false
+        expect( obj.has_data?(:name) ).to be true
+        expect( obj.add_data(:lastname => 'Doe').has_data?(:lastname) ).to be true
+      end
+    end
+
+    describe "#given" do 
+      it "has a given method to get given data" do
+        expect(provider.given(:array)).to eq [1,2,4]
+        expect(provider.give(:array => 'array').given(:array)).to eq 'array'
+      end
+
+      it "has a get_data alias" do
+        expect(provider.get_data(:array)).to eq provider.given(:array)
+      end
+    end
+
+    describe "fallback_provider?" do
+      it "lets you know if a fallback provider has been registered" do
+        klass = Class.new Object do
+          include DataProvider::Base
+        end
+
+        expect(klass.new.fallback_provider?).to eq false
+
+        klass.provider_missing do
+          "New fallback!"
+        end
+
+        expect(klass.new.fallback_provider?).to eq true
+      end
+    end
+
+    describe "#add!" do
+      let(:m){
+        Module.new do
+          include DataProvider::Base
+          provider :new_provider do
+            "I'm new!"
+          end
+        end
+      }
+
+      let(:klass){
+        Class.new(Object) do include DataProvider::Base end
+      }
+
+      let(:instance){
+        klass.new
+      }
+
+      it "adds data providers from a module to itself" do
+        # before
+        expect(instance.has_provider?(:new_provider)).to eq false
+        expect(instance.try_take(:new_provider)).to eq nil
+
+        # add!
+        instance.add!(m)
+
+        # after
+        expect(instance.has_provider?(:new_provider)).to eq true
+        expect(instance.try_take(:new_provider)).to eq "I'm new!"
+      end
+
+      it "returns self" do
+        expect(instance.add!(m)).to be instance
+      end
+
+      it "includes a module into the object's class, so normal methods become available as well" do
+        m = Module.new do
+          include DataProvider::Base
+
+          def mfunc
+            take(:cprovider)
+          end
+        end
+
+        c = Class.new(Object) do
+          include DataProvider::Base
+          provider :cprovider do 'Good to be back' end
+        end
+
+        instance = c.new
+        expect{instance.mfunc}.to raise_error(NoMethodError)
+        instance.add!(m)
+        expect(instance.mfunc).to eq 'Good to be back'
+      end
+    end
+
+    describe "#add" do
+      it "adds modules to a clone and returns that clone" do
+        m = Module.new do
+          include DataProvider::Base
+          provider :new_provider do
+            "I'm new!"
+          end
+        end
+
+        klass = Class.new(Object) do include DataProvider::Base end
+        instance = klass.new
+
+        # before
+        expect(instance.has_provider?(:new_provider)).to eq false
+        expect(instance.try_take(:new_provider)).to eq nil
+
+        # add
+        clone = instance.add(m)
+
+        # after
+        expect(instance.has_provider?(:new_provider)).to eq false
+        expect(instance.try_take(:new_provider)).to eq nil
+
+        expect(clone.has_provider?(:new_provider)).to eq true
+        expect(clone.try_take(:new_provider)).to eq "I'm new!"
+      end
+
+      it "includes a module into the object's class, so normal methods become available as well" do
+        m = Module.new do
+          include DataProvider::Base
+
+          def mfunc
+            take(:cprovider)
+          end
+        end
+
+        c = Class.new(Object) do
+          include DataProvider::Base
+
+          provider :cprovider do 'Good to be back' end
+        end
+
+        instance = c.new
+        expect{instance.mfunc}.to raise_error(NoMethodError)
+        instance.add(m)
+        expect(instance.mfunc).to eq 'Good to be back'
+      end
+    end
+
+    describe "#add_scoped" do
+      it "adds providers to this object instance" do
+        m = Module.new do
+          include DataProvider::Base
+          provider :imnew do
+            "I'm new!"
+          end
+        end
+
+        klass = Class.new(Object) do include DataProvider::Base end
+        instance = klass.new
+        instance2 = instance.add_scoped(m, :scope => [:what, :ever])
+        # didn't get added to existing instance
+        expect(instance.has_provider?([:what, :ever, :imnew])).to eq false
+        # created new instance with the new scoped provider
+        expect(instance2.has_provider?([:what, :ever, :imnew])).to eq true
+        # unscoped provider was not added to new instance
+        expect(instance2.has_provider?([:imnew])).to eq false
+      end
+    end
+
+    describe "#provider_stack" do
+      let(:instance){
+        Class.new(Object) do
+          include DataProvider::Base
+
+          provider :one do
+            take :two
+          end
+          provider :two do
+            provider_stack
+          end
+        end
+      }
+
+      it "gives the provider's callstack" do
+        expect(instance.take(:one)).to eq [:one, :two]
+      end
+    end
+
+    describe "#provider_id" do
+      let(:instance){
+        Class.new(Object) do
+          include DataProvider::Base
+          provider :narcissist do
+            provider_id
+          end
+        end
+      }
+
+      it "give the provider's own id" do
+        expect(instance.take(:narcissist)).to eq :narcissist
+      end
+    end
+  end
+end