wedge 0.0.27 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2423b8d5acb640ee673e87efd91c7521940ed508
-  data.tar.gz: 2fd4bca2a845a52e5ed71b541c76991dde0a7f8f
+  metadata.gz: ef2f58249fc92d7275ded58a7adf02cb4c902cc7
+  data.tar.gz: 9ca0bf1765457342dc330f60e65fb2ae4f4fa388
 SHA512:
-  metadata.gz: 11772071118c3afd17cae4b17625e2cf7c5e694bb1f5e0b5d400c54eac0d700979543b9cdd8e4c75662094feeef439cb529f07623d5a4af940e77fb060e04085
-  data.tar.gz: 4a6c220aa19f86805af5567eeb70519218615d3ec35dd261c9110a8981201b30ef0708172eda4f1d6c4155e7d92b58613bf5ebd95d9b34da223aea568a919e68
+  metadata.gz: 6c00389efaee2f6a672c1631c6c9b5ed198a1236f4b8aa08e2b8b1a46952701b376d71561263a7a0027a9de68095bfb8e8bbfa8b9060c67eabd61c643e4ffde5
+  data.tar.gz: 1de60359395c01ef233f3c6e23cfcfc0aa264692d7bcc0ad4ada476c30004a2f29a5f437c35d22bc926226e75feab7d47e2015ba239fac67b2c308b74c1ad4f7

data/Gemfile

@@ -3,7 +3,9 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in BrowserIO.gemspec
 gemspec
 
-gem 'opal', github: 'opal/opal'
+gem 'opal', github: 'opal/opal', path: '~/gems/opal'
 gem 'opal-jquery', github: 'opal/opal-jquery'
+gem 'binding_of_caller'
+gem 'better_errors'
 gem 'thin'
 gem 'roda-bin'

data/lib/roda/plugins/wedge.rb

@@ -1,6 +1,6 @@
 class Roda
   module RodaPlugins
-    module Wedge
+    class Wedge
       def self.configure(app, opts = {})
         if app.opts[:wedge]
           app.opts[:wedge].merge!(opts)
@@ -16,27 +16,31 @@ class Roda
             v.each { |p| ::Wedge.config.plugin p }
           when 'scope'
             begin
-              ::Wedge.config.opts[:scope] = v.new
+              ::Wedge.config.scope = v.new
             rescue
-              ::Wedge.config.opts[:scope] = v.new({})
+              ::Wedge.config.scope = v.new({})
             end
           else
-            ::Wedge.config.opts[k.to_sym] = v
+            ::Wedge.config.send "#{k}=", v
           end
         end
+
+        # cache the javascript on load
+        Wedge.javascript if opts[:cache_assets]
       end
 
       module InstanceMethods
-        def wedge(*args)
-          args << { scope: self }
-          ::Wedge[*args]
+        def wedge(name, *args, &block)
+          ::Wedge.scope!(self)[name, *args, &block]
         end
       end
 
       module RequestClassMethods
         def wedge_route_regex
           assets_url = ::Wedge.assets_url.gsub(%r{^\/}, '')
-          %r{#{assets_url}/(.*)\.(.*)$}
+          # # We also allow for no assets key so when we post server methods there
+          # # isn't an error if the key has been changed since a browser refresh.
+          %r{(?:#{assets_url}|#{assets_url.sub("#{::Wedge.config.assets_key}/", '')})/(.*)\.(.*)$}
         end
       end
 
@@ -48,7 +52,7 @@ class Roda
               ::Wedge.source_map component
             when 'rb'
               if component =~ /^wedge/
-                path = ::Wedge.opts.file_path.gsub(/\/wedge.rb$/, '')
+                path = ::Wedge.config.path.gsub(/\/wedge.rb$/, '')
                 File.read("#{path}/#{component}.rb")
               else
                 File.read("#{ROOT_PATH}/#{component}.rb")
@@ -88,7 +92,7 @@ class Roda
             else
               scope.response.headers['Content-Type'] = 'application/javascript; charset=UTF-8'
 
-              if ::Wedge.opts[:debug]
+              if ::Wedge.config.debug
                 "#{::Wedge.javascript(component)}\n//# sourceMappingURL=/assets/wedge/#{component}.map"
               else
                 ::Wedge.javascript(component)

data/lib/wedge.rb

@@ -14,33 +14,56 @@ unless RUBY_ENGINE == 'opal'
 end
 require 'wedge/html'
 require 'wedge/dom'
+require 'wedge/events'
 require 'wedge/config'
 require 'wedge/component'
 
-module Wedge
+class Wedge
   include Methods
 
   class << self
-    attr_accessor :requires, :loaded_requires, :loaded_requires_events, :javascript_cache,
-      :wedge_javascript_loaded, :object_events, :browser_events, :events_triggered
+    ATTR_ACCESSORS = %i{scope store config events}
 
-    def compile_opal
-      javascript
-    end
+    attr_accessor(*ATTR_ACCESSORS)
 
     def assets_url
-      url = opts.assets_url.gsub(%r{^(http(|s)://[^\/]*\/|\/)}, '/')
-      "#{url}#{opts.cache_assets ? "/#{opts.assets_key}" : ''}"
+      url = config.assets_url.gsub(%r{^(http(|s)://[^\/]*\/|\/)}, '/')
+      "#{url}#{config.cache_assets ? "/#{config.assets_key}" : ''}"
     end
 
     def assets_url_with_host
-      "#{opts.assets_url}#{opts.cache_assets ? "/#{opts.assets_key}" : ''}"
+      "#{config.assets_url}#{config.cache_assets ? "/#{config.assets_key}" : ''}"
     end
 
     def script_tag
       "<script src='#{assets_url}/wedge.js'></script>"
     end
 
+    unless RUBY_ENGINE == 'opal'
+      def javascript_cache
+        @javascript_cache ||= IndifferentHash.new
+      end
+    end
+
+    if RUBY_ENGINE == 'opal'
+      def trigger_browser_events
+        config.component_class.each do |k, klass|
+          next if klass.config.triggered_browser_events
+          klass.config.triggered_browser_events = true
+
+          Wedge.trigger klass.config.name, :browser_events
+        end
+      end
+    end
+
+    def trigger(wedge_name, event_name, *args)
+      events.trigger wedge_name, event_name, *args
+    end
+
+    def events
+      @events ||= Events.new
+    end
+
     # Used to call a component.
     #
     # @example
@@ -48,14 +71,19 @@ module Wedge
     #
     # @param name [String, Symbol, #to_s] The unique name given to a component.
     # @return [Wedge::Component#method] Last line of the method called.
-    def [](name, *args)
-      component = components[name.to_sym]
-
-      component.klass.new(*args)
+    def [](name, *args, &block)
+      config.component_class[name].wedge_new self, *args, &block
     end
 
-    def components
-      @components ||= OpenStruct.new
+    %w(store scope).each do |meth|
+      define_method "#{meth}!" do |value|
+        klass = Class.new(self)
+        ATTR_ACCESSORS.each do |name|
+          klass.instance_variable_set(:"@#{name}", Wedge.instance_variable_get(:"@#{name}"))
+        end
+        klass.instance_variable_set(:"@#{meth}", value)
+        klass
+      end
     end
 
     unless RUBY_ENGINE == 'opal'
@@ -64,8 +92,7 @@ module Wedge
       # @param path [String] require path to file to build.
       # @return [String, Opal::Builder#build]
       def build(path = 'wedge', options = {})
-        append_paths
-        Opal::Builder.build(path, options)
+        Opal::Builder.build(path, options) if append_paths
       end
 
       # Source maps for the javascript
@@ -78,7 +105,7 @@ module Wedge
       # @return [Array] List of opal paths.
       def append_paths
         @append_paths ||= begin
-          file     = method(:components).source_location.first.sub('/wedge.rb', '')
+          file     = method(:assets_url).source_location.first.sub('/wedge.rb', '')
           gems_dir = ::Opal.gem_dir.gsub(/(?<=gems)\/opal-.*/, '')
           Wedge::Opal.append_path file
           Wedge::Opal.append_path Dir.pwd
@@ -90,176 +117,49 @@ module Wedge
     end
 
     # Return the opal javascript.
-    def javascript(path_name = 'wedge', options = {}, promise = false)
+    def javascript(path_name = 'wedge', options = {})
       if server?
-        if path_name == 'wedge'
-          @wedge_javascript ||= begin
-            @wedge_javascript_loaded = true
-            requires      = {}
-            @object_events = {}
-            @browser_events = {}
-
-            @javascript_cache ||= {}
-
-            components.to_h.each do |k, v|
-              requires[k]      = v.klass.wedge_config.get_requires
-              # events = Wedge[v.name].wedge_opts.events
-              # @object_events[v.name]  = events.object_events
-              # @browser_events[v.name] = events.browser_events
-              javascript(v.klass.wedge_opts[:path_name])
+        javascript_cache[path_name] ||= begin
+          js = build(path_name, options).javascript
+
+          if path_name == 'wedge'
+            compiled_data = Base64.encode64 config.client_data.to_json
+            # We need to merge in some data that is only set on the server.
+            # i.e. path, assets_key etc....
+            js << Opal.compile("Wedge.config.data = HashObject.new(JSON.parse(Base64.decode64('#{compiled_data}')).merge Wedge.config.data.to_h)")
+            # load all global plugins into wedge
+            config.plugins.each do |path|
+              js << Wedge.javascript(path)
             end
-
-            compiled_requires = Base64.encode64 requires.to_json
-            # compiled_object_events = Base64.encode64 object_events.to_json
-            assets_key        = opts.assets_key
-            cache_assets      = opts.cache_assets
-
-            js = build(path_name, options).javascript
-            js << Opal.compile("Wedge.instance_variable_set(:@requires, JSON.parse(Base64.decode64('#{compiled_requires}')))")
-            # fix: we need to just merge in all config opts and just reject
-            # certain ones
-            js << Opal.compile("Wedge.config.assets_key('#{assets_key}')") if assets_key
-            js << Opal.compile("Wedge.config.cache_assets('#{cache_assets}')") if cache_assets
-            js << Opal.compile("Wedge.config.assets_url('#{opts.assets_url}')")
-            js << Opal.compile("Wedge.config.assets_url_with_host('#{opts.assets_url_with_host}')")
-            ##############################################################
-            js
           end
-        else
-          @javascript_cache[path_name] ||= begin
-            js = build(path_name, options).javascript
-            comp_name = components.to_h.select { |k, v| v.path_name == path_name }.first.last.name
-            comp = Wedge[comp_name]
-            options = comp.client_wedge_opts
-            compiled_opts = Base64.encode64 options.to_json
-            js << Opal.compile("Wedge.components[:#{comp_name}].klass.instance_variable_set(:@wedge_config, Wedge::Config.new(Wedge.components[:#{comp_name}].klass.wedge_config.opts_dup.merge(JSON.parse(Base64.decode64('#{compiled_opts}')))))")
-          end
-        end
-      else
-        Wedge.events_triggered ||= []
-        Wedge.loaded_requires ||= []
-        Wedge.loaded_requires_events ||= []
-        reqs     = Wedge.requires[options[:name].to_sym]
-        promise  = Promise.new
 
-        if reqs
-          requires = get_requires(reqs.dup)
-          load_requires(requires.dup, promise)
-        else
-          promise.resolve true
+          js
         end
+      else
+        url   = "#{Wedge.assets_url_with_host}/#{options[:path]}.js"
+        cache = options[:cache_assets]
 
-        promise.then do
-          load_comp(options).then do
-            method_called = options[:method_called]
-            method_args   = options[:method_args]
-            name          = options[:name]
-            comp          = Wedge[name, options]
-
-            Document.ready? do
-              if method_called && !comp.wedge_opts.on_server_methods.include?(method_called)
-                comp.send(method_called, *method_args)
-              end
-
-              unless Wedge.events_triggered.include?(name)
-                comp.wedge_trigger :browser_events
-                Wedge.loaded_requires << name
-                Wedge.events_triggered << name
-              end
+        `jQuery.ajax({ url: url, dataType: "script", cache: cache }).done(function() {`
+          comp = Wedge.store!(options[:store].indifferent)[options[:name]]
 
-              trigger_requires_events requires.dup
-            end
+          if options[:method_args].any?
+            comp.send(options[:method_called], options[:method_args])
+          else
+            comp.send(options[:method_called])
           end
-        end
-      end
-    end
-
-    def trigger_requires_events requires
-      reqs = requires.shift
-
-      reqs.each do |r|
-        next if Wedge.loaded_requires_events.include? r[:name]
-
-        Wedge.loaded_requires_events << r[:name]
-        comp = Wedge[r[:name], r]
-        comp.wedge_trigger :browser_events
-        Wedge.events_triggered << r[:name]
-      end
-
-      trigger_requires_events requires if requires.any?
-    end
-
-    def load_requires requires, promise = Promise.new
-      reqs     = requires.shift
-      promises = []
-
-      reqs.each do |r|
-        next if Wedge.loaded_requires.include? r[:name]
-
-        Wedge.loaded_requires << r[:name]
-
-        promises << -> { load_comp r }
-      end if reqs
-
-      Promise.when(*promises.map!(&:call)).then do
-        requires.any?? load_requires(requires, promise) : promise.resolve(true)
-      end
-    end
-
-    def get_requires reqs, requires_array = []
-      new_reqs = []
 
-      reqs.each do |r|
-        if r[:requires].any?
-          get_requires(r[:requires], requires_array)
-        end
+          Wedge.trigger_browser_events
 
-        new_reqs << r
+         `}).fail(function(jqxhr, settings, exception){ window.console.log(exception); })`
       end
-
-      requires_array << new_reqs if new_reqs.any?
-
-      requires_array
-    end
-
-    def load_comp options = {}, promise = Promise.new
-      path_name  = options[:path_name]
-      assets_url = Wedge.assets_url_with_host
-
-      if !Wedge.components[options[:name]]
-        # fix: this could give people unwanted behaviour, change getScript to just
-        # use ajax.
-        `jQuery.ajaxSetup({ cache: true })` if Wedge.opts.cache_assets
-        `$.getScript(assets_url + "/" + path_name + ".js").done(function(){`
-          promise.resolve true
-        `}).fail(function(jqxhr, settings, exception){ window.console.log(exception); });`
-        #########################################################################
-      else
-        promise.resolve true
-      end
-
-      promise
-    end
-
-    # Used to setup the component with default options.
-    #
-    # @example
-    #   class SomeComponent < Component
-    #     setup do |config|
-    #       config.name :some
-    #     end
-    #   end
-    # @yield [Config]
-    def setup(&block)
-      block.call config if block_given?
     end
 
     def config
       @config ||= begin
-        args = { klass: self }
+        args = { klass: self, component_class: IndifferentHash.new }
 
         unless RUBY_ENGINE == 'opal'
-          args[:file_path]  = caller.first.gsub(/(?<=\.rb):.*/, '')
+          args[:path]       = caller.first.gsub(/(?<=\.rb):.*/, '')
           args[:assets_key] = begin
             if defined?(PlatformAPI) && ENV['HEROKU_TOKEN'] && ENV['HEROKU_APP']
               heroku = PlatformAPI.connect_oauth(ENV['HEROKU_TOKEN'], default_headers: {'Range' => 'version ..; order=desc'})
@@ -274,9 +174,5 @@ module Wedge
         Config.new(args)
       end
     end
-
-    def opts
-      config.opts
-    end
   end
 end

data/lib/wedge/component.rb

@@ -1,99 +1,73 @@
-module Wedge
+class Wedge
   class Component
     include Methods
 
-    ALLOWED_CLIENT_OPTS = %i(name path_name method_args method_called cache tmpl key cache_assets assets_key assets_url assets_url_with_host requires skip_method_wrap on_server_methods)
-
     class << self
-      # Override the default new behaviour
-      def new(*args, &block)
-        obj                 = allocate
-        obj.wedge_opts.js   = args.delete(:js)
-        obj.wedge_opts.init = args.delete(:init)
-
-        if args.any? && obj.wedge_opts.skip_method_wrap
-          obj.wedge_opts.init = args
-        end
+      attr_accessor :wedge_on_count
 
-        # Merge other args into opts
-        args.each { |a| a.each {|k, v| obj.wedge_opts[k] = v } } if args.any?
+      def wedge_new(klass, *args, &block)
+        obj = allocate
 
-        obj.wedge_opts.events.scope = obj
-
-        # Set all the on events
-        obj.wedge_opts.on.each do |*a, &b|
-          obj.wedge_opts.events.add(*a.first.first, &a.first.last)
+        %w(store scope).each do |meth|
+          if value = klass.send(meth)
+            obj.config.send "#{meth}=", value
+          end
         end
-        wedge_opts.added_class_events = true
 
-        if obj.wedge_opts.init
-          if obj.wedge_opts.init.is_a? Array
-            obj.send :initialize, *obj.wedge_opts.init, &block
-          else
-            obj.send :initialize, obj.wedge_opts.init, &block
-          end
+        if args.any?
+          obj.send :initialize, *args, &block
         else
           obj.send :initialize, &block
         end
 
-        # don't need to wrap the method if it's opal
-        unless RUBY_ENGINE == 'opal' || wedge_opts.methods_wrapped || wedge_opts.skip_method_wrap
-          obj.wedge_opts.methods_wrapped = wedge_opts.methods_wrapped = true
-
-          public_instance_methods(false).each do |meth|
-            alias_method :"wedge_original_#{meth}", :"#{meth}"
-            define_method "#{meth}" do |*d_args, &blk|
-              if server? && !wedge_opts.method_called && wedge_opts.js
-                wedge_opts.method_called = meth
-                wedge_opts.method_args   = *d_args
-              end
+        obj
+      end
 
-              o_name = "wedge_original_#{meth}"
+      alias_method :original_name, :name
+      def wedge_name(*args)
+        if args.any?
+          unless RUBY_ENGINE == 'opal'
+            # set the file path
+            path = "#{caller[0]}".gsub(/(?<=\.rb):.*/, '')
+              .gsub(%r{(#{Dir.pwd}/|.*(?=wedge))}, '')
+              .gsub(/\.rb$/, '')
+          end
 
-              if client? || method(o_name).parameters.length > 0
-                result = send(o_name, *d_args, &blk)
-              else
-                result = send(o_name, &blk)
-              end
+          @wedge_on_count = 0
 
-              # Append the initialize javscript
-              if server? && meth == wedge_opts.method_called && opts.js
-                result = result.to_html if result.is_a? DOM
-                result << wedge_javascript if result.is_a? String
-              end
+          args.each do |name|
+            # set the name
+            wedge_config.name = name
 
-              result
+            unless RUBY_ENGINE == 'opal'
+              # set the file path
+              wedge_config.path = path
+              # add it to the component class list allow path or name
+              Wedge.config.component_class[path.gsub(/\//, '__')] = self
             end
-          end
-        end
-
-        if obj.wedge_opts.call
-          method_args = args.first
-          method_called = method_args.delete(:call)
 
-          if method_args.any?
-            obj.send(method_called, method_args)
-          else
-            obj.send(method_called)
+            Wedge.config.component_class[name] = self
           end
         else
-          obj
+          original_name
         end
       end
-
-      # Used to setup the component with default options.
-      #
-      # @example
-      #   class SomeComponent < Component
-      #     setup do |config|
-      #       config.name :some
-      #     end
-      #   end
-      # @yield [Config]
-      def wedge_setup(&block)
-        block.call wedge_config
+      alias_method :name, :wedge_name
+
+      def wedge_html(html, &block)
+        unless RUBY_ENGINE == 'opal'
+          wedge_config.html = begin
+            File.read html
+          rescue
+            html
+          end.strip
+
+          if block_given?
+            yield
+          end
+        end
       end
-      alias_method :setup, :wedge_setup
+      alias_method :html, :wedge_html
 
       # Set templates
       #
@@ -103,11 +77,11 @@ module Wedge
       def wedge_tmpl(name, dom = false, remove = true)
         if dom
           dom = remove ? dom.remove : dom
-          wedge_opts.tmpl[name] = {
+          wedge_config.tmpl[name] = {
             dom:  dom,
             html: dom.to_html
           }
-        elsif t = wedge_opts.tmpl[name]
+        elsif t = wedge_config.tmpl[name]
           dom = DOM.new t[:html]
         else
           false
@@ -117,57 +91,26 @@ module Wedge
       end
       alias_method :tmpl, :wedge_tmpl
 
-      def wedge_dom
-        @wedge_dom ||= DOM.new wedge_opts.html
-      end
-      alias_method :dom, :wedge_dom
+      def wedge_dom &block
+        @wedge_dom ||= DOM.new wedge_config.html
 
-      # Shortcut for Wedge.components
-      #
-      # @return [Hash, Wedge.components]
-      def wedge_components
-        Wedge.components ||= {}
-      end
-      alias_method :components, :wedge_components
+        if block_given?
+          yield
+        end
 
-      # Shortcut for the Config#opts
-      #
-      # @return [Openstruct, Config#opts]
-      def wedge_opts
-        wedge_config.opts
+        @wedge_dom
       end
-      alias_method :opts, :wedge_opts
+      alias_method :dom, :wedge_dom
 
       def wedge_config
-        @wedge_config ||= begin
-          args = Wedge.config.opts_dup.merge(klass: self, object_events: {})
-
-          unless RUBY_ENGINE == 'opal'
-            args[:file_path] = caller.first.gsub(/(?<=\.rb):.*/, '')
-            args[:path_name] = args[:file_path]
-              .gsub(%r{(#{Dir.pwd}/|.*(?=wedge))}, '')
-              .gsub(/\.rb$/, '')
-          end
-
-          c = Config.new(args)
-
-          # If extending from a plugin it will automatically require it.
-          ancestors.each do |klass|
-            next if klass.to_s == name.to_s
-
-            if klass.method_defined?(:wedge_opts) && klass.wedge_opts.name.to_s =~ /_plugin$/
-              c.requires klass.wedge_opts.name
-            end
-          end
-
-          c
-        end
+        @wedge_config ||= Config.new Wedge.config.data.dup.merge(klass: self)
       end
       alias_method :config, :wedge_config
 
       def wedge_on(*args, &block)
         if args.first.to_s != 'server'
-          wedge_opts.on << [args, block]
+          @wedge_on_count += 1
+          Wedge.events.add config.name, *args, &block
         else
           wedge_on_server(&block)
         end
@@ -175,17 +118,13 @@ module Wedge
       alias_method :on, :wedge_on
 
       def method_missing(method, *args, &block)
-        if wedge_opts.scope.respond_to?(method, true)
-          wedge_opts.scope.send method, *args, &block
+        if config.scope.respond_to?(method, true)
+          config.scope.send method, *args, &block
         else
           super
         end
       end
 
-      def client_wedge_opts
-        wedge_config.opts_dup.select {|k, v| ALLOWED_CLIENT_OPTS.include? k }
-      end
-
       def wedge_on_server(&block)
         if server?
           m = Module.new(&block)
@@ -193,7 +132,7 @@ module Wedge
           yield
 
           m.public_instance_methods(false).each do |meth|
-            wedge_opts.on_server_methods << meth.to_s
+            config.server_methods << meth.to_s
 
             alias_method :"wedge_on_server_#{meth}", :"#{meth}"
             define_method "#{meth}" do |*args, &blk|
@@ -212,20 +151,22 @@ module Wedge
           m = Module.new(&block)
 
           m.public_instance_methods(false).each do |meth|
-            wedge_opts.on_server_methods << meth.to_s
+            config.server_methods << meth.to_s
 
             define_method "#{meth}" do |*args, &blk|
-              path_name = wedge_opts.path_name
-              # event_id = "comp-event-#{$faye.generate_id}"
+              path_name = config.path
 
-              payload = client_wedge_opts.reject do |k, _|
+              payload = config.client_data.reject do |k, _|
                 %w(html tmpl requires plugins object_events js_loaded).include? k
               end
               payload[:wedge_name]          = payload[:name]
               payload[:wedge_method_called] = meth
               payload[:wedge_method_args]   = args
 
-              call_url = "#{Wedge.assets_url}/#{path_name}.call"
+              # we want to remove the assets key from the call so we don't get
+              # an error if they assets_key has changed and the user hasn't
+              # refreshed the browser yet.
+              call_url = "#{Wedge.assets_url.sub("#{Wedge.config.assets_key}/")}/#{path_name}.call"
 
               HTTP.post(call_url,
                 headers: {
@@ -254,35 +195,29 @@ module Wedge
       end
     end
 
+    if RUBY_ENGINE == 'opal'
+      def wedge(*args)
+        Wedge[*args]
+      end
+    end
+
     def wedge_scope
-      wedge_opts[:scope]
+      wedge_config.scope
     end
     alias_method :scope, :wedge_scope
 
-    def wedge_cache
-      wedge_opts[:cache]
+    def wedge_store
+      wedge_config.store
     end
-    alias_method :cache, :wedge_cache
+    alias_method :store, :wedge_store
 
     # Duplicate of class condig [Config]
     # @return config [Config]
     def wedge_config
-      @wedge_config ||= begin
-        c = Config.new(self.class.wedge_config.opts_dup.merge(events: Events.new))
-        c.opts.events.object_events = c.opts.object_events.dup
-        c.opts.object_events = {}
-        c
-      end
+      @wedge_config ||= Config.new(self.class.wedge_config.data.dup)
     end
     alias_method :config, :wedge_config
 
-    # Duplicated of config.opts [Config#opts]
-    # @return opts [Config#opts]
-    def wedge_opts
-      wedge_config.opts
-    end
-    alias_method :opts, :wedge_opts
-
     # Grab a copy of the template
     # @return dom [DOM]
     def wedge_tmpl(name)
@@ -339,48 +274,35 @@ module Wedge
     end
     alias_method :from_client?, :wedge_from_client?
 
-    def wedge_javascript
+    def wedge_javascript(method = false, *args)
       return unless server?
 
-      compiled_opts = Base64.encode64 client_wedge_opts.to_json
-      name          = wedge_opts.file_path.gsub("#{Dir.pwd}/", '').gsub(/\.rb$/, '')
+      client_data = config.client_data.dup
+      client_data.merge! method_called: method, method_args: args
 
+      compiled_opts = Base64.encode64 client_data.to_json
       javascript = <<-JS
-        Wedge.javascript('#{name}', JSON.parse(Base64.decode64('#{compiled_opts}')))
+        Wedge.javascript('#{config.path}', JSON.parse(Base64.decode64('#{compiled_opts}')))
       JS
       "<script>#{Opal.compile(javascript)}</script>"
     end
     alias_method :javscript, :wedge_javascript
 
-    def client_wedge_opts
-      wedge_config.opts_dup.select {|k, v| ALLOWED_CLIENT_OPTS.include? k }
-    end
-    alias_method :client_opts, :client_wedge_opts
-
-    def wedge_trigger(*args)
-      wedge_opts.events.trigger(*args)
+    def wedge_trigger(event_name, *args)
+      Wedge.events.trigger config.name, event_name, *args
     end
     alias_method :trigger, :wedge_trigger
 
-    def wedge_super *args, &block
-      if server?
-        caller_str = "#{caller[0]}"
-        calling_method = (caller_str =~ /`([^']*)'/ and $1)
-        self.class.superclass.instance_method(:"wedge_original_#{calling_method}").bind(self).call(*args, &block)
-      else
-        super *args, &block
-      end
-    end
-
-    if RUBY_ENGINE == 'opal'
-      def wedge(*args)
-        Wedge[*args]
-      end
+    def to_js(method = false, *args)
+      response = args.any? ? send(method, *args) : send(method)
+      response = response.to_html if response.is_a? DOM
+      response << wedge_javascript(method, *args) if response.is_a? String
+      response
     end
 
     def method_missing(method, *args, &block)
-      if wedge_opts.scope.respond_to?(method, true)
-        wedge_opts.scope.send method, *args, &block
+      if config.scope.respond_to?(method, true)
+        config.scope.send method, *args, &block
       else
         super
       end