data-provider 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38f6f8ba1418886f65eb5bed06cfba596744dfb8
-  data.tar.gz: 33d309c91f3cbb341159b20f99129d0ea387a10e
+  metadata.gz: 3463cfbe49623868590249a50db750da286c65f2
+  data.tar.gz: 9dad29a26d14bbb7fd2f5a38c9d6761dc38e3710
 SHA512:
-  metadata.gz: f73b0708c03917f4a58a14bffddbd1357336154b917f0ff610511c0572fb743f12f2824647b36d7bd30972967cc41d6a887de8ae696b6318acd69236a847ec51
-  data.tar.gz: a19b6508e5c30fe4ad94ee42c0f205f8a539cc9f1311b9828feb407daf66ab99d2651f8268b418ffaf91c922c93006cfc9a03535a7ee14af676b7382ecc76c13
+  metadata.gz: 95affc545a8fd0e3d60b32b88a36f692ac1b97093991d3b33f6292559922586ed587650ed511db4a6f7af59a04d7c5a86153f7fc96dfe60f685c648d33c9b1b6
+  data.tar.gz: f907443bc27cf6917cf845da401c771377078998562cd897b010468404b8c6de1000bdefd97a4fd5eaa31942987ba25d3a4192fd11c6b892cc55152b7631708b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    data-provider (0.0.1)
+    data-provider (0.1.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -71,9 +71,9 @@ product_provider.take(:discount_price) # => TypeError (discount data not given,)
 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.add_data!(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
+product_provider.add_data!(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!)

data/data-provider.gemspec

@@ -1,9 +1,6 @@
-GEM_NAME="data-provider"
-PKG_VERSION='0.1.0'
-
 Gem::Specification.new do |s|
-  s.name = GEM_NAME
-  s.version = PKG_VERSION
+  s.name = "data-provider"
+  s.version = '0.2.0'
   s.files = `git ls-files`.split($/)
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
 

data/lib/data_provider/base.rb

@@ -2,226 +2,229 @@ require 'logger'
 
 module DataProvider
 
-  class ProviderMissingException < Exception
-  end
-
   module Base
 
     def self.included(base)
       base.class_eval do
         include InstanceMethods
+        include ProxyMethods
         extend ClassMethods
+        extend ProxyMethods
       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] || {}
+    # both instance- class-level
+    module ProxyMethods
+      def provides *args
+        return dpc.provides if args.length == 0
+        dpc.provides *args
+        return self
       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)
+      def provider_identifiers *args
+        dpc.provider_identifiers *args
       end
 
-      def provider_identifiers
-        (provides.keys + data_provider_definitions.map(&:first)).compact.uniq
+      def provider *args, &block
+        dpc.provider *args, &block
       end
 
-      # adds a new provider to the class
-      def provider identifier, opts = {}, &block
-        add_provider(identifier, opts, block_given? ? block : nil)
+      def has_provider? *args
+        dpc.has_provider? *args
       end
 
-      # reader method for the raw data of the currently defined providers
-      def data_provider_definitions
-        ((@data_provider || {})[:provider_args] || [])
+      def has_providers_with_scope?(*args)
+        dpc.has_providers_with_scope?(*args)
       end
 
-      # returns wether a provider with the given identifier is available
-      def has_provider?(identifier)
-        (provides[identifier] || get_provider(identifier)) != nil
+      def fallback_provider?
+        dpc.fallback_provider?
       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
+      def provider_missing *args, &block
+        dpc.provider_missing *args, &block
       end
 
-      def fallback_provider?
-        !fallback_provider.nil?
+      def take(id, opts = {})
+        dpc.take(id, opts.merge(:scope => self))
       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] || {})
+      def try_take(id, opts = {})
+        dpc.try_take(id, opts.merge(:scope => self))
       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') || {}
+      def got?(*args)
+        dpc.got?(*args)
+      end
 
-        (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
+      alias :has_data? :got?
 
-        (data[:provides] || {}).each_pair do |key, value|
-          provides(([_options[:scope]].flatten.compact + [key].flatten.compact) => value)
-        end
+      def given *args
+        dpc.given *args
       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
+      alias :get_data :given
 
-      def fallback_provider
-        block = (@data_provider || {})[:provider_missing]
-        block.nil? ? nil : Provider.new(nil, nil, block)
+      def give! *args
+        dpc.give! *args
+        return self
       end
 
+      alias :add_scope! :give!
+      alias :add_data! :give!
+
       private
 
-      def add_provider(identifier, opts = {}, block = nil)
-        @data_provider ||= {}
-        @data_provider[:provider_args] ||= []
-        @data_provider[:provider_args].unshift [identifier, opts, block]
+      def missing_provider *args
+        dpc.missing_provider *args
       end
-    end # module ClassMethods
-
 
-    module InstanceMethods
+      def scoped_take *args
+        dpc.scoped_take *args
+      end
 
-      attr_reader :data
-      attr_reader :options
+      def scope *args
+        dpc.scope *args
+      end
 
-      def initialize(opts = {})
-        @options = opts.is_a?(Hash) ? opts : {}
-        @data = options[:data].is_a?(Hash) ? options[:data] : {}
+      def scopes *args
+        dpc.scopes *args
       end
 
-      def logger
-        @logger ||= options[:logger] || Logger.new(STDOUT)
+      def provider_stack *args
+        dpc.provider_stack *args
       end
 
-      def has_provider?(id)
-        self.class.has_provider?(id)
+      def provider_id *args
+        dpc.provider_id *args
       end
+    end
 
-      def has_providers_with_scope?(scope)
-        self.class.has_providers_with_scope?(scope)
+    module ClassMethods
+      def data_provider_container
+        @data_provider_container ||= DataProvider::Container.new
       end
 
-      def fallback_provider?
-        self.class.fallback_provider?
+      alias :dpc :data_provider_container
+
+      # can't copy self on a class-level
+      def give *args
+        dpc.give! *args
+        return self
       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
+      # alias :give :give!
+      alias :add_scope :give
+      alias :add_data :give
 
-        # 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
+      def add! _module
+        if _module.is_a?(DataProvider::Container)
+          dpc.add!(_module)
+        else
+          dpc.add!(_module.dpc)
         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
+        include _module
+        return self
+      end
 
-        logger.debug "Try for missing provider: #{id.inspect}"
-          return nil
+      def add_scoped! _module, options = {}
+        if _module.is_a?(DataProvider::Container)
+          dpc.add_scoped!(_module, options) 
+        else
+          dpc.add_scoped! _module.dpc, options
         end
+
+        include _module
+        return self
       end
 
-      private
+      # classes/modules can't be cloned, so add behave just like add!
+      alias :add :add!
+      alias :add_scoped :add_scoped!
+    end # module ClassMethods
+
+
+    module InstanceMethods
 
-      def scoped_take(id)
-        take(((@scope || []).last || []) + [id].flatten)
+      attr_reader :options
+
+      def initialize(opts = {})
+        @options = opts.is_a?(Hash) ? opts : {}
+        dpc.give!(options[:data]) if options[:data].is_a?(Hash)
       end
 
-      public
+      def logger
+        @logger ||= options[:logger] || Logger.new(STDOUT).tap do |lger|
+          lger.level = Logger::WARN
+        end
+      end
 
-      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
+      def data_provider_container
+        @data_provider_container ||= options[:dpc] || DataProvider::Container.new.tap do |c|
+          # automatically adopt all class-level providers/provides/data
+          c.add! self.class.dpc
+        end
       end
 
-      alias :get_data :given
+      alias :dpc :data_provider_container
 
-      def give(_data = {})
-        return self.class.new(options.merge(:data => data.merge(_data)))
+      def add _module
+        if _module.is_a?(DataProvider::Container)
+          _dpc = _module
+        else
+          _dpc = _module.dpc
+          self.class.include _module # todo: make optional?
+        end
+
+        self.class.new(options.merge({
+          :data => nil,
+          :dpc => dpc.add(_dpc)
+        }))
       end
 
-      alias :add_scope :give
-      alias :add_data :give
+      def add_scoped _module, options = {}
+        if _module.is_a?(DataProvider::Container)
+          _dpc = _module
+        else
+          _dpc = _module.dpc
+          self.class.include _module # todo: make optional?
+        end
 
-      def give!(_data = {})
-        @data = data.merge(_data)
-        return self
+        self.class.new(options.merge({
+          :data => nil,
+          :dpc => dpc.add_scoped(_dpc, :scope => options[:scope])
+        }))
       end
 
-      alias :add_scope! :give!
-      alias :add_data! :give!
+      def give *args
+        self.class.new(options.merge(:data => nil, :dpc => self.dpc.give(*args)))
+      end
 
-      private
+      alias :add_scope :give
+      alias :add_data :give
 
-      def missing_provider
-        # byebug
-        @missing_provider
+      def add! _module
+        if _module.is_a?(DataProvider::Container)
+          dpc.add!(_module)
+        else
+          dpc.add!(_module.dpc)
+          self.class.include _module
+        end
+        
+        return self
       end
 
-      def scope
-        @scope || []
+      def add_scoped! _module, options = {}
+        if _module.is_a?(DataProvider::Container)
+          dpc.add_scoped!(_module, options) 
+        else
+          dpc.add_scoped! _module.dpc, options
+          self.class.include _module
+        end
+        
+        return self
       end
     end # module InstanceMethods
-
   end # module Base
-
 end # module DataProvider

data/lib/data_provider/container.rb

@@ -0,0 +1,277 @@
+module DataProvider
+
+  class ProviderMissingException < Exception
+    attr_reader :params
+
+    def initialize(_params = {})
+      @params = _params || {}
+      super(params[:message] || "Tried to take data from missing provider: #{provider_id.inspect}")
+    end
+
+    def provider_id
+      params[:provider_id]
+    end
+  end
+
+
+  class Container
+    attr_reader :options
+
+    def initialize _opts = {}
+      @options = _opts.is_a?(Hash) ? _opts : {}
+    end
+
+    def logger
+      @logger ||= options[:logger] || Logger.new(STDOUT).tap do |lger|
+        lger.level = Logger::WARN
+      end
+    end
+
+    def provider identifier, opts = {}, &block
+      add_provider(identifier, opts, block_given? ? block : nil)
+    end
+
+    def has_provider?(identifier)
+      (provides.keys.find{|k| k == 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 provider_identifiers
+      (provides.keys + providers.map(&:first)).compact.uniq
+    end
+
+    # 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 _provides = nil
+      return @provides || {} if _provides.nil?
+      add_provides _provides
+      return self
+    end
+
+    def providers
+      @providers || []
+    end
+
+    def provider_missing &block
+      raise "DataProvider::Base#provider_missing expects a block as an argument" if !block_given?
+      @fallback_provider = block
+    end
+
+    def fallback_provider
+      block = @fallback_provider
+      block.nil? ? nil : Provider.new(nil, nil, block)
+    end
+
+    def fallback_provider?
+      !fallback_provider.nil?
+    end
+
+    def take(id, opts = {})
+      logger.debug "DataProvider::Container#take with id: #{id.inspect}"
+
+      # first try the simple providers
+      if provides.has_key?(id)
+        provider = provides[id]
+        return provider.is_a?(Proc) ? provider.call : provider
+      end
+
+      # try to get a provider object
+      provider = get_provider(id)
+      if provider
+        @stack = (@stack || []) + [id]
+        result = (opts[:scope] || self).instance_eval(&provider.block) 
+        @stack.pop
+        # execute provider object's block within the scope of self
+        return result
+      end
+
+      # try to get a scoped provider object
+      if scope.length > 0
+        scoped_id = [scope, id].flatten
+        provider = get_provider(scoped_id)
+        if provider
+          @stack = (@stack || []) + [scoped_id]
+          result = (opts[:scope] || self).instance_eval(&provider.block) 
+          @stack.pop
+          # execute provider object's block within the scope of self
+          return result
+        end
+      end
+
+      # couldn't find requested provider, let's see if there's a fallback
+      if provider = 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
+        @stack = (@stack || []) + [id]
+        result = (opts[:scope] || self).instance_eval(&provider.block) # provider.block.call # with the block.call method the provider can't access private methods like missing_provider
+        @stack.pop # = nil
+        @missing_provider = nil
+        return result
+      end
+
+      # no fallback either? Time for an error
+      raise ProviderMissingException.new(:provider_id => id) 
+    end
+
+    def try_take(id, opts = {})
+      return take(id, opts) if self.has_provider?(id) || self.fallback_provider?
+      logger.debug "Try for missing provider: #{id.inspect}"
+      return nil
+    end
+
+    #
+    # "adding existing containers"-related methods
+    #
+
+    # adds all the providers defined in the given module to this class
+    def add!(container)
+      ### add container's providers ###
+      # internally providers are added in reverse order (last one first)
+      # so at runtime you it's easy and fast to grab the latest provider
+      # so when adding now, we have to reverse the providers to get them in the original order
+      container.providers.reverse.each do |definition|
+        add_provider(*definition)
+      end
+
+      ### add container's provides (simple providers) ###
+      self.provides(container.provides)
+
+      ### fallback provider ###
+      @fallback_provider = container.fallback_provider.block if container.fallback_provider
+
+      ### add container's data ###
+      give!(container.data)
+    end
+
+    def add(container)
+      # make a copy and add the container to that 
+      give({}).add!(container)
+    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! container, _options = {}
+      ### add container's providers ###
+      container.providers.reverse.each do |definition|
+        identifier = [definition[0]].flatten
+        identifier = [_options[:scope]].flatten.compact + identifier if _options[:scope]
+        add_provider(*([identifier]+definition[1..-1]))
+      end
+
+      ### add container's provides (simple providers) ###
+      container.provides.each_pair do |key, value|
+        provides(([_options[:scope]].flatten.compact + [key].flatten.compact) => value)
+      end
+
+      ### fallback provider ###
+      @fallback_provider = container.fallback_provider.block if container.fallback_provider
+
+      ### add container's data ###
+      give!(container.data)
+    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 container, _options = {}
+      copy.add_scoped!(container, _options)
+    end
+
+    #
+    # Data-related methods
+    #
+
+    def copy
+      c = self.class.new
+      c.add!(self)
+    end
+
+    def data
+      @data || {}
+    end
+
+    def give(_data = {})
+      copy.give!(_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!
+
+    def given(param_name)
+      return data[param_name] if got?(param_name)
+      logger.debug "Data provider expected missing data with identifier: #{param_name.inspect}"
+      # TODO: raise?
+      return nil
+    end
+
+    alias :get_data :given
+
+
+    def got?(param_name)
+      data.has_key?(param_name)
+    end
+
+    alias :has_data? :got?
+
+    def missing_provider
+      @missing_provider
+    end
+
+    def scoped_take(id)
+      take(scope + [id].flatten)
+    end
+
+    def provider_stack
+      (@stack || []).clone
+    end
+
+    def provider_id
+      provider_stack.last
+    end
+
+    def scopes
+      provider_stack.map{|provider_id| provider_id.is_a?(Array) ? provider_id[0..-2] : []}
+    end
+
+    def scope
+      scopes.last || []
+    end
+
+  private
+
+    def add_provider(identifier, opts = {}, block = nil)
+      @providers ||= []
+      @providers.unshift [identifier, opts, block]
+    end
+
+    def add_provides _provides = {}
+      if _provides.is_a?(Hash) != true
+        logger.error 'DataProvider::Container#add_provides received non-hash param'
+        return @provides
+      end
+
+      @provides ||= {}
+      @provides.merge! _provides
+    end
+
+    # returns the requested provider as a Provider object
+    def get_provider(id)
+      args = providers.find{|args| args.first == id}
+      return args.nil? ? nil : Provider.new(*args)
+    end
+  end # class Container
+end # module DataProvider