ribbon-intercom 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbc66058ef3f67f202ae929f759b20a1ca45a0f7
-  data.tar.gz: d5eee408147e0cf447120c6f2ee8150cba30cec9
+  metadata.gz: c41ac1f0f1b5608ce40ce2610cc29cf28a8d7bc6
+  data.tar.gz: d975fe767bcc9bc0cc9bd3a6da43ba81b8054c88
 SHA512:
-  metadata.gz: ed1f4b07d38b1fca0657cc08ec4fac171ae9fc65a7132f9afe4f46a9043d6104d4fec26ade902ab93bed155102365fdf56518dfbf93b0a2695805173b8d834b3
-  data.tar.gz: 723e68476ea49afd0cf055e2ce6adcfb8636ea6c7d12625abfa9ff2486a1502bc4507af01a7fbfc5f4d8935ee1b0bc82de2a9e223547e99ec9513a6cd9e8fe81
+  metadata.gz: e5f12d2757fa4c8a1e1343df7b44ae31228d5a24572a6bfafba6356eacbb362f65d5530e778f68af3fafe9d99aef2fb4f672783b8b924d1ea29009a1bcb351a4
+  data.tar.gz: 44453cbf103d87a761d25b92934c501bc09c96b5a85d4cca97675303dd8c87cd65c7fd8c944a8de0fbdba45cc1b5cdde170aa8ca4c06c22dd7f508ff721ec1a1

data/lib/ribbon/intercom/client/sdk.rb

@@ -84,7 +84,7 @@ module Ribbon::Intercom
       def _process_response(packet)
         _handle_response_error(packet) if packet.error?
 
-        _init_packages(packet.retval)
+        Package.init_packages(packet.retval, self)
         packet
       end
 
@@ -94,20 +94,6 @@ module Ribbon::Intercom
         raise 'packet contains no error' unless packet.error?
         raise packet.error
       end
-
-      ##
-      # Walks the object and initializes all packages (i.e., sets them up to be
-      # accessed by the end-user on the client).
-      def _init_packages(object)
-        Utils.walk(object) { |object|
-          if object.is_a?(Package)
-            object.sdk = dup
-            object.mock_safe! if mock_safe?
-          end
-
-          object
-        }
-      end
     end # SDK
   end # Client
 end # Ribbon::Intercom

data/lib/ribbon/intercom/package.rb

@@ -4,6 +4,49 @@ module Ribbon::Intercom
   class Package
     include Utils::Mixins::MockSafe
 
+    class << self
+      ##
+      # Package up any non-basic objects that include Packageable::Mixin.
+      def package(subject)
+        Utils.walk(subject) { |subject, context|
+          if Utils.basic_type?(subject)
+            subject
+          elsif context == :hash_key
+            # Hash keys must be basic types.
+            raise Errors::UnsafeResponseError, subject.inspect
+          elsif subject.is_a?(Packageable::Mixin)
+            _package_obj(subject, package(subject.package_data))
+          elsif subject.is_a?(Class) && subject < Packageable::Mixin
+            _package_obj(subject)
+          else
+            raise Errors::UnsafeResponseError, subject.inspect
+          end
+        }
+      end
+
+      def _package_obj(subject, data=nil)
+        new(encode_subject(subject), data)
+      end
+
+      def encode_subject(subject)
+        Marshal.dump(subject)
+      end
+
+      def decode_subject(encoded_subject)
+        Marshal.load(encoded_subject)
+      end
+
+      ##
+      # Walks the object and initializes all packages (i.e., sets them up to be
+      # accessed by the end-user on the client).
+      def init_packages(object, sdk)
+        Utils.walk(object) { |object|
+          object.send(:_init, sdk) if object.is_a?(Package)
+          object
+        }
+      end
+    end # Class Methods
+
     attr_reader :sdk
 
     def initialize(subject_data=nil, data=nil)
@@ -11,10 +54,11 @@ module Ribbon::Intercom
       @_data = data
     end
 
-    def sdk=(sdk)
-      @sdk = sdk
-    end
-
+    ##
+    # Begin a method chain (must be completed with `#end`).
+    #
+    # When `#end` is called on the method chain, the chain will be resolved
+    # remotely. This allows the chain of methods to be executed in one round-trip.
     def begin
       Utils::MethodChain.begin { |methods|
         queue = Packet::MethodQueue.new
@@ -29,12 +73,26 @@ module Ribbon::Intercom
       if @_data && @_data.key?(meth)
         @_data[meth]
       elsif sdk
-        _send_method_queue(Packet::MethodQueue.new.enqueue(meth, *args))
+        _call(meth, *args)
       else
         super
       end
     end
 
+    ##
+    # Call a method on the subject remotely.
+    def _call(method_name, *args)
+      _send_method_queue(Packet::MethodQueue.new.enqueue(method_name, *args))
+    end
+
+    ##
+    # Initializes the package on the client-side.
+    def _init(sdk)
+      @sdk = sdk
+      self.class.init_packages(@_data, sdk)
+      mock_safe! if sdk.mock_safe?
+    end
+
     def _send_method_queue(method_queue)
       _process_response(
         sdk.send_packet(
@@ -55,7 +113,7 @@ module Ribbon::Intercom
 
     def _process_response(packet)
       @_subject_data = packet.subject
-      @_data = packet.package_data
+      @_data = self.class.init_packages(packet.package_data, sdk)
 
       packet.retval
     end

data/lib/ribbon/intercom/packageable/mixin.rb

@@ -22,9 +22,7 @@ module Ribbon::Intercom
       ##
       # Returns the package data for the instance as a hash.
       def package_data
-        Utils.sanitize(
-          self.class._package_with_methods.map { |meth| [meth, public_send(meth)] }.to_h
-        )
+        self.class._package_with_methods.map { |meth| [meth, public_send(meth)] }.to_h
       end
     end # Mixin
   end # Service::Subject

data/lib/ribbon/intercom/service.rb

@@ -66,8 +66,19 @@ module Ribbon::Intercom
       store.lookup_channel(token)
     end
 
+    ##
+    # Check that the channel has sufficient permissions to call the method.
+    #
+    # The `send` method is forbidden because it breaks the encapsulation guaranteed
+    # by intercom (i.e., private methods can't be called).
+    #
+    # In addition to the permissions granted to the channel, all channels have
+    # implicit permission to call public methods on basic types.
     def sufficient_permissions?(base, intercom_method)
-      Utils.basic_type?(base) || channel.may?(Utils.method_identifier(base, intercom_method))
+      intercom_method != :send && (
+        Utils.basic_type?(base) ||
+        channel.may?(Utils.method_identifier(base, intercom_method))
+      )
     end
 
     def call(env)
@@ -123,7 +134,7 @@ module Ribbon::Intercom
 
     def _load_subject
       if (encoded_subject=request_packet.subject) && !encoded_subject.empty?
-        @subject = _decode_subject(encoded_subject)
+        @subject = Package.decode_subject(encoded_subject)
         _error!(Errors::InvalidSubjectSignatureError) unless @subject
       else
         @subject = self
@@ -150,7 +161,7 @@ module Ribbon::Intercom
         base = base.public_send(meth, *args)
       }
 
-      _package(base)
+      Package.package(base)
     rescue NoMethodError => error
       if error.name == intercom_method
         _error!(Errors::InvalidMethodError, intercom_method)
@@ -173,11 +184,11 @@ module Ribbon::Intercom
       Packet.new.tap { |packet|
         unless self == subject # Order matters here! See: issue#52
           # Need to send subject back in case it was modified by the methods.
-          packet.subject = _encode_subject(subject)
+          packet.subject = Package.encode_subject(subject)
 
           if subject.is_a?(Packageable::Mixin)
             # Need to send the package data back in case it changed, too.
-            packet.package_data = subject.package_data
+            packet.package_data = Package.package(subject.package_data)
           end
         end
 
@@ -189,42 +200,6 @@ module Ribbon::Intercom
       _respond!(status, {}, packet.encode)
     end
 
-    ##
-    # Package up any non-basic objects that include Packageable::Mixin.
-    def _package(object)
-      Utils.walk(object) { |object, context|
-        if Utils.basic_type?(object)
-          object
-        elsif context == :hash_key
-          # Hash keys must be basic types.
-          _error!(Errors::UnsafeResponseError, object.inspect)
-        elsif object.is_a?(Packageable::Mixin)
-          _package_obj(object, object.package_data)
-        elsif object.is_a?(Class) && object < Packageable::Mixin
-          _package_obj(object)
-        else
-          _error!(Errors::UnsafeResponseError, object.inspect)
-        end
-      }
-    end
-
-    def _package_obj(object, data=nil)
-      Package.new(_encode_subject(object), data)
-    end
-
-    ##
-    # Marshal dumps the subject and signs the resulting bytes with the channel.
-    def _encode_subject(subject)
-      channel.sign(Marshal.dump(subject))
-    end
-
-    ##
-    # Decodes the subject sent from the client.
-    def _decode_subject(encoded_subject)
-      marshalled_subject = channel.verify(encoded_subject)
-      marshalled_subject && Marshal.load(marshalled_subject)
-    end
-
     def _request_authenticated?
       auth = Rack::Auth::Basic::Request.new(env)
 

data/lib/ribbon/intercom/version.rb

@@ -1,5 +1,5 @@
 module Ribbon
   module Intercom
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ribbon-intercom
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Robert Honer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack