storefront 0.2.1 → 0.2.7

data/lib/storefront/form/fields.rb

@@ -1,420 +0,0 @@
-# http://stackoverflow.com/questions/2731735/formtastic-own-as-input-type
-# to convert this from formtastic back to normal, remove @template, and pass "form" in as a param
-module Storefront
-  module OldFormHelper
-    def action(label, options = {})
-      self.next label, options
-    end
-  
-    def watched_input(method, options = {})
-      options[:input_html] ||= {}
-      options[:input_html].merge!(:class => "watch-characters", "data-character-count" => (options.delete(:count) || 100))
-      text_input method, options
-    end
-  
-    def live_update_input(method, options = {})
-      options[:input_html] ||= {}
-      options[:input_html].merge!(:class => "watch-characters live-update", "data-character-count" => (options.delete(:count) || 100))
-      text_input method, options
-    end
-  
-    def phone_input(method, options = {})
-      options[:input_html] ||= {}
-      options[:input_html].merge!(:class => "phone")
-      string_input method, options
-    end
-  
-    def security_code_input(method, options = {})
-      options[:input_html] ||= {}
-      options[:input_html].merge!(:class => "security_code")
-      string_input method, options
-    end
-  
-    def filter_input(method, options = {})
-      expression = options.delete(:match)
-      expression = expression.source if expression.is_a?(::Regexp)
-      filter      = options.delete(:filter) || method.to_s
-      boolean_input method, options.merge("data-filter-attribute" => filter, "data-filter-expression" => expression)
-    end
-  
-    def money_input(method, options = {})
-      options[:input_html] ||= {}
-      classes = options.delete(:class)
-      if classes.blank?
-        classes = "money"
-      else
-        classes = [classes, "money"].join(" ")
-      end
-      options[:input_html].reverse_merge!("data-accepts" => Regexp.new('^[\d\.\,\$]$').source, :class => classes, :maxlength => nil, :size => nil, :value => @template.format_money(object.send(method)))
-      string_input method, options
-    end
-  
-    def percent_input(method, options = {})
-      options[:input_html] ||= {}
-      options[:input_html].reverse_merge!(:class => "percent", :maxlength => nil, :size => nil, :value => @template.format_percent(object.send(method)))
-      string_input method, options
-    end
-  
-    def card_input(method, options = {})
-      options[:input_html] ||= {}
-      options[:input_html].merge!(:class => "card", :maxlength => nil, :size => nil)
-      string_input method, options
-    end
-  
-    def birthday_input(method, options = {})
-      string_input method, options.reverse_merge(:hint => "MM/DD/YYYY", :input_html => {:class => "birthday"})
-    end
-  
-    def datepicker_input(method, options = {})
-      input_html = options[:input_html] || {}
-      input_html[:class] = ["string", input_html[:class], "datepicker-deal", method.to_s.gsub("_", "-")].compact.uniq.join(" ")
-      input_html[:value] = I18n.l(object.send(method), :format => options.delete(:format) || :pretty)
-      options[:input_html] = input_html
-      string_input method, options
-    end
-  
-    def simple_datepicker_input(method, options = {})
-      string_input method, options.reverse_merge(:input_html => {:class => 'datepicker'})
-    end
-  
-    # merge with above
-    def deal_datepicker_input(method, options = {})
-      options[:input_html] ||= {}
-      classes = ["datepicker-deal", options.delete(:class)].flatten.join(" ")
-      options[:input_html].merge!(:readonly => true, :class => classes, :value => options.delete(:value))
-      string_input method, options
-    end
-  
-    def slider_input(method, options = {})
-      slider_classes = options.delete(:class) || method.to_s
-      inner_html = options.delete(:input_html) || {}
-      inner_html[:class]        = "with-slider #{slider_classes}"
-      inner_html["data-meter"]  = slider_classes.split(/\s+/).first
-      inner_html["data-min"]    = options[:min] if options[:min].present?
-      inner_html["data-max"]    = options[:max] if options[:max].present?
-      inner_html["data-step"]   = options[:step] if options[:step].present?
-      inner_html["data-accepts"] = Regexp.new('\\d').source
-      inner_html[:value] = options[:value]
-      string_input method, :input_html => inner_html
-    end
-  
-    def cash_input(method, options = {})
-      string_input method, options.reverse_merge(:input_html => {:class => "money"})
-    end
-  
-    def image_input(method, options = {})
-      label = options[:label] || method.to_s.humanize
-      image = options[:resource] || object
-      @template.render :partial => "shared/forms/image", :locals => {:form => self, :brandable => image, :as => method, :label => label, :required => (options[:required] || false)}
-    end
-  
-    def submit_center(label, options = {})
-      @template.render :partial => "shared/forms/submit_center", :locals => options.reverse_merge(:reject => nil, :form => self, :label => label)
-    end
-  
-    def state(name)
-      @template.hidden_field_tag :event, @template.workflow_state(name)
-    end
-  
-    def hours
-      @template.render :partial => "shared/forms/hours", :locals => {:form => self}
-    end
-  
-    def group(name, options = {})
-      scoping = options.delete(:scoped)
-      scoping = nil if scoping.is_a?(User) && scoping.admin?
-      as    = options.delete(:as) || :parent
-      if scoping.blank?
-        items = @template.select_attributes(name, :name, :id)
-      else
-        items = scoping.send(name.to_s.pluralize)
-      end
-      hidden = options.delete(:hidden) || false
-      if hidden
-        input "#{name}_id".to_sym, :as => :hidden, :input_html => {:value => default_id_for(@template.parent)}
-      else
-        input_select "#{name}_id".to_sym, :collection => items, :label_method => :name, :default => @template.parent, :required => true
-      end
-    end
-  
-    def has_one(model, options = {})
-      conditions = (options.delete(:conditions) || {})
-      collection = options.delete(:collection) || @template.select_attributes(model, :name, :id, conditions)
-      default    = options.delete(:default) || @template.params["#{model}_id".to_sym] || @template.resource.send(model)
-      input_select "#{model}_id", {:collection => collection, :default => default}.merge(options)
-    end
-  
-    def logo(brandable)
-      image(brandable, :logo)
-    end
-  
-    def image(attribute, brandable, options = {})
-      label = options[:label] || attribute.to_s.humanize
-      has_one_association = brandable.class.belongs_to?(attribute) || brandable.class.has_one?(attribute)
-      single_file = (options[:single_file] == true) || (has_one_association == true)
-      @template.render :partial => "shared/forms/image", :locals => {:form => self, :brandable => brandable, :as => attribute, :label => label, :required => (options[:required] || false), :single_file => single_file, :hint => options[:hint]}
-    end
-  
-    def images(attribute, brandable, options = {})
-      label = options[:label] || attribute.to_s.humanize
-      @template.render :partial => "shared/forms/images", :locals => {:form => self, :brandable => brandable, :as => attribute, :label => label}
-    end
-  
-    def store(options = {})
-      label = options[:label] || "Primary Location"
-      defaults = (options[:defaults] || []).flatten.compact
-      @template.render :partial => "shared/forms/store", :locals => {:form => self, :label => label, :defaults => defaults}
-    end
-  
-    def address(options = {})
-      label = options[:label] || "Address"
-      defaults = (options[:defaults] || []).flatten.compact
-      include_details = options[:include_details] == true
-      @template.render :partial => "shared/forms/address", :locals => {:form => self, :label => label, :defaults => defaults, :include_details => include_details}
-    end
-  
-    def inline_address(options = {})
-      default = options[:default]
-      @template.render :partial => "shared/forms/inline_address", :locals => {:form => self, :default => default}
-    end
-  
-    def location(attribute, options = {})
-      label = options[:label] || "Address"
-      defaults = (options[:defaults] || []).flatten.compact
-      options[:input_html] = {}
-      if options.delete(:read_only) == true
-        options[:input_html][:readonly] = true
-      end
-      if options.delete(:disabled) == true
-        options[:input_html][:disabled] = true
-      end
-      id = options.delete(:id)
-      @template.render :partial => "shared/forms/location", :locals => {:form => self, :id => id, :label => label, :defaults => defaults, :attribute => attribute, :input_html => options[:input_html], :disabled => (options[:disabled] == false)}
-    end
-  
-    def default(model, attribute, object = nil)
-      (object || self.object).send(attribute) || model.to_s.camelize.constantize.new
-    end
-  
-    def submit_to(path, options = {})
-      label = options[:label] || "Save Changes"
-      cancel = options[:cancel] || "Cancel"
-      label_class = (Array(options[:class]) + ["round-green"]).compact.join(" ")
-      @template.render :partial => "shared/forms/submit", :locals => {:form => self, :path => path, :label => label, :cancel => cancel, :label_class => label_class, :agree => options[:agree]}
-    end
-  
-    def contact(attribute, options = {})
-      label = options[:label] || attribute.to_s.humanize
-      include_logo = options[:include_logo] == true
-      @template.render :partial => "shared/forms/contact", :locals => {:form => self, :label => label, :attribute => attribute, :no_address => options[:no_address] == true ? true : false, :include_logo => include_logo}
-    end
-  
-    def hidden_select(attribute, options = {})
-      options[:value] = default_id_for(options[:default])
-      if !options[:value].blank?
-        input attribute.to_sym, :as => :hidden, :input_html => {:value => options[:value]}
-      else
-        input_select attribute.to_sym, options.except(:value)
-      end
-    end
-  
-    def next(label, options = {})
-      submit_to(@template.send(:root_path), options.reverse_merge(:label => label, :deal => nil, :agree => nil))
-    end
-  
-    def input_select(attribute, options = {})
-      default = default_id_for(options.delete(:default))
-      result = input(attribute, options.reverse_merge(:as => :select, :include_blank => true))
-      result.gsub!(/selected=['"]([^'"]+)['"]/, "")
-      result.gsub!(/(value=['"]#{default.to_s}['"])/, "\\1 selected='selected'") unless default.blank?
-      result
-    end
-  
-    def default_password
-      result = input :password, :as => :hidden, :value => "biglobby"
-      result += input :password_confirmation, :as => :hidden, :value => "biglobby"
-      result
-    end
-  
-    def autocomplete(attribute, options = {})
-      value = object.work_name.to_s if object.respond_to?(:work_name)
-      value ||= object.group_name.to_s if object.respond_to?(:group_name)
-      result = input(attribute, :as => :hidden, :input_html => {:class => "hidden-autocomplete", :value => value})
-      result += input(attribute, options.merge(:input_html => {:class => "autocomplete", :maxlength => nil, :size => nil}, :as => :string))
-      result
-    end
-  
-    def autocomplete_two(attribute, options = {})
-      default = options[:default]
-      #attribute = "#{attribute}".gsub(/_id$/, "")
-      if default.present?
-        name = default.name rescue ""
-      else
-        name = (object.send("#{attribute}".gsub(/_id$/, "")).name || "") rescue ""
-      end
-    
-      options[:value] ||= default_id_for(default || object.send("#{attribute}".gsub(/_id$/, "")))
-      value = User.find_by_id(options[:value])
-      name = value.name if value
-      value = value.id if value
-    
-      result = input(attribute, :as => :hidden, :input_html => {:class => "hidden-autocomplete", :value => value})
-    
-      options[:input_html] ||= {}
-      options[:input_html].merge!(:class => "autocomplete-two", :value => name)
-    
-      result += input("#{attribute}".gsub(/_id$/, ""), options)
-    
-      result
-    end
-  
-    def partial(method, options = {})
-      send(:"#{options.delete(:as)}_partial", method, options)
-    end
-  
-    def select_partial(method, options = {})
-      default = default_id_for(options.delete(:default))
-      result = input(method, options.merge(:as => :select, :include_blank => true))
-      result.gsub!(/selected=['"]([^'"]+)['"]/, "")
-      result.gsub!(/(value=['"]#{default.to_s}['"])/, "\\1 selected='selected'") unless default.blank?
-      result
-    end
-  
-    def partial_for(method, options = {})
-      send("#{method}_partial", options)
-    end
-  
-    def conditions_partial(options = {})
-      @template.render :partial => "shared/forms/conditions", :locals => options.reverse_merge(:form => self, :locale => "group")
-    end
-  
-    def cost_partial(options = {})
-      @template.render :partial => "shared/forms/cost", :locals => {:form => self}
-    end
-  
-    def value_input(method, options)
-      basic_input_helper(:value_field, :string, method, options.merge(:input_html => options))
-    end
-  
-    def value_field(method, html_options = {})
-      @template.content_tag(:output, html_options.delete(:value) || object.send(method), html_options)
-    end
-  
-    private
-    def default_id_for(value)
-      result = (value && !value.is_a?(Fixnum) && !value.is_a?(String)) ? value.id : value
-      result.blank? ? nil : result
-    end
-  end
-end
-
-
-Dir["#{File.expand_path(File.dirname(__FILE__))}/**/*"].each do |path|
-  require path unless ::File.directory?(path) || File.basename(path) =~ /fields/
-end
-
-module Storefront
-  class Form    
-    class Fields
-      include Haml::Helpers
-      include Storefront::Form::Model
-      include Storefront::Form::Elements
-      include Storefront::Form::Inputs
-      include Storefront::Form::Labels
-      include Storefront::Form::Errors
-      include Storefront::Form::Hints
-      include Storefront::AttributeHelper
-      include Storefront::OldFormHelper
-      
-      attr_accessor :template, :object, :parent, :tabindex, :access_keys, :keys
-      
-      def initialize(template, options, &block)
-        @template       = template
-        @tabindex       = options[:tabindex]
-        @access_keys    = options[:access_keys]
-        @parent         = options[:parent]
-        @object         = options[:object]
-        @attribute      = options[:attribute] 
-        @macro          = options[:macro]
-        if @attribute.present?
-          @keys         = [options[:keys], "#{@attribute}_attributes"]
-        else
-          @keys         = Array(options[:keys])
-        end
-        if @parent && @object.blank? && @attribute.present? && @parent.respond_to?("#{@attribute}_or_default")
-          @object = @parent.send("#{@attribute}_or_default")
-        end
-        
-        if @macro == :has_many && @object
-          @index        = @parent.send(@attribute).index(@object)
-        end
-        yield(self)
-      end
-      
-      def inputs(*args, &block)
-        options = args.extract_options!
-        label   = args.shift
-        template.capture_haml do
-          template.haml_tag :fieldset, options do
-            template.haml_tag :legend do
-              template.haml_tag :span, label
-            end if label.present?
-            template.haml_tag :ol, &block
-          end
-        end
-      end
-      alias fieldset inputs
-      
-      def fields_for(*args, &block)
-        options          = args.extract_options!
-        attribute        = args.shift
-        if block_given?
-          reflection     = reflection_for(attribute)
-          fields         = Storefront::Form::Fields.new(@template, options.merge(
-            :access_keys => @access_keys, 
-            :tabindex    => @tabindex, 
-            :parent      => @object, 
-            :object      => args.shift || @object.send(attribute),
-            :keys        => @keys,
-            :macro       => reflection ? reflection.macro : nil,
-            :attribute   => attribute
-          ), &block)
-          
-          @tabindex = fields.tabindex
-        end
-        nil
-      end
-      alias semantic_fields_for fields_for
-      
-      def access_key_for(attribute)
-        attribute.to_s[0,1]
-      end
-      
-      def options
-        
-      end
-      
-      def options_for(attribute, options = {})
-
-      end
-      
-      def param_for(*parts)
-        parts = parts.flatten.compact
-        parts[0].to_s + parts[1..-1].map {|i| "[#{i}]"}.join("")
-      end
-      
-      # get rid of this, don't like
-      def default(model, attribute, object = nil)
-        (object || self.object).send(attribute) || model.to_s.camelize.constantize.new
-      end
-      
-      def method_missing(method, *args, &block)
-        if @template.respond_to?(method)
-          @template.send(method, *args, &block)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/storefront/form/hints.rb

@@ -1,18 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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 => "numeric", "data-type" => "numeric")
-      end
-      
-      def numeric_input(key, attributes = {})
-        base_input :string, key, attributes.merge(:class => "numeric", "data-type" => "numeric")
-      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