active_any 0.0.1 → 0.0.2

data/lib/active_any/reflection/association_reflection.rb

@@ -54,8 +54,73 @@ module ActiveAny
         @primary_key ||= options[:primary_key] || primary_key_for_record_class
       end
 
+      def scope_for(klass)
+        scope ? klass.unscoped.instance_exec(nil, &scope) : klass.unscoped
+      end
+
+      def check_preloadable!
+        return unless scope
+
+        if scope.arity.positive?
+          raise ArgumentError, <<-MSG.squish
+            The association scope '#{name}' is instance dependent (the scope
+            block takes an argument). Preloading instance dependent scopes is
+            not supported.
+          MSG
+        end
+      end
+      alias check_eager_loadable! check_preloadable!
+
+      def inverse_of
+        return unless inverse_name
+
+        @inverse_of ||= klass._reflect_on_association inverse_name
+      end
+
       private
 
+      def inverse_name
+        options.fetch(:inverse_of) do
+          @automatic_inverse_of ||= automatic_inverse_of
+        end
+      end
+
+      def automatic_inverse_of
+        if can_find_inverse_of_automatically?(self)
+          inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym
+
+          begin
+            reflection = klass._reflect_on_association(inverse_name)
+          rescue NameError
+            # Give up: we couldn't compute the klass type so we won't be able
+            # to find any associations either.
+            reflection = false
+          end
+
+          if valid_inverse_reflection?(reflection)
+            return inverse_name
+          end
+        end
+
+        false
+      end
+
+      VALID_AUTOMATIC_INVERSE_MACROS = %i[has_many has_one belongs_to].freeze
+      INVALID_AUTOMATIC_INVERSE_OPTIONS = %i[foreign_key].freeze
+
+      def can_find_inverse_of_automatically?(reflection)
+        reflection.options[:inverse_of] != false &&
+          VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
+          INVALID_AUTOMATIC_INVERSE_OPTIONS.none? { |opt| reflection.options[opt] } &&
+          !reflection.scope
+      end
+
+      def valid_inverse_reflection?(reflection)
+        reflection &&
+          klass.name == reflection.record_class.name &&
+          can_find_inverse_of_automatically?(reflection)
+      end
+
       def join_pk
         raise NotImplementedError
       end

data/lib/active_any/reflection.rb

@@ -10,7 +10,9 @@ module ActiveAny
 
     included do
       class_attribute :reflections, instance_writer: false
+      class_attribute :_reflections, instance_writer: false
       self.reflections = {}
+      self._reflections = {}
     end
 
     class UnknownPrimaryKey < StandardError
@@ -45,5 +47,9 @@ module ActiveAny
     def self.add_reflection(klass, name, reflection)
       klass.reflections = klass.reflections.merge(name.to_s => reflection)
     end
+
+    def self._reflect_on_association(association)
+      _reflections[association.to_s]
+    end
   end
 end

data/lib/active_any/relation/finder_methods.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Relation
+    module FinderMethods
+      def find_by(condition)
+        where(condition).take
+      end
+
+      def first(limit = nil)
+        if loaded
+          limit ? records.first(limit) : records.first
+        else
+          limit ? spawn.records.first(limit) : spawn.records.first
+        end
+      end
+
+      def last(limit = nil)
+        return find_last(limit) if loaded? || limit_value
+
+        result = limit(limit)
+        result.order!(klass.primary_key) if order_clause.empty? && klass.primary_key
+        result = result.reverse_order!
+        limit ? result.reverse : result.first
+      end
+
+      private
+
+      def find_last(limit)
+        limit ? records.last(limit) : records.last
+      end
+    end
+  end
+end

data/lib/active_any/relation/query_methods.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Relation
+    MULTI_VALUE_METHODS  = %i[group includes join].freeze
+    SINGLE_VALUE_METHODS = %i[limit].freeze
+    CLAUSE_METHODS = %i[where order].freeze
+    VALUE_METHODS = (MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS + CLAUSE_METHODS).freeze
+
+    module QueryMethods # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      Relation::VALUE_METHODS.each do |name|
+        method_name = \
+          case name
+          when *Relation::MULTI_VALUE_METHODS then "#{name}_values"
+          when *Relation::SINGLE_VALUE_METHODS then "#{name}_value"
+          when *Relation::CLAUSE_METHODS then "#{name}_clause"
+          end
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{method_name}                   # def includes_values
+            get_value(#{name.inspect})         #   get_value(:includes)
+          end                                  # end
+
+          def #{method_name}=(value)           # def includes_values=(value)
+            set_value(#{name.inspect}, value)  #   set_value(:includes, value)
+          end                                  # end
+        CODE
+      end
+
+      def get_value(name)
+        @values[name] || default_value_for(name)
+      end
+
+      def set_value(name, value)
+        assert_mutability!
+        @values[name] = value
+      end
+
+      def values
+        @values.dup
+      end
+
+      def limit(value)
+        spawn.limit!(value)
+      end
+
+      def where(condition)
+        spawn.where!(condition)
+      end
+
+      def take(limit = nil)
+        limit ? find_take_with_limit(limit) : find_take
+      end
+
+      def reverse_order
+        spawn.reverse_order!
+      end
+
+      def reverse_order!
+        self.order_clause = order_clause.reverse!
+        self
+      end
+
+      def group(*args)
+        spawn.group!(*args)
+      end
+
+      def order(*args)
+        spawn.order!(*args)
+      end
+
+      def limit!(value)
+        self.limit_value = value
+        self
+      end
+
+      def where!(condition)
+        self.where_clause += WhereClause.new(condition)
+        self
+      end
+
+      def group!(*args)
+        args.flatten!
+
+        self.group_values += args
+        self
+      end
+
+      def order!(*args)
+        args.flatten!
+
+        self.order_clause += OrderClause.new(args)
+        self
+      end
+
+      def includes(*args)
+        spawn.includes!(*args)
+      end
+
+      def includes!(*args)
+        args.reject!(&:blank?)
+        args.flatten!
+
+        self.includes_values |= args
+        self
+      end
+
+      private
+
+      def find_take
+        if loaded
+          records.first
+        else
+          limit(1).records.first
+        end
+      end
+
+      def find_take_with_limit(limit)
+        if loaded
+          records.take(limit)
+        else
+          limit(limit).to_a
+        end
+      end
+
+      FROZEN_EMPTY_ARRAY = [].freeze
+
+      def default_value_for(name)
+        case name
+        when :where then WhereClause.empty
+        when :order then OrderClause.empty
+        when *Relation::MULTI_VALUE_METHODS then FROZEN_EMPTY_ARRAY
+        when *Relation::SINGLE_VALUE_METHODS then nil
+        else
+          raise ArgumentError, "unknown relation value #{name.inspect}"
+        end
+      end
+
+      def assert_mutability!
+        raise ImmutableRelation if @loaded
+      end
+    end
+  end
+end

data/lib/active_any/relation.rb

@@ -1,42 +1,23 @@
 # frozen_string_literal: true
 
+require 'active_any/relation/finder_methods'
+require 'active_any/relation/query_methods'
 require 'active_any/relation/merger'
 require 'active_any/relation/where_clause'
 require 'active_any/relation/order_clause'
 
 module ActiveAny
-  class Relation # rubocop:disable Metrics/ClassLength
+  class Relation
     attr_reader :loaded, :klass
 
     delegate :each, to: :records
 
     include Enumerable
+    include FinderMethods
+    include QueryMethods
 
     class ImmutableRelation < StandardError; end
 
-    MULTI_VALUE_METHODS  = %i[group].freeze
-    SINGLE_VALUE_METHODS = %i[limit].freeze
-    CLAUSE_METHODS = %i[where order].freeze
-    VALUE_METHODS = (MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS + CLAUSE_METHODS).freeze
-
-    Relation::VALUE_METHODS.each do |name|
-      method_name = \
-        case name
-        when *Relation::MULTI_VALUE_METHODS then "#{name}_values"
-        when *Relation::SINGLE_VALUE_METHODS then "#{name}_value"
-        when *Relation::CLAUSE_METHODS then "#{name}_clause"
-        end
-      class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{method_name}                   # def includes_values
-          get_value(#{name.inspect})         #   get_value(:includes)
-        end                                  # end
-
-        def #{method_name}=(value)           # def includes_values=(value)
-          set_value(#{name.inspect}, value)  #   set_value(:includes, value)
-        end                                  # end
-      CODE
-    end
-
     def self.create(klass, *args)
       new(klass, *args)
     end
@@ -48,73 +29,10 @@ module ActiveAny
       @values = {}
     end
 
-    def get_value(name)
-      @values[name] || default_value_for(name)
-    end
-
-    def set_value(name, value)
-      assert_mutability!
-      @values[name] = value
-    end
-
     def to_a
       records.dup
     end
 
-    def limit(value)
-      spawn.limit!(value)
-    end
-
-    def where(condition)
-      spawn.where!(condition)
-    end
-
-    def find_by(condition)
-      where(condition).take
-    end
-
-    def take(limit = nil)
-      limit ? find_take_with_limit(limit) : find_take
-    end
-
-    def first(limit = nil)
-      if loaded
-        limit ? records.first(limit) : records.first
-      else
-        limit ? spawn.records.first(limit) : spawn.records.first
-      end
-    end
-
-    def last(limit = nil)
-      return find_last(limit) if loaded? || limit_value
-
-      result = limit(limit)
-      result.order!(klass.primary_key) if order_clause.empty? && klass.primary_key
-      result = result.reverse_order!
-      limit ? result.reverse : result.first
-    end
-
-    def reverse_order
-      spawn.reverse_order!
-    end
-
-    def reverse_order!
-      self.order_clause = order_clause.reverse!
-      self
-    end
-
-    def find_last(limit)
-      limit ? records.last(limit) : records.last
-    end
-
-    def group(*args)
-      spawn.group!(*args)
-    end
-
-    def order(*args)
-      spawn.order!(*args)
-    end
-
     def merge(other)
       if other.is_a?(Array)
         records & other
@@ -137,32 +55,8 @@ module ActiveAny
       end
     end
 
-    def limit!(value)
-      self.limit_value = value
-      self
-    end
-
-    def where!(condition)
-      self.where_clause += WhereClause.new(condition)
-      self
-    end
-
-    def group!(*args)
-      args.flatten!
-
-      self.group_values += args
-      self
-    end
-
-    def order!(*args)
-      args.flatten!
-
-      self.order_clause += OrderClause.new(args)
-      self
-    end
-
     def records
-      load_unless_loaded
+      load
       @records
     end
 
@@ -172,10 +66,6 @@ module ActiveAny
       super
     end
 
-    def values
-      @values.dup
-    end
-
     def reset
       @loaded = nil
       @records = [].freeze
@@ -186,58 +76,52 @@ module ActiveAny
       @loaded
     end
 
-    private
-
-    def load_unless_loaded
+    def load
       exec_query unless loaded
       self
     end
 
-    def spawn
-      clone
+    def eager_loading?
+      false
     end
 
-    def find_take_with_limit(limit)
-      if loaded
-        records.take(limit)
-      else
-        limit(limit).to_a
-      end
-    end
+    private
 
-    def find_take
-      if loaded
-        records.first
-      else
-        limit(1).records.first
-      end
+    def spawn
+      clone
     end
 
-    def exec_query
-      @records = klass.find_by_query(
+    def clauses
+      {
         where_clause: where_clause,
         limit_value: limit_value,
         group_values: group_values,
         order_clause: order_clause
-      )
-      @loaded = true
+      }
     end
 
-    def assert_mutability!
-      raise ImmutableRelation if @loaded
+    def exec_query
+      ActiveSupport::Notifications.instrument('exec_query.active_any', clauses: clauses, class_name: klass.name) do
+        @records = klass.find_by_query(clauses)
+        preload_records(@records)
+        @loaded = true
+      end
     end
 
-    FROZEN_EMPTY_ARRAY = [].freeze
-
-    def default_value_for(name)
-      case name
-      when :where then WhereClause.empty
-      when :order then OrderClause.empty
-      when *Relation::MULTI_VALUE_METHODS then FROZEN_EMPTY_ARRAY
-      when *Relation::SINGLE_VALUE_METHODS then nil
-      else
-        raise ArgumentError, "unknown relation value #{name.inspect}"
+    def preload_records(records)
+      # TODO: implement preload
+      # preload = preload_values
+      preload = []
+      preload += includes_values unless eager_loading?
+      preloader = nil
+      preload.each do |associations|
+        preloader ||= build_preloader
+        preloader.preload records, associations
       end
     end
+
+    def build_preloader
+      ActiveAny::Associations::Preloader.new
+    end
   end
 end

data/lib/active_any/subscriber.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Subscriber < ActiveSupport::LogSubscriber
+    attach_to :active_any
+
+    def exec_query(event)
+      class_name = event.payload[:class_name]
+      clauses = event.payload[:clauses]
+
+      debug "#{class_name} exec_query(clauses: #{clauses})"
+    end
+
+    private
+
+    def logger
+      super || ActiveSupport::LogSubscriber.logger = ActiveAny.config.logger
+    end
+  end
+end

data/lib/active_any/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveAny
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/active_any.rb

@@ -4,6 +4,8 @@ require 'active_support'
 require 'active_support/core_ext'
 
 require 'active_any/version'
+require 'active_any/attribute'
+require 'active_any/configuration'
 require 'active_any/relation'
 require 'active_any/reflection'
 require 'active_any/associations'
@@ -11,52 +13,18 @@ require 'active_any/association_relation'
 require 'active_any/attribute_assignment'
 require 'active_any/finders'
 require 'active_any/core'
+require 'active_any/base'
+require 'active_any/subscriber'
 require 'active_any/adapter'
 require 'active_any/adapters/abstract_adapter'
 require 'active_any/adapters/object_adapter'
 
 module ActiveAny
-  class Base
-    include Core
-    include Associations
-    include AttributeAssignment
-    include Finders
-    include Reflection
+  def self.configure
+    yield config
   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.each do |method|
-          attr_accessor method
-        end
-
-        @data = data.map { |d| new(d) }
-      end
-
-      def adapter
-        @adapter ||= ObjectAdapter.new(self)
-      end
-    end
+  def self.config
+    @config ||= Configuration.new
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_any
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - yuemori
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-24 00:00:00.000000000 Z
+date: 2017-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -212,7 +212,14 @@ files:
 - lib/active_any/associations/builder/has_many.rb
 - lib/active_any/associations/collection_proxy.rb
 - lib/active_any/associations/has_many_association.rb
+- lib/active_any/associations/preloader.rb
+- lib/active_any/associations/preloader/association.rb
+- lib/active_any/associations/preloader/belongs_to.rb
+- lib/active_any/associations/preloader/has_many.rb
+- lib/active_any/attribute.rb
 - lib/active_any/attribute_assignment.rb
+- lib/active_any/base.rb
+- lib/active_any/configuration.rb
 - lib/active_any/core.rb
 - lib/active_any/finders.rb
 - lib/active_any/reflection.rb
@@ -220,9 +227,12 @@ files:
 - lib/active_any/reflection/belongs_to_reflection.rb
 - lib/active_any/reflection/has_many_reflection.rb
 - lib/active_any/relation.rb
+- lib/active_any/relation/finder_methods.rb
 - lib/active_any/relation/merger.rb
 - lib/active_any/relation/order_clause.rb
+- lib/active_any/relation/query_methods.rb
 - lib/active_any/relation/where_clause.rb
+- lib/active_any/subscriber.rb
 - lib/active_any/version.rb
 homepage: https://github.com/yuemori/active_any
 licenses: