storefront 0.2.1 → 0.2.7

data/lib/storefront/proxies/model_proxy.rb

@@ -0,0 +1,249 @@
+require 'ostruct'
+
+module Storefront
+  class ModelProxy
+    class << self
+      def model_names(array)
+        Array(array).flatten.map do |object|
+          case object
+          when ::Class
+            object.ancestor_classes.map { |i| i.name.underscore }
+          when ::String, ::Symbol
+            object
+          else
+            object.class.ancestor_classes.map { |i| i.name.underscore }
+          end
+        end.flatten.compact.uniq
+      end
+    end
+    
+    attr_reader :object, :parent, :errors, :keys
+    
+    def initialize(options = {}, &block)
+      @object = options[:object]
+      @parent = options[:parent]
+      if options[:keys].present?
+        @keys   = options[:keys]
+      elsif @object.is_a?(::OpenStruct) && @object.klass.present?
+        @keys   = [@object.klass.to_s.underscore]
+      else
+        @keys   = [@object.class.name.underscore]
+      end
+    end
+    
+    def new_record?
+      @object.respond_to?(:new_record?) && !@object.new_record?
+    end
+    
+    def config
+      Storefront.configuration
+    end
+    
+    def self_and_ancestor_names
+      @self_and_ancestor_names ||= self.class.model_names(@object)
+    end
+    
+    def get(attribute)
+      @object.send(attribute)
+    end
+    
+    def validators?
+      @object.class.respond_to?(:validators_on)
+    end
+    
+    def validators_on(attribute)
+      @object.class.validators_on(attribute)
+    end
+    
+    def validation_message(attribute, key, options = {})
+      @object.errors.generate_message(attribute, key, options)
+    end
+    
+    def errors_on?(attribute, options = {})
+      @object.respond_to?(:errors) ? @object.errors[attribute].present? : false
+    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 errors_for(name)
+      return @object.errors[name] if errors_on?(name)
+    end
+    
+    def humanized_attribute_name(method) #:nodoc:
+      if @object && @object.class.respond_to?(:human_attribute_name)
+        @object.class.human_attribute_name(method.to_s)
+      else
+        method.to_s.send(config.label_method)
+      end
+    end
+    
+    def default(attribute)
+      if @object.respond_to?(attribute)
+        result = case macro_for(attribute)
+        when :belongs_to, :has_one
+          @object.send(attribute) || @object.send("build_#{attribute}")
+        when :has_many
+          @object.send(attribute.to_s.pluralize).build
+        else
+          @object.send(attribute)
+        end
+        result
+      elsif @object.is_a?(::OpenStruct)
+        result = ::OpenStruct.new
+        result.klass = attribute.to_s.camelize
+        @object.send("#{attribute}=", result)
+        result
+      else
+        nil
+      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
+    
+    def macro_for(method)
+      reflection     = reflection_for(method)
+      reflection ? reflection.macro : nil
+    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 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
+    
+    # remove this, it's for old rails
+    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)
+      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
+    
+    def default_string_options(method, type)
+      validation_max_limit = get_maxlength_for(method)
+      column               = column_for(method)
+      
+      if type == :text
+        {:rows => default_text_area_height, :cols => config.default_text_area_width}
+      elsif type == :numeric || column.nil? || !column.respond_to?(:limit) || column.limit.nil?
+        {:maxlength => validation_max_limit, :size => config.default_text_field_size}
+      else
+        {:maxlength => validation_max_limit || column.limit, :size => config.default_text_field_size}
+      end
+    end
+  end
+end

data/lib/storefront/railtie.rb

@@ -1,4 +1,3 @@
-# https://gist.github.com/af7e572c2dc973add221
 module Storefront
   class Railtie < Rails::Railtie
     initializer "storefront.insert_into_action_view" do
@@ -12,16 +11,19 @@ module Storefront
       end
       
       ActiveSupport.on_load :active_record do
-        #
+        Object.send :include, Storefront::ModelHelper
       end
       
       ActiveSupport.on_load :action_controller do   
         base = "#{File.expand_path(File.dirname(__FILE__))}/helpers"
         Dir["#{base}/*"].each do |path|
           next if File.directory?(path) || File.basename(path) =~ /(form|table|dashboard)/
+          # need to do these as traditional helper declarations somehow
           constant_name = File.basename(path, File.extname(path)).gsub("/", "::").camelize
           ActionController::Base.send :include, "Storefront::#{constant_name}".constantize
         end
+        
+        ActionController::Base.send :before_filter, :configure_storefront
       end
     end
   end

data/lib/storefront/table.rb

@@ -1,5 +1,9 @@
 module Storefront
   class Table
+    include Storefront::AttributeHelper
+    include Storefront::LocaleHelper
+    include Storefront::TimeHelper
+    
     attr_reader :content, :template, :key
     
     def initialize(template, *args, &block)
@@ -159,6 +163,9 @@ module Storefront
       attributes[:id]                 ||= id_for(:cell, key, value, @row_index, @cell_index)
       #attributes[:"aria-describedby"] = @headers[@cell_index]
       attributes[:headers]            = @headers[@cell_index]
+      [:width, :height].each do |size|
+        attributes[size] = pixelate(attributes[size]) unless attributes[size].nil?
+      end
       template.capture_haml do
         if block_given?
           template.haml_tag :td, attributes, &block

data/test/form_helper_test.rb

@@ -2,4 +2,4 @@ require 'test_helper'
 
 class FormHelperTest < ActionView::TestCase
   
-end
+end

metadata

@@ -2,7 +2,7 @@
 name: storefront
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.1
+  version: 0.2.7
 platform: ruby
 authors: 
 - Lance Pollard
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-29 00:00:00 Z
+date: 2011-07-05 00:00:00 Z
 dependencies: []
 
 description: Semantic HTML5 for Rails
@@ -23,15 +23,27 @@ extra_rdoc_files: []
 
 files: 
 - Rakefile
-- init.rb
+- lib/storefront/configuration.rb
 - lib/storefront/dashboard.rb
-- lib/storefront/form/elements.rb
+- lib/storefront/form/base.rb
+- lib/storefront/form/builder.rb
 - lib/storefront/form/errors.rb
-- lib/storefront/form/fields.rb
-- lib/storefront/form/hints.rb
-- lib/storefront/form/inputs.rb
-- lib/storefront/form/labels.rb
-- lib/storefront/form/model.rb
+- lib/storefront/form/field.rb
+- lib/storefront/form/fieldset.rb
+- lib/storefront/form/hint.rb
+- lib/storefront/form/input.rb
+- lib/storefront/form/inputs/checkbox.rb
+- lib/storefront/form/inputs/date.rb
+- lib/storefront/form/inputs/file.rb
+- lib/storefront/form/inputs/hidden.rb
+- lib/storefront/form/inputs/radio.rb
+- lib/storefront/form/inputs/range.rb
+- lib/storefront/form/inputs/select.rb
+- lib/storefront/form/inputs/string.rb
+- lib/storefront/form/inputs/submit.rb
+- lib/storefront/form/inputs/textarea.rb
+- lib/storefront/form/inputs/value.rb
+- lib/storefront/form/label.rb
 - lib/storefront/form.rb
 - lib/storefront/helpers/attribute_helper.rb
 - lib/storefront/helpers/body_helper.rb
@@ -59,29 +71,15 @@ files:
 - lib/storefront/helpers/sidebar_helper.rb
 - lib/storefront/helpers/system_helper.rb
 - lib/storefront/helpers/table_helper.rb
+- lib/storefront/helpers/template_helper.rb
 - lib/storefront/helpers/time_helper.rb
 - lib/storefront/helpers/url_helper.rb
 - lib/storefront/helpers/user_helper.rb
 - lib/storefront/helpers/widget_helper.rb
 - lib/storefront/helpers/workflow_helper.rb
-- lib/storefront/microdata/address.rb
-- lib/storefront/microdata/event.rb
-- lib/storefront/microdata/geo.rb
-- lib/storefront/microdata/organization.rb
-- lib/storefront/microdata/person.rb
-- lib/storefront/microformat/event.rb
-- lib/storefront/microformat/person.rb
-- lib/storefront/models/container.rb
-- lib/storefront/models/element.rb
-- lib/storefront/models/form.rb
-- lib/storefront/models/form_element.rb
-- lib/storefront/models/link.rb
-- lib/storefront/models/list.rb
-- lib/storefront/models/list_element.rb
-- lib/storefront/models/table.rb
-- lib/storefront/models/term.rb
-- lib/storefront/models/term_list.rb
-- lib/storefront/models/validation.rb
+- lib/storefront/model_helper.rb
+- lib/storefront/proxies/attribute_proxy.rb
+- lib/storefront/proxies/model_proxy.rb
 - lib/storefront/railtie.rb
 - lib/storefront/table.rb
 - lib/storefront.rb

data/init.rb

@@ -1 +0,0 @@
-File.dirname(__FILE__) + "/rails/init.rb"

data/lib/storefront/form/elements.rb

@@ -1,101 +0,0 @@
-module Storefront
-  class Form
-    module Elements
-      def wrapper_id(attribute, options = {})
-
-      end
-      
-      # 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
-      def input(attribute, options = {}, &block)
-        # aria-required=true
-        
-        options[:required] = required?(attribute) unless options.has_key?(:required)
-        options[:as] ||= default_input_type(attribute, options)
-        
-        html_class = [
-          options[:required] ? "required" : "optional",
-          errors_on?(attribute, options) ? "error" : nil
-        ].compact.uniq
-        
-        # input
-        input_attributes            = {}
-        if options[:input_html].present?
-          options[:input_html].each do |key, value|
-            input_attributes[key] = value
-          end
-        end
-        input_attributes[:class]    = (html_class << (options.delete(:class) || options[:as]).to_s).compact.join(" ")
-        input_attributes[:id]       ||= input_id(attribute)
-        
-        input_attributes[:name]     ||= input_name(attribute, options)
-        input_attributes[:value]    ||= input_value(attribute, options.delete(:value))
-        input_attributes[:tabindex] = @tabindex
-        
-        @tabindex = @tabindex + 1
-        access_key = input_attributes.delete(:accesskey) || access_key_for(attribute)
-        input_attributes[:accesskey] = access_key
-        #input_attributes = {
-        #  :input_attributes => input_attributes,
-        #  :include_blank    => options.delete(:include_blank)
-        #}
-        
-        # label
-        unless options[:label] == false
-          label_attributes            = options.delete(:label_html) || {}
-          label_attributes[:for]      ||= input_attributes[:id]
-          label_attributes[:id]       ||= input_id(attribute, "label")
-          label_attributes[:class]    = "label"
-          label_attributes[:value]    = localized_string(attribute, options[:label], :label)
-          label_attributes[:value]    = humanized_attribute_name(attribute) if label_attributes[:value].blank?
-        else
-          label_attributes = false
-        end
-        
-        # wrapper
-        wrapper_attributes          = options.delete(:wrapper_attributes) || {}
-        wrapper_attributes[:class]  = (html_class << wrapper_attributes[:class]).compact.join(" ")
-        wrapper_attributes[:id]     ||= input_id(attribute, "field")
-        
-        # hint
-        #return if options[:hint].blank? or options[:hint].kind_of? Hash
-        hint_class              = options[:hint_class]# || default_hint_class
-        hint_attributes         = options.delete(:hint_html) || {}
-        hint_attributes[:class] = "hint inline-hints"
-        hint_attributes[:value] = localized_string(attribute, options[:hint], :hint)
-        
-        # error
-        error_attributes            = options.delete(:error_html) || {}
-        error_attributes[:class]    = "error"
-        
-        elements = []
-        if options[:as] == :hidden
-          elements << :input
-        else
-          if label_attributes
-            elements << :label
-          end
-          elements = elements.concat [:input, :hints, :errors]
-        end
-        
-        options[:input_attributes]  = input_attributes
-        options[:label_attributes]  = label_attributes
-        options[:hint_attributes]   = hint_attributes
-        options[:error_attributes]  = error_attributes
-
-        template.capture_haml do
-          template.haml_tag :li, wrapper_attributes do
-            result = elements.map do |element|
-              send("#{element}_for", attribute, options)
-              #if element == :input && block_given?
-              #  yield
-              #end
-            end.join
-            template.haml_concat result.gsub(/\n$/, "")
-          end
-        end
-      end
-    end
-  end
-end