perry 0.4.0 → 0.5.0

data/lib/perry/middlewares/cache_records.rb

@@ -0,0 +1,67 @@
+class Perry::Middlewares::CacheRecords; end
+require 'perry/middlewares/cache_records/store'
+require 'perry/middlewares/cache_records/entry'
+require 'perry/middlewares/cache_records/scopes'
+require 'digest/md5'
+
+class Perry::Middlewares::CacheRecords
+  include Perry::Logger
+
+  attr_accessor :record_count_threshold
+
+  # TRP: Default to a 5 minute cache
+  DEFAULT_LONGEVITY = 5*60
+
+  def reset_cache_store(default_longevity=DEFAULT_LONGEVITY)
+    @cache_store = Perry::Middlewares::CacheRecords::Store.new(default_longevity)
+  end
+
+  def cache_store
+    @cache_store || reset_cache_store
+  end
+
+  def initialize(adapter, config={})
+    @adapter = adapter
+    self.record_count_threshold = config[:record_count_threshold]
+  end
+
+  def call(options)
+    if options[:relation]
+      call_with_cache(options)
+    else
+      @adapter.call(options)
+    end
+  end
+
+  protected
+
+  def call_with_cache(options)
+    relation = options[:relation]
+    modifiers = relation.modifiers_value
+    query = relation.to_hash
+
+    reset_cache_store if modifiers[:reset_cache]
+    get_fresh = modifiers[:fresh]
+
+    key = key_for_query(query)
+    cached_values = self.cache_store.read(key)
+
+
+    if cached_values && !get_fresh
+      log(query, "CACHE #{relation.klass.name}")
+      cached_values
+    else
+      fresh_values = @adapter.call(options)
+      self.cache_store.write(key, fresh_values) if should_store_in_cache?(fresh_values)
+      fresh_values
+    end
+  end
+
+  def key_for_query(query_hash)
+    Digest::MD5.hexdigest(self.class.to_s + query_hash.to_a.sort { |a,b| a.to_s.first <=> b.to_s.first }.inspect)
+  end
+
+  def should_store_in_cache?(fresh_values)
+    !self.record_count_threshold || fresh_values.size <= self.record_count_threshold
+  end
+end

data/lib/perry/middlewares/model_bridge.rb

@@ -0,0 +1,66 @@
+class Perry::Middlewares::ModelBridge
+
+  def initialize(adapter, config={})
+    @adapter = adapter
+    @config = config
+  end
+
+  def call(options)
+    result = @adapter.call(options)
+
+    case options[:mode]
+    when :read
+      build_models_from_records(result, options)
+    when :write
+      update_model_after_save(result, options[:object])
+      result
+    when :delete
+      update_model_after_delete(result, options[:object])
+      result
+    else
+      result
+    end
+  end
+
+  protected
+
+  def build_models_from_records(records, options)
+    if options[:relation]
+      records.collect do |attributes|
+        options[:relation].klass.new_from_data_store(attributes)
+      end
+    else
+      records
+    end
+  end
+
+  def update_model_after_save(response, model)
+    model.saved = response.success
+    if model.saved
+      if model.new_record?
+        key = response.model_attributes[model.primary_key]
+        raise Perry::PerryError.new('primary key not included in response') if key.nil?
+        model.send("#{model.primary_key}=", key)
+      end
+      model.new_record = false
+      model.reload unless model.read_adapter.nil?
+    else
+      add_errors_to_model(response, model, 'not saved')
+    end
+  end
+
+  def update_model_after_delete(response, model)
+    if response.success
+      model.freeze!
+    else
+      add_errors_to_model(response, model, 'not deleted')
+    end
+  end
+
+  def add_errors_to_model(response, model, default_message)
+    errors = response.errors
+    errors[:base] = default_message if errors.empty?
+    model.errors.merge!(errors)
+  end
+
+end

data/lib/perry/middlewares.rb

@@ -0,0 +1,8 @@
+module Perry::Middlewares
+
+  autoload :ModelBridge, 'perry/middlewares/model_bridge'
+  autoload :PreloadAssociations, 'perry/middlewares/preload_associations'
+  autoload :CacheRecords, 'perry/middlewares/cache_records'
+
+end
+

data/lib/perry/persistence/response.rb

@@ -0,0 +1,75 @@
+module Perry::Persistence
+  class Response
+
+    @@parsers = { :json => ::JSON }
+    ATTRIBUTES = [:success, :status, :meta, :raw, :raw_format, :parsed]
+
+    # A boolean value reflecting whether or not the response was successful
+    attr_accessor :success
+
+    # A more detailed report of the success/failure of the response
+    attr_accessor :status
+
+    # Any adapter specific response metadata
+    attr_accessor :meta
+
+    # Raw response -- format specified by raw_format
+    attr_accessor :raw
+
+    # Format of the raw response
+    attr_accessor :raw_format
+
+    # Parsed raw data
+    attr_writer :parsed
+
+    # @attrs: Sets any values listed in ATTRIBUTES
+    def initialize(attrs={})
+      ATTRIBUTES.each do |attr|
+        self.send("#{attr}=", attrs[attr])
+      end
+    end
+
+    def parsed
+      if parser = self.class.parsers[self.raw_format]
+        begin
+          @parsed ||= parser.parse(self.raw)
+        rescue Exception => err
+          Perry.logger.error("Failure parsing raw response #{err.inspect}")
+          Perry.logger.error("Response: #{self.inspect}")
+          nil
+        end
+      else
+        @parsed
+      end
+    end
+
+    def self.parsers
+      @@parsers
+    end
+
+    def model_attributes
+      # return the inner hash if nested
+      if parsed_hash.keys.size == 1 && parsed_hash[parsed_hash.keys.first].is_a?(Hash)
+        parsed_hash[parsed_hash.keys.first]
+      else
+        parsed_hash
+      end.symbolize_keys
+    end
+
+    def errors
+      parsed_hash.symbolize_keys
+    end
+
+    protected
+
+    def parsed_hash
+      if parsed.is_a?(Hash)
+        parsed
+      else
+        {}
+      end
+    end
+
+  end
+end
+

data/lib/perry/persistence.rb

@@ -1,3 +1,5 @@
+require 'perry/persistence/response'
+
 module Perry::Persistence
 
   module ClassMethods
@@ -24,7 +26,8 @@ module Perry::Persistence
     end
 
     def save
-      write_adapter.write(self)
+      raise Perry::PerryError.new("cannot write a frozen object") if frozen?
+      write_adapter.call(:write, :object => self).success
     end
 
     def save!
@@ -41,10 +44,44 @@ module Perry::Persistence
     end
 
     def destroy
-      write_adapter.delete(self) unless self.new_record?
+      raise Perry::PerryError.new("cannot destroy a frozen object") if frozen?
+      unless self.new_record? || self.send(primary_key).nil?
+        write_adapter.call(:delete, :object => self).success
+      end
     end
     alias :delete :destroy
 
+    def destroy!
+      destroy or raise Perry::RecordNotSaved
+    end
+    alias :delete! :destroy!
+
+    def reload
+      self.attributes = self.class.where(primary_key => self.send(primary_key)).first.attributes
+    end
+
+    # Calls Object#freeze on the model and on the attributes hash in addition to
+    # calling #freeze! to prevent the model from being saved or destroyed.
+    #
+    def freeze
+      freeze!
+      attributes.freeze
+      super
+    end
+
+    # Prevents the model from being saved or destroyed in the future while still
+    # allowing the model and its attributes hash to be modified.
+    #
+    def freeze!
+      @frozen = true
+    end
+
+    # Returns true if ether #freeze or #freeze! has been called on the model.
+    #
+    def frozen?
+      !!@frozen
+    end
+
   end
 
   def self.included(receiver)
@@ -53,3 +90,4 @@ module Perry::Persistence
   end
 
 end
+

data/lib/perry/processors/preload_associations.rb

@@ -0,0 +1,61 @@
+##
+# = Perry::Processors::PreloadAssociations
+#
+# This adapter processor will allow associations to be eager loaded after the original records are fetched.
+# Any associations specified in an :includes option will be loaded for all records in the query
+# (each association in a single request).
+#
+# == Configuration Options:
+#
+# None
+#
+# == Modifiers:
+#
+# None
+#
+#
+#
+class Perry::Processors::PreloadAssociations
+
+  def initialize(adapter, config={})
+    @adapter = adapter
+    @config = config
+  end
+
+  def call(options)
+    results = @adapter.call(options)
+
+    unless results.empty?
+      relation = options[:relation]
+      (includes = relation.to_hash[:includes] || {}).keys.each do |association_id|
+        association = relation.klass.defined_associations[association_id.to_sym]
+        raise Perry::AssociationNotFound, "unknown association #{association_id}" unless association
+        eager_records = association.scope(results).includes(includes[association_id]).all(:modifiers => options[:relation].modifiers_value)
+
+        results.each do |result|
+          scope = association.scope(result)
+          case association.type
+          when :has_one, :has_many
+            scope.records = eager_records.select do |record|
+              record.send(association.foreign_key) == result.send(association.primary_key)
+            end
+            if association.collection?
+              result.send("#{association.id}=", scope)
+            else
+              result.send("#{association.id}=", scope.records.first)
+            end
+          when :belongs_to
+            scope.records = eager_records.select do |record|
+              record.send(association.primary_key) == result.send(association.foreign_key)
+            end
+            result.send("#{association.id}=", scope.records.first)
+          end
+        end
+      end
+    end
+
+    results
+  end
+
+end
+

data/lib/perry/processors.rb

@@ -0,0 +1,5 @@
+module Perry::Processors
+
+  autoload :PreloadAssociations, 'perry/processors/preload_associations'
+
+end

data/lib/perry/relation/finder_methods.rb

@@ -3,10 +3,12 @@ module Perry::FinderMethods
   def find(ids_or_mode, options={})
     case ids_or_mode
     when Fixnum, String
-      self.where(:id => ids_or_mode.to_i).first(options) || raise(Perry::RecordNotFound, "Could not find #{@klass} with :id = #{ids_or_mode}")
+      self.where(primary_key => ids_or_mode).first(options) || raise(Perry::RecordNotFound, "Could not find #{@klass} with :#{primary_key} = #{ids_or_mode}")
     when Array
-      self.where(:id => ids_or_mode).all(options).tap do |result|
-        raise Perry::RecordNotFound, "Couldn't find all #{@klass} with ids (#{ids_or_mode.join(',')}) (expected #{ids_or_mode.size} records but got #{result.size})." unless result.size == ids_or_mode.size
+      self.where(primary_key => ids_or_mode).all(options).tap do |result|
+        unless result.size == ids_or_mode.size
+          raise Perry::RecordNotFound, "Couldn't find all #{@klass} with ids (#{ids_or_mode.join(',')}) (expected #{ids_or_mode.size} records but got #{result.size})."
+        end
       end
     when :all
       self.all(options)
@@ -37,7 +39,7 @@ module Perry::FinderMethods
     relation = clone
     return relation unless options
 
-    [:joins, :limit, :offset, :order, :select, :group, :having, :from, :fresh, :includes].each do |finder|
+    Perry::Relation::QUERY_METHODS.each do |finder|
       relation = relation.send(finder, options[finder]) if options[finder]
     end
 
@@ -50,6 +52,8 @@ module Perry::FinderMethods
 
     relation = relation.sql(options[:sql]) if options.has_key?(:sql)
 
+    relation = relation.modifiers(options[:modifiers]) if options.has_key?(:modifiers)
+
     relation
   end
 

data/lib/perry/relation/modifiers.rb

@@ -0,0 +1,37 @@
+module Perry::Modifiers
+  attr_accessor :modifiers_value, :modifiers_array
+
+  # The modifiers query method allows you to 'extend' your query by adding parameters that
+  # middlewares or adapters can use to modify the query itself or modify how the query is executed.
+  # This method expects a hash or a Proc that returns a hash as its only argument and will merge
+  # that hash onto a master hash of query modifiers.
+  #
+  # For most purposes, the modifiers method acts like any other query method. For example, you
+  # can chain it with other query methods on a relation, and you can build scopes with it.
+  # One exception is that modifiers are not included in the hash returned by Relation#to_hash.
+  # This exception is intended to discourage adapters from passing modifiers to backends external
+  # to perry (such as a data server or a webservice call) whose behavior is undefined with respect
+  # to these additional parameters/
+  #
+  # See also 'perry/middlewares/cache_records/scopes.rb' for examples of how to use the modifiers
+  # pseudo-query method.
+  def modifiers(value={})
+    clone.tap do |r|
+      if value.nil?
+        r.modifiers_array = [] # wipeout all previously set modifiers
+      else
+        r.modifiers_array ||= []
+        r.modifiers_array.push(value)
+      end
+    end
+  end
+
+  def modifiers_value
+    self.modifiers_array ||= []
+    {}.tap do |hash|
+      self.modifiers_array.each do |value|
+        hash.merge!(value.is_a?(Proc) ? value.call : value)
+      end
+    end
+  end
+end

data/lib/perry/relation/query_methods.rb

@@ -1,8 +1,7 @@
 module Perry::QueryMethods
   # TRP: Define each of the variables the query options will be stored in.
-  attr_accessor :select_values, :group_values, :order_values, :joins_values, :includes_values, :where_values, :having_values,
-                :limit_value, :offset_value, :from_value,
-                :raw_sql_value, :fresh_value
+  attr_accessor :select_values, :group_values, :order_values, :joins_values, :includes_value, :where_values, :having_values,
+                :limit_value, :offset_value, :from_value, :raw_sql_value
 
   def select(*args)
     if block_given?
@@ -26,7 +25,7 @@ module Perry::QueryMethods
 
   def includes(*args)
     args.reject! { |a| a.nil? }
-    clone.tap { |r| r.includes_values += (r.includes_values + args).flatten.uniq if args_valid? args }
+    clone.tap { |r| r.includes_value = (r.includes_value || {}).deep_merge(sanitize_includes(args)) if args_valid? args }
   end
 
   def where(*args)
@@ -49,13 +48,6 @@ module Perry::QueryMethods
     clone.tap { |r| r.from_value = table }
   end
 
-  def fresh(val=true)
-    clone.tap do |r|
-      r.fresh_value = val
-      r.reset_queries if r.fresh_value
-    end
-  end
-
   def sql(raw_sql)
     clone.tap { |r| r.raw_sql_value = raw_sql }
   end
@@ -66,4 +58,20 @@ module Perry::QueryMethods
     args.respond_to?(:empty?) ? !args.empty? : !!args
   end
 
+  # This will allow for the nested structure
+  def sanitize_includes(values)
+    case values
+    when Hash
+      values.keys.inject({}) do |hash, key|
+        hash.merge key => sanitize_includes(values[key])
+      end
+    when Array
+      values.inject({}) { |hash, val| hash.merge sanitize_includes(val) }
+    when String, Symbol
+      { values.to_sym => {} }
+    else
+      {}
+    end
+  end
+
 end

data/lib/perry/relation.rb

@@ -1,5 +1,6 @@
 require 'perry/relation/query_methods'
 require 'perry/relation/finder_methods'
+require 'perry/relation/modifiers'
 
 # TRP: The concepts behind this class are heavily influenced by ActiveRecord::Relation v.3.0.0RC1
 # => http://github.com/rails/rails
@@ -8,13 +9,15 @@ class Perry::Relation
   attr_reader :klass
   attr_accessor :records
 
-  SINGLE_VALUE_METHODS = [:limit, :offset, :from, :fresh]
-  MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :includes, :where, :having]
+  SINGLE_VALUE_METHODS = [:limit, :offset, :includes, :from]
+  MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having]
 
-  FINDER_OPTIONS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS + [:conditions, :search, :sql]
+  QUERY_METHODS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS
+  FINDER_OPTIONS = QUERY_METHODS + [:conditions, :search, :sql]
 
   include Perry::QueryMethods
   include Perry::FinderMethods
+  include Perry::Modifiers
 
   def initialize(klass)
     @klass = klass
@@ -36,6 +39,8 @@ class Perry::Relation
       merged_relation = merged_relation.send(option, *r.send("#{option}_values"))
     end
 
+    merged_relation.send(:modifiers_array=, r.send(:modifiers_array))
+
     merged_relation
   end
 
@@ -76,7 +81,7 @@ class Perry::Relation
   end
 
   def eager_load?
-    @includes_values && !@includes_values.empty?
+    @includes_value
   end
 
   def inspect

data/lib/perry/version.rb

@@ -2,7 +2,7 @@ module Perry
   module Version
 
     MAJOR = 0
-    MINOR = 4
+    MINOR = 5
     TINY  = 0
 
     def self.to_s # :nodoc:

data/lib/perry.rb

@@ -2,9 +2,11 @@
 require 'active_support/core_ext/array'
 require 'active_support/core_ext/class/inheritable_attributes'
 require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/keys'
 begin
   require 'active_support/core_ext/duplicable' #ActiveSupport 2.3.x
   Hash.send(:include, ActiveSupport::CoreExtensions::Hash::DeepMerge) unless Hash.instance_methods.include?('deep_merge')
+  Hash.send(:include, ActiveSupport::CoreExtensions::Hash::Keys) unless Hash.instance_methods.include?('symbolize_keys')
 rescue LoadError => exception
   require 'active_support/core_ext/object/duplicable' #ActiveSupport 3.0.x
 end
@@ -13,6 +15,9 @@ require 'active_support/core_ext/module/delegation'
 # TRP: Used for pretty logging
 autoload :Benchmark, 'benchmark'
 
+# If needed to parse raw adapter responses
+require 'json'
+
 require 'ostruct'
 
 # TRP: Perry core_ext

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: perry
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Travis Petticrew
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-14 00:00:00 -05:00
+date: 2011-05-13 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -112,6 +112,22 @@ dependencies:
         version: 1.3.0
   type: :runtime
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  type: :runtime
+  version_requirements: *id007
 description: 
 email: bobo@petticrew.net
 executables: []
@@ -128,19 +144,25 @@ files:
 - lib/perry/adapters/restful_http_adapter.rb
 - lib/perry/adapters.rb
 - lib/perry/association.rb
-- lib/perry/association_preload.rb
 - lib/perry/associations/common.rb
 - lib/perry/associations/contains.rb
 - lib/perry/associations/external.rb
 - lib/perry/base.rb
-- lib/perry/cacheable/entry.rb
-- lib/perry/cacheable/store.rb
-- lib/perry/cacheable.rb
 - lib/perry/core_ext/kernel/singleton_class.rb
 - lib/perry/errors.rb
 - lib/perry/logger.rb
+- lib/perry/middlewares/cache_records/entry.rb
+- lib/perry/middlewares/cache_records/scopes.rb
+- lib/perry/middlewares/cache_records/store.rb
+- lib/perry/middlewares/cache_records.rb
+- lib/perry/middlewares/model_bridge.rb
+- lib/perry/middlewares.rb
+- lib/perry/persistence/response.rb
 - lib/perry/persistence.rb
+- lib/perry/processors/preload_associations.rb
+- lib/perry/processors.rb
 - lib/perry/relation/finder_methods.rb
+- lib/perry/relation/modifiers.rb
 - lib/perry/relation/query_methods.rb
 - lib/perry/relation.rb
 - lib/perry/scopes/conditions.rb
@@ -179,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Ruby library for querying and mapping data through generic interfaces