selfish_associations 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27c26aa51df5427a9e49e1cab0579b2221dff05d
-  data.tar.gz: c097635034e3eacb38684804688c2299ae5eab7f
+  metadata.gz: 3bd7fff1c41265161aea2372a9fb041ce4ff77e0
+  data.tar.gz: 7af54ffb489231247f270348800a6e144418d847
 SHA512:
-  metadata.gz: e859a4392f780a056d70379f3fc5bc0a1e965422f852421354240cf3dabe36a65bf3da912f1b5dbb1d1c85c24187a06ce00059cdc4251bff8093b68709b52306
-  data.tar.gz: b2042d49ad28fc35e24e6752f5823cf03bb4c0e6d6a09f0aa5487ecce69090fbfd3803540168f9b2e330db02d25536302221228bbda6161b9c579a535724b8a3
+  metadata.gz: 93cdb13cfba94868478e470979fb9cbc4696771ae45344ead80bb9cb3f578039d61622dc833e96914fa86b5869bc2a0a3dfa8a79f012fca3623d8a8b6fcc8e35
+  data.tar.gz: 3a50a8ef46c954d305ddfce23a041b53b059b33103e7fc88f53c9fa80db0b0a24ca9f3633a9fe953c965678f3e1662f2f614211b0c5a0abf2b8963a7daab39aa

data/lib/selfish_associations/associations/association.rb

@@ -16,14 +16,8 @@ module SelfishAssociations
       @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
-
+      @foreign_key_scope = @foreign_key.present? ? foreign_key_scope : nil
       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
@@ -34,63 +28,93 @@ module SelfishAssociations
       @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)
+      conditions = arelize_conditions(relation_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)
+    def matches_for(instance)
       foreign_class.where(instance_find_conditions(instance))
     end
 
+    def create_for(instance)
+      foreign_class.create(instance_create_attributes(instance))
+    end
 
     private
 
+    def apply_scopes(reader)
+      reader.read(@scope) if @scope.present?
+      reader.read(@foreign_key_scope) if @foreign_key.present?
+      return reader
+    end
+
     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.reduce(&:and)
     end
 
     def instance_find_conditions(instance)
-      instance_conditions(instance, @reader.conditions_for_find)
+      read_instance_find_conditions(instance)
+      # TODO: dynamically determine if we should use lookup_instance_find_conditions instead
+      # cannot use if the scope constains non-associations
+      # should not use if all associations are preloaded on instance
+      # cannot use if instance contains unpersisted changes
     end
 
-    def instance_create_attributes(instance)
-      instance_find_conditions(instance).merge(instance_conditions(instance, @reader.attribuets_for_create))
+    def relation_reader
+      @relation_reader ||= apply_scopes(SelfishAssociations::ScopeReaders::Relation.new(@model))
     end
 
-    def joins_for_find
-      @reader.joins_for_find
+    def instance_reader(instance)
+      apply_scopes(ScopeReaders::Instance.new(instance))
     end
 
-    def joins_for_create
-      @reader.joins_for_create
+    def read_instance_find_conditions(instance)
+      instance_reader(instance).attributes_for_find
     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
+    def read_instance_create_attributes(instance)
+      instance_reader(instance).attributes_for_create
+    end
+
+    def lookup_instance_find_conditions(instance)
+      instantiate_conditions(instance, relation_reader.conditions_for_find)
+    end
+
+    def lookup_instance_create_attributes(instance)
+      instantiate_conditions(instance, relation_reader.attributes_for_create)
+    end
+
+    def instantiate_conditions(instance, conditions)
       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]}
+      instance = @model.joins(joins_for_find).select(selector).find_by(id: instance.id)
+      arel_conditions.keys.each{|k| static_conditions[k] = instance[k]}
       return static_conditions
     end
 
+    def joins_for_find
+      relation_reader.joins_for_find
+    end
+
+    def joins_for_create
+      relation_reader.joins_for_create
+    end
+
+    def foreign_key_scope
+      # TODO: pass foreign_key in rather than using the closure
+      foreign_key = @foreign_key
+      return ->(obj){ where foreign_key => obj.id }
+    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"
+      if @scope.present?
+        @scope.is_a?(Proc) or raise SelfishAssociations::SelfishException, "Scope must be a Proc"
+        @scope.arity == 0 || @scope.arity == 1 or raise SelfishAssociations::SelfishException, "Scope must have arity of 0 or 1"
+      end
       @model.is_a?(Class) && @model < ActiveRecord::Base or raise SelfishAssociations::SelfishException, "Tried to define a SelfishAssociation for an invalid object (#{@model})"
     end
   end

data/lib/selfish_associations/associations/has_many.rb

@@ -2,7 +2,7 @@ module SelfishAssociations
   module Associations
     class HasMany < SelfishAssociations::Association
       def find(instance)
-        foreign_class.instance_exec(instance, @scope)
+        matches_for(instance)
       end
     end
   end

data/lib/selfish_associations/associations/has_one.rb

@@ -2,9 +2,7 @@ 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))
+        matches_for(instance).first
       end
     end
   end

data/lib/selfish_associations/base.rb

@@ -15,11 +15,11 @@ module SelfishAssociations
 
     module ClassMethods
       def has_one_selfish(name, scope = nil, **options)
-        SelfishAssociations::Builder.new(self).add_association(SelfishAssociations::Association::HasOne.new(name, self, scope, options))
+        SelfishAssociations::Builder.new(self).add_association(name, SelfishAssociations::Associations::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))
+        SelfishAssociations::Builder.new(self).add_association(name, SelfishAssociations::Associations::HasMany.new(name, self, scope, options))
       end
 
       def selfish_joins(name)

data/lib/selfish_associations/builder.rb

@@ -6,10 +6,11 @@ module SelfishAssociations
 
     def initialize_methods_class
       @model.const_set("SelfishAssociationMethods", Module.new) unless defined? @model::SelfishAssociationMethods
-      @model.include @model::SelfishAssociationMethods if !ancestors.include?(@model::SelfishAssociationMethods)
+      @model.include @model::SelfishAssociationMethods if !@model.ancestors.include?(@model::SelfishAssociationMethods)
     end
 
-    def add_association(assoc)
+    def add_association(name, assoc)
+      initialize_methods_class
       @model.selfish_associations[name] = assoc
 
       @model::SelfishAssociationMethods.class_eval do

data/lib/selfish_associations/scope_readers/instance.rb

@@ -0,0 +1,38 @@
+module SelfishAssociations
+  module ScopeReaders
+    class Instance < BasicObject
+      attr_reader :attributes_for_find, :attributes_for_create
+
+      def initialize(instance)
+        @instance = Nilifier.new(instance)
+        @attributes_for_find = {}
+        @attributes_for_create = {}
+      end
+
+      def read(scope)
+        args = scope.arity == 0 ? [] : [@instance]
+        instance_exec(*args, &scope)
+        return self
+      end
+
+      def where(conditions)
+        unnilify(conditions)
+        create_with(conditions)
+        @attributes_for_find.merge!(conditions)
+        return self
+      end
+
+      def create_with(conditions)
+        unnilify(conditions)
+        @attributes_for_create.merge!(conditions)
+        return self
+      end
+
+      def unnilify(conditions)
+        conditions.keys.each do |key|
+          conditions[key] = conditions[key].unnilify if conditions[key].respond_to?(:unnilify?)
+        end
+      end
+    end
+  end
+end

data/lib/selfish_associations/scope_readers/relation.rb

@@ -0,0 +1,61 @@
+# A scope reader is an object that response to scope methods such as `where` and 
+# `create_with`. It must return a ScopeReader for each of these methods so that
+# these methods can be chained. For it to be useful, these methods must also have
+# side effects that can be inspected by a third party.
+# 
+# For SelfishAssociations, we generally want to support passing a single argument
+# to the scope lambda. E.g. `->(record){ where field: record.matching_field }`. In
+# order to collect useful information, we may want to pass a special object in place
+# of `record`: one that can respond to the same methods that `record` could respond
+# to, but in doing so collects information about each call that is being made. This
+# is what we are using the `AssociationTraverser` for in `ScopeReaders::Relation`.
+# This traverser can respond to relations and field names of the record model.
+# Similarly, it returns a modified traverser in respons to this so that those calls
+# may also be chained. For more, see association_traverser.rb.
+
+module SelfishAssociations
+  module ScopeReaders
+    class Relation < BasicObject
+      attr_reader :conditions_for_find, :attributes_for_create
+      attr_reader :traverser
+
+      def initialize(klass)
+        @traverser = ::SelfishAssociations::AssociationTraverser.new(klass)
+        @conditions_for_find = {}
+        @joins_for_find = []
+        @attributes_for_create = {}
+        @joins_for_create = []
+      end
+
+      def read(scope)
+        args = scope.arity == 0 ? [] : [@traverser]
+        instance_exec(*args, &scope)
+        return self
+      end
+
+      # TODO: implement argless where() and not()
+      def where(conditions)
+        create_with(conditions)
+        @conditions_for_find.merge!(conditions)
+        @joins_for_find += @traverser.associations!(merge: false)
+        @traverser.reset!
+        return self
+      end
+
+      def create_with(conditions)
+        @attributes_for_create.merge!(conditions)
+        @joins_for_create += @traverser.associations!(merge: false)
+        @traverser.reset!
+        return self
+      end
+
+      def joins_for_find
+        ::SelfishAssociations::PathMerger.new(@joins_for_find).merge
+      end
+
+      def joins_for_create
+        ::SelfishAssociations::PathMerger.new(@joins_for_create).merge
+      end
+    end
+  end
+end

data/lib/selfish_associations/{association_traverser.rb → utils/association_traverser.rb}

@@ -9,8 +9,8 @@
 # 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.
+# As a Traverser gets iterated accross associations, it collects every model that
+# it has seen.  You can then call :associations! to fetch these associations.
 #
 # e.g., continuing from above
 # # t.associations!
@@ -71,6 +71,10 @@ module SelfishAssociations
         @path << method
         @klass = @klass.reflect_on_association(method).klass
         return self
+      elsif @klass.selfish_associations[method].present?
+        @path << method
+        @klass = @klass.selfish_associations[method].foreign_class
+        return self
       else
         message = "No association or field named #{method} found for class #{@klass}"
         reset!

data/lib/selfish_associations/utils/nilifier.rb

@@ -0,0 +1,24 @@
+module SelfishAssociations
+  class Nilifier < BasicObject
+    def initialize(object)
+      @object = object
+    end
+
+    def inspect
+      @object.inspect + " (nil-safe)"
+    end
+
+    def unnilify
+      @object
+    end
+
+    def respond_to?(method)
+      true
+    end
+
+    def method_missing(method, *args)
+      result = @object.respond_to?(method) ? @object.public_send(method, *args) : nil
+      ::SelfishAssociations::Nilifier.new(result)
+    end
+  end
+end

data/lib/selfish_associations.rb

@@ -1,7 +1,13 @@
-ActiveRecord::Base.include(SelfishAssociations::Base)
+require 'selfish_associations/base'
+require 'selfish_associations/builder'
+require 'selfish_associations/selfish_exception'
+require 'selfish_associations/utils/association_traverser'
+require 'selfish_associations/utils/nilifier'
+require 'selfish_associations/utils/path_merger'
+require 'selfish_associations/scope_readers/instance'
+require 'selfish_associations/scope_readers/relation'
+require 'selfish_associations/associations/association'
+require 'selfish_associations/associations/has_one'
+require 'selfish_associations/associations/has_many'
 
-require 'selfish_associations/association_traverser'
-require 'selfish_associations/association'
-require 'selfish_associations/path_merger'
-require 'selfish_associations/scope_reader'
-require 'selfish_associations/selfish_exception'
+ActiveRecord::Base.include(SelfishAssociations::Base)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: selfish_associations
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Andrew Schwartz
@@ -10,22 +10,24 @@ bindir: bin
 cert_chain: []
 date: 2016-05-04 00:00:00.000000000 Z
 dependencies: []
-description: Create ActiveRecord-like associations with self-awareness
+description: Create joinable associations with instance/record-level constraints
 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/scope_readers/instance.rb
+- lib/selfish_associations/scope_readers/relation.rb
 - lib/selfish_associations/selfish_exception.rb
+- lib/selfish_associations/utils/association_traverser.rb
+- lib/selfish_associations/utils/nilifier.rb
+- lib/selfish_associations/utils/path_merger.rb
 homepage: https://github.com/ozydingo/selfish_associations
 licenses:
 - MIT

data/lib/selfish_associations/scope_reader.rb

@@ -1,55 +0,0 @@
-# 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