active_file_record 0.0.2a → 0.0.3a

data/active_file_record.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{Gem summary}
   gem.homepage      = ""
 
-  gem.files         = `git ls-files`.split($\)
+  gem.files         = `git ls-files`.split("\n")
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "active_file_record"

data/lib/active_file_record/associations.rb

@@ -0,0 +1,57 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveFileRecord
+  module Associations
+    extend ActiveSupport::Autoload
+      extend ActiveSupport::Concern
+
+      autoload :Association
+      autoload :SingularAssociation
+      autoload :BelongsToAssociation
+
+      module Builder
+        autoload :Association,           'active_file_record/associations/builder/association'
+        autoload :SingularAssociation,   'active_file_record/associations/builder/singular_association'
+        autoload :BelongsTo,           'active_file_record/associations/builder/belongs_to'
+      end
+
+      eager_autoload do
+        autoload :AssociationScope, 'active_file_record/associations/association_scope'
+      end
+
+      attr_reader :association_cache
+
+      def association(name)
+        association = association_instance_get(name)
+        if association.nil?
+          reflection  = self.class.reflect_on_association(name)
+          association = reflection.association_class.new(self, reflection)
+          association_instance_set(name, association)
+        end
+
+        association
+      end
+
+      private
+      def association_instance_get(name)
+        @association_cache[name.to_sym]
+      end
+
+      def association_instance_set(name, association)
+        @association_cache[name] = association
+      end
+
+      module ClassMethods
+        def belongs_to(name, options = {})
+            Builder::BelongsTo.build(self, name, options)
+        end
+      end
+
+  end
+end

data/lib/active_file_record/associations/association.rb

@@ -0,0 +1,101 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/inclusion'
+
+module ActiveFileRecord
+  module Associations
+
+    class Association
+      attr_reader :owner, :target, :reflection
+      delegate :options, :to => :reflection
+
+      def initialize(owner, reflection)
+        #reflection.check_validity!
+
+        @target = nil
+        @owner, @reflection = owner, reflection
+        @updated = false
+
+        reset
+        reset_scope
+      end
+
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      def reset_scope
+        @association_scope = nil
+      end
+
+      def reload
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+
+      def klass
+        reflection.klass
+      end
+
+      def scoped
+        target_scope.merge(association_scope)
+      end
+
+      def target_scope
+        klass.scoped
+      end
+
+      def association_scope
+        if klass
+          @association_scope ||= AssociationScope.new(self).scope
+        end
+      end
+
+      def set_inverse_instance(record)
+        if record && invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+        end
+      end
+
+      def inverse_reflection_for(record)
+        reflection.inverse_of
+      end
+
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def load_target
+        if find_target?
+          #begin
+          #  if IdentityMap.enabled? && association_class && association_class.respond_to?(:base_class)
+          #    @target = IdentityMap.get(association_class, owner[reflection.foreign_key])
+          #  end
+          #rescue NameError
+          #  nil
+          #ensure
+          @target ||= find_target
+          #end
+        end
+
+        loaded! unless loaded?
+        target
+        rescue ActiveFileRecord::RecordNotFound
+        reset
+      end
+
+      def loaded!
+        @loaded      = true
+        @stale_state = stale_state
+      end
+
+    end
+  end
+end

data/lib/active_file_record/associations/association_scope.rb

@@ -0,0 +1,29 @@
+module ActiveFileRecord
+  module Associations
+    class AssociationScope
+
+      attr_reader :association
+
+      delegate :klass, :owner, :reflection, :to => :association
+      delegate :chain, :conditions, :to => :reflection
+
+      def initialize(association)
+        @association   = association
+      end
+
+      def scope
+        scope = klass.unscoped
+        add_constraints(scope)
+      end
+
+      private
+
+      def add_constraints(scope)
+        key = reflection.association_primary_key
+        foreign_key = reflection.foreign_key
+        scope.where({key => {:eq => owner[foreign_key].to_i}})
+      end
+
+    end
+  end
+end

data/lib/active_file_record/associations/belongs_to_association.rb

@@ -0,0 +1,78 @@
+module ActiveFileRecord
+  module Associations
+    class BelongsToAssociation < SingularAssociation
+      def replace(record)
+        raise_on_type_mismatch(record) if record
+
+        update_counters(record)
+        replace_keys(record)
+        set_inverse_instance(record)
+
+        @updated = true if record
+
+        self.target = record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+
+        #def update_counters(record)
+        #  counter_cache_name = reflection.counter_cache_column
+        #
+        #  if counter_cache_name && owner.persisted? && different_target?(record)
+        #    if record
+        #      record.class.increment_counter(counter_cache_name, record.id)
+        #    end
+        #
+        #    if foreign_key_present?
+        #      klass.decrement_counter(counter_cache_name, target_id)
+        #    end
+        #  end
+        #end
+
+        # Checks whether record is different to the current target, without loading it
+        def different_target?(record)
+          record.nil? && owner[reflection.foreign_key] ||
+          record && record.id != owner[reflection.foreign_key]
+        end
+
+        def replace_keys(record)
+          if record
+            owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+          else
+            owner[reflection.foreign_key] = nil
+          end
+        end
+
+        def foreign_key_present?
+          owner[reflection.foreign_key]
+        end
+
+        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+        # has_one associations.
+        def invertible_for?(record)
+          inverse = inverse_reflection_for(record)
+          inverse && inverse.macro == :has_one
+        end
+
+        def target_id
+          if options[:primary_key]
+            owner.send(reflection.name).try(:id)
+          else
+            owner[reflection.foreign_key]
+          end
+        end
+
+        def stale_state
+          owner[reflection.foreign_key].to_s
+        end
+    end
+  end
+end

data/lib/active_file_record/associations/builder/association.rb

@@ -0,0 +1,46 @@
+module ActiveFileRecord::Associations::Builder
+  class Association
+    class_attribute :macro
+
+    attr_reader :model, :name, :options, :reflection
+
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+
+    def initialize(model, name, options)
+      @model, @name, @options = model, name, options
+    end
+
+    def mixin
+      @model.generated_feature_methods
+    end
+
+    def build
+      reflection = model.create_reflection(self.class.macro, name, options, model)
+      define_accessors
+      reflection
+    end
+
+    private
+
+      def define_accessors
+        define_readers
+        define_writers
+      end
+
+      def define_readers
+        name = self.name
+        mixin.redefine_method(name) do |*params|
+          association(name).reader(*params)
+        end
+      end
+
+      def define_writers
+        name = self.name
+        mixin.redefine_method("#{name}=") do |value|
+          association(name).writer(value)
+        end
+      end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'active_support/core_ext/object/inclusion'
+
+module ActiveFileRecord::Associations::Builder
+  class BelongsTo < Association #< SingularAssociation #:nodoc:
+    self.macro = :belongs_to
+
+    def build
+      reflection = super
+      reflection
+    end
+
+  end
+end

data/lib/active_file_record/associations/singular_association.rb

@@ -0,0 +1,64 @@
+module ActiveFileRecord
+  module Associations
+    class SingularAssociation < Association #:nodoc:
+      # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
+      def reader(force_reload = false)
+        if force_reload
+          klass.uncached { reload }
+        elsif !loaded? || stale_target?
+          reload
+        end
+
+        target
+      end
+
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(record)
+        replace(record)
+      end
+
+      def create(attributes = {}, options = {}, &block)
+        create_record(attributes, options, &block)
+      end
+
+      def create!(attributes = {}, options = {}, &block)
+        create_record(attributes, options, true, &block)
+      end
+
+      def build(attributes = {}, options = {})
+        record = build_record(attributes, options)
+        yield(record) if block_given?
+        set_new_record(record)
+        record
+      end
+
+      private
+
+        def create_scope
+          scoped.scope_for_create.stringify_keys.except(klass.primary_key)
+        end
+
+        def find_target
+          scoped.first.tap { |record| set_inverse_instance(record) }
+        end
+
+        # Implemented by subclasses
+        def replace(record)
+          raise NotImplementedError, "Subclasses must implement a replace(record) method"
+        end
+
+        def set_new_record(record)
+          replace(record)
+        end
+
+        def create_record(attributes, options, raise_error = false)
+          record = build_record(attributes, options)
+          yield(record) if block_given?
+          saved = record.save
+          set_new_record(record)
+          raise RecordInvalid.new(record) if !saved && raise_error
+          record
+        end
+    end
+  end
+end

data/lib/active_file_record/attribute_assignment.rb

@@ -0,0 +1,25 @@
+module ActiveFileRecord
+  module AttributeAssignment
+
+    extend ActiveSupport::Concern
+    include ActiveModel::MassAssignmentSecurity
+
+    def attributes=(new_attributes)
+      return unless new_attributes.is_a?(Hash)
+
+      assign_attributes(new_attributes)
+    end
+
+    def assign_attributes(new_attributes, options = {})
+      return if new_attributes.blank?
+
+      attributes = new_attributes.stringify_keys
+      attributes = sanitize_for_mass_assignment(attributes) unless options[:without_protection]
+
+      attributes.each do |k, v|
+        send("#{k}=", v)
+      end
+    end
+
+  end
+end

data/lib/active_file_record/attribute_methods.rb

@@ -0,0 +1,48 @@
+module ActiveFileRecord
+  module AttributeMethods
+
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      include Read
+      include Write
+
+      class_attribute :_fields
+      self._fields = []
+
+      def [](attr_name)
+        read_attribute(attr_name)
+      end
+
+      def []=(attr_name, value)
+        write_attribute(attr_name, value)
+      end
+    end
+
+    def attribute_names
+      @attributes.keys
+    end
+
+
+    module ClassMethods
+      def fields(*names)
+        self._fields += names
+        define_attribute_methods names
+      end
+
+      def initialize_attributes(fields_names)
+        Hash[fields_names.map {|attribute| [attribute, nil]}]
+      end
+
+      def generated_methods
+        @generated_methods ||= begin
+        mod = Module.new
+        include(mod)
+          mod
+        end
+      end
+    end
+
+  end
+end