opal-connect 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de60747b1ade488a697ae66c25931d1bad6dd5c5
-  data.tar.gz: 2bc80456910377dadeff20ebada2a9b8c3a3a13a
+  metadata.gz: b52883ea798fba1bc5ef8e7e3b77083fe082634e
+  data.tar.gz: 055c956583030f66affcd36a84e96f0cb498d0d6
 SHA512:
-  metadata.gz: 4cbfab39d084eaaf3eb6848155bff391a3734efa802bb14a7ac90f48fd3cb69f28bdfe60acc16c48db63f461da2b8081f2a26446bb9c97ba744e4675676b0f3a
-  data.tar.gz: b6e9af69f0aa91683401b01788efecdd6b1cc13e55df4722a5197ae49ba3c4f1e781261a3d51a31c29c5660b5fcc1fc485dc330935e7848169685673c1452c1a
+  metadata.gz: 872c395c0bdfbc176ee10d55374318f94ef063151af77143135f6d600c88e79651bebfb15d0c3d5f41406e1bd40a0ebf40834fdb1df052791f04f3959e3a477e
+  data.tar.gz: 88a527535fc13204d3d95588fd6f56692f405ee1b27a42d786da5e4d7cd565eb1f3ccce3ff7e36555081bed5db53bd92b06a4da0b4cc9edfe307288c0b221915

data/Rakefile

@@ -1,2 +1 @@
 require "bundler/gem_tasks"
-

data/lib/opal/connect/plugins/abilities.rb

@@ -0,0 +1,79 @@
+unless RUBY_ENGINE == 'opal'
+  require 'yaml'
+  Opal.use_gem 'ability_list'
+end
+
+require 'ability_list'
+
+module Opal::Connect
+  module ConnectPlugins
+    module Abilities
+      def self.load_dependencies(connect, *args)
+        connect.plugin :current_user
+      end
+
+      def self.configure(connect, options = false)
+        if options
+          unless RUBY_ENGINE == 'opal'
+            if file = options[:file]
+              options[:list] = YAML.load_file file
+            end
+          end
+
+          connect.options[:abilities] = options
+        end
+      end
+
+      ConnectJavascript = -> do
+        if current_user.respond_to?(:id) && current_user.id
+          abilities = Opal::Connect.options[:abilities][:list][current_user.role]
+          "$current_user_abilities = Base64.decode64('#{Base64.encode64 abilities.to_json}')"
+        else
+          "$current_user_abilities = {}"
+        end
+      end
+
+      module InstanceMethods
+        def load_abilities(user, scope)
+          # make sure the user is logged in
+          return unless user.respond_to?(:id) && user.id
+
+          abilities = RUBY_ENGINE == 'opal' \
+            ? $current_user_abilities \
+            : Opal::Connect.options[:abilities][:list][user.role]
+
+          Abilities.process abilities['can'], :can, scope, user
+          Abilities.process abilities['cannot'], :can, scope, user
+        end
+      end
+
+      def self.process(abilities, type, scope, user)
+        (abilities || []).each do |ability|
+          obj = get_object(ability['object'])
+
+          if method = ability['method']
+            scope.send type, ability['action'].to_sym, obj do |record|
+              scope.send(method, record)
+            end
+          else
+            scope.send type, ability['action'].to_sym, obj
+          end
+        end
+      end
+
+      def self.get_object(obj)
+        if RUBY_ENGINE == 'opal'
+          obj.to_sym
+        else
+          if obj[0,1] == obj[0,1].upcase
+            Object.const_get(obj)
+          else
+            obj.to_sym
+          end
+        end
+      end
+    end
+
+    register_plugin :abilities, Abilities
+  end
+end

data/lib/opal/connect/plugins/current_user.rb

@@ -0,0 +1,43 @@
+require 'ostruct'
+
+module Opal
+  module Connect
+    module ConnectPlugins
+      module CurrentUser
+        def self.load_dependencies(connect, *args)
+          connect.plugin :scope
+        end
+
+        def self.configure(connect, options = false)
+          if options
+            unless RUBY_ENGINE == 'opal'
+              Connect::CLIENT_OPTIONS << 'current_user'
+              connect.options[:plugin_requires] << options[:class_path]
+              require options[:class_path]
+            end
+
+            connect.options[:current_user] = options
+          end
+        end
+
+        ConnectJavascript = -> do
+          "$current_user = Base64.decode64('#{Base64.encode64 current_user.to_h.to_json}')"
+        end
+
+        module InstanceMethods
+          def current_user
+            @current_user ||= Object.const_get(Connect.options[:current_user][:class]).new(OpenStruct.new begin
+              if RUBY_ENGINE == 'opal'
+                $current_user || {}
+              else
+                scope.instance_exec(&Connect.options[:current_user][:authenticate]) || {}
+              end
+            end)
+          end
+        end
+      end
+
+      register_plugin :current_user, CurrentUser
+    end
+  end
+end

data/lib/opal/connect/plugins/events.rb

@@ -29,8 +29,9 @@ module Opal
                 selector = "#{events_dom} #{selector}"
               end
 
-              handler = proc { |evt| __send__(method, evt) } if method
-              event   = [name, selector, handler]
+              klass   = self
+              handler = proc { |evt| klass.new.__send__(method, evt) } if method
+              event   = [klass, name, selector, handler]
               connect_events << event unless connect_events.include? event
             end
           end
@@ -43,7 +44,7 @@ module Opal
                 el = dom('html')
 
                 events.each do |event|
-                  name, selector, wrapper = event
+                  _, name, selector, wrapper = event
                   if name.to_s != 'document'
                     el.off(name, selector, &wrapper)
                   else
@@ -59,11 +60,13 @@ module Opal
                 el = dom('html')
 
                 events.map! do |event|
-                  name, selector, handler = event
-                  wrapper = proc do |e|
+                  klass, name, selector, handler = event
+                  c = klass.name == 'Opal::Connect' ? klass : klass.new
+
+                  wrapper = ->(e) do
                     # gives you access to this, like jquery
-                    @this = dom(e.current_target)
-                    instance_exec(e, &handler)
+                    c.instance_variable_set(:@this, dom(e.current_target))
+                    c.instance_exec(e, &handler)
                   end
 
                   if name.to_s != 'document'
@@ -71,7 +74,8 @@ module Opal
                   else
                     Document.on(selector, &wrapper)
                   end
-                  [name, selector, wrapper]
+
+                  [klass, name, selector, wrapper]
                 end
               end
             end

data/lib/opal/connect/plugins/pjax.rb

@@ -0,0 +1,48 @@
+module Opal::Connect
+  module ConnectPlugins
+    module Pjax
+      def self.load_dependencies(connect)
+        connect.plugin :events
+      end
+
+      if RUBY_ENGINE == 'opal'
+        `require('expose?$!expose?Pjax!pjax')`
+        `require('expose?$!expose?NProgress!nprogress')`
+        `require('nprogress/nprogress.css')`
+
+        ConnectSetup = -> do
+          on(:document, 'pjax:send')     { `NProgress.start(); NProgress.inc()` }
+          on(:document, 'pjax:complete') { `NProgress.done()` }
+
+          $pjax = Native(`new Pjax({elements: 'a', selectors: ['#k-menu', '.container']})`)
+        end
+      end
+
+      if RUBY_ENGINE == 'opal'
+        module InstanceMethods
+          def pjax_load(url)
+            $pjax.loadUrl(url, $pjax.options.to_n)
+          end
+        end
+      else
+        module InstanceMethods
+          def render_pjax(method, *options, &block)
+            js = Opal::Connect.build Opal::Connect.javascript(self, method, *options)
+            content = dom.load! public_send(method, *options, &block)
+            content.find('#pjax-inline-script').remove
+            content.find('body > div').first.append "<script id='pjax-inline-script'>#{js}</script>"
+            content.to_html
+          end
+        end
+
+        module ClassMethods
+          def render_pjax(method, *args, &block)
+            new.render_pjax(method, *args, &block)
+          end
+        end
+      end
+    end
+
+    register_plugin :pjax, Pjax
+  end
+end

data/lib/opal/connect/plugins/server.rb

@@ -17,15 +17,40 @@ module Opal
             Connect.server_methods[self.name] ||= []
           end
 
-          def __server__(m = false, &block)
-            return if RUBY_ENGINE == 'opal'
+          def __server__(method = false, *args, &block)
+            if RUBY_ENGINE == 'opal'
+              klass_name = self.name
 
-            m ||= Module.new(&block)
+              if Connect.server_methods[klass_name].include? method
+                promise = Promise.new
 
-            yield if block_given?
+                payload = {
+                  method: method,
+                  args: args,
+                  klass: klass_name
+                }
 
-            m.public_instance_methods(false).each do |meth|
-              connect_server_methods << meth unless connect_server_methods.include? meth
+                HTTP.post(Connect.options[:url], payload: payload) do |response|
+                  if response.ok?
+                    res = JSON.from_object(`response`)
+                    promise.resolve res[:body], response
+                  else
+                    promise.reject response
+                  end
+                end
+
+                promise
+              else
+                raise "#{method} is not a server method"
+              end
+            else
+              method ||= Module.new(&block)
+
+              yield if block_given?
+
+              method.public_instance_methods(false).each do |meth|
+                connect_server_methods << meth unless connect_server_methods.include? meth
+              end
             end
           end
           alias server __server__
@@ -33,28 +58,7 @@ module Opal
 
         module InstanceMethods
           def __server__(method, *args)
-            if Connect.server_methods[self.class.name].include? method
-              promise = Promise.new
-
-              payload = {
-                method: method,
-                args: args,
-                klass: self.class.name
-              }
-
-              HTTP.post(Connect.options[:url], payload: payload) do |response|
-                if response.ok?
-                  res = JSON.from_object(`response`)
-                  promise.resolve res[:body], response
-                else
-                  promise.reject response
-                end
-              end
-
-              promise
-            else
-              raise "#{method} is not a server method"
-            end
+            self.class.server(method, *args)
           end
           alias server __server__
         end

data/lib/opal/connect/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module Connect
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

data/lib/opal/connect.rb

@@ -21,7 +21,9 @@ module Opal
           hot_reload: false,
           url: '/connect',
           plugins: [],
-          setup_ran: false
+          setup_ran: false,
+          javascript: [],
+          plugin_requires: []
         )
       end
 
@@ -29,8 +31,8 @@ module Opal
         @options = opts
       end if RUBY_ENGINE == 'opal'
 
-      def setup
-        yield(options) if block_given?
+      def setup(&block)
+        instance_exec(&block) if block_given?
 
         # make sure we include the default plugins with connect
         options[:plugins].each { |plug| Connect.plugin plug }
@@ -68,6 +70,10 @@ module Opal
               file.puts "require 'opal/connect/plugins/#{name}'"
             end
           end
+
+          Connect.options[:plugin_requires].each do |require_path|
+            file.puts "require '#{require_path}'"
+          end
         end
       end
     end
@@ -163,11 +169,11 @@ module Opal
                 hl = {} unless hl.is_a? Hash
                 hl = { host: 'http://localhost', port: 8080 }.merge hl
 
-                Connect.write_entry_file(self.class, method, *options)
+                Connect.write_entry_file(self, method, *options)
 
                 "#{public_send(method, *options, &block)}<script src='#{hl[:host]}:#{hl[:port]}/main.js'></script>"
               else
-                js = Connect.build Connect.javascript(self.class, method, *options)
+                js = Connect.build Connect.javascript(self, method, *options)
 
                 "#{public_send(method, *options, &block)}<script>#{js}</script>"
               end
@@ -194,8 +200,11 @@ module Opal
             included = (args.first == :included) ? args.shift : false
 
             raise ConnectError, "Cannot add a plugin to a frozen Connect class" if RUBY_ENGINE != 'opal' && frozen?
-            plugin = ConnectPlugins.load_plugin(plugin) if plugin.is_a?(Symbol)
-            plugin.load_dependencies(self, *args, &block) if plugin.respond_to?(:load_dependencies)
+            if plugin.is_a?(Symbol)
+              Connect.options[:plugins] << plugin unless Connect.options[:plugins].include? plugin
+              plugin = ConnectPlugins.load_plugin(plugin)
+            end
+            plugin.load_dependencies(self, *args, &block) if !included && plugin.respond_to?(:load_dependencies)
             return unless plugin
             include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
             extend(plugin::ClassMethods) if defined?(plugin::ClassMethods)
@@ -203,8 +212,11 @@ module Opal
               Connect.extend(plugin::ConnectClassMethods) if defined?(plugin::ConnectClassMethods)
               Connect.include(plugin::ConnectInstanceMethods) if defined?(plugin::ConnectInstanceMethods)
               Connect.instance_exec(plugin, &plugin::ConnectSetup) if defined?(plugin::ConnectSetup)
+              unless RUBY_ENGINE == 'opal'
+                Connect.options[:javascript] << plugin::ConnectJavascript if defined?(plugin::ConnectJavascript)
+              end
             end
-            plugin.configure(self, *args, &block) if plugin.respond_to?(:configure)
+            plugin.configure(self, *args, &block) if !included && plugin.respond_to?(:configure)
             nil
           end
 
@@ -222,15 +234,26 @@ module Opal
             def javascript(klass, method, *options)
               return unless klass
 
+              js         = []
+              javascript = Connect.options[:javascript]
+
+              if javascript.length
+                javascript.each do |block|
+                  js << klass.instance_exec(&block)
+                end
+              end
+
               %{
                 Document.ready? do
-                  klass = #{klass.name}.new
+                  klass = #{klass.class.name}.new
 
                   if klass.respond_to?(:#{method})
                     klass.__send__(:#{method}, *JSON.parse(Base64.decode64('#{Base64.encode64 options.to_json}')))
                   end
 
-                  Opal::Connect.start_events
+                  #{js.join(';')}
+
+                  Opal::Connect.start_events unless $connect_events_started
                 end
               }
             end
@@ -257,6 +280,7 @@ module Opal
               code  = %{#{code} Opal::Connect.server_methods = JSON.parse(
                 Base64.decode64('#{Base64.encode64 Connect.server_methods.to_json}')
               );}
+              code = "#{code} #{Connect.options[:entry]}" if Connect.options[:entry]
 
 
               if !Connect.options[:hot_reload]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal-connect
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - cj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-22 00:00:00.000000000 Z
+date: 2016-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
@@ -93,9 +93,12 @@ files:
 - README.md
 - Rakefile
 - lib/opal/connect.rb
+- lib/opal/connect/plugins/abilities.rb
+- lib/opal/connect/plugins/current_user.rb
 - lib/opal/connect/plugins/dom.rb
 - lib/opal/connect/plugins/events.rb
 - lib/opal/connect/plugins/html.rb
+- lib/opal/connect/plugins/pjax.rb
 - lib/opal/connect/plugins/scope.rb
 - lib/opal/connect/plugins/server.rb
 - lib/opal/connect/version.rb