wedge 0.0.27 → 0.1.0

data/lib/wedge/config.rb

@@ -1,139 +1,61 @@
-require 'ostruct'
-require 'wedge/events'
-
-module Wedge
+class Wedge
   class Config
     include Methods
 
     # Stores the options for the config
     #
     # @return [OpenStruct]
-    attr_accessor :opts
+    attr_accessor :data
 
     # Setup initial opts values
     #
     # @param opts [Hash] The initial params for #opts.
     def initialize(opts = {})
-      opts = {
-        cache_assets: false,
-        cache: IndifferentHash.new,
+      @data = HashObject.new({
+        name: nil,
+        path: nil,
+        html: nil,
+        scope: nil,
+        debug: false,
+        assets_url: '/assets/wedge',
         assets_key: false,
-        tmpl: IndifferentHash.new,
-        scope: false,
-        loaded: false,
-        requires: [],
-        skip_method_wrap: false,
-        on: [],
-        on_server_methods: [],
-        object_events: {},
+        cache_assets: false,
         is_plugin: false,
-        assets_url: '/assets/wedge',
-        plugins: []
-      }.merge opts
-
-      @opts = OpenStruct.new(opts)
-    end
-
-    # Set the unique name of the component
-    #
-    # @param name [<String, Symbol>, #to_sym]
-    def name(*names)
-      names.each do |name|
-        opts.name = name.to_sym
-        opts.is_plugin = true if name.to_s =~ /_plugin$/
-        Wedge.components ||= {}
-        Wedge.components[opts.name] = opts
-      end
-    end
-
-    def is_plugin?
-      opts.is_plugin
-    end
-
-    # Used to set and update the dom
-    def dom
-      if server?
-        yield
-      end
-    end
-    alias_method :setup, :dom
-
-    # Set the raw html
-    # @param html [String]
-    def html(html)
-      unless RUBY_ENGINE == 'opal'
-        opts.html = begin
-          File.read html
-        rescue
-          html
-        end.strip
-      end
-    end
-
-    def requires(*args)
-      unless RUBY_ENGINE == 'opal'
-        args.each do |a|
-          if a.to_s[/_plugin$/]
-            require "wedge/plugins/#{a.to_s.gsub(/_plugin$/, '')}"
-          end
-          opts.requires << a
-        end
-      end
-    end
-
-    def opts_dup
-      opts.to_h.inject({}) {|copy, (key, value)| copy[key] = value.dup rescue value; copy}
+        triggered_browser_events: false,
+        store: IndifferentHash.new,
+        settings: IndifferentHash.new,
+        tmpl: IndifferentHash.new,
+        on_block: [],
+        on_block_count: 0,
+        server_methods: [],
+        plugins: [],
+        allowed_client_data: %w(name path method_args method_called store tmpl key cache_assets assets_key assets_url assets_url_with_host)
+      }.merge(opts))
     end
 
-    def skip_method_wrap
-      opts.skip_method_wrap = true
-    end
-
-    %w(scope assets_url assets_url_with_host cache_assets assets_key debug).each do |m|
-      define_method m do |v|
-        opts[m] = v
-      end
+    def client_data
+      @data.dup.select {|k, v| allowed_client_data.include? k }
     end
 
     def plugin(name)
       unless RUBY_ENGINE == 'opal'
         require "wedge/plugins/#{name}"
-        klass = Wedge.components[:"#{name}_plugin"].klass
-        Wedge::Component.include(klass::InstanceMethods) if defined?(klass::InstanceMethods)
-        Wedge::Component.extend(klass::ClassMethods) if defined?(klass::ClassMethods)
-      end
-    end
-
-    def get_requires(requires = false, previous_requires = [])
-      list = []
-
-      unless requires
-        requires ||= opts.requires.dup
-        previous_requires << opts.name.to_sym
       end
 
-      previous_requires.each { |p| requires.delete(p) }
+      klass = Wedge.config.component_class[:"#{name}_plugin"]
+      plugins << klass.config.path unless plugins.include? klass.config.path
 
-      requires.each do |r|
-        begin
-          klass = Wedge.components[r.to_sym].klass
-        rescue
-          raise "No component named: #{r}"
-        end
-        o = klass.client_wedge_opts.select do |k, v|
-          %w(path_name name requires).include? k.to_s
-        end
-
-        # We don't want to get a stack limit error so we stop something
-        # requiring itself
-        pr = previous_requires.dup << o[:name].to_sym
-
-        o[:requires] = get_requires o[:requires].dup, pr if o[:requires].present?
+      # Merge in instance/class methods
+      Wedge::Component.include(klass::InstanceMethods) if defined?(klass::InstanceMethods)
+      Wedge::Component.extend(klass::ClassMethods) if defined?(klass::ClassMethods)
+    end
 
-        list << o
+    def method_missing(method, *args, &block)
+      if @data.respond_to?(method, true)
+        @data.send method, *args, &block
+      else
+        super
       end
-
-      list
     end
   end
 end

data/lib/wedge/dom.rb

@@ -1,4 +1,4 @@
-module Wedge
+class Wedge
   class DOM
     include Methods
 

data/lib/wedge/events.rb

@@ -1,18 +1,32 @@
-module Wedge
+class Wedge
   class Events
-    attr_accessor :scope, :browser_events, :object_events
+    attr_accessor :events
 
     VIP_ORDER_LIST = %w(history_change)
 
     def initialize
-      @browser_events = []
-      @object_events  = {}
+      @events = IndifferentHash.new
     end
 
-    def add(*args, &block)
+    def add(wedge_name, *args, &block)
+      event_name = args.shift
+
+      events = @events[wedge_name] ||= IndifferentHash.new({
+        browser_events: [],
+        object_events: IndifferentHash.new,
+        on_count: 0
+      })
+
+      # fix: there is a bug in opal where even though it's only including a
+      # module once it is loading the class twice. So this stops on events being
+      # double added
+      return if events[:on_count] >= Wedge[wedge_name].class.wedge_on_count
+      events[:on_count] += 1
+
       event = {
-        name: args.shift,
+        name: event_name,
         block: block,
+        wedge_name: wedge_name,
         options: {}
       }
 
@@ -27,46 +41,43 @@ module Wedge
       end
 
       if %w(ready history_change).include?(event[:name].to_s) || event[:name] =~ /[:\s]/ || event[:selector]
-        browser_events << event
+        events[:browser_events] << event
       else
-        event[:component] = scope.wedge_opts.name
-
-        if !scope.class.wedge_opts.added_class_events && for_component = event[:options].delete(:for)
-          wedge_opts = Wedge.components[for_component].klass.wedge_opts
-          events = wedge_opts.object_events[event.delete(:name)] ||= []
-          events << event
-        else
-          events = object_events[event.delete(:name)] ||= []
-          events << event
+        if for_component = event[:options].delete(:for)
+          events = @events[for_component] ||= IndifferentHash.new({
+            browser_events: [],
+            object_events: IndifferentHash.new
+          })
         end
+
+        (events[:object_events][event_name] ||= []) << event
       end
     end
 
-    def trigger(name, options = {})
-      name    = name.to_s
-      options = options.indifferent
+    def trigger(wedge_name, event_name, *args)
+      event_name = event_name.to_s
 
-      case name
+      return unless events = @events[wedge_name]
+
+      case event_name
       when 'browser_events'
+        browser_events = events[:browser_events]
+
         # We make sure anything in the VIP_ORDER_LIST goes first
         (browser_events.sort_by do |x|
           [VIP_ORDER_LIST.index(x[:name]) || VIP_ORDER_LIST.length, browser_events.index(x)]
         end).each do |event|
-          trigger_browser_event event
+          trigger_browser_event wedge_name, event
         end
       else
-        # fix: we need to change the way events are stored
-        wedge_events = (Wedge.components[scope.wedge_opts.name].klass.wedge_opts.object_events[name] || [])
-        events = wedge_events.concat(object_events[name] || [])
-        ##################################################
-        events.each do |event|
-          Wedge[event[:component]].instance_exec options, &event[:block]
+        (events[:object_events][event_name] || []).each do |event|
+          Wedge[event[:wedge_name]].instance_exec(*args, &event[:block])
         end
       end
     end
 
-    def trigger_browser_event event
-      comp = Wedge[scope.wedge_opts.name]
+    def trigger_browser_event wedge_name, event
+      comp = Wedge[wedge_name]
 
       case
       when event[:name].to_s == 'ready'
@@ -113,9 +124,9 @@ module Wedge
           opts[:dom] = el
 
           if opts && key = opts[:key]
-            form = Wedge[event[:options][:form], init: [params_obj[key], opts]]
+            form = Wedge[event[:options][:form], params_obj[key], opts]
           else
-            form = Wedge[event[:options][:form], init: [params_obj, opts]]
+            form = Wedge[event[:options][:form], params_obj, opts]
           end
 
           el.find(opts[:error_selector] || '.field-error').remove

data/lib/wedge/html.rb

@@ -1,4 +1,4 @@
-module Wedge
+class Wedge
   module HTML
     include Methods
 

data/lib/wedge/opal.rb

@@ -12,7 +12,7 @@ unless RUBY_ENGINE == 'opal'
   end
 end
 
-module Wedge
+class Wedge
   # Create our own opal instance.
   Opal = ::Opal.dup
 end

data/lib/wedge/plugins/form.rb

@@ -1,10 +1,10 @@
 require 'wedge/plugins/validations'
 require 'forwardable'
 
-module Wedge
+class Wedge
   module Plugins
     class Form < Component
-      config.name :form_plugin
+      name :form_plugin
 
       include Methods
       include Validations
@@ -105,7 +105,7 @@ module Wedge
         _form.each do |key, form_name|
           opts = {}
           if _data.respond_to?(key)
-            opts[key] = wedge(form_name, init: _data.send(key))
+            opts[key] = wedge(form_name, _data.send(key))
           end
           @_attributes.set_values opts
 
@@ -155,7 +155,7 @@ module Wedge
             atts[att] = _attributes.send(att)
 
             if form_name = _form[att.to_s.to_sym]
-              atts[att] = wedge(form_name, init: atts[att]).attributes
+              atts[att] = wedge(form_name, atts[att]).attributes
             end
           end
         end
@@ -169,7 +169,7 @@ module Wedge
             d = data[k]
             d = d.attributes if d.is_a?(Form)
 
-            f  = wedge(form_name, init: d)
+            f  = wedge(form_name, d)
             k  = "#{k}_attributes"
             dt = f.model_attributes
 

data/lib/wedge/plugins/history.rb

@@ -1,7 +1,7 @@
-module Wedge
+class Wedge
   module Plugins
     class History < Component
-      config.name :history_plugin
+      name :history_plugin
     end
   end
 end

data/lib/wedge/plugins/pjax.rb

@@ -11,11 +11,12 @@ if RUBY_ENGINE == 'opal'
   end
 end
 
-module Wedge
+require 'wedge/plugins/history'
+
+class Wedge
   module Plugins
     class Pjax < Component
-      config.name :pjax, :pjax_plugin
-      config.requires :history_plugin
+      name :pjax, :pjax_plugin
 
       def get href = false
         `$(document).trigger('page:get')`

data/lib/wedge/plugins/validations.rb

@@ -1,4 +1,4 @@
-module Wedge
+class Wedge
   module Plugins
     class Form < Component
       # Provides a base implementation for extensible validation routines.
@@ -134,7 +134,7 @@ module Wedge
               options = {}
               options[:key] = _options[:key] if _options.key? :key
 
-              f = wedge(form_name, init: [_attributes.send(att).attributes, options])
+              f = wedge(form_name, _attributes.send(att).attributes, options)
               assert(f.valid?, [att, f.errors])
             else
               assert(!_attributes.send(att).to_s.empty?, error)

data/lib/wedge/utilis/hash.rb

@@ -16,6 +16,7 @@ class Hash
       ## create the setter that sets the instance variable
       self.class.send(:define_method, "#{k}=", proc{|v| self.instance_variable_set("@#{k}", v)})
     end
+
     return self
   end
 
@@ -75,3 +76,30 @@ class Hash
     Wedge::IndifferentHash.new self
   end
 end
+
+class HashObject
+  def initialize(hash = {})
+    hash.each do |k,v|
+      if v.kind_of? Hash
+        self.instance_variable_set("@#{k}", HashObject.new(v))
+      end
+
+      self.instance_variable_set("@#{k}", v)
+      self.class.send(:define_method, k, proc{self.instance_variable_get("@#{k}")})
+      self.class.send(:define_method, "#{k}=", proc{|vv| self.instance_variable_set("@#{k}", vv)})
+    end
+  end
+
+  def to_h
+    hash_to_return = Wedge::IndifferentHash.new
+    self.instance_variables.each do |var|
+      value = self.instance_variable_get(var)
+      hash_to_return[var.to_s.gsub("@","")] = value.is_a?(HashObject) ? value.to_h : value
+    end
+    return hash_to_return
+  end
+
+  def dup
+    Wedge::IndifferentHash.new self.to_h.inject({}) {|copy, (key, value)| copy[key] = value.dup rescue value; copy}
+  end
+end

data/lib/wedge/utilis/indifferent_hash.rb

@@ -1,4 +1,4 @@
-module Wedge
+class Wedge
   class IndifferentHash < Hash
 
     def initialize(constructor = {}, &block)

data/lib/wedge/utilis/methods.rb

@@ -1,4 +1,4 @@
-module Wedge
+class Wedge
   module Methods
     def self.included(base)
       base.extend(ClassMethods)