datasource 0.1.1 → 0.2.0

data/lib/datasource/adapters/sequel.rb

@@ -4,35 +4,43 @@ module Datasource
   module Adapters
     module Sequel
       module ScopeExtensions
-        def use_datasource_serializer(value)
-          @datasource_serializer = value
+        def self.extended(mod)
+          mod.instance_exec do
+            @datasource_info ||= { select: [], params: [] }
+          end
+        end
+
+        def datasource_set(hash)
+          @datasource_info.merge!(hash)
+          self
+        end
+
+        def datasource_select(*args)
+          @datasource_info[:select] += args
           self
         end
 
-        def use_datasource(value)
-          @datasource = value
+        def datasource_params(*args)
+          @datasource_info[:params] += args
           self
         end
 
         def get_datasource
-          datasource = @datasource.new(self)
-          datasource.select(*Array(@datasource_select))
-          if @datasource_serializer
+          klass = @datasource_info[:datasource_class]
+          datasource = klass.new(self)
+          datasource.select(*Array(@datasource_info[:select]))
+          datasource.params(*@datasource_info[:params])
+          if @datasource_info[:serializer_class]
             select = []
-            Datasource::Base.consumer_adapter.to_datasource_select(select, @datasource.orm_klass, @datasource_serializer, nil, datasource.adapter)
+            Datasource::Base.consumer_adapter.to_datasource_select(select, klass.orm_klass, @datasource_info[:serializer_class], nil, datasource.adapter)
 
             datasource.select(*select)
           end
           datasource
         end
 
-        def datasource_select(*args)
-          @datasource_select = Array(@datasource_select) + args
-          self
-        end
-
         def each(&block)
-          if @datasource
+          if @datasource_info[:datasource_class]
             datasource = get_datasource
 
             datasource.results.each(&block)
@@ -46,25 +54,31 @@ module Datasource
         extend ActiveSupport::Concern
 
         included do
-          attr_accessor :loaded_values
+          attr_accessor :_datasource_loaded, :_datasource_instance
 
           dataset_module do
-            def for_serializer(serializer = nil)
-              scope = if respond_to?(:use_datasource_serializer)
-                self
-              else
-                self.extend(ScopeExtensions).use_datasource(Adapters::Sequel.scope_to_class(self).default_datasource)
-              end
-              scope.use_datasource_serializer(serializer || Datasource::Base.consumer_adapter.get_serializer_for(Adapters::Sequel.scope_to_class(scope)))
+            def for_serializer(serializer_class = nil)
+              scope = scope_with_datasource_ext
+              serializer_class ||=
+                Datasource::Base.consumer_adapter
+                .get_serializer_for(Adapters::Sequel.scope_to_class(scope))
+              scope.datasource_set(serializer_class: serializer_class)
+            end
+
+            def with_datasource(datasource_class = nil)
+              scope_with_datasource_ext(datasource_class)
             end
 
-            def with_datasource(datasource = nil)
-              scope = if respond_to?(:use_datasource)
+          private
+            def scope_with_datasource_ext(datasource_class = nil)
+              if respond_to?(:datasource_set)
                 self
               else
+                datasource_class ||= Adapters::Sequel.scope_to_class(self).default_datasource
+
                 self.extend(ScopeExtensions)
+                .datasource_set(datasource_class: datasource_class)
               end
-              scope.use_datasource(datasource || default_datasource)
             end
           end
         end
@@ -75,7 +89,10 @@ module Datasource
 
           scope = self.class
           .with_datasource(datasource_class)
-          .for_serializer(serializer).where(pk => send(pk))
+          .for_serializer(serializer)
+          .where(pk => send(pk))
+
+          scope = yield(scope) if block_given?
 
           datasource = scope.get_datasource
           if datasource.can_upgrade?(self)
@@ -134,11 +151,15 @@ module Datasource
         false
       end
 
+      def scope_to_records(scope)
+        scope.all
+      end
+
       def has_attribute?(record, name)
         record.values.key?(name.to_sym)
       end
 
-      def get_assoc_eager_options(klass, name, assoc_select, append_select)
+      def get_assoc_eager_options(klass, name, assoc_select, append_select, params)
         if reflection = association_reflection(klass, name)
           self_append_select = []
           Datasource::Base.reflection_select(reflection, append_select, self_append_select)
@@ -150,6 +171,7 @@ module Datasource
             name => ->(ds) {
               ds.with_datasource(datasource_class)
               .datasource_select(*(assoc_select + self_append_select))
+              .datasource_params(params)
             }
           }
         else
@@ -170,6 +192,7 @@ module Datasource
       end
 
       def upgrade_records(ds, records)
+        Datasource.logger.debug { "Upgrading records #{records.map(&:class).map(&:name).join(', ')}" }
         get_final_scope(ds).send :post_load, records
         ds.results(records)
       end
@@ -179,12 +202,12 @@ module Datasource
         append_select = []
         ds.expose_associations.each_pair do |assoc_name, assoc_select|
           eager.merge!(
-            get_assoc_eager_options(ds.class.orm_klass, assoc_name.to_sym, assoc_select, append_select))
+            get_assoc_eager_options(ds.class.orm_klass, assoc_name.to_sym, assoc_select, append_select, ds.params))
         end
         # TODO: remove/disable datasource on scope if present
         scope = select_scope(ds)
-        if scope.respond_to?(:use_datasource)
-          scope = scope.clone.use_datasource(nil)
+        if scope.respond_to?(:datasource_set)
+          scope = scope.clone.datasource_set(datasource_class: nil)
         end
         scope
         .select_append(*get_sequel_select_values(append_select.map { |v| primary_scope_table(ds) + ".#{v}" }))

data/lib/datasource/attributes/loaded.rb

@@ -0,0 +1,101 @@
+module Datasource
+  module Attributes
+    class Loaded
+      class << self
+        attr_accessor :_options
+
+        def inherited(base)
+          base._options = (_options || {}).dup
+        end
+
+        def options(hash)
+          self._options.merge!(hash)
+        end
+
+        def default_value
+          self._options[:default]
+        end
+
+        def load(collection_context)
+          loader = collection_context.method(_options[:source])
+          args = [collection_context].slice(0, loader.arity) if loader.arity >= 0
+          results = loader.call(*args)
+
+          if _options[:group_by]
+            results = Array(results)
+            send_args = if results.first && results.first.kind_of?(Hash)
+              [:[]]
+            else
+              []
+            end
+
+            if _options[:one]
+              results.inject(empty_hash) do |hash, r|
+                key = r.send(*send_args, _options[:group_by])
+                hash[key] = r
+                hash
+              end
+            else
+              results.inject(empty_hash) do |hash, r|
+                key = r.send(*send_args, _options[:group_by])
+                (hash[key] ||= []).push(r)
+                hash
+              end
+            end
+          elsif _options[:from] == :array
+            Array(results).inject(empty_hash) do |hash, r|
+              hash[r[0]] = r[1]
+              hash
+            end
+          else
+            set_hash_default(Hash(results))
+          end
+        end
+
+      private
+        def set_hash_default(hash)
+          hash.default = default_value
+          hash
+        end
+
+        def empty_hash
+          set_hash_default(Hash.new)
+        end
+      end
+    end
+  end
+
+  class Datasource::Base
+  private
+    def self.loaded(name, _options = {}, &block)
+      name = name.to_sym
+      datasource_class = self
+      loader_class = Class.new(Attributes::Loaded) do
+        options(_options.reverse_merge(source: :"load_#{name}"))
+      end
+      @_loaders[name] = loader_class
+      @_loader_order << name
+
+      method_module = Module.new do
+        define_method name do |*args, &block|
+          if _datasource_loaded
+            if _datasource_loaded.key?(name)
+              _datasource_loaded[name]
+            else
+              fail Datasource::Error, "loader #{name} called but was not selected"
+            end
+          elsif defined?(super)
+            super(*args, &block)
+          else
+            method_missing(name, *args, &block)
+          end
+        end
+      end
+
+      orm_klass.class_eval do
+        prepend method_module
+      end
+      computed name, loader: name
+    end
+  end
+end

data/lib/datasource/base.rb

@@ -1,13 +1,15 @@
 module Datasource
   class Base
     class << self
-      attr_accessor :_attributes, :_associations, :_update_scope, :_loaders
+      attr_accessor :_attributes, :_associations, :_update_scope, :_loaders, :_loader_order, :_collection_context
       attr_writer :orm_klass
 
       def inherited(base)
         base._attributes = (_attributes || {}).dup
         base._associations = (_associations || {}).dup
         base._loaders = (_loaders || {}).dup
+        base._loader_order = (_loader_order || []).dup
+        base._collection_context = Class.new(_collection_context || CollectionContext)
       end
 
       def default_adapter
@@ -39,6 +41,10 @@ module Datasource
         end
       end
 
+      def collection(&block)
+        _collection_context.class_exec(&block)
+      end
+
     private
       def attributes(*attrs)
         attrs.each { |name| attribute(name) }
@@ -84,6 +90,21 @@ module Datasource
       @expose_attributes = []
       @expose_associations = {}
       @select_all_columns = false
+      @params = {}
+    end
+
+    def params(*args)
+      args.each do |arg|
+        if arg.kind_of?(Hash)
+          @params.deep_merge!(arg.symbolize_keys)
+        elsif arg.is_a?(Symbol)
+          @params.merge!(arg => true)
+        else
+          fail Datasource::Error, "unknown parameter type #{arg.class}"
+        end
+      end
+
+      @params
     end
 
     def select_all_columns
@@ -230,39 +251,79 @@ module Datasource
       adapter.upgrade_records(self, Array(records))
     end
 
-    def results(rows = nil)
-      rows ||= adapter.get_rows(self)
+    def get_collection_context(rows)
+      self.class._collection_context.new(@scope, rows, self, @params)
+    end
 
-      unless rows.empty?
-        @expose_attributes.each do |name|
-          att = self.class._attributes[name]
-          klass = att[:klass]
-          next unless klass
-
-          if att[:klass].ancestors.include?(Attributes::ComputedAttribute)
-            att[:klass]._loader_depends.each do |name|
-              if loader = self.class._loaders[name]
-                if loaded_values = loader.load(rows.map(&self.class.primary_key), rows, @scope)
-                  unless rows.first.loaded_values
-                    rows.each do |row|
-                      row.loaded_values = {}
-                    end
-                  end
-                  rows.each do |row|
-                    key = row.send(self.class.primary_key)
-                    if loaded_values.key?(key)
-                      row.loaded_values[name] = loaded_values[key]
-                    elsif loader.default_value
-                      row.loaded_values[name] = loader.default_value
-                    end
-                  end
-                end
-              else
-                raise Datasource::Error, "loader with name :#{name} could not be found"
+    def get_exposed_loaders
+      @expose_attributes
+      .map { |name|
+        self.class._attributes[name]
+      }.select { |att|
+        att[:klass] && att[:klass].ancestors.include?(Attributes::ComputedAttribute)
+      }.flat_map { |att|
+        att[:klass]._loader_depends
+      }.uniq
+      .sort_by { |loader_name|
+        self.class._loader_order.index(loader_name)
+      }
+    end
+
+    def run_loaders(rows)
+      return if rows.empty?
+
+      # check if loaders have already been ran
+      if rows.first._datasource_loaded
+        # not frequent, so we can afford to check all rows
+        check_list = get_exposed_loaders
+        run_list = []
+        rows.each do |row|
+          if row._datasource_loaded
+            check_list.delete_if do |name|
+              if !row._datasource_loaded.key?(name)
+                run_list << name
+                true
               end
             end
+            break if check_list.empty?
+          else
+            run_list.concat(check_list)
+            break
           end
         end
+      else
+        # most frequent case - loaders haven't been ran
+        run_list = get_exposed_loaders
+      end
+
+      get_collection_context(rows).tap do |collection_context|
+        run_list.each do |loader_name|
+          loader =
+            self.class._loaders[loader_name] or
+            fail Datasource::Error, "loader with name :#{loader_name} could not be found"
+          Datasource.logger.info { "Running loader #{loader_name} for #{rows.first.try!(:class)}" }
+          collection_context.loaded_values[loader_name] = loader.load(collection_context)
+        end
+      end
+    end
+
+    def set_row_loaded_values(collection_context, row)
+      row._datasource_loaded ||= {}
+
+      primary_key = row.send(self.class.primary_key)
+      collection_context.loaded_values.each_pair do |name, values|
+        row._datasource_loaded[name] = values[primary_key]
+      end
+    end
+
+    def results(rows = nil)
+      rows ||= adapter.get_rows(self)
+
+      collection_context = run_loaders(rows)
+
+      rows.each do |row|
+        row._datasource_instance = self
+        set_row_loaded_values(collection_context, row) if collection_context
       end
 
       rows

data/lib/datasource/collection_context.rb

@@ -0,0 +1,32 @@
+module Datasource
+  class CollectionContext
+    attr_reader :scope, :all_models, :datasource, :datasource_class, :params, :loaded_values
+
+    def initialize(scope, collection, datasource, params)
+      @scope = scope
+      @all_models = collection
+      @datasource = datasource
+      @datasource_class = datasource.class
+      @params = params
+      @loaded_values = {}
+    end
+
+    def models
+      return @models if @models
+
+      @model_ids = []
+      @models = all_models.select do |model|
+        id = model.send(@datasource_class.primary_key)
+        @model_ids << id
+        id
+      end
+    end
+
+    def model_ids
+      return @model_ids if @model_ids
+      models
+      @model_ids
+    end
+    alias_method :ids, :model_ids
+  end
+end

data/lib/datasource/consumer_adapters/active_model_serializers.rb

@@ -10,9 +10,20 @@ module Datasource
           if adapter && !adapter.scope_loaded?(objects)
             datasource_class ||= adapter.scope_to_class(objects).default_datasource
 
-            records = objects
+            scope = begin
+              objects
               .with_datasource(datasource_class)
-              .for_serializer(options[:serializer]).all.to_a # all needed for Sequel eager loading
+              .for_serializer(options[:serializer])
+              .datasource_params(*[options[:datasource_params]].compact)
+            rescue NameError
+              if options[:serializer].nil?
+                return initialize_without_datasource(objects, options)
+              else
+                raise
+              end
+            end
+
+            records = adapter.scope_to_records(scope)
 
             initialize_without_datasource(records, options)
           else
@@ -37,8 +48,13 @@ module Datasource
         adapter ||= Datasource::Base.default_adapter
         serializer ||= get_serializer_for(klass, serializer_assoc)
         result.unshift("*") if Datasource.config.simple_mode
-        result.concat(serializer._attributes)
-        result_assocs = {}
+        if serializer._attributes.respond_to?(:keys)  # AMS 0.8
+          result.concat(serializer._attributes.keys)
+        else                                          # AMS 0.9
+          result.concat(serializer._attributes)
+        end
+        result.concat(serializer.datasource_select)
+        result_assocs = serializer.datasource_includes.dup
         result.push(result_assocs)
 
         serializer._associations.each_pair do |name, serializer_assoc|
@@ -74,3 +90,49 @@ array_serializer_class.class_exec do
     initialize_with_datasource(*args)
   end
 end
+
+module SerializerClassMethods
+  def inherited(base)
+    base.datasource_select(*datasource_select.deep_dup)
+    base.datasource_includes(*datasource_includes.deep_dup)
+
+    super
+  end
+
+  def datasource_select(*args)
+    @datasource_select ||= []
+    @datasource_select.concat(args)
+
+    @datasource_select
+  end
+
+  def datasource_includes(*args)
+    @datasource_includes ||= {}
+
+    args.each do |arg|
+      @datasource_includes.deep_merge!(datasource_includes_to_select(arg))
+    end
+
+    @datasource_includes
+  end
+
+private
+  def datasource_includes_to_select(arg)
+    if arg.kind_of?(Hash)
+      arg.keys.inject({}) do |memo, key|
+        memo[key.to_sym] = ["*", datasource_includes_to_select(arg[key])]
+        memo
+      end
+    elsif arg.kind_of?(Array)
+      arg.inject({}) do |memo, element|
+        memo.deep_merge!(datasource_includes_to_select(element))
+      end
+    elsif arg.respond_to?(:to_sym)
+      { arg.to_sym => ["*"] }
+    else
+      fail Datasource::Error, "unknown includes value type #{arg.class}"
+    end
+  end
+end
+
+ActiveModel::Serializer.singleton_class.send :prepend, SerializerClassMethods

data/lib/datasource.rb

@@ -1,5 +1,7 @@
 require 'datasource/configuration'
 module Datasource
+  mattr_accessor :logger
+
   Error = Class.new(StandardError)
   RecursionError = Class.new(StandardError)
   include Configuration
@@ -13,12 +15,17 @@ module Datasource
   }
 
 module_function
-  def load(*adapters)
-    unless adapters.empty?
-      warn "[DEPRECATION] passing adapters to Datasource.load is deprecated. Use Datasource.setup instead."
-      config.adapters = adapters
+  def setup
+    self.logger ||= Logger.new(STDOUT).tap do |logger|
+      logger.level = Logger::WARN
+      logger.formatter = proc do |severity, datetime, progname, msg|
+        "[Datasource][#{severity}] - #{msg}\n"
+      end
+      logger
     end
 
+    yield(config)
+
     config.adapters.each do |adapter|
       adapter = AdapterPaths[adapter]
       adapter = AdapterPaths[adapter] if adapter.is_a?(Symbol)
@@ -26,11 +33,6 @@ module_function
     end
   end
 
-  def setup
-    yield(config)
-    load
-  end
-
   def orm_adapters
     @orm_adapters ||= begin
       Datasource::Adapters.constants.map { |name| Datasource::Adapters.const_get(name) }
@@ -38,10 +40,9 @@ module_function
   end
 end
 
+require 'datasource/collection_context'
 require 'datasource/base'
 
 require 'datasource/attributes/computed_attribute'
 require 'datasource/attributes/query_attribute'
-require 'datasource/attributes/loader'
-
-require 'datasource/serializer'
+require 'datasource/attributes/loaded'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datasource
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Jan Berdajs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-11 00:00:00.000000000 Z
+date: 2015-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -136,15 +136,15 @@ files:
 - lib/datasource/adapters/active_record.rb
 - lib/datasource/adapters/sequel.rb
 - lib/datasource/attributes/computed_attribute.rb
-- lib/datasource/attributes/loader.rb
+- lib/datasource/attributes/loaded.rb
 - lib/datasource/attributes/query_attribute.rb
 - lib/datasource/base.rb
+- lib/datasource/collection_context.rb
 - lib/datasource/configuration.rb
 - lib/datasource/consumer_adapters/active_model_serializers.rb
-- lib/datasource/serializer.rb
 - lib/generators/datasource/install_generator.rb
 - lib/generators/datasource/templates/initializer.rb
-homepage: https://github.com/mrbrdo/datasource
+homepage: https://github.com/kundi/datasource
 licenses:
 - MIT
 metadata: {}
@@ -164,8 +164,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Ruby library to automatically preload records for your serializers
+summary: Ruby library to automatically preload data for your serializers
 test_files: []