padrino-fields 0.3.3

data/lib/padrino-fields.rb

@@ -0,0 +1,30 @@
+require 'sinatra'
+require 'padrino'
+require 'padrino-core/support_lite' unless defined?(SupportLite)
+require 'cgi'
+require 'i18n'
+require 'enumerator'
+
+FileSet.glob_require('padrino-fields/**/*.rb', __FILE__)
+
+# Load our locales
+I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-helpers/locale/*.yml"]
+
+module PadrinoFields
+  ##
+  # This component provides view helpers and shortcuts for generating form fields
+  # Should feel familiar to users of Formtastic or SimpleForm
+
+    ##
+    # Register Padrino::Helpers::Fields for Padrino::Application
+    #
+    class << self
+      def registered(app)
+        app.set :default_builder, 'PadrinoFieldsBuilder'
+        app.helpers Padrino::Helpers::FormBuilder::PadrinoFieldsBuilder
+        rescue
+      end
+      alias :included :registered
+    end
+            
+end # PadrinoFields

data/lib/padrino-fields/form_builder.rb

@@ -0,0 +1,183 @@
+require 'padrino-helpers'
+require File.expand_path(File.dirname(__FILE__) + '/form_helpers')
+require File.expand_path(File.dirname(__FILE__) + '/orms/datamapper') if defined?(DataMapper)
+require File.expand_path(File.dirname(__FILE__) + '/settings')
+
+module Padrino
+  module Helpers
+    module FormBuilder #:nodoc:
+      class PadrinoFieldsBuilder < AbstractFormBuilder #:nodoc:
+        
+        include PadrinoFields::Settings
+        include PadrinoFields::DataMapperWrapper if defined?(DataMapper)
+        
+        @@settings = PadrinoFields::Settings
+        
+        attr_reader :template, :object_name, :object
+        
+        def input(attribute, options={})
+          options.reverse_merge!(:caption => options.delete(:caption)) if options[:caption]
+          type = options[:as] || klazz.form_column_type_for(attribute)
+          field_html =  ""
+          if type == :boolean || options[:as] == :boolean
+            field_html << default_input(attribute,type,options) 
+            field_html << setup_label(attribute,type,labelize(options))
+          else
+            field_html << setup_label(attribute,type,labelize(options))
+            field_html << default_input(attribute,type, options)
+          end
+          field_html << hint(options[:hint]) if options[:hint]
+          field_html << @template.error_message_on(@object,attribute,{}) if @object.errors.any?
+          @template.content_tag(@@settings.container, :class => css_class(attribute,type,options[:disabled])) do
+            field_html
+          end
+        end
+        
+        def default_input(attribute,type,options={})
+          input_options = options.keep_if {|key, value| key != :as}
+          if options[:options] || options[:grouped_options]
+            if type==:radios || type == :checks
+              collect_inputs_as(attribute,type,input_options)
+            else
+              select(attribute,input_options)
+            end
+          else
+            singular_input_for(attribute,type,options)
+          end
+        end
+        
+        %w(date email number search tel url).each do |type|
+          class_eval <<-EOF
+          ##
+          # Constructs a #{type} field input from the given options
+          #
+          # ==== Examples
+          #
+          #   #{type}_field :username, :class => 'long'
+          #
+          def #{type}_field(field, options={})
+            options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+            options.merge!(:class => field_error(field, options))
+            @template.#{type}_field_tag(field_name(field), options)
+          end
+          EOF
+        end
+        
+
+        def collect_inputs_as(attribute,type,options={})
+          options[:options].map do |item|
+            collection_input(attribute,type,item,options.keep_if {|key, value| key != :options})
+          end.join("")
+        end
+        
+        def singular_input_for(attribute,type,options={})
+          options.keep_if {|key, value| key != :for}
+          opts = html_options(attribute,type,options)
+          case type
+          when :string
+            case attribute
+            when /email/         ; email_field(attribute, opts);
+            when /password/      ; password_field(attribute, opts);
+            when /tel/,/phone/   ; tel_field(attribute, opts);
+            when /url/,/website/ ; url_field(attribute, opts);
+            when /search/        ; search_field(attribute, opts);
+            else                 ; text_field(attribute, opts);
+            end
+          when :text
+            text_area(attribute, opts)
+          when :boolean
+            check_box(attribute, opts)
+          when :date
+            date_field(attribute, opts)
+          when :file
+            file_field(attribute, opts)
+          when :number
+            number_field(attribute, opts)
+          when :radios
+            default_radios(attribute,type,options)
+          end
+        end
+        
+        def required?(attribute)
+          k = klazz.is_a?(String) ? klazz.constantize : klazz
+          k.form_attribute_is_required?(attribute)
+        end
+        
+        def collection_input(attribute,type,item, options={})
+          unchecked_value = options.delete(:uncheck_value) || '0'
+          options.reverse_merge!(:id => field_id(attribute), :value => '1')
+          options.reverse_merge!(:checked => true) if values_matches_field?(attribute, options[:value])
+          klass =  css_class(attribute,type,options[:disabled])
+          name  =  type == :checks ? field_name(attribute) + '[]' : field_name(attribute)
+          if item.is_a?(Array)
+            text, value = item[0], item[1]
+          else
+            text = item; value = item;
+          end
+          id = field_id(attribute) + "_" + domize(text)
+          opts = html_options(attribute,type,options.merge(:id => id, :class => klass, :value => value))
+          if type == :checks
+            html = @template.hidden_field_tag(options[:name] || name, :value => unchecked_value, :id => nil)
+            input_item = @template.check_box_tag(name, opts)
+          else
+            html = ""
+            input_item = @template.radio_button_tag(name, opts)
+          end
+          html << "<label for='#{id}' class='#{klass}'>#{input_item}#{text}</label>"
+        end
+        
+        def domize(text)
+          text.downcase.gsub(' ','_').gsub(/[^[:alnum:]]/, '')
+        end
+        
+        def setup_label(attribute, type, options={})
+          marker = @@settings.label_required_marker
+          text = ""
+          text << marker if required?(attribute) && @@settings.label_required_marker_position == :prepend
+          text << field_human_name(attribute)
+          text << marker if required?(attribute) && @@settings.label_required_marker_position == :append
+          options.reverse_merge!(:caption => text, :class => css_class(attribute,type,options[:disabled]))
+          @template.label_tag(field_id(attribute), options)
+        end
+        
+        def css_class(attribute,type,disabled=false)
+          klass = type.to_s
+          klass << ' required' if required?(attribute)
+          klass << ' required' if disabled
+          klass
+        end
+        
+        def html_options(attribute,type,options)
+          options.keep_if {|key, value| key != :as}
+          html_class = options.merge(:class => css_class(attribute,type,options[:disabled]))
+          input_html = options[:input_html]
+          if input_html
+            html_class.merge(input_html) {|key, first, second| first + " " + second }.delete(:input_html)
+          else
+            html_class
+          end
+        end
+        
+        def labelize(options)
+          opts = {}.merge(options)
+          opts.keep_if {|key, value| [:class,:id,:caption].include?(key)}
+        end
+        
+        def hint(text)
+          @template.content_tag(:span, :class=>'hint') { text }
+        end
+        
+        def default_radios(attribute,type,options)
+          [['yes',1],['no',0]].map do |item|
+            collection_input(attribute,:radios,item,options.keep_if {|key, value| key != :options})
+          end.join("")
+        end
+        
+        def klazz
+          @object.class
+        end
+        
+      end # StandardFormBuilder
+    end # FormBuilder
+  end # Helpers
+end # Padrino

data/lib/padrino-fields/form_helpers.rb

@@ -0,0 +1,63 @@
+module Padrino
+  module Helpers
+    module FormHelpers
+      
+      %w(date date email number search tel url).each do |type|
+        class_eval <<-EOF
+        ##
+        # Constructs a #{type} field input from the given options
+        #
+        # ==== Examples
+        #
+        #   #{type}_field_tag :username, :class => 'long'
+        #
+        def #{type}_field_tag(name, options={})
+          options.reverse_merge!(:name => name)
+          input_tag(:#{type}, options)
+        end
+        EOF
+      end
+      
+      def select_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        collection, fields = options.delete(:collection), options.delete(:fields)
+        options[:options] = options_from_collection(collection, fields) if collection
+        prompt = options.delete(:include_blank)
+        select_options_html = if options[:options]
+          options_for_select(options.delete(:options), options.delete(:selected))
+        elsif options[:grouped_options]
+          grouped_options_for_select(options.delete(:grouped_options), options.delete(:selected), prompt)
+        end.unshift(blank_option(prompt))
+        options.merge!(:name => "#{options[:name]}[]") if options[:multiple]
+        content_tag(:select, select_options_html, options)
+      end
+
+      def grouped_options_for_select(collection,selected=nil,prompt=false)
+        if collection.is_a?(Hash)
+          collection.map do |key, value|
+            content_tag :optgroup, :label => key do
+              options_for_select(value, selected)
+            end
+          end
+        elsif collection.is_a?(Array)
+          collection.map do |optgroup|
+            content_tag :optgroup, :label => optgroup.first do
+              options_for_select(optgroup.last, selected)
+            end
+          end
+        end
+      end
+      
+      def blank_option(prompt)
+        if prompt
+          case prompt.class.to_s
+          when 'String' ; content_tag(:option, prompt, :value => '') ;
+          when 'Array'  ; content_tag(:option, prompt.first, :value => prompt.last) ;
+          else          ; content_tag(:option, '', :value => '') ;
+          end
+        end
+      end
+
+    end # FormHelpers
+  end # Helpers
+end # Padrino

data/lib/padrino-fields/orms/datamapper.rb

@@ -0,0 +1,54 @@
+require 'dm-core'
+require 'dm-validations'
+
+module PadrinoFields
+  module DataMapperWrapper
+    module ClassMethods
+
+      attr_reader :reflection
+      
+      def form_attribute_validators; validators.contexts[:default]; end
+      
+      def form_validators_on(attribute)
+        validators.contexts[:default].find_all {|v| v.field_name == attribute}
+      end
+      
+      def form_attribute_is_required?(attribute)
+        form_validators_on(attribute).find_all {|v| v.class == DataMapper::Validations::PresenceValidator }.any?
+      end
+      
+      def form_reflection_validators(reflection=nil)
+        new.send(reflection).validators.contexts[:default]
+      end
+      
+      def form_has_required_attributes?(reflection=nil)
+        validators = form_attribute_validators
+        validators += reflection_validators(reflection) if reflection
+        validators.find_all {|v| v.class == DataMapper::Validations::PresenceValidator }.any?
+      end
+      
+      def form_column_type_for(attribute)
+        klass = properties.find_all {|p| p.name == attribute}.first.class      
+        if klass == DataMapper::Property::String
+          :string
+        elsif klass == DataMapper::Property::Text
+          :text
+        elsif [DataMapper::Property::Integer,DataMapper::Property::Decimal,DataMapper::Property::Float].include?(klass)
+          :number
+        elsif klass == DataMapper::Property::Boolean
+          :boolean
+        elsif [DataMapper::Property::Date,DataMapper::Property::DateTime].include?(klass)
+          :date
+        elsif klass == DataMapper::Property::Serial
+          :serial
+        else
+          nil
+        end
+      end
+      
+    end # ClassMethods
+  end # Datamapper
+end # PadrinoFields
+
+DataMapper::Model.append_extensions(PadrinoFields::DataMapperWrapper::ClassMethods)
+#DataMapper::Model.append_inclusions(PadrinoFields::DataMapperWrapper::InstanceMethods) 

data/lib/padrino-fields/settings.rb

@@ -0,0 +1,18 @@
+module PadrinoFields
+  module Settings
+
+    mattr_accessor :container
+    @@container = :p
+    
+    mattr_accessor :label_required_marker
+    @@label_required_marker = "<abbr>*</abbr>"
+    
+    mattr_accessor :label_required_marker_position
+    @@label_required_marker_position = :prepend
+    
+    def self.configure
+      yield self
+    end
+    
+  end
+end

data/load_paths.rb

@@ -0,0 +1,12 @@
+begin
+  require File.expand_path('../.bundle/environment', __FILE__)
+rescue LoadError
+  if defined?(Gem)
+    Gem.cache
+    gem 'bundler'
+  else
+    require 'rubygems'
+  end
+  require 'bundler'
+  Bundler.setup
+end

data/padrino-fields.gemspec

@@ -0,0 +1,141 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{padrino-fields}
+  s.version = "0.3.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Steven Garcia"]
+  s.date = %q{2011-03-17}
+  s.description = %q{Smart fields for your forms, similar to Formtastic or SimpleForm}
+  s.email = %q{stevendgarcia@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "lib/padrino-fields.rb",
+    "lib/padrino-fields/form_builder.rb",
+    "lib/padrino-fields/form_helpers.rb",
+    "lib/padrino-fields/orms/datamapper.rb",
+    "lib/padrino-fields/settings.rb",
+    "load_paths.rb",
+    "padrino-fields.gemspec",
+    "test/.DS_Store",
+    "test/fixtures/datamapper/app.rb",
+    "test/fixtures/datamapper/views/capture_concat.erb",
+    "test/fixtures/datamapper/views/capture_concat.haml",
+    "test/fixtures/datamapper/views/content_for.erb",
+    "test/fixtures/datamapper/views/content_for.haml",
+    "test/fixtures/datamapper/views/content_tag.erb",
+    "test/fixtures/datamapper/views/content_tag.haml",
+    "test/fixtures/datamapper/views/fields_for.erb",
+    "test/fixtures/datamapper/views/fields_for.haml",
+    "test/fixtures/datamapper/views/form_for.erb",
+    "test/fixtures/datamapper/views/form_for.haml",
+    "test/fixtures/datamapper/views/form_tag.erb",
+    "test/fixtures/datamapper/views/form_tag.haml",
+    "test/fixtures/datamapper/views/link_to.erb",
+    "test/fixtures/datamapper/views/link_to.haml",
+    "test/fixtures/datamapper/views/mail_to.erb",
+    "test/fixtures/datamapper/views/mail_to.haml",
+    "test/fixtures/datamapper/views/meta_tag.erb",
+    "test/fixtures/datamapper/views/meta_tag.haml",
+    "test/helper.rb",
+    "test/test_datamapper.rb",
+    "test/test_form_builder.rb",
+    "test/test_form_helpers.rb",
+    "test/test_settings.rb"
+  ]
+  s.homepage = %q{http://github.com/activestylus/padrino-fields}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Advanced form helpers for Padrino framework}
+  s.test_files = [
+    "test/fixtures/datamapper/app.rb",
+    "test/helper.rb",
+    "test/test_datamapper.rb",
+    "test/test_form_builder.rb",
+    "test/test_form_helpers.rb",
+    "test/test_settings.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<padrino>, [">= 0"])
+      s.add_runtime_dependency(%q<padrino-core>, [">= 0"])
+      s.add_runtime_dependency(%q<padrino-helpers>, [">= 0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0.8.7"])
+      s.add_development_dependency(%q<mocha>, [">= 0.9.8"])
+      s.add_development_dependency(%q<rack-test>, [">= 0.5.0"])
+      s.add_development_dependency(%q<fakeweb>, [">= 1.2.8"])
+      s.add_development_dependency(%q<webrat>, [">= 0.5.1"])
+      s.add_development_dependency(%q<haml>, [">= 2.2.22"])
+      s.add_development_dependency(%q<phocus>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 2.10.3"])
+      s.add_development_dependency(%q<uuid>, [">= 2.3.1"])
+      s.add_development_dependency(%q<bcrypt-ruby>, [">= 0"])
+      s.add_development_dependency(%q<ruby-prof>, [">= 0.9.1"])
+      s.add_development_dependency(%q<system_timer>, [">= 1.0"])
+      s.add_development_dependency(%q<memcached>, [">= 0.20.1"])
+      s.add_development_dependency(%q<dalli>, [">= 1.0.2"])
+    else
+      s.add_dependency(%q<padrino>, [">= 0"])
+      s.add_dependency(%q<padrino-core>, [">= 0"])
+      s.add_dependency(%q<padrino-helpers>, [">= 0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0.8.7"])
+      s.add_dependency(%q<mocha>, [">= 0.9.8"])
+      s.add_dependency(%q<rack-test>, [">= 0.5.0"])
+      s.add_dependency(%q<fakeweb>, [">= 1.2.8"])
+      s.add_dependency(%q<webrat>, [">= 0.5.1"])
+      s.add_dependency(%q<haml>, [">= 2.2.22"])
+      s.add_dependency(%q<phocus>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 2.10.3"])
+      s.add_dependency(%q<uuid>, [">= 2.3.1"])
+      s.add_dependency(%q<bcrypt-ruby>, [">= 0"])
+      s.add_dependency(%q<ruby-prof>, [">= 0.9.1"])
+      s.add_dependency(%q<system_timer>, [">= 1.0"])
+      s.add_dependency(%q<memcached>, [">= 0.20.1"])
+      s.add_dependency(%q<dalli>, [">= 1.0.2"])
+    end
+  else
+    s.add_dependency(%q<padrino>, [">= 0"])
+    s.add_dependency(%q<padrino-core>, [">= 0"])
+    s.add_dependency(%q<padrino-helpers>, [">= 0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0.8.7"])
+    s.add_dependency(%q<mocha>, [">= 0.9.8"])
+    s.add_dependency(%q<rack-test>, [">= 0.5.0"])
+    s.add_dependency(%q<fakeweb>, [">= 1.2.8"])
+    s.add_dependency(%q<webrat>, [">= 0.5.1"])
+    s.add_dependency(%q<haml>, [">= 2.2.22"])
+    s.add_dependency(%q<phocus>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 2.10.3"])
+    s.add_dependency(%q<uuid>, [">= 2.3.1"])
+    s.add_dependency(%q<bcrypt-ruby>, [">= 0"])
+    s.add_dependency(%q<ruby-prof>, [">= 0.9.1"])
+    s.add_dependency(%q<system_timer>, [">= 1.0"])
+    s.add_dependency(%q<memcached>, [">= 0.20.1"])
+    s.add_dependency(%q<dalli>, [">= 1.0.2"])
+  end
+end
+