perry 0.4.0

data/README.rdoc

@@ -0,0 +1,38 @@
+= Perry
+
+== Description
+
+Ruby library for querying and mapping data through generic interfaces
+
+== Installation
+
+    gem install perry
+
+== Usage
+
+    require 'perry'
+
+== License
+
+Copyright (c) 2011 Travis Petticrew
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/perry/version'
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'perry'
+  s.version          = Perry::Version.to_s
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "Ruby library for querying and mapping data through generic interfaces"
+  s.author           = 'Travis Petticrew'
+  s.email            = 'bobo@petticrew.net'
+  s.homepage         = 'http://github.com/tpett/perry'
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib}/**/*")
+  # s.executables    = ['perry']
+
+  s.add_development_dependency("shoulda", [">= 2.10.0"])
+  s.add_development_dependency("leftright", [">= 0.0.6"])
+  s.add_development_dependency("fakeweb", [">= 1.3.0"])
+  s.add_development_dependency("factory_girl", [">= 0"])
+
+  s.add_dependency("activesupport", [">= 2.3.0"])
+  s.add_dependency("bertrpc", [">= 1.3.0"])
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+[:rails2, :rails3].each do |name|
+
+  Rake::TestTask.new("test_#{name}") do |t|
+    t.libs << 'test'
+    t.ruby_opts << "-r load_#{name}"
+    t.test_files = FileList["test/**/*_test.rb"]
+    t.verbose = true
+  end
+
+end
+
+desc "Test all gem versions"
+task :test => [:test_rails2, :test_rails3] do
+end
+
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new(:coverage) do |t|
+    t.libs       = ['test']
+    t.test_files = FileList["test/**/*_test.rb"]
+    t.verbose    = true
+    t.rcov_opts  = ['--text-report', "-x #{Gem.path}", '-x /Library/Ruby', '-x /usr/lib/ruby']
+  end
+
+  task :default => :coverage
+
+rescue LoadError
+  warn "\n**** Install rcov (sudo gem install relevance-rcov) to get coverage stats ****\n"
+  task :default => :test
+end
+
+desc 'Generate the gemspec to serve this gem'
+task :gemspec do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/lib/perry.rb

@@ -0,0 +1,48 @@
+# TRP: Cherry pick some goodies from active_support
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/hash/deep_merge'
+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')
+rescue LoadError => exception
+  require 'active_support/core_ext/object/duplicable' #ActiveSupport 3.0.x
+end
+require 'active_support/core_ext/module/delegation'
+
+# TRP: Used for pretty logging
+autoload :Benchmark, 'benchmark'
+
+require 'ostruct'
+
+# TRP: Perry core_ext
+require 'perry/core_ext/kernel/singleton_class'
+
+module Perry
+  @@log_file = nil
+
+  def self.logger
+    @@logger ||= default_logger
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  def self.log_file=(file)
+    @@log_file = file
+  end
+
+  def self.default_logger
+    if defined?(Rails)
+      Rails.logger
+    else
+      require 'logger' unless defined?(::Logger)
+      ::Logger.new(@@log_file)
+    end
+  end
+
+end
+
+require 'perry/base'
+

data/lib/perry/adapters.rb

@@ -0,0 +1,5 @@
+module Perry::Adapters; end
+
+require 'perry/adapters/abstract_adapter'
+require 'perry/adapters/bertrpc_adapter'
+require 'perry/adapters/restful_http_adapter'

data/lib/perry/adapters/abstract_adapter.rb

@@ -0,0 +1,92 @@
+require 'perry/logger'
+
+module Perry::Adapters
+  class AbstractAdapter
+    include Perry::Logger
+
+    attr_accessor :config
+    attr_reader :type
+    @@registered_adapters ||= {}
+
+    def initialize(type, config)
+      @type = type.to_sym
+      @configuration_contexts = config.is_a?(Array) ? config : [config]
+    end
+
+    def self.create(type, config)
+      klass = @@registered_adapters[type.to_sym]
+      klass.new(type, config)
+    end
+
+    def extend_adapter(config)
+      config = config.is_a?(Array) ? config : [config]
+      self.class.create(self.type, @configuration_contexts + config)
+    end
+
+    def config
+      @config ||= build_configuration
+    end
+
+    def call(mode, options)
+      @stack ||= self.middlewares.reverse.inject(self.method(mode)) do |below, (above_klass, above_config)|
+        above_klass.new(below, above_config)
+      end
+
+      @stack.call(options)
+    end
+
+    def middlewares
+      self.config[:middlewares] || []
+    end
+
+    def read(options)
+      raise(NotImplementedError,
+            "You must not use the abstract adapter.  Implement an adapter that extends the " +
+            "Perry::Adapters::AbstractAdapter class and overrides this method.")
+    end
+
+    def write(object)
+      raise(NotImplementedError,
+            "You must not use the abstract adapter.  Implement an adapter that extends the " +
+            "Perry::Adapters::AbstractAdapter class and overrides this method.")
+    end
+
+    def delete(object)
+      raise(NotImplementedError,
+            "You must not use the abstract adapter.  Implement an adapter that extends the " +
+            "Perry::Adapters::AbstractAdapter class and overrides this method.")
+    end
+
+    def self.register_as(name)
+      @@registered_adapters[name.to_sym] = self
+    end
+
+    private
+
+    # TRP: Run each configure block in order of class hierarchy / definition and merge the results.
+    def build_configuration
+      @configuration_contexts.inject({}) do |sum, config|
+        if config.is_a?(Hash)
+          sum.merge(config)
+        else
+          AdapterConfig.new(sum).tap { |ac| config.call(ac) }.marshal_dump
+        end
+      end
+    end
+
+    class AdapterConfig < OpenStruct
+
+      def add_middleware(klass, config={})
+        self.middlewares ||= []
+        self.middlewares << [klass, config]
+      end
+
+      def to_hash
+        marshal_dump
+      end
+
+    end
+
+  end
+end
+

data/lib/perry/adapters/bertrpc_adapter.rb

@@ -0,0 +1,32 @@
+autoload :BERTRPC, 'bertrpc'
+
+module Perry::Adapters
+  class BERTRPCAdapter < Perry::Adapters::AbstractAdapter
+    register_as :bertrpc
+
+    @@service_pool ||= {}
+
+    def service
+      @@service_pool["#{config[:host]}:#{config[:port]}"] ||=
+          BERTRPC::Service.new(self.config[:host], self.config[:port])
+    end
+
+    def read(options)
+      log(options, "RPC #{config[:service]}") {
+        self.service.call.send(self.namespace).send(self.service_name,
+                                                    options.merge(config[:default_options] || {}))
+      }
+    end
+
+    protected
+
+    def namespace
+      self.config[:namespace]
+    end
+
+    def service_name
+      self.config[:service]
+    end
+
+  end
+end

data/lib/perry/adapters/restful_http_adapter.rb

@@ -0,0 +1,99 @@
+autoload :Net, 'net/http'
+autoload :URI, 'uri'
+
+module Perry::Adapters
+  class RestfulHTTPAdapter < Perry::Adapters::AbstractAdapter
+    register_as :restful_http
+
+    attr_reader :last_response
+
+    def initialize(*args)
+      super
+      @configuration_contexts << { :primary_key => :id }
+    end
+
+    def write(object)
+      params = build_params_from_attributes(object)
+      object.new_record? ? post_http(object, params) : put_http(object, params)
+    end
+
+    def delete(object)
+      delete_http(object)
+    end
+
+    protected
+
+    def post_http(object, params)
+      http_call(object, :post, params)
+    end
+
+    def put_http(object, params)
+      http_call(object, :put, params)
+    end
+
+    def delete_http(object)
+      http_call(object, :delete, self.config[:default_options])
+    end
+
+    def http_call(object, method, params={})
+      request_klass = case method
+      when :post    then Net::HTTP::Post
+      when :put     then Net::HTTP::Put
+      when :delete  then Net::HTTP::Delete
+      end
+
+      req_uri = self.build_uri(object, method)
+
+      request = if method == :delete
+        request = request_klass.new([req_uri.path, req_uri.query].join('?'))
+      else
+        request = request_klass.new(req_uri.path)
+        request.set_form_data(params) unless method == :delete
+        request
+      end
+
+      self.log(params, "#{method.to_s.upcase} #{req_uri}") do
+        @last_response = Net::HTTP.new(req_uri.host, req_uri.port).start { |http| http.request(request) }
+      end
+      parse_response_code(@last_response)
+    end
+
+    def parse_response_code(response)
+      case response
+      when Net::HTTPSuccess, Net::HTTPRedirection
+        true
+      else
+        false
+      end
+    end
+
+    def build_params_from_attributes(object)
+      if self.config[:post_body_wrapper]
+        params = self.config[:default_options] || {}
+        params.merge!(object.write_options[:default_options]) if object.write_options.is_a?(Hash) && object.write_options[:default_options].is_a?(Hash)
+
+        object.attributes.each do |attribute, value|
+          params.merge!({"#{self.config[:post_body_wrapper]}[#{attribute}]" => value})
+        end
+
+        params
+      else
+        object.attributes
+      end
+    end
+
+    def build_uri(object, method)
+      url = [self.config[:host].gsub(%r{/$}, ''), self.config[:service]]
+      url << object.send(self.config[:primary_key]) unless object.new_record?
+      uri = URI.parse "#{url.join('/')}#{self.config[:format]}"
+
+      # TRP: method DELETE has no POST body so we have to append any default options onto the query string
+      if method == :delete
+        uri.query = (self.config[:default_options] || {}).collect { |key, value| "#{key}=#{value}" }.join('&')
+      end
+
+      uri
+    end
+
+  end
+end

data/lib/perry/association.rb

@@ -0,0 +1,330 @@
+module Perry::Association; end
+
+module Perry::Association
+
+  ##
+  # Association::Base
+  #
+  # This is the base class for all associations.  It defines the basic structure
+  # of an association.  The basic nomenclature is as follows:
+  #
+  # TODO: Clean up this nomenclature.  Source and Target should be switched.  From
+  # the configuration side this is already done but the internal naming is backwards.
+  #
+  # Source:  The start point of the association.  The source class is the class
+  # on which the association is defined.
+  #
+  # Proxy:  On a through association the proxy is the class on which the target
+  # association lives
+  #
+  # Target:  The class that will ultimately be returned by the association
+  #
+  class Base
+    attr_accessor :source_klass, :id, :options
+
+    def initialize(klass, id, options={})
+      self.source_klass = klass
+      self.id = id.to_sym
+      self.options = options
+    end
+
+    def type
+      raise NotImplementedError, "You must define the type in subclasses."
+    end
+
+    def polymorphic?
+      raise(
+        NotImplementedError,
+        "You must define how your association is polymorphic in subclasses."
+      )
+    end
+
+    def collection?
+      raise NotImplementedError, "You must define collection? in subclasses."
+    end
+
+    def primary_key
+      options[:primary_key] || :id
+    end
+
+    def foreign_key
+      options[:foreign_key]
+    end
+
+    def target_klass(object=nil)
+      if options[:polymorphic] && object
+        poly_type = object.is_a?(Perry::Base) ? object.send("#{id}_type") : object
+      end
+
+      klass = if poly_type
+        type_string = [
+          options[:polymorphic_namespace],
+          sanitize_type_attribute(poly_type)
+        ].compact.join('::')
+        begin
+          eval(type_string)
+        rescue NameError => err
+          raise(
+            Perry::PolymorphicAssociationTypeError,
+            "No constant defined called #{type_string}"
+          )
+        end
+      else
+        unless options[:class_name]
+          raise(ArgumentError,
+                ":class_name option required for association declaration.")
+        end
+
+        unless options[:class_name] =~ /^::/
+          options[:class_name] = "::#{options[:class_name]}"
+        end
+
+        eval(options[:class_name])
+      end
+
+      Perry::Base.resolve_leaf_klass klass
+    end
+
+    def scope(object)
+      raise NotImplementedError, "You must define scope in subclasses"
+    end
+
+    # TRP: Only eager loadable if association query does not depend on instance
+    # data
+    def eager_loadable?
+      Perry::Relation::FINDER_OPTIONS.inject(true) do |condition, key|
+        condition && !options[key].respond_to?(:call)
+      end
+    end
+
+    protected
+
+    def base_scope(object)
+      target_klass(object).scoped.apply_finder_options base_finder_options(object)
+    end
+
+    def base_finder_options(object)
+      Perry::Relation::FINDER_OPTIONS.inject({}) do |sum, key|
+        value = self.options[key]
+        sum.merge!(key => value.respond_to?(:call) ? value.call(object) : value) if value
+        sum
+      end
+    end
+
+    # TRP: Make sure the value looks like a variable syntaxtually
+    def sanitize_type_attribute(string)
+      string.gsub(/[^a-zA-Z]\w*/, '')
+    end
+
+  end
+
+
+  class BelongsTo < Base
+
+    def type
+      :belongs_to
+    end
+
+    def collection?
+      false
+    end
+
+    def foreign_key
+      super || "#{id}_id".to_sym
+    end
+
+    def polymorphic?
+      !!options[:polymorphic]
+    end
+
+    def polymorphic_type
+      "#{id}_type".to_sym
+    end
+
+    ##
+    # Returns a scope on the target containing this association
+    #
+    # Builds conditions on top of the base_scope generated from any finder
+    # options set with the association
+    #
+    # belongs_to :foo, :foreign_key => :foo_id
+    #
+    # In addition to any finder options included with the association options
+    # the following scope will be added:
+    #  where(:id => source[:foo_id])
+    #
+    def scope(object)
+      if object[self.foreign_key]
+        base_scope(object).where(self.primary_key => object[self.foreign_key])
+      end
+    end
+
+  end
+
+
+  class Has < Base
+
+    def foreign_key
+      super || if self.polymorphic?
+        "#{options[:as]}_id"
+      else
+         "#{Perry::Base.base_class_name(source_klass).downcase}_id"
+      end.to_sym
+    end
+
+
+    ##
+    # Returns a scope on the target containing this association
+    #
+    # Builds conditions on top of the base_scope generated from any finder
+    # options set with the association
+    #
+    #   has_many :widgets, :class_name => "Widget", :foreign_key => :widget_id
+    #   has_many :comments, :as => :parent
+    #
+    # In addition to any finder options included with the association options
+    # the following will be added:
+    #
+    #   where(widget_id => source[:id])
+    #
+    # Or for the polymorphic :comments association:
+    #
+    #   where(:parent_id => source[:id], :parent_type => source.class)
+    #
+    def scope(object)
+      return nil unless object[self.primary_key]
+      s = base_scope(object).where(self.foreign_key => object[self.primary_key])
+      if polymorphic?
+        s = s.where(
+          polymorphic_type => Perry::Base.base_class_name(object.class) )
+      end
+      s
+    end
+
+    def polymorphic_type
+      :"#{options[:as]}_type"
+    end
+
+    def polymorphic?
+      !!options[:as]
+    end
+
+  end
+
+
+  class HasMany < Has
+
+    def collection?
+      true
+    end
+
+    def type
+      :has_many
+    end
+
+  end
+
+
+  class HasOne < Has
+
+    def collection?
+      false
+    end
+
+    def type
+      :has_one
+    end
+
+  end
+
+
+  class HasManyThrough < HasMany
+    attr_accessor :proxy_association
+    attr_accessor :target_association
+
+    def proxy_association
+      @proxy_association ||= source_klass.defined_associations[options[:through]] ||
+        raise(
+          Perry::AssociationNotFound,
+          ":has_many_through: '#{options[:through]}' is not an association " +
+          "on #{source_klass}"
+        )
+    end
+
+    def target_association
+      return @target_association if @target_association
+
+      klass = proxy_association.target_klass
+      @target_association = klass.defined_associations[self.id] ||
+        klass.defined_associations[self.options[:source]] ||
+        raise(Perry::AssociationNotFound,
+          ":has_many_through: '#{options[:source] || self.id}' is not an " +
+          "association on #{klass}"
+        )
+    end
+
+    def scope(object)
+      # Which attribute's values should be used on the proxy
+      key = if target_is_has?
+        target_association.primary_key.to_sym
+      else
+        target_association.foreign_key.to_sym
+      end
+
+      # Fetch the ids of all records on the proxy using the correct key
+      proxy_ids = proc do
+        proxy_association.scope(object).select(key).collect(&key)
+      end
+
+      # Use these ids to build a scope on the target object
+      relation = target_klass.scoped
+
+      if target_is_has?
+        relation = relation.where(
+          proc do
+            { target_association.foreign_key => proxy_ids.call }
+          end
+        )
+      else
+        relation = relation.where(
+          proc do
+            { target_association.primary_key => proxy_ids.call }
+          end
+        )
+      end
+
+      # Add polymorphic type condition if target is polymorphic and has
+      if target_association.polymorphic? && target_is_has?
+        relation = relation.where(
+          target_association.polymorphic_type =>
+            Perry::Base.base_class_name(proxy_association.target_klass(object))
+        )
+      end
+
+      relation
+    end
+
+    def target_klass
+      target_association.target_klass(options[:source_type])
+    end
+
+    def target_type
+      target_association.type
+    end
+
+    def target_is_has?
+      target_association.is_a?(Has)
+    end
+
+    def type
+      :has_many_through
+    end
+
+    def polymorphic?
+      false
+    end
+
+  end
+
+
+end