padrino-helpers 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Padrino
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= padrino-helpers
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2009 Padrino. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "padrino-helpers"
+    gem.summary = "Helpers for padrino"
+    gem.description = "Tag helpers, asset helpers, form helpers, form builders and many more helpers for padrino"
+    gem.email = "nesquena@gmail.com"
+    gem.homepage = "http://github.com/padrino/padrino-helpers"
+    gem.authors = ["Padrino Team", "Nathan Esquenazi", "Davide D'Agostino", "Arthur Chiu"]
+    gem.add_runtime_dependency     "sinatra",       ">= 0.9.2"
+    gem.add_development_dependency "haml",          ">= 2.2.1"
+    gem.add_development_dependency "shoulda", ">= 0"
+    gem.add_development_dependency "mocha",         ">= 0.9.7"
+    gem.add_development_dependency "rack-test",     ">= 0.5.0"
+    gem.add_development_dependency "webrat",        ">= 0.5.1"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "padrino-helpers #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/padrino-helpers.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../../padrino-core/lib/padrino-core/support_lite'
+Dir[File.dirname(__FILE__) + '/padrino-helpers/**/*.rb'].each {|file| require file }
+
+module Padrino
+  module Helpers
+    def self.registered(app)
+      app.set :default_builder, 'StandardFormBuilder'
+      app.helpers Padrino::Helpers::OutputHelpers
+      app.helpers Padrino::Helpers::TagHelpers
+      app.helpers Padrino::Helpers::AssetTagHelpers
+      app.helpers Padrino::Helpers::FormHelpers
+      app.helpers Padrino::Helpers::FormatHelpers
+      app.helpers Padrino::Helpers::RenderHelpers
+    end
+  end
+end

data/lib/padrino-helpers/asset_tag_helpers.rb

@@ -0,0 +1,97 @@
+module Padrino
+  module Helpers
+    module AssetTagHelpers
+
+      # Creates a div to display the flash of given type if it exists
+      # flash_tag(:notice, :class => 'flash', :id => 'flash-notice')
+      def flash_tag(kind, options={})
+        flash_text = flash[kind]
+        return '' if flash_text.blank?
+        options.reverse_merge!(:class => 'flash')
+        content_tag(:div, flash_text, options)
+      end
+
+      # Creates a link element with given name, url and options
+      # link_to 'click me', '/dashboard', :class => 'linky'
+      # link_to('/dashboard', :class => 'blocky') do ... end
+      # parameters: name, url='javascript:void(0)', options={}, &block
+      def link_to(*args, &block)
+        if block_given?
+          url, options = (args[0] || 'javascript:void(0);'), (args[1] || {})
+          options.reverse_merge!(:href => url)
+          link_content = capture_html(&block)
+          result_link = content_tag(:a, link_content, options)
+          block_is_template?(block) ? concat_content(result_link) : result_link
+        else
+          name, url, options = args.first, (args[1] || 'javascript:void(0);'), (args[2] || {})
+          options.reverse_merge!(:href => url)
+          content_tag(:a, name, options)
+        end
+      end
+
+      # Creates a mail link element with given name and caption
+      # mail_to "me@demo.com"             => <a href="mailto:me@demo.com">me@demo.com</a>
+      # mail_to "me@demo.com", "My Email" => <a href="mailto:me@demo.com">My Email</a>
+      def mail_to(email, caption=nil, mail_options={})
+        html_options = mail_options.slice!(:cc, :bcc, :subject, :body)
+        mail_query = Rack::Utils.build_query(mail_options).gsub(/\+/, '%20').gsub('%40', '@')
+        mail_href = "mailto:#{email}"; mail_href << "?#{mail_query}" if mail_query.present?
+        link_to (caption || email), mail_href, html_options
+      end
+
+      # Creates an image element with given url and options
+      # image_tag('icons/avatar.png')
+      def image_tag(url, options={})
+        options.reverse_merge!(:src => image_path(url))
+        tag(:img, options)
+      end
+
+      # Returns a stylesheet link tag for the sources specified as arguments
+      # stylesheet_link_tag 'style', 'application', 'layout'
+      def stylesheet_link_tag(*sources)
+        options = sources.extract_options!.symbolize_keys
+        sources.collect { |sheet| stylesheet_tag(sheet, options) }.join("\n")
+      end
+
+      # javascript_include_tag 'application', 'special'
+      def javascript_include_tag(*sources)
+        options = sources.extract_options!.symbolize_keys
+        sources.collect { |script| javascript_tag(script, options) }.join("\n")
+      end
+
+      # Returns the path to the image, either relative or absolute
+      def image_path(src)
+        src.gsub!(/\s/, '')
+        src =~ %r{^\s*(/|http)} ? src : File.join('/images', src)
+      end
+
+      protected
+
+      # stylesheet_tag('style', :media => 'screen')
+      def stylesheet_tag(source, options={})
+        options = options.dup.reverse_merge!(:href => stylesheet_path(source), :media => 'screen', :rel => 'stylesheet', :type => 'text/css')
+        tag(:link, options)
+      end
+
+      # javascript_tag 'application', :src => '/javascripts/base/application.js'
+      def javascript_tag(source, options={})
+        options = options.dup.reverse_merge!(:src => javascript_path(source), :type => 'text/javascript', :content => "")
+        tag(:script, options)
+      end
+
+      def javascript_path(source)
+        return source if source =~ /^http/
+        result_path = "/javascripts/#{File.basename(source, '.js')}.js"
+        stamp = File.exist?(result_path) ? File.mtime(result_path) : Time.now.to_i
+        "#{result_path}?#{stamp}"
+      end
+
+      def stylesheet_path(source)
+        return source if source =~ /^http/
+        result_path = "/stylesheets/#{File.basename(source, '.css')}.css"
+        stamp = File.exist?(result_path) ? File.mtime(result_path) : Time.now.to_i
+        "#{result_path}?#{stamp}"
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_builder/abstract_form_builder.rb

@@ -0,0 +1,139 @@
+module Padrino
+  module Helpers
+    module FormBuilder
+      class AbstractFormBuilder
+        attr_accessor :template, :object
+
+        def initialize(template, object)
+          @template = template
+          @object   = build_object(object)
+          raise "FormBuilder template must be initialized!" unless template
+          raise "FormBuilder object must be not be nil value. If there's no object, use a symbol instead! (i.e :user)" unless object
+        end
+
+        # f.error_messages
+        def error_messages(options={})
+          @template.error_messages_for(@object, options)
+        end
+
+        # f.label :username, :caption => "Nickname"
+        def label(field, options={})
+          options.reverse_merge!(:caption => field.to_s.titleize)
+          @template.label_tag(field_id(field), options)
+        end
+
+        # f.hidden_field :session_id, :value => "45"
+        def hidden_field(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @template.hidden_field_tag field_name(field), options
+        end
+
+        # f.text_field :username, :value => "(blank)", :id => 'username'
+        def text_field(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @template.text_field_tag field_name(field), options
+        end
+
+        # f.text_area :summary, :value => "(enter summary)", :id => 'summary'
+        def text_area(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @template.text_area_tag field_name(field), options
+        end
+
+        # f.password_field :password, :id => 'password'
+        def password_field(field, options={})
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          @template.password_field_tag field_name(field), options
+        end
+
+        # f.select :color, :options => ['red', 'green'], :include_blank => true
+        # f.select :color, :collection => @colors, :fields => [:name, :id]
+        def select(field, options={})
+          options.reverse_merge!(:id => field_id(field), :selected => field_value(field))
+          @template.select_tag field_name(field), options
+        end
+
+        # f.check_box :remember_me, :value => 'true', :uncheck_value => '0'
+        def check_box(field, options={})
+          unchecked_value = options.delete(:uncheck_value) || '0'
+          options.reverse_merge!(:id => field_id(field), :value => '1')
+          options.merge!(:checked => true) if values_matches_field?(field, options[:value])
+          html = @template.check_box_tag field_name(field), options
+          html << hidden_field(field, :value => unchecked_value, :id => nil)
+        end
+
+        # f.radio_button :gender, :value => 'male'
+        def radio_button(field, options={})
+          options.reverse_merge!(:id => field_id(field, options[:value]))
+          options.merge!(:checked => true) if values_matches_field?(field, options[:value])
+          @template.radio_button_tag field_name(field), options
+        end
+
+        # f.file_field :photo, :class => 'avatar'
+        def file_field(field, options={})
+          options.reverse_merge!(:id => field_id(field))
+          @template.file_field_tag field_name(field), options
+        end
+
+        # f.submit "Update", :class => 'large'
+        def submit(caption="Submit", options={})
+          @template.submit_tag caption, options
+        end
+
+        # f.simage_submitubmit "buttons/submit.png", :class => 'large'
+        def image_submit(source, options={})
+          @template.image_submit_tag source, options
+        end
+
+        protected
+
+        # Returns the known field types for a formbuilder
+        def self.field_types
+          [:hidden_field, :text_field, :text_area, :password_field, :file_field, :radio_button, :check_box, :select]
+        end
+
+        # Returns the object's models name
+        #   => user_assignment
+        def object_name
+          object.is_a?(Symbol) ? object : object.class.to_s.underscore
+        end
+
+        # Returns true if the value matches the value in the field
+        # field_has_value?(:gender, 'male')
+        def values_matches_field?(field, value)
+          value.present? && (field_value(field).to_s == value.to_s || field_value(field).to_s == 'true')
+        end
+
+        # Returns the value for the object's field
+        # field_value(:username) => "Joey"
+        def field_value(field)
+          @object && @object.respond_to?(field) ? @object.send(field) : ""
+        end
+
+        # Returns the name for the given field
+        # field_name(:username) => "user[username]"
+        def field_name(field)
+          "#{object_name}[#{field}]"
+        end
+
+        # Returns the id for the given field
+        # field_id(:username) => "user_username"
+        # field_id(:gender, :male) => "user_gender_male"
+        def field_id(field, value=nil)
+          value.blank? ? "#{object_name}_#{field}" : "#{object_name}_#{field}_#{value}"
+        end
+
+        # explicit_object is either a symbol or a record
+        # Returns a new record of the type specified in the object
+        def build_object(object_or_symbol)
+          object_or_symbol.is_a?(Symbol) ? object_class(object_or_symbol).new : object_or_symbol
+        end
+
+        # Returns the class type for the given object
+        def object_class(explicit_object)
+          explicit_object.is_a?(Symbol) ? explicit_object.to_s.classify.constantize : explicit_object.class
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_builder/standard_form_builder.rb

@@ -0,0 +1,37 @@
+module Padrino
+  module Helpers
+    module FormBuilder
+      class StandardFormBuilder < AbstractFormBuilder
+
+        # text_field_block(:username, { :class => 'long' }, { :class => 'wide-label' })
+        # text_area_block(:summary, { :class => 'long' }, { :class => 'wide-label' })
+        # password_field_block(:password, { :class => 'long' }, { :class => 'wide-label' })
+        # file_field_block(:photo, { :class => 'long' }, { :class => 'wide-label' })
+        # check_box_block(:remember_me, { :class => 'long' }, { :class => 'wide-label' })
+        # select_block(:color, :options => ['green', 'black'])
+        (self.field_types - [ :hidden_field, :radio_button ]).each do |field_type|
+          class_eval <<-EOF
+          def #{field_type}_block(field, options={}, label_options={})
+            label_options.reverse_merge!(:caption => options.delete(:caption)) if options[:caption]
+            field_html = label(field, label_options)
+            field_html << #{field_type}(field, options)
+            @template.content_tag(:p, field_html)
+          end
+          EOF
+        end
+
+        # submit_block("Update")
+        def submit_block(caption, options={})
+          submit_html = self.submit(caption, options)
+          @template.content_tag(:p, submit_html)
+        end
+
+        # image_submit_block("submit.png")
+        def image_submit_block(source, options={})
+          submit_html = self.image_submit(source, options)
+          @template.content_tag(:p, submit_html)
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_helpers.rb

@@ -0,0 +1,194 @@
+module Padrino
+  module Helpers
+    module FormHelpers
+      # Constructs a form for object using given or default form_builder
+      # form_for :user, '/register' do |f| ... end
+      # form_for @user, '/register', :id => 'register' do |f| ... end
+      def form_for(object, url, settings={}, &block)
+        builder_class = configured_form_builder_class(settings[:builder])
+        form_html = capture_html(builder_class.new(self, object), &block)
+        form_tag(url, settings) { form_html }
+      end
+
+      # Constructs form fields for an object using given or default form_builder
+      # Used within an existing form to allow alternate objects within one form
+      # fields_for @user.assignment do |assignment| ... end
+      # fields_for :assignment do |assigment| ... end
+      def fields_for(object, settings={}, &block)
+        builder_class = configured_form_builder_class(settings[:builder])
+        fields_html = capture_html(builder_class.new(self, object), &block)
+        concat_content fields_html
+      end
+
+      # Constructs a form without object based on options
+      # form_tag '/register' do ... end
+      def form_tag(url, options={}, &block)
+        options.reverse_merge!(:method => 'post', :action => url)
+        options[:enctype] = "multipart/form-data" if options.delete(:multipart)
+        inner_form_html = hidden_form_method_field(options[:method]) + capture_html(&block)
+        concat_content content_tag('form', inner_form_html, options)
+      end
+
+      # Constructs a field_set to group fields with given options
+      # field_set_tag("Office", :class => 'office-set')
+      # parameters: legend_text=nil, options={}
+      def field_set_tag(*args, &block)
+        options = args.extract_options!
+        legend_text = args[0].is_a?(String) ? args.first : nil
+        legend_html = legend_text.blank? ? '' : content_tag(:legend, legend_text)
+        field_set_content = legend_html + capture_html(&block)
+        concat_content content_tag('fieldset', field_set_content, options)
+      end
+
+      # Constructs list html for the errors for a given object
+      # error_messages_for @user
+      def error_messages_for(record, options={})
+        return "" if record.blank? or record.errors.none?
+        options.reverse_merge!(:header_message => "The #{record.class.to_s.downcase} could not be saved!")
+        error_messages = record.errors.full_messages
+        error_items = error_messages.collect { |er| content_tag(:li, er) }.join("\n")
+        error_html = content_tag(:p, options.delete(:header_message))
+        error_html << content_tag(:ul, error_items, :class => 'errors-list')
+        content_tag(:div, error_html, :class => 'field-errors')
+      end
+
+      # Constructs a label tag from the given options
+      # label_tag :username, :class => 'long-label'
+      # label_tag :username, :class => 'long-label' do ... end
+      def label_tag(name, options={}, &block)
+        options.reverse_merge!(:caption => name.to_s.titleize, :for => name)
+        caption_text = options.delete(:caption) + ": "
+        if block_given? # label with inner content
+          label_content = caption_text + capture_html(&block)
+          concat_content(content_tag(:label, label_content, options))
+        else # regular label
+          content_tag(:label, caption_text, options)
+        end
+      end
+
+      # Constructs a hidden field input from the given options
+      # hidden_field_tag :session_key, :value => "__secret__"
+      def hidden_field_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:hidden, options)
+      end
+
+      # Constructs a text field input from the given options
+      # text_field_tag :username, :class => 'long'
+      def text_field_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:text, options)
+      end
+
+      # Constructs a text area input from the given options
+      # text_area_tag :username, :class => 'long'
+      def text_area_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        content_tag(:textarea, '', options)
+      end
+
+      # Constructs a password field input from the given options
+      # password_field_tag :password, :class => 'long'
+      def password_field_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:password, options)
+      end
+
+      # Constructs a check_box from the given options
+      # options = [['caption', 'value'], ['Green', 'green1'], ['Blue', 'blue1'], ['Black', "black1"]]
+      # options = ['option', 'red', 'yellow' ]
+      # select_tag(:favorite_color, :options => ['red', 'yellow'], :selected => 'green1')
+      # select_tag(:country, :collection => @countries, :fields => [:name, :code])
+      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
+        options[:options].unshift('') if options.delete(:include_blank)
+        select_options_html = options_for_select(options.delete(:options), options.delete(:selected))
+        options.merge!(:name => "#{options[:name]}[]") if options[:multiple]
+        content_tag(:select, select_options_html, options)
+      end
+
+      # Constructs a check_box from the given options
+      # check_box_tag :remember_me, :value => 'Yes'
+      def check_box_tag(name, options={})
+        options.reverse_merge!(:name => name, :value => '1')
+        input_tag(:checkbox, options)
+      end
+
+      # Constructs a radio_button from the given options
+      # radio_button_tag :remember_me, :value => 'true'
+      def radio_button_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:radio, options)
+      end
+
+      # Constructs a file field input from the given options
+      # file_field_tag :photo, :class => 'long'
+      def file_field_tag(name, options={})
+        options.reverse_merge!(:name => name)
+        input_tag(:file, options)
+      end
+
+      # Constructs a submit button from the given options
+      # submit_tag "Create", :class => 'success'
+      def submit_tag(caption="Submit", options={})
+        options.reverse_merge!(:value => caption)
+        input_tag(:submit, options)
+      end
+
+      # Constructs a button input from the given options
+      # button_tag "Cancel", :class => 'clear'
+      def button_tag(caption, options = {})
+        options.reverse_merge!(:value => caption)
+        input_tag(:button, options)
+      end
+
+      # Constructs a submit button from the given options
+      # submit_tag "Create", :class => 'success'
+      def image_submit_tag(source, options={})
+        options.reverse_merge!(:src => image_path(source))
+        input_tag(:image, options)
+      end
+
+      protected
+
+      # Returns an array of option items for a select field based on the given collection
+      # fields is an array containing the fields to display from each item in the collection
+      def options_from_collection(collection, fields)
+        return '' if collection.blank?
+        collection.collect { |item| [ item.send(fields.first), item.send(fields.last) ] }
+      end
+
+      # Returns the options tags for a select based on the given option items
+      def options_for_select(option_items, selected_value=nil)
+        return '' if option_items.blank?
+        option_items.collect do |caption, value|
+          value ||= caption
+          content_tag(:option, caption, :value => value, :selected => selected_value.to_s =~ /#{value}|#{caption}/)
+        end
+      end
+
+      # returns the hidden method field for 'put' and 'delete' forms
+      # Only 'get' and 'post' are allowed within browsers;
+      # 'put' and 'delete' are just specified using hidden fields with form action still 'put'.
+      # hidden_form_method_field('delete') => <input name="_method" value="delete" />
+      def hidden_form_method_field(desired_method)
+        return '' if (desired_method =~ /get|post/)
+        original_method = desired_method.dup
+        desired_method.replace('post')
+        hidden_field_tag(:_method, :value => original_method)
+      end
+
+      # Returns the FormBuilder class to use based on all available setting sources
+      # If explicitly defined, returns that, otherwise returns defaults
+      # configured_form_builder_class(nil) => StandardFormBuilder
+      def configured_form_builder_class(explicit_builder=nil)
+        default_builder = self.respond_to?(:options) && self.options.default_builder
+        configured_builder = explicit_builder || default_builder || 'StandardFormBuilder'
+        configured_builder = "Padrino::Helpers::FormBuilder::#{configured_builder}".constantize if configured_builder.is_a?(String)
+        configured_builder
+      end
+    end
+  end
+end