techthumb-formtastic 1.rails3.sha

data/lib/generators/formtastic/form/form_generator.rb

@@ -0,0 +1,86 @@
+# coding: utf-8
+module Formtastic
+  class FormGenerator < Rails::Generators::NamedBase
+    desc "Generates formtastic form code based on an existing model. By default the " <<
+         "generated code will be printed out directly in the terminal, and also copied " <<
+         "to clipboard. Can optionally be saved into partial directly."
+
+    argument :name, :type => :string, :required => true, :banner => 'ExistingModelName'
+    argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
+
+    class_option :haml, :type => :boolean, :default => false, :group => :formtastic,
+                 :desc => "Generate HAML instead of ERB"
+
+    class_option :partial, :type => :boolean, :default => false, :group => :formtastic,
+                 :desc => 'Generate a form partial in the model views path, i.e. "_form.html.erb" or "_form.html.haml"'
+
+    class_option :controller, :type => :string, :default => false, :group => :formtastic,
+                 :desc => 'Generate for custom controller/view path - in case model and controller namespace is different, i.e. "admin/posts"'
+
+    def self.source_root
+     # Set source directory for the templates to the rails2 generator template directory
+     @source_root ||= File.expand_path(File.join('..', '..', '..', '..', 'generators', 'form', 'templates'), File.dirname(__FILE__))
+    end
+
+    def create_or_show
+      @attributes = self.columns if @attributes.empty?
+      if options[:partial]
+        empty_directory "app/views/#{controller_path}"
+        template "view__form.html.#{template_type}", "app/views/#{controller_path}/_form.html.#{template_type}"
+      else
+        template = File.read("#{self.class.source_root}/view__form.html.#{template_type}")
+        erb = ERB.new(template, nil, '-')
+        generated_code = erb.result(binding).strip rescue nil
+
+        puts "# ---------------------------------------------------------"
+        puts "#  GENERATED FORMTASTIC CODE"
+        puts "# ---------------------------------------------------------"
+        puts
+        puts generated_code || "Nothing could be generated - model exists?"
+        puts
+        puts "# ---------------------------------------------------------"
+        puts "Copied to clipboard - just paste it!" if save_to_clipboard(generated_code)
+      end
+    end
+
+    protected
+
+    IGNORED_COLUMNS = [:updated_at, :created_at].freeze
+
+    def template_type
+      @template_type ||= options[:haml] ? :haml : :erb
+    end
+
+    def controller_path
+      @controller_path ||= if options[:controller]
+        options[:controller].underscore
+      else
+        name.underscore.pluralize
+      end
+    end
+
+    def columns
+      @columns ||= self.name.camelize.constantize.content_columns.reject { |column| IGNORED_COLUMNS.include?(column.name.to_sym) }
+    end
+
+    def save_to_clipboard(data)
+      return unless data
+
+      begin
+        case RUBY_PLATFORM
+        when /win32/
+          require 'win32/clipboard'
+          ::Win32::Clipboard.data = data
+        when /darwin/ # mac
+          `echo "#{data}" | pbcopy`
+        else # linux/unix
+          `echo "#{data}" | xsel --clipboard` || `echo "#{data}" | xclip`
+        end
+      rescue LoadError
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/generators/formtastic/install/install_generator.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+module Formtastic
+  class InstallGenerator < Rails::Generators::Base
+    desc "Copies formtastic.css and formtastic_changes.css to public/stylesheets/ and a config initializer to config/initializers/formtastic_config.rb"
+
+    def self.source_root
+      # Set source directory for the templates to the rails2 generator template directory
+      @source_root ||= File.expand_path(File.join('..', '..', '..', '..', 'generators', 'formtastic', 'templates'), File.dirname(__FILE__))
+    end
+    
+    def self.banner
+      "rails generate formtastic:install [options]"
+    end
+
+    def copy_files
+      empty_directory 'config/initializers'
+      template        'formtastic.rb', 'config/initializers/formtastic.rb'
+
+      empty_directory 'public/stylesheets'
+      template        'formtastic.css',         'public/stylesheets/formtastic.css'
+      template        'formtastic_changes.css', 'public/stylesheets/formtastic_changes.css'
+    end
+  end
+end

data/lib/locale/en.yml

@@ -0,0 +1,8 @@
+en:
+  formtastic:
+    :yes: 'Yes'
+    :no: 'No'
+    create: 'Create'
+    save: 'Save'
+    submit: 'Submit'
+    required: 'Required'

data/rails/init.rb

@@ -0,0 +1,2 @@
+# coding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "init"))

data/spec/buttons_spec.rb

@@ -0,0 +1,166 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe 'SemanticFormBuilder#buttons' do
+
+  include FormtasticSpecHelper
+  
+  before do
+    @output_buffer = ''
+    mock_everything
+  end
+
+  describe 'with a block' do
+    describe 'when no options are provided' do
+      before do
+        @form = semantic_form_for(@new_post) do |builder|
+          buttons = builder.buttons do
+            concat('hello')
+          end
+          concat(buttons)
+        end
+      end
+
+      it 'should render a fieldset inside the form, with a class of "inputs"' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form fieldset.buttons")
+      end
+
+      it 'should render an ol inside the fieldset' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form fieldset.buttons ol")
+      end
+
+      it 'should render the contents of the block inside the ol' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form fieldset.buttons ol", /hello/)
+      end
+
+      it 'should not render a legend inside the fieldset' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should_not have_tag("form fieldset.buttons legend")
+      end
+    end
+
+    describe 'when a :name option is provided' do
+      before do
+        @legend_text = "Advanced options"
+
+        @form = semantic_form_for(@new_post) do |builder|
+          builder.buttons :name => @legend_text do
+          end
+        end
+      end
+      it 'should render a fieldset inside the form' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form fieldset legend", /#{@legend_text}/)
+      end
+    end
+
+    describe 'when other options are provided' do
+      before do
+        @id_option = 'advanced'
+        @class_option = 'wide'
+
+        @form = semantic_form_for(@new_post) do |builder|
+          builder.buttons :id => @id_option, :class => @class_option do
+          end
+        end
+      end
+      it 'should pass the options into the fieldset tag as attributes' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag("form fieldset##{@id_option}")
+        output_buffer.should have_tag("form fieldset.#{@class_option}")
+      end
+    end
+
+  end
+
+  describe 'without a block' do
+
+    describe 'with no args (default buttons)' do
+
+      before do
+        @form = semantic_form_for(@new_post) do |builder|
+          concat(builder.buttons)
+        end
+      end
+
+      it 'should render a form' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form')
+      end
+
+      it 'should render a buttons fieldset inside the form' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form fieldset.buttons')
+      end
+
+      it 'should not render a legend in the fieldset' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should_not have_tag('form fieldset.buttons legend')
+      end
+
+      it 'should render an ol in the fieldset' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form fieldset.buttons ol')
+      end
+
+      it 'should render a list item in the ol for each default button' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form fieldset.buttons ol li', :count => 1)
+      end
+
+      it 'should render a commit list item for the commit button' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form fieldset.buttons ol li.commit')
+      end
+
+    end
+
+    describe 'with button names as args' do
+
+      before do
+        @form = semantic_form_for(@new_post) do |builder|
+          concat(builder.buttons(:commit))
+        end
+      end
+
+      it 'should render a form with a fieldset containing a list item for each button arg' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form > fieldset.buttons > ol > li', :count => 1)
+        output_buffer.should have_tag('form > fieldset.buttons > ol > li.commit')
+      end
+
+    end
+
+    describe 'with button names as args and an options hash' do
+
+      before do
+        @form = semantic_form_for(@new_post) do |builder|
+          concat(builder.buttons(:commit, :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.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form > fieldset.buttons > ol > li', :count => 1)
+        output_buffer.should have_tag('form > fieldset.buttons > ol > li.commit', :count => 1)
+      end
+
+      it 'should pass the options down to the fieldset' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form > fieldset#my-id.buttons')
+      end
+
+      it 'should use the special :name option as a text for the legend tag' do
+        output_buffer.concat(@form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('form > fieldset#my-id.buttons > legend', /Now click a button/)
+      end
+
+    end
+
+  end
+
+end
+

data/spec/commit_button_spec.rb

@@ -0,0 +1,401 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe 'SemanticFormBuilder#commit_button' do
+
+  include FormtasticSpecHelper
+  
+  before do
+    @output_buffer = ''
+    mock_everything
+  end
+
+  describe 'when used on any record' do
+
+    before do
+      @new_post.stub!(:new_record?).and_return(false)
+      @form = semantic_form_for(@new_post) do |builder|
+        concat(builder.commit_button)
+      end
+    end
+
+    it 'should render a commit li' do
+      output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li.commit')
+    end
+
+    it 'should render an input with a type attribute of "submit"' do
+      output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li.commit input[@type="submit"]')
+    end
+
+    it 'should render an input with a name attribute of "commit"' do
+      output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li.commit input[@name="commit"]')
+    end
+
+    it 'should pass options given in :button_html to the button' do
+      @new_post.stub!(:new_record?).and_return(false)
+      form = semantic_form_for(@new_post) do |builder|
+        concat(builder.commit_button('text', :button_html => {:class => 'my_class', :id => 'my_id'}))
+      end
+
+      output_buffer.concat(form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li.commit input#my_id')
+      output_buffer.should have_tag('li.commit input.my_class')
+    end
+    
+  end
+
+  describe "its accesskey" do
+  
+    it 'should allow nil default' do
+      with_config :default_commit_button_accesskey, nil do
+        output_buffer.should_not have_tag('li.commit input[@accesskey]')
+      end
+    end
+
+    it 'should use the default if set' do
+      with_config :default_commit_button_accesskey, 's' do
+        @new_post.stub!(:new_record?).and_return(false)
+        form = semantic_form_for(@new_post) do |builder|
+          concat(builder.commit_button('text', :button_html => {}))
+        end
+        output_buffer.concat(form) if Formtastic::Util.rails3?
+        output_buffer.should have_tag('li.commit input[@accesskey="s"]')
+      end
+    end
+
+    it 'should use the value set in options over the default' do
+      with_config :default_commit_button_accesskey, 's' do
+        @new_post.stub!(:new_record?).and_return(false)
+        form = semantic_form_for(@new_post) do |builder|
+          concat(builder.commit_button('text', :accesskey => 'o'))
+        end
+        output_buffer.concat(form) if Formtastic::Util.rails3?
+        output_buffer.should_not have_tag('li.commit input[@accesskey="s"]')
+        output_buffer.should have_tag('li.commit input[@accesskey="o"]')
+      end
+    end
+
+    it 'should use the value set in button_html over options' do
+      with_config :default_commit_button_accesskey, 's' do
+        @new_post.stub!(:new_record?).and_return(false)
+        form = semantic_form_for(@new_post) do |builder|
+          concat(builder.commit_button('text', :accesskey => 'o', :button_html => {:accesskey => 't'}))
+        end
+        output_buffer.concat(form) if Formtastic::Util.rails3?
+        output_buffer.should_not have_tag('li.commit input[@accesskey="s"]')
+        output_buffer.should_not have_tag('li.commit input[@accesskey="o"]')
+        output_buffer.should have_tag('li.commit input[@accesskey="t"]')
+      end
+    end
+
+  end
+
+  describe 'when the first option is a string and the second is a hash' do
+    
+    before do
+      @new_post.stub!(:new_record?).and_return(false)
+      @form = semantic_form_for(@new_post) do |builder|
+        concat(builder.commit_button("a string", :button_html => { :class => "pretty"}))
+      end
+    end
+    
+    it "should render the string as the value of the button" do
+      output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li input[@value="a string"]')
+    end
+    
+    it "should deal with the options hash" do
+      output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li input.pretty')
+    end
+    
+  end
+
+  describe 'when the first option is a hash' do
+
+    before do
+      @new_post.stub!(:new_record?).and_return(false)
+      @form = semantic_form_for(@new_post) do |builder|
+        concat(builder.commit_button(:button_html => { :class => "pretty"}))
+      end
+    end
+    
+    it "should deal with the options hash" do
+      output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li input.pretty')
+    end
+    
+  end
+
+  describe 'label' do
+
+    # No object
+    describe 'when used without object' do
+      describe 'when explicit label is provided' do
+        it 'should render an input with the explicitly specified label' do
+          form = semantic_form_for(:post, :url => 'http://example.com') do |builder|
+            concat(builder.commit_button("Click!"))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag('li.commit input[@value="Click!"][@class~="submit"]')
+        end
+      end
+
+      describe 'when no explicit label is provided' do
+        describe 'when no I18n-localized label is provided' do
+          before do
+            ::I18n.backend.store_translations :en, :formtastic => {:submit => 'Submit %{model}'}
+          end
+          
+          after do
+            ::I18n.backend.reload!
+          end
+          
+          it 'should render an input with default I18n-localized label (fallback)' do
+            form = semantic_form_for(:post, :url => 'http://example.com') do |builder|
+              concat(builder.commit_button)
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+            output_buffer.should have_tag('li.commit input[@value="Submit Post"][@class~="submit"]')
+          end
+        end
+
+       describe 'when I18n-localized label is provided' do
+         before do
+           ::I18n.backend.store_translations :en,
+             :formtastic => {
+                 :actions => {
+                   :submit => 'Custom Submit',
+                  }
+               }
+           ::Formtastic::SemanticFormBuilder.i18n_lookups_by_default = true
+         end
+
+         after do
+           ::I18n.backend.reload!
+         end
+
+         it 'should render an input with localized label (I18n)' do
+           ::I18n.backend.store_translations :en,
+             :formtastic => {
+                 :actions => {
+                   :post => {
+                     :submit => 'Custom Submit %{model}'
+                    }
+                  }
+               }
+           form = semantic_form_for(:post, :url => 'http://example.com') do |builder|
+             concat(builder.commit_button)
+           end
+           output_buffer.concat(form) if Formtastic::Util.rails3?
+           output_buffer.should have_tag(%Q{li.commit input[@value="Custom Submit Post"][@class~="submit"]})
+         end
+
+         it 'should render an input with anoptional localized label (I18n) - if first is not set' do
+           form = semantic_form_for(:post, :url => 'http://example.com') do |builder|
+             concat(builder.commit_button)
+           end
+           output_buffer.concat(form) if Formtastic::Util.rails3?
+           output_buffer.should have_tag(%Q{li.commit input[@value="Custom Submit"][@class~="submit"]})
+         end
+
+       end
+      end
+    end
+
+    # New record
+    describe 'when used on a new record' do
+      before do
+        @new_post.stub!(:new_record?).and_return(true)
+      end
+
+      describe 'when explicit label is provided' do
+        it 'should render an input with the explicitly specified label' do
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.commit_button("Click!"))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag('li.commit input[@value="Click!"][@class~="create"]')
+        end
+      end
+
+      describe 'when no explicit label is provided' do
+        describe 'when no I18n-localized label is provided' do
+          before do
+            ::I18n.backend.store_translations :en, :formtastic => {:create => 'Create %{model}'}
+          end
+
+          after do
+            ::I18n.backend.reload!
+          end
+
+          it 'should render an input with default I18n-localized label (fallback)' do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.commit_button)
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+            output_buffer.should have_tag('li.commit input[@value="Create Post"][@class~="create"]')
+          end
+        end
+
+        describe 'when I18n-localized label is provided' do
+          before do
+            ::I18n.backend.store_translations :en,
+              :formtastic => {
+                  :actions => {
+                    :create => 'Custom Create',
+                   }
+                }
+            ::Formtastic::SemanticFormBuilder.i18n_lookups_by_default = true
+          end
+          
+          after do
+            ::I18n.backend.reload!
+          end
+
+          it 'should render an input with localized label (I18n)' do
+            ::I18n.backend.store_translations :en,
+              :formtastic => {
+                  :actions => {
+                    :post => {
+                      :create => 'Custom Create %{model}'
+                     }
+                   }
+                }
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.commit_button)
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+            output_buffer.should have_tag(%Q{li.commit input[@value="Custom Create Post"][@class~="create"]})
+          end
+
+          it 'should render an input with anoptional localized label (I18n) - if first is not set' do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.commit_button)
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+            output_buffer.should have_tag(%Q{li.commit input[@value="Custom Create"][@class~="create"]})
+          end
+
+        end
+      end
+    end
+
+    # Existing record
+    describe 'when used on an existing record' do
+      before do
+        @new_post.stub!(:new_record?).and_return(false)
+      end
+
+      describe 'when explicit label is provided' do
+        it 'should render an input with the explicitly specified label' do
+          form = semantic_form_for(@new_post) do |builder|
+            concat(builder.commit_button("Click!"))
+          end
+          output_buffer.concat(form) if Formtastic::Util.rails3?
+          output_buffer.should have_tag('li.commit input[@value="Click!"][@class~="update"]')
+        end
+      end
+
+      describe 'when no explicit label is provided' do
+        describe 'when no I18n-localized label is provided' do
+          before do
+            ::I18n.backend.store_translations :en, :formtastic => {:update => 'Save %{model}'}
+          end
+          
+          after do
+            ::I18n.backend.reload!
+          end
+
+          it 'should render an input with default I18n-localized label (fallback)' do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.commit_button)
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+            output_buffer.should have_tag('li.commit input[@value="Save Post"][@class~="update"]')
+          end
+        end
+
+        describe 'when I18n-localized label is provided' do
+          before do
+            ::I18n.backend.reload!
+            ::I18n.backend.store_translations :en,
+              :formtastic => {
+                  :actions => {
+                    :update => 'Custom Save',
+                   }
+                }
+            ::Formtastic::SemanticFormBuilder.i18n_lookups_by_default = true
+          end
+
+          after do
+            ::I18n.backend.reload!
+          end
+          
+          it 'should render an input with localized label (I18n)' do
+            ::I18n.backend.store_translations :en,
+              :formtastic => {
+                  :actions => {
+                    :post => {
+                      :update => 'Custom Save %{model}'
+                     }
+                   }
+                }
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.commit_button)
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+            output_buffer.should have_tag(%Q{li.commit input[@value="Custom Save Post"][@class~="update"]})
+          end
+
+          it 'should render an input with anoptional localized label (I18n) - if first is not set' do
+            form = semantic_form_for(@new_post) do |builder|
+              concat(builder.commit_button)
+            end
+            output_buffer.concat(form) if Formtastic::Util.rails3?
+            output_buffer.should have_tag(%Q{li.commit input[@value="Custom Save"][@class~="update"]})
+            ::I18n.backend.store_translations :en, :formtastic => {}
+          end
+
+        end
+      end
+    end
+  end
+  
+  describe 'when the model is two words' do
+    before do
+      output_buffer = ''
+      class ::UserPost
+        extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+        include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+        def id
+        end
+        
+        def persisted?
+        end
+        
+        # Rails does crappy human_name
+        def self.human_name
+          "User post"
+        end
+      end
+      @new_user_post = ::UserPost.new
+      
+      @new_user_post.stub!(:new_record?).and_return(true)
+      @form = semantic_form_for(@new_user_post, :url => '') do |builder|
+        concat(builder.commit_button())
+      end
+    end
+    
+    it "should render the string as the value of the button" do
+      output_buffer.concat(@form) if Formtastic::Util.rails3?
+      output_buffer.should have_tag('li input[@value="Create User post"]')
+    end
+    
+  end
+    
+end