active_any 0.0.1

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Associations
+    module Builder
+      class BelongsTo < Association
+        def self.macro
+          :belongs_to
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Associations
+    module Builder
+      class HasMany < Association
+        def self.macro
+          :has_many
+        end
+
+        def self.valid_options
+          super + %i[primary_key]
+        end
+      end
+    end
+  end
+end

data/lib/active_any/associations/collection_proxy.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Associations
+    class CollectionProxy < ActiveAny::Relation
+      attr_reader :association
+
+      delegate :target, :load_target, :load_target,
+               :size, :empty?, :include?, to: :@association
+
+      def initialize(klass, association)
+        @association = association
+        super(klass)
+      end
+
+      def take(limit = nil)
+        load_target if find_from_target?
+        super
+      end
+
+      def scope
+        @scope ||= @association.scope
+      end
+
+      def ==(other)
+        load_target == other
+      end
+
+      def to_ary
+        load_target.dup
+      end
+      alias to_a to_ary
+
+      def records
+        load_target
+      end
+
+      def proxy_association
+        @association
+      end
+
+      def reset
+        proxy_association.reset
+        proxy_association.reset_scope
+        reset_scope
+      end
+
+      def reload
+        proxy_association.reload
+        reset_scope
+      end
+
+      def reset_scope # :nodoc:
+        @offsets = {}
+        @scope = nil
+        self
+      end
+
+      private
+
+      def find_from_target?
+        @association.find_from_target?
+      end
+    end
+  end
+end

data/lib/active_any/associations/has_many_association.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Associations
+    class HasManyAssociation < Association
+      def reader
+        # TODO: implement
+        # reload if stale_target?
+
+        @proxy ||= CollectionProxy.create(owner, self)
+        @proxy.reset_scope
+      end
+
+      def writer(_records)
+        raise NotImplementedError.new, 'writer is unimplemented'
+      end
+
+      def size
+        if !find_target? || loaded?
+          target.size
+        else
+          scope.count
+        end
+      end
+
+      def empty?
+        size.zero?
+      end
+
+      def include?(record)
+        if record.is_a?(klass)
+          target.include?(record)
+        else
+          false
+        end
+      end
+
+      def find_target
+        scope.to_a
+      end
+    end
+  end
+end

data/lib/active_any/associations.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'active_any/associations/collection_proxy'
+require 'active_any/associations/association_scope'
+require 'active_any/associations/builder/association'
+require 'active_any/associations/builder/has_many'
+require 'active_any/associations/builder/belongs_to'
+require 'active_any/associations/association'
+require 'active_any/associations/has_many_association'
+require 'active_any/associations/belongs_to_association'
+
+module ActiveAny
+  module Associations
+    extend ActiveSupport::Concern
+
+    class AssociationNotFoundError < StandardError
+      def initialize(record = nil, association_name = nil)
+        if record && association_name
+          super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
+        else
+          super('Association was not found.')
+        end
+      end
+    end
+
+    module ClassMethods
+      def has_many(name, scope = nil, options = {})
+        reflection = Builder::HasMany.build(self, name, scope, options)
+        Reflection.add_reflection self, name, reflection
+      end
+
+      def belongs_to(name, scope = nil, options = {})
+        reflection = Builder::BelongsTo.build(self, name, scope, options)
+        Reflection.add_reflection self, name, reflection
+      end
+    end
+
+    def initialize_dup(*)
+      @association_cache = {}
+      super
+    end
+
+    private
+
+    def init_internals(*)
+      @association_cache = {}
+      super
+    end
+
+    def association(name)
+      association = association_instance_get(name)
+
+      if association.nil?
+        reflection = self.class.reflections[name.to_s]
+        raise AssociationNotFoundError.new(self, name) unless reflection
+
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+
+    def association_instance_get(name)
+      @association_cache[name]
+    end
+
+    def association_instance_set(name, association)
+      @association_cache[name] = association
+    end
+  end
+end

data/lib/active_any/attribute_assignment.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module AttributeAssignment
+    def init_internals(attributes = {})
+      assign_attributes(attributes) if attributes.present?
+      super
+    end
+
+    def assign_attributes(data)
+      data.each do |key, value|
+        public_send("#{key}=", value)
+      end
+    end
+  end
+end

data/lib/active_any/core.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :abstract_class, instance_writer: false
+      class_attribute :primary_key, instance_writer: false
+      self.abstract_class = true
+      self.primary_key = nil
+    end
+
+    class_methods do
+      delegate :take, :take!, :first, :last, to: :all
+    end
+
+    def initialize(*args)
+      init_internals(*args)
+    end
+
+    private
+
+    def init_internals(*); end
+  end
+end

data/lib/active_any/finders.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Finders
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      delegate :find_by, :limit, :where, :take, :group, :order, to: :all
+
+      def all
+        Relation.create(self)
+      end
+
+      def find_by_query(where_clause:, limit_value:, group_values:, order_clause:)
+        adapter.query(
+          where_clause: where_clause,
+          limit_value: limit_value,
+          group_values: group_values,
+          order_clause: order_clause
+        )
+      end
+
+      def adapter
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/active_any/reflection/association_reflection.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Reflection
+    class AssociationReflection
+      attr_reader :name, :scope, :options, :record_class
+
+      def initialize(name, scope, options, record_class)
+        @name = name
+        @record_class = record_class
+        @options = options
+        @scope = scope
+      end
+
+      def association_class
+        raise NotImplementedError
+      end
+
+      def marco
+        raise NotImplementedError
+      end
+
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      def klass
+        @klass ||= compute_class(class_name)
+      end
+
+      def compute_class(name)
+        name.constantize
+      end
+
+      def collection?
+        false
+      end
+
+      def belongs_to?
+        false
+      end
+
+      JoinKeys = Struct.new(:key, :foreign_key)
+
+      def join_keys
+        JoinKeys.new(join_pk, join_fk)
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
+      end
+
+      def primary_key
+        @primary_key ||= options[:primary_key] || primary_key_for_record_class
+      end
+
+      private
+
+      def join_pk
+        raise NotImplementedError
+      end
+
+      def join_fk
+        raise NotImplementedError
+      end
+
+      def primary_key_for_record_class
+        klass.primary_key || (raise UnknownPrimaryKey.new, klass)
+      end
+
+      def derive_class_name
+        class_name = name.to_s
+        class_name = class_name.singularize if collection?
+        class_name.camelize
+      end
+
+      def derive_foreign_key
+        if belongs_to?
+          "#{name}_id"
+        elsif options[:as]
+          "#{options[:as]}_id"
+        else
+          record_class.name.foreign_key
+        end
+      end
+    end
+  end
+end

data/lib/active_any/reflection/belongs_to_reflection.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Reflection
+    class BelongsToReflection < AssociationReflection
+      def association_class
+        Associations::BelongsToAssociation
+      end
+
+      def macro
+        :belongs_to
+      end
+
+      def belongs_to?
+        true
+      end
+
+      private
+
+      def join_pk
+        primary_key
+      end
+
+      def join_fk
+        foreign_key
+      end
+    end
+  end
+end

data/lib/active_any/reflection/has_many_reflection.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  module Reflection
+    class HasManyReflection < AssociationReflection
+      def association_class
+        Associations::HasManyAssociation
+      end
+
+      def macro
+        :has_many
+      end
+
+      def collection?
+        true
+      end
+
+      private
+
+      def join_pk
+        foreign_key
+      end
+
+      def join_fk
+        primary_key
+      end
+    end
+  end
+end

data/lib/active_any/reflection.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_any/reflection/association_reflection'
+require 'active_any/reflection/has_many_reflection'
+require 'active_any/reflection/belongs_to_reflection'
+
+module ActiveAny
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections, instance_writer: false
+      self.reflections = {}
+    end
+
+    class UnknownPrimaryKey < StandardError
+      attr_reader :model
+
+      def initialize(model = nil, description = nil)
+        if model
+          message = "Unknown primary key for table #{model.table_name} in model #{model}."
+          message += "\n#{description}" if description
+          @model = model
+          super(message)
+        else
+          super('Unknown primary key.')
+        end
+      end
+    end
+
+    def self.create(macro, name, scope, options, klass)
+      reflection_class =
+        case macro
+        when :belongs_to
+          BelongsToReflection
+        when :has_many
+          HasManyReflection
+        else
+          raise "Unsupported Macro: #{macro}"
+        end
+
+      reflection_class.new(name, scope, options, klass)
+    end
+
+    def self.add_reflection(klass, name, reflection)
+      klass.reflections = klass.reflections.merge(name.to_s => reflection)
+    end
+  end
+end

data/lib/active_any/relation/merger.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Relation
+    class HashMerger
+      attr_reader :relation, :hash
+
+      def initialize(relation, hash)
+        hash.assert_valid_keys(*Relation::VALUE_METHODS)
+
+        @relation = relation
+        @hash     = hash
+      end
+
+      def merge
+        Merger.new(relation, other).merge
+      end
+
+      def other
+        other = Relation.create(relation.klass)
+        hash.each { |k, v| other.public_send("#{k}!", v) }
+        other
+      end
+    end
+
+    class Merger
+      attr_reader :relation, :values, :other
+
+      def initialize(relation, other)
+        @relation = relation
+        @values   = other.values
+        @other    = other
+      end
+
+      def normal_values
+        Relation::VALUE_METHODS -
+          Relation::CLAUSE_METHODS -
+          %i[includes preload joins order reverse_order lock create_with reordering]
+      end
+
+      def merge
+        normal_values.each do |name|
+          value = values[name]
+          relation.send("#{name}!", *value) unless value.nil? || (value.blank? && value != false)
+        end
+
+        merge_multi_values
+        merge_single_values
+        merge_clauses
+
+        relation
+      end
+
+      private
+
+      def merge_multi_values
+        relation.order! other.order_clause unless other.order_clause.empty?
+        relation.group! other.group_values if other.group_values
+      end
+
+      def merge_single_values; end
+
+      def merge_clauses
+        CLAUSE_METHODS.each do |method|
+          clause = relation.get_value(method)
+          other_clause = other.get_value(method)
+          relation.set_value(method, clause.merge(other_clause))
+        end
+      end
+    end
+  end
+end

data/lib/active_any/relation/order_clause.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Relation
+    class OrderClause
+      def self.empty
+        new
+      end
+
+      OrderValue = Struct.new(:key, :sort_type)
+
+      attr_reader :order_values
+
+      def initialize(values = [], reverse = false)
+        @reverse = reverse
+        @order_values = convert_order_values(values)
+      end
+
+      def reverse?
+        @reverse
+      end
+
+      def reverse!
+        @reverse = true
+        self
+      end
+
+      def +(other)
+        OrderClause.new(
+          order_values + other.order_values,
+          reverse? || other.reverse?
+        )
+      end
+
+      alias merge +
+
+      def ==(other)
+        reverse? == other.reverse? && order_values == other.order_values
+      end
+
+      def empty?
+        order_values.empty?
+      end
+
+      private
+
+      def convert_order_values(values)
+        values.map do |arg|
+          case arg
+          when ::Hash then OrderValue.new(arg.keys.first, arg.values.first)
+          when ::Symbol, ::String then OrderValue.new(arg, :asc)
+          when OrderValue then arg
+          else
+            raise ArgumentError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_any/relation/where_clause.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ActiveAny
+  class Relation
+    class WhereClause
+      class Condition
+        attr_reader :key, :value
+
+        def initialize(key, value)
+          @key = key
+          @value = value
+
+          register_handler(BasicObject, :base_handler)
+          register_handler(Regexp, :regexp_handler)
+          register_handler(Range, :range_handler)
+          register_handler(Array, :array_handler)
+        end
+
+        def evaluate(adapter, record)
+          adapter.public_send(handle_for(value), record, key, value)
+        end
+
+        def to_h
+          { key => value }
+        end
+
+        private
+
+        def handle_for(value)
+          handlers.select { |klass, _| value.is_a?(klass) }.last.last
+        end
+
+        def handlers
+          @handlers ||= []
+        end
+
+        def register_handler(klass, method)
+          handlers << [klass, method]
+        end
+      end
+
+      attr_reader :conditions
+
+      def initialize(hash = {}, conditions = nil)
+        @conditions = conditions ? conditions : hash.map { |key, value| Condition.new(key, value) }
+      end
+
+      def self.empty
+        new
+      end
+
+      def ==(other)
+        other.conditions.sort_by(&:key) == conditions.sort_by(&:key)
+      end
+
+      def +(other)
+        WhereClause.new({}, (conditions + other.conditions).flatten)
+      end
+
+      alias merge +
+
+      def merge!(hash)
+        hash.each do |key, value|
+          conditions << Condition.new(key, value)
+        end
+      end
+
+      def all?(&block)
+        conditions.all?(&block)
+      end
+    end
+  end
+end