wedgeio 0.0.1

data/lib/wedge/events.rb

@@ -0,0 +1,136 @@
+module Wedge
+  class Events
+    attr_accessor :scope, :browser_events, :object_events
+
+    VIP_ORDER_LIST = %w(history_change)
+
+    def initialize
+      @browser_events = []
+      @object_events  = {}
+    end
+
+    def add(*args, &block)
+      event = {
+        name: args.shift,
+        block: block,
+        options: {}
+      }
+
+      args.each do |arg|
+        if arg.is_a?(String)
+          event[:selector] = arg
+        elsif arg.is_a? Class
+          event[:klass] = arg
+        else
+          event[:options] = event[:options].merge(arg).indifferent.to_h
+        end
+      end
+
+      if event[:name].to_s == 'ready' || event[:name] =~ /[:\s]/ || event[:selector]
+        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
+        end
+      end
+    end
+
+    def trigger(name, options = {})
+      name    = name.to_s
+      options = options.indifferent
+
+      case name
+      when '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
+        end
+      else
+        events = object_events[name] || []
+        events.each do |event|
+          Wedge[event[:component]].instance_exec options, &event[:block]
+        end
+      end
+    end
+
+    def trigger_browser_event event
+      comp = Wedge[scope.wedge_opts.name]
+
+      case event[:name]
+      when 'ready'
+        el = Element.find(event[:selector] != '' ? event[:selector] : 'body')
+
+        comp.instance_exec el, &event[:block]
+      when 'history_change'
+        $window.history.change do |he|
+          comp.instance_exec he, &event[:block]
+        end
+      when 'form'
+        warn 'missing form class option' unless event[:klass]
+
+        Document.on :submit, event[:selector] do |evt|
+          el = evt.current_target
+          evt.prevent_default
+
+          params = {}
+
+          # loop through all the forum values
+          el.serialize_array.each do |row|
+            field, _ = row
+
+            # we need to make it native to access it like ruby
+            field    = Native(field)
+            name     = field['name']
+            value    = field['value']
+
+            params[name] = value
+          end
+
+          params_obj = {}
+
+          params.each do |param, value|
+            keys = param.gsub(/[^a-z0-9_]/, '|').gsub(/\|\|/, '|').gsub(/\|$/, '').split('|')
+            params_obj = params_obj.deep_merge keys.reverse.inject(value) { |a, n| { n => a } }
+          end
+
+          opts[:dom] = el
+
+          if opts && key = opts[:key]
+            form = event[:klass].new params_obj[key], opts
+          else
+            form = event[:klass].new params_obj, opts
+          end
+
+          el.find(opts[:error_selector] || '.field-error').remove
+
+          comp.instance_exec form, evt.current_target, evt, &event[:block]
+        end
+      else
+        args = [event[:name]]
+
+        if selector = event[:selector]
+          args << selector
+        end
+
+        Document.on(*args) do |evt|
+          el = evt.current_target
+          comp.instance_exec el, evt, &event[:block]
+        end
+
+        if event[:name] =~ /ready/
+          el = Element.find(event[:selector] != '' ? event[:selector] : 'body')
+          comp.instance_exec el, &event[:block]
+        end
+      end
+    end
+  end
+end

data/lib/wedge/html.rb

@@ -0,0 +1,29 @@
+module Wedge
+  module HTML
+    include Methods
+
+    class << self
+      # Parse HTML into a Nokogiri object
+      # @param raw_html [String]
+      # @return parsed_html [Nokogiri]
+      def [](raw_html)
+        return unless server?
+
+        # remove all the starting and trailing whitespace
+        raw_html = raw_html.strip
+
+        if raw_html[/\A<!DOCTYPE/] || raw_html[/\A<html/]
+          Nokogiri::HTML(raw_html)
+        else
+          parsed_html = Nokogiri::HTML.fragment(raw_html)
+
+          if parsed_html.children.length >= 1
+            parsed_html.children.first
+          else
+            parsed_html
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wedge/opal.rb

@@ -0,0 +1,18 @@
+require 'opal'
+require 'opal-jquery'
+
+unless RUBY_ENGINE == 'opal'
+  module Opal
+    class Builder
+      # @return [String] Compiled javascript.
+      def javascript
+        to_s
+      end
+    end
+  end
+end
+
+module Wedge
+  # Create our own opal instance.
+  Opal = ::Opal.dup
+end

data/lib/wedge/plugins/form.rb

@@ -0,0 +1,431 @@
+require 'wedge/plugins/validations'
+require 'forwardable'
+
+module Wedge
+  module Plugins
+    class Form < Component
+      config.name :form_plugin
+
+      include Methods
+      include Validations
+
+      module Delegates
+        def _delegates(*names)
+          accessors = Module.new do
+            extend Forwardable # DISCUSS: do we really need Forwardable here?
+            names.each do |name|
+              delegate [name, "#{name}="] => :_attributes
+            end
+          end
+          include accessors
+        end
+      end
+
+      extend Delegates
+
+      class Attributes
+        def set_values(atts)
+          @_attributes = []
+
+          atts.each do |key, val|
+            if respond_to?("#{key}=")
+              send(:"#{key}=", val)
+              @_attributes << key
+            end
+          end
+        end
+
+        def set_attr_accessors attrs
+          attrs.each do |attr|
+            define_singleton_method "#{attr}=" do |value|
+              value = value.to_obj if value.is_a? Hash
+              instance_variable_set(:"@#{attr}", value)
+              @_attributes ||= []
+              @_attributes << attr
+            end
+
+            define_singleton_method attr do
+              instance_variable_get(:"@#{attr}")
+            end
+          end
+        end
+
+        def _attributes
+          @_attributes ||= []
+        end
+
+        def empty?
+          _attributes.empty?
+        end
+      end
+
+      # 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 = {}, options = {})
+        @_data    = atts
+        @_data    = atts.to_obj if atts.is_a? Hash
+        @_options = options
+
+        # @_attributes = Class.new(Attributes).new
+        @_attributes = Attributes.new
+        @_attributes.set_attr_accessors _attr_accessors
+        @_attributes.set_values _data
+
+        _data.each do |key, val|
+          send("#{key}=", val)
+        end
+
+        _form.each do |key, klass|
+          opts = {}
+          opts[key] = klass.new(_data.send(key)) if _data.respond_to?(key)
+          @_attributes.set_values opts
+
+          send("#{key}=", opts[key])
+        end
+      end
+
+      def self.attr_accessor(*vars)
+        @_attr_accessors ||= []
+        @_form ||= {}
+
+        vars.each do |v|
+          if !v.is_a? Hash
+            @_attr_accessors << v unless @_attr_accessors.include? v
+          else
+            v = v.first
+
+            unless @_attr_accessors.include? v.first
+              @_attr_accessors << v.first
+              @_form[v.first] = v.last
+            end
+          end
+        end
+
+        _delegates(*_attr_accessors)
+      end
+
+      def method_missing method, *args, &block
+        # respond_to?(symbol, include_all=false)
+        if _data.respond_to? method, true
+          _data.send method, *args, &block
+        else
+          return if method[/\=\z/]
+
+          super
+        end
+      end
+
+      # Return hash of attributes and values.
+      def attributes
+        Hash.new.tap do |atts|
+          _attributes.instance_variables.each do |ivar|
+            # todo: figure out why it's setting @constructor and @toString
+            next if ivar == :@constructor || ivar == :@toString || ivar == :@_attributes || ivar == :@_data || ivar == :@_forms
+
+            att = ivar[1..-1].to_sym
+            atts[att] = _attributes.send(att)
+
+            if klass = _form[att.to_s.to_sym]
+              atts[att] = klass.new(atts[att]).attributes
+            end
+          end
+        end
+      end
+
+      def model_attributes data = attributes
+        hash = {}
+
+        data.each do |k, v|
+          if klass = _form[k.to_s.to_sym]
+            d = data[k]
+            d = d.attributes if d.is_a?(Form)
+
+            f  = klass.new d
+            k  = "#{k}_attributes"
+            dt = f.model_attributes
+
+            hash[k] = model_attributes dt
+          elsif v.is_a? Hash
+            hash[k] = model_attributes data[k]
+          else
+            hash[k] = v
+          end
+        end
+
+        hash
+      end
+
+      def slice(*keys)
+        Hash.new.tap do |atts|
+          keys.each do |att|
+            atts[att] = send(att)
+            # atts[att] = _attributes.send(att)
+          end
+        end
+      end
+
+      def display_errors options = {}, &block
+        dom = options.delete(:dom) || _dom
+        d_errors = errors
+
+        if override_errors = options[:override_errors]
+          d_errors = override_errors
+        end
+
+        keys = options.delete(:keys) || (_options[:key] ? [_options[:key]] : [])
+
+        if extra_errors = options.delete(:errors)
+          extra_errors.each do |key, value|
+            d_errors[key] = value
+          end
+        end
+
+        d_errors.each do |key, error|
+          d_keys = (keys.dup << key)
+
+          error = error.first
+
+          if error.is_a?(Hash)
+            d_options = options.dup
+            d_options[:keys] = d_keys
+            d_options[:override_errors] = d_errors[key].first
+
+            display_errors d_options, &block
+          elsif !block_given? || block.call(d_keys, error) == false
+            name = d_keys.each_with_index.map do |field, i|
+              i != 0 ? "[#{field}]" : field
+            end.join
+
+            if tmpl = options[:tmpl]
+              if client?
+                field_error_dom = DOM.new(`#{tmpl.dom}[0].outerHTML`)
+              else
+                field_error_dom = DOM.new(tmpl.dom.to_html)
+              end
+            else
+              field_error_dom = DOM.new('<span class="field-error"><span>')
+            end
+
+            field_error_dom.html _error_name(key, error)
+
+            field = dom.find("[name='#{name}']")
+            field.before field_error_dom.dom
+          end
+        end
+      end
+      alias_method :render_errors, :display_errors
+
+      def render_values dom = false, key = false, data = false
+        dom = _options[:dom] unless dom
+        key = _options[:key] if !key && _options.key?(:key)
+
+        dom.find('input, select, textarea') do |element|
+          name  = element['name']
+          name  = name.gsub(/\A#{key}/, '') if key
+          keys  = name.gsub(/\A\[/, '').gsub(/[^a-z0-9_]/, '|').gsub(/\|\|/, '|').gsub(/\|$/, '').split('|')
+          value = false
+
+          keys.each do |k|
+            begin
+              value = value ? value.send(k) : send(k)
+            rescue
+              value = ''
+            end
+          end
+
+          case element.name
+          when 'select'
+            element.find('option') do |x|
+              x['selected'] = true if x['value'] == value.to_s
+            end
+          when 'input'
+            if %w(radio checkbox).include? element['type']
+              if element['value'] == value.to_s
+                element['checked'] = true
+              else
+                element.delete 'checked'
+              end
+            else
+              value = sprintf('%.2f', value) if value.is_a? BigDecimal
+              element['value'] = value.to_s
+            end
+          when 'textarea'
+            element.val value.to_s
+          end
+        end
+      end
+
+      def _attributes
+        @_attributes ||= {}
+      end
+
+      def validate_msg error, column
+        false
+      end
+
+      protected
+
+      def _data
+        @_data ||= {}
+      end
+
+      def self._attr_accessors
+        @_attr_accessors ||= []
+      end
+
+      def self._form
+        @_form || {}
+      end
+
+      def _form
+        self.class._form
+      end
+
+      def _attr_accessors
+        self.class._attr_accessors
+      end
+
+      def _options
+        @_options
+      end
+
+      def _dom
+        @_dom ||= @_options[:dom]
+      end
+
+      def _error_name key, error
+        validate_msg(error.to_sym, key.to_sym) || case error.to_s.to_sym
+        when :not_email
+          'Email Isn\'t Valid.'
+        when :not_present
+          'Required.'
+        when :not_equal
+          'Password does not match.'
+        else
+          !error[/\s/] ? error.to_s.gsub(/_/, ' ').titleize : error
+        end
+      end
+
+      def empty?
+        _attributes.empty?
+      end
+
+      module InstanceMethods
+        def render_fields data, options = {}
+          data = data.is_a?(Hash) ? data.to_obj : data
+
+          l_dom = options[:dom] || dom
+
+          l_dom.find("[data-if]") do |field_dom|
+            value = get_value_for field_dom['data-if'], data
+
+            unless value.present?
+              field_dom.remove
+            end
+          end
+
+          l_dom.find("[data-unless]") do |field_dom|
+            value = get_value_for field_dom['data-unless'], data
+
+            if value.present?
+              field_dom.remove
+            end
+          end
+
+          l_dom.find("[data-field]") do |field_dom|
+            if field = field_dom['data-field']
+              value = get_value_for field, data
+
+              if !value.nil?
+                value = value.to_s
+
+                if value != value.upcase && !value.match(Wedge::Plugins::Form::EMAIL)
+                  field_value = value.titleize
+                else
+                  field_value = value
+                end
+
+                field_value = 'No'  if field_value == 'False'
+                field_value = 'Yes' if field_value == 'True'
+
+                field_dom.html = field_value
+              else
+                field_dom.html = ''
+              end
+            end
+          end
+
+          l_dom
+        end
+
+        def get_value_for field, data
+          field = (field || '').split '.'
+
+          if field.length > 1
+            value = data.is_a?(Hash) ? data.to_obj : data
+
+            field.each_with_index do |f, i|
+              # might not have the parent object
+              if (value.respond_to?('empty?') ? value.empty? : !value.present?)
+                value = ''
+                next
+              end
+
+              if (i+1) < field.length
+                begin
+                  value = value.send(f)
+                rescue
+                  value = nil
+                end
+              else
+                begin
+                  value = value.respond_to?(:present) ? value.present("print_#{f}") : value.send(f)
+                rescue
+                  value = nil
+                end
+              end
+
+            end
+          else
+            begin
+              value = data.respond_to?(:present) ? data.present("print_#{field.first}") : data.send(field.first)
+            rescue
+              value = nil
+            end
+          end
+
+          value
+        end
+      end
+    end
+  end
+end
+
+Wedge::Form = Wedge::Plugins::Form