selfish_associations 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 27c26aa51df5427a9e49e1cab0579b2221dff05d
+  data.tar.gz: c097635034e3eacb38684804688c2299ae5eab7f
+SHA512:
+  metadata.gz: e859a4392f780a056d70379f3fc5bc0a1e965422f852421354240cf3dabe36a65bf3da912f1b5dbb1d1c85c24187a06ce00059cdc4251bff8093b68709b52306
+  data.tar.gz: b2042d49ad28fc35e24e6752f5823cf03bb4c0e6d6a09f0aa5487ecce69090fbfd3803540168f9b2e330db02d25536302221228bbda6161b9c579a535724b8a3

data/lib/selfish_associations/association_traverser.rb

@@ -0,0 +1,81 @@
+# A SelfishAssociations::Traverser allows you to explore an ActiveRecord's associations
+# You can call any method on an Traverser that is a valid association or column
+# name of the initialized class. For associations, the return value is another
+# Traverser for the new node, allowing you to iterate this process. For a column
+# name, the return values is an Arel::Node representing the endpoint of the traverse.
+#
+# E.g., for a class Foo that has_one :bar, where Bar has_one :baz
+# t = AssociationTraverser.new(Foo)
+# t.bar.baz.id
+# # => Arel::Attribute(table: "bazs", field: "id")
+#
+# As a Traverser gets iterated accross assocaitions, it collects every model that
+# it has seen.  You can then call :associations! to fetch these assocaitions.
+#
+# e.g., continuing from above
+# # t.associations!
+# # => {:bar => :baz}
+#
+# A Traverser keeps track of all paths it traversed, and each terminal node gets returned
+# as an Arel Node. Thus you can use it in a series of calls to return the Arel Nodes, and
+# you can subsequently call :associations! on the Traverser to gain access to all
+# paths specified by the Hash:
+#
+# t = AssociationTraverser.new(Foo)
+# {baz_id: t.bar.baz.id, quz_name: t.bar.qux.name}
+# => {baz_id: #<Arel::Attributes(table: "bazs", name: "id")>, quz_name: <#Arel::Attributes(table: quxes, name: "name")>}
+# t.associations!
+# {:bar => [:baz, :qux]}
+#
+# You can also pass merge: false to :associations! to  return associations as an unflattened Array:
+# t.associations!(merge: false)
+# [[:bar, :baz], [:bar, :qux]]
+
+
+# We use bang method names to avoid conflicting with valid association and column names
+module SelfishAssociations
+  class AssociationTraverser < BasicObject
+    def initialize(klass)
+      klass.is_a?(::Class) or ::Kernel.raise ::ArgumentError, "Input must be a Class"
+      @original = klass
+      @associations = []
+      reset!
+    end
+
+    def reset!
+      @path = []
+      @klass = @original
+    end
+
+    # Return associations traversed
+    # Default behavior is to return an array of each path (Array of associations)
+    # Use argument merge = true to return a Hash where duplicate keys are merged
+    def associations!(merge: true)
+      merge ? PathMerger.new(@associations).merge : @associations
+    end
+
+    # Method Missing pattern (reluctantly).
+    # Really we could initialize anew at each node and pre-define all methods
+    # But this actually seems more lightweight.
+    # Intercept any method to check if it is an association or a column
+    # If Association, store current node and iterate to the association.
+    # If it is a column, return an Arel::Node representing that value
+    # Else, raise NoMethodError
+    def method_missing(method, *args)
+      if @klass.column_names.include?(method.to_s)
+        @associations << @path if @path.present?
+        node = @klass.arel_table[method]
+        reset!
+        return node
+      elsif @klass.reflect_on_association(method)
+        @path << method
+        @klass = @klass.reflect_on_association(method).klass
+        return self
+      else
+        message = "No association or field named #{method} found for class #{@klass}"
+        reset!
+        ::Kernel.raise ::NoMethodError, message
+      end
+    end
+  end
+end

data/lib/selfish_associations/associations/association.rb

@@ -0,0 +1,97 @@
+# A SelfishAssociation::Association is the main engine behind generating SelfishAssociations.
+# They are primarily defined using the has_one_selfish, has_many_selfish methods.
+# But if you want to debug and explor, you can initailize a SelfishAssociation::Association
+# easily with a name and a model (class), options scope and other options.
+#
+#   assoc = SelfishAssociations::Association.new(:native_transcript, Video, ->(vid){where language_id: vid.language_id}, class_name: "Transcript")
+#
+# Use the :joins, :find, :create, and :matches methods to play!
+
+module SelfishAssociations
+  class Association
+    def initialize(name, model, scope = nil, options = {})
+      options = options.symbolize_keys
+      @name = name.to_s
+      @model = model
+      @scope = scope
+      @foreign_class_name = (options[:class_name] || name.to_s.classify).to_s
+      @foreign_key = options[:foreign_key] == false ? false : (options[:foreign_key] || @model.name.foreign_key).to_sym
+
+      validate
+
+      @reader = SelfishAssociations::ScopeReader.new(@model)
+      # Can't use ivar inside Lambda
+      foreign_key = @foreign_key
+      add_scope(->(selph){ where foreign_key => selph.id }) if @foreign_key.present?
+      add_scope(@scope) if @scope.present?
+    end
+
+    def inspect
+      "#<#{self.class}:#{self.object_id} @name=#{@name} @model=#{@model} @foreign_class=#{foreign_class} @foreign_key=#{@foreign_key}>"
+    end
+
+    def foreign_class
+      @foreign_class ||= self.class.const_get(@foreign_class_name)
+    end
+
+    def add_scope(scope)
+      @reader.read(scope)
+    end
+
+    def join
+      conditions = arelize_conditions(@reader.conditions_for_find)
+      arel_join = @model.arel_table.join(foreign_class.arel_table).on(conditions).join_sources
+      @model.joins(joins_for_find).joins(arel_join).merge(foreign_class.all)
+    end
+
+    def create(instance)
+      foreign_class.create(instance_create_attributes(instance))
+    end
+
+    def matches(instance)
+      foreign_class.where(instance_find_conditions(instance))
+    end
+
+
+    private
+
+    def arelize_conditions(conditions)
+      conditions.map do |foreign_field, node|
+        foreign_class.arel_table[foreign_field].eq(node)
+      end.reduce{|c1, c2| c1.and(c2)}
+    end
+
+    def instance_find_conditions(instance)
+      instance_conditions(instance, @reader.conditions_for_find)
+    end
+
+    def instance_create_attributes(instance)
+      instance_find_conditions(instance).merge(instance_conditions(instance, @reader.attribuets_for_create))
+    end
+
+    def joins_for_find
+      @reader.joins_for_find
+    end
+
+    def joins_for_create
+      @reader.joins_for_create
+    end
+
+    # TODO: does this even work for create??
+    def instance_conditions(instance, conditions)
+      # TODO: if no joins, we can just read fields off of instance
+      # TODO: if cached associations exist, we can read fields off those too
+      arel_conditions, static_conditions = conditions.partition{|field, value| value.is_a?(::Arel::Attribute)}.map(&:to_h)
+      selector = arel_conditions.map{|field, arel| arel.as(field.to_s)}
+      record = @model.joins(joins_for_find).select(selector).find_by(id: instance.id)
+      arel_conditions.keys.each{|k| static_conditions[k] = record[k]}
+      return static_conditions
+    end
+
+    def validate
+      # self.class.const_defined?(foreign_class) or raise SelfishAssociations::SelfishException, "No class named #{foreign_class} found."
+      @scope.nil? || @scope.is_a?(Proc) or raise SelfishAssociations::SelfishException, "Scope must be a Proc"
+      @model.is_a?(Class) && @model < ActiveRecord::Base or raise SelfishAssociations::SelfishException, "Tried to define a SelfishAssociation for an invalid object (#{@model})"
+    end
+  end
+end

data/lib/selfish_associations/associations/has_many.rb

@@ -0,0 +1,9 @@
+module SelfishAssociations
+  module Associations
+    class HasMany < SelfishAssociations::Association
+      def find(instance)
+        foreign_class.instance_exec(instance, @scope)
+      end
+    end
+  end
+end

data/lib/selfish_associations/associations/has_one.rb

@@ -0,0 +1,11 @@
+module SelfishAssociations
+  module Associations
+    class HasOne < SelfishAssociations::Association
+      def find(instance)
+        # TODO: just this? In fact, can we just combined this entirely with AR?
+        # foreign_class.instance_exec(instance, @scope).first
+        foreign_class.find_by(instance_find_conditions(instance))
+      end
+    end
+  end
+end

data/lib/selfish_associations/base.rb

@@ -0,0 +1,32 @@
+module SelfishAssociations
+  module Base
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :selfish_associations
+      self.selfish_associations = {}
+      attr_reader :selfish_association_cache
+      after_initialize :reset_selfish_association_cache
+    end
+
+    def reset_selfish_association_cache
+      @selfish_association_cache = {}
+    end
+
+    module ClassMethods
+      def has_one_selfish(name, scope = nil, **options)
+        SelfishAssociations::Builder.new(self).add_association(SelfishAssociations::Association::HasOne.new(name, self, scope, options))
+      end
+
+      def has_many_selfish(name, scope = nil, **options)
+        SelfishAssociations::Builder.new(self).add_association(SelfishAssociations::Association::HasMany.new(name, self, scope, options))
+      end
+
+      def selfish_joins(name)
+        assoc = self.selfish_associations[name] or raise SelfishException, "No selfish_associations named #{name} found, perhaps you misspelled it?"
+        assoc.join
+      end
+
+    end
+  end
+end

data/lib/selfish_associations/builder.rb

@@ -0,0 +1,23 @@
+module SelfishAssociations
+  class Builder
+    def initialize(model)
+      @model = model
+    end
+
+    def initialize_methods_class
+      @model.const_set("SelfishAssociationMethods", Module.new) unless defined? @model::SelfishAssociationMethods
+      @model.include @model::SelfishAssociationMethods if !ancestors.include?(@model::SelfishAssociationMethods)
+    end
+
+    def add_association(assoc)
+      @model.selfish_associations[name] = assoc
+
+      @model::SelfishAssociationMethods.class_eval do
+        define_method(name) do |reload = false|
+          return @selfish_association_cache[name] if !reload && @selfish_association_cache.key?(name)
+          @selfish_association_cache[name] = self.selfish_associations[name].find(self)
+        end
+      end
+    end
+  end
+end

data/lib/selfish_associations/path_merger.rb

@@ -0,0 +1,66 @@
+module SelfishAssociations
+  class PathMerger
+    attr_reader :paths
+
+    def initialize(paths)
+      @paths = paths.select(&:present?)
+    end
+
+    # Take array of arrays in @paths and turn into a nested hash
+    # Duplicate keys are collapsed into Array values
+    # Endpoint values are guaranteed to be Arrays
+    def merge
+      merged_paths = @paths.reduce({}){|merged, path| merge_paths(merged, hashify_path(path))}
+      return denillify(merged_paths)
+    end
+
+    # Convert each association index array into a 1-wide, n-deep Hash
+    # For algorithmic convenience (see below), applies a nil endpoint
+    # to all paths.
+    # So
+    #   [:a, :b, :c]
+    # becomes
+    #   {:a => {:b => {:c => nil}}}
+    def hashify_path(path)
+      path.reverse.reduce(nil){|path_partial, node| {node => path_partial}}
+    end
+
+    # Merge in a new hash path into the current merged hash paths.
+    # Dup keys are combined as a merged Hash themselves: we need recursion!
+    # Non-nil values are guaranteed to be Hashes because we've introduced the nil endpoint
+    # Therefore we can simply merge all non-nil values recursivelye
+    # So
+    #   [[:a, :b, :c], [:a, :b], [:a, :x]
+    # which hashifies into (remembering that we add nil endpoints)
+    #   [{:a => {:b => {:c => nil}}}, {:a => {:b => :nil}}, {:a => {:x => nil}}]
+    # now becomes
+    #   {:a => {:b => {:c => nil}, {:x => nil}}}
+    def merge_paths(paths, new_path)
+      paths.merge!(new_path) do |parent_node, oldval, newval|
+        if oldval.nil? || newval.nil?
+          # If either old or new path ended at parent_node, use the other
+          oldval || newval
+        else
+          # Else both paths continue from this node: recurse down the path!
+          merge_paths(oldval, newval)
+        end
+      end
+    end
+
+    # Strip off the nil endpoints in a merged nillified Hash path Array.
+    # 1-deep paths get un-Hashed. I.e., {key => nil} becomes just key.
+    # >1-deep Hashes are guaranteed to have Hash values.
+    # So, from above,
+    #   {:a => {:b => {:c => nil}, {:x => nil}}}
+    # now becomes
+    #   {:a => [:x, {:b => :c}]}
+    def denillify(paths)
+      singles, hashes = paths.keys.partition{|k| paths[k].nil?}
+      hashes.each{|k| paths[k] = denillify(paths[k])}
+      return_array = singles
+      return_array << paths.slice(*hashes) if hashes.present?
+      return return_array.length == 1 ? return_array.first : return_array
+    end
+
+  end
+end

data/lib/selfish_associations/scope_reader.rb

@@ -0,0 +1,55 @@
+# A SelfishAssociations::ScopeReader is responsible for reading a scope lambda, such
+# as `->(foo){ where language_id: foo.language_id}`. The reader collects information
+# about the scope in order to apply it either to an instnace-level find, e.g., 
+# `where(language_id: 1)`, or to a joins, e.g., `where("language_id = foos.language_id")
+# It does this by responding to `where` and `create_with` methods that you might
+# use in a scope and keeping track of the resulitng Arel Nodes in order to build
+# the find or joins query, using an SelfishAssociations::AssociationTraverser to interpret
+# the conditions themselves.
+
+module SelfishAssociations
+  class ScopeReader < BasicObject
+    attr_reader :traverser
+
+    def initialize(klass)
+      @traverser = ::SelfishAssociations::AssociationTraverser.new(klass)
+      @conditions_for_find = {}
+      @joins_for_find = []
+      @attribuets_for_create = {}
+      @joins_for_create = []
+    end
+
+    def read(scope)
+      args = scope.arity == 0 ? [] : [@traverser]
+      instance_exec(*args, &scope)
+    end
+
+    def where(conditions)
+      @conditions_for_find.merge!(conditions)
+      @joins_for_find += @traverser.associations!(merge: false)
+      @traverser.reset!
+      return self
+    end
+
+    def create_with(conditions)
+      @attribuets_for_create.merge!(conditions)
+      @joins_for_create += @traverser.associations!
+      @traverser.reset!
+      return self
+    end
+
+    attr_reader :conditions_for_find, :attribuets_for_create
+
+    def joins_for_find
+      ::SelfishAssociations::PathMerger.new(@joins_for_find).merge
+    end
+
+    def joins_for_create
+      ::SelfishAssociations::PathMerger.new(@joins_for_create).merge
+    end
+
+    # TODO: implement `.where.not`
+    # TODO: join to other SelfishAssociations associations
+
+  end
+end

data/lib/selfish_associations/selfish_exception.rb

@@ -0,0 +1,4 @@
+module SelfishAssociations
+  class SelfishException < StandardError
+  end
+end

data/lib/selfish_associations.rb

@@ -0,0 +1,7 @@
+ActiveRecord::Base.include(SelfishAssociations::Base)
+
+require 'selfish_associations/association_traverser'
+require 'selfish_associations/association'
+require 'selfish_associations/path_merger'
+require 'selfish_associations/scope_reader'
+require 'selfish_associations/selfish_exception'

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: selfish_associations
+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 ActiveRecord-like associations with self-awareness
+email: ozydingo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/selfish_associations.rb
+- lib/selfish_associations/association_traverser.rb
+- lib/selfish_associations/associations/association.rb
+- lib/selfish_associations/associations/has_many.rb
+- lib/selfish_associations/associations/has_one.rb
+- lib/selfish_associations/base.rb
+- lib/selfish_associations/builder.rb
+- lib/selfish_associations/path_merger.rb
+- lib/selfish_associations/scope_reader.rb
+- lib/selfish_associations/selfish_exception.rb
+homepage: https://github.com/ozydingo/selfish_associations
+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: Selfish Associations
+test_files: []