storefront 0.2.1 → 0.2.7

data/lib/storefront/form/builder.rb

@@ -0,0 +1,124 @@
+module Storefront
+  class Form
+    class Builder < Storefront::Form::Base
+      delegate :object, :parent, :to => :model
+      
+      def fieldset(*args, &block)
+        options                     = default_options!(args.extract_options!)
+        options[:label]           ||= args.shift
+        
+        Storefront::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$/, "")
+          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
+
+        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
+
+        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)
+          end
+        end
+
+        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
+        )
+
+        options.merge!(
+          :template       => template,
+          :model          => model,
+          :parent_index   => index,
+          :access_keys    => access_keys, 
+          :tabindex       => tabindex
+        )
+        Storefront::Form::Builder.new(options).render(&block)
+      end
+      
+      def field(*args, &block)        
+        options        = args.extract_options!
+        attribute_name = args.shift || attribute.name
+        attribute      = Storefront::AttributeProxy.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]  || {}
+        )
+        
+        Storefront::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 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
+      end
+      
+      def partial(path, options = {})
+        @template.render :partial => path, :locals => options.merge(:fields => self)
+      end
+      
+      def render(&block)
+        yield(self)
+      end
+    end
+  end
+end

data/lib/storefront/form/errors.rb

@@ -1,57 +1,31 @@
 module Storefront
   class Form
-    module Errors      
-      def errors_for(key, options = {})
-        value = options[:error_attributes].delete(:value)
+    class Errors < Storefront::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
+      
+      def render(&block)
         template.capture_haml do
           if value.present?
-            template.haml_tag :output, options[:error_attributes] do
-              template.haml_concat value.html_safe
+            template.haml_tag config.error_tag, attributes do
+              template.haml_concat value.join("\n").html_safe.gsub(/\n$/)
             end
-          else
-            template.haml_tag :output, options[:error_attributes]
-          end
-        end
-      end
-      
-      def errors_on?(attribute, options = {})
-
-      end
-      
-      def required?(attribute)
-        attribute_sym = attribute.to_s.sub(/_id$/, '').to_sym
-
-        if @object && @object.class.respond_to?(:reflect_on_validations_for)
-          @object.class.reflect_on_validations_for(attribute_sym).any? do |validation|
-            (validation.macro == :validates_presence_of || validation.macro == :validates_inclusion_of) &&
-            validation.name == attribute_sym &&
-            (validation.options.present? ? options_require_validation?(validation.options) : true)
-          end
-        else
-          if @object && @object.class.respond_to?(:validators_on)
-            !@object.class.validators_on(attribute_sym).find{|validator| (validator.kind == :presence || validator.kind == :inclusion) && (validator.options.present? ? options_require_validation?(validator.options) : true)}.nil?
-          else
-            true
+          elsif config.always_include_error_tag
+            template.haml_tag config.error_tag, attributes
           end
         end
       end
-
-      def options_require_validation?(options) #nodoc
-        allow_blank = options[:allow_blank]
-        return !allow_blank unless allow_blank.nil?
-        if_condition = !options[:if].nil?
-        condition = if_condition ? options[:if] : options[:unless]
-
-        condition = if condition.respond_to?(:call)
-                      condition.call(@object)
-                    elsif condition.is_a?(::Symbol) && @object.respond_to?(condition)
-                      @object.send(condition)
-                    else
-                      condition
-                    end
-
-        if_condition ? !!condition : !condition
-      end
     end
   end
 end

data/lib/storefront/form/field.rb

@@ -0,0 +1,102 @@
+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
+        
+        # input type
+        options[:as]    ||= attribute.input_type(options)
+        @input_type     = options[:as]
+        @inputs         = []
+        
+        # class
+        
+        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 attribute.validations.present?
+            classes << config.validate_class
+          end
+        end
+        
+        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
+        
+        unless [:hidden, :submit].include?(input_type)
+          # errors
+          @errors           = Storefront::Form::Errors.new(options.slice(:error_html, :error, :model, :index, :parent_index, :attribute, :template))
+          
+          # label
+          @label            = Storefront::Form::Label.new(options.slice(:label_html, :label, :model, :index, :parent_index, :attribute, :template))
+          
+          # hint
+          @hints            = Storefront::Form::Hint.new(options.slice(: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
+        
+        merge_class! options[:field_html], attributes[:class]
+        
+        @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 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?
+            
+            yield(self) if block_given? # template.capture_haml(self, &block)
+          end
+        end
+      end
+      
+      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 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
+      end
+    end
+  end
+end

data/lib/storefront/form/fieldset.rb

@@ -0,0 +1,44 @@
+module Storefront
+  class Form
+    class Fieldset < Storefront::Form::Base
+      attr_reader :builder
+      
+      def initialize(options = {})
+        super
+        
+        @label      = localize(:titles, options[:label], nil, (attributes[:locale_options] || {}).merge(:allow_blank => true)) if options[:label].present?
+        
+        merge_class! attributes, *[
+          config.fieldset_class
+        ]
+        
+        attributes[:id] ||= label.underscore.strip.gsub(/[_\s]+/, config.separator) if label.present?
+        attributes.delete(:index)
+        attributes.delete(:parent_index)
+        attributes.delete(:label)
+        
+        @builder     = Storefront::Form::Builder.new(
+          :template       => template, 
+          :model          => model,
+          :attribute      => attribute,
+          :index          => index,
+          :parent_index   => parent_index
+        )
+      end
+      
+      # form.inputs :basic_info, :locale_options => {:count => 1, :past => true}
+      def render(&block)
+        template.capture_haml do
+          template.haml_tag :fieldset, attributes do
+            template.haml_tag :legend, :class => config.legend_class do
+              template.haml_tag :span, label
+            end if label.present?
+            template.haml_tag config.field_list_tag, :class => config.list_class do
+              builder.render(&block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/storefront/form/hint.rb

@@ -0,0 +1,34 @@
+module Storefront
+  class Form
+    class Hint < Storefront::Form::Base
+      def initialize(options = {})
+        super
+        
+        attributes.merge!(options[:hint_html]) if options[:hint_html]
+        attributes.delete :hint_html
+        attributes.delete :hint
+        
+        unless options[:hint] == false
+          merge_class! attributes, config.hint_class
+          attributes[:id]  ||= attribute.to_id(:type => :hint, :index => index, :parent_index => parent_index) if config.id_enabled_on.include?("hint")
+          if config.include_aria && config.hint_is_popup
+            attributes[:role] ||= :tooltip
+          end
+          @value            = localize(:hints, attribute.name, options[:hint].is_a?(::String) ? options[:hint] : nil, :allow_blank => true)
+        end
+      end
+      
+      def render(&block)
+        template.capture_haml do
+          if value.present?
+            template.haml_tag config.hint_tag, attributes do
+              template.haml_concat value.html_safe.gsub(/\n$/, "")
+            end
+          elsif config.always_include_hint_tag
+            template.haml_tag config.hint_tag, attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/storefront/form/input.rb

@@ -0,0 +1,191 @@
+module Storefront
+  class Form
+    class Input < Storefront::Form::Base
+      class << self
+        attr_accessor :resolves
+        
+        def resolves(*input_types)
+          @resolves ||= []
+          @resolves = @resolves.concat(input_types.flatten.compact).uniq
+        end
+        
+        def resolves?(name)
+          @resolves ||= []
+          @resolves.include?(name)
+        end
+        
+        def registry
+          @registry ||= Dir[::File.join(::File.dirname(__FILE__), "inputs", "*")].map do |path|
+            next unless ::File.extname(path) == ".rb"
+            "Storefront::Form::#{::File.basename(path, ::File.extname(path)).camelize}".constantize
+          end.compact
+        end
+        
+        def find(name)
+          registry.detect do |input_class|
+            input_class.resolves?(name)
+          end
+        end
+      end
+      
+      def initialize(options = {})
+        super
+        
+        # input type
+        options[:as]    ||= attribute.input_type(options)
+        @input_type     = options[:as]
+        @include_blank  = options[:include_blank] != false
+        @value          = options[:value]
+        @dynamic        = options[:dynamic] == true
+        
+        classes = [input_type, self.class.name.split("::").last.underscore, attribute.name.to_s.underscore.strip.gsub(/[_\s]+/, config.separator)]
+        
+        if options[:input_html].present?
+          classes << options[:input_html].delete(:class)
+        end
+        
+        unless [:submit].include?(input_type)
+          classes += [
+            attribute.required? ? config.required_class : config.optional_class, 
+            attribute.errors? ? config.error_class : config.valid_class,
+            "input"
+          ]
+          
+          if attribute.validations.present?
+            classes << config.validate_class
+          end
+        end
+        
+        # class
+        merge_class! attributes, *classes.compact.uniq.map(&:to_s)
+        
+        # id
+        attributes[:id] ||= attribute.to_id(:index => index, :parent_index => parent_index)
+        
+        # validations
+        attributes.merge!(attribute.validations) if config.inline_validations && attribute.validations.present?
+        attributes[:placeholder] = options[:placeholder] if options[:placeholder].present?
+        
+        # name
+        attributes[:name]     ||= attribute.to_param(:index => index, :parent_index => parent_index)
+        
+        # value
+        attributes[:value]    ||= attribute.value(options[:value])
+        
+        # attributes[:tabindex]      = @tabindex
+        attributes[:maxlength]       = options[:max] if options[:max].present?
+        
+        # expressions
+        pattern                      = options[:match]
+        pattern                      = pattern.source if pattern.is_a?(::Regexp)
+        attributes[:"data-match"]    = pattern if pattern.present?
+        attributes[:"aria-required"] = attribute.required.to_s if attribute.required?
+        
+        # access key
+        access_key                   = attributes[:accesskey] || attribute.access_key
+        attributes[:accesskey]       = access_key
+        
+        attributes.merge!(options[:input_html]) if options[:input_html]
+        
+        attributes.delete :include_blank
+        attributes.delete :input_html
+        attributes.delete :include_template
+        attributes.delete :as
+        attributes.delete :dynamic
+        attributes.delete :max
+        attributes.delete :min
+        attributes.delete :parent_index
+        
+        attributes[:required] = "true" if attributes.delete(:required) == true
+        attributes[:disabled] = "true" if attributes.delete(:disabled) == true
+        attributes[:autofocus] = "true" if attributes.delete(:autofocus) == true
+        attributes[:"data-dynamic"] = "true" if @dynamic
+        
+        attributes[:title] ||= attributes[:placeholder] if attributes[:placeholder].present?
+        
+        autocomplete = attributes.delete(:autocomplete)
+        if autocomplete && config.include_aria
+          attributes[:"aria-autocomplete"] = case autocomplete
+          when :inline, :list, :both
+            autocomplete.to_s
+          else
+            "both"
+          end
+        end
+      end
+      
+      def render(&block)
+        send(:"#{@input_type}_input")
+      end
+      
+      protected
+      attr_reader :include_blank
+      
+      def simple_input(type, options = {}, &block)
+        template.capture_haml do
+          template.haml_tag :input, extract_attributes!(type, options), &block
+          if @dynamic
+            template.haml_tag :ul, :class => "buttons" do
+              template.haml_tag :li do
+                template.haml_tag :a, config.add_label, :class => :add, :role => :button, :type => :button, :href => "#"
+              end
+              template.haml_tag :li do
+                template.haml_tag :a, config.remove_label, :class => :remove, :role => :button, :type => :button, :href => "#"
+              end
+            end
+          end
+        end
+      end
+      
+      def rich_input(type, options = {}, &block)
+        template.capture_haml do
+          result = template.rich_button :inner_html => extract_attributes!(type, options), :as => :input
+          template.haml_concat result.gsub(/\n$/, "") if result
+        end
+      end
+      
+      def extract_attributes!(type, options = {})
+        if [:numeric, :string, :password, :text, :phone, :url, :email].include?(type)
+          attributes = model.default_string_options(attribute.name, type).merge(self.attributes)
+        else
+          attributes = self.attributes
+        end
+
+        merge_class! attributes, options.delete(:class)
+
+        attributes[:type] = input_type_for(type)
+
+        attributes.merge(options)
+      end
+      
+      def base_input(tag, *args, &block)
+        options    = args.extract_options!
+        attributes = self.attributes
+        text       = args.shift
+        
+        template.capture_haml do
+          if block_given?
+            template.haml_tag tag, attributes, &block
+          else
+            if text.present?
+              template.haml_tag tag, text, attributes
+            else
+              template.haml_tag tag, attributes
+            end
+          end
+        end
+      end
+      
+      def input_type_for(type)
+        case type
+        when :password, :text, :url, :email, :file, :textarea, :search, :submit, :radio, :checkbox
+          type
+        when :phone, :tel
+          :tel
+        else
+          :string
+        end
+      end
+    end
+  end
+end