perry 0.4.0

data/lib/perry/cacheable.rb

@@ -0,0 +1,80 @@
+require 'perry/cacheable/store'
+require 'perry/cacheable/entry'
+require 'digest/md5'
+
+module Perry::Cacheable
+
+  module ClassMethods
+
+    # TRP: Default to a 5 minute cache
+    DEFAULT_LONGEVITY = 5*60
+    @@cache_store = nil
+
+    def reset_cache_store(default_longevity=DEFAULT_LONGEVITY)
+      @@cache_store = Perry::Cacheable::Store.new(default_longevity)
+    end
+
+    def cache_store
+      @@cache_store
+    end
+
+    protected
+
+    def fetch_records_with_caching(relation)
+      options = relation.to_hash
+      key = Digest::MD5.hexdigest(self.to_s + options.to_a.sort { |a,b| a.to_s.first <=> b.to_s.first }.inspect)
+      cache_hit = self.cache_store.read(key)
+      get_fresh = options.delete(:fresh)
+
+      if cache_hit && !get_fresh
+        self.read_adapter.log(options, "CACHE #{self.name}")
+        cache_hit.each { |fv| fv.fresh = false.freeze }
+        cache_hit
+      else
+        fresh_value = fetch_records_without_caching(relation)
+
+        # TRP: Only store in cache if record count is below the cache_record_count_threshold (if it is set)
+        if !self.cache_record_count_threshold || fresh_value.size <= self.cache_record_count_threshold
+          self.cache_store.write(key, fresh_value, (self.cache_expires) ? fresh_value[0].send(self.cache_expires) : Time.now + DEFAULT_LONGEVITY) unless fresh_value.empty?
+          fresh_value.each { |fv| fv.fresh = true.freeze }
+        end
+
+        fresh_value
+      end
+    end
+
+    def enable_caching(options)
+      reset_cache_store unless cache_store
+      self.cacheable = true
+      self.cache_expires = options[:expires]
+      self.cache_record_count_threshold = options[:record_count_threshold]
+    end
+
+  end
+
+  module InstanceMethods
+
+    def fresh?
+      @fresh
+    end
+
+  end
+
+  def self.included(receiver)
+    receiver.class_inheritable_accessor :cache_expires, :cache_record_count_threshold
+    receiver.send :attr_accessor, :fresh
+
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+
+    # TRP: Remap calls for RPC through the caching mechanism
+    receiver.class_eval do
+      class << self
+        alias_method :fetch_records_without_caching, :fetch_records
+        alias_method :fetch_records, :fetch_records_with_caching
+      end
+    end
+
+  end
+
+end

data/lib/perry/cacheable/entry.rb

@@ -0,0 +1,18 @@
+module Perry::Cacheable
+  
+  class Entry
+    
+    attr_accessor :value, :expire_at
+    
+    def initialize(value, expire_at)
+      self.value = value
+      self.expire_at = expire_at
+    end
+    
+    def expired?
+      Time.now > self.expire_at rescue true
+    end
+    
+  end
+  
+end

data/lib/perry/cacheable/store.rb

@@ -0,0 +1,45 @@
+module Perry::Cacheable
+
+  class Store
+
+    attr_reader :store
+    attr_accessor :default_longevity
+
+    # TRP: Specify the default longevity of a cache entry in seconds
+    def initialize(default_longevity)
+      @store = {}
+      @default_longevity = default_longevity
+    end
+
+    def clear(key=nil)
+      if key
+        @store.delete(key)
+      else
+        @store.each do |key, entry|
+          clear(key) if key && (!entry || entry.expired?)
+        end
+      end
+    end
+
+    # TRP: Returns value if a cache hit and the entry is not expired, nil otherwise
+    def read(key)
+      if entry = @store[key]
+        if entry.expired?
+          clear(key)
+          nil
+        else
+          entry.value
+        end
+      end
+    end
+
+    # TRP: Write a new cache value and optionally specify the expire time
+    #      this also will clear all expired items out of the store to keep memory consumption as low as possible
+    def write(key, value, expires=Time.now + default_longevity)
+      clear
+      @store[key] = Entry.new(value, expires)
+    end
+
+  end
+
+end

data/lib/perry/core_ext/kernel/singleton_class.rb

@@ -0,0 +1,14 @@
+# TRP: Copied from Rails 3RC1 on 8/17/2010 (not available in Rails2)
+module Kernel
+  # Returns the object's singleton class.
+  def singleton_class
+    class << self
+      self
+    end
+  end unless respond_to?(:singleton_class) # exists in 1.9.2
+
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end

data/lib/perry/errors.rb

@@ -0,0 +1,49 @@
+module Perry
+
+  # Generic Perry error
+  #
+  class PerryError < StandardError
+  end
+
+  # Raised when Perry cannot find records from a given id or set of ids
+  #
+  class RecordNotFound < PerryError
+  end
+
+  # Raised when Perry cannot save a record through the write_adapter
+  # and save! or update_attributes! was used
+  #
+  class RecordNotSaved < PerryError
+  end
+
+  # Used for all association related errors
+  #
+  class AssociationError < PerryError
+  end
+
+  # Raised when trying to eager load an association that relies on instance
+  # level data.
+  # class Article < Perry::Base
+  #   has_many :comments, :conditions => lambda { |article| ... }
+  # end
+  #
+  # Article.recent.includes(:comments) # Raises AssociationPreloadNotSupported
+  #
+  class AssociationPreloadNotSupported < AssociationError
+  end
+
+  # Raised when trying to eager load an association that does not exist or
+  # trying to create a :has_many_through association with a nonexistant
+  # association as the source
+  #
+  class AssociationNotFound < AssociationError
+  end
+
+  # Raised when a polymorphic association type is not present in the specified
+  # scope.  Always be sure that any values set for the type attribute on any
+  # polymorphic association are real constants defined in :polymorphic_namespace
+  #
+  class PolymorphicAssociationTypeError < AssociationError
+  end
+
+end

data/lib/perry/logger.rb

@@ -0,0 +1,54 @@
+module Perry
+
+  module Logger
+    module ClassMethods
+
+      def log(params, name)
+        if block_given?
+          result = nil
+          ms = Benchmark.measure { result = yield }.real
+          log_info(params, name, ms*1000)
+          result
+        else
+          log_info(params, name, 0)
+          []
+        end
+      rescue Exception => err
+        log_info(params, name, 0)
+        Perry.logger.error("#{err.message} \n\n#{err.backtrace.join('\n')}")
+        []
+      end
+
+      private
+
+      def log_info(params, name, ms)
+        if Perry.logger && Perry.logger.debug?
+          name = '%s (%.1fms)' % [name || 'RPC', ms]
+          Perry.logger.debug(format_log_entry(name, params.inspect))
+        end
+      end
+
+      def format_log_entry(message, dump=nil)
+        message_color, dump_color = "4;33;1", "0;1"
+
+        log_entry = "  \e[#{message_color}m#{message}\e[0m   "
+        log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump
+        log_entry
+      end
+
+    end
+
+    module InstanceMethods
+
+      def log(*args, &block)
+        self.class.send(:log, *args, &block)
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/perry/persistence.rb

@@ -0,0 +1,55 @@
+module Perry::Persistence
+
+  module ClassMethods
+
+    protected
+
+    def create_writer(attribute)
+      define_method("#{attribute}=") do |value|
+        self[attribute] = value
+      end
+    end
+
+  end
+
+
+  module InstanceMethods
+
+    def []=(attribute, value)
+      set_attribute(attribute, value)
+    end
+
+    def attributes=(attributes)
+      set_attributes(attributes)
+    end
+
+    def save
+      write_adapter.write(self)
+    end
+
+    def save!
+      save or raise Perry::RecordNotSaved
+    end
+
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    def update_attributes!(attributes)
+      update_attributes(attributes) or raise Perry::RecordNotSaved
+    end
+
+    def destroy
+      write_adapter.delete(self) unless self.new_record?
+    end
+    alias :delete :destroy
+
+  end
+
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+
+end

data/lib/perry/relation.rb

@@ -0,0 +1,153 @@
+require 'perry/relation/query_methods'
+require 'perry/relation/finder_methods'
+
+# TRP: The concepts behind this class are heavily influenced by ActiveRecord::Relation v.3.0.0RC1
+# => http://github.com/rails/rails
+# Used to achieve the chainability of scopes -- methods are delegated back and forth from BM::Base and BM::Relation
+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]
+
+  FINDER_OPTIONS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS + [:conditions, :search, :sql]
+
+  include Perry::QueryMethods
+  include Perry::FinderMethods
+
+  def initialize(klass)
+    @klass = klass
+
+    SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
+    MULTI_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_values", [])}
+  end
+
+  def merge(r)
+    merged_relation = clone
+    return merged_relation unless r
+
+    SINGLE_VALUE_METHODS.each do |option|
+      new_value = r.send("#{option}_value")
+      merged_relation = merged_relation.send(option, new_value) if new_value
+    end
+
+    MULTI_VALUE_METHODS.each do |option|
+      merged_relation = merged_relation.send(option, *r.send("#{option}_values"))
+    end
+
+    merged_relation
+  end
+
+  def to_hash
+    # TRP: If present pass :sql option alone as it trumps all other options
+    @hash ||= if self.raw_sql_value
+      { :sql => raw_sql_value }
+    else
+      hash = SINGLE_VALUE_METHODS.inject({}) do |h, option|
+        value = self.send("#{option}_value")
+        value = call_procs(value)
+        value ? h.merge(option => value) : h
+      end
+
+      hash.merge!((MULTI_VALUE_METHODS - [:select]).inject({}) do |h, option|
+        value = self.send("#{option}_values")
+        value = call_procs(value)
+        value && !value.empty? ? h.merge(option => value.uniq) : h
+      end)
+
+      # TRP: If one of the select options contains a * than select options are ignored
+      if select_values && !select_values.empty? && !select_values.any? { |val| val.to_s.match(/\*$/) }
+        value = call_procs(select_values)
+        hash.merge!(:select => value.uniq)
+      end
+
+      hash
+    end
+  end
+
+  def reset_queries
+    @hash = nil
+    @records = nil
+  end
+
+  def to_a
+    @records ||= fetch_records
+  end
+
+  def eager_load?
+    @includes_values && !@includes_values.empty?
+  end
+
+  def inspect
+   to_a.inspect
+  end
+
+  def scoping
+    @klass.scoped_methods << self
+    begin
+      yield
+    ensure
+      @klass.scoped_methods.pop
+    end
+  end
+
+  def respond_to?(method, include_private=false)
+    super ||
+    Array.method_defined?(method) ||
+    @klass.scopes[method] ||
+    dynamic_finder_method(method) ||
+    @klass.respond_to?(method, false)
+  end
+
+  def dynamic_finder_method(method)
+    defined_attributes = (@klass.defined_attributes || []).join('|')
+    if method.to_s =~ /^(find_by|find_all_by)_(#{defined_attributes})/
+      [$1, $2]
+    else
+      nil
+    end
+  end
+
+  protected
+
+  def method_missing(method, *args, &block)
+    if Array.method_defined?(method)
+      to_a.send(method, *args, &block)
+    elsif result = dynamic_finder_method(method)
+      method, attribute = result
+      options = { :conditions => { attribute => args[0] } }
+      options.merge!(args[1]) if args[1] && args[1].is_a?(Hash)
+      case method.to_sym
+      when :find_by
+        self.first(options)
+      when :find_all_by
+        self.all(options)
+      end
+    elsif @klass.scopes[method]
+      merge(@klass.send(method, *args, &block))
+    elsif @klass.respond_to?(method, false)
+      scoping { @klass.send(method, *args, &block) }
+    else
+      super
+    end
+  end
+
+  def fetch_records
+    @klass.send(:fetch_records, self)
+  end
+
+  private
+
+  def call_procs(values)
+    case values
+    when Array:
+      values.collect { |v| v.is_a?(Proc) ? v.call : v }
+    when Proc:
+      values.call
+    else
+      values
+    end
+  end
+
+end