roda-component 0.0.10 → 0.1.0

data/lib/roda/component/faye.rb

@@ -16,6 +16,8 @@ if RUBY_ENGINE == 'opal'
         alias_native :set_header, :setHeader
         alias_native :add_extension, :addExtension
 
+        attr_accessor :disconnected, :online
+
         def initialize url
           super `new Faye.Client(#{url})`
           set_header 'X-CSRF-TOKEN', Element.find('meta[name=_csrf]').attr('content')
@@ -34,9 +36,11 @@ if RUBY_ENGINE == 'opal'
         end
 
         def incoming message, block
-          msg = Native(message)
+          # puts '====INCOMING===='
+          # `console.log(#{message})`
+          # puts '================'
 
-          if (!@public_id && !@private_id) && msg[:channel] == '/meta/handshake'
+          if (!@public_id && !@private_id) && message[:channel] == '/meta/handshake'
             subscribe "/components/incoming/#{private_id}/#{public_id}" do |data|
               data     = Native(data)
               event_id = data[:event_id]
@@ -55,7 +59,14 @@ if RUBY_ENGINE == 'opal'
             message = #{message}
             message.ext = message.ext || {};
             message.ext.csrfToken = $('meta[name=_csrf]').attr('content');
+            message.ext.public_id = #{public_id};
+            message.ext.private_id = #{private_id};
           }
+
+          # puts '====OUTGOING===='
+          # `console.log(#{message})`
+          # puts '================'
+
           block.call message
         end
 
@@ -70,20 +81,29 @@ if RUBY_ENGINE == 'opal'
   end
 else
   require 'faye'
-  require 'roda/component/ohm'
-  require 'roda/component/models/user'
-  require 'roda/component/models/channel'
+  require 'redic'
 
   class Roda
     class Component
       class Faye
         class CsrfProtection
           def incoming(message, request, callback)
-            session_token = request.session['csrf.token']
-            message_token = message['ext'] && message['ext'].delete('csrfToken')
+            case message['channel']
+            when '/meta/connect', '/meta/handshake', '/meta/subscribe', '/meta/disconnect', '/meta/unsubscribe'
+              session_token = request.session['csrf.token']
+              message_token = message['ext'] && message['ext'].delete('csrfToken')
+
+              unless session_token == message_token
+                message['error'] = '401::Access denied'
+              end
+            else
+              app_token     = Roda::Component.app.component_opts[:token]
+              message_token = message['data'] && message['data'].delete('token')
 
-            unless session_token == message_token
-              message['error'] = '401::Access denied'
+
+              unless app_token == message_token
+                message['error'] = '401::Access denied'
+              end
             end
 
             callback.call(message)
@@ -91,37 +111,114 @@ else
         end
 
         class ChannelManager
-          def incoming(message, request, callback)
-            app = get_app(request)
-
-            if data = message['data']
-              case data['type']
-              when 'event'
-                options = { local: data['local'] }
-                data['event_type'] == 'call' \
-                  ? options[:call] = data['event_method'] \
-                  : options[:trigger] = data['event_method']
-
-                message['data']['local'] = app.roda_component(:"#{data['name']}", options)
-                message['channel']       = message['channel'].gsub(/outgoing/, 'incoming')
+          def redis
+            @redis ||= Redic.new(Roda::Component.app.component_opts[:redis_uri])
+          end
+
+          def incoming(message, r, callback)
+            r.env['RODA_COMPONENT_FROM_FAYE'] = true
+            r.env['HTTP_X_RODA_COMPONENT_ON_SERVER'] = true
+
+            app = get_app(r)
+
+            session_id = r.session['session_id']
+            public_id  = message['ext'] && message['ext']['public_id']
+            private_id = message['ext'] && message['ext'].delete('private_id')
+            key        = "#{app.component_opts[:redis_namespace]}users:#{session_id}"
+
+            case message['channel']
+            when '/meta/connect'
+              if session_id
+                redis.call 'HSET', "#{key}/ids", private_id, public_id
+                # puts redis.call 'HGETALL', "#{key}/ids"
+              end
+              callback.call message
+            when '/meta/disconnect'
+              callback.call message
+
+              redis.call 'DEL', "#{key}/ids"
+              channels = redis.call 'GET', "#{key}/channels/#{public_id}"
+              channels = channels ? JSON.parse(channels) : []
+
+              channels.each do |channel|
+                send_sub_to({
+                  'channel'      => '/meta/unsubscribe',
+                  'subscription' => channel,
+                  'ext'          => message['ext']
+                }, public_id, private_id, app, key, r)
+              end
+
+              redis.call 'DEL', "#{key}/channels/#{public_id}"
+            when '/meta/subscribe', '/meta/unsubscribe'
+              if message['subscription'][%r{\A/components/}]
+                callback.call message
+                send_sub_to message, public_id, private_id, app, key, r
+              end
+            else
+              if data = message['data']
+                case data['type']
+                when 'event'
+                  options ||= {}
+                  options.merge! data['local']
+
+                  data['event_type'] == 'call' \
+                    ? options[:call]    = data['event_method'] \
+                    : options[:trigger] = data['event_method']
+
+                  begin
+                    message['data']['local'] = app.roda_component(:"#{data['name']}", options)
+                    message['channel']       = message['channel'].gsub(/outgoing/, 'incoming')
+                  rescue Exception => e
+                    #fix: faye extentions are capturing errors for some reason
+                    ap e.message
+                    ap e.message.inspect
+                  end
+                end
               end
+
+              callback.call message
             end
+          end
 
-            callback.call message
+          def send_sub_to message, public_id, private_id, app, key, request
+            key = "#{key}/channels/#{public_id}"
+
+            joining = message['channel'] == '/meta/subscribe' ? true : false
+
+            component_name = message['subscription'].split('/').last
+
+            channels = redis.call 'GET', key
+            channels = channels ? JSON.parse(channels) : []
+
+            if joining
+              channels << message['subscription']
+            else
+              channels.delete message['subscription']
+            end
+
+            if channels.length
+              redis.call 'SET', key, channels.to_json
+            end
+
+            data = app.roda_component(:"#{component_name}", { trigger: (joining ? :join : :leave), public_id: public_id, private_id: private_id })
+
+            client = ::Faye::Client.new("#{request.env['HTTP_ORIGIN']}/faye")
+            client.set_header 'X-CSRF-TOKEN', message['ext']['csrfToken']
+            client.publish "/components/#{component_name}", type: (joining ? 'join' : 'leave'), public_id: public_id, token: app.component_opts[:token], local: data
           end
 
           # /components/:id/:comp/:action
-          # def outgoing(message, request, callback)
-          #   app = get_app request
-          #
-          #   # message[:data] = app.roda_component(:auth, call: :cow) || false
-          #
-          #   ap '====OUTGOING===='
-          #   ap message
-          #   ap '================'
-          #
-          #   callback.call message
-          # end
+          def outgoing(message, request, callback)
+            app = get_app request
+
+            # message[:data] = app.roda_component(:auth, call: :cow) || false
+
+            # ap '====OUTGOING===='
+            # ap message
+            # ap '================'
+
+            callback.call message
+          end
 
           def get_app request
             request.env['RODA_COMPONENT_FROM_FAYE'] = true

data/lib/roda/component/form.rb

@@ -0,0 +1,64 @@
+require 'roda/component/form/validations'
+
+class Roda
+  class Component
+    class Form
+      include Validations
+
+      # Initialize with a hash of attributes and values.
+      # If extra attributes are sent, a NoMethodError exception will be raised.
+      #
+      # @example
+      #
+      #   class EditPost < Scrivener
+      #     attr_accessor :title
+      #     attr_accessor :body
+      #
+      #     def validate
+      #       assert_present :title
+      #       assert_present :body
+      #     end
+      #   end
+      #
+      #   edit = EditPost.new(title: "Software Tools")
+      #
+      #   edit.valid? #=> false
+      #
+      #   edit.errors[:title] #=> []
+      #   edit.errors[:body]  #=> [:not_present]
+      #
+      #   edit.body = "Recommended reading..."
+      #
+      #   edit.valid? #=> true
+      #
+      #   # Now it's safe to initialize the model.
+      #   post = Post.new(edit.attributes)
+      #   post.save
+      def initialize(atts)
+        atts.each do |key, val|
+          send(:"#{key}=", val)
+        end
+      end
+
+      # Return hash of attributes and values.
+      def attributes
+        Hash.new.tap do |atts|
+          instance_variables.each do |ivar|
+            next if ivar == :@errors
+
+            att = ivar[1..-1].to_sym
+            atts[att] = send(att)
+          end
+        end
+      end
+
+      def slice(*keys)
+        Hash.new.tap do |atts|
+          keys.each do |att|
+            atts[att] = send(att)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roda/component/form/validations.rb

@@ -0,0 +1,204 @@
+class Roda
+  class Component
+    class Form
+      # Provides a base implementation for extensible validation routines.
+      # {Scrivener::Validations} currently only provides the following assertions:
+      #
+      # * assert
+      # * assert_present
+      # * assert_format
+      # * assert_numeric
+      # * assert_url
+      # * assert_email
+      # * assert_member
+      # * assert_length
+      # * assert_decimal
+      # * assert_equal
+      #
+      # The core tenets that Scrivener::Validations advocates can be summed up in a
+      # few bullet points:
+      #
+      # 1. Validations are much simpler and better done using composition rather
+      #    than macros.
+      # 2. Error messages should be kept separate and possibly in the view or
+      #    presenter layer.
+      # 3. It should be easy to write your own validation routine.
+      #
+      # Other validations are simply added on a per-model or per-project basis.
+      #
+      # @example
+      #
+      #   class Quote
+      #     attr_accessor :title
+      #     attr_accessor :price
+      #     attr_accessor :date
+      #
+      #     def validate
+      #       assert_present :title
+      #       assert_numeric :price
+      #       assert_format  :date, /\A[\d]{4}-[\d]{1,2}-[\d]{1,2}\z
+      #     end
+      #   end
+      #
+      #   s = Quote.new
+      #   s.valid?
+      #   # => false
+      #
+      #   s.errors
+      #   # => { :title => [:not_present],
+      #          :price => [:not_numeric],
+      #          :date  => [:format] }
+      #
+      module Validations
+
+        # Check if the current model state is valid. Each call to {#valid?} will
+        # reset the {#errors} array.
+        #
+        # All validations should be declared in a `validate` method.
+        #
+        # @example
+        #
+        #   class Login
+        #     attr_accessor :username
+        #     attr_accessor :password
+        #
+        #     def validate
+        #       assert_present :user
+        #       assert_present :password
+        #     end
+        #   end
+        #
+        def valid?
+          errors.clear
+          validate
+          errors.empty?
+        end
+
+        # Base validate implementation. Override this method in subclasses.
+        def validate
+        end
+
+        # Hash of errors for each attribute in this model.
+        def errors
+          @errors ||= Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        protected
+
+        # Allows you to do a validation check against a regular expression.
+        # It's important to note that this internally calls {#assert_present},
+        # therefore you need not structure your regular expression to check
+        # for a non-empty value.
+        #
+        # @param [Symbol] att The attribute you want to verify the format of.
+        # @param [Regexp] format The regular expression with which to compare
+        #                 the value of att with.
+        # @param [Array<Symbol, Symbol>] error The error that should be returned
+        #                                when the validation fails.
+        def assert_format(att, format, error = [att, :format])
+          if assert_present(att, error)
+            assert(send(att).to_s.match(format), error)
+          end
+        end
+
+        # The most basic and highly useful assertion. Simply checks if the
+        # value of the attribute is empty.
+        #
+        # @param [Symbol] att The attribute you wish to verify the presence of.
+        # @param [Array<Symbol, Symbol>] error The error that should be returned
+        #                                when the validation fails.
+        def assert_present(att, error = [att, :not_present])
+          assert(!send(att).to_s.empty?, error)
+        end
+
+        # Checks if all the characters of an attribute is a digit.
+        #
+        # @param [Symbol] att The attribute you wish to verify the numeric format.
+        # @param [Array<Symbol, Symbol>] error The error that should be returned
+        #                                when the validation fails.
+        def assert_numeric(att, error = [att, :not_numeric])
+          if assert_present(att, error)
+            assert_format(att, /\A\-?\d+\z/, error)
+          end
+        end
+
+        URL = /\A(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(2 5[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3} |localhost)(:[0-9]{1,5})?(\/.*)?\z/i
+
+        def assert_url(att, error = [att, :not_url])
+          if assert_present(att, error)
+            assert_format(att, URL, error)
+          end
+        end
+
+        EMAIL = /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/i
+
+        def assert_email(att, error = [att, :not_email])
+          if assert_present(att, error)
+            assert_format(att, EMAIL, error)
+          end
+        end
+
+        def assert_member(att, set, err = [att, :not_valid])
+          assert(set.include?(send(att)), err)
+        end
+
+        def assert_length(att, range, error = [att, :not_in_range])
+          if assert_present(att, error)
+            val = send(att).to_s
+            assert range.include?(val.length), error
+          end
+        end
+
+        DECIMAL = /\A\-?(\d+)?(\.\d+)?\z/
+
+        def assert_decimal(att, error = [att, :not_decimal])
+          assert_format att, DECIMAL, error
+        end
+
+        # Check that the attribute has the expected value. It uses === for
+        # comparison, so type checks are possible too. Note that in order
+        # to make the case equality work, the check inverts the order of
+        # the arguments: `assert_equal :foo, Bar` is translated to the
+        # expression `Bar === send(:foo)`.
+        # 
+        # @example
+        # 
+        #   def validate
+        #     assert_equal :status, "pending"
+        #     assert_equal :quantity, Fixnum
+        #   end
+        #
+        # @param [Symbol] att The attribute you wish to verify for equality.
+        # @param [Object] value The value you want to test against.
+        # @param [Array<Symbol, Symbol>] error The error that should be returned
+        #                                when the validation fails.
+        def assert_equal(att, value, error = [att, :not_equal])
+          assert value === send(att), error
+        end
+
+        # The grand daddy of all assertions. If you want to build custom
+        # assertions, or even quick and dirty ones, you can simply use this method.
+        #
+        # @example
+        #
+        #   class CreatePost
+        #     attr_accessor :slug
+        #     attr_accessor :votes
+        #
+        #     def validate
+        #       assert_slug :slug
+        #       assert votes.to_i > 0, [:votes, :not_valid]
+        #     end
+        #
+        #   protected
+        #     def assert_slug(att, error = [att, :not_slug])
+        #       assert send(att).to_s =~ /\A[a-z\-0-9]+\z/, error
+        #     end
+        #   end
+        def assert(value, error)
+          value or errors[error.first].push(error.last) && false
+        end
+      end
+    end
+  end
+end