datasource 0.0.1 → 0.0.2

data/lib/datasource/adapters/sequel.rb

@@ -0,0 +1,200 @@
+require 'set'
+
+module Datasource
+  module Adapters
+    module Sequel
+      module ScopeExtensions
+        def use_datasource_serializer(value)
+          @datasource_serializer = value
+          self
+        end
+
+        def use_datasource(value)
+          @datasource = value
+          self
+        end
+
+        def datasource_select(*args)
+          @datasource_select = Array(@datasource_select) + args
+          self
+        end
+
+        def each(&block)
+          if @datasource
+            datasource = @datasource.new(self)
+            datasource.select(*Array(@datasource_select))
+            if @datasource_serializer
+              select = []
+              Datasource::Base.consumer_adapter.to_datasource_select(select, @datasource.orm_klass, @datasource_serializer)
+
+              datasource.select(*select)
+            end
+
+            datasource.results.each(&block)
+          else
+            super
+          end
+        end
+      end
+
+      module Model
+        extend ActiveSupport::Concern
+
+        included do
+          attr_accessor :loaded_values
+
+          dataset_module do
+            def for_serializer(serializer = nil)
+              scope = if respond_to?(:use_datasource_serializer)
+                self
+              else
+                self.extend(ScopeExtensions).use_datasource(default_datasource)
+              end
+              scope.use_datasource_serializer(serializer || Datasource::Base.consumer_adapter.get_serializer_for(Adapters::Sequel.scope_to_class(scope)))
+            end
+
+            def with_datasource(datasource = nil)
+              scope = if respond_to?(:use_datasource)
+                self
+              else
+                self.extend(ScopeExtensions)
+              end
+              scope.use_datasource(datasource || default_datasource)
+            end
+          end
+        end
+
+        module ClassMethods
+          def default_datasource
+            @default_datasource ||= Class.new(Datasource::From(self))
+          end
+
+          def datasource_module(&block)
+            default_datasource.instance_exec(&block)
+          end
+        end
+      end
+
+      def self.association_reflection(klass, name)
+        reflection = klass.association_reflections[name]
+
+        macro = case reflection[:type]
+        when :many_to_one then :belongs_to
+        when :one_to_many then :has_many
+        when :one_to_one then :has_one
+        else
+          fail Datasource::Error, "unimplemented association type #{reflection[:type]} - TODO"
+        end
+        {
+          klass: reflection[:cache][:class] || reflection[:class_name].constantize,
+          macro: macro,
+          foreign_key: reflection[:key].try!(:to_s)
+        }
+      end
+
+      def self.get_table_name(klass)
+        klass.table_name
+      end
+
+      def self.is_scope?(obj)
+        obj.kind_of?(::Sequel::Dataset)
+      end
+
+      def self.scope_to_class(scope)
+        if scope.row_proc && scope.row_proc.ancestors.include?(::Sequel::Model)
+          scope.row_proc
+        else
+          fail Datasource::Error, "unable to determine model for scope"
+        end
+      end
+
+      def to_query(scope)
+        scope.sql
+      end
+
+      def select_scope
+        @scope.select(*get_sequel_select_values)
+      end
+
+      def get_rows
+        eager = {}
+        append_select = []
+        @expose_associations.each_pair do |assoc_name, assoc_select|
+          eager.merge!(
+            get_assoc_eager_options(self.class.orm_klass, assoc_name.to_sym, assoc_select, append_select))
+        end
+        # TODO: remove/disable datasource on scope if present
+        scope = select_scope
+        if scope.respond_to?(:use_datasource)
+          scope = scope.clone.use_datasource(nil)
+        end
+        scope
+        .select_append(*get_sequel_select_values(append_select.map { |v| primary_scope_table(@scope) + ".#{v}" }))
+        .eager(eager).all
+      end
+
+      def get_assoc_eager_options(klass, name, assoc_select, append_select)
+        if reflection = Adapters::Sequel.association_reflection(klass, name)
+          self_append_select = []
+          Datasource::Base.reflection_select(reflection, append_select, self_append_select)
+          assoc_class = reflection[:klass]
+
+          datasource_class = assoc_class.default_datasource
+
+          {
+            name => ->(ds) {
+              ds.with_datasource(datasource_class)
+              .datasource_select(*(self_append_select + assoc_select))
+            }
+          }
+        else
+          {}
+        end
+      end
+
+      def get_sequel_select_values(values = nil)
+        (values || get_select_values).map { |str| ::Sequel.lit(str) }
+      end
+
+      def primary_scope_table(scope)
+        scope.first_source_alias.to_s
+      end
+
+      def ensure_table_join!(name, att)
+        join_value = Hash(@scope.opts[:join]).find do |value|
+          (value.table_alias || value.table).to_s == att[:name]
+        end
+        fail Datasource::Error, "given scope does not join on #{name}, but it is required by #{att[:name]}" unless join_value
+      end
+
+      module DatasourceGenerator
+        def From(klass)
+          if klass.ancestors.include?(::Sequel::Model)
+            Class.new(Datasource::Base) do
+              attributes *klass.columns
+              associations *klass.associations
+
+              define_singleton_method(:orm_klass) do
+                klass
+              end
+
+              define_method(:primary_key) do
+                klass.primary_key
+              end
+            end
+          else
+            super if defined?(super)
+          end
+        end
+      end
+    end
+  end
+
+  extend Adapters::Sequel::DatasourceGenerator
+end
+
+if not(::Sequel::Model.respond_to?(:datasource_module))
+  class ::Sequel::Model
+    include Datasource::Adapters::Sequel::Model
+  end
+end

data/lib/datasource/attributes/computed_attribute.rb

@@ -11,30 +11,26 @@ module Datasource
         def depends(*args)
           args.each do |dep|
             _depends.deep_merge!(dep)
-            dep.values.each do |names|
-              Array(names).each do |name|
-                define_method(name) do
-                  @depend_values[name.to_s]
-                end
-              end
-            end
           end
         end
       end
-
-      def initialize(depend_values)
-        @depend_values = depend_values
-      end
     end
   end
 
   class Datasource::Base
-    def self.computed_attribute(name, deps, &block)
-      klass = Class.new(Attributes::ComputedAttribute) do
-        depends deps
+  private
+    def self.computed(name, *_deps)
+      deps = _deps.select { |dep| dep.kind_of?(Hash) }
+      _deps.reject! { |dep| dep.kind_of?(Hash) }
+      unless _deps.empty?
+        self_key = adapter.get_table_name(orm_klass)
+        deps.push(self_key => _deps)
+      end
 
-        define_method(:value, &block)
+      klass = Class.new(Attributes::ComputedAttribute) do
+        depends *deps
       end
+
       attribute name, klass
     end
   end

data/lib/datasource/attributes/loader.rb

@@ -0,0 +1,65 @@
+module Datasource
+  module Attributes
+    class Loader
+      class << self
+        attr_accessor :_options
+        attr_accessor :_load_proc
+
+        def inherited(base)
+          base._options = (_options || {}).dup
+        end
+
+        def options(hash)
+          self._options.merge!(hash)
+        end
+
+        def load(*args, &block)
+          args = args.slice(0, _load_proc.arity) if _load_proc.arity >= 0
+          results = _load_proc.call(*args, &block)
+
+          if _options[:group_by]
+            results = Array(results)
+            send_args = if results.first && results.first.kind_of?(Hash)
+              [:[]]
+            else
+              []
+            end
+
+            if _options[:one]
+              results.inject({}) do |hash, r|
+                key = r.send(*send_args, _options[:group_by])
+                hash[key] = r
+                hash
+              end
+            else
+              results.inject({}) do |hash, r|
+                key = r.send(*send_args, _options[:group_by])
+                (hash[key] ||= []).push(r)
+                hash
+              end
+            end
+          elsif _options[:array_to_hash]
+            Array(results).inject({}) do |hash, r|
+              hash[r[0]] = r[1]
+              hash
+            end
+          else
+            results
+          end
+        end
+      end
+    end
+  end
+
+  class Datasource::Base
+  private
+    def self.loader(name, _options = {}, &block)
+      klass = Class.new(Attributes::Loader) do
+        # depends deps
+        options(_options)
+        self._load_proc = block
+      end
+      @_loaders[name.to_sym] = klass
+    end
+  end
+end

data/lib/datasource/attributes/query_attribute.rb

@@ -16,11 +16,16 @@ module Datasource
   end
 
   class Datasource::Base
-    def self.query_attribute(name, deps, &block)
+  private
+    def self.query(name, deps = nil, value = nil, &block)
       klass = Class.new(Attributes::QueryAttribute) do
-        depends deps
+        depends deps if deps
 
-        define_method(:select_value, &block)
+        if block
+          define_singleton_method(:select_value, &block)
+        else
+          define_singleton_method(:select_value) { value }
+        end
       end
       attribute name, klass
     end

data/lib/datasource/base.rb

@@ -1,96 +1,189 @@
 module Datasource
   class Base
     class << self
-      attr_accessor :_attributes, :_virtual_attributes, :_associations
-      attr_accessor :adapter
+      attr_accessor :_attributes, :_associations, :_update_scope, :_loaders
+      attr_writer :orm_klass
 
       def inherited(base)
-        base._attributes = (_attributes || []).dup
-        @adapter ||= Datasource::Adapters::ActiveRecord
-        self.send :include, @adapter
+        base._attributes = (_attributes || {}).dup
+        base._associations = (_associations || {}).dup
+        base._loaders = (_loaders || {}).dup
+        self.send :include, adapter
       end
 
+      def adapter
+        @adapter ||= begin
+          Datasource::Adapters.const_get(Datasource::Adapters.constants.first)
+        end
+      end
+
+      def consumer_adapter
+        @consumer_adapter = Datasource::ConsumerAdapters::ActiveModelSerializers
+      end
+
+      def orm_klass
+        fail Datasource::Error, "Model class not set for #{name}. You should define it:\nclass YourDatasource\n  @orm_klass = MyModelClass\nend"
+      end
+
+      def reflection_select(reflection, parent_select, assoc_select)
+        # append foreign key depending on assoication
+        if reflection[:macro] == :belongs_to
+          parent_select.push(reflection[:foreign_key])
+        elsif [:has_many, :has_one].include?(reflection[:macro])
+          assoc_select.push(reflection[:foreign_key])
+        else
+          fail Datasource::Error, "unsupported association type #{reflection[:macro]} - TODO"
+        end
+      end
+
+    private
       def attributes(*attrs)
         attrs.each { |name| attribute(name) }
       end
 
+      def associations(*assocs)
+        assocs.each { |name| association(name) }
+      end
+
+      def association(name)
+        @_associations[name.to_s] = true
+      end
+
       def attribute(name, klass = nil)
-        @_attributes.push name: name.to_s, klass: klass
+        att = { name: name.to_s, klass: klass }
+        @_attributes[att[:name]] = att
       end
 
-      def includes_many(name, klass, foreign_key)
-        @_attributes.push name: name.to_s, klass: klass, foreign_key: foreign_key.to_s, id_key: self::ID_KEY
+      def update_scope(&block)
+        # TODO: careful about scope module extension, to_a infinite recursion
+        @_update_scope = block
+      end
+
+      def group_by_column(column, rows, remove_column = false)
+        rows.inject({}) do |map, row|
+          map[row[column]] = row
+          row.delete(column) if remove_column
+          map
+        end
       end
     end
 
     def initialize(scope)
-      @scope = scope
+      @scope =
+        if self.class._update_scope
+          self.class._update_scope.call(scope)
+        else
+          scope
+        end
       @expose_attributes = []
-      @datasource_data = {}
+      @expose_associations = {}
+    end
+
+    def primary_key
+      :id
+    end
+
+    def select_all
+      @expose_attributes = self.class._attributes.keys.dup
     end
 
     def select(*names)
-      names = names.flat_map do |name|
+      failure = ->(name) { fail Datasource::Error, "attribute or association #{name} doesn't exist for #{self.class.orm_klass.name}, did you forget to call \"computed :#{name}, <dependencies>\" in your datasource_module?" }
+      names.each do |name|
         if name.kind_of?(Hash)
-          # datasource data
-          name.each_pair do |k, v|
-            @datasource_data[k.to_s] = v
+          name.each_pair do |assoc_name, assoc_select|
+            assoc_name = assoc_name.to_s
+            if self.class._associations.key?(assoc_name)
+              @expose_associations[assoc_name] ||= []
+              @expose_associations[assoc_name] += Array(assoc_select)
+              @expose_associations[assoc_name].uniq!
+            else
+              failure.call(assoc_name)
+            end
           end
-          name.keys
         else
-          name
+          name = name.to_s
+          if self.class._attributes.key?(name)
+            @expose_attributes.push(name)
+          else
+            failure.call(name)
+          end
         end
       end
-      @expose_attributes = (@expose_attributes + names.map(&:to_s)).uniq
+      @expose_attributes.uniq!
       self
     end
 
-    def attribute_exposed?(name)
-      @expose_attributes.include?(name)
-    end
+    def get_select_values
+      scope_table = primary_scope_table(@scope)
+      select_values = Set.new
+      select_values.add("#{scope_table}.#{primary_key}")
 
-    def to_query
-      to_query(@scope)
+      self.class._attributes.values.each do |att|
+        if attribute_exposed?(att[:name])
+          if att[:klass] == nil
+            select_values.add("#{scope_table}.#{att[:name]}")
+          elsif att[:klass].ancestors.include?(Attributes::ComputedAttribute)
+            att[:klass]._depends.keys.map(&:to_s).each do |name|
+              next if name == scope_table
+              next if name == "loaders"
+              ensure_table_join!(name, att)
+            end
+            att[:klass]._depends.each_pair do |table, names|
+              next if table.to_sym == :loaders
+              Array(names).each do |name|
+                select_values.add("#{table}.#{name}")
+              end
+              # TODO: handle depends on virtual attribute
+            end
+          elsif att[:klass].ancestors.include?(Attributes::QueryAttribute)
+            select_values.add("(#{att[:klass].select_value}) as #{att[:name]}")
+            att[:klass]._depends.each do |name|
+              next if name == scope_table
+              ensure_table_join!(name, att)
+            end
+          end
+        end
+      end
+      select_values.to_a
     end
 
-    def results
-      rows = get_rows(@scope)
-
-      attribute_map = self.class._attributes.inject({}) do |hash, att|
-        hash[att[:name]] = att
-        hash
-      end
+    def attribute_exposed?(name)
+      @expose_attributes.include?(name.to_s)
+    end
 
-      computed_expose_attributes = []
-      datasources = {}
+    def results(rows = nil)
+      rows ||= get_rows
 
       @expose_attributes.each do |name|
-        att = attribute_map[name]
+        att = self.class._attributes[name]
+        fail Datasource::Error, "attribute #{name} doesn't exist for #{self.class.orm_klass.name}, did you forget to call \"computed :#{name}, <dependencies>\" in your datasource_module?" unless att
         klass = att[:klass]
         next unless klass
 
-        if klass.ancestors.include?(Attributes::ComputedAttribute)
-          computed_expose_attributes.push(att)
-        elsif klass.ancestors.include?(Base)
-          datasources[att] =
-            included_datasource_rows(att, @datasource_data[att[:name]], rows)
-        end
-      end
+        next if rows.empty?
 
-      # TODO: field names...
-      rows.each do |row|
-        computed_expose_attributes.each do |att|
-          klass = att[:klass]
-          if klass
-            row[att[:name]] = klass.new(row).value
+        if att[:klass].ancestors.include?(Attributes::ComputedAttribute)
+          loaders = att[:klass]._depends[:loaders]
+          if loaders
+            Array(loaders).each do |name|
+              if loader = self.class._loaders[name]
+                if loaded_values = loader.load(rows.map(&primary_key), rows, @scope)
+                  unless rows.first.loaded_values
+                    rows.each do |row|
+                      row.loaded_values = {}
+                    end
+                  end
+                  rows.each do |row|
+                    row.loaded_values[name] = loaded_values[row.send(primary_key)]
+                  end
+                end
+              else
+                raise Datasource::Error, "loader with name :#{name} could not be found"
+              end
+            end
           end
         end
-        datasources.each_pair do |att, rows|
-          row[att[:name]] = Array(rows[row[att[:id_key]]])
-        end
-        row.delete_if do |key, value|
-          !attribute_exposed?(key)
-        end
       end
 
       rows

data/lib/datasource/consumer_adapters/active_model_serializers.rb

@@ -0,0 +1,66 @@
+require "active_model/serializer"
+
+module Datasource
+  module ConsumerAdapters
+    module ActiveModelSerializers
+      superclass = if defined?(ActiveModel::Serializer::ArraySerializer)
+        ActiveModel::Serializer::ArraySerializer
+      else
+        ActiveModel::ArraySerializer
+      end
+      class ArraySerializer < superclass
+        def initialize(objects, options = {})
+          datasource_class = options.delete(:datasource)
+          adapter = Datasource::Base.adapter
+          if adapter.is_scope?(objects)
+            datasource_class ||= adapter.scope_to_class(objects).default_datasource
+
+            records = objects
+              .with_datasource(datasource_class)
+              .for_serializer(options[:serializer]).all.to_a # all needed for Sequel eager loading
+
+            super(records, options)
+          else
+            super
+          end
+        end
+      end
+
+    module_function
+      def get_serializer_for(klass, serializer_assoc = nil)
+        serializer = if serializer_assoc
+          if serializer_assoc.kind_of?(Hash)
+            serializer_assoc[:options].try(:[], :serializer)
+          else
+            serializer_assoc.options[:serializer]
+          end
+        end
+        serializer || "#{klass.name}Serializer".constantize
+      end
+
+      def to_datasource_select(result, klass, serializer = nil, serializer_assoc = nil)
+        serializer ||= get_serializer_for(klass, serializer_assoc)
+        result.concat(serializer._attributes)
+        result_assocs = {}
+        result.push(result_assocs)
+
+        serializer._associations.each_pair do |name, serializer_assoc|
+          # TODO: what if assoc is renamed in serializer?
+          reflection = Datasource::Base.adapter.association_reflection(klass, name.to_sym)
+          assoc_class = reflection[:klass]
+
+          name = name.to_s
+          result_assocs[name] = []
+          to_datasource_select(result_assocs[name], assoc_class, nil, serializer_assoc)
+        end
+      rescue Exception => ex
+        if ex.is_a?(SystemStackError) || ex.is_a?(Datasource::RecursionError)
+          fail Datasource::RecursionError, "recursive association (involving #{klass.name})"
+        else
+          raise
+        end
+      end
+    end
+  end
+  ArrayAMS = ConsumerAdapters::ActiveModelSerializers::ArraySerializer
+end