data-provider 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38f6f8ba1418886f65eb5bed06cfba596744dfb8
+  data.tar.gz: 33d309c91f3cbb341159b20f99129d0ea387a10e
+SHA512:
+  metadata.gz: f73b0708c03917f4a58a14bffddbd1357336154b917f0ff610511c0572fb743f12f2824647b36d7bd30972967cc41d6a887de8ae696b6318acd69236a847ec51
+  data.tar.gz: a19b6508e5c30fe4ad94ee42c0f205f8a539cc9f1311b9828feb407daf66ab99d2651f8268b418ffaf91c922c93006cfc9a03535a7ee14af676b7382ecc76c13

data/.gitignore

@@ -0,0 +1,35 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'byebug'
+end

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    data-provider (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (5.0.0)
+      columnize (= 0.9.0)
+    columnize (0.9.0)
+    diff-lcs (1.2.5)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.1)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  data-provider!
+  rspec
+
+BUNDLED WITH
+   1.10.5

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Mark
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,154 @@
+# data-provider
+Ruby gem that provides a set of classes to build consistent data interfaces
+
+## Installation
+
+Rubygems:
+```
+gem install data-provider
+```
+
+Bundler:
+```ruby
+gem 'data-provider'
+```
+
+## Examples
+
+Define a provider class with some providers
+```ruby
+
+require 'data_provider'
+
+class BookProvider
+	include DataProvider::Base
+	
+	# quick syntax for 'simple' providers
+	provides({
+		title: 'The Monkey Wrench Gang',
+		author: 'Edward Abbey'
+	})
+	
+	# longer syntax for more complicated providers
+	provider :display_title do
+		"#{take(:author)} - #{take(:title)}"
+	end
+
+	provider :price do
+		9.99
+	end
+end
+```
+
+Using a provider class
+```ruby
+book_provider = BookProvider.new()
+book_provider.take(:title) # => 'The Monkey Wrench Gang'
+book_provider.take(:author) # => 'Edward Abbey'
+book_provider.take(:display_title) # => 'Edward Abbey - The Monkey Wrench Gang'
+book_provider.take(:price) # => 9.99
+```
+
+Data providers can be given data to customize their output
+```ruby
+require 'data_provider'
+
+class ProductProvider
+	include DataProvider::Base
+	
+	provider :normal_price do
+		17.99
+	end
+	
+	provider :discount_price do
+		take(:normal_price) - get_data(:discount)
+	end
+end
+
+product_provider = ProductProvider.new
+product_provider.take(:normal_price) # => 17.99
+product_provider.take(:discount_price) # => TypeError (discount data not given,): nil can't be coerced into Float
+discounted_provider = product_provider.add_data(discount: 3.0) # returns a new instance of the same provider class
+discounted_provider.take(:discount_price) # => 14.99
+product_provider.take(:discount_price) # => TypeError (this instance didn't get the new data)
+product_provider.add_date!(discount: 2) # => Updates this instance instead of creating a new one
+product_provider.take(:discount_price) # => 15.99
+product_provider.add_date!(discount: 4).take(:discount_price) #=> 13.99
+```
+
+Providers can be defined in a module and added to a provider class using the add class-method (not using include!)
+```ruby
+require 'data-provider'
+
+module BandInfo
+	include DataProvider::Base
+	
+	provider :band do
+		'D4'
+	end
+	
+	provider :bassPlayer do
+		'Paddy'
+	end
+end
+
+class Band
+	include DataProvider::Base
+	
+	provider :band do
+		'Dillinger Four'
+	end
+	
+	provider :drummer do
+		'Lane Pederson'
+	end
+
+	add BandInfo # note: add, not include!
+end
+
+band = Band.new
+band.take(:band) # => 'D4', class provider was overwritten when the module got added
+band.take(:bassPlayer) # => 'Paddy'
+band.take(:drummer) #=> 'Lane Pederson'
+```
+
+Provider identifiers don't have to be symbols, they can be anything. Specifically array identifiers are suitable for creating data providers for hierarchical systems
+```ruby
+require 'data_provider'
+
+module AlbumProvider
+	include DataProvider::Base
+	
+	provides({
+		title: 'Reinventing Axle Rose',
+		band: 'Against Me!'
+		[:band, :hometown] => 'Gainesville, FL'
+	})
+end
+
+class Catalog
+	include DataProvider::Base
+	
+	provider [:music, :album, :bandname] do
+		# scoped_take is a method only available inside provider blocks,
+		# it lets a provider access other providers in the same 'scope',
+		# which means provider whose array-identifiers start with the same values,
+		# in this case the scope is [:music, :album]
+		scoped_take(:band).upcase
+	end
+
+	# by using `add_scoped` all providers of the added module, will be
+	# turned into array and prefixed with the given scope
+	add_scoped AlbumProvider, :scope => [:music, :album]
+end
+
+catalog = Catalog.new
+catalog.take(:title) # => DataProvider::ProviderMissingException
+catalog.take([:music, :album, :title]) # => 'Reinventing Axle Rose'
+catalog.take([:music, :album, :band, :hometown]) # => 'Gainesville, FL'
+catalog.take([:music, :album, :bandname]) # => 'AGAINST ME!"
+```
+
+
+
+	

data/Rakefile

@@ -0,0 +1,20 @@
+# rxsd project Rakefile
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the LGPLv3+ http://www.gnu.org/licenses/lgpl.txt
+
+require 'rdoc/task'
+require "rspec/core/rake_task"
+
+task :default => :rspec do; end
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('rspec') do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc/site/api"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end

data/data-provider.gemspec

@@ -0,0 +1,19 @@
+GEM_NAME="data-provider"
+PKG_VERSION='0.1.0'
+
+Gem::Specification.new do |s|
+  s.name = GEM_NAME
+  s.version = PKG_VERSION
+  s.files = `git ls-files`.split($/)
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  s.add_development_dependency 'rspec'
+
+  s.author = "Mark van de Korput"
+  s.email = "dr.theman@gmail.com"
+  s.date = '2015-07-14'
+  s.description = %q{A library of Ruby classes to help create consistent data interfaces}
+  s.summary = %q{A library of Ruby classes to help create consistent data interfaces}
+  s.homepage = %q{https://github.com/markkorput/data-provider}
+  s.license = "MIT"
+end

data/lib/data_provider/base.rb

@@ -0,0 +1,227 @@
+require 'logger'
+
+module DataProvider
+
+  class ProviderMissingException < Exception
+  end
+
+  module Base
+
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      # provides, when called with a hash param, will define 'simple providers' (providers
+      # with a simple, static value). When called without a param (or nil) it returns
+      # the current cumulative 'simple providers' hash
+      def provides simple_provides = nil
+        if simple_provides
+          @data_provider ||= {}
+          @data_provider[:provides] ||= {}
+          @data_provider[:provides].merge!(simple_provides)
+          return self
+        end
+        # no data given? just return existing hash
+        (@data_provider || {})[:provides] || {}
+      end
+
+      # returns the requested provider as a Provider object
+      def get_provider(id)
+        args = data_provider_definitions.find{|args| args.first == id}
+        return args.nil? ? nil : Provider.new(*args)
+      end
+
+      def provider_identifiers
+        (provides.keys + data_provider_definitions.map(&:first)).compact.uniq
+      end
+
+      # adds a new provider to the class
+      def provider identifier, opts = {}, &block
+        add_provider(identifier, opts, block_given? ? block : nil)
+      end
+
+      # reader method for the raw data of the currently defined providers
+      def data_provider_definitions
+        ((@data_provider || {})[:provider_args] || [])
+      end
+
+      # returns wether a provider with the given identifier is available
+      def has_provider?(identifier)
+        (provides[identifier] || get_provider(identifier)) != nil
+      end
+
+      def has_providers_with_scope?(args)
+        scope = args.is_a?(Array) ? args : [args]
+        provider_identifiers.find{|id| id.is_a?(Array) && id.length > scope.length && id[0..(scope.length-1)] == scope} != nil
+      end
+
+      def fallback_provider?
+        !fallback_provider.nil?
+      end
+
+      # adds all the providers defined in the given module to this class
+      def add(providers_module)
+        data = providers_module.instance_variable_get('@data_provider') || {}
+
+        (data[:provider_args] || []).each do |definition|
+          add_provider(*definition)
+        end
+
+        self.provides(data[:provides] || {})
+      end
+
+      # adds all the providers defined in the given module to this class,
+      # but turns their identifiers into array and prefixes the array with the :scope option
+      def add_scoped(providers_module, _options = {})
+        data = providers_module.instance_variable_get('@data_provider') || {}
+
+        (data[:provider_args] || []).each do |definition|
+          definition[0] = [definition[0]].flatten
+          definition[0] = [_options[:scope]].flatten.compact + definition[0] if _options[:scope]
+          add_provider(*definition)
+        end
+
+        (data[:provides] || {}).each_pair do |key, value|
+          provides(([_options[:scope]].flatten.compact + [key].flatten.compact) => value)
+        end
+      end
+
+      def provider_missing &block
+        raise "DataProvider::Base#provider_missing expects a block as an argument" if !block_given?
+        @data_provider ||= {}
+        @data_provider[:provider_missing] = block
+      end
+
+      def fallback_provider
+        block = (@data_provider || {})[:provider_missing]
+        block.nil? ? nil : Provider.new(nil, nil, block)
+      end
+
+      private
+
+      def add_provider(identifier, opts = {}, block = nil)
+        @data_provider ||= {}
+        @data_provider[:provider_args] ||= []
+        @data_provider[:provider_args].unshift [identifier, opts, block]
+      end
+    end # module ClassMethods
+
+
+    module InstanceMethods
+
+      attr_reader :data
+      attr_reader :options
+
+      def initialize(opts = {})
+        @options = opts.is_a?(Hash) ? opts : {}
+        @data = options[:data].is_a?(Hash) ? options[:data] : {}
+      end
+
+      def logger
+        @logger ||= options[:logger] || Logger.new(STDOUT)
+      end
+
+      def has_provider?(id)
+        self.class.has_provider?(id)
+      end
+
+      def has_providers_with_scope?(scope)
+        self.class.has_providers_with_scope?(scope)
+      end
+
+      def fallback_provider?
+        self.class.fallback_provider?
+      end
+
+      def take(id)
+        # first try the simple providers
+        if self.class.provides.has_key?(id)
+          provider = self.class.provides[id]
+          return provider.is_a?(Proc) ? provider.call : provider
+        end
+        # try to get a provider object
+        provider = self.class.get_provider(id)
+        if provider
+          @scope ||= []
+          @scope << (id.is_a?(Array) ? id[0..-2] : [])
+          result = instance_eval(&provider.block) 
+          @scope.pop
+          # execute provider object's block within the scope of self
+          return result
+        end
+
+        # couldn't find requested provider, let's see if there's a fallback
+        if provider = self.class.fallback_provider
+          # temporarily set the @missing_provider instance variable, so the
+          # fallback provider can use it through the missing_provider private method
+          @missing_provider = id
+          @scope ||= []
+          @scope << (id.is_a?(Array) ? id[0..-2] : [])
+          result = instance_eval(&provider.block) # provider.block.call # with the block.call method the provider can't access private methods like missing_provider
+          @scope = nil
+          return result
+        end
+        # no fallback either? Time for an error
+        raise ProviderMissingException.new(:message=>"Tried to take data from missing provider.", :provider_id => id) 
+      end
+
+      def try_take(id, opts = {})
+        return take(id) if self.has_provider?(id) || self.fallback_provider?
+        if opts[:fallback] == true
+
+        logger.debug "Try for missing provider: #{id.inspect}"
+          return nil
+        end
+      end
+
+      private
+
+      def scoped_take(id)
+        take(((@scope || []).last || []) + [id].flatten)
+      end
+
+      public
+
+      def given(param_name)
+        return data[param_name] if data.has_key?(param_name)
+        logger.error "Data provider expected missing data with identifier: #{param_name.inspect}"
+        # TODO: raise?
+        return nil
+      end
+
+      alias :get_data :given
+
+      def give(_data = {})
+        return self.class.new(options.merge(:data => data.merge(_data)))
+      end
+
+      alias :add_scope :give
+      alias :add_data :give
+
+      def give!(_data = {})
+        @data = data.merge(_data)
+        return self
+      end
+
+      alias :add_scope! :give!
+      alias :add_data! :give!
+
+      private
+
+      def missing_provider
+        # byebug
+        @missing_provider
+      end
+
+      def scope
+        @scope || []
+      end
+    end # module InstanceMethods
+
+  end # module Base
+
+end # module DataProvider

data/lib/data_provider/provider.rb

@@ -0,0 +1,20 @@
+module DataProvider
+  class Provider
+    attr_reader :options
+    attr_reader :identifier
+    attr_reader :block
+
+    def initialize(identifier, opts = {}, block = nil)
+      @identifier = identifier
+      @options = opts.is_a?(Hash) ? opts : {}
+      @block = block || Proc.new
+    end
+
+    alias_method :id, :identifier
+
+    def requirements
+      [options[:requires]].flatten.compact
+    end
+
+  end # module Provider
+end # module DataProvider

data/lib/data_provider.rb

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

data/spec/data_provider_spec.rb

@@ -0,0 +1,420 @@
+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
+  end
+
+  let(:provider){
+    ProviderClass.new(:data => {:array => [1,2,4]})
+  }
+
+  describe "#has_provider?" do
+    it 'provides the has_provider? instance method' 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
+
+    it 'provides the has_provider? class method' 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.new.has_providers_with_scope?(:unscoped)).to eq false
+      # byebug
+      expect(klass.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 it' 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)
+    end
+
+
+    it 'works from within a provider block' do
+      expect(provider.take(:billy)).to eq 'Billy Bragg'
+    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
+  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
+  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 "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 "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 "#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 "#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
+  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'
+      })
+    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
+  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
+      expect(klass.new.fallback_provider?).to eq false
+
+      klass.provider_missing do
+        "New fallback!"
+      end
+
+      expect(klass.fallback_provider?).to eq true
+      expect(klass.new.fallback_provider?).to eq true
+    end
+  end
+end
+
+describe "Adding additional providers" do
+  module AdditionalProvider
+    include DataProvider::Base
+
+    provider 'provider2' do
+      '#2'
+    end
+  end
+
+  module OverwriteProvider
+    include DataProvider::Base
+
+    provider 'provider1' do
+      '#111'
+    end
+  end
+
+  class OriginalProvider
+    include DataProvider::Base
+
+    provider 'provider1' do
+      '#1'
+    end
+
+    add AdditionalProvider
+    add OverwriteProvider
+  end
+
+  it "lets you include modules with additional providers" do
+    expect(OriginalProvider.new.take('provider2')).to eq '#2'
+  end
+
+  it "lets you include modules with additional providers" do
+    expect(OriginalProvider.new.take('provider1')).to eq '#111'
+  end
+end
+
+describe "Array identifiers" do
+  module ArrayProviderModule
+    include DataProvider::Base
+
+    provider [:some, 'Stuff'] do
+      'OtherStuff'
+    end
+  end
+
+  class ArrayProviderClass
+    include DataProvider::Base
+
+    provider [:some, 'Stuff'] do
+      'SomeStuff'
+    end
+
+    # add ArrayProviderModule
+  end
+
+  let(:provider){
+    ArrayProviderClass.new
+  }
+
+  it "lets you use array as provider identifiers" do
+    expect(provider.take([:some, 'Stuff'])).to eq 'SomeStuff'
+  end
+
+  it "lets you overwrite existing providers with Array-based identifiers" do
+    expect(provider.take([:some, 'Stuff'])).to eq 'SomeStuff'
+
+    provider.class.add(ArrayProviderModule)
+    expect(provider.take([:some, 'Stuff'])).to eq 'OtherStuff'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# loads and runs all tests for the rxsd project
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the AGPLv3+ http://www.gnu.org/licenses/agpl.txt
+
+require 'rspec'
+
+CURRENT_DIR=File.dirname(__FILE__)
+$: << File.expand_path(CURRENT_DIR + "/../lib")
+
+require 'data_provider'
+require 'byebug'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: data-provider
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark van de Korput
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-14 00:00:00.000000000 Z
+dependencies:
+- !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'
+description: A library of Ruby classes to help create consistent data interfaces
+email: dr.theman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- data-provider.gemspec
+- lib/data_provider.rb
+- lib/data_provider/base.rb
+- lib/data_provider/provider.rb
+- spec/data_provider_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/markkorput/data-provider
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A library of Ruby classes to help create consistent data interfaces
+test_files: []