rasti-app 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c24be9250ab6f65ffd3cc688760f7bb0b4799d7
-  data.tar.gz: 9c650eb527a592b8b2740920d4d0da99574638ff
+  metadata.gz: 3793dceedf42613f23ddee1725e14f152c97d6ce
+  data.tar.gz: 933deb25ee6be913c2013a277922262cef53d325
 SHA512:
-  metadata.gz: 904659322892ac6ca613284384cfdea9d954f31d49cdc4400faee610c4f1a943ad029bc93b409a99a4828a387132ae7750e59ae3db6baaf8ceb306ae804ff437
-  data.tar.gz: 6e2d6966e134d151b5630da1b196499cceeb075b44551e89926ab574f61b47a438930edc5e94e53ed9f81c6bfa045510fc15d4325b5fc564a08d39585fa535e9
+  metadata.gz: 5c467add607bc1afadb2ff9ab5c3eb46293fa33752b5b29a35c8d90c65bb3749e80e5187535d7daaeb50fdcb2e89a4fd8f17f7d83a5654c9697943cac8cfa561
+  data.tar.gz: e1ff86425b84a98621ce3563c81e34ffdd885c9edbf3d074d10bdaadc40e569d6ba935ecd8f8f21fa45098e25137b0044b77558a23c61f570e17be8816f3a2e6

data/lib/rasti/app.rb

@@ -17,51 +17,34 @@ module Rasti
 
     class << self
 
-      def permissions
-        @permissions ||= []
-      end
+      extend Forwardable
 
-      def valid_permission?(permission)
-        permission = Permission.new permission
-        permissions.any? { |p| permission.include? p }
-      end
+      def_delegators :facade, :interactions,
+                              :synchronic_interactions,
+                              :asynchronic_interactions,
+                              :permissions, 
+                              :valid_permission?
 
-      def classes_in(namespace, superclass=nil)
-        [].tap do |classes|
-          namespace.constants.each do |name|
-            constant = namespace.const_get name
-            if constant.class == Module
-              classes_in(constant, superclass).each { |c| classes << c }
-            elsif constant.class == Class && (superclass.nil? || constant.ancestors.include?(superclass))
-              classes << constant
-            end
-          end
-        end
-      end
+      attr_reader :facade
 
       private
 
-      def facade(namespace)
-        classes_in(namespace, Interaction).each do |interaction|
-          permission = interaction_permission interaction, namespace
-          permissions << permission
+      def expose(namespace)
+        @facade = Facade.new namespace
 
-          if !interaction.ancestors.include?(AsynchronicInteraction)
-            define_method permission.last_section do |params={}|
-              call interaction, permission, params
+        facade.interactions.each do |name, specification|
+          if specification.synchronic?
+            define_method name do |params={}|
+              call name, specification.permission, params
             end
           end
-          
-          define_method "enqueue_#{permission.last_section}" do |params={}|
-            enqueue interaction, permission, params
+
+          define_method "enqueue_#{name}" do |params={}|
+            enqueue name, specification.permission, params
           end
         end
       end
 
-      def interaction_permission(interaction, namespace)
-        Permission.new interaction.name.sub("#{namespace.name}::", '').split('::').map { |s| Inflecto.underscore s }
-      end
-
     end
 
     def initialize(container, context={})
@@ -77,19 +60,14 @@ module Rasti
       @policy ||= (container[:policy_class] || Policy).new container, context
     end
 
-    def call(interaction, permission, params)
+    def call(name, permission, params={})
       authorize! permission, params
-      interaction.new(container, context).call(params)
+      self.class.facade.call name, container, context, params
     end
 
-    def enqueue(interaction, permission, params)
+    def enqueue(name, permission, params={})
       authorize! permission, params
-
-      Job.enqueue queue:       params.delete(:queue) || Asynchronic.default_queue,
-                  alias:       interaction,
-                  interaction: interaction,
-                  context:     context,
-                  params:      interaction.build_form(params).attributes
+      self.class.facade.enqueue name, context, params
     end
 
     def authorize!(permission, params)

data/lib/rasti/app/asynchronic_interaction.rb

@@ -2,6 +2,10 @@ module Rasti
   class App
     class AsynchronicInteraction < Interaction
 
+      def self.asynchronic?
+        true
+      end      
+
       private
 
       def job

data/lib/rasti/app/delegable.rb

@@ -0,0 +1,33 @@
+module Rasti
+  class App
+    module Delegable
+
+      def methods(*args)
+        delegated_methods | super
+      end
+
+      def public_methods(*args)
+        delegated_methods | super
+      end
+
+      private
+
+      def delegated_method?(method_name)
+        delegated_methods.include? method_name.to_sym
+      end
+
+      def method_missing(method_name, *args, &block)
+        if delegated_method? method_name
+          call_delegated_method method_name, *args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, *args)
+        delegated_method?(method_name) || super
+      end
+
+    end
+  end
+end

data/lib/rasti/app/facade.rb

@@ -0,0 +1,118 @@
+module Rasti
+  class App
+    class Facade
+
+      class UndefinedInteraction < StandardError
+        def initialize(name)
+          super "Undefined interaction #{name}"
+        end
+      end
+
+
+      class InteractionSpecification
+
+        attr_reader :interaction, :namespace
+
+        def initialize(interaction, namespace)
+          @interaction = interaction
+          @namespace = namespace
+        end
+
+        def name
+          permission.last_section.to_sym
+        end
+
+        def permission
+          @permission ||= Permission.new interaction.name.sub("#{namespace.name}::", '').split('::').map { |s| Inflecto.underscore s }
+        end
+
+        def asynchronic?
+          interaction.asynchronic?
+        end
+
+        def synchronic?
+          !asynchronic?
+        end
+
+      end
+
+
+      class SynchronicInteractionsFactory
+
+        include Delegable
+
+        def initialize(facade, container, context)
+          @facade = facade
+          @container = container
+          @context = context
+        end
+
+        private
+
+        attr_reader :facade, :container, :context
+
+        def delegated_methods
+          facade.synchronic_interactions.keys
+        end
+
+        def call_delegated_method(method_name, *args, &block)
+          facade.call method_name, container, context, *args
+        end
+
+      end
+
+
+      attr_reader :interactions
+
+      def initialize(namespace)
+        @interactions = Utils.classes_in(namespace, Interaction).each_with_object({}) do |interaction, hash|
+          specificaiton = InteractionSpecification.new interaction, namespace
+          hash[specificaiton.name] = specificaiton
+        end
+      end
+
+      def call(name, container, context, params={})
+        interaction_class(name).new(container, context).call(params)
+      end
+
+      def enqueue(name, context, params={})
+        interaction = interaction_class name
+        
+        Job.enqueue queue:       params.delete(:queue) || Asynchronic.default_queue,
+                    alias:       interaction,
+                    interaction: interaction,
+                    context:     context,
+                    params:      interaction.build_form(params).attributes
+      end
+
+      def synchronic_interactions
+        interactions.select { |k,v| v.synchronic? }
+      end
+
+      def asynchronic_interactions
+        interactions.select { |k,v| v.asynchronic? }
+      end
+
+      def permissions
+        interactions.values.map(&:permission).sort
+      end
+
+      def valid_permission?(permission)
+        permission = Permission.new permission
+        permissions.any? { |p| permission.include? p }
+      end
+
+      def synchronic_interactions_factory(container, context)
+        SynchronicInteractionsFactory.new self, container, context
+      end
+
+      private
+
+      def interaction_class(name)
+        raise UndefinedInteraction, name unless interactions.key?(name.to_sym)
+        interactions[name.to_sym].interaction
+      end
+
+    end
+  end
+end

data/lib/rasti/app/interaction.rb

@@ -8,6 +8,10 @@ module Rasti
         constants.include?(:Form) ? const_get(:Form).new(params) : Form.new
       end
 
+      def self.asynchronic?
+        false
+      end      
+
       def initialize(container, context)
         @container = container
         @context = context

data/lib/rasti/app/utils.rb

@@ -0,0 +1,22 @@
+module Rasti
+  class App
+    class Utils
+      class << self
+
+        def classes_in(namespace, superclass=nil)
+          [].tap do |classes|
+            namespace.constants.each do |name|
+              constant = namespace.const_get name
+              if constant.class == Module
+                classes_in(constant, superclass).each { |c| classes << c }
+              elsif constant.class == Class && (superclass.nil? || constant.ancestors.include?(superclass))
+                classes << constant
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/app/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   class App
-    VERSION = '0.0.4'
+    VERSION = '0.0.5'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-app
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-29 00:00:00.000000000 Z
+date: 2017-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: inflecto
@@ -238,6 +238,8 @@ files:
 - lib/rasti/app.rb
 - lib/rasti/app/asynchronic_interaction.rb
 - lib/rasti/app/container.rb
+- lib/rasti/app/delegable.rb
+- lib/rasti/app/facade.rb
 - lib/rasti/app/interaction.rb
 - lib/rasti/app/job.rb
 - lib/rasti/app/permission.rb
@@ -245,6 +247,7 @@ files:
 - lib/rasti/app/service.rb
 - lib/rasti/app/service_factory.rb
 - lib/rasti/app/settings.rb
+- lib/rasti/app/utils.rb
 - lib/rasti/app/version.rb
 - rasti-app.gemspec
 - spec/coverage_helper.rb