perry 0.4.0

data/lib/perry/relation/finder_methods.rb

@@ -0,0 +1,56 @@
+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}")
+    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
+      end
+    when :all
+      self.all(options)
+    when :first
+      self.first(options)
+    else
+      raise ArgumentError, "Unknown arguments for method find"
+    end
+  end
+
+  def all(options={})
+    self.apply_finder_options(options).to_a
+  end
+
+  def first(options={})
+    self.apply_finder_options(options).limit(1).to_a.first
+  end
+
+  def search(options={})
+    relation = self
+    options.each do |search, *args|
+      relation = relation.send(search, *args) if @klass.send(:condition_details, search)
+    end
+    relation
+  end
+
+  def apply_finder_options(options)
+    relation = clone
+    return relation unless options
+
+    [:joins, :limit, :offset, :order, :select, :group, :having, :from, :fresh, :includes].each do |finder|
+      relation = relation.send(finder, options[finder]) if options[finder]
+    end
+
+    relation = relation.where(options[:conditions]) if options.has_key?(:conditions)
+    relation = relation.where(options[:where]) if options.has_key?(:where)
+
+    relation = relation.includes(options[:include]) if options.has_key?(:include)
+
+    relation = relation.search(options[:search]) if options.has_key?(:search)
+
+    relation = relation.sql(options[:sql]) if options.has_key?(:sql)
+
+    relation
+  end
+
+end

data/lib/perry/relation/query_methods.rb

@@ -0,0 +1,69 @@
+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
+
+  def select(*args)
+    if block_given?
+      to_a.select {|*block_args| yield(*block_args) }
+    else
+      clone.tap { |r| r.select_values += args if args_valid? args }
+    end
+  end
+
+  def group(*args)
+    clone.tap { |r| r.group_values += args if args_valid? args }
+  end
+
+  def order(*args)
+    clone.tap { |r| r.order_values += args if args_valid? args }
+  end
+
+  def joins(*args)
+    clone.tap { |r| r.joins_values += args if args_valid?(args) }
+  end
+
+  def includes(*args)
+    args.reject! { |a| a.nil? }
+    clone.tap { |r| r.includes_values += (r.includes_values + args).flatten.uniq if args_valid? args }
+  end
+
+  def where(*args)
+    clone.tap { |r| r.where_values += args.compact.select { |i| args_valid? i } if args_valid? args }
+  end
+
+  def having(*args)
+    clone.tap { |r| r.having_values += args if args_valid? args }
+  end
+
+  def limit(value = true)
+    clone.tap { |r| r.limit_value = value }
+  end
+
+  def offset(value = true)
+    clone.tap { |r| r.offset_value = value }
+  end
+
+  def from(table)
+    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
+
+  protected
+
+  def args_valid?(args)
+    args.respond_to?(:empty?) ? !args.empty? : !!args
+  end
+
+end

data/lib/perry/scopes.rb

@@ -0,0 +1,45 @@
+require 'perry/scopes/conditions'
+
+module Perry::Scopes
+  
+  module ClassMethods
+    
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+    
+    def scoped
+      current_scope ? relation.merge(current_scope) : relation.clone
+    end
+    
+    def scope(name, scope_options={})
+      name = name.to_sym
+      
+      # TRP: Define the scope and merge onto the relation
+      scopes[name] = lambda do |*args|
+        options = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
+        if options.is_a?(Hash)
+          scoped.apply_finder_options(options)
+        else
+          scoped.merge(options)
+        end
+      end
+      
+      # TRP: Bind the above block to a method for easy access
+      singleton_class.send(:define_method, name, &scopes[name])
+    end
+    
+  end
+  
+  module InstanceMethods
+    
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+    
+    receiver.extend Conditions
+  end
+  
+end

data/lib/perry/scopes/conditions.rb

@@ -0,0 +1,101 @@
+
+# TRP: Implementation of this feature was heavily influenced by binarylogic's Searchlogic-2.4.19
+# => http://github.com/binarylogic/searchlogic
+#
+#  It is designed to mimick much of the API of searchlogic so that it can be used alongside AR objects utilizing Searchlogic
+#  without developer confusion.  There are certain features that are skipped because of the nature of Perry.
+
+module Perry::Scopes
+
+  module Conditions
+
+    COMPARISON_CONDITIONS = {
+      :equals => [:is, :eq],
+      :does_not_equal => [:not_equal_to, :is_not, :not, :ne],
+      :less_than => [:lt, :before],
+      :less_than_or_equal_to => [:lte],
+      :greater_than => [:gt, :after],
+      :greater_than_or_equal_to => [:gte],
+    }
+
+    WILDCARD_CONDITIONS = {
+      :like => [:contains, :includes],
+      :not_like => [:does_not_include],
+      :begins_with => [:bw],
+      :not_begin_with => [:does_not_begin_with],
+      :ends_with => [:ew],
+      :not_end_with => [:does_not_end_with]
+    }
+
+    CONDITIONS = {}
+
+    # Add any / all variations to every comparison and wildcard condition
+    COMPARISON_CONDITIONS.merge(WILDCARD_CONDITIONS).each do |condition, aliases|
+      CONDITIONS[condition] = aliases
+      CONDITIONS["#{condition}_any".to_sym] = aliases.collect { |a| "#{a}_any".to_sym }
+      CONDITIONS["#{condition}_all".to_sym] = aliases.collect { |a| "#{a}_all".to_sym }
+    end
+
+    CONDITIONS[:equals_any] = CONDITIONS[:equals_any] + [:in]
+    CONDITIONS[:does_not_equal_all] = CONDITIONS[:does_not_equal_all] + [:not_in]
+
+    PRIMARY_CONDITIONS = CONDITIONS.keys
+    ALIAS_CONDITIONS = CONDITIONS.values.flatten
+
+    def respond_to?(name, include_private=false)
+      super ||
+      condition_details(name)
+    end
+
+    private
+
+    def method_missing(name, *args, &block)
+      if details = condition_details(name)
+        create_condition(details[:attribute], details[:condition], args)
+        send(name, *args)
+      else
+        super
+      end
+    end
+
+    def condition_details(method_name)
+      return nil unless defined_attributes
+
+      attribute_name_matcher = defined_attributes.join("|")
+      conditions_matcher = (PRIMARY_CONDITIONS + ALIAS_CONDITIONS).join("|")
+
+      if method_name.to_s =~ /^(#{attribute_name_matcher})_(#{conditions_matcher})$/
+        {:attribute => $1, :condition => $2}
+      end
+    end
+
+    def create_condition(attribute, condition, args)
+      if PRIMARY_CONDITIONS.include?(condition.to_sym)
+        create_primary_condition(attribute, condition)
+      elsif ALIAS_CONDITIONS.include?(condition.to_sym)
+        create_alias_condition(attribute, condition, args)
+      end
+    end
+
+    def create_primary_condition(attribute, condition)
+      scope_name = "#{attribute}_#{condition}"
+      scope scope_name, lambda { |a| where(scope_name => a) }
+    end
+
+    def create_alias_condition(attribute, condition, args)
+      primary_condition = primary_condition(condition)
+      alias_name = "#{attribute}_#{condition}"
+      primary_name = "#{attribute}_#{primary_condition}"
+      send(primary_name, *args) # go back to method_missing and make sure we create the method
+      singleton_class.class_eval { alias_method alias_name, primary_name }
+    end
+
+    # Returns the primary condition for the given alias. Ex:
+    #
+    #   primary_condition(:gt) => :greater_than
+    def primary_condition(alias_condition)
+      CONDITIONS.find { |k, v| k == alias_condition.to_sym || v.include?(alias_condition.to_sym) }.first
+    end
+  end
+
+end

data/lib/perry/serialization.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+module Perry::Serialization
+
+  module ClassMethods
+
+    def serialize(fields)
+      [*fields].each do |field|
+        serialized_attributes << field
+
+        define_method("deserialize_#{field}") do
+          YAML.load(self[field]) rescue self[field]
+        end
+
+        alias_method "#{field}_raw", field
+        alias_method field, "deserialize_#{field}"
+
+        set_serialize_writers(field) if self.write_adapter
+
+      end
+    end
+
+    def set_serialize_writers(field)
+      define_method("serialize_#{field}") do |value|
+        self[field] = value.to_yaml
+      end
+
+      alias_method "#{field}_raw=", "#{field}="
+      alias_method "#{field}=", "serialize_#{field}"
+    end
+
+  end
+
+  module InstanceMethods
+
+  end
+
+  def self.included(receiver)
+    receiver.class_eval do
+      class_inheritable_accessor :serialized_attributes
+      self.serialized_attributes = []
+    end
+
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+
+end

data/lib/perry/version.rb

@@ -0,0 +1,13 @@
+module Perry
+  module Version
+
+    MAJOR = 0
+    MINOR = 4
+    TINY  = 0
+
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY].join('.')
+    end
+
+  end
+end

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification 
+name: perry
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+- Travis Petticrew
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-14 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 39
+        segments: 
+        - 2
+        - 10
+        - 0
+        version: 2.10.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: leftright
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 0
+        - 6
+        version: 0.0.6
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: factory_girl
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: bertrpc
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :runtime
+  version_requirements: *id006
+description: 
+email: bobo@petticrew.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/perry/adapters/abstract_adapter.rb
+- lib/perry/adapters/bertrpc_adapter.rb
+- 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/persistence.rb
+- lib/perry/relation/finder_methods.rb
+- lib/perry/relation/query_methods.rb
+- lib/perry/relation.rb
+- lib/perry/scopes/conditions.rb
+- lib/perry/scopes.rb
+- lib/perry/serialization.rb
+- lib/perry/version.rb
+- lib/perry.rb
+has_rdoc: true
+homepage: http://github.com/tpett/perry
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Ruby library for querying and mapping data through generic interfaces
+test_files: []
+