gnoso-remote_entity 0.0.1

data/lib/remote_entity/entity_record.rb

@@ -0,0 +1,28 @@
+module RemoteEntity
+  module EntityRecord
+      
+    def self.included(base)
+      base.class_eval do
+        alias_method :old_to_xml, :to_xml
+        def to_xml(options = {})
+          if !options[:methods]
+            options[:methods] = [ :remote_entity_id ]
+          else
+            options[:methods] << :remote_entity_id
+          end
+
+          old_to_xml(options)
+        end
+      end
+    end
+    
+    attr_accessor :remote_entity_id
+    def remote_entity_id
+      if id
+        return "#{RemoteEntity.service}-#{self.class.name.underscore.gsub("/", "_")}-#{id}"
+      else
+        return nil
+      end
+    end
+  end
+end

data/lib/remote_entity/entity_record_associations.rb

@@ -0,0 +1,97 @@
+module RemoteEntity
+  module EntityRecord
+    module Assocations
+    
+      def self.included(base)
+        base.extend ClassMethods
+      end
+    
+      module ClassMethods
+        def belongs_to_remote_entity(association_id, options = {})
+          if options[:class_name].nil?
+            options[:class_name] = association_id.to_s.camelize.to_sym 
+          end
+          
+          association_class = 
+              Object.const_get(options[:class_name].to_sym)
+            
+          define_accessible(association_id, options, association_class)
+          define_constructors(association_id, options, association_class)
+          
+          if options[:dependent] == :destroy
+            define_destroy(association_id, options, association_class)
+            after_destroy "destroy_#{association_id}".to_sym
+          end
+        end
+    
+        private
+        def define_accessible(association_id, options, association_class)
+
+            
+          if !method_defined?("remote_entity_cache")
+            define_method("remote_entity_cache") do
+              @remote_entity_cache ||= {}
+            end
+          end
+          if !method_defined?("remote_entity_dirty_vals")
+            define_method("remote_entity_dirty_vals") do
+              @remote_entity_dirty_vals ||= {}
+            end
+          end
+        
+          define_method("#{association_id.to_s}_remote_entity_object") do
+            service = association_class.service
+            resource = association_class.name.underscore
+          
+            RemoteEntity.new(
+                self.send("#{association_id.to_s}_id").to_s)
+          end
+        
+          define_method("#{association_id.to_s}".to_sym) do
+            if remote_entity_dirty_vals.has_key?(association_id)
+              remote_entity_dirty_vals[association_id]
+            elsif !self.send("#{association_id.to_s}_id").nil?
+              id = self.send("#{association_id.to_s}_remote_entity_object").id
+              remote_entity_cache[association_id] ||= association_class.find(id)
+            else
+              nil
+            end
+          end
+      
+          define_method("#{association_id.to_s}=".to_sym) do |value|
+            remote_entity_cache[association_id] = nil
+          
+            self.send("#{association_id.to_s}_id=", value.remote_entity_id)
+            remote_entity_dirty_vals[association_id] = value
+          end
+        end
+    
+        def define_constructors(association_id, options, association_class)
+          define_method("build_#{association_id}") do |*params|
+            attributes = params.first
+          
+            object = association_class.new(attributes)
+          
+            self.send("#{association_id.to_s}=", object)
+          end
+      
+          define_method("create_#{association_id}") do |*params|
+            attributes = params.first
+          
+            object = association_class.new(attributes)
+            object.save
+
+            self.send("#{association_id}=", object)
+          end
+        end
+        
+        def define_destroy(association_id, options, association_class)
+          define_method("destroy_#{association_id}") do
+            object = self.send("#{association_id}")
+            object.destroy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/remote_entity/entity_resource.rb

@@ -0,0 +1,54 @@
+require 'active_resource'
+
+module RemoteEntity
+  class EntityResource < ActiveResource::Base
+    
+    def initialize(attrs = {})      
+      @@schema ||= []
+      
+      attrs = HashWithIndifferentAccess.new(attrs)
+      @@schema.each do |attribute|
+        if !attrs.has_key?(attribute)
+          attrs[attribute] = nil
+        end
+      end
+      if !attrs.has_key?(:remote_entity_id)
+        attrs[:remote_entity_id] = nil
+      end
+      
+      super(attrs)
+    end
+    
+    # Defines methods for the following properties on every instance of this
+    # type that is created
+    def self.schema(*args)
+      @@schema = args
+    end
+    
+    # Helps us set the site automatically.
+    def self.version=(version)
+      @@api_version = version
+      self.update_site
+    end
+    
+    def self.version
+      return defined?(@@api_version) ? @@api_version : nil
+    end
+    
+    # Helps us set the site automatically
+    def self.service=(service)
+      @@service = service
+      self.update_site
+    end
+    
+    def self.service
+      return defined?(@@service) ? @@service : nil
+    end
+    
+    private
+    def self.update_site
+      self.site = RemoteEntity.service_uri(self.service,
+          self.version)
+    end
+  end
+end

data/lib/remote_entity/remote_entity.rb

@@ -0,0 +1,48 @@
+module RemoteEntity
+  class RemoteEntity
+    attr_accessor :service
+    attr_accessor :resource
+    attr_accessor :id
+  
+    # Constructs a new remote entity object.
+    def initialize(remote_entity_id)
+       parts = remote_entity_id.split('-', 3)
+       if parts.length != 3
+         raise "Entity id given is not a proper entity id"
+       end
+     
+       self.service, self.resource, self.id = parts
+    end
+  
+    # Returns the service uri for the given service at the given version
+    def self.service_uri(service, version)
+      return "#{lookup_service(service)[:uri]}/api/v#{version.to_s}/"
+    end
+    
+    # Registers a service so that we can build urls from it. Holla!
+    def self.register_service(service_name, service_uri, service_api_key = "")
+      services[service_name.to_sym] = { :uri => service_uri, 
+          :api_key => service_api_key }
+    end
+    
+    def self.lookup_service(service)
+      result = services[service.to_sym]
+      raise "Service `#{service.to_s}` not found" if !result
+      
+      return result
+    end
+    
+    def self.service=(service)
+      @@service = service
+    end
+    
+    def self.service
+      @@service ||= nil
+    end
+    
+    private 
+    def self.services
+      @@services ||= {}
+    end
+  end
+end

data/lib/remote_entity.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'remote_entity', 'remote_entity')
+require File.join(File.dirname(__FILE__), 'remote_entity', 'entity_resource')
+require File.join(File.dirname(__FILE__), 'remote_entity', 'entity_record')
+require File.join(File.dirname(__FILE__), 'remote_entity',
+    'entity_record_associations')

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: gnoso-remote_entity
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Gnoso, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+    version: 
+description: Remote Entity defines a pattern for working with REST services. It defines a versioning scheme, a remote entity identifier scheme, and adds some useful features to ActiveRecord and ActiveResource for working with those schemes.
+email: alan@gnoso.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/remote_entity.rb
+- lib/remote_entity/entity_record.rb
+- lib/remote_entity/entity_record_associations.rb
+- lib/remote_entity/entity_resource.rb
+- lib/remote_entity/remote_entity.rb
+has_rdoc: true
+homepage: http://www.gnoso.com
+licenses: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Remote Entity defines a pattern for working with REST services.
+test_files: []
+