active_any 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe7ee5723d9362864d198ce08fea398a304bed1e
-  data.tar.gz: f3bd88f1d456569eeed90e9471336a0c63f65ceb
+  metadata.gz: 7c70ba8be173563a70f75ae70628ddddb8dc66b9
+  data.tar.gz: 3b21c6608095ba05c84b2ab1256771434a567a75
 SHA512:
-  metadata.gz: c429d20676d4b11e0ff92d22ffbea558198b148ed871c6ab2be531bb374b00b96f214c88ee54e5a812d836823aec646987a1ec847a3409a085187279658f15ca
-  data.tar.gz: 2ef9773b72a9063711f83615dedf345457f08146f839afefd160bdbbedb2d741b85784051c7d462527e04038e5170bbb2848cdf5b882d52203faeeb99e16e50c
+  metadata.gz: 7e7c7311ed6633a140b529ce3acdadd7858e728322f15707c45a93a2980d14f271b3fd23e8f385604a1f9a3512dea1451ff00c93037d31c172762e3912c9951a
+  data.tar.gz: d3eccc65ad03a3b637bfd49ceb52f87702a36ffc58e5b74b3c11cadf65085f2ee381b671b6fba517e01f582589b185d5367f61449aabbd20ba9d350c942a4992

data/.travis.yml

@@ -1,5 +1,18 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.4.1
-before_install: gem install bundler -v 1.15.1
+- 2.2.7
+- 2.3.4
+- 2.4.1
+before_install:
+- gem update --system
+- gem install bundler -v 1.15.3
+cache: bundler
+script:
+- bundle exec rubocop
+- bundle exec rake test
+notifications:
+  slack:
+    secure: S1W/Lw+dH3wb8FfkMIWPZmr6M4Q6S2WMkSlanpKva1HM7K5QL7hXdmUl2yBUxJE26BHSsb1ScozMEzadyda2+i/W34UvZ7LXgKeHkUKEdjy/AmsSJPK1ZjMfgnv10tVgbEIusNb4bF/sSuChdZKK3ILwOlqIPDlQNdMwF1xRA2xt5J7tb26UgyIzoCI4P3bJYMULWsEkk+UwHiJH0YO9ulkTZI/j0N+hLXQLJTZPjmKtMk/tE0NbBmFVL4md89hUcR5gKTGGrNzEMJ58K+zqeDG/DubkcIbA5ZuqKv+oE5m0pDODZExxnC+oeENTvq/VfYwOfD0pTDrBNYjj+Bm3YiyGDzQAgov9XPDG8g/fKEs/LNAT79UZXkZlFO99Yn/vrYH9o5DKpOE9smENUXylb55MgLTUiYe17CTp7pB3trbJl3wwIbLjSmTjAdSUNgPv8qDP4uk3K4U32mknXCDDkU9EI7f6F731ocdoxsGarEBcPcgjs73Y84iwDteQp847Gigtgo4Y4TCWH657uzLolR2O8NSw+vWT0VNI9qtR5PZD7iVYtSp1qHtPAKowCztodewY2Nu+Ds9Z95udf4GPUkFg/SNEJPTPrQFLiiJZ8UYP8NJEuA+IP1tc2zG3zU/ADrjenRC1ZiupQG7OMH82y11408U6PcHFSlF+7NuDkac=
+    on_success: change
+    on_failure: always

data/README.md

@@ -1,8 +1,10 @@
 # ActiveAny
 
+[![Build Status](https://travis-ci.org/yuemori/active_any.svg?branch=master)](https://travis-ci.org/yuemori/active_any)
+
 A utility for quering interface to any objects like ActiveRecord. This gem support for querying, association and relation.
 
-This gem is not stable version. Be careful.
+**This gem is not stable version. Be careful.**
 
 ## Installation
 
@@ -46,8 +48,8 @@ end
 
 User.all                  #=> Relation
 User.all.to_a             #=> Array of User
-User.where(name: 'alice') #=> WHERE name equals alice
-User.where(name: /li/)    #=> WHERE name LIKE li (alice, charlie)
+User.where(name: 'alice') #=> WHERE name = alice
+User.where(name: /li/)    #=> WHERE name LIKE %li% (alice, charlie)
 User.group(:name)         #=> GROUP BY name
 User.order(:age)          #=> ORDER BY age
 User.order(age: :desc)    #=> ORDER BY age DESC
@@ -61,15 +63,24 @@ Clone repository and run `bin/console`, if you want to try it!
 
 ## Features
 
-- more powerful interface for select query
-  - [] `joins` (interface only)
-  - [] `includes`
-  - [] `having`
-- [] Interface for other than select query (create, destroy, update)
-- [] enum support
-- [] logging
-- [] scoping
-- [] ActiveRecord integration
+- More powerful interface for select query
+  - [ ] `joins`      (interface only)
+  - [ ] `preload`    (interface only)
+  - [ ] `eager_load` (interface only)
+  - [x] `includes`
+  - [ ] `having`
+  - [ ] `offset`
+- Adapters
+  - [ ] YAML
+  - [ ] JSON
+  - [ ] CSV
+- ActiveRecord like interfaces
+  - [ ] Interface for other than select query (create, destroy, update)
+  - [ ] enum support
+  - [x] subscriber
+  - [ ] scoping
+- Integration
+  - [ ] ActiveRecord
 
 ## Testing
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'rake/testtask'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
   t.libs << 'lib'
-  t.test_files = FileList['test/**/*_test.rb']
+  t.test_files = FileList['test/**/test_*.rb']
 end
 
 task default: :test

data/lib/active_any/adapters/abstract_adapter.rb

@@ -11,17 +11,5 @@ module ActiveAny
     def query(_where_clause, _limit_value = nil, _group_values = [], _order_values = [])
       raise NotImplementedError.new, "#{self.class.name} can not handle for #{value.class}"
     end
-
-    def limit_handler(_records, _limit_value)
-      raise NotImplementedError.new, "#{self.class.name} can not handle for limit"
-    end
-
-    def group_handler(_records, _group_values)
-      raise NotImplementedError.new, "#{self.class.name} can not handle for group"
-    end
-
-    def order_handler(_records, _order_values)
-      raise NotImplementedError.new, "#{self.class.name} can not handle for order"
-    end
   end
 end

data/lib/active_any/associations/association.rb

@@ -3,7 +3,7 @@
 module ActiveAny
   module Associations
     class Association
-      attr_reader :loaded, :reflection, :target, :owner
+      attr_reader :loaded, :reflection, :target, :owner, :inversed
 
       def initialize(owner, reflection)
         @owner = owner
@@ -61,6 +61,7 @@ module ActiveAny
       def reset
         @loaded = false
         @stale_target = nil
+        @inversed = false
       end
 
       def reset_scope
@@ -71,12 +72,17 @@ module ActiveAny
         @loaded
       end
 
+      def find_from_target?
+        loaded?
+      end
+
       def find_target
         raise NotImplementedError
       end
 
       def loaded!
         @loaded = true
+        @inversed = false
       end
 
       def target=(target)
@@ -84,11 +90,32 @@ module ActiveAny
         loaded!
       end
 
+      def set_inverse_instance(record)
+        if invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+          inverse.inversed = true
+        end
+        record
+      end
+
       private
 
+      def invertible_for?(record)
+        foreign_key_for?(record) && inverse_reflection_for(record)
+      end
+
+      def foreign_key_for?(record)
+        record.has_attribute?(reflection.foreign_key)
+      end
+
       def find_target?
         !loaded? && klass
       end
+
+      def inverse_reflection_for(_record)
+        reflection.inverse_of
+      end
     end
   end
 end

data/lib/active_any/associations/has_many_association.rb

@@ -15,6 +15,11 @@ module ActiveAny
         raise NotImplementedError.new, 'writer is unimplemented'
       end
 
+      def reset
+        super
+        @target = []
+      end
+
       def size
         if !find_target? || loaded?
           target.size

data/lib/active_any/associations/preloader/association.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'active_any/associations/preloader/association'
+
+module ActiveAny
+  module Associations
+    class Preloader
+      class Association
+        attr_reader :reflection, :preload_scope, :owners, :klass, :preloaded_records
+
+        def initialize(klass, owner_records, reflection, preload_scope)
+          @klass = klass
+          @owners = owner_records
+          @reflection = reflection
+          @preload_scope = preload_scope
+          @preloaded_records = []
+        end
+
+        def run(preloader)
+          preload(preloader)
+        end
+
+        def preload(_preloader)
+          raise NotImplementedError
+        end
+
+        def scope
+          @scope ||= build_scope
+        end
+
+        def records_for(ids)
+          scope.where(association_key_name => ids)
+        end
+
+        # The name of the key on the associated records
+        def association_key_name
+          raise NotImplementedError
+        end
+
+        def owner_key_name
+          raise NotImplementedError
+        end
+
+        def options
+          reflection.options
+        end
+
+        private
+
+        def associated_records_by_owner(_preloader)
+          records = load_records do |record|
+            owner = owners_by_key[record[association_key_name]]
+            association = owner.association(reflection.name)
+            association.set_inverse_instance(record)
+          end
+
+          owners.each_with_object({}) do |owner, result|
+            result[owner] = records[owner[owner_key_name]] || []
+          end
+        end
+
+        def owners_by_key
+          @owners_by_key ||= owners.each_with_object({}) do |owner, h|
+            h[owner[owner_key_name]] = owner
+          end
+        end
+
+        def owner_keys
+          @owner_keys ||= owners.map do |owner|
+            owner[owner_key_name]
+          end.uniq.compact
+        end
+
+        def load_records
+          return {} if owner_keys.empty?
+          @preloaded_records = records_for(owner_keys).load
+          @preloaded_records.each do |record|
+            yield record if block_given?
+          end
+          @preloaded_records.group_by do |record|
+            record[association_key_name]
+          end
+        end
+
+        def reflection_scope
+          @reflection_scope ||= reflection.scope_for(klass)
+        end
+
+        def build_scope # rubocop:disable all
+          scope = klass.unscoped
+
+          values = reflection_scope.values
+          preload_values = preload_scope.values
+
+          scope.where_clause = reflection_scope.where_clause + preload_scope.where_clause
+          # scope.references_values = Array(values[:references]) + Array(preload_values[:references])
+
+          if preload_values[:select] || values[:select]
+            scope._select!(preload_values[:select] || values[:select])
+          end
+          scope.includes! preload_values[:includes] || values[:includes]
+          # if preload_scope.joins_values.any?
+          #   scope.joins!(preload_scope.joins_values)
+          # else
+          #   scope.joins!(reflection_scope.joins_values)
+          # end
+          order_values = preload_values[:order] || values[:order]
+          if order_values
+            scope.order!(order_values)
+          end
+
+          # if preload_values[:reordering] || values[:reordering]
+          #   scope.reordering_value = true
+          # end
+
+          # if preload_values[:readonly] || values[:readonly]
+          #   scope.readonly!
+          # end
+
+          # if options[:as]
+          #   scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
+          # end
+
+          # scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
+          klass.default_scoped.merge(scope)
+        end
+      end
+    end
+  end
+end

data/lib/active_any/associations/preloader/belongs_to.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Associations
+    class Preloader
+      class BelongsTo < Association
+        def preload(preloader)
+          associated_records_by_owner(preloader).each do |owner, associated_records|
+            record = associated_records.first
+
+            association = owner.association(reflection.name)
+            association.target = record
+          end
+        end
+
+        def association_key_name
+          reflection.options[:primary_key] || klass && klass.primary_key
+        end
+
+        def owner_key_name
+          reflection.foreign_key
+        end
+      end
+    end
+  end
+end

data/lib/active_any/associations/preloader/has_many.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Associations
+    class Preloader
+      class HasMany < Association
+        def preload(preloader)
+          associated_records_by_owner(preloader).each do |owner, records|
+            association = owner.association(reflection.name)
+            association.loaded!
+            association.target.concat(records)
+          end
+        end
+
+        def association_key_name
+          reflection.foreign_key
+        end
+
+        def owner_key_name
+          reflection.primary_key
+        end
+      end
+    end
+  end
+end

data/lib/active_any/associations/preloader.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'active_any/associations/preloader/association'
+require 'active_any/associations/preloader/has_many'
+require 'active_any/associations/preloader/belongs_to'
+
+module ActiveAny
+  module Associations
+    class Preloader
+      NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
+
+      def preload(records, associations, scope = NULL_RELATION)
+        records       = Array.wrap(records).compact.uniq
+        associations  = Array.wrap(associations)
+
+        if records.empty?
+          []
+        else
+          associations.flat_map do |association|
+            preloaders_on association, records, scope
+          end
+        end
+      end
+
+      private
+
+      def preloaders_on(association, records, scope)
+        case association
+        when Symbol
+          preloaders_for_one(association, records, scope)
+        when String
+          preloaders_for_one(association.to_sym, records, scope)
+        else
+          raise ArgumentError, "#{association.inspect} was not recognized for preload"
+        end
+      end
+
+      def preloaders_for_one(association, records, scope)
+        grouped_records(association, records).flat_map do |reflection, klasses|
+          klasses.map do |rhs_klass, rs|
+            loader = preloader_for(reflection, rs, rhs_klass).new(rhs_klass, rs, reflection, scope)
+            loader.run self
+            loader
+          end
+        end
+      end
+
+      def grouped_records(association, records)
+        h = {}
+        records.each do |record|
+          next unless record
+          assoc = record.association(association)
+          klasses = h[assoc.reflection] ||= {}
+          (klasses[assoc.klass] ||= []) << record
+        end
+        h
+      end
+
+      class AlreadyLoaded
+        attr_reader :owners, :reflection
+
+        def initialize(_klass, owners, reflection, _preload_scope)
+          @owners = owners
+          @reflection = reflection
+        end
+
+        def run(preloader); end
+
+        def preloaded_records
+          owners.flat_map { |owner| owner.association(reflection.name).target }
+        end
+      end
+
+      class NullPreloader
+        def self.new(_klass, _owners, _reflection, _preload_scope)
+          self
+        end
+
+        def self.run(_preloader); end
+
+        def self.preloaded_records
+          []
+        end
+
+        def self.owners
+          []
+        end
+      end
+
+      def preloader_for(reflection, owners, rhs_klass) # rubocop:disable Metrics/MethodLength
+        return NullPreloader unless rhs_klass
+
+        if owners.first.association(reflection.name).loaded?
+          return AlreadyLoaded
+        end
+        reflection.check_preloadable!
+
+        case reflection.macro
+        when :has_many
+          # reflection.options[:through] ? HasManyThrough : HasMany
+          HasMany
+        when :has_one
+          # reflection.options[:through] ? HasOneThrough : HasOne
+          HasOne
+        when :belongs_to
+          BelongsTo
+        end
+      end
+    end
+  end
+end

data/lib/active_any/associations.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'active_any/associations/preloader'
 require 'active_any/associations/collection_proxy'
 require 'active_any/associations/association_scope'
 require 'active_any/associations/builder/association'
@@ -40,13 +41,6 @@ module ActiveAny
       super
     end
 
-    private
-
-    def init_internals(*)
-      @association_cache = {}
-      super
-    end
-
     def association(name)
       association = association_instance_get(name)
 
@@ -61,6 +55,13 @@ module ActiveAny
       association
     end
 
+    private
+
+    def init_internals(*)
+      @association_cache = {}
+      super
+    end
+
     def association_instance_get(name)
       @association_cache[name]
     end

data/lib/active_any/attribute.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Attribute
+    extend ActiveSupport::Concern
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def has_attribute?(attribute)
+      attributes.key?(attribute)
+    end
+
+    def read_attribute(name)
+      attributes.fetch(name)
+    end
+
+    def attribute_for_inspect(attr_name)
+      value = read_attribute(attr_name)
+
+      if value.is_a?(String) && value.length > 50
+        "#{value[0, 50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+
+    def inspect
+      inspection = self.class.attribute_names.collect do |name|
+        "#{name}: #{attribute_for_inspect(name)}" if has_attribute?(name)
+      end.compact.join(', ')
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+    module ClassMethods
+      def attributes(*names)
+        names.each { |name| attribute name }
+      end
+
+      def attribute(name)
+        attribute_names << name.to_sym
+        define_writer_method name
+        define_reader_method name
+      end
+
+      def attribute_names
+        @attribute_names ||= []
+      end
+
+      def define_writer_method(name)
+        define_method "#{name}=" do |value|
+          attributes[name] = value
+        end
+      end
+
+      def define_reader_method(name)
+        define_method name do
+          attributes.fetch(name)
+        end
+      end
+
+      def has_attribute?(attribute)
+        attribute_names.key?(attribute)
+      end
+    end
+  end
+end

data/lib/active_any/base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Base
+    include Core
+    include Attribute
+    include Associations
+    include AttributeAssignment
+    include Finders
+    include Reflection
+  end
+
+  class Object < Base
+    def self.inherited(child)
+      child.abstract_class = false
+    end
+
+    class << self
+      attr_accessor :data
+
+      def adapter
+        @adapter ||= ObjectAdapter.new(self)
+      end
+    end
+  end
+
+  class Hash < Base
+    def self.inherited(child)
+      child.abstract_class = false
+    end
+
+    class << self
+      attr_reader :data
+
+      def data=(data)
+        data.map(&:keys).flatten.uniq.each do |method|
+          attribute method
+        end
+
+        @data = data.map { |d| new(d) }
+      end
+
+      def adapter
+        @adapter ||= ObjectAdapter.new(self)
+      end
+    end
+  end
+end

data/lib/active_any/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Configuration
+    attr_accessor :logger, :log_level
+
+    def logger
+      @logger ||= begin
+        logger = Logger.new($stdout)
+        logger.level = "::Logger::#{log_level.to_s.upcase}".constantize
+        logger
+      end
+    end
+
+    def log_level
+      @log_level ||= :debug
+    end
+  end
+end

data/lib/active_any/core.rb

@@ -12,13 +12,29 @@ module ActiveAny
     end
 
     class_methods do
-      delegate :take, :take!, :first, :last, to: :all
+      delegate :includes, :take, :take!, :first, :last, to: :all
+    end
+
+    module ClassMethods
+      def unscoped
+        # TODO: implement
+        all
+      end
+
+      def default_scoped
+        # TODO: implement
+        all
+      end
     end
 
     def initialize(*args)
       init_internals(*args)
     end
 
+    def [](key)
+      send(key)
+    end
+
     private
 
     def init_internals(*); end