rpc-mapper 0.0.1

data/lib/rpc_mapper/cacheable.rb

@@ -0,0 +1,68 @@
+require 'rpc_mapper/cacheable/store'
+require 'rpc_mapper/cacheable/entry'
+require 'digest/md5'
+
+module RPCMapper::Cacheable
+
+  module ClassMethods
+
+    # TRP: Default to a 5 minute cache
+    DEFAULT_LONGEVITY = 5*60
+
+    protected
+
+    def fetch_records_with_caching(options={})
+      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.cacheable.read(key)
+
+      if cache_hit
+        self.adapter.log(options, "CACHE #{self.service_namespace}__#{self.service}")
+        cache_hit.each { |fv| fv.fresh = false.freeze }
+        cache_hit
+      else
+        fresh_value = fetch_records_without_caching(options)
+
+        # 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.cacheable.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)
+      self.cacheable = RPCMapper::Cacheable::Store.new(DEFAULT_LONGEVITY)
+      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/rpc_mapper/config_options.rb

@@ -0,0 +1,41 @@
+module RPCMapper
+
+  module ConfigOptions
+    module ClassMethods
+
+      def config_options(options={})
+        options.each do |option, default_value|
+          class_eval do
+            self.configure_options << option
+            class_inheritable_accessor option
+            self.send "#{option}=", default_value
+          end
+          # TRP: We run a direct string eval on the class because we cannot get a closure on the class << self scope
+          #      We need that in order to use our option variable to define a class method of the same name.
+          self.class_eval <<-EOS
+            def self.#{option}                                                              # def self.my_awesome_option
+              val = read_inheritable_attribute(:#{option})                                  #   val = read_inheritable_attribute(:my_awesome_option)
+              val.is_a?(Proc) ? write_inheritable_attribute(:#{option}, val.call) : val     #   val.is_a?(Proc) ? write_inheritable_attribute(:my_awesome_option, val.call) : val
+            end                                                                             # end
+          EOS
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+    end
+
+    def self.included(receiver)
+      receiver.class_eval do
+        class_inheritable_accessor :configure_options
+        self.configure_options = []
+      end
+
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/rpc_mapper/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/rpc_mapper/logger.rb

@@ -0,0 +1,54 @@
+module RPCMapper
+
+  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)
+        RPCMapper.logger.error("#{err.message} \n\n#{err.backtrace.join('\n')}")
+        []
+      end
+
+      private
+
+      def log_info(params, name, ms)
+        if RPCMapper.logger && RPCMapper.logger.debug?
+          name = '%s (%.1fms)' % [name || 'RPC', ms]
+          RPCMapper.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/rpc_mapper/mutable.rb

@@ -0,0 +1,138 @@
+require 'net/http'
+require 'uri'
+
+module RPCMapper
+
+  module Mutable
+
+    module ClassMethods
+
+      protected
+
+      def save_mutable_configuration(options={})
+        self.mutable_service = options[:service] || self.service
+        self.mutable_post_body_wrapper = options[:post_body_wrapper]
+      end
+
+      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
+        new_record? ? post_http(build_params_from_attributes) : put_http(build_params_from_attributes)
+      end
+
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      end
+
+      def destroy
+        delete_http
+      end
+      alias :delete :destroy
+
+
+      protected
+
+
+      def post_http(params)
+        http_call(:post, params)
+      end
+
+      def put_http(params)
+        http_call(:put, params)
+      end
+
+      def delete_http
+        http_call(:delete, self.mutable_default_parameters)
+      end
+
+      def http_call(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_url = self.build_url(method)
+
+        request = if method == :delete
+          request = request_klass.new([req_url.path, req_url.query].join('?'))
+        else
+          request = request_klass.new(req_url.path)
+          request.set_form_data(params) unless method == :delete
+          request
+        end
+
+        self.class.send(:adapter).log(params, "#{method.to_s.upcase} #{req_url}") do
+          @response = Net::HTTP.new(req_url.host, req_url.port).start { |http| http.request(request) }
+        end
+        parse_response_code(@response)
+      end
+
+      def parse_response_code(response)
+        case response
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          true
+        else
+          false
+        end
+      end
+
+      def build_params_from_attributes
+        if self.mutable_post_body_wrapper
+          params = self.mutable_default_parameters
+          @attributes.each do |attribute, value|
+            params.merge!({"#{self.mutable_post_body_wrapper}[#{attribute}]" => value})
+          end
+          # TRP: Append ivar mutable_params to params if set
+          params.merge!(self.mutable_params) if self.mutable_params.is_a?(Hash)
+
+          params
+        else
+          @attributes
+        end
+      end
+
+      def build_url(method)
+        url = [self.mutable_host.gsub(%r{/$}, ''), self.mutable_service]
+        url << self.id unless self.new_record?
+        uri = URI.parse "#{url.join('/')}.json"
+
+        if method == :delete
+          uri.query = self.mutable_default_parameters.collect { |key, value| "#{key}=#{value}" }.join('&')
+        end
+
+        uri
+      end
+
+    end
+
+    def self.included(receiver)
+      receiver.class_inheritable_accessor :mutable_service, :mutable_post_body_wrapper
+      receiver.send :attr_accessor, :mutable_params
+      receiver.send(:attr_accessor, :response)
+
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+
+  end
+
+end

data/lib/rpc_mapper/relation/finder_methods.rb

@@ -0,0 +1,52 @@
+module RPCMapper::FinderMethods
+
+  def find(ids_or_mode, options={})
+    case ids_or_mode
+    when Fixnum, String
+      self.where(:id => ids_or_mode.to_i).first(options)
+    when Array
+      self.where(:id => ids_or_mode).all(options)
+    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).fetch_records
+  end
+
+  def first(options={})
+    self.apply_finder_options(options).limit(1).fetch_records.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].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.search(options[:search]) if options.has_key?(:search)
+
+    relation = relation.sql(options[:sql]) if options.has_key?(:sql)
+
+    relation
+  end
+
+end

data/lib/rpc_mapper/relation/query_methods.rb

@@ -0,0 +1,50 @@
+module RPCMapper::QueryMethods
+  # TRP: Define each of the variables the query options will be stored in.
+  attr_accessor :select_values, :group_values, :order_values, :joins_values, :where_values,
+                :having_values, :limit_value, :offset_value, :from_value, :raw_sql_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 && !args.empty? }
+    end
+  end
+
+  def group(*args)
+    clone.tap { |r| r.group_values += args if args && !args.empty? }
+  end
+
+  def order(*args)
+    clone.tap { |r| r.order_values += args if args && !args.empty? }
+  end
+
+  def joins(*args)
+    clone.tap { |r| r.joins_values += args if args && !args.empty? }
+  end
+
+  def where(*args)
+    clone.tap { |r| r.where_values += args if args && !args.empty? }
+  end
+
+  def having(*args)
+    clone.tap { |r| r.having_values += args if args && !args.empty? }
+  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 sql(raw_sql)
+    clone.tap { |r| r.raw_sql_value = raw_sql }
+  end
+
+end

data/lib/rpc_mapper/relation.rb

@@ -0,0 +1,125 @@
+require 'rpc_mapper/relation/query_methods'
+require 'rpc_mapper/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 RPCMapper::Relation
+  SINGLE_VALUE_METHODS = [:limit, :offset, :from]
+  MULTI_VALUE_METHODS = [:select, :group, :order, :joins, :where, :having]
+
+  FINDER_OPTIONS = SINGLE_VALUE_METHODS + MULTI_VALUE_METHODS + [:conditions, :search, :sql]
+
+  include RPCMapper::QueryMethods
+  include RPCMapper::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
+    if self.raw_sql_value
+      { :sql => raw_sql_value }
+    else
+      hash = SINGLE_VALUE_METHODS.inject({}) do |h, option|
+        value = self.send("#{option}_value")
+        value ? h.merge(option => value) : h
+      end
+
+      hash.merge!((MULTI_VALUE_METHODS - [:select]).inject({}) do |h, option|
+        value = self.send("#{option}_values")
+        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(/\*$/) }
+        hash.merge!(:select => select_values.uniq)
+      end
+
+      hash
+    end
+  end
+
+  def to_a
+    @records ||= fetch_records
+  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, to_hash)
+  end
+
+end

data/lib/rpc_mapper/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 RPCMapper.
+
+module RPCMapper::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/rpc_mapper/scopes.rb

@@ -0,0 +1,45 @@
+require 'rpc_mapper/scopes/conditions'
+
+module RPCMapper::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