formtastic 1.1.0 → 1.2.0.beta

data/spec/label_spec.rb

@@ -1,89 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe 'SemanticFormBuilder#label' do
-
-  include FormtasticSpecHelper
-  
-  before do
-    @output_buffer = ''
-    mock_everything
-  end
-
-  it 'should humanize the given attribute' do
-    semantic_form_for(@new_post) do |builder|
-      builder.label(:login).should have_tag('label', :with => /Login/)
-    end
-  end
-
-  describe 'when required is given' do
-    it 'should append a required note' do
-      semantic_form_for(@new_post) do |builder|
-        builder.label(:login, nil, :required => true).should have_tag('label abbr')
-      end
-    end
-
-    it 'should allow require option to be given as second argument' do
-      semantic_form_for(@new_post) do |builder|
-        builder.label(:login, :required => true).should have_tag('label abbr')
-      end
-    end
-  end
-
-  describe 'when a collection is given' do
-    it 'should use a supplied label_method for simple collections' do
-      form = semantic_form_for(:project, :url => 'http://test.host') do |builder|
-        concat(builder.input(:author_id, :as => :check_boxes, :collection => [:a, :b, :c], :value_method => :to_s, :label_method => proc {|f| ('Label_%s' % [f])}))
-      end
-      output_buffer.concat(form) if Formtastic::Util.rails3?
-      output_buffer.should have_tag('form li fieldset ol li label', :with => /Label_[abc]/, :count => 3)
-    end
-
-    it 'should use a supplied value_method for simple collections' do
-      form = semantic_form_for(:project, :url => 'http://test.host') do |builder|
-        concat(builder.input(:author_id, :as => :check_boxes, :collection => [:a, :b, :c], :value_method => proc {|f| ('Value_%s' % [f.to_s])}))
-      end
-      output_buffer.concat(form) if Formtastic::Util.rails3?
-      output_buffer.should have_tag('form li fieldset ol li label input[value="Value_a"]')
-      output_buffer.should have_tag('form li fieldset ol li label input[value="Value_b"]')
-      output_buffer.should have_tag('form li fieldset ol li label input[value="Value_c"]')
-    end
-  end
-
-  describe 'when label is given' do
-    it 'should allow the text to be given as label option' do
-      semantic_form_for(@new_post) do |builder|
-        builder.label(:login, :required => true, :label => 'My label').should have_tag('label', :with => /My label/)
-      end
-    end
-
-    it 'should return nil if label is false' do
-      semantic_form_for(@new_post) do |builder|
-        builder.label(:login, :label => false).should be_blank
-      end
-    end
-
-    it 'should html escape the label string by default' do
-      semantic_form_for(@new_post) do |builder|
-        builder.label(:login, :required => false, :label => '<b>My label</b>').should == "<label for=\"post_login\">&lt;b&gt;My label&lt;/b&gt;</label>"
-      end
-    end
-
-    it 'should not html escape the label if configured that way' do
-      ::Formtastic::SemanticFormBuilder.escape_html_entities_in_hints_and_labels = false
-      semantic_form_for(@new_post) do |builder|
-        builder.label(:login, :required => false, :label => '<b>My label</b>').should == "<label for=\"post_login\"><b>My label</b></label>"
-      end
-    end
-
-    it 'should not html escape the label string for html_safe strings' do
-      ::Formtastic::SemanticFormBuilder.escape_html_entities_in_hints_and_labels = true
-      semantic_form_for(@new_post) do |builder|
-        builder.label(:login, :required => false, :label => '<b>My label</b>'.html_safe).should == "<label for=\"post_login\"><b>My label</b></label>"
-      end
-    end
-
-  end
-  
-end
-

data/spec/semantic_errors_spec.rb

@@ -1,98 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe 'SemanticFormBuilder#semantic_errors' do
-
-  include FormtasticSpecHelper
-
-  before do
-    @output_buffer = ''
-    mock_everything
-    @title_errors = ['must not be blank', 'must be awesome']
-    @base_errors = ['base error message', 'nasty error']
-    @base_error = 'one base error'
-    @errors = mock('errors')
-    @new_post.stub!(:errors).and_return(@errors)
-  end
-
-  describe 'when there is only one error on base' do
-    before do
-      @errors.stub!(:[]).with(:base).and_return(@base_error)
-    end
-
-    it 'should render an unordered list' do
-      semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors.should have_tag('ul.errors li', @base_error)
-      end
-    end
-  end
-
-  describe 'when there is more than one error on base' do
-    before do
-      @errors.stub!(:[]).with(:base).and_return(@base_errors)
-    end
-
-    it 'should render an unordered list' do
-      semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors.should have_tag('ul.errors')
-        @base_errors.each do |error|
-          builder.semantic_errors.should have_tag('ul.errors li', error)
-        end
-      end
-    end
-  end
-
-  describe 'when there are errors on title' do
-    before do
-      @errors.stub!(:[]).with(:title).and_return(@title_errors)
-      @errors.stub!(:[]).with(:base).and_return([])
-    end
-
-    it 'should render an unordered list' do
-      semantic_form_for(@new_post) do |builder|
-        title_name = builder.send(:localized_string, :title, :title, :label) || builder.send(:humanized_attribute_name, :title)
-        builder.semantic_errors(:title).should have_tag('ul.errors li', title_name << " " << @title_errors.to_sentence)
-      end
-    end
-  end
-
-  describe 'when there are errors on title and base' do
-    before do
-      @errors.stub!(:[]).with(:title).and_return(@title_errors)
-      @errors.stub!(:[]).with(:base).and_return(@base_error)
-    end
-
-    it 'should render an unordered list' do
-      semantic_form_for(@new_post) do |builder|
-        title_name = builder.send(:localized_string, :title, :title, :label) || builder.send(:humanized_attribute_name, :title)
-        builder.semantic_errors(:title).should have_tag('ul.errors li', title_name << " " << @title_errors.to_sentence)
-        builder.semantic_errors(:title).should have_tag('ul.errors li', @base_error)
-      end
-    end
-  end
-
-  describe 'when there are no errors' do
-    before do
-      @errors.stub!(:[]).with(:title).and_return(nil)
-      @errors.stub!(:[]).with(:base).and_return(nil)
-    end
-
-    it 'should return nil' do
-      semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors(:title).should be_nil
-      end
-    end
-  end
-
-  describe 'when there is one error on base and options with class is passed' do
-    before do
-      @errors.stub!(:[]).with(:base).and_return(@base_error)
-    end
-
-    it 'should render an unordered list with given class' do
-      semantic_form_for(@new_post) do |builder|
-        builder.semantic_errors(:class => "awesome").should have_tag('ul.awesome li', @base_error)
-      end
-    end
-  end
-end

data/spec/semantic_fields_for_spec.rb

@@ -1,45 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-
-describe 'SemanticFormBuilder#semantic_fields_for' do
-
-  include FormtasticSpecHelper
-  
-  before do
-    @output_buffer = ''
-    mock_everything
-    @new_post.stub!(:author).and_return(::Author.new)
-  end
-
-  it 'yields an instance of SemanticFormHelper.builder' do  
-    semantic_form_for(@new_post) do |builder|
-      builder.semantic_fields_for(:author) do |nested_builder|
-        nested_builder.class.should == ::Formtastic::SemanticFormHelper.builder
-      end
-    end
-  end
-  
-  it 'nests the object name' do
-    semantic_form_for(@new_post) do |builder|
-      builder.semantic_fields_for(@bob) do |nested_builder|
-        nested_builder.object_name.should == 'post[author]'
-      end
-    end
-  end
-  
-  it 'should sanitize html id for li tag' do
-    @bob.stub!(:column_for_attribute).and_return(mock('column', :type => :string, :limit => 255))
-    form = semantic_form_for(@new_post) do |builder|
-      concat(builder.semantic_fields_for(@bob, :index => 1) do |nested_builder|
-        concat(nested_builder.inputs(:login))
-      end)
-    end
-    output_buffer.concat(form) if Formtastic::Util.rails3?
-    output_buffer.should have_tag('form fieldset.inputs #post_author_1_login_input')
-    # Not valid selector, so using good ol' regex
-    output_buffer.should_not =~ /id="post\[author\]_1_login_input"/
-    # <=> output_buffer.should_not have_tag('form fieldset.inputs #post[author]_1_login_input')
-  end
-
-end
-

data/spec/spec.opts

@@ -1,2 +0,0 @@
---color
---format=progress

data/spec/spec_helper.rb

@@ -1,289 +0,0 @@
-# coding: utf-8
-require 'rubygems'
-require 'active_support'
-require 'action_pack'
-require 'action_view'
-require 'action_controller'
-require 'action_mailer'
-
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic/util'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic/layout_helper'))
-
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories in alphabetic order.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each {|f| require f}
-
-module FormtasticSpecHelper
-  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_presence_validator(attributes, options = {})
-    presence_validator = mock('ActiveModel::Validations::PresenceValidator', :attributes => attributes, :options => options)
-    presence_validator.stub!(:kind).and_return(:presence)
-    presence_validator
-  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 = mock('user')
-    @fred.stub!(:to_ary)
-    @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 = mock('user')
-    @bob.stub!(:to_ary)
-    @bob.stub!(:class).and_return(::Author)
-    @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 = mock('user')
-    @james.stub!(:to_ary)
-    @james.stub!(:class).and_return(::Author)
-    @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!(:to_ary)
-    ::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!(:to_ary)
-    @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!(: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)
-    
-    @new_post.stub!(:title)
-    @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!(:time_zone)
-    @new_post.stub!(:category_name)
-    @new_post.stub!(:allow_comments)
-    @new_post.stub!(:country)
-    @new_post.stub!(:country_subdivision)
-    @new_post.stub!(:country_code)
-    @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))
-    @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!(: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