formtastic_datepicker_inputs 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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

@@ -0,0 +1,52 @@
+FormtasticDatepickerInputs
+==========================
+
+This plugin is based off of a blog post by Grzegorz Brzezinka: http://blog.brzezinka.eu/webmaster-tips/ruby/ruby-on-rails-formtastic-jquery-ui-datepicker
+
+The concept is simple. It adds a new input into formtastic that can be used like this:  
+<% semantic_form_for @master do |f| -%>
+  <% f.inputs do -%>
+    <%= f.input :name %>
+    <%= f.input :born, :as => :date_picker %>
+  <% end -%>
+  <%= f.buttons %>
+<% end -%>
+
+It adds a class onto a normal text input called 'ui-date-picker', and the parent <li> it adds a class called 'date_picker.'
+Assuming you have already referenced jquery, and jqueryui in your layout, You can then hook this with a call from jquery:
+
+$(document).ready(function(){
+  $('input.ui-date-picker').datepicker();
+});
+
+Development Environment
+=======================
+
+We currently support both Rails 2 and Rails 3, under Ruby 1.8.7-ish (and 1.9.2-ish). That means, at a bare minimum, you'll want to set-up two rvm gemsets to run your specs against. So, fork the project on Github, clone it, make some gemsets, run bundler, run your specs and then finally set-up an .rvmrc file that specifies Rails 3 as your default gemset and cd back into that directory to load in the .rvmrc file. Something like this:
+
+<pre>
+  $ cd ~/code/formtastic
+  $ rvm gemset create formtastic-rails3
+  $ rvm gemset use formtastic-rails3
+  $ gem install bundler
+  $ bundle install
+  $ rake spec
+  $ rm Gemfile.lock
+  $ rvm gemset create formtastic-rails2
+  $ rvm gemset use formtastic-rails2
+  $ gem install bundler
+  $ RAILS_2=true bundle install
+  $ RAILS_2=true rake spec
+  $ touch .rvmrc
+  $ echo "rvm gemset use formtastic-rails-3" > .rvmrc
+  $ cd ~/code/formtastic
+</pre>
+
+Also, most of the testing environment has been copied straight of formtastic, so if something doesn't make sense here, it probably did where I grabbed it from.
+
+Contributors
+============
+
+* Grzegorz Brzezinka
+* Nik Petersen
+* Alan Harper

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/init.rb

@@ -0,0 +1,2 @@
+# Include hook code here
+require 'formtastic_datepicker_inputs'

data/lib/formtastic_datepicker_inputs.rb

@@ -0,0 +1,48 @@
+# FormtasticDatepickerInputs
+#To get this solution working in Rails 3, replace:
+#
+#format = options[:format] || ActiveSupport::CoreExtensions::Date::Conversions::DATE_FORMATS[:default] || ‘%d %b %Y’
+#
+#with:
+#
+#format = options[:format] || Date::DATE_FORMATS[:default] || ‘%d %b %Y’
+module Formtastic
+  if defined?(ActiveSupport::CoreExtensions)
+	DATE_FORMATS = ActiveSupport::CoreExtensions::Date::Conversions::DATE_FORMATS
+  else
+	DATE_FORMATS = Date::DATE_FORMATS
+  end
+ 
+  module DatePicker
+    protected
+
+    def date_picker_input(method, options = {})
+      format = options[:format] || DATE_FORMATS[:default] || '%d %b %Y'
+      string_input(method, date_picker_options(format, object.send(method)).merge(options))
+    end
+
+    # Generate html input options for the datepicker_input
+    #
+    def date_picker_options(format, value = nil)
+      {:input_html => {:class => 'ui-date-picker',:value => value.try(:strftime, format)}}
+    end
+  end
+  
+  module DateTimePicker
+    protected
+
+    def datetime_picker_input(method, options = {})
+      format = options[:format] || DATE_FORMATS[:default] || '%d %b %Y %H:%M'
+      string_input(method, datetime_picker_options(format, object.send(method)).merge(options))
+    end
+
+    # Generate html input options for the datepicker_input
+    #
+    def datetime_picker_options(format, value = nil)
+	  {:wrapper_html => {:class => 'datetime'},:input_html => {:class => 'ui-datetime-picker',:value => value.try(:strftime, format)}}
+    end
+  end
+end
+
+Formtastic::SemanticFormBuilder.send(:include, Formtastic::DatePicker)
+Formtastic::SemanticFormBuilder.send(:include, Formtastic::DateTimePicker)

data/spec/formtastic_datepicker_inputs_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "FormtasticDatepickerInputs" do
+  include FormtasticDatepickerInputsSpecHelper
+
+  before do
+    @output_buffer = ''
+    mock_everything
+  end
+
+  describe "date_picker_input" do
+	before do
+	  @new_post.stub!(:publish_at).and_return(DateTime.parse('2000-01-02'))
+      output_buffer.replace ''
+      @form = semantic_form_for(@new_post) do |builder|
+        concat(builder.input(:publish_at, :as => :date_picker))
+      end
+    end
+
+    it_should_have_input_wrapper_with_class(:date_picker)
+    it_should_have_input_wrapper_with_id("post_publish_at_input")
+    it_should_have_label_with_text(/Publish at/)
+    it_should_have_label_for("post_publish_at")
+    it_should_have_input_with_id("post_publish_at")
+    it_should_have_input_with_type(:text)
+    it_should_have_input_with_name("post[publish_at]")
+    it_should_have_input_with_class("ui-date-picker")
+    
+    it "should format date correctly" do
+	  output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag("form li input#post_publish_at[@value='02 Jan 2000']")
+	end
+  end
+
+  it "should use custom date format correctly" do
+	@new_post.stub!(:publish_at).and_return(DateTime.parse('2000-01-02'))
+	output_buffer.replace ''
+	@form = semantic_form_for(@new_post) do |builder|
+	  concat(builder.input(:publish_at, :as => :date_picker, :format => '%A, %B %d %Y'))
+	end
+	output_buffer.concat(@form) if Formtastic::Util.rails3?
+	output_buffer.should have_tag("form li input#post_publish_at[@value='Sunday, January 02 2000']")
+  end
+
+  describe "datetime_picker_input" do
+	before do
+	@new_post.stub!(:publish_at).and_return(DateTime.parse('2000-01-02 03:04'))
+      output_buffer.replace ''
+      @form = semantic_form_for(@new_post) do |builder|
+        concat(builder.input(:publish_at, :as => :datetime_picker))
+      end
+    end
+
+    it_should_have_input_wrapper_with_class(:datetime_picker)
+    it_should_have_input_wrapper_with_id("post_publish_at_input")
+    it_should_have_label_with_text(/Publish at/)
+    it_should_have_label_for("post_publish_at")
+    it_should_have_input_with_id("post_publish_at")
+    it_should_have_input_with_type(:text)
+    it_should_have_input_with_name("post[publish_at]")
+    it_should_have_input_with_class("ui-datetime-picker")
+    
+    it "should format date correctly" do
+	  output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag("form li input#post_publish_at[@value='02 Jan 2000 03:04']")
+	end
+  end
+  
+  it "should use custom date/time format correctly" do
+	@new_post.stub!(:publish_at).and_return(DateTime.parse('2000-01-02 03:04'))
+	output_buffer.replace ''
+	@form = semantic_form_for(@new_post) do |builder|
+	  concat(builder.input(:publish_at, :as => :date_picker, :format => '%A, %B %d %Y %H:%M'))
+	end
+	output_buffer.concat(@form) if Formtastic::Util.rails3?
+	output_buffer.should have_tag("form li input#post_publish_at[@value='Sunday, January 02 2000 03:04']")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,327 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+
+require 'active_support'
+require 'action_pack'
+require 'action_view'
+require 'action_controller'
+require 'formtastic'
+require 'rspec_tag_matchers'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+require 'formtastic_datepicker_inputs'
+
+RSpec.configure do |config|
+  config.include RspecTagMatchers
+  config.include CustomMacros
+  config.mock_with :rspec
+end
+
+module FormtasticDatepickerInputsSpecHelper
+  include ActionPack
+  include ActionView::Context if defined?(ActionView::Context)
+  include ActionController::RecordIdentifier
+  include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::FormOptionsHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::ActiveRecordHelper if defined?(ActionView::Helpers::ActiveRecordHelper)
+  include ActionView::Helpers::ActiveModelHelper if defined?(ActionView::Helpers::ActiveModelHelper)
+  include ActionView::Helpers::DateHelper
+  include ActionView::Helpers::CaptureHelper
+  include ActionView::Helpers::AssetTagHelper
+  include ActiveSupport
+  include ActionController::PolymorphicRoutes if defined?(ActionController::PolymorphicRoutes)
+
+  include Formtastic::SemanticFormHelper
+
+  def rails3?
+    ActionPack::VERSION::MAJOR > 2
+  end
+
+  def rails2?
+    ActionPack::VERSION::MAJOR == 2
+  end
+
+  def default_input_type(column_type, column_name = :generic_column_name)
+    @new_post.stub!(column_name)
+    @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => column_type)) unless column_type.nil?
+
+    semantic_form_for(@new_post) do |builder|
+      @default_type = builder.send(:default_input_type, column_name)
+    end
+
+    return @default_type
+  end
+
+  def active_model_validator(kind, attributes, options = {})
+    validator = mock("ActiveModel::Validations::#{kind.to_s.titlecase}Validator", :attributes => attributes, :options => options)
+    validator.stub!(:kind).and_return(kind)
+    validator
+  end
+
+  def active_model_presence_validator(attributes, options = {})
+    active_model_validator(:presence, attributes, options)
+  end
+
+  def active_model_length_validator(attributes, options = {})
+    active_model_validator(:length, attributes, options)
+  end
+
+  def active_model_inclusion_validator(attributes, options = {})
+    active_model_validator(:inclusion, attributes, options)
+  end
+
+  class ::Post
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+    def id
+    end
+
+    def persisted?
+    end
+  end
+  module ::Namespaced
+    class Post
+      extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+      include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+      def id
+      end
+
+      def persisted?
+      end
+    end
+  end
+  class ::Author
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+    def to_label
+    end
+  end
+  class ::Continent
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+  end
+  class ::PostModel
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+  end
+
+  def mock_everything
+
+    # Resource-oriented styles like form_for(@post) will expect a path method for the object,
+    # so we're defining some here.
+    def post_models_path; "/postmodels/1"; end
+
+    def post_path(o); "/posts/1"; end
+    def posts_path; "/posts"; end
+    def new_post_path; "/posts/new"; end
+
+    def author_path(o); "/authors/1"; end
+    def authors_path; "/authors"; end
+    def new_author_path; "/authors/new"; end
+    
+    @fred = ::Author.new
+    @fred.stub!(:class).and_return(::Author)
+    @fred.stub!(:to_label).and_return('Fred Smith')
+    @fred.stub!(:login).and_return('fred_smith')
+    @fred.stub!(:id).and_return(37)
+    @fred.stub!(:new_record?).and_return(false)
+    @fred.stub!(:errors).and_return(mock('errors', :[] => nil))
+    @fred.stub!(:to_key).and_return(nil)
+    @fred.stub!(:persisted?).and_return(nil)
+
+    @bob = ::Author.new
+    @bob.stub!(:to_label).and_return('Bob Rock')
+    @bob.stub!(:login).and_return('bob')
+    @bob.stub!(:created_at)
+    @bob.stub!(:id).and_return(42)
+    @bob.stub!(:posts).and_return([])
+    @bob.stub!(:post_ids).and_return([])
+    @bob.stub!(:new_record?).and_return(false)
+    @bob.stub!(:errors).and_return(mock('errors', :[] => nil))
+    @bob.stub!(:to_key).and_return(nil)
+    @bob.stub!(:persisted?).and_return(nil)
+
+    @james = ::Author.new
+    @james.stub!(:to_label).and_return('James Shock')
+    @james.stub!(:login).and_return('james')
+    @james.stub!(:id).and_return(75)
+    @james.stub!(:posts).and_return([])
+    @james.stub!(:post_ids).and_return([])
+    @james.stub!(:new_record?).and_return(false)
+    @james.stub!(:errors).and_return(mock('errors', :[] => nil))
+    @james.stub!(:to_key).and_return(nil)
+    @james.stub!(:persisted?).and_return(nil)
+
+
+    ::Author.stub!(:find).and_return([@fred, @bob])
+    ::Author.stub!(:all).and_return([@fred, @bob])
+    ::Author.stub!(:human_attribute_name).and_return { |column_name| column_name.humanize }
+    ::Author.stub!(:human_name).and_return('::Author')
+    ::Author.stub!(:reflect_on_association).and_return { |column_name| mock('reflection', :options => {}, :klass => Post, :macro => :has_many) if column_name == :posts }
+    ::Author.stub!(:content_columns).and_return([mock('column', :name => 'login'), mock('column', :name => 'created_at')])
+    ::Author.stub!(:to_key).and_return(nil)
+    ::Author.stub!(:persisted?).and_return(nil)
+
+    # Sometimes we need a mock @post object and some Authors for belongs_to
+    @new_post = mock('post')
+    @new_post.stub!(:class).and_return(::Post)
+    @new_post.stub!(:id).and_return(nil)
+    @new_post.stub!(:new_record?).and_return(true)
+    @new_post.stub!(:errors).and_return(mock('errors', :[] => nil))
+    @new_post.stub!(:author).and_return(nil)
+    @new_post.stub!(:reviewer).and_return(nil)
+    @new_post.stub!(:main_post).and_return(nil)
+    @new_post.stub!(:sub_posts).and_return([]) #TODO should be a mock with methods for adding sub posts
+    @new_post.stub!(:to_key).and_return(nil)
+    @new_post.stub!(:to_model).and_return(@new_post)
+    @new_post.stub!(:persisted?).and_return(nil)
+
+    @freds_post = mock('post')
+    @freds_post.stub!(:to_ary)
+    @freds_post.stub!(:class).and_return(::Post)
+    @freds_post.stub!(:to_label).and_return('Fred Smith')
+    @freds_post.stub!(:id).and_return(19)
+    @freds_post.stub!(:title).and_return("Hello World")
+    @freds_post.stub!(:author).and_return(@fred)
+    @freds_post.stub!(:author_id).and_return(@fred.id)
+    @freds_post.stub!(:authors).and_return([@fred])
+    @freds_post.stub!(:author_ids).and_return([@fred.id])
+    @freds_post.stub!(:new_record?).and_return(false)
+    @freds_post.stub!(:errors).and_return(mock('errors', :[] => nil))
+    @freds_post.stub!(:to_key).and_return(nil)
+    @freds_post.stub!(:persisted?).and_return(nil)
+    @fred.stub!(:posts).and_return([@freds_post])
+    @fred.stub!(:post_ids).and_return([@freds_post.id])
+
+    ::Post.stub!(:human_attribute_name).and_return { |column_name| column_name.humanize }
+    ::Post.stub!(:human_name).and_return('Post')
+    ::Post.stub!(:reflect_on_all_validations).and_return([])
+    ::Post.stub!(:reflect_on_validations_for).and_return([])
+    ::Post.stub!(:reflections).and_return({})
+    ::Post.stub!(:reflect_on_association).and_return do |column_name|
+      case column_name
+      when :author, :author_status
+        mock = mock('reflection', :options => {}, :klass => ::Author, :macro => :belongs_to)
+        mock.stub!(:[]).with(:class_name).and_return("Author")
+        mock
+      when :reviewer
+        mock = mock('reflection', :options => {:class_name => 'Author'}, :klass => ::Author, :macro => :belongs_to)
+        mock.stub!(:[]).with(:class_name).and_return("Author")
+        mock
+      when :authors
+        mock('reflection', :options => {}, :klass => ::Author, :macro => :has_and_belongs_to_many)
+      when :sub_posts
+        mock('reflection', :options => {}, :klass => ::Post, :macro => :has_many)
+      when :main_post
+        mock('reflection', :options => {}, :klass => ::Post, :macro => :belongs_to)
+      end
+
+    end
+    ::Post.stub!(:find).and_return([@freds_post])
+    ::Post.stub!(:all).and_return([@freds_post])
+    ::Post.stub!(:content_columns).and_return([mock('column', :name => 'title'), mock('column', :name => 'body'), mock('column', :name => 'created_at')])
+    ::Post.stub!(:to_key).and_return(nil)
+    ::Post.stub!(:persisted?).and_return(nil)
+    ::Post.stub!(:to_ary)
+
+    @mock_file = mock('file')
+    ::Formtastic::SemanticFormBuilder.file_methods.each do |method|
+      @mock_file.stub!(method).and_return(true)
+    end
+
+    @new_post.stub!(:title)
+    @new_post.stub!(:email)
+    @new_post.stub!(:url)
+    @new_post.stub!(:phone)
+    @new_post.stub!(:search)
+    @new_post.stub!(:to_ary)
+    @new_post.stub!(:body)
+    @new_post.stub!(:published)
+    @new_post.stub!(:publish_at)
+    @new_post.stub!(:created_at)
+    @new_post.stub!(:secret)
+    @new_post.stub!(:url)
+    @new_post.stub!(:email)
+    @new_post.stub!(:search)
+    @new_post.stub!(:phone)
+    @new_post.stub!(:time_zone)
+    @new_post.stub!(:category_name)
+    @new_post.stub!(:allow_comments).and_return(true)
+    @new_post.stub!(:answer_comments)
+    @new_post.stub!(:country)
+    @new_post.stub!(:country_subdivision)
+    @new_post.stub!(:country_code)
+    @new_post.stub!(:document).and_return(@mock_file)
+    @new_post.stub!(:column_for_attribute).with(:meta_description).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:title).and_return(mock('column', :type => :string, :limit => 50))
+    @new_post.stub!(:column_for_attribute).with(:body).and_return(mock('column', :type => :text))
+    @new_post.stub!(:column_for_attribute).with(:published).and_return(mock('column', :type => :boolean))
+    @new_post.stub!(:column_for_attribute).with(:publish_at).and_return(mock('column', :type => :date, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:time_zone).and_return(mock('column', :type => :string))
+    @new_post.stub!(:column_for_attribute).with(:allow_comments).and_return(mock('column', :type => :boolean))
+    @new_post.stub!(:column_for_attribute).with(:author).and_return(mock('column', :type => :integer))
+    @new_post.stub!(:column_for_attribute).with(:country).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:country_subdivision).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:country_code).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:email).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:url).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:phone).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:search).and_return(mock('column', :type => :string, :limit => 255))
+    @new_post.stub!(:column_for_attribute).with(:document).and_return(nil)
+
+    @new_post.stub!(:author).and_return(@bob)
+    @new_post.stub!(:author_id).and_return(@bob.id)
+
+    @new_post.stub!(:reviewer).and_return(@fred)
+    @new_post.stub!(:reviewer_id).and_return(@fred.id)
+
+    @new_post.should_receive(:publish_at=).any_number_of_times
+    @new_post.should_receive(:title=).any_number_of_times
+    @new_post.stub!(:main_post_id).and_return(nil)
+
+  end
+
+  def self.included(base)
+    base.class_eval do
+
+      attr_accessor :output_buffer
+
+      def protect_against_forgery?
+        false
+      end
+
+    end
+  end
+
+  def with_config(config_method_name, value, &block)
+    old_value = ::Formtastic::SemanticFormBuilder.send(config_method_name)
+    ::Formtastic::SemanticFormBuilder.send(:"#{config_method_name}=", value)
+    yield
+    ::Formtastic::SemanticFormBuilder.send(:"#{config_method_name}=", old_value)
+  end
+
+  def with_deprecation_silenced(&block)
+    ::ActiveSupport::Deprecation.silenced = true
+    yield
+    ::ActiveSupport::Deprecation.silenced = false
+  end
+
+end
+
+::ActiveSupport::Deprecation.silenced = false
+

data/spec/support/custom_macros.rb

@@ -0,0 +1,520 @@
+# encoding: utf-8
+
+module CustomMacros
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+
+    def it_should_have_input_wrapper_with_class(class_name)
+      it "should have input wrapper with class '#{class_name}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li.#{class_name}")
+      end
+    end
+
+    def it_should_have_input_wrapper_with_id(id_string)
+      it "should have input wrapper with id '#{id_string}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li##{id_string}")
+      end
+    end
+
+    def it_should_not_have_a_label
+      it "should not have a label" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should_not have_tag("form li label")
+      end
+    end
+
+    def it_should_have_a_nested_fieldset
+      it "should have a nested_fieldset" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li fieldset")
+      end
+    end
+
+    def it_should_have_label_with_text(string_or_regex)
+      it "should have a label with text '#{string_or_regex}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li label", string_or_regex)
+      end
+    end
+
+    def it_should_have_label_for(element_id)
+      it "should have a label for ##{element_id}" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li label[@for='#{element_id}']")
+      end
+    end
+
+    def it_should_have_input_with_id(element_id)
+      it "should have an input with id '#{element_id}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input##{element_id}")
+      end
+    end
+
+    def it_should_have_input_with_class(element_class)
+      it "should have an input with class '#{element_class}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input.#{element_class}")
+      end
+    end
+
+    def it_should_have_select_with_id(element_id)
+      it "should have a select box with id '#{element_id}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li select##{element_id}")
+      end
+    end
+
+    def it_should_have_input_with_type(input_type)
+      it "should have a #{input_type} input" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input[@type=\"#{input_type}\"]")
+      end
+    end
+
+    def it_should_have_input_with_name(name)
+      it "should have an input named #{name}" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input[@name=\"#{name}\"]")
+      end
+    end
+
+    def it_should_have_textarea_with_name(name)
+      it "should have an input named #{name}" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li textarea[@name=\"#{name}\"]")
+      end
+    end
+
+    def it_should_have_textarea_with_id(element_id)
+      it "should have an input with id '#{element_id}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li textarea##{element_id}")
+      end
+    end
+
+    def it_should_have_label_and_input_with_id(element_id)
+      it "should have an input with id '#{element_id}'" do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input##{element_id}")
+        output_buffer.should have_tag("form li label[@for='#{element_id}']")
+      end
+    end
+
+    def it_should_use_default_text_field_size_when_not_nil(as)
+      it 'should use default_text_field_size when not nil' do
+        with_config :default_text_field_size, 30 do
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:title, :as => as))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag("form li input[@size='#{Formtastic::SemanticFormBuilder.default_text_field_size}']")
+        end
+      end
+    end
+
+    def it_should_not_use_default_text_field_size_when_nil(as)
+      it 'should not use default_text_field_size when nil' do
+        with_config :default_text_field_size, nil do
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:title, :as => as))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag("form li input")
+          output_buffer.should_not have_tag("form li input[@size]")
+        end
+      end
+    end
+
+    def it_should_apply_custom_input_attributes_when_input_html_provided(as)
+      it 'it should apply custom input attributes when input_html provided' do
+        form = semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:title, :as => as, :input_html => { :class => 'myclass' }))
+        end
+        output_buffer.concat(form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input.myclass")
+      end
+    end
+
+    def it_should_apply_custom_for_to_label_when_input_html_id_provided(as)
+      it 'it should apply custom for to label when input_html :id provided' do
+        form = semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:title, :as => as, :input_html => { :id => 'myid' }))
+        end
+        output_buffer.concat(form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form li label[@for="myid"]')
+      end
+    end
+
+    def it_should_have_maxlength_matching_column_limit
+      it 'should have a maxlength matching column limit' do
+        @new_post.column_for_attribute(:title).limit.should == 50
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input[@maxlength='50']")
+      end
+    end
+
+    def it_should_use_column_size_for_columns_shorter_than_default_text_field_size(as)
+      it 'should use the column size for columns shorter than default_text_field_size' do
+        column_limit_shorted_than_default = 1
+        @new_post.stub!(:column_for_attribute).and_return(mock('column', :type => as, :limit => column_limit_shorted_than_default))
+
+        form = semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:title, :as => as))
+        end
+
+        output_buffer.concat(form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form li input[@size='#{column_limit_shorted_than_default}']")
+      end
+    end
+
+    def it_should_apply_error_logic_for_input_type(type)
+      describe 'when there are errors on the object for this method' do
+        before do
+          @title_errors = ['must not be blank', 'must be longer than 10 characters', 'must be awesome']
+          @errors = mock('errors')
+          @errors.stub!(:[]).with(:title).and_return(@title_errors)
+          ::Formtastic::SemanticFormBuilder.file_metadata_suffixes.each do |suffix|
+            @errors.stub!(:[]).with("title_#{suffix}".to_sym).and_return(nil)
+          end
+          @new_post.stub!(:errors).and_return(@errors)
+        end
+
+        it 'should apply an errors class to the list item' do
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:title, :as => type))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag('form li.error')
+        end
+
+        it 'should not wrap the input with the Rails default error wrapping' do
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:title, :as => type))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should_not have_tag('div.fieldWithErrors')
+        end
+
+        it 'should render a paragraph for the errors' do
+          ::Formtastic::SemanticFormBuilder.inline_errors = :sentence
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:title, :as => type))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag('form li.error p.inline-errors')
+        end
+
+        it 'should not display an error list' do
+          ::Formtastic::SemanticFormBuilder.inline_errors = :list
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:title, :as => type))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag('form li.error ul.errors')
+        end
+      end
+
+      describe 'when there are no errors on the object for this method' do
+        before do
+          @form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:title, :as => type))
+          end
+        end
+
+        it 'should not apply an errors class to the list item' do
+          output_buffer.concat(@form) if Formtastic::Util.rails3?
+          output_buffer.should_not have_tag('form li.error')
+        end
+
+        it 'should not render a paragraph for the errors' do
+          output_buffer.concat(@form) if Formtastic::Util.rails3?
+          output_buffer.should_not have_tag('form li.error p.inline-errors')
+        end
+
+        it 'should not display an error list' do
+          output_buffer.concat(@form) if Formtastic::Util.rails3?
+          output_buffer.should_not have_tag('form li.error ul.errors')
+        end
+      end
+
+      describe 'when no object is provided' do
+        before do
+          @form = semantic_form_for(:project, :url => 'http://test.host') do |builder|
+            concat(builder.input(:title, :as => type))
+          end
+        end
+
+        it 'should not apply an errors class to the list item' do
+          output_buffer.concat(@form) if Formtastic::Util.rails3?
+          output_buffer.should_not have_tag('form li.error')
+        end
+
+        it 'should not render a paragraph for the errors' do
+          output_buffer.concat(@form) if Formtastic::Util.rails3?
+          output_buffer.should_not have_tag('form li.error p.inline-errors')
+        end
+
+        it 'should not display an error list' do
+          output_buffer.concat(@form) if Formtastic::Util.rails3?
+          output_buffer.should_not have_tag('form li.error ul.errors')
+        end
+      end
+    end
+
+    def it_should_call_find_on_association_class_when_no_collection_is_provided(as)
+      it "should call find on the association class when no collection is provided" do
+        ::Author.should_receive(:all)
+        form = semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:author, :as => as))
+        end
+      end
+    end
+
+    def it_should_use_the_collection_when_provided(as, countable)
+      describe 'when the :collection option is provided' do
+
+        before do
+          @authors = ::Author.all * 2
+          output_buffer.replace '' # clears the output_buffer from the before block, hax!
+        end
+
+        it 'should use the provided collection' do
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.input(:author, :as => as, :collection => @authors))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag("form li.#{as} #{countable}", :count => @authors.size + (as == :select ? 1 : 0))
+        end
+
+        describe 'and the :collection is an array of strings' do
+          before do
+            @categories = [ 'General', 'Design', 'Development', 'Quasi-Serious Inventions' ]
+          end
+
+          it "should use the string as the label text and value for each #{countable}" do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:category_name, :as => as, :collection => @categories))
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+
+            @categories.each do |value|
+              output_buffer.should have_tag("form li.#{as}", /#{value}/)
+              output_buffer.should have_tag("form li.#{as} #{countable}[@value='#{value}']")
+            end
+          end
+
+          if as == :radio
+            it 'should generate a sanitized label for attribute' do
+              @bob.stub!(:category_name).and_return(@categories)
+              form = semantic_form_for(@new_post) do |builder|
+                fields = builder.semantic_fields_for(@bob) do |bob_builder|
+                  concat(bob_builder.input(:category_name, :as => as, :collection => @categories))
+                end
+                concat(fields)
+              end
+              output_buffer.concat(form) if Formtastic::Util.rails3?
+              output_buffer.should have_tag("form li fieldset ol li label[@for='post_author_category_name_general']")
+              output_buffer.should have_tag("form li fieldset ol li label[@for='post_author_category_name_design']")
+              output_buffer.should have_tag("form li fieldset ol li label[@for='post_author_category_name_development']")
+              output_buffer.should have_tag("form li fieldset ol li label[@for='post_author_category_name_quasiserious_inventions']")
+            end
+          end
+        end
+
+        describe 'and the :collection is a hash of strings' do
+          before do
+            @categories = { 'General' => 'gen', 'Design' => 'des','Development' => 'dev' }
+          end
+
+          it "should use the key as the label text and the hash value as the value attribute for each #{countable}" do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:category_name, :as => as, :collection => @categories))
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+
+            @categories.each do |label, value|
+              output_buffer.should have_tag("form li.#{as}", /#{label}/)
+              output_buffer.should have_tag("form li.#{as} #{countable}[@value='#{value}']")
+            end
+          end
+        end
+
+        describe 'and the :collection is an array of arrays' do
+          before do
+            @categories = { 'General' => 'gen', 'Design' => 'des', 'Development' => 'dev' }.to_a
+          end
+
+          it "should use the first value as the label text and the last value as the value attribute for #{countable}" do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:category_name, :as => as, :collection => @categories))
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+
+            @categories.each do |text, value|
+              label = as == :select ? :option : :label
+              output_buffer.should have_tag("form li.#{as} #{label}", /#{text}/i)
+              output_buffer.should have_tag("form li.#{as} #{countable}[@value='#{value.to_s}']")
+              output_buffer.should have_tag("form li.#{as} #{countable}#post_category_name_#{value.to_s}") if as == :radio
+            end
+          end
+        end
+
+        if as == :radio
+          describe 'and the :collection is an array of arrays with boolean values' do
+            before do
+              @choices = { 'Yeah' => true, 'Nah' => false }.to_a
+            end
+
+            it "should use the first value as the label text and the last value as the value attribute for #{countable}" do
+              form = semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:category_name, :as => as, :collection => @choices))
+              end
+              output_buffer.concat(form) if Formtastic::Util.rails3?
+
+              output_buffer.should have_tag("form li.#{as} #{countable}#post_category_name_true")
+              output_buffer.should have_tag("form li.#{as} #{countable}#post_category_name_false")
+            end
+          end
+        end
+
+        describe 'and the :collection is an array of symbols' do
+          before do
+            @categories = [ :General, :Design, :Development ]
+          end
+
+          it "should use the symbol as the label text and value for each #{countable}" do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:category_name, :as => as, :collection => @categories))
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+
+            @categories.each do |value|
+              label = as == :select ? :option : :label
+              output_buffer.should have_tag("form li.#{as} #{label}", /#{value}/i)
+              output_buffer.should have_tag("form li.#{as} #{countable}[@value='#{value.to_s}']")
+            end
+          end
+        end
+
+        describe 'and the :collection is an OrderedHash of strings' do
+          before do
+            @categories = ActiveSupport::OrderedHash.new('General' => 'gen', 'Design' => 'des','Development' => 'dev')
+          end
+
+          it "should use the key as the label text and the hash value as the value attribute for each #{countable}" do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:category_name, :as => as, :collection => @categories))
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+
+            @categories.each do |label, value|
+              output_buffer.should have_tag("form li.#{as}", /#{label}/)
+              output_buffer.should have_tag("form li.#{as} #{countable}[@value='#{value}']")
+            end
+          end
+
+        end
+
+        describe 'when the :label_method option is provided' do
+
+          describe 'as a symbol' do
+            before do
+              @form = semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:author, :as => as, :label_method => :login))
+              end
+            end
+
+            it 'should have options with text content from the specified method' do
+              output_buffer.concat(@form) if Formtastic::Util.rails3?
+              ::Author.all.each do |author|
+                output_buffer.should have_tag("form li.#{as}", /#{author.login}/)
+              end
+            end
+          end
+
+          describe 'as a proc' do
+            before do
+              @form  = semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:author, :as => as, :label_method => Proc.new {|a| a.login.reverse }))
+              end
+            end
+
+            it 'should have options with the proc applied to each' do
+              output_buffer.concat(@form) if Formtastic::Util.rails3?
+              ::Author.all.each do |author|
+                output_buffer.should have_tag("form li.#{as}", /#{author.login.reverse}/)
+              end
+            end
+          end
+
+        end
+
+        describe 'when the :label_method option is not provided' do
+          ::Formtastic::SemanticFormBuilder.collection_label_methods.each do |label_method|
+
+            describe "when the collection objects respond to #{label_method}" do
+              before do
+                @fred.stub!(:respond_to?).and_return { |m| m.to_s == label_method || m.to_s == 'id' }
+                ::Author.all.each { |a| a.stub!(label_method).and_return('The Label Text') }
+
+                @form = semantic_form_for(@new_post) do |builder|
+                  concat(builder.input(:author, :as => as))
+                end
+              end
+
+              it "should render the options with #{label_method} as the label" do
+                output_buffer.concat(@form) if Formtastic::Util.rails3?
+                ::Author.all.each do |author|
+                  output_buffer.should have_tag("form li.#{as}", /The Label Text/)
+                end
+              end
+            end
+
+          end
+        end
+
+        describe 'when the :value_method option is provided' do
+
+          describe 'as a symbol' do
+            before do
+              @form = semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:author, :as => as, :value_method => :login))
+              end
+            end
+
+            it 'should have options with values from specified method' do
+              output_buffer.concat(@form) if Formtastic::Util.rails3?
+              ::Author.all.each do |author|
+                output_buffer.should have_tag("form li.#{as} #{countable}[@value='#{author.login}']")
+              end
+            end
+          end
+
+          describe 'as a proc' do
+            before do
+              @form = semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:author, :as => as, :value_method => Proc.new {|a| a.login.reverse }))
+              end
+            end
+
+            it 'should have options with the proc applied to each value' do
+              output_buffer.concat(@form) if Formtastic::Util.rails3?
+              ::Author.all.each do |author|
+                output_buffer.should have_tag("form li.#{as} #{countable}[@value='#{author.login.reverse}']")
+              end
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/spec/support/output_buffer.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+module ActionView
+  class OutputBuffer < Formtastic::Util.rails_safe_buffer_class
+  end
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification 
+name: formtastic_datepicker_inputs
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Alan Harper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-30 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 3
+        - 7
+        version: 2.3.7
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 3
+        - 7
+        version: 2.3.7
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec-rails
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec_tag_matchers
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 8
+        - 3
+        version: 0.8.3
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: formtastic
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id009
+description: Use jQuery UI's date picker with formtastic easily
+email: alan@appfission.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/formtastic_datepicker_inputs.rb
+- MIT-LICENSE
+- README
+- Rakefile
+- init.rb
+- spec/support/output_buffer.rb
+- spec/support/custom_macros.rb
+- spec/spec_helper.rb
+- spec/formtastic_datepicker_inputs_spec.rb
+has_rdoc: true
+homepage: http://github.com/aussiegeek/formtastic_datepicker_inputs
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Use jQuery UI's date picker with formtastic easily
+test_files: 
+- spec/support/output_buffer.rb
+- spec/support/custom_macros.rb
+- spec/spec_helper.rb
+- spec/formtastic_datepicker_inputs_spec.rb