storefront 0.2.0

data/lib/storefront/form/hints.rb

@@ -0,0 +1,18 @@
+module Storefront
+  class Form
+    module Hints      
+      def hints_for(key, options = {})
+        value = options[:hint_attributes].delete(:value)
+        template.capture_haml do
+          if value.present?
+            template.haml_tag :figure, options[:hint_attributes] do
+              template.haml_concat value.html_safe
+            end
+          else
+            template.haml_tag :figure, options[:hint_attributes]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/storefront/form/inputs.rb

@@ -0,0 +1,254 @@
+module Storefront
+  class Form
+    module Inputs
+      def input_for(key, options)
+        send(:"#{options.delete(:as)}_input", key, options)
+      end
+            
+      def default_input_type(method, options = {}) #:nodoc:
+        if column = column_for(method)
+          # Special cases where the column type doesn't map to an input method.
+          case column.type
+          when :string
+            return :password  if method.to_s =~ /password/
+            return :country   if method.to_s =~ /country$/
+            return :time_zone if method.to_s =~ /time_zone/
+            return :email     if method.to_s =~ /email/
+            return :url       if method.to_s =~ /^url$|^website$|_url$/
+            return :phone     if method.to_s =~ /(phone|fax)/
+            return :search    if method.to_s =~ /^search$/
+          when :integer
+            return :select    if reflection_for(method)
+            return :numeric
+          when :float, :decimal
+            return :numeric
+          when :timestamp
+            return :datetime
+          end
+
+          # Try look for hints in options hash. Quite common senario: Enum keys stored as string in the database.
+          return :select    if column.type == :string && options.key?(:collection)
+          # Try 3: Assume the input name will be the same as the column type (e.g. string_input).
+          return column.type
+        else
+          if @object
+            return :select  if reflection_for(method)
+
+            return :file    if is_file?(method, options)
+          end
+
+          return :select    if options.key?(:collection)
+          return :password  if method.to_s =~ /password/
+          return :string
+        end
+      end
+
+      def is_file?(method, options = {})
+        @files ||= {}
+        @files[method] ||= (options[:as].present? && options[:as] == :file) || begin
+          file = @object.send(method) if @object && @object.respond_to?(method)
+          file && file_methods.any?{|m| file.respond_to?(m)}
+        end
+      end
+
+      def file_methods
+        [:file?, :public_filename, :filename]
+      end
+      
+    
+      def base_input(input_type, key, options = {}, &block)
+        if [:numeric, :string, :password, :text, :phone, :url, :email].include?(input_type)
+          attributes = default_string_options(key, input_type).merge(options[:input_attributes]) 
+        else
+          attributes = options[:input_attributes]
+        end
+        merge_class! attributes, key.to_s, options[:class]
+        attributes[:required] = true if options[:required] == true
+        template.capture_haml do
+          template.haml_tag :input, attributes.merge(:type => input_type), &block
+        end
+      end
+      
+      def core_input(tag, *args, &block)
+        options    = args.extract_options!
+        attributes = options[:input_attributes]
+        attributes[:required] = true if options[:required] == true
+        template.capture_haml do
+          if block_given?
+            template.haml_tag tag, attributes, &block
+          else
+            template.haml_tag tag, args.shift, attributes
+          end
+        end
+      end
+      
+      # autofocus, pattern, placeholder, title, size, data-validate, data-validate-match, data-validate-unique
+      def string_input(key, attributes = {})
+        base_input :string, key, attributes
+      end
+
+      # maxlength, placeholder, required, wrap, readonly
+      def textarea_input(key, options = {})
+        attributes = options[:input_attributes]
+        value      = attributes.delete(:value)
+        core_input :textarea, value, attributes
+      end
+      alias_method :text_input, :textarea_input
+
+      def checkbox_input(key, attributes = {})
+        hidden_input key, attributes.merge(:value => 0)
+        base_input :checkbox, key, attributes.merge(:value => 1)
+      end
+      
+      # prompt, blank, multiple
+      def select_input(key, options = {})
+        collection = Array(options.delete(:collection) || [])
+        if options[:include_blank] != false
+          prompt     = options[:prompt] || ""
+          collection = [[prompt, ""]] + collection
+        end
+        attributes = options[:input_attributes]
+        selected   = attributes.delete(:value)
+        core_input :select, options do
+          collection.map do |item|
+            name, options = item, {}
+            case item
+            when Array
+              name            = item[0]
+              options[:value] = item[1]
+            when Hash
+              name            = item[:name]
+              options[:value] = item[:value]
+            else
+              options[:value] = item
+            end
+            options[:selected] = "true" if selected.present? && options[:value] == selected
+            template.haml_tag :option, name, options
+          end
+        end
+      end
+      
+      def hidden_input(key, attributes = {})
+        base_input :hidden, key, attributes
+      end
+      
+      def number_input(key, attributes = {})
+        base_input :string, key, attributes.merge(:class => "number", "data-type" => "number")
+      end
+      
+      def search_input(key, attributes = {})
+        base_input :search, key, merge_class(attributes, "search").merge("data-type" => "search")
+      end
+      
+      def boolean_input(key, attributes = {})
+        select_input(key, attributes.merge(:collection => [["Yes", "1"], ["No", "0"]]))
+        #checkbox_input(key, attributes = {})
+      end
+      
+      # accept, maxlength="2"
+      def file_input(key, attributes = {})
+        base_input :file, key, attributes
+      end
+      
+      def password_input(key, attributes = {})
+        base_input :password, key, attributes
+      end
+      
+      def email_input(key, attributes = {})
+        base_input :email, key, attributes
+      end
+
+      def url_input(key, attributes = {})
+        base_input :url, key, attributes
+      end
+      
+      def phone_input(key, attributes = {})
+        base_input :tel, key, attributes.merge(:class => "phone")
+      end
+      
+      def fax_input(key, attributes = {})
+        base_input :tel, key, attributes.merge(:class => "phone fax")
+      end
+      
+      def date_input(key, attributes = {})
+        base_input :string, key, attributes.merge(:class => "date", "data-type" => "date")
+      end
+      
+      def money_input(key, attributes = {})
+        base_input :string, key, merge_class(attributes, "money").merge("data-type" => "money")
+      end
+      
+      def percent_input(key, attributes = {})
+        base_input :string, key, merge_class(attributes, "percent").merge("data-type" => "percent")
+      end
+      
+      def watched_input(key, attributes = {})
+        text_input key, merge_class(attributes, "watch-characters").merge(:"data-character-count" => (attributes.delete(:count) || 100))
+        # haml_tag :figure, :class => "watched"
+      end
+      
+      def color_input(key, attributes = {})
+        
+      end
+      
+      def range_input(key, attributes = {})
+        
+      end
+      
+      def autocomplete_input(key, attributes = {})
+
+      end
+
+      def date_range_input(key, attributes = {})
+
+      end
+      
+      def slider_input(key, attributes = {})
+        
+      end
+      
+      def state_input(key, attributes = {})
+        
+      end
+
+      def partial(key, attributes = {})
+
+      end
+
+      def input_id(attribute, name = "input")
+        ([keys] + [@index ? @index.to_s : nil, attribute]).compact.join("-").gsub("_", "-") + "-#{name}"
+      end
+      
+      def input_name(attribute, options = {})
+        param_for([keys] + [@index ? @index.to_s : nil, attribute])
+      end
+      
+      def input_value(attribute, default = nil)
+        return default if default.present?
+        
+        if object.respond_to?(attribute)
+          object.send(attribute)
+        else
+          nil
+        end
+      end
+      
+      ## FORMTASTIC STUFF
+      def create_boolean_collection(options) #:nodoc:
+        options[:true] ||= ::Formtastic::I18n.t(:yes)
+        options[:false] ||= ::Formtastic::I18n.t(:no)
+        options[:value_as_class] = true unless options.key?(:value_as_class)
+
+        [ [ options.delete(:true), true], [ options.delete(:false), false ] ]
+      end
+      
+      def validation_max_limit
+        255
+      end
+
+      def default_text_field_size
+        nil
+      end
+    end
+  end
+end

data/lib/storefront/form/labels.rb

@@ -0,0 +1,81 @@
+module Storefront
+  class Form
+    module Labels    
+      def label_for(key, options = {})
+        attributes = options[:label_attributes]
+        text       = attributes.delete(:value)
+        result     = template.capture_haml do
+          template.haml_tag :label, options[:label_attributes] do
+            template.haml_tag :span, text
+            if options[:required] == true
+              template.haml_tag :abbr, "*", :title => "required"
+            else
+              template.haml_tag :abbr, "", :title => "optional"
+            end
+          end
+        end
+        result
+      end
+      
+      def label_method
+        :titleize
+      end
+      
+      def humanized_attribute_name(method) #:nodoc:
+        if @object && @object.class.respond_to?(:human_attribute_name)
+          humanized_name = @object.class.human_attribute_name(method.to_s)
+          if humanized_name == method.to_s.send(:humanize)
+            method.to_s.send(label_method)
+          else
+            humanized_name
+          end
+        else
+          method.to_s.send(label_method)
+        end
+      end
+
+      def localized_string(key, value, type, options = {}) #:nodoc:
+        key = value if value.is_a?(::Symbol)
+
+        if value.is_a?(::String)
+          value.html_safe
+        else
+          use_i18n = true
+
+          if use_i18n
+            model_name, nested_model_name  = normalize_model_name(self.model_name.underscore)
+            action_name = template.params[:action].to_s rescue ''
+            attribute_name = key.to_s
+
+            defaults = ::Formtastic::I18n::SCOPES.reject do |i18n_scope|
+              nested_model_name.nil? && i18n_scope.match(/nested_model/)
+            end.collect do |i18n_scope|
+              i18n_path = i18n_scope.dup
+              i18n_path.gsub!('%{action}', action_name)
+              i18n_path.gsub!('%{model}', model_name)
+              i18n_path.gsub!('%{nested_model}', nested_model_name) unless nested_model_name.nil?
+              i18n_path.gsub!('%{attribute}', attribute_name)
+              i18n_path.gsub!('..', '.')
+              i18n_path.to_sym
+            end
+            defaults << ''
+
+            defaults.uniq!
+
+            default_key = defaults.shift
+            i18n_value = ::Formtastic::I18n.t(default_key,
+              options.merge(:default => defaults, :scope => type.to_s.pluralize.to_sym))
+            if i18n_value.blank? && type == :label
+              # This is effectively what Rails label helper does for i18n lookup
+              options[:scope] = [:helpers, type]
+              options[:default] = defaults
+              i18n_value = ::I18n.t(default_key, options)
+            end
+
+            i18n_value.blank? ? nil : i18n_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/storefront/form/model.rb

@@ -0,0 +1,84 @@
+module Storefront
+  class Form
+    module Model
+      def model_name
+        @object.present? ? @object.class.name : @object_name.to_s.classify
+      end
+
+      def normalize_model_name(name)
+        if name =~ /(.+)\[(.+)\]/
+          [$1, $2]
+        else
+          [name]
+        end
+      end
+      
+      # If an association method is passed in (f.input :author) try to find the
+      # reflection object.
+      #
+      def reflection_for(method) #:nodoc:
+        @object.class.reflect_on_association(method) if @object.class.respond_to?(:reflect_on_association)
+      end
+      
+      # Get a column object for a specified attribute method - if possible.
+      #
+      def column_for(method) #:nodoc:
+        @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
+      end
+      
+      def validations_for(method, mode = :active)
+        # ActiveModel?
+        validations = if @object && @object.class.respond_to?(:validators_on)
+          @object.class.validators_on(method)
+        else
+          # ValidationReflection plugin?
+          if @object && @object.class.respond_to?(:reflect_on_validations_for)
+            @object.class.reflect_on_validations_for(method)
+          else
+            []
+          end
+        end
+
+        validations = validations.select do |validation|
+          (validation.options.present? ? options_require_validation?(validation.options) : true)
+        end unless mode == :all
+
+        return validations
+      end
+
+      def sanitized_object_name #:nodoc:
+        @sanitized_object_name ||= @object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+      end
+      
+      def get_maxlength_for(method)
+        validation = validations_for(method).find do |validation|
+          (validation.respond_to?(:macro) && validation.macro == :validates_length_of) || # Rails 2 validation
+          (validation.respond_to?(:kind) && validation.kind == :length) # Rails 3 validator
+        end
+        
+        if validation
+          validation.options[:maximum] || (validation.options[:within].present? ? validation.options[:within].max : nil)
+        else
+          nil
+        end
+      end
+      
+      def default_string_options(method, type) #:nodoc:
+        validation_max_limit = get_maxlength_for(method)
+        column = column_for(method)
+
+        if type == :text
+          { :rows => default_text_area_height, 
+            :cols => default_text_area_width }
+        elsif type == :numeric || column.nil? || !column.respond_to?(:limit) || column.limit.nil?
+          { :maxlength => validation_max_limit,
+            :size => default_text_field_size }
+        else
+          { :maxlength => validation_max_limit || column.limit,
+            :size => default_text_field_size }
+        end
+      end
+      
+    end
+  end
+end

data/lib/storefront/helpers/attribute_helper.rb

@@ -0,0 +1,60 @@
+module Storefront
+  module AttributeHelper
+    def underscore_class_name(record)
+      record.class.base_class.snake_case
+    end
+    
+    def datetime_for(time)
+      with_time_at time
+    end
+    
+    def record_method(method, *args, &block)
+      record = args.shift
+      sent_method = "#{method}_#{underscore_class_name(record)}"
+      if args.length > 0 && options = args.pop
+        send(sent_method, record, options, &block)
+      else
+        send(sent_method, record, &block)
+      end
+    end
+    
+    def merge_class!(attributes, *values)
+      return {} if attributes.nil?
+      hash = merge_class(attributes, *values)
+      attributes[:class] = hash[:class] if hash
+      attributes
+    end
+    
+    def merge_class(attributes, *values)
+      if values.present?
+        if attributes[:class].present?
+          classes = attributes[:class].split(/\s+/)
+        else
+          classes = []
+        end
+        classes += values.compact.map(&:to_s)
+        classes.uniq!
+      else
+        classes = nil
+      end
+
+      if classes.present?
+        attributes.merge(:class => classes.join(" "))
+      else
+        attributes
+      end
+    end
+
+    def index_class(index, length)
+      return nil if length.blank? || (length <= 1)
+
+      if index == 0
+        "first"
+      elsif index == length - 1
+        "last"
+      else
+        nil
+      end
+    end
+  end
+end