active_remote 1.2.1

data/.gitignore

@@ -0,0 +1,10 @@
+*.gem
+*.swp
+.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+coverage
+pkg/*
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--order rand
+--format RSpec::Pride

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@active_remote --create

data/Gemfile

@@ -0,0 +1,7 @@
+source 'http://gems.moneydesktop.com'
+source 'https://rubygems.org'
+
+gem 'builder', '~> 3.0.0' # Geminabox will to go to 3.1.3, which causes problems with ActiveModel.
+
+# Specify your gem's dependencies in active_remote.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 MDev
+
+MIT License
+
+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/README.md

@@ -0,0 +1,86 @@
+# Active Remote
+
+Active Remote provides [Active Record](https://github.com/rails/rails/tree/master/activerecord)-like object-relational mapping over RPC. Think of it as Active Record for your platform: within a service, use Active Record to persist objects and between services, use Active Remote.
+
+Active Remote provides a base class that when subclassed, provides the functionality you need to setup your remote model. Because Active Remote provides model persistence between RPC services, it uses a GUID to retrieve records and establish associations. So Active Remote expects your RPC data format to provide a :guid field that can be used to identify your remote models.
+
+Unlike Active Record, Active Remote doesn't have access to a database table to create attribute mappings. So you'll need to do a little setup to let Active Remote know how to persist your model*.
+
+```Ruby
+  # Given a product record that has :guid & :name fields:
+  class Product < ActiveRecord::Base
+    # :guid, :name
+  end
+
+  # Configure your Active Remote model like this:
+  class Product < ActiveRemote::Base
+    attribute :guid
+    attribute :name
+  end
+```
+
+_*Using Ruby's inherited hook, you could build an attribute mapper to setup your remote models for you._
+
+Like Active Record, Active Remote relies heavily on naming conventions and standard CRUD actions. It expects models name to map to it's service (e.g Product => ProductService) and will infer the service name automatically.
+
+```Ruby
+  # Given a product service that has #search, #create, #update, and #delete endpoints
+  class ProductService < RPCService
+    def search(request)
+      #...
+    end
+
+    def create(request)
+      #...
+    end
+
+    def update(request)
+      #...
+    end
+
+    def delete(request)
+      #...
+    end
+  end
+
+  # Your remote model will just work.
+  class Product < ActiveRemote::Base
+  end
+```
+
+ You can, of course override it if need be:
+
+```Ruby
+  # If you have a custom service:
+  class CustomProductService < RPCService
+    # CRUD actions
+  end
+
+  # Configure your remote model like this:
+  class Product < ActiveRemote::Base
+    service_name :custom_product_service
+  end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_remote'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_remote
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,21 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run specs (default)"
+task :default, [] => :spec
+
+desc "Remove protobuf definitions that have been compiled"
+task :clean do 
+  FileUtils.rm(Dir.glob("spec/support/protobuf/**/*.proto"))
+  puts "Cleaned"
+end
+
+desc "Compile spec/support protobuf definitions"
+task :compile, [] => :clean do 
+  cmd = "rprotoc --ruby_out=spec/support/protobuf --proto_path=spec/support/definitions spec/support/definitions/*.proto"
+  sh(cmd)
+end

data/active_remote.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_remote/version"
+
+Gem::Specification.new do |s|
+  s.name          = "active_remote"
+  s.version       = ActiveRemote::VERSION
+  s.authors       = ["Adam Hutchison"]
+  s.email         = ["liveh2o@gmail.com"]
+  s.homepage      = "https://github.com/liveh2o/active_remote"
+  s.summary       = %q{Active Record for your platform}
+  s.description   = %q{Active Remote provides Active Record-like object-relational mapping over RPC. It was written for use with Google Protocol Buffers, but could be extended to use any RPC data format.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  ##
+  # Dependencies
+  #
+  s.add_dependency "activemodel"
+  s.add_dependency "active_attr"
+  s.add_dependency "protobuf", ">= 2.0"
+
+  ##
+  # Development Dependencies
+  #
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-pride"
+  s.add_development_dependency "pry-nav"
+  s.add_development_dependency "protobuf-rspec"
+  s.add_development_dependency "simplecov"
+end

data/lib/active_remote.rb

@@ -0,0 +1,15 @@
+require 'active_attr'
+require 'active_model'
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/hash'
+require 'active_support/inflector'
+require 'active_support/json'
+
+require 'core_ext/date_time'
+require 'core_ext/date'
+require 'core_ext/integer'
+
+require 'active_remote/base'
+require 'active_remote/errors'
+
+require 'active_remote/version'

data/lib/active_remote/association.rb

@@ -0,0 +1,152 @@
+module ActiveRemote
+  module Association
+    def self.included(klass)
+      klass.class_eval do
+        extend ActiveRemote::Association::ClassMethods
+      end
+    end
+
+    module ClassMethods
+      # Create a `belongs_to` association for a given remote resource.
+      # Specify one or more associations to define. The constantized
+      # class must be loaded into memory already. A method will be defined
+      # with the same name as the association. When invoked, the associated
+      # remote model will issue a `search` for the :guid with the associated
+      # guid's attribute (e.g. read_attribute(:client_guid)) and return the first
+      # remote object from the result, or nil.
+      #
+      # A `belongs_to` association should be used when the associating remote
+      # contains the guid to the associated model. For example, if a User model
+      # `belongs_to` Client, the User model would have a client_guid field that is
+      # used to search the Client service. The Client model would have no
+      # reference to the user.
+      #
+      # ====Examples
+      #
+      #   class User
+      #     belongs_to :client
+      #   end
+      #
+      # An equivalent code snippet without a `belongs_to` declaration would be:
+      #
+      # ====Examples
+      #
+      #   class User
+      #     def client
+      #       Client.search(:guid => self.client_guid).first
+      #     end
+      #   end
+      #
+      def belongs_to(*klass_names)
+        klass_names.flatten.compact.uniq.each do |klass_name|
+
+          define_method(klass_name) do
+            value = instance_variable_get(:"@#{klass_name}")
+
+            unless value
+              klass = klass_name.to_s.classify.constantize
+              value = klass.search(:guid => read_attribute(:"#{klass_name}_guid")).first
+              instance_variable_set(:"@#{klass_name}", value)
+            end
+
+            return value
+          end
+        end
+      end
+
+      # Create a `has_many` association for a given remote resource.
+      # Specify one or more associations to define. The constantized
+      # class must be loaded into memory already. A method will be defined
+      # with the same plural name as the association. When invoked, the associated
+      # remote model will issue a `search` for the :guid with the associated
+      # guid's attribute (e.g. read_attribute(:client_guid)).
+      #
+      # A `has_many` association should be used when the associated model has
+      # a field to identify the associating model, and there can be multiple
+      # remotes associated. For example, if a Client has many Users, the User remote
+      # would have a client_guid field that is searchable. That search would likely
+      # return multiple user records. The client would not
+      # have a field indicating which users are associated.
+      #
+      # ====Examples
+      #
+      #   class Client
+      #     has_many :users
+      #   end
+      #
+      # An equivalent code snippet without a `has_many` declaration would be:
+      #
+      # ====Examples
+      #
+      #   class Client
+      #     def users
+      #       User.search(:client_guid => self.guid)
+      #     end
+      #   end
+      #
+      def has_many(*klass_names)
+        klass_names.flatten.compact.uniq.each do |plural_klass_name|
+          singular_name = plural_klass_name.to_s.singularize
+
+          define_method(plural_klass_name) do
+            values = instance_variable_get(:"@#{plural_klass_name}")
+
+            unless values
+              klass = plural_klass_name.to_s.classify.constantize
+              values = klass.search(:"#{self.class.name.demodulize.underscore}_guid" => self.guid)
+              instance_variable_set(:"@#{plural_klass_name}", values)
+            end
+
+            return values
+          end
+        end
+      end
+
+      # Create a `has_one` association for a given remote resource.
+      # Specify one or more associations to define. The constantized
+      # class must be loaded into memory already. A method will be defined
+      # with the same name as the association. When invoked, the associated
+      # remote model will issue a `search` for the :guid with the associated
+      # guid's attribute (e.g. read_attribute(:client_guid)) and return the first
+      # remote object in the result, or nil.
+      #
+      # A `has_one` association should be used when the associated remote
+      # contains the guid from the associating model. For example, if a User model
+      # `has_one` Client, the Client remote would have a user_guid field that is
+      # searchable. The User model would have no reference to the client.
+      #
+      # ====Examples
+      #
+      #   class User
+      #     has_one :client
+      #   end
+      #
+      # An equivalent code snippet without a `has_one` declaration would be:
+      #
+      # ====Examples
+      #
+      #   class User
+      #     def client
+      #       Client.search(:user_guid => self.guid).first
+      #     end
+      #   end
+      #
+      def has_one(*klass_names)
+        klass_names.flatten.compact.uniq.each do |klass_name|
+
+          define_method(klass_name) do
+            value = instance_variable_get(:"@#{klass_name}")
+
+            unless value
+              klass = klass_name.to_s.classify.constantize
+              value = klass.search(:"#{self.class.name.demodulize.underscore}_guid" => self.guid).first
+              instance_variable_set(:"@#{klass_name}", value)
+            end
+
+            return value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_remote/attributes.rb

@@ -0,0 +1,29 @@
+module ActiveRemote
+  module Attributes
+    # Read attribute from the attributes hash
+    #
+    def read_attribute(name)
+      name = name.to_s
+
+      if respond_to? name
+        @attributes[name]
+      else
+        raise UnknownAttributeError, "unknown attribute: #{name}"
+      end
+    end
+    alias_method :[], :read_attribute
+
+    # Update an attribute in the attributes hash
+    #
+    def write_attribute(name, value)
+      name = name.to_s
+
+      if respond_to? "#{name}="
+        @attributes[name] = typecast_attribute(_attribute_typecaster(name), value)
+      else
+        raise UnknownAttributeError, "unknown attribute: #{name}"
+      end
+    end
+    alias_method :[]=, :write_attribute
+  end
+end

data/lib/active_remote/base.rb

@@ -0,0 +1,49 @@
+require 'active_remote/association'
+require 'active_remote/attributes'
+require 'active_remote/bulk'
+require 'active_remote/dirty'
+require 'active_remote/dsl'
+require 'active_remote/persistence'
+require 'active_remote/rpc'
+require 'active_remote/search'
+require 'active_remote/serialization'
+
+module ActiveRemote
+  class Base
+    extend ::ActiveModel::Callbacks
+
+    include ::ActiveAttr::Model
+
+    include ::ActiveRemote::Association
+    include ::ActiveRemote::Attributes
+    include ::ActiveRemote::Bulk
+    include ::ActiveRemote::DSL
+    include ::ActiveRemote::Persistence
+    include ::ActiveRemote::RPC
+    include ::ActiveRemote::Search
+    include ::ActiveRemote::Serialization
+
+    # Overrides some methods, providing support for dirty tracking,
+    # so it needs to be included last.
+    include ::ActiveRemote::Dirty
+
+    attr_reader :last_request, :last_response
+
+    define_model_callbacks :initialize, :only => :after
+
+    def initialize(*)
+      run_callbacks :initialize do
+        @attributes ||= {}
+        super
+      end
+    end
+
+    def freeze
+      @attributes.freeze; self
+    end
+
+    def frozen?
+      @attributes.frozen?
+    end
+  end
+end