wedge 0.1.17 → 0.1.18

data/lib/wedge/plugins/{validations.rb → form/validations.rb}

@@ -50,25 +50,7 @@ class Wedge
       #          :date  => [:format] }
       #
       module Validations
-        def server? &block
-          RUBY_ENGINE == 'ruby'
-        end
-        alias :server :server?
-
-        def client?
-          RUBY_ENGINE == 'opal'
-        end
-        alias :client :client?
-
-        def self.server? &block
-          RUBY_ENGINE == 'ruby'
-        end
-        alias :server :server?
-
-        def self.client?
-          RUBY_ENGINE == 'opal'
-        end
-        alias :client :client?
+        include Methods
 
         # Check if the current model state is valid. Each call to {#valid?} will
         # reset the {#errors} array.
@@ -88,18 +70,40 @@ class Wedge
         #   end
         #
         def valid?
-          errors.clear
+          _errors.clear
           validate
-          errors.empty?
+          _errors.empty?
         end
 
         # Base validate implementation. Override this method in subclasses.
         def validate
         end
 
-        # Hash of errors for each attribute in this model.
+        def error key, value
+          value = [value] unless value.is_a? Array
+          _errors[key] = value
+        end
+
         def errors
-          @errors ||= Hash.new { |hash, key| hash[key] = [] }
+          IndifferentHash.new(_errors)
+        end
+
+        # gives back errors using the model_alias keys
+        def model_errors
+          IndifferentHash.new(_model_errors)
+        end
+
+        # Hash of errors for each attribute in this model.
+        def _errors
+          @_errors ||= Hash.new do |hash, key|
+            data = _accessor_options[key].key?(:form) ? {} : []
+            alias_key       = _aliases[key] || key
+           _model_errors[alias_key] = hash[key] = data
+          end
+        end
+
+        def _model_errors
+          @_model_errors ||= {}
         end
 
         protected
@@ -115,7 +119,7 @@ class Wedge
         # @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)
+          if !send(att).to_s.empty?
             assert(_attributes.send(att).to_s.match(format), error)
           end
         end
@@ -130,25 +134,35 @@ class Wedge
           if att.is_a? Array
             att.each { |a| assert_present(a, error = [a, :not_present])}
           else
-            if form_name = _form[att]
-              options = {}
-              options[:key] = _options[:key] if _options.key? :key
+            att_options = _accessor_options[att].deep_dup
 
-              f = wedge(form_name, _attributes.send(att).attributes, options)
-              assert(f.valid?, [att, f.errors])
+            if att_options.key? :form
+              assert_form att, error
             else
-              assert(!_attributes.send(att).to_s.empty?, error)
+              assert(!send(att).to_s.empty?, error)
             end
           end
         end
 
+        def assert_form(att, error = [att, :no_form])
+          att_options = _accessor_options[att].deep_dup
+          form_name   = att_options.delete :form
+
+          f = wedge("#{form_name}_form", send(att).attributes, att_options)
+          assert(f.valid?, [att, f._errors])
+        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)
+          # discuss: I commented this out as I don't think we should assume they
+          # want to validate presents if they validate for numeric. if they
+          # validate for numeric.
+          # if assert_present(att, error)
+          if !send(att).to_s.empty?
             if client?
               assert_format(att, /^\-?\d+$/, error)
             else
@@ -158,13 +172,13 @@ class Wedge
         end
 
         if client?
-          URL = /^(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})?(\/.*)?$/i
+          URL = /^(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(25[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})?(\/.*)?$/i
         else
-          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
+          URL = /\A(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(25[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
         end
 
         def assert_url(att, error = [att, :not_url])
-          if assert_present(att, error)
+          if !send(att).to_s.empty?
             assert_format(att, URL, error)
           end
         end
@@ -176,7 +190,7 @@ class Wedge
         end
 
         def assert_email(att, error = [att, :not_email])
-          if assert_present(att, error)
+          if !send(att).to_s.empty?
             assert_format(att, EMAIL, error)
           end
         end
@@ -186,7 +200,7 @@ class Wedge
         end
 
         def assert_length(att, range, error = [att, :not_in_range])
-          if assert_present(att, error)
+          if !send(att).to_s.empty?
             val = _attributes.send(att).to_s
             assert range.include?(val.length), error
           end
@@ -243,7 +257,20 @@ class Wedge
         #     end
         #   end
         def assert(value, error)
-          value or errors[error.first].push(error.last) && false
+          value or begin
+            name   = error.shift.to_s
+            atts   = _accessor_options[name][:atts] || false
+            error  = atts ? error.first.select {|k, _| atts.include?(k) } : error
+            errors = _errors[name]
+
+            if errors.is_a?(Array)
+              errors.concat(error) && false
+            else
+              errors.merge!(error.is_a?(Array) ? error.first : error) && false
+            end
+
+            false
+          end
         end
       end
     end

data/lib/wedge/plugins/form_backup.rb

@@ -0,0 +1,442 @@
+require 'wedge/plugins/validations'
+require 'forwardable'
+
+class Wedge
+  module Plugins
+    class Form < Component
+      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, form_name|
+          opts = {}
+          if _data.respond_to?(key)
+            opts[key] = wedge(form_name, _data.send(key))
+          end
+          @_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 form_name = _form[att.to_s.to_sym]
+              atts[att] = wedge(form_name, atts[att].respond_to?(:attributes)? atts[att].attributes : atts[att]).attributes
+            end
+          end
+        end
+      end
+
+      def model_attributes data = attributes
+        hash = {}
+
+        data.each do |k, v|
+          if form_name = _form[k.to_s.to_sym]
+            d = data[k]
+            d = d.attributes if d.is_a?(Form)
+
+            f  = wedge(form_name, 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']
+          next if name.nil?
+          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 != false ? 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
+
+      def wedge_config
+        @wedge_config ||= begin
+          c = super
+          c.skip_method_wrap
+          c
+        end
+      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