formtastic 3.0.0 → 5.0.0

data/spec/generators/formtastic/input/input_generator_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+require 'generators/formtastic/input/input_generator'
+
+RSpec.describe Formtastic::InputGenerator do
+  include FormtasticSpecHelper
+
+  destination File.expand_path("../../../../../tmp", __FILE__)
+
+  before do
+    prepare_destination
+  end
+
+  after do
+    FileUtils.rm_rf(File.expand_path("../../../../../tmp", __FILE__))
+  end
+
+  describe 'without file name' do
+    it 'should raise Thor::RequiredArgumentMissingError' do
+      expect { run_generator }.to raise_error(Thor::RequiredArgumentMissingError)
+    end
+  end
+
+  describe "input generator with underscore definition" do
+    before { run_generator %w(hat_size)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { is_expected.to exist}
+      it { is_expected.to contain "class HatSizeInput"}
+      it { is_expected.to contain "def to_html"}
+      it { is_expected.to contain "include Formtastic::Inputs::Base"}
+      it { is_expected.not_to contain "super"}
+    end
+  end
+
+  describe "input generator with camelcase definition" do
+    before { run_generator %w(HatSize)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { is_expected.to exist}
+      it { is_expected.to contain "class HatSizeInput"}
+    end
+  end
+
+  describe "input generator with camelcase Input name sufixed" do
+    before { run_generator %w(HatSizeInput)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { is_expected.to exist}
+      it { is_expected.to contain "class HatSizeInput"}
+    end
+  end
+
+  describe "input generator with underscore _input name sufixed" do
+    before { run_generator %w(hat_size_input)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { is_expected.to exist}
+      it { is_expected.to contain "class HatSizeInput"}
+    end
+  end
+
+  describe "input generator with underscore input name sufixed" do
+    before { run_generator %w(hat_sizeinput)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { is_expected.to exist}
+      it { is_expected.to contain "class HatSizeInput"}
+    end
+  end
+
+  describe "override an existing input using extend" do
+    before { run_generator %w(string --extend)}
+
+    describe 'app/inputs/string_input.rb' do
+      subject{ file('app/inputs/string_input.rb')}
+      it { is_expected.to exist }
+      it { is_expected.to contain "class StringInput < Formtastic::Inputs::StringInput" }
+      it { is_expected.to contain "def to_html" }
+      it { is_expected.not_to contain "include Formtastic::Inputs::Base" }
+      it { is_expected.to contain "super" }
+      it { is_expected.not_to contain "def input_html_options" }
+    end
+  end
+
+  describe "extend an existing input" do
+    before { run_generator %w(FlexibleText --extend string)}
+
+    describe 'app/inputs/flexible_text_input.rb' do
+      subject{ file('app/inputs/flexible_text_input.rb')}
+      it { is_expected.to contain "class FlexibleTextInput < Formtastic::Inputs::StringInput" }
+      it { is_expected.to contain "def input_html_options" }
+      it { is_expected.not_to contain "include Formtastic::Inputs::Base" }
+      it { is_expected.not_to contain "def to_html" }
+    end
+  end
+
+  describe "provide a slashed namespace" do
+    before { run_generator %w(stuff/foo)}
+
+    describe 'app/inputs/stuff/foo_input.rb' do
+      subject{ file('app/inputs/stuff/foo_input.rb')}
+      it {is_expected.to exist}
+      it { is_expected.to contain "class Stuff::FooInput" }
+      it { is_expected.to contain "include Formtastic::Inputs::Base" }
+    end
+  end
+
+  describe "provide a camelized namespace" do
+    before { run_generator %w(Stuff::Foo)}
+
+    describe 'app/inputs/stuff/foo_input.rb' do
+      subject{ file('app/inputs/stuff/foo_input.rb')}
+      it {is_expected.to exist}
+      it { is_expected.to contain "class Stuff::FooInput" }
+      it { is_expected.to contain "include Formtastic::Inputs::Base" }
+    end
+  end
+end

data/spec/generators/formtastic/install/install_generator_spec.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 # Generators are not automatically loaded by Rails
 require 'generators/formtastic/install/install_generator'
 
-describe Formtastic::InstallGenerator do
+RSpec.describe Formtastic::InstallGenerator do
   # Tell the generator where to put its output (what it thinks of as Rails.root)
   destination File.expand_path("../../../../../tmp", __FILE__)
 
@@ -14,14 +15,14 @@ describe Formtastic::InstallGenerator do
 
     describe 'config/initializers/formtastic.rb' do
       subject { file('config/initializers/formtastic.rb') }
-      it { should exist }
-      it { should contain "#" }
+      it { is_expected.to exist }
+      it { is_expected.to contain "#" }
     end
 
     describe 'lib/templates/erb/scaffold/_form.html.erb' do
       subject { file('lib/templates/erb/scaffold/_form.html.erb') }
-      it { should exist }
-      it { should contain "<%%= semantic_form_for @<%= singular_name %> do |f| %>" }
+      it { is_expected.to exist }
+      it { is_expected.to contain "<%%= semantic_form_for @<%= singular_name %> do |f| %>" }
     end
   end
 
@@ -30,8 +31,8 @@ describe Formtastic::InstallGenerator do
 
     describe 'lib/templates/erb/scaffold/_form.html.haml' do
       subject { file('lib/templates/haml/scaffold/_form.html.haml') }
-      it { should exist }
-      it { should contain "= semantic_form_for @<%= singular_name %> do |f|" }
+      it { is_expected.to exist }
+      it { is_expected.to contain "= semantic_form_for @<%= singular_name %> do |f|" }
     end
   end
 
@@ -40,8 +41,8 @@ describe Formtastic::InstallGenerator do
 
     describe 'lib/templates/erb/scaffold/_form.html.slim' do
       subject { file('lib/templates/slim/scaffold/_form.html.slim') }
-      it { should exist }
-      it { should contain "= semantic_form_for @<%= singular_name %> do |f|" }
+      it { is_expected.to exist }
+      it { is_expected.to contain "= semantic_form_for @<%= singular_name %> do |f|" }
     end
   end
 end

data/spec/helpers/action_helper_spec.rb

@@ -1,72 +1,62 @@
-# encoding: utf-8
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe 'Formtastic::FormBuilder#action' do
-
-  include FormtasticSpecHelper
-
-  before do
-    @output_buffer = ''
-    mock_everything
-  end
-
-  after do
-    ::I18n.backend.reload!
-  end
+RSpec.describe 'with action class finder' do
+  include_context 'form builder'
 
   describe 'arguments and options' do
 
     it 'should require the first argument (the action method)' do
-      lambda {
+      expect {
         concat(semantic_form_for(@new_post) do |builder|
           concat(builder.action()) # no args passed in at all
         end)
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     describe ':as option' do
-    
+
       describe 'when not provided' do
-    
+
         it 'should default to a commit for commit' do
           concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
             concat(builder.action(:submit))
           end)
-          output_buffer.should have_tag('form li.action.input_action', :count => 1)
+          expect(output_buffer.to_str).to have_tag('form li.action.input_action', :count => 1)
         end
-    
+
         it 'should default to a button for reset' do
           concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
             concat(builder.action(:reset))
           end)
-          output_buffer.should have_tag('form li.action.input_action', :count => 1)
+          expect(output_buffer.to_str).to have_tag('form li.action.input_action', :count => 1)
         end
 
         it 'should default to a link for cancel' do
           concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
             concat(builder.action(:cancel))
           end)
-          output_buffer.should have_tag('form li.action.link_action', :count => 1)
+          expect(output_buffer.to_str).to have_tag('form li.action.link_action', :count => 1)
         end
       end
-    
+
       it 'should call the corresponding action class with .to_html' do
         [:input, :button, :link].each do |action_style|
           semantic_form_for(:project, :url => "http://test.host") do |builder|
             action_instance = double('Action instance')
             action_class = "#{action_style.to_s}_action".classify
             action_constant = "Formtastic::Actions::#{action_class}".constantize
-    
-            action_constant.should_receive(:new).and_return(action_instance)
-            action_instance.should_receive(:to_html).and_return("some HTML")
-    
+
+            expect(action_constant).to receive(:new).and_return(action_instance)
+            expect(action_instance).to receive(:to_html).and_return("some HTML")
+
             concat(builder.action(:submit, :as => action_style))
           end
         end
       end
-    
+
     end
-    
+
     #describe ':label option' do
     #
     #  describe 'when provided' do
@@ -207,159 +197,142 @@ describe 'Formtastic::FormBuilder#action' do
     #end
     #
     describe ':wrapper_html option' do
-    
+
       describe 'when provided' do
         it 'should be passed down to the li tag' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:submit, :wrapper_html => {:id => :another_id}))
           end)
-          output_buffer.should have_tag("form li#another_id")
+          expect(output_buffer.to_str).to have_tag("form li#another_id")
         end
-    
+
         it 'should append given classes to li default classes' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:submit, :wrapper_html => {:class => :another_class}))
           end)
-          output_buffer.should have_tag("form li.action")
-          output_buffer.should have_tag("form li.input_action")
-          output_buffer.should have_tag("form li.another_class")
+          expect(output_buffer.to_str).to have_tag("form li.action")
+          expect(output_buffer.to_str).to have_tag("form li.input_action")
+          expect(output_buffer.to_str).to have_tag("form li.another_class")
         end
-    
+
         it 'should allow classes to be an array' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:submit, :wrapper_html => {:class => [ :my_class, :another_class ]}))
           end)
-          output_buffer.should have_tag("form li.action")
-          output_buffer.should have_tag("form li.input_action")
-          output_buffer.should have_tag("form li.my_class")
-          output_buffer.should have_tag("form li.another_class")
+          expect(output_buffer.to_str).to have_tag("form li.action")
+          expect(output_buffer.to_str).to have_tag("form li.input_action")
+          expect(output_buffer.to_str).to have_tag("form li.my_class")
+          expect(output_buffer.to_str).to have_tag("form li.another_class")
         end
       end
-    
+
       describe 'when not provided' do
         it 'should use default id and class' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:submit))
           end)
-          output_buffer.should have_tag("form li#post_submit_action")
-          output_buffer.should have_tag("form li.action")
-          output_buffer.should have_tag("form li.input_action")
+          expect(output_buffer.to_str).to have_tag("form li#post_submit_action")
+          expect(output_buffer.to_str).to have_tag("form li.action")
+          expect(output_buffer.to_str).to have_tag("form li.input_action")
         end
       end
-    
+
     end
-    
+
   end
 
   describe 'instantiating an action class' do
-  
     context 'when a class does not exist' do
       it "should raise an error" do
-        lambda {
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             builder.action(:submit, :as => :non_existant)
           end)
-        }.should raise_error(Formtastic::UnknownActionError)
+        }.to raise_error(Formtastic::UnknownActionError)
       end
     end
-  
+
     context 'when a customized top-level class does not exist' do
-  
       it 'should instantiate the Formtastic action' do
         action = double('action', :to_html => 'some HTML')
-        Formtastic::Actions::ButtonAction.should_receive(:new).and_return(action)
+        expect(Formtastic::Actions::ButtonAction).to receive(:new).and_return(action)
         concat(semantic_form_for(@new_post) do |builder|
           builder.action(:commit, :as => :button)
         end)
       end
-  
     end
-  
+
     describe 'when a top-level (custom) action class exists' do
       it "should instantiate the top-level action instead of the Formtastic one" do
         class ::ButtonAction < Formtastic::Actions::ButtonAction
         end
-  
+
         action = double('action', :to_html => 'some HTML')
-        Formtastic::Actions::ButtonAction.should_not_receive(:new)
-        ::ButtonAction.should_receive(:new).and_return(action)
-  
+        expect(Formtastic::Actions::ButtonAction).not_to receive(:new)
+        expect(::ButtonAction).to receive(:new).and_return(action)
+
         concat(semantic_form_for(@new_post) do |builder|
           builder.action(:commit, :as => :button)
         end)
       end
     end
-  
-    describe 'when instantiated multiple times with the same action type' do
-  
-      it "should be cached (not calling the internal methods)" do
-        # TODO this is really tied to the underlying implementation
-        concat(semantic_form_for(@new_post) do |builder|
-          builder.should_receive(:custom_action_class_name).with(:button).once.and_return(::Formtastic::Actions::ButtonAction)
-          builder.action(:submit, :as => :button)
-          builder.action(:submit, :as => :button)
-        end)
-      end
-  
-    end
-    
+
     describe 'support for :as on each action' do
-      
+
       it "should raise an error when the action does not support the :as" do
-        lambda {
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:submit, :as => :link))
           end)
-        }.should raise_error(Formtastic::UnsupportedMethodForAction)
-        
-        lambda {
+        }.to raise_error(Formtastic::UnsupportedMethodForAction)
+
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:cancel, :as => :input))
           end)
-        }.should raise_error(Formtastic::UnsupportedMethodForAction)
-        
-        lambda {
+        }.to raise_error(Formtastic::UnsupportedMethodForAction)
+
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:cancel, :as => :button))
           end)
-        }.should raise_error(Formtastic::UnsupportedMethodForAction)
+        }.to raise_error(Formtastic::UnsupportedMethodForAction)
       end
-      
+
       it "should not raise an error when the action does not support the :as" do
-        lambda {
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:cancel, :as => :link))
           end)
-        }.should_not raise_error
-        
-        lambda {
+        }.not_to raise_error
+
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:submit, :as => :input))
           end)
-        }.should_not raise_error
+        }.not_to raise_error
 
-        lambda {
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:submit, :as => :button))
           end)
-        }.should_not raise_error
-        
-        lambda {
+        }.not_to raise_error
+
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:reset, :as => :input))
           end)
-        }.should_not raise_error
-        
-        lambda {
+        }.not_to raise_error
+
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.action(:reset, :as => :button))
           end)
-        }.should_not raise_error
+        }.not_to raise_error
       end
-      
+
     end
-    
+
   end
 
 end
-

data/spec/helpers/actions_helper_spec.rb

@@ -1,12 +1,13 @@
 # encoding: utf-8
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe 'Formtastic::FormBuilder#actions' do
+RSpec.describe 'Formtastic::FormBuilder#actions' do
 
   include FormtasticSpecHelper
 
   before do
-    @output_buffer = ''
+    @output_buffer = ActionView::OutputBuffer.new ''
     mock_everything
   end
 
@@ -21,123 +22,123 @@ describe 'Formtastic::FormBuilder#actions' do
       end
 
       it 'should render a fieldset inside the form, with a class of "actions"' do
-        output_buffer.should have_tag("form fieldset.actions")
+        expect(output_buffer.to_str).to have_tag("form fieldset.actions")
       end
 
       it 'should render an ol inside the fieldset' do
-        output_buffer.should have_tag("form fieldset.actions ol")
+        expect(output_buffer.to_str).to have_tag("form fieldset.actions ol")
       end
 
       it 'should render the contents of the block inside the ol' do
-        output_buffer.should have_tag("form fieldset.actions ol", /hello/)
+        expect(output_buffer.to_str).to have_tag("form fieldset.actions ol", :text => /hello/)
       end
 
       it 'should not render a legend inside the fieldset' do
-        output_buffer.should_not have_tag("form fieldset.actions legend")
+        expect(output_buffer.to_str).not_to have_tag("form fieldset.actions legend")
       end
     end
 
     describe 'when a :name option is provided' do
       before do
         @legend_text = "Advanced options"
-    
+
         concat(semantic_form_for(@new_post) do |builder|
           builder.actions :name => @legend_text do
           end
         end)
       end
       it 'should render a fieldset inside the form' do
-        output_buffer.should have_tag("form fieldset.actions legend", /#{@legend_text}/)
+        expect(output_buffer.to_str).to have_tag("form fieldset.actions legend", :text => /#{@legend_text}/)
       end
     end
-    
+
     describe 'when other options are provided' do
       before do
         @id_option = 'advanced'
         @class_option = 'wide'
-    
+
         concat(semantic_form_for(@new_post) do |builder|
           builder.actions :id => @id_option, :class => @class_option do
           end
         end)
       end
       it 'should pass the options into the fieldset tag as attributes' do
-        output_buffer.should have_tag("form fieldset##{@id_option}")
-        output_buffer.should have_tag("form fieldset.#{@class_option}")
+        expect(output_buffer.to_str).to have_tag("form fieldset##{@id_option}")
+        expect(output_buffer.to_str).to have_tag("form fieldset.#{@class_option}")
       end
     end
-    
+
   end
 
   describe 'without a block' do
-  
+
     describe 'with no args (default buttons)' do
-  
+
       before do
         concat(semantic_form_for(@new_post) do |builder|
           concat(builder.actions)
         end)
       end
-  
+
       it 'should render a form' do
-        output_buffer.should have_tag('form')
+        expect(output_buffer.to_str).to have_tag('form')
       end
-  
+
       it 'should render an actions fieldset inside the form' do
-        output_buffer.should have_tag('form fieldset.actions')
+        expect(output_buffer.to_str).to have_tag('form fieldset.actions')
       end
-  
+
       it 'should not render a legend in the fieldset' do
-        output_buffer.should_not have_tag('form fieldset.actions legend')
+        expect(output_buffer.to_str).not_to have_tag('form fieldset.actions legend')
       end
-  
+
       it 'should render an ol in the fieldset' do
-        output_buffer.should have_tag('form fieldset.actions ol')
+        expect(output_buffer.to_str).to have_tag('form fieldset.actions ol')
       end
-  
+
       it 'should render a list item in the ol for each default action' do
-        output_buffer.should have_tag('form fieldset.actions ol li.action.input_action', :count => 1)
+        expect(output_buffer.to_str).to have_tag('form fieldset.actions ol li.action.input_action', :count => 1)
       end
-  
+
     end
-  
+
     describe 'with button names as args' do
-    
+
       before do
         concat(semantic_form_for(@new_post) do |builder|
           concat(builder.actions(:submit, :cancel, :reset))
         end)
       end
-    
+
       it 'should render a form with a fieldset containing a list item for each button arg' do
-        output_buffer.should have_tag('form > fieldset.actions > ol > li.action', :count => 3)
+        expect(output_buffer.to_str).to have_tag('form > fieldset.actions > ol > li.action', :count => 3)
       end
-    
+
     end
-  
+
     describe 'with button names as args and an options hash' do
-    
+
      before do
        concat(semantic_form_for(@new_post) do |builder|
          concat(builder.actions(:submit, :cancel, :reset, :name => "Now click a button", :id => "my-id"))
        end)
      end
-    
+
      it 'should render a form with a fieldset containing a list item for each button arg' do
-       output_buffer.should have_tag('form > fieldset.actions > ol > li.action', :count => 3)
+       expect(output_buffer.to_str).to have_tag('form > fieldset.actions > ol > li.action', :count => 3)
      end
-    
+
      it 'should pass the options down to the fieldset' do
-       output_buffer.should have_tag('form > fieldset#my-id.actions')
+       expect(output_buffer.to_str).to have_tag('form > fieldset#my-id.actions')
      end
-    
+
      it 'should use the special :name option as a text for the legend tag' do
-       output_buffer.should have_tag('form > fieldset#my-id.actions > legend', /Now click a button/)
+       expect(output_buffer.to_str).to have_tag('form > fieldset#my-id.actions > legend', :text => /Now click a button/)
      end
-    
+
     end
-  
+
   end
-  
+
 end