storefront 0.5.1 → 0.5.2

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
   s.name              = "storefront"
   s.authors           = ["Lance Pollard"]
-  s.version           = "0.5.1"
+  s.version           = "0.5.2"
   s.description       = "Opinionated Forms, Tables, and Widgets for Rails and Sinatra"
   s.summary           = "A simple and semantic FormBuilder, TableBuilder, Locale Interpolator, and Widget API for Rails 3 and Sinatra"
   s.homepage          = "http://github.com/viatropos/storefront"

data/lib/storefront.rb

@@ -22,5 +22,6 @@ require "storefront/configuration"
 
 Dir["#{this}/storefront/helpers/**/*"].each { |path| require path unless ::File.directory?(path) }
 require "storefront/components/base"
+require "storefront/components/form"
 Dir["#{this}/storefront/components/**/*"].each { |path| require path unless ::File.directory?(path) }
 Dir["#{this}/storefront/models/**/*"].each { |path| require path unless ::File.directory?(path) }

data/lib/storefront/components/form.rb

@@ -1,8 +1,6 @@
-require 'storefront/components/form/base'
-
 module Storefront
   module Components
-    class Form < Base
+    class Form < ::Storefront::Components::Base
       attr_reader :model, :template, :tabindex, :access_keys, :attributes
       delegate :object, :parent, :to => :model
       
@@ -11,7 +9,7 @@ module Storefront
         @template   = template
         @model      = Storefront::Model.new(:object => extract_object!(args.shift))
         @attributes = extract_attributes!(options)
-        @builder    = Storefront::Form::Builder.new(
+        @builder    = Storefront::Components::Form::Builder.new(
           :template    => template, 
           :tabindex    => 1, 
           :access_keys => {},

data/lib/storefront/components/form/base.rb

@@ -1,49 +1,51 @@
 module Storefront
-  class Form
-    class Base < Storefront::Components::Base
-      include Storefront::Helpers::ContentHelper
-      include Storefront::Helpers::DomHelper
-      
-      def initialize(options = {})
-        @template       = options[:template]
-        @model          = options[:model]
-        @attribute      = options[:attribute]
-        @parent_index   = options[:parent_index]
-        @index          = options[:index]
-        @tabindex       = options[:tabindex]
-        @access_keys    = options[:access_keys]
-        @attributes     = clone_attributes(options.except(:template, :model, :attribute, :access_keys, :index, :tabindex))
-      end
-      
-      protected
+  module Components
+    class Form
+      class Base < Storefront::Components::Base
+        include Storefront::Helpers::ContentHelper
+        include Storefront::Helpers::DomHelper
+        
+        def initialize(options = {})
+          @template       = options[:template]
+          @model          = options[:model]
+          @attribute      = options[:attribute]
+          @parent_index   = options[:parent_index]
+          @index          = options[:index]
+          @tabindex       = options[:tabindex]
+          @access_keys    = options[:access_keys]
+          @attributes     = clone_attributes(options.except(:template, :model, :attribute, :access_keys, :index, :tabindex))
+        end
       
-      attr_accessor :template, :model, :attribute, :index, :parent_index
-      attr_accessor :attributes, :value, :label, :access_keys, :tabindex, :input_type
+        protected
       
-      def default_options!(options = {})
-        options[:model]     ||= model
-        options[:index]     ||= index
-        options[:attribute] ||= attribute
-        options[:template]  ||= template
-        options
-      end
+        attr_accessor :template, :model, :attribute, :index, :parent_index
+        attr_accessor :attributes, :value, :label, :access_keys, :tabindex, :input_type
       
-      def config
-        Storefront.configuration
-      end
-      alias_method :storefront_config, :config
+        def default_options!(options = {})
+          options[:model]     ||= model
+          options[:index]     ||= index
+          options[:attribute] ||= attribute
+          options[:template]  ||= template
+          options
+        end
       
-      def value?
-        @value.present?
-      end
+        def config
+          Storefront.configuration
+        end
+        alias_method :storefront_config, :config
       
-      def localize(key, attribute, default, options = {})
-        if default.present?
-          return default.to_s unless default.is_a?(::Symbol)
-          attribute = default
+        def value?
+          @value.present?
         end
+      
+        def localize(key, attribute, default, options = {})
+          if default.present?
+            return default.to_s unless default.is_a?(::Symbol)
+            attribute = default
+          end
         
-        t?(attribute, options.reverse_merge(:scope => :"forms.#{key}", :model => model.object))
+          t?(attribute, options.reverse_merge(:scope => :"forms.#{key}", :model => model.object))
+        end
       end
     end
   end

data/lib/storefront/components/form/builder.rb

@@ -1,123 +1,125 @@
 module Storefront
-  class Form
-    class Builder < Storefront::Form::Base
-      delegate :object, :parent, :to => :model
+  module Components
+    class Form
+      class Builder < Storefront::Components::Form::Base
+        delegate :object, :parent, :to => :model
       
-      def fieldset(*args, &block)
-        options                     = default_options!(args.extract_options!)
-        options[:label]           ||= args.shift
+        def fieldset(*args, &block)
+          options                     = default_options!(args.extract_options!)
+          options[:label]           ||= args.shift
         
-        Storefront::Form::Fieldset.new(options).render(&block)
-      end
+          Storefront::Components::Form::Fieldset.new(options).render(&block)
+        end
       
-      def fields(*args, &block)
-        options           = args.extract_options!
-        options[:as]      = :fields
-        options[:label] ||= false
-        attr_name         = args.shift || attribute.name
-        template.capture_haml do
-          result          = field attr_name, options do |_field|
-            template.haml_concat fieldset(&block).gsub(/\n$/, "")
+        def fields(*args, &block)
+          options           = args.extract_options!
+          options[:as]      = :fields
+          options[:label] ||= false
+          attr_name         = args.shift || attribute.name
+          template.capture_haml do
+            result          = field attr_name, options do |_field|
+              template.haml_concat fieldset(&block).gsub(/\n$/, "")
+            end
+            template.haml_concat result.gsub(/\n$/, "")
           end
-          template.haml_concat result.gsub(/\n$/, "")
         end
-      end
       
-      def fields_for(*args, &block)
-        options        = args.extract_options!
-        attribute      = args.shift
-        macro          = model.macro_for(attribute)
-        attr_name      = nil
+        def fields_for(*args, &block)
+          options        = args.extract_options!
+          attribute      = args.shift
+          macro          = model.macro_for(attribute)
+          attr_name      = nil
 
-        if options[:as] == :object
-          attr_name = attribute.to_s
-        else
-          attr_name = config.rename_nested_attributes ? "#{attribute}_attributes" : attribute.to_s
-        end
+          if options[:as] == :object
+            attr_name = attribute.to_s
+          else
+            attr_name = config.rename_nested_attributes ? "#{attribute}_attributes" : attribute.to_s
+          end
 
-        # do something here for counts
-        sub_parent     = model.object
-        sub_object     = args.shift
+          # do something here for counts
+          sub_parent     = model.object
+          sub_object     = args.shift
         
-        index          = options.delete(:index)
+          index          = options.delete(:index)
         
-        unless index.present? && index.is_a?(::String)
-          if sub_object.blank? && index.present?
-            sub_object   = sub_parent.send(attribute)[index]
-          elsif index.blank? && sub_object.present? && macro == :has_many
-            index        = sub_parent.send(attribute).index(sub_object)
+          unless index.present? && index.is_a?(::String)
+            if sub_object.blank? && index.present?
+              sub_object   = sub_parent.send(attribute)[index]
+            elsif index.blank? && sub_object.present? && macro == :has_many
+              index        = sub_parent.send(attribute).index(sub_object)
+            end
           end
-        end
 
-        sub_object   ||= model.default(attribute) || model.to_s.camelize.constantize.new
-        keys           = [model.keys, attr_name]
+          sub_object   ||= model.default(attribute) || model.to_s.camelize.constantize.new
+          keys           = [model.keys, attr_name]
 
-        model          = Storefront::ModelProxy.new(
-          :object      => sub_object, 
-          :parent      => sub_parent,
-          :keys        => keys
-        )
+          model          = Storefront::ModelProxy.new(
+            :object      => sub_object, 
+            :parent      => sub_parent,
+            :keys        => keys
+          )
 
-        options.merge!(
-          :template       => template,
-          :model          => model,
-          :parent_index   => index,
-          :access_keys    => access_keys, 
-          :tabindex       => tabindex
-        )
-        Storefront::Form::Builder.new(options).render(&block)
-      end
+          options.merge!(
+            :template       => template,
+            :model          => model,
+            :parent_index   => index,
+            :access_keys    => access_keys, 
+            :tabindex       => tabindex
+          )
+          Storefront::Components::Form::Builder.new(options).render(&block)
+        end
       
-      def field(*args, &block)        
-        options        = args.extract_options!
-        attribute_name = args.shift || attribute.name
-        attribute      = Storefront::Attribute.new(
-          :name        => attribute_name,
-          :model       => @model, 
-          :required    => options[:required] == true, 
-          :disabled    => options[:disabled] == true,
-          :top_level   => options[:attribute] == false
-        )
+        def field(*args, &block)        
+          options        = args.extract_options!
+          attribute_name = args.shift || attribute.name
+          attribute      = Storefront::Attribute.new(
+            :name        => attribute_name,
+            :model       => @model, 
+            :required    => options[:required] == true, 
+            :disabled    => options[:disabled] == true,
+            :top_level   => options[:attribute] == false
+          )
         
-        options.reverse_merge!(
-          :template       => template,
-          :model          => model,
-          :attribute      => attribute, 
-          :parent_index   => parent_index,
-          :index          => index,
-          :field_html     => options[:field_html] || {},
-          :input_html     => options[:input_html] || {},
-          :label_html     => options[:label_html] || {},
-          :error_html     => options[:error_html] || {},
-          :hint_html      => options[:hint_html]  || {}
-        )
+          options.reverse_merge!(
+            :template       => template,
+            :model          => model,
+            :attribute      => attribute, 
+            :parent_index   => parent_index,
+            :index          => index,
+            :field_html     => options[:field_html] || {},
+            :input_html     => options[:input_html] || {},
+            :label_html     => options[:label_html] || {},
+            :error_html     => options[:error_html] || {},
+            :hint_html      => options[:hint_html]  || {}
+          )
         
-        Storefront::Form::Field.new(options).render(&block)
-      end
+          Storefront::Components::Form::Field.new(options).render(&block)
+        end
       
-      def button(*args, &block)
-        options = args.extract_options!
-        options.reverse_merge!(:as => :submit)
-        options[:value] = args.shift || "Submit"
-        field(options[:value], options, &block)
-      end
+        def button(*args, &block)
+          options = args.extract_options!
+          options.reverse_merge!(:as => :submit)
+          options[:value] = args.shift || "Submit"
+          field(options[:value], options, &block)
+        end
       
-      def submit(*args, &block)
-        template.capture_haml do
-          result = fieldset :class => config.submit_fieldset_class do |fields|
-            template.haml_concat fields.button(*args).gsub(/\n$/, "")
-            yield(fields) if block_given?
+        def submit(*args, &block)
+          template.capture_haml do
+            result = fieldset :class => config.submit_fieldset_class do |fields|
+              template.haml_concat fields.button(*args).gsub(/\n$/, "")
+              yield(fields) if block_given?
+            end
+            template.haml_concat result.gsub(/\n$/, "")
           end
-          template.haml_concat result.gsub(/\n$/, "")
         end
-      end
       
-      def partial(path, options = {})
-        @template.render :partial => path, :locals => options.merge(:fields => self)
-      end
+        def partial(path, options = {})
+          @template.render :partial => path, :locals => options.merge(:fields => self)
+        end
       
-      def render(&block)
-        yield(self)
+        def render(&block)
+          yield(self)
+        end
       end
     end
   end

data/lib/storefront/components/form/errors.rb

@@ -1,26 +1,28 @@
 module Storefront
-  class Form
-    class Errors < Storefront::Form::Base
-      def initialize(options = {})
-        super
+  module Components
+    class Form
+      class Errors < Storefront::Components::Form::Base
+        def initialize(options = {})
+          super
         
-        attributes.merge!(options[:error_html]) if options[:error_html]
-        attributes.delete :error_html
-        attributes.delete :error
-        # error
-        merge_class! @attributes, config.error_class
-        # aria-invalid = true|grammar|spelling
-        # aria-hidden
-        attributes[:id]  ||= attribute.to_id(:type => :error, :index => index, :parent_index => parent_index) if config.id_enabled_on.include?("error")
-        @value = model.errors_for(attribute.name)
-      end
+          attributes.merge!(options[:error_html]) if options[:error_html]
+          attributes.delete :error_html
+          attributes.delete :error
+          # error
+          merge_class! @attributes, config.error_class
+          # aria-invalid = true|grammar|spelling
+          # aria-hidden
+          attributes[:id]  ||= attribute.to_id(:type => :error, :index => index, :parent_index => parent_index) if config.id_enabled_on.include?("error")
+          @value = model.errors_for(attribute.name)
+        end
       
-      def render(&block)
-        template.capture_haml do
-          if value.present?
-            template.haml_tag config.error_tag, value.join("\n").html_safe.gsub(/\n$/, ""), attributes
-          elsif config.always_include_error_tag
-            template.haml_tag config.error_tag, attributes
+        def render(&block)
+          template.capture_haml do
+            if value.present?
+              template.haml_tag config.error_tag, value.join("\n").html_safe.gsub(/\n$/, ""), attributes
+            elsif config.always_include_error_tag
+              template.haml_tag config.error_tag, attributes
+            end
           end
         end
       end

data/lib/storefront/components/form/field.rb

@@ -1,101 +1,103 @@
 module Storefront
-  class Form
-    # input :name, :as => :string, :class => "string something", :label_method => x, :value_method => y
-    # disabled, readonly, accesskey, tabindex
-    # button, checkbox, color, date, datetime, datetime-local, email, file, hidden, image, month, number, password, radio, range , reset, search, submit, tel, text, time, url, week
-    # input :phone, :mask => /\d\d\d-\d\d\d-\d\d\d\d/, :hint => "Enter your phone number", :tip => "This is so we can call you."
-    class Field < Storefront::Form::Builder
-      def initialize(options = {})
-        super
+  module Components
+    class Form
+      # input :name, :as => :string, :class => "string something", :label_method => x, :value_method => y
+      # disabled, readonly, accesskey, tabindex
+      # button, checkbox, color, date, datetime, datetime-local, email, file, hidden, image, month, number, password, radio, range , reset, search, submit, tel, text, time, url, week
+      # input :phone, :mask => /\d\d\d-\d\d\d-\d\d\d\d/, :hint => "Enter your phone number", :tip => "This is so we can call you."
+      class Field < Storefront::Components::Form::Builder
+        def initialize(options = {})
+          super
         
-        # input type
-        options[:as]    ||= attribute.input_type(options)
-        @input_type     = options[:as]
-        @inputs         = []
+          # input type
+          options[:as]    ||= attribute.input_type(options)
+          @input_type     = options[:as]
+          @inputs         = []
         
-        # class
+          # class
         
-        classes = [config.field_class, input_type]
+          classes = [config.field_class, input_type]
         
-        unless [:submit, :fieldset].include?(input_type)
-          classes += [
-            attribute.required? ? config.required_class : config.optional_class, 
-            attribute.errors? ? config.error_class : config.valid_class,
-          ]
-          if options[:validate] != false && attribute.validations.present?
-            classes << config.validate_class
+          unless [:submit, :fieldset].include?(input_type)
+            classes += [
+              attribute.required? ? config.required_class : config.optional_class, 
+              attribute.errors? ? config.error_class : config.valid_class,
+            ]
+            if options[:validate] != false && attribute.validations.present?
+              classes << config.validate_class
+            end
           end
-        end
         
-        merge_class! attributes, *classes.compact.uniq.map(&:to_s)
+          merge_class! attributes, *classes.compact.uniq.map(&:to_s)
         
-        # id
-        if attributes[:id].blank? && config.id_enabled_on.include?("field")
-          attributes[:id] = attribute.to_id(:type => :field, :index => index, :parent_index => parent_index)
-        end
+          # id
+          if attributes[:id].blank? && config.id_enabled_on.include?("field")
+            attributes[:id] = attribute.to_id(:type => :field, :index => index, :parent_index => parent_index)
+          end
         
-        unless [:hidden, :submit].include?(input_type)
-          # errors
-          @errors           = Storefront::Form::Errors.new(options.slice(:rich_input, :error_html, :error, :model, :index, :parent_index, :attribute, :template))
+          unless [:hidden, :submit].include?(input_type)
+            # errors
+            @errors           = Storefront::Components::Form::Errors.new(options.slice(:rich_input, :error_html, :error, :model, :index, :parent_index, :attribute, :template))
           
-          # label
-          @label            = Storefront::Form::Label.new(options.slice(:rich_input, :label_html, :label, :model, :index, :parent_index, :attribute, :template))
+            # label
+            @label            = Storefront::Components::Form::Label.new(options.slice(:rich_input, :label_html, :label, :model, :index, :parent_index, :attribute, :template))
           
-          # hint
-          @hints            = Storefront::Form::Hint.new(options.slice(:rich_input, :hint_html, :hint, :model, :index, :parent_index, :attribute, :template))
-        end
+            # hint
+            @hints            = Storefront::Components::Form::Hint.new(options.slice(:rich_input, :hint_html, :hint, :model, :index, :parent_index, :attribute, :template))
+          end
         
-        unless input_type == :fieldset
-          # inputs
-          @input_attributes = default_options!.merge(attributes.except(:id, :class, :field_html, :attributes, :error_html, :label_html, :hint_html))
-        end
+          unless input_type == :fieldset
+            # inputs
+            @input_attributes = default_options!.merge(attributes.except(:id, :class, :field_html, :attributes, :error_html, :label_html, :hint_html))
+          end
         
-        merge_class! options[:field_html], attributes[:class]
+          merge_class! options[:field_html], attributes[:class]
         
-        @attributes       = options[:field_html].merge(:id => attributes[:id])
-      end
+          @attributes       = options[:field_html].merge(:id => attributes[:id])
+        end
       
-      def input(*args)
-        #@tabindex                    = @tabindex + 1
-        options = args.extract_options!
-        key     = args.shift || attribute.name
-        @inputs << input_for(input_type, key, options)
-      end
+        def input(*args)
+          #@tabindex                    = @tabindex + 1
+          options = args.extract_options!
+          key     = args.shift || attribute.name
+          @inputs << input_for(input_type, key, options)
+        end
       
-      def render(&block)
-        template.capture_haml do
-          template.haml_tag :li, attributes do
-            input(attribute.name) unless block_given?
-            elements = extract_elements!(attributes)
+        def render(&block)
+          template.capture_haml do
+            template.haml_tag :li, attributes do
+              input(attribute.name) unless block_given?
+              elements = extract_elements!(attributes)
             
-            result = elements.map do |element|
-              Array(send(element)).map(&:render)
-            end
-            template.haml_concat result.flatten.join.gsub(/\n$/, "") if result.present?
+              result = elements.map do |element|
+                Array(send(element)).map(&:render)
+              end
+              template.haml_concat result.flatten.join.gsub(/\n$/, "") if result.present?
             
-            yield(self) if block_given? # template.capture_haml(self, &block)
+              yield(self) if block_given? # template.capture_haml(self, &block)
+            end
           end
         end
-      end
       
-      protected
-      attr_reader :errors, :labels, :inputs, :hints, :label, :input_type
+        protected
+        attr_reader :errors, :labels, :inputs, :hints, :label, :input_type
       
-      def input_for(key, attribute, options = {})
-        Storefront::Form::Input.find(key.to_sym).new(@input_attributes.merge(options))
-      end
+        def input_for(key, attribute, options = {})
+          Storefront::Components::Form::Input.find(key.to_sym).new(@input_attributes.merge(options))
+        end
       
-      def extract_elements!(options = {})
-        elements = []
-        if [:hidden, :submit].include?(input_type)
-          elements << :inputs
-        else
-          if @label.present? && @label.value?
-            elements << :label
+        def extract_elements!(options = {})
+          elements = []
+          if [:hidden, :submit].include?(input_type)
+            elements << :inputs
+          else
+            if @label.present? && @label.value?
+              elements << :label
+            end
+            elements = elements.concat [:inputs, :hints, :errors]
           end
-          elements = elements.concat [:inputs, :hints, :errors]
+          elements
         end
-        elements
       end
     end
   end