wedge 0.1.17 → 0.1.18

data/lib/wedge/middleware.rb

@@ -1,24 +1,47 @@
 class Wedge
   class Middleware
-    def initialize(app, settings = {})
-      @app = app
-
-      # Add settings to wedge
-      settings.each do |k, v|
-        Wedge.config.send "#{k}=", v
+    def initialize(app = false, settings = {}, scope = false)
+      @app   = app
+      @scope = scope || self.class.scope
+      @opal  = Wedge::Opal::Server.new { |s|
+        s.prefix = Wedge.config.assets_url
+        s.debug  = Wedge.config.debug
+        s.append_path "#{Dir.pwd}/#{Wedge.config.app_dir}"
+      }
+
+      case settings
+      when Proc
+        Wedge.config.instance_eval &settings
+      else
+        settings.each { |k, v| Wedge.config.send "#{k}=", v }
       end
     end
 
     def call(env)
-      responder = Responder.new(@app, env)
+      responder = Responder.new(@app, @opal, @scope, env)
       responder.respond
     end
 
+    class << self
+      attr_accessor :scope
+
+      def scope! scope
+        klass = Class.new(self)
+        klass.instance_variable_set(:@scope, scope)
+        klass
+      end
+
+      def call env
+        self.new.call env
+      end
+    end
+
     class Responder
+      attr_reader :opal, :scope
       attr_accessor :app, :env, :wedge_path, :extension
 
-      def initialize(app, env)
-        @app = app; @env = env
+      def initialize(app, opal, scope, env)
+        @app = app; @opal = opal; @scope = (scope || self); @env = env
       end
 
       def respond
@@ -26,17 +49,7 @@ class Wedge
           @wedge_path, @extension = $1, $2
           body, headers, status = [], {}, 200
 
-          case extension
-          when 'map'
-            body << ::Wedge.source_map(wedge_path)
-          when 'rb'
-            if wedge_path =~ /^wedge/
-              path = ::Wedge.config.path.gsub(/\/wedge.rb$/, '')
-              body << File.read("#{path}/#{wedge_path}.rb")
-            else
-              body << File.read("#{ROOT_PATH}/#{wedge_path}.rb")
-            end if Wedge.config.debug
-          when 'call'
+          if extension == 'call'
             body_data = request.body.read
             data      = request.params
 
@@ -58,16 +71,17 @@ class Wedge
             method_args   = data.delete(:__wedge_args__)
 
             if method_args == '__wedge_data__' && data
-              method_args   = [data]
-              res = Wedge.scope!(self)[name].send(method_called, *method_args) || ''
+              method_args = [data]
+              res         = Wedge.scope!(scope)[name].send(method_called, *method_args) || ''
             else
               # This used to send things like init, we need a better way to
               # send client config data to the server
               # res = scope.wedge(name, data).send(method_called, *method_args) || ''
-              res = Wedge.scope!(self)[name].send(method_called, *method_args) || ''
+              res = Wedge.scope!(scope)[name].send(method_called, *method_args) || ''
             end
 
-            # headers["WEDGE-CSRF-TOKEN"] = scope.csrf_token if scope.methods.include? :csrf_token
+            # discuss: I don't think we should update the csrf token # every ajax call
+            # headers["WEDGE-CSRF-TOKEN"] = self.csrf_token if self.methods.include? :csrf_token
 
             if res.is_a? Hash
               headers["Content-Type"] = 'application/json; charset=UTF-8'
@@ -75,17 +89,11 @@ class Wedge
             else
               body << res.to_s
             end
-          else
-            headers['Content-Type'] = 'application/javascript; charset=UTF-8'
 
-            if Wedge.config.debug
-              body << "#{Wedge.javascript(wedge_path)}\n//# sourceMappingURL=#{Wedge.assets_url}/#{wedge_path}.map"
-            else
-              body << Wedge.javascript(wedge_path)
-            end
+            [status, headers, body]
+          else
+            @opal.call env
           end
-
-          [status, headers, body.join]
         else
           response.finish
         end
@@ -98,7 +106,7 @@ class Wedge
       private
 
       def path
-        @env['PATH_INFO']
+        @env['PATH_INFO'].present?? @env['PATH_INFO'] : @env['PATH_INFO'] = @env['REQUEST_PATH']
       end
 
       def request
@@ -107,7 +115,7 @@ class Wedge
 
       def response
         @response ||= begin
-          status, headers, body = @app.call(request.env)
+          status, headers, body = (@app ? @app.call(request.env) : [404, {}, ''])
           Rack::Response.new(body, status, headers)
         end
       end

data/lib/wedge/opal.rb

@@ -34,11 +34,20 @@ unless RUBY_ENGINE == 'opal'
               @result << Builder.build(path).to_s
             end
           elsif comp_class
-            comp_class.config.on_compile.each { |blk| comp_class.instance_eval(&blk) }
+            comp_class.config.on_compile.each { |blk| comp_class.instance_exec(true, &blk) }
             comp_name     = comp_class.config.name
             compiled_data = Base64.encode64 comp_class.config.client_data.to_json
+            js            = ''
+
+            js << "require '#{self.file}'; Wedge.config.component_class[:#{comp_name}].config.data = HashObject.new(Wedge.config.component_class[:#{comp_name}].config.data.to_h.merge JSON.parse(Base64.decode64('#{compiled_data}')))"
+            # todo: discuss: pass plugin settings that were set server side?
+            js << "; Wedge.plugin(:#{comp_name.to_s.gsub(/_plugin$/, '')})" if comp_class.config.is_plugin
 
-            @result << Opal.original_compile("require '#{self.file}'; Wedge.config.component_class[:#{comp_name}].config.data = HashObject.new(Wedge.config.component_class[:#{comp_name}].config.data.to_h.merge JSON.parse(Base64.decode64('#{compiled_data}')))")
+            @result << Opal.original_compile(js)
+
+            if compile_str = comp_class.config.compile_str
+              @result << compile_str
+            end
 
             load_requires logical_path
           end
@@ -74,10 +83,12 @@ end
 
 if RUBY_ENGINE == 'opal'
   class Element
-    alias_native :mask
+    # alias_native :mask
     alias_native :remove_data, :removeData
     alias_native :replace_with, :replaceWith
-    alias_native :selectize
+    # alias_native :selectize
   end
+else
+  Wedge::Opal.use_gem 'wedge'
 end
 

data/lib/wedge/plugins/ability_list.rb

@@ -0,0 +1,95 @@
+require 'wedge/plugins/form'
+
+class Wedge
+  module Plugins
+    class AbilityList < Form
+      name :ability_list_plugin
+
+      Error = Class.new(StandardError)
+
+      # Returns a list of rules. These are populated by `can` and `cannot`.
+      # (Rules are tuples)
+      def rules
+        @rules ||= []
+      end
+
+      # ---
+
+      # Declares that the owner can perform `verb` on `class`.
+      def can(verb, klass=nil, columns=[], &block)
+        columns = [columns] unless columns.is_a? Array
+        rules << [true, verb, get_class(klass), columns, block]
+      end
+
+      # Inverse of `can`.
+      def cannot(verb, klass=nil, columns=[], &block)
+        columns = [columns] unless columns.is_a? Array
+        rules << [false, verb, get_class(klass), columns, block]
+      end
+
+      # ---
+
+      # Checks if the owner can perform `verb` on the given `object` (or class).
+      def can?(verb, object=nil, columns=[])
+        columns = [columns] unless columns.is_a? Array
+        rules = rules_for(verb, get_class(object))
+        rules.inject(false) do |bool, (sign, _, _, cols, proc)|
+          sign ?
+            ((bool || !proc ||  proc.call(object)) && ((columns & cols) == columns)) :  # can
+            (bool &&  proc && !proc.call(object) && (columns.empty? || (columns & cols) != columns))    # cannot
+        end
+      end
+
+      # Inverse of `can?`.
+      def cannot?(verb, object=nil, columns=[])
+        !can?(verb, object, columns)
+      end
+
+      # ---
+
+      # Ensures that the owner can perform `verb` on `object/class` -- raises an
+      # error otherwise.
+      def authorize!(verb, object=nil)
+        can?(verb, object) or raise Error.new("Access denied (#{verb})")
+      end
+
+      # Inverse of `authorize!`.
+      def unauthorize!(verb, object=nil)
+        cannot?(verb, object) or raise Error.new("Access denied (#{verb})")
+      end
+
+      # ---
+
+      # Returns a subset of `rules` that match the given `verb` and `class`.
+      def rules_for(verb, klass)
+        rules.select do |(sign, _verb, _klass, cols, block)|
+          (_verb  == :manage || _verb  == verb) &&
+          (_klass == :all    || _klass == klass)
+        end
+      end
+
+    private
+
+      def get_class(object)
+        [NilClass, Symbol, Class].include?(object.class) ? object : object.class
+      end
+    end
+
+    # Provides `#can?` and `#cannot?` and other helpers.
+    # Assumes that you have an `#ability` method defined.
+    module AbilityList::Helpers
+      def can?(*a)
+        abilities && abilities.can?(*a)
+      end
+
+      def cannot?(*a)
+        !abilities || abilities.cannot?(*a)
+      end
+
+      def authorize!(*a)
+        raise AbilityList::Error.new("No 'ability' defined") unless abilities
+        abilities.authorize!(*a)
+      end
+    end
+  end
+end

data/lib/wedge/plugins/current_user.rb

@@ -0,0 +1,48 @@
+require 'wedge/plugins/form'
+
+class Wedge
+  module Plugins
+    class CurrentUser < Form
+      plugin :ability_list
+
+      include AbilityList::Helpers
+
+      name :current_user_plugin
+
+      on :compile do |for_client|
+        # todo: raise error meaningful error if either of these files don't exist
+        %w'ability_list current_user'.each do |type|
+          config.compile_str ||= ''
+          path = Wedge.config.component_class[:"#{type}"].config.path
+          code = File.read("#{Dir.pwd}/#{Wedge.config.app_dir}/#{path}.rb")
+          config.compile_str << Opal.original_compile("require 'wedge/plugins/#{type}'; #{code}")
+        end if for_client
+      end
+
+      module InstanceMethods
+        def wedge_current_user
+          @wedge_current_user ||= Wedge[:current_user, wedge(:current_user_plugin).get_current_user]
+        end
+        alias_method :current_user, :wedge_current_user
+      end
+
+      on :server do
+        def get_current_user
+          data = instance_exec(&Wedge[:current_user_plugin].config.block) || {}
+
+          if from_client?
+            form          = Wedge[:current_user, data]
+            client_fields = config.settings[:client_fields]
+            form.attributes.select { |k, v| client_fields.include? k }
+          else
+            data
+          end
+        end
+      end
+
+      def abilities
+        @abilities ||= Wedge[:ability_list, self]
+      end
+    end
+  end
+end

data/lib/wedge/plugins/factory.rb

@@ -0,0 +1,36 @@
+class Wedge
+  module Plugins
+    class Factory < Form
+      name :factory, :factory_plugin
+
+      def initialize
+        class_store[:stubs] ||= IndifferentHash.new
+      end
+
+      def stub data, name, keys = false
+        class_store[:stubs][name] = parse data, keys
+      end
+
+      def [] name, data = {}
+        data = IndifferentHash.new(data)
+        store_data = IndifferentHash.new class_store[:stubs][name].deep_dup
+        HashObject.new store_data.merge data
+      end
+
+      private
+
+      def parse data, keys = false
+        data        = data.deep_dup
+        parsed_data = data.to_h if data.respond_to? :to_h
+        parsed_data = JSON.parse data.to_json
+
+        keys.each do |k, v|
+          d = data.kind_of?(Hash) ? data[k] : data.send(k)
+          parsed_data[k] = parse d, v
+        end if keys
+
+        parsed_data
+      end
+    end
+  end
+end

data/lib/wedge/plugins/form.rb

@@ -1,5 +1,5 @@
-require 'wedge/plugins/validations'
-require 'forwardable'
+require_relative 'form/validations'
+require_relative 'render'
 
 class Wedge
   module Plugins
@@ -8,13 +8,16 @@ class Wedge
 
       include Methods
       include Validations
+      include Render
 
+      # This allows us to call super
       module Delegates
         def _delegates(*names)
           accessors = Module.new do
-            extend Forwardable # DISCUSS: do we really need Forwardable here?
+            extend Forwardable
+
             names.each do |name|
-              delegate [name, "#{name}="] => :_attributes
+              delegate [name, "#{name}="] => :_atts
             end
           end
           include accessors
@@ -23,420 +26,290 @@ class Wedge
 
       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
+      class Atts
+        attr_accessor :_atts, :_form
+        attr_reader :_options, :_accessors, :_aliases
 
-        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
+        def initialize atts, accessors, aliases, options
+          @_atts      = atts.kind_of?(Hash) ? HashObject.new(atts) : atts
+          @_accessors = accessors
+          @_aliases   = aliases
+          @_options   = options
 
-            define_singleton_method attr do
-              instance_variable_get(:"@#{attr}")
-            end
-          end
-        end
+          set_atts
+          set_accessors
 
-        def _attributes
-          @_attributes ||= []
+          self
         end
 
-        def empty?
-          _attributes.empty?
-        end
-      end
+        def set_atts
+          atts_hash = {}
 
-      # 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))
+          _accessors.each do |att|
+            atts_hash[att] = _atts.respond_to?(att) ? _atts.send(att) : nil
           end
-          @_attributes.set_values opts
 
-          send("#{key}=", opts[key])
+          @_atts = HashObject.new atts_hash
         end
-      end
 
-      def self.attr_accessor(*vars)
-        @_attr_accessors ||= []
-        @_form ||= {}
+        def set_accessors
+          _accessors.each do |att|
+            att_options = _options[att]
+            alias_att   = _aliases[att]
+
+            define_singleton_method att do
+              _atts.send(att) if can_read?(att)
+            end
 
-        vars.each do |v|
-          if !v.is_a? Hash
-            @_attr_accessors << v unless @_attr_accessors.include? v
-          else
-            v = v.first
+            define_singleton_method "#{att}=" do |val, override = false|
+              if can_write?(att, override)
+                _atts.send("#{att}=", process_value(val, att_options))
+              end
+            end
 
-            unless @_attr_accessors.include? v.first
-              @_attr_accessors << v.first
-              @_form[v.first] = v.last
+            if alias_att
+              define_singleton_method(alias_att) { send(att) }
+              define_singleton_method("#{alias_att}=") { |val, override = false| send("#{att}=", val, override) }
             end
           end
         end
 
-        _delegates(*_attr_accessors)
-      end
+        def can_read? att
+          att_options = _options[att]
 
-      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/]
+          return true if !att_options[:if] && !att_options[:unless]
+          return true if att_options[:if] && _form.instance_exec(&att_options[:if])
+          return true if att_options[:unless] && !_form.instance_exec(&att_options[:unless])
 
-          super
+          false
         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
+        def can_write? att, override = false
+          att_options = _options[att]
 
-            att = ivar[1..-1].to_sym
-            atts[att] = _attributes.send(att)
+          override || (can_read?(att) && (!att_options[:read_only]))
+        end
 
-            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
+        def set_defaults _form = self
+          @_form = _form
+
+          _accessors.each do |att|
+            att_options = _options[att].deep_dup
+            default     = att_options[:default]
+            default     = _form.instance_exec(&default) if default.kind_of? Proc
+            default     = _form.send("default_#{att}") if _form.respond_to? "default_#{att}"
+
+            if form = att_options.delete(:form)
+              send("#{att}=", Wedge[
+                # name
+                "#{form}_form",
+                # attributes
+                (_atts.respond_to?(att) ? (_atts.send(att) || {}) : {}),
+                # options
+                { _nested: true }.merge(att_options)
+              ])
+            elsif att_options.key? :default
+              send("#{att}=", default, true)
             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
+          self
         end
 
-        hash
-      end
-
-      def slice(*keys)
-        Hash.new.tap do |atts|
-          keys.each do |att|
-            atts[att] = send(att)
-            # atts[att] = _attributes.send(att)
+        def process_value val, opts
+          # Make sure the value is the correct type
+          if type = opts[:type]
+            val = case type
+            when 'Integer'
+              val.to_i
+            when 'String'
+              val.to_s
+            when 'Symbol'
+              val.to_sym
+            end
           end
+
+          val
         end
       end
 
-      def display_errors options = {}, &block
-        dom = options.delete(:dom) || _dom
-        d_errors = errors
+      class << self
+        attr_accessor :_accessors, :_accessor_options, :_aliases
 
-        if override_errors = options[:override_errors]
-          d_errors = override_errors
-        end
+        alias_method :original_attr_reader, :attr_reader
+        def attr_reader(*attrs, &block)
+          default_opts = { read_only: true }
+          opts = attrs.pop
+          opts.merge!(default_opts) if opts.is_a? Hash
 
-        keys = options.delete(:keys) || (_options[:key] ? [_options[:key]] : [])
+          attrs << opts
 
-        if extra_errors = options.delete(:errors)
-          extra_errors.each do |key, value|
-            d_errors[key] = value
-          end
+          attr_accessor(*attrs, &block)
         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
+        def form_accessor name, options = {}
+          attr_accessor *[name, { form: name }.merge(options)]
+        end
 
-            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)
+        alias_method :original_attr_accessor, :attr_accessor
+        def attr_accessor(*attrs, &block)
+          attrs.each_with_index do |att, i|
+            if att.is_a? Hash
+              # remove the hash from the attrs, use them as options
+              options = attrs.delete_at i
+              # set the type class to aa string so it's not turned into an
+              # anonymous class
+              if type = options.delete(:type)
+                options[:type] = type.to_s
+              end
+              # merge and att them to the accessor options
+              attrs.each do |a|
+                ((@_accessor_options ||= IndifferentHash.new)[a] ||= {}).merge! options
               end
             else
-              field_error_dom = DOM.new('<span class="field-error"><span>')
+              # issue: OPAL is not using the alias method original_attr_reader
+              # correctly.  It's still somehow getting in here when called below.
+              next if %w'_atts _options'.include? att.to_s
+              ###################################################################
+
+              # set empty options if need be
+              (@_accessor_options ||= IndifferentHash.new)[att] ||= {}
+              # store the accessors
+              ((@_accessors ||= []) << att).uniq!
+              define_method(att) { _atts.send att }
             end
-
-            field_error_dom.html _error_name(key, error)
-
-            field = dom.find("[name='#{name}']")
-            field.before field_error_dom.dom
           end
+
+          _delegates(*attrs)
         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
+        # We need to set instance variables on the inherited class
+        def inherited(subclass)
+          return if name == 'Wedge::Plugins::Form'
+
+          subclass.instance_variable_set :@_accessors, @_accessors.deep_dup
+          subclass.instance_variable_set :@_accessor_options, @_accessor_options.deep_dup
         end
-      end
 
-      def _attributes
-        @_attributes ||= {}
+        def model_alias alias_name, original_name
+          @_aliases ||= IndifferentHash.new
+          @_aliases[original_name] = alias_name
+          # discuss: should we also alias_method. right now I'm think no, reason
+          # being it's just a model alias and shouldn't allow people to call
+          # that method on the form to avoid some people using one name and some
+          # another.
+          # alias_method alias_name, original_name
+        end
+        alias alias_model model_alias
       end
 
-      def validate_msg error, column
-        false
-      end
+      original_attr_reader :_atts, :_options
 
-      protected
+      # Initialize with a hash of attributes and values.
+      # Extra attributes are discarded.
+      #
+      # @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 = {})
+        atts      = atts.deep_dup
+        @_options = options.indifferent
+        @_atts    = Atts.new atts, _accessors, _aliases, _accessor_options
+        @_atts    = @_atts.set_defaults self
 
-      def _data
-        @_data ||= {}
-      end
+        atts.each do |key, val|
+          # grab the original key if alias is given
+          key = _aliases.invert[key] || key
 
-      def self._attr_accessors
-        @_attr_accessors ||= []
-      end
+          next if (_accessor_options[key] || {})[:form]
 
-      def self._form
-        @_form || {}
-      end
+          accessor = "#{key}="
 
-      def _form
-        self.class._form
+          if respond_to?(accessor)
+            send(accessor, val)
+          end
+        end
       end
 
-      def _attr_accessors
-        self.class._attr_accessors
+      def _accessors
+        @_accessors ||= (self.class._accessors || IndifferentHash.new).deep_dup
       end
 
-      def _options
-        @_options
+      def _accessor_options
+        @_accessor_options ||= (self.class._accessor_options || IndifferentHash.new).deep_dup
       end
 
-      def _dom
-        @_dom ||= @_options[:dom]
+      def _aliases
+        @_aliases || (self.class._aliases || IndifferentHash.new).deep_dup
       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
+      def nested?
+        @_options[:_nested] ? true : false
       end
 
-      def empty?
-        _attributes.empty?
+      def attributes?
+        @_options[:_attributes] ? true : false
       end
 
-      def wedge_config
-        @wedge_config ||= begin
-          c = super
-          c.skip_method_wrap
-          c
-        end
+      def model_attributes?
+        @_options[:_model_attributes] ? true : false
       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
+      # Return hash of attributes and values.
+      def attributes for_model = false
+        IndifferentHash.new.tap do |atts|
+          _options[:_attributes]       = true
+          _options[:_model_attributes] = for_model
+
+          _accessors.each do |att|
+            opts = _accessor_options[att]
+            if _atts.can_read?(att) && (!opts[:hidden] || opts[:hidden].is_a?(Proc) && !self.instance_exec(&opts[:hidden]))
+              is_form   = opts[:form]
+              key       = for_model ? _aliases[att] || att : att
+              key       = (for_model && is_form)? "#{key}_attributes" : key
+              atts[key] = is_form ? send(att).send(for_model ? 'model_attributes' : 'attributes') : send(att)
             end
           end
-
-          l_dom
         end
+      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
+      def model_attributes
+        attributes true
+      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
+      alias atts _atts
+      alias options _options
 
-            end
-          else
-            begin
-              value = data.respond_to?(:present) ? data.present("print_#{field.first}") : data.send(field.first)
-            rescue
-              value = nil
-            end
+      def slice(*keys)
+        IndifferentHash.new.tap do |atts|
+          keys.each do |att|
+            atts[att] = send(att)
           end
-
-          value
         end
       end
     end
   end
 end
-
-Wedge::Form = Wedge::Plugins::Form