rpc-mapper 0.0.1

data/README.rdoc

@@ -0,0 +1,38 @@
+= RPCMapper
+
+== Description
+
+Ruby library for querying and mapping data over RPC
+
+== Installation
+
+    gem install rpc-mapper
+
+== Usage
+
+    require 'rpc_mapper'
+
+== License
+
+Copyright (c) 2010 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,61 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/rpc_mapper/version'
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'rpc-mapper'
+  s.version          = RPCMapper::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 over RPC"
+  s.author           = 'Travis Petticrew'
+  s.email            = 'bobo@petticrew.net'
+  s.homepage         = 'http://github.com/tpett/rpc-mapper'
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib}/**/*")
+  # s.executables    = ['rpc-mapper']
+
+  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
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+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/rpc_mapper/adapters/abstract_adapter.rb

@@ -0,0 +1,36 @@
+require 'rpc_mapper/logger'
+
+module RPCMapper::Adapters
+  class AbstractAdapter
+    include RPCMapper::Logger
+
+    attr_accessor :options
+    @@registered_adapters ||= {}
+
+    def initialize(options={})
+      @options = options.dup
+    end
+
+    def self.create(type, options={})
+      type = type ? @@registered_adapters[type.to_sym] : self
+      type.new(options)
+    end
+
+    def call(procedure, options={})
+      log(options, "#{service_log_prefix} #{procedure}") { self.service.call.data_server.send(procedure, options) }
+    end
+
+    def service
+      raise NotImplementedError, "You must not use the AbstractAdapter.  Implement an adapter that extends the AbstractAdapter class and overrides this method."
+    end
+
+    def service_log_prefix
+      "RPC"
+    end
+
+    def self.register_as(name)
+      @@registered_adapters[name.to_sym] = self
+    end
+
+  end
+end

data/lib/rpc_mapper/adapters/bertrpc_adapter.rb

@@ -0,0 +1,10 @@
+module RPCMapper::Adapters
+  class BERTRPCAdapter < RPCMapper::Adapters::AbstractAdapter
+    register_as :bertrpc
+
+    def service
+      @service ||= BERTRPC::Service.new(self.options[:host], self.options[:port])
+    end
+
+  end
+end

data/lib/rpc_mapper/adapters.rb

@@ -0,0 +1,4 @@
+module RPCMapper::Adapters; end
+
+require 'rpc_mapper/adapters/abstract_adapter'
+require 'rpc_mapper/adapters/bertrpc_adapter'

data/lib/rpc_mapper/associations/common.rb

@@ -0,0 +1,51 @@
+module RPCMapper::Associations
+
+  module Common
+    module ClassMethods
+
+      protected
+
+      def extension_map
+        @@extension_map ||= Hash.new(Array.new)
+      end
+
+      def update_extension_map(old_klass, new_klass)
+        self.extension_map[old_klass] += [new_klass] if base_class_name(old_klass) == base_class_name(new_klass)
+      end
+
+      # TRP: This will return the most recent extension of klass or klass if it is a leaf node in the hierarchy
+      def resolve_leaf_klass(klass)
+        extension_map[klass].empty? ? klass : resolve_leaf_klass(extension_map[klass].last)
+      end
+
+      def base_class_name(klass)
+        klass.to_s.split("::").last
+      end
+
+    end
+
+    module InstanceMethods
+
+      protected
+
+      def klass_from_association_options(association, options)
+        klass = if options[:polymorphic]
+          eval [options[:polymorphic_namespace], self.send("#{association}_type")].compact.join('::')
+        else
+          raise(ArgumentError, ":class_name or :klass option required for association declaration.") unless options[:class_name] || options[:klass]
+          options[:class_name] = "::#{options[:class_name]}" unless options[:class_name] =~ /^::/
+          options[:klass] || eval(options[:class_name])
+        end
+
+        self.class.send :resolve_leaf_klass, klass
+      end
+
+    end
+
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/rpc_mapper/associations/contains.rb

@@ -0,0 +1,64 @@
+require 'rpc_mapper/associations/common'
+
+module RPCMapper::Associations
+
+  module Contains
+    module ClassMethods
+
+      # TRP: Define an association that is serialized within the data for this class.
+      # If a subset of the data returned for a class contains the data for another class you can use the contains_many
+      # association to (lazy) auto initialize the specified object(s) using the data from that attribute.
+      def contains_many(association, options={})
+        create_contains_association(:many, association, options)
+      end
+
+      # TRP: Same as contains_many, but only works with a single record
+      def contains_one(association, options={})
+        create_contains_association(:one, association, options)
+      end
+
+      private
+
+      def create_contains_association(type, association, options)
+        attribute = (options[:attribute] || association).to_sym
+        cache_variable = "@association_#{association}"
+
+        self.defined_attributes << association.to_s unless self.defined_attributes.include?(association.to_s)
+        define_method(association) do
+          klass = klass_from_association_options(association, options)
+          records = instance_variable_get(cache_variable)
+
+          unless records
+            records = case type
+            when :many
+              self[attribute].collect { |record| klass.new_from_data_store(record) } if self[attribute]
+            when :one
+              klass.new_from_data_store(self[attribute]) if self[attribute]
+            end
+            instance_variable_set(cache_variable, records)
+          end
+
+          records
+        end
+
+        # TRP: This method will allow eager loaded values to be loaded into the association
+        define_method("#{association}=") do |value|
+          instance_variable_set(cache_variable, value)
+        end
+
+      end
+
+    end
+
+    module InstanceMethods
+
+    end
+
+    def self.included(receiver)
+      receiver.send :include, RPCMapper::Associations::Common
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/rpc_mapper/associations/external.rb

@@ -0,0 +1,102 @@
+require 'rpc_mapper/associations/common'
+
+module RPCMapper::Associations
+
+  module External
+    module ClassMethods
+
+      def belongs_to(association, options={})
+        create_external_association(:belongs, association, options)
+      end
+
+      def has_one(association, options={})
+        create_external_association(:one, association, options)
+      end
+
+      def has_many(association, options={})
+        create_external_association(:many, association, options)
+      end
+
+      protected
+
+      def create_external_association(association_type, association, association_options={})
+        cache_ivar = "@association_#{association}"
+        self.declared_associations[association] = [association_type, association_options]
+
+        define_method(association) do
+          type = self.class.declared_associations[association].first
+          options = self.class.declared_associations[association].last.dup
+          options = options.is_a?(Proc) ? options.call(self) : options
+          klass = klass_from_association_options(association, options)
+          cached_value = instance_variable_get(cache_ivar)
+
+          options[:primary_key] = (options[:primary_key] || "id").to_sym
+          options[:foreign_key] = (options[:foreign_key] || ((type == :belongs) ? "#{association}_id" : "#{self.class.name.split('::').last.downcase}_id")).to_sym
+
+          # TRP: Logic for actually pulling setting the value
+          unless cached_value
+            query_options = build_query_options_for_external_association(type, options)
+            cached_value = case type
+            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
+            end
+            instance_variable_set(cache_ivar, cached_value)
+          end
+
+          cached_value
+        end
+
+        # TRP: Allow eager loading of the association without having to load it through the normal accessor
+        define_method("#{association}=") do |value|
+          instance_variable_set(cache_ivar, value)
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      protected
+
+      def build_query_options_for_external_association(type, options)
+        as = options[:as]
+        as_type = self.class.send(:base_class_name, self.class) if as
+
+        pk = options[:primary_key].to_sym
+        fk = (as ? "#{as}_id" : options[:foreign_key]).to_sym
+
+        default_query_options = case type
+        when :belongs
+          { :conditions => (self[fk] ? { pk => self[fk] } : nil) } # TRP: Only add conditions if the fk is not nil
+        when :one, :many
+          # TRP: Only add conditions if the pk is not nil
+          if self[pk]
+            conditions = { fk => self[pk] }
+            conditions.merge!(:"#{as}_type" => as_type) if as
+            { :conditions => conditions }
+          else
+            {}
+          end
+        end
+
+        configured_query_options = {}
+        RPCMapper::Relation::FINDER_OPTIONS.each do |key|
+          value = options[key]
+          configured_query_options.merge!({ key => value.respond_to?(:call) ? value.call(self) : value }) if value
+        end
+
+        default_query_options.deep_merge(configured_query_options)
+      end
+
+    end
+
+    def self.included(receiver)
+      receiver.send :include, RPCMapper::Associations::Common
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/rpc_mapper/base.rb

@@ -0,0 +1,202 @@
+# 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/config_options'
+require 'rpc_mapper/associations/contains'
+require 'rpc_mapper/associations/external'
+require 'rpc_mapper/cacheable'
+require 'rpc_mapper/serialization'
+require 'rpc_mapper/relation'
+require 'rpc_mapper/scopes'
+require 'rpc_mapper/adapters'
+
+
+class RPCMapper::Base
+  include RPCMapper::ConfigOptions
+  include RPCMapper::Associations::Contains
+  include RPCMapper::Associations::External
+  include RPCMapper::Serialization
+  include RPCMapper::Scopes
+
+  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
+  self.cacheable = false
+  self.declared_associations = {}
+  self.defined_attributes = []
+  @@adapter_pool = {}
+
+  def initialize(attributes={})
+    self.new_record = true
+    set_attributes(attributes)
+  end
+
+  def [](attribute)
+    @attributes[attribute.to_s]
+  end
+
+  protected
+
+  # TRP: Common interface for setting attributes to keep things consistent
+  def set_attributes(attributes)
+    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) })
+  end
+
+  def set_attribute(attribute, value)
+    set_attributes({ attribute => value })
+  end
+
+  # Class Methods
+  class << self
+    public
+
+    delegate :find, :first, :all, :search, :to => :scoped
+    delegate :select, :group, :order, :joins, :where, :having, :limit, :offset, :from, :to => :scoped
+
+    def new_from_data_store(hash)
+      if hash.nil?
+        nil
+      else
+        record = self.new(hash)
+        record.new_record = false
+        record
+      end
+    end
+
+    def unscoped
+      current_scopes = self.scoped_methods
+      self.scoped_methods = []
+      begin
+        yield
+      ensure
+        self.scoped_methods = current_scopes
+      end
+    end
+
+    def inherited(subclass)
+      update_extension_map(self, subclass)
+      super
+    end
+
+    def respond_to?(method, include_private=false)
+      super ||
+      scoped.dynamic_finder_method(method)
+    end
+
+    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
+    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 })
+    end
+
+    def method_missing(method, *args, &block)
+      if scoped.dynamic_finder_method(method)
+        scoped.send(method, *args, &block)
+      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)
+
+        # 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
+    end
+
+    def configure_cacheable(options={})
+      unless cacheable
+        self.send(:include, RPCMapper::Cacheable)
+        self.enable_caching(options)
+      end
+    end
+
+    # TRP: Used to declare attributes -- only attributes that are declared will be available
+    def attributes(*attributes)
+      return self.defined_attributes if attributes.empty?
+
+      [*attributes].each do |attribute|
+        self.defined_attributes << attribute.to_s
+
+        define_method(attribute) do
+          self[attribute]
+        end
+
+        # TRP: Setup the writers if mutable is set
+        create_writer(attribute) if self.mutable
+
+      end
+    end
+    def attribute(*attrs)
+      self.attributes(*attrs)
+    end
+
+    def relation
+      @relation ||= RPCMapper::Relation.new(self)
+    end
+
+    def default_scope(scope)
+      base_scope = current_scope || relation
+      self.scoped_methods << (scope.is_a?(Hash) ? base_scope.apply_finder_options(scope) : base_scope.merge(scope))
+    end
+
+    def current_scope
+      self.scoped_methods ||= []
+      self.scoped_methods.last
+    end
+
+  end
+
+end

data/lib/rpc_mapper/cacheable/entry.rb

@@ -0,0 +1,18 @@
+module RPCMapper::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/rpc_mapper/cacheable/store.rb

@@ -0,0 +1,45 @@
+module RPCMapper::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