storefront 0.2.0

data/lib/storefront/form/errors.rb

@@ -0,0 +1,57 @@
+module Storefront
+  class Form
+    module Errors      
+      def errors_for(key, options = {})
+        value = options[:error_attributes].delete(:value)
+        template.capture_haml do
+          if value.present?
+            template.haml_tag :output, options[:error_attributes] do
+              template.haml_concat value.html_safe
+            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
+          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/fields.rb

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