perry 0.4.0

data/lib/perry/association_preload.rb

@@ -0,0 +1,69 @@
+module Perry::AssociationPreload
+  module ClassMethods
+
+    def eager_load_associations(original_results, relation)
+      relation.includes_values.each do |association_id|
+        association = self.defined_associations[association_id.to_sym]
+        force_fresh = relation.fresh_value
+
+        unless association
+          raise(
+            Perry::AssociationNotFound,
+            "no such association (#{association_id})"
+          )
+        end
+
+        unless association.eager_loadable?
+          raise(
+            Perry::AssociationPreloadNotSupported,
+            "delayed execution options (block options) cannot be used for eager loaded associations"
+          )
+        end
+
+        options = association.options
+
+        case association.type
+        when :has_many, :has_one
+          fks = original_results.collect { |record| record.send(association.primary_key) }.compact
+
+          pre_records = association.target_klass.where(association.foreign_key => fks).all(:fresh => force_fresh)
+
+          original_results.each do |record|
+            pk = record.send(association.primary_key)
+            relevant_records = pre_records.select { |r| r.send(association.foreign_key) == pk }
+
+            relevant_records = if association.collection?
+              scope = association.scope(record).where(association.foreign_key => pk)
+              scope.records = relevant_records
+              scope
+            else
+              relevant_records.first
+            end
+
+            record.send("#{association.id}=", relevant_records)
+          end
+
+        when :belongs_to
+          fks = original_results.collect { |record| record.send(association.foreign_key) }.compact
+
+          pre_records = association.target_klass.where(association.primary_key => fks).all(:fresh => force_fresh)
+
+          original_results.each do |record|
+            fk = record.send(association.foreign_key)
+            relevant_records = pre_records.select { |r| r.send(association.primary_key) == fk }.first
+            record.send("#{association.id}=", relevant_records)
+          end
+        end
+      end
+    end
+
+  end
+
+  module InstanceMethods
+  end
+
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+end

data/lib/perry/associations/common.rb

@@ -0,0 +1,51 @@
+module Perry::Associations
+
+  module Common
+    module ClassMethods
+
+      def base_class_name(klass)
+        klass.to_s.split("::").last
+      end
+
+      # TRP: This will return the most recent extension of klass or klass if it is a leaf node in the hierarchy
+      def resolve_leaf_klass(klass)
+        extension_map[klass].empty? ? klass : resolve_leaf_klass(extension_map[klass].last)
+      end
+
+      protected
+
+      def extension_map
+        @@extension_map ||= Hash.new(Array.new)
+      end
+
+      def update_extension_map(old_klass, new_klass)
+        self.extension_map[old_klass] += [new_klass] if base_class_name(old_klass) == base_class_name(new_klass)
+      end
+
+    end
+
+    module InstanceMethods
+
+      protected
+
+      def klass_from_association_options(association, options)
+        klass = if options[:polymorphic]
+          eval [options[:polymorphic_namespace], self.send("#{association}_type")].compact.join('::')
+        else
+          raise(ArgumentError, ":class_name option required for association declaration.") unless options[:class_name]
+          options[:class_name] = "::#{options[:class_name]}" unless options[:class_name] =~ /^::/
+          eval(options[:class_name])
+        end
+
+        self.class.send :resolve_leaf_klass, klass
+      end
+
+    end
+
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/perry/associations/contains.rb

@@ -0,0 +1,64 @@
+require 'perry/associations/common'
+
+module Perry::Associations
+
+  module Contains
+    module ClassMethods
+
+      # TRP: Define an association that is serialized within the data for this class.
+      # If a subset of the data returned for a class contains the data for another class you can use the contains_many
+      # association to (lazy) auto initialize the specified object(s) using the data from that attribute.
+      def contains_many(association, options={})
+        create_contains_association(:many, association, options)
+      end
+
+      # TRP: Same as contains_many, but only works with a single record
+      def contains_one(association, options={})
+        create_contains_association(:one, association, options)
+      end
+
+      private
+
+      def create_contains_association(type, association, options)
+        attribute = (options[:attribute] || association).to_sym
+        cache_variable = "@association_#{association}"
+
+        self.defined_attributes << association.to_s unless self.defined_attributes.include?(association.to_s)
+        define_method(association) do
+          klass = klass_from_association_options(association, options)
+          records = instance_variable_get(cache_variable)
+
+          unless records
+            records = case type
+            when :many
+              self[attribute].collect { |record| klass.new_from_data_store(record) } if self[attribute]
+            when :one
+              klass.new_from_data_store(self[attribute]) if self[attribute]
+            end
+            instance_variable_set(cache_variable, records)
+          end
+
+          records
+        end
+
+        # TRP: This method will allow eager loaded values to be loaded into the association
+        define_method("#{association}=") do |value|
+          instance_variable_set(cache_variable, value)
+        end
+
+      end
+
+    end
+
+    module InstanceMethods
+
+    end
+
+    def self.included(receiver)
+      receiver.send :include, Perry::Associations::Common
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/perry/associations/external.rb

@@ -0,0 +1,67 @@
+require 'perry/associations/common'
+require 'perry/association'
+
+module Perry::Associations
+
+  module External
+    module ClassMethods
+
+      def belongs_to(id, options={})
+        create_external_association Perry::Association::BelongsTo.new(self, id, options)
+      end
+
+      def has_one(id, options={})
+        create_external_association Perry::Association::HasOne.new(self, id, options)
+      end
+
+      def has_many(id, options={})
+        klass = if options.include?(:through)
+          Perry::Association::HasManyThrough
+        else
+          Perry::Association::HasMany
+        end
+        create_external_association klass.new(self, id, options)
+      end
+
+      protected
+
+      def create_external_association(association)
+        cache_ivar = "@association_#{association.id}"
+        self.defined_associations[association.id] = association
+
+        define_method(association.id) do
+          cached_value = instance_variable_get(cache_ivar)
+
+          # TRP: Logic for actually pulling & setting the value
+          unless cached_value
+            scoped = association.scope(self)
+
+            if scoped && !scoped.where_values.empty?
+              cached_value = association.collection? ? scoped : scoped.first
+            end
+
+            instance_variable_set(cache_ivar, cached_value)
+          end
+
+          cached_value
+        end
+
+        # TRP: Allow eager loading of the association without having to load it through the normal accessor
+        define_method("#{association.id}=") do |value|
+          instance_variable_set(cache_ivar, value)
+        end
+      end
+
+    end
+
+    module InstanceMethods
+    end
+
+    def self.included(receiver)
+      receiver.send :include, Perry::Associations::Common
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/perry/base.rb

@@ -0,0 +1,204 @@
+# TRP: Perry modules
+require 'perry/errors'
+require 'perry/associations/contains'
+require 'perry/associations/external'
+require 'perry/association_preload'
+require 'perry/cacheable'
+require 'perry/serialization'
+require 'perry/relation'
+require 'perry/scopes'
+require 'perry/adapters'
+
+
+class Perry::Base
+  include Perry::Associations::Contains
+  include Perry::Associations::External
+  include Perry::AssociationPreload
+  include Perry::Serialization
+  include Perry::Scopes
+
+  attr_accessor :attributes, :new_record, :read_options, :write_options
+  alias :new_record? :new_record
+
+  class_inheritable_accessor :read_adapter, :write_adapter, :cacheable,
+    :defined_attributes, :scoped_methods, :defined_associations
+
+  self.cacheable = false
+  self.defined_associations = {}
+  self.defined_attributes = []
+
+  def initialize(attributes={})
+    self.new_record = true
+    set_attributes(attributes)
+  end
+
+  def [](attribute)
+    @attributes[attribute.to_s]
+  end
+
+  protected
+
+  # TRP: Common interface for setting attributes to keep things consistent; if
+  # force is true the defined_attributes list will be ignored
+  def set_attributes(attributes, force=false)
+    attributes = attributes.inject({}) do |options, (key, value)|
+      options[key.to_s] = value
+      options
+    end
+    @attributes = {} if @attributes.nil?
+    @attributes.merge!(attributes.reject { |field, value|
+      !self.defined_attributes.include?(field) && !force
+    })
+  end
+
+  def set_attribute(attribute, value, force=false)
+    set_attributes({ attribute => value }, force)
+  end
+
+  # Class Methods
+  class << self
+    public
+
+    delegate :find, :first, :all, :search, :apply_finder_options, :to => :scoped
+    delegate :select, :group, :order, :joins, :where, :having, :limit, :offset,
+      :from, :fresh, :to => :scoped
+
+    def new_from_data_store(hash)
+      if hash.nil?
+        nil
+      else
+        record = self.new(hash)
+        record.new_record = false
+        record
+      end
+    end
+
+    def unscoped
+      current_scopes = self.scoped_methods
+      self.scoped_methods = []
+      begin
+        yield
+      ensure
+        self.scoped_methods = current_scopes
+      end
+    end
+
+    def inherited(subclass)
+      update_extension_map(self, subclass)
+      super
+    end
+
+    def respond_to?(method, include_private=false)
+      super ||
+      scoped.dynamic_finder_method(method)
+    end
+
+    protected
+
+    def fetch_records(relation)
+      options = relation.to_hash
+      self.read_adapter.read(options).collect { |hash| self.new_from_data_store(hash) }.compact.tap { |result| eager_load_associations(result, relation) }
+    end
+
+    def read_with(adapter_type)
+      setup_adapter(:read, { :type => adapter_type })
+    end
+
+    def write_with(adapter_type)
+      if write_adapter
+        write_inheritable_attribute :write_adapter, nil if adapter_type != write_adapter.type
+      else
+        # TRP: Pull in methods and libraries needed for mutable functionality
+        require 'perry/persistence' unless defined?(Perry::Persistence)
+        self.send(:include, Perry::Persistence) unless self.class.ancestors.include?(Perry::Persistence)
+
+        # TRP: Create writers if attributes are declared before configure_mutable is called
+        self.defined_attributes.each { |attribute| create_writer(attribute) }
+        # TRP: Create serialized writers if attributes are declared serialized before this call
+        self.serialized_attributes.each { |attribute| set_serialize_writers(attribute) }
+      end
+      setup_adapter(:write, { :type => adapter_type })
+    end
+
+    def configure_read(&block)
+      configure_adapter(:read, &block)
+    end
+
+    def configure_write(&block)
+      configure_adapter(:write, &block)
+    end
+
+    def method_missing(method, *args, &block)
+      if scoped.dynamic_finder_method(method)
+        scoped.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def configure_cacheable(options={})
+      unless cacheable
+        self.send(:include, Perry::Cacheable)
+        self.enable_caching(options)
+      end
+    end
+
+    # TRP: Used to declare attributes -- only attributes that are declared will be available
+    def attributes(*attributes)
+      return self.defined_attributes if attributes.empty?
+
+      [*attributes].each do |attribute|
+        self.defined_attributes << attribute.to_s
+
+        define_method(attribute) do
+          self[attribute]
+        end
+
+        # TRP: Setup the writers if mutable is set
+        create_writer(attribute) if self.write_adapter
+
+      end
+    end
+    def attribute(*attrs)
+      self.attributes(*attrs)
+    end
+
+    def relation
+      @relation ||= Perry::Relation.new(self)
+    end
+
+    def default_scope(scope)
+      base_scope = current_scope || relation
+      self.scoped_methods << (scope.is_a?(Hash) ? base_scope.apply_finder_options(scope) : base_scope.merge(scope))
+    end
+
+    def current_scope
+      self.scoped_methods ||= []
+      self.scoped_methods.last
+    end
+
+    private
+
+    def setup_adapter(mode, config)
+      current_adapter = read_inheritable_attribute :"#{mode}_adapter"
+      type = config[:type] if config.is_a?(Hash)
+
+      new_adapter = if current_adapter
+        current_adapter.extend_adapter(config)
+      else
+        Perry::Adapters::AbstractAdapter.create(type, config)
+      end
+
+      write_inheritable_attribute :"#{mode}_adapter", new_adapter
+    end
+
+    def configure_adapter(mode, &block)
+      raise ArgumentError, "A block must be passed to configure_#{mode} method." unless block_given?
+      raise ArgumentError, "You must first define an adapter before configuring it.  Use #{mode}_with :adapter_type." unless self.send(:"#{mode}_adapter")
+
+      setup_adapter(mode, block)
+    end
+
+  end
+
+end