active_remote 1.2.1

data/lib/active_remote/rpc.rb

@@ -0,0 +1,71 @@
+require 'active_remote/serializers/protobuf'
+
+module ActiveRemote
+  module RPC
+    def self.included(klass)
+      klass.class_eval do
+        extend ::ActiveRemote::RPC::ClassMethods
+        include ::ActiveRemote::Serializers::Protobuf
+      end
+    end
+
+    module ClassMethods
+      # Execute an RPC call to the remote service and return the raw response.
+      #
+      def remote_call(rpc_method, request_args)
+        remote = self.new
+        remote.execute(rpc_method, request_args)
+        remote.last_response
+      end
+
+      # Return a protobuf request object for the given rpc request.
+      #
+      def request(rpc_method, request_args)
+        return request_args unless request_args.is_a?(Hash)
+
+        message_class = request_type(rpc_method)
+        build_message(message_class, request_args)
+      end
+
+      # Return the class applicable to the request for the given rpc method.
+      #
+      def request_type(rpc_method)
+        service_class.rpcs[rpc_method].request_type
+      end
+    end
+
+    # Invoke an RPC call to the service for the given rpc method.
+    #
+    def execute(rpc_method, request_args)
+      @last_request = request(rpc_method, request_args)
+
+      _service_class.client.__send__(rpc_method, @last_request) do |c|
+
+        # In the event of service failure, raise the error.
+        c.on_failure do |error|
+          raise ActiveRemoteError, error.message
+        end
+
+        # In the event of service success, assign the response.
+        c.on_success do |response|
+          @last_response = response
+        end
+      end
+    end
+
+    # Execute an RPC call to the remote service and return the raw response.
+    #
+    def remote_call(rpc_method, request_args)
+      self.execute(rpc_method, request_args)
+      self.last_response
+    end
+
+  private
+
+    # Return a protobuf request object for the given rpc call.
+    #
+    def request(rpc_method, attributes)
+      self.class.request(rpc_method, attributes)
+    end
+  end
+end

data/lib/active_remote/search.rb

@@ -0,0 +1,131 @@
+require 'active_remote/persistence'
+require 'active_remote/rpc'
+
+module ActiveRemote
+  module Search
+    def self.included(klass)
+      klass.class_eval do
+        extend ::ActiveRemote::Search::ClassMethods
+        include ::ActiveRemote::Persistence
+        include ::ActiveRemote::RPC
+
+        define_model_callbacks :search
+      end
+    end
+
+    module ClassMethods
+
+      # Tries to load the first record; if it fails, an exception is raised.
+      #
+      # ====Examples
+      #
+      #   # A single hash
+      #   Tag.find(:guid => 'foo')
+      #
+      #   # Active remote object
+      #   Tag.find(Tag.new(:guid => 'foo'))
+      #
+      #   # Protobuf object
+      #   Tag.find(Generic::Remote::TagRequest.new(:guid => 'foo'))
+      #
+      def find(args)
+        remote = self.search(args).first
+        raise RemoteRecordNotFound if remote.nil?
+
+        return remote
+      end
+
+      # Tries to load the first record; if it fails, then create is called
+      # with the same arguments.
+      #
+      # ====Examples
+      #
+      #   # A single hash
+      #   Tag.first_or_create(:name => 'foo')
+      #
+      #   # Protobuf object
+      #   Tag.first_or_create(Generic::Remote::TagRequest.new(:name => 'foo'))
+      #
+      def first_or_create(attributes)
+        remote = self.search(attributes).first
+        remote ||= self.create(attributes)
+        remote
+      end
+
+      # Tries to load the first record; if it fails, then create! is called
+      # with the same arguments.
+      #
+      def first_or_create!(attributes)
+        remote = self.search(attributes).first
+        remote ||= self.create!(attributes)
+        remote
+      end
+
+      # Tries to load the first record; if it fails, then a new record is
+      # initialized with the same arguments.
+      #
+      # ====Examples
+      #
+      #   # A single hash
+      #   Tag.first_or_initialize(:name => 'foo')
+      #
+      #   # Protobuf object
+      #   Tag.first_or_initialize(Generic::Remote::TagRequest.new(:name => 'foo'))
+      #
+      def first_or_initialize(attributes)
+        remote = self.search(attributes).first
+        remote ||= self.new(attributes)
+        remote
+      end
+
+      # Searches for records with the given arguments. Returns a collection of
+      # Active Remote objects.
+      #
+      # ====Examples
+      #
+      #   # A single hash
+      #   Tag.search(:name => 'foo')
+      #
+      #   # Protobuf object
+      #   Tag.search(Generic::Remote::TagRequest.new(:name => 'foo'))
+      #
+      def search(args)
+        args = _active_remote_search_args(args)
+
+        remote = self.new
+        remote._active_remote_search(args)
+        remote.serialize_records
+      end
+
+      # :noapi:
+      def _active_remote_search_args(args)
+        unless args.is_a?(Hash)
+          if args.respond_to?(:to_hash)
+            args = args.to_hash
+          else
+            raise "Invalid parameter: #{args}. First parameter must respond to :to_hash."
+          end
+        end
+
+        args
+      end
+    end
+
+    # Search for the given resource. Auto-paginates (i.e. continues searching
+    # for records matching the given search args until all records have been
+    # retrieved) if no pagination options are given.
+    #
+    def _active_remote_search(args)
+      run_callbacks :search do
+        execute(:search, args)
+      end
+    end
+
+    # Reload this record from the remote service.
+    #
+    def reload
+      _active_remote_search(:guid => self.guid)
+      assign_attributes(last_response.to_hash)
+    end
+  end
+end

data/lib/active_remote/serialization.rb

@@ -0,0 +1,40 @@
+require 'active_remote/serializers/json'
+
+module ActiveRemote
+  module Serialization
+    def self.included(klass)
+      klass.class_eval do
+        include ::ActiveRemote::Serializers::JSON
+      end
+    end
+
+    # Examine the last response and add any errors to our internal errors
+    # list.
+    #
+    def add_errors_from_response
+      return unless last_response.respond_to?(:errors)
+
+      last_response.errors.each do |error|
+        if error.respond_to?(:message)
+          errors.add(error.field, error.message)
+        elsif error.respond_to?(:messages)
+          error.messages.each do |message|
+            errors.add(error.field, message)
+          end
+        end
+      end
+    end
+
+    # Examine the last response and serialize any records returned into Active
+    # Remote objects.
+    #
+    def serialize_records
+      return nil unless last_response.respond_to?(:records)
+
+      last_response.records.map do |record|
+        remote = self.class.new(record.to_hash)
+        remote
+      end
+    end
+  end
+end

data/lib/active_remote/serializers/json.rb

@@ -0,0 +1,18 @@
+module ActiveRemote
+  module Serializers
+    module JSON
+      # Returns a json representation of the whitelisted publishable attributes.
+      def as_json(options = {})
+        json_attributes = _publishable_attributes || attributes.keys
+
+        json_methods = json_attributes.reject { |attribute| attributes.key?(attribute) }
+        json_attributes -= json_methods
+
+        default_options = { :only => json_attributes, :methods => json_methods }
+        default_options.merge!(options)
+
+        super(default_options)
+      end
+    end
+  end
+end

data/lib/active_remote/serializers/protobuf.rb

@@ -0,0 +1,100 @@
+require 'protobuf_extensions/base_field'
+
+module ActiveRemote
+  module Serializers
+    module Protobuf
+      ATTRIBUTE_TYPES = {
+        ::Protobuf::Field::DoubleField => Float,
+        ::Protobuf::Field::FloatField => Float,
+        ::Protobuf::Field::Int32Field => Integer,
+        ::Protobuf::Field::Int64Field => Integer,
+        ::Protobuf::Field::Uint32Field => Integer,
+        ::Protobuf::Field::Uint64Field => Integer,
+        ::Protobuf::Field::Sint32Field => Integer,
+        ::Protobuf::Field::Sint64Field => Integer,
+        ::Protobuf::Field::Fixed32Field => Float,
+        ::Protobuf::Field::Fixed64Field => Float,
+        ::Protobuf::Field::Sfixed32Field => Float,
+        ::Protobuf::Field::Sfixed64Field => Float,
+        ::Protobuf::Field::StringField => String,
+        ::Protobuf::Field::BytesField => String,
+        ::Protobuf::Field::BoolField => ::ActiveAttr::Typecasting::Boolean,
+        :bool => ::ActiveAttr::Typecasting::Boolean,
+        :double => Float,
+        :float => Float,
+        :int32 => Integer,
+        :int64 => Integer,
+        :string => String
+      }.freeze
+
+      def self.included(klass)
+        klass.extend ::ActiveRemote::Serializers::Protobuf::ClassMethods
+      end
+
+      module ClassMethods
+        # Recursively build messages from a hash of attributes.
+        # TODO: Pull this functionality into the protobuf gem.
+        #
+        def build_message(message_class, attributes)
+          attributes.inject(message_class.new) do |message, (key, value)|
+            if field = message.get_field_by_name(key)
+
+              # Override the value based on the field type where issues
+              # exist in the protobuf gem.
+              #
+              if field.repeated?
+                collection = [ value ]
+                collection.flatten!
+                collection.compact!
+                collection.map! { |value| coerce(value, field) }
+                value = collection
+              else
+                value = coerce(value, field)
+              end
+
+              if field.message? && field.repeated?
+                value = value.map do |attributes|
+                  attributes.is_a?(Hash) ? build_message(field.type, attributes) : attributes
+                end
+              elsif field.message?
+                value = value.is_a?(Hash) ? build_message(field.type, value) : value
+              end
+
+              message.method("#{key}=").call(value)
+            end
+
+            message
+          end
+        end
+
+        def coerce(value, field)
+          return value if value.nil?
+          return value.to_i if field.enum?
+
+          protobuf_field_type = ::ActiveRemote::Serializers::Protobuf::ATTRIBUTE_TYPES[field.type]
+
+          case 
+          when protobuf_field_type == ::ActiveAttr::Typecasting::Boolean then
+            if value == 1
+              return true
+            elsif value == 0
+              return false
+            end
+          when protobuf_field_type == Integer then
+            return value.to_i
+          when protobuf_field_type == Float then
+            return value.to_f
+          when protobuf_field_type == String then
+            return value.to_s
+          end
+
+          return value
+        end
+      end
+
+      def build_message(message_class, attributes)
+        self.class.build_message(message_class, attributes)
+      end
+    end
+  end
+end

data/lib/active_remote/version.rb

@@ -0,0 +1,3 @@
+module ActiveRemote
+  VERSION = "1.2.1"
+end

data/lib/core_ext/date.rb

@@ -0,0 +1,7 @@
+Date.class_eval do
+  unless instance_methods.include?(:to_i)
+    def to_i
+      to_time.to_i
+    end
+  end
+end

data/lib/core_ext/date_time.rb

@@ -0,0 +1,7 @@
+DateTime.class_eval do
+  unless instance_methods.include?(:to_i)
+    def to_i
+      to_time.to_i
+    end
+  end
+end

data/lib/core_ext/integer.rb

@@ -0,0 +1,19 @@
+Integer.class_eval do
+  unless instance_methods.include?(:to_date)
+    def to_date
+      to_time.to_date
+    end
+  end
+  
+  unless instance_methods.include?(:to_datetime)
+    def to_datetime
+      to_time.to_datetime
+    end
+  end
+
+  unless instance_methods.include?(:to_time)
+    def to_time
+      Time.at(self)
+    end
+  end
+end

data/lib/protobuf_extensions/base_field.rb

@@ -0,0 +1,18 @@
+require 'protobuf'
+
+# A couple of helper fields.
+# Might make sense to create a patch for Protobuf.
+#
+Protobuf::Field::BaseField.class_eval do
+  unless respond_to?(:enum?)
+    def enum?
+      kind_of?(Protobuf::Field::EnumField)
+    end
+  end
+
+  unless respond_to?(:message?)
+    def message?
+      kind_of?(Protobuf::Field::MessageField)
+    end
+  end
+end

data/spec/core_ext/date_time_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe DateTime do
+
+  describe "#to_i" do
+    it "does not raise errors bj" do
+      expect {subject.to_i }.to_not raise_error
+    end
+  end
+end

data/spec/lib/active_remote/association_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe ActiveRemote::Association do
+  let(:record) { double(:record) }
+  let(:records) { [ record ] }
+
+  describe '.belongs_to' do
+    let(:author_guid) { 'AUT-123' }
+
+    subject { Post.new(:author_guid => author_guid) }
+    it { should respond_to(:author) }
+
+    it 'searches the associated model for a single record' do
+      Author.should_receive(:search).with(:guid => subject.author_guid).and_return(records)
+      subject.author.should eq record
+    end
+
+    it 'memoizes the result record' do
+      Author.should_receive(:search).once.with(:guid => subject.author_guid).and_return(records)
+      3.times { subject.author.should eq record }
+    end
+
+    context 'when the search is empty' do
+      it 'returns a nil' do
+        Author.should_receive(:search).with(:guid => subject.author_guid).and_return([])
+        subject.author.should be_nil
+      end
+    end
+  end
+
+  describe '.has_many' do
+    let(:records) { [ record, record, record ] }
+    let(:guid) { 'AUT-123' }
+
+    subject { Author.new(:guid => guid) }
+    it { should respond_to(:posts) }
+
+    it 'searches the associated model for all associated records' do
+      Post.should_receive(:search).with(:author_guid => subject.guid).and_return(records)
+      subject.posts.should eq records
+    end
+
+    it 'memoizes the result record' do
+      Post.should_receive(:search).once.with(:author_guid => subject.guid).and_return(records)
+      3.times { subject.posts.should eq records }
+    end
+
+    context 'when the search is empty' do
+      it 'returns the empty set' do
+        Post.should_receive(:search).with(:author_guid => subject.guid).and_return([])
+        subject.posts.should be_empty
+      end
+    end
+  end
+
+  describe '.has_one' do
+    let(:guid) { 'PST-123' }
+
+    subject { Post.new(:guid => guid) }
+    it { should respond_to(:category) }
+
+    it 'searches the associated model for all associated records' do
+      Category.should_receive(:search).with(:post_guid => subject.guid).and_return(records)
+      subject.category.should eq record
+    end
+
+    it 'memoizes the result record' do
+      Category.should_receive(:search).once.with(:post_guid => subject.guid).and_return(records)
+      3.times { subject.category.should eq record }
+    end
+
+    context 'when the search is empty' do
+      it 'returns a nil value' do
+        Category.should_receive(:search).with(:post_guid => subject.guid).and_return([])
+        subject.category.should be_nil
+      end
+    end
+  end
+
+end