through_hierarchy 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d022dd2e412e69e8daacf89cb32acdde7fa2aa8
+  data.tar.gz: d3b3db0afcabfbc671be794845a3b6fd52e9f191
+SHA512:
+  metadata.gz: b6c87687c6180d6eb104be80238b9e9cd77f62458af378b152b31c9c1567666457f5112e183fd310eeed208be669cfc30f8c616d312c8047afbbd327fdaa7ffa
+  data.tar.gz: 2e39324c5fdee36ddfea5a839d58f37f93ce20410f041facfc21d38c8dd110925f8a0811bfbc89f9583fe23fe93f23a734a6aa1870d1824645082757d2c76540

data/lib/through_hierarchy/associations/association.rb

@@ -0,0 +1,173 @@
+module ThroughHierarchy
+  module Associations
+    class Association
+      def initialize(name, model, members, options = {})
+        @name = name
+        @model = model
+        @members = members
+        @as = options[:as].to_s
+        @scope = options[:scope]
+        @foreign_class_name = options[:class_name] || @name.to_s.classify
+        @uniq = options[:uniq]
+
+        validate_options
+      end
+
+      def find(instance)
+        return uniq_find(instance) if @uniq.present?
+
+        results = foreign_class.where(arel_instance_filters(instance))
+        results = results.instance_exec(&@scope) if @scope.present?
+        return results
+      end
+
+      def joins
+        # TODO: make this work
+        # joins = @model.arel_table.join(foreign_arel_table).on(arel_model_filters)
+
+        # joins = joins.join(arel_uniq_subquery).on(
+        #   arel_hierarchy_rank.eq(uniq_subquery_arel_table[best_hierarchy_match_name]).
+        #   and(foreign_arel_table[@uniq].eq(uniq_subquery_arel_table[@uniq]))
+        # ) if @uniq.present?
+
+        # results = @model.joins(joins.join_sources)
+        # results = results.merge(foreign_class.instance_exec(&@scope)) if @scope.present?
+        # return results
+      end
+
+      def create(member, attributes)
+        # NIY
+      end
+
+      private
+
+      def validate_options
+        @as.present? or raise ThroughHierarchyDefinitionError, "Must provide polymorphic `:as` options for through_hierarchy"
+        @model.is_a?(Class) or raise ThroughHierarchyDefinitionError, "Expected: class, got: #{@model.class}"
+        @model < ActiveRecord::Base or raise ThroughHierarchyDefinitionError, "Expected: ActiveRecord::Base descendant, got: #{@model}"
+        @scope.blank? || @scope.is_a?(Proc) or raise ThroughHierarchyDefinitionError, "Expected scope to be a Proc, got #{@scope.class}"
+      end
+
+      def foreign_class
+        @foreign_class_name.constantize
+      end
+
+      def foreign_arel_table
+        foreign_class.arel_table
+      end
+
+      def sql_hierarchy_rank
+        "CASE `#{foreign_class.table_name}`.`#{foreign_type_field}` " +
+          hierarchy_models.map.with_index{|m, ii| "WHEN #{@model.sanitize(model_type_constraint(m))} THEN #{ii} "}.join +
+          "END"
+      end
+
+      def arel_hierarchy_rank
+        Arel.sql(sql_hierarchy_rank)
+      end
+
+      # TODO: generate this dynamically based on existing columns and selects
+      def best_hierarchy_match_name
+        "through_hierarchy_match"
+      end
+
+      def arel_best_hierarchy_member
+        arel_hierarchy_rank.minimum.as(best_hierarchy_match_name)
+      end
+
+      # TODO: for model level joins, subquery needs to join to all hierarchy tables
+      def arel_uniq_subquery(instance = nil)
+        foreign_arel_table.
+          project(foreign_arel_table[Arel.star], arel_best_hierarchy_member).
+          where(instance.present? ? arel_instance_filters(instance) : arel_model_filters).
+          group(foreign_arel_table[@uniq]).
+          as(uniq_subquery_alias)
+      end
+
+      def uniq_subquery_alias
+        "through_hierarchy_subtable"
+      end
+
+      def uniq_subquery_arel_table
+        Arel::Table.new(uniq_subquery_alias)
+      end
+
+      # TODO: build join sources for model-level query
+      def uniq_subquery_join_sources(instance = nil)
+        foreign_arel_table.
+          join(arel_uniq_subquery(instance)).
+          on(
+            arel_hierarchy_rank.eq(uniq_subquery_arel_table[best_hierarchy_match_name]).
+            and(foreign_arel_table[@uniq].eq(uniq_subquery_arel_table[@uniq]))
+          ).join_sources
+      end
+
+      def uniq_find(instance)
+        join_sources = uniq_subquery_join_sources(instance)
+
+        return foreign_class.
+          joins(uniq_subquery_join_sources(instance)).
+          where(arel_instance_filters(instance)).
+          order(foreign_arel_table[@uniq])
+      end
+
+      def hierarchy_models
+        [@model] + @members.map{|m| @model.reflect_on_association(m).klass}
+      end
+
+      def hierarchy_instances(instance)
+        [instance] + @members.map{|m| instance.association(m).load_target}
+      end
+
+      def foreign_key_field
+        @as.foreign_key
+      end
+
+      def foreign_type_field
+        @as + "_type"
+      end
+
+      def arel_foreign_key_field
+        foreign_arel_table[foreign_key_field]
+      end
+
+      def arel_foreign_type_field
+        foreign_arel_table[foreign_type_field]
+      end
+
+      def arel_model_filters
+        hierarchy_models.map{|model| arel_model_filter(model)}.reduce{|q, cond| q.or(cond)}
+      end
+
+      def arel_instance_filters(instance)
+        hierarchy_instances(instance).map{|instance| arel_instance_filter(instance)}.reduce{|q, cond| q.or(cond)}
+      end
+
+      def arel_model_filter(model)
+        arel_foreign_type_field.eq(model_type_constraint(model)).
+          and(arel_foreign_key_field.eq(model_key_constraint(model)))        
+      end
+
+      def arel_instance_filter(instance)
+        arel_foreign_type_field.eq(instance_type_constraint(instance)).
+          and(arel_foreign_key_field.eq(instance_key_constraint(instance)))
+      end
+
+      def instance_type_constraint(resource)
+        resource.class.base_class.to_s
+      end
+
+      def instance_key_constraint(resource)
+        resource.attributes[resource.class.primary_key]
+      end
+
+      def model_type_constraint(model_class)
+        model_class.base_class.to_s
+      end
+
+      def model_key_constraint(model_class)
+        model_class.arel_table[model_class.primary_key]
+      end
+    end
+  end
+end

data/lib/through_hierarchy/associations/has_many.rb

@@ -0,0 +1,6 @@
+module ThroughHierarchy
+  module Associations
+    class HasMany < Association
+    end
+  end
+end

data/lib/through_hierarchy/associations/has_one.rb

@@ -0,0 +1,9 @@
+module ThroughHierarchy
+  module Associations
+    class HasOne < Association
+      def find(instance)
+        super.first
+      end
+    end
+  end
+end

data/lib/through_hierarchy/base.rb

@@ -0,0 +1,22 @@
+module ThroughHierarchy
+  module Base
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :hierarchical_associations
+      self.hierarchical_associations = {}
+      attr_reader :hierarchical_association_cache
+      after_initialize :reset_hierarchical_association_cache
+    end
+
+    def reset_hierarchical_association_cache
+      @hierarchical_association_cache = {}
+    end
+
+    module ClassMethods
+      def through_hierarchy(members, &blk)
+        Hierarchy.new(self, members).instance_eval(&blk)
+      end
+    end
+  end
+end

data/lib/through_hierarchy/builder.rb

@@ -0,0 +1,29 @@
+module ThroughHierarchy
+  class Builder
+    def initialize(model)
+      @model = model
+      initialize_methods_class
+    end
+
+    def initialize_methods_class
+      @model.const_set("ThroughHierarchyAssociationMethods", Module.new) unless defined? @model::ThroughHierarchyAssociationMethods
+      @model.include @model::ThroughHierarchyAssociationMethods if !@model.ancestors.include?(@model::ThroughHierarchyAssociationMethods)
+    end
+
+    def add_association(name, assoc)
+      @model.hierarchical_associations[name] = assoc
+
+      @model::ThroughHierarchyAssociationMethods.class_eval do
+        define_method(name) do |reload = false|
+          return @hierarchical_association_cache[name] if !reload && @hierarchical_association_cache.key?(name)
+          @hierarchical_association_cache[name] = self.hierarchical_associations[name].find(self)
+        end
+
+        # TODO: join_through_hierarchy
+
+        # TODO: create_from_hierarchy(member, attributes)
+        
+      end
+    end
+  end
+end

data/lib/through_hierarchy/exceptions.rb

@@ -0,0 +1,7 @@
+module ThroughHierarchy
+  class ThroughHierarchyError < StandardError
+  end
+
+  class ThroughHierarchyDefinitionError < ThroughHierarchyError
+  end
+end

data/lib/through_hierarchy/hierarchy.rb

@@ -0,0 +1,29 @@
+module ThroughHierarchy
+  class Hierarchy < BasicObject
+    def initialize(klass, members)
+      @klass = klass
+      @members = members
+
+      validate_members
+    end
+
+    def has_one(name, scope = nil, **options)
+      options.merge!(scope: scope) if scope.present?
+      assoc = ::ThroughHierarchy::Associations::HasOne.new(name, @klass, @members, options)
+      ::ThroughHierarchy::Builder.new(@klass).add_association(name, assoc)
+    end
+
+    def has_many(name, scope = nil, **options)
+      options.merge!(scope: scope) if scope.present?
+      assoc = ::ThroughHierarchy::Associations::HasMany.new(name, @klass, @members, options)
+      ::ThroughHierarchy::Builder.new(@klass).add_association(name, assoc)
+    end
+
+    private
+
+    def validate_members
+      @members.is_a?(::Array) or ::Kernel.raise ::ThroughHierarchy::ThroughHierarchyDefinitionError, "Hierarchy members: expected: Array, got: #{@members.class}"
+      @members.all?{|member| @klass.reflect_on_association(member).present?} or ::Kernel.raise ::ThroughHierarchy::ThroughHierarchyDefinitionError, "No association named #{member} was found. Perhaps you misspelled it?"
+    end
+  end  
+end

data/lib/through_hierarchy.rb

@@ -0,0 +1,9 @@
+require 'through_hierarchy/base.rb'
+require 'through_hierarchy/hierarchy.rb'
+require 'through_hierarchy/builder.rb'
+require 'through_hierarchy/associations/association.rb'
+require 'through_hierarchy/associations/has_one.rb'
+require 'through_hierarchy/associations/has_many.rb'
+require 'through_hierarchy/exceptions.rb'
+
+ActiveRecord::Base.include(ThroughHierarchy::Base)

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: through_hierarchy
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Andrew Schwartz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-04 00:00:00.000000000 Z
+dependencies: []
+description: Create hierarchical polymorphic associations
+email: ozydingo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/through_hierarchy.rb
+- lib/through_hierarchy/associations/association.rb
+- lib/through_hierarchy/associations/has_many.rb
+- lib/through_hierarchy/associations/has_one.rb
+- lib/through_hierarchy/base.rb
+- lib/through_hierarchy/builder.rb
+- lib/through_hierarchy/exceptions.rb
+- lib/through_hierarchy/hierarchy.rb
+homepage: https://github.com/ozydingo/through_hierarchy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Has Many Through Hierarchy
+test_files: []