rpc-mapper 0.0.2 → 0.1.0

data/Rakefile

@@ -30,10 +30,19 @@ Rake::GemPackageTask.new(spec) do |pkg|
   pkg.gem_spec = spec
 end
 
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList["test/**/*_test.rb"]
-  t.verbose = true
+[: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

data/lib/rpc_mapper/adapters/abstract_adapter.rb

@@ -4,33 +4,52 @@ module RPCMapper::Adapters
   class AbstractAdapter
     include RPCMapper::Logger
 
-    attr_accessor :options
+    attr_accessor :config
+    attr_reader :type
     @@registered_adapters ||= {}
 
-    def initialize(options={})
-      @options = options.dup
+    def initialize(type, config)
+      @type = type.to_sym
+      @configuration_contexts = config.is_a?(Array) ? config : [config]
     end
 
-    def self.create(type, options={})
-      type = type ? @@registered_adapters[type.to_sym] : self
-      type.new(options)
+    def self.create(type, config)
+      klass = type ? @@registered_adapters[type.to_sym] : self
+      klass.new(type, config)
     end
 
-    def call(procedure, options={})
-      log(options, "#{service_log_prefix} #{procedure}") { self.service.call.data_server.send(procedure, options) }
+    def extend_adapter(config)
+      self.class.create(self.type, @configuration_contexts + [*config])
     end
 
-    def service
-      raise NotImplementedError, "You must not use the AbstractAdapter.  Implement an adapter that extends the AbstractAdapter class and overrides this method."
+    def config
+      @config ||= build_configuration
     end
 
-    def service_log_prefix
-      "RPC"
+    def read(options)
+      raise NotImplementedError, "You must not use the abstract adapter.  Implement an adapter that extends the RPCMapper::Adapters::Abstract::Base class and overrides this method."
+    end
+
+    def write(object)
+      raise NotImplementedError, "You must not use the abstract adapter.  Implement an adapter that extends the RPCMapper::Adapters::Abstract::Base class and overrides this method."
+    end
+
+    def delete(object)
+      raise NotImplementedError, "You must not use the abstract adapter.  Implement an adapter that extends the RPCMapper::Adapters::Abstract::Base 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.collect do |config_block|
+        config_block.is_a?(Hash) ? config_block : OpenStruct.new.tap { |os| config_block.call(os) }.marshal_dump
+      end.inject({}) { |sum, config| sum.merge(config) }
+    end
+
   end
 end

data/lib/rpc_mapper/adapters/bertrpc_adapter.rb

@@ -1,9 +1,27 @@
+autoload :BERTRPC, 'bertrpc'
+
 module RPCMapper::Adapters
   class BERTRPCAdapter < RPCMapper::Adapters::AbstractAdapter
     register_as :bertrpc
 
+    @@service_pool ||= {}
+
     def service
-      @service ||= BERTRPC::Service.new(self.options[:host], self.options[:port])
+      @@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

data/lib/rpc_mapper/adapters/restful_http_adapter.rb

@@ -0,0 +1,91 @@
+autoload :Net, 'net/http'
+autoload :URI, 'uri'
+
+module RPCMapper::Adapters
+  class RestfulHTTPAdapter < RPCMapper::Adapters::AbstractAdapter
+    register_as :restful_http
+
+    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] || {}
+
+        object.attributes.each do |attribute, value|
+          params.merge!({"#{self.config[:post_body_wrapper]}[#{attribute}]" => value})
+        end
+
+        params
+      else
+        @attributes
+      end
+    end
+
+    def build_uri(object, method)
+      url = [self.config[:host].gsub(%r{/$}, ''), self.config[:service]]
+      url << object.id 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/rpc_mapper/adapters.rb

@@ -2,3 +2,4 @@ module RPCMapper::Adapters; end
 
 require 'rpc_mapper/adapters/abstract_adapter'
 require 'rpc_mapper/adapters/bertrpc_adapter'
+require 'rpc_mapper/adapters/restful_http_adapter'

data/lib/rpc_mapper/associations/external.rb

@@ -40,7 +40,7 @@ module RPCMapper::Associations
             when :belongs, :one
               klass.first(query_options) if query_options[:conditions] # TRP: Only run query if conditions is not nil
             when :many
-              klass.all(query_options)   if query_options[:conditions] # TRP: Only run query if conditions is not nil
+              klass.apply_finder_options(query_options)   if query_options[:conditions] # TRP: Only apply scopes if conditions is not nil
             end
             instance_variable_set(cache_ivar, cached_value)
           end

data/lib/rpc_mapper/base.rb

@@ -1,24 +1,5 @@
-# TRP: Cherry pick some goodies from active_support
-require 'active_support/core_ext/array'
-begin
-  require 'active_support/core_ext/duplicable' #ActiveSupport 2.3.5
-rescue LoadError => exception
-  require 'active_support/core_ext/object/duplicable' #ActiveSupport 3.0.0.RC
-end
-require 'active_support/core_ext/class/inheritable_attributes'
-require 'active_support/core_ext/hash/deep_merge'
-require 'active_support/core_ext/module/delegation'
-Hash.send(:include, ActiveSupport::CoreExtensions::Hash::DeepMerge) unless Hash.new.respond_to?(:deep_merge)
-
-# TRP: Used for pretty logging
-require 'benchmark'
-
-# TRP: RPCMapper core_ext
-require 'rpc_mapper/core_ext/kernel/singleton_class'
-
 # TRP: RPCMapper modules
 require 'rpc_mapper/errors'
-require 'rpc_mapper/config_options'
 require 'rpc_mapper/associations/contains'
 require 'rpc_mapper/associations/external'
 require 'rpc_mapper/cacheable'
@@ -29,7 +10,6 @@ require 'rpc_mapper/adapters'
 
 
 class RPCMapper::Base
-  include RPCMapper::ConfigOptions
   include RPCMapper::Associations::Contains
   include RPCMapper::Associations::External
   include RPCMapper::Serialization
@@ -38,23 +18,11 @@ class RPCMapper::Base
   attr_accessor :attributes, :new_record
   alias :new_record? :new_record
 
-  class_inheritable_accessor :defined_attributes, :mutable, :cacheable, :scoped_methods, :declared_associations
-  config_options :rpc_server_host => 'localhost',
-                 :rpc_server_port => 8000,
-                 :service => nil,
-                 :service_namespace => nil,
-                 :adapter_type => nil,
-                 # TRP: Only used if configure_mutable is called
-                 :mutable_default_parameters => {},
-                 :mutable_host => nil,
-                 # TRP: This is used to append any options to the call (e.g. value to authenticate the client with the server, :app_key)
-                 :default_options => {}
-
-  self.mutable = false
+  class_inheritable_accessor :read_adapter, :write_adapter, :cacheable, :defined_attributes, :scoped_methods, :declared_associations
+
   self.cacheable = false
   self.declared_associations = {}
   self.defined_attributes = []
-  @@adapter_pool = {}
 
   def initialize(attributes={})
     self.new_record = true
@@ -67,25 +35,25 @@ class RPCMapper::Base
 
   protected
 
-  # TRP: Common interface for setting attributes to keep things consistent
-  def set_attributes(attributes)
+  # TRP: Common interface for setting attributes to keep things consistent; if force is true the defined_attributes list will be ignored
+  def set_attributes(attributes, force=false)
     attributes = attributes.inject({}) do |options, (key, value)|
       options[key.to_s] = value
       options
     end
     @attributes = {} if @attributes.nil?
-    @attributes.merge!(attributes.reject { |field, value| !self.defined_attributes.include?(field) })
+    @attributes.merge!(attributes.reject { |field, value| !self.defined_attributes.include?(field) && !force })
   end
 
-  def set_attribute(attribute, value)
-    set_attributes({ attribute => value })
+  def set_attribute(attribute, value, force=false)
+    set_attributes({ attribute => value }, force)
   end
 
   # Class Methods
   class << self
     public
 
-    delegate :find, :first, :all, :search, :to => :scoped
+    delegate :find, :first, :all, :search, :apply_finder_options, :to => :scoped
     delegate :select, :group, :order, :joins, :where, :having, :limit, :offset, :from, :to => :scoped
 
     def new_from_data_store(hash)
@@ -121,40 +89,43 @@ class RPCMapper::Base
     protected
 
     def fetch_records(options={})
-      self.adapter.call("#{self.service_namespace}__#{self.service}", options.merge(default_options)).collect { |hash| self.new_from_data_store(hash) }.compact
+      self.read_adapter.read(options).collect { |hash| self.new_from_data_store(hash) }.compact
     end
 
-    def adapter
-      @@adapter_pool[self.adapter_type] ||= RPCMapper::Adapters::AbstractAdapter.create(self.adapter_type, { :host => self.rpc_server_host, :port => self.rpc_server_port })
+    def read_with(adapter_type)
+      setup_adapter(:read, { :type => adapter_type })
     end
 
-    def method_missing(method, *args, &block)
-      if scoped.dynamic_finder_method(method)
-        scoped.send(method, *args, &block)
+    def write_with(adapter_type)
+      if write_adapter
+        write_inheritable_attribute :write_adapter, nil if adapter_type != write_adapter.type
       else
-        super
-      end
-    end
-
-    def configure(options={})
-      self.configure_options.each { |option| self.send("#{option}=", options[option]) if options[option] }
-    end
-
-    # TRP: Only pulls in mutable module if configure_mutable is called
-    def configure_mutable(options={})
-      unless mutable
-        self.mutable = true
-
         # TRP: Pull in methods and libraries needed for mutable functionality
-        require 'rpc_mapper/mutable'
-        self.send(:include, RPCMapper::Mutable)
-        self.save_mutable_configuration(options)
+        require 'rpc_mapper/persistence' unless defined?(RPCMapper::Persistence)
+        self.send(:include, RPCMapper::Persistence) unless self.class.ancestors.include?(RPCMapper::Persistence)
 
         # TRP: Create writers if attributes are declared before configure_mutable is called
         self.defined_attributes.each { |attribute| create_writer(attribute) }
         # TRP: Create serialized writers if attributes are declared serialized before this call
         self.serialized_attributes.each { |attribute| set_serialize_writers(attribute) }
       end
+      setup_adapter(:write, { :type => adapter_type })
+    end
+
+    def configure_read(&block)
+      configure_adapter(:read, &block)
+    end
+
+    def configure_write(&block)
+      configure_adapter(:write, &block)
+    end
+
+    def method_missing(method, *args, &block)
+      if scoped.dynamic_finder_method(method)
+        scoped.send(method, *args, &block)
+      else
+        super
+      end
     end
 
     def configure_cacheable(options={})
@@ -176,7 +147,7 @@ class RPCMapper::Base
         end
 
         # TRP: Setup the writers if mutable is set
-        create_writer(attribute) if self.mutable
+        create_writer(attribute) if self.write_adapter
 
       end
     end
@@ -198,6 +169,28 @@ class RPCMapper::Base
       self.scoped_methods.last
     end
 
+    private
+
+    def setup_adapter(mode, config)
+      current_adapter = read_inheritable_attribute :"#{mode}_adapter"
+      type = config[:type] if config.is_a?(Hash)
+
+      new_adapter = if current_adapter
+        current_adapter.extend_adapter(config)
+      else
+        RPCMapper::Adapters::AbstractAdapter.create(type, config)
+      end
+
+      write_inheritable_attribute :"#{mode}_adapter", new_adapter
+    end
+
+    def configure_adapter(mode, &block)
+      raise ArgumentError, "A block must be passed to configure_#{mode} method." unless block_given?
+      raise ArgumentError, "You must first define an adapter before configuring it.  Use #{mode}_with :adapter_type." unless self.send(:"#{mode}_adapter")
+
+      setup_adapter(mode, block)
+    end
+
   end
 
 end

data/lib/rpc_mapper/cacheable.rb

@@ -16,7 +16,7 @@ module RPCMapper::Cacheable
       cache_hit = self.cacheable.read(key)
 
       if cache_hit
-        self.adapter.log(options, "CACHE #{self.service_namespace}__#{self.service}")
+        self.read_adapter.log(options, "CACHE")
         cache_hit.each { |fv| fv.fresh = false.freeze }
         cache_hit
       else

data/lib/rpc_mapper/persistence.rb

@@ -0,0 +1,47 @@
+module RPCMapper::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 update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    def destroy
+      write_adapter.delete(self)
+    end
+    alias :delete :destroy
+
+  end
+
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+
+end

data/lib/rpc_mapper/serialization.rb

@@ -15,7 +15,7 @@ module RPCMapper::Serialization
         alias_method "#{field}_raw", field
         alias_method field, "deserialize_#{field}"
 
-        set_serialize_writers(field) if self.mutable
+        set_serialize_writers(field) if self.write_adapter
 
       end
     end

data/lib/rpc_mapper/version.rb

@@ -2,8 +2,8 @@ module RPCMapper
   module Version
 
     MAJOR = 0
-    MINOR = 0
-    TINY  = 2
+    MINOR = 1
+    TINY  = 0
 
     def self.to_s # :nodoc:
       [MAJOR, MINOR, TINY].join('.')

data/lib/rpc_mapper.rb

@@ -1,5 +1,22 @@
-require 'bert'
-require 'bertrpc'
+# 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: RPCMapper core_ext
+require 'rpc_mapper/core_ext/kernel/singleton_class'
 
 module RPCMapper
   @@log_file = nil

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 2
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - Travis Petticrew
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-03 00:00:00 -05:00
+date: 2010-10-26 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -125,6 +125,7 @@ files:
 - Rakefile
 - lib/rpc_mapper/adapters/abstract_adapter.rb
 - lib/rpc_mapper/adapters/bertrpc_adapter.rb
+- lib/rpc_mapper/adapters/restful_http_adapter.rb
 - lib/rpc_mapper/adapters.rb
 - lib/rpc_mapper/associations/common.rb
 - lib/rpc_mapper/associations/contains.rb
@@ -133,11 +134,10 @@ files:
 - lib/rpc_mapper/cacheable/entry.rb
 - lib/rpc_mapper/cacheable/store.rb
 - lib/rpc_mapper/cacheable.rb
-- lib/rpc_mapper/config_options.rb
 - lib/rpc_mapper/core_ext/kernel/singleton_class.rb
 - lib/rpc_mapper/errors.rb
 - lib/rpc_mapper/logger.rb
-- lib/rpc_mapper/mutable.rb
+- lib/rpc_mapper/persistence.rb
 - lib/rpc_mapper/relation/finder_methods.rb
 - lib/rpc_mapper/relation/query_methods.rb
 - lib/rpc_mapper/relation.rb

data/lib/rpc_mapper/config_options.rb

@@ -1,41 +0,0 @@
-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/mutable.rb

@@ -1,138 +0,0 @@
-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