mega-safe-tool 0.0.1

data/formtastic-6.0.0/spec/helpers/reflection_helper_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe 'Formtastic::Helpers::Reflection' do
+
+  include FormtasticSpecHelper
+
+  before do
+    @output_buffer = ActionView::OutputBuffer.new ''
+    mock_everything
+  end
+
+  class ReflectionTester
+    include Formtastic::Helpers::Reflection
+    def initialize(model_object)
+      @object = model_object
+    end
+  end
+
+  context 'with an ActiveRecord object' do
+    it "should return association details on an ActiveRecord association" do
+      @reflection_tester = ReflectionTester.new(@new_post)
+      expect(@reflection_tester.reflection_for(:sub_posts)).not_to be_nil
+    end
+    it "should return association details on a MongoMapper association" do
+      @reflection_tester = ReflectionTester.new(@new_mm_post)
+      expect(@reflection_tester.reflection_for(:sub_posts)).not_to be_nil
+    end
+  end
+
+
+end

data/formtastic-6.0.0/spec/helpers/semantic_errors_helper_spec.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe 'Formtastic::FormBuilder#semantic_errors' do
+
+  include FormtasticSpecHelper
+
+  before do
+    @output_buffer = ActionView::OutputBuffer.new ''
+    mock_everything
+    @title_errors = ['must not be blank', 'must be awesome']
+    @base_errors = ['base error message', 'nasty error']
+    @base_error = ['one base error']
+    @errors = double('errors')
+    allow(@new_post).to receive(:errors).and_return(@errors)
+  end
+
+  describe 'when there is only one error on base' do
+    before do
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
+    end
+
+    it 'should render an unordered list' do
+      semantic_form_for(@new_post) do |builder|
+        expect(builder.semantic_errors).to have_tag('ul.errors li', text: 'one base error')
+      end
+    end
+  end
+
+  describe 'when there is more than one error on base' do
+    before do
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_errors)
+    end
+
+    it 'should render an unordered list' do
+      semantic_form_for(@new_post) do |builder|
+        expect(builder.semantic_errors).to have_tag('ul.errors')
+        @base_errors.each do |error|
+          expect(builder.semantic_errors).to have_tag('ul.errors li', :text => error)
+        end
+      end
+    end
+  end
+
+  describe 'when there are errors on title' do
+    before do
+      allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return(@title_errors)
+      allow(@errors).to receive(:[]).with(errors_matcher(: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)
+        expect(builder.semantic_errors(:title)).to have_tag('ul.errors li', :text => title_name << " " << @title_errors.to_sentence)
+      end
+    end
+  end
+
+  describe 'when there are errors on title and base' do
+    before do
+      allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return(@title_errors)
+      allow(@errors).to receive(:[]).with(errors_matcher(: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)
+        expect(builder.semantic_errors(:title)).to have_tag('ul.errors li', :text => title_name << " " << @title_errors.to_sentence)
+        expect(builder.semantic_errors(:title)).to have_tag('ul.errors li', text: 'one base error')
+      end
+    end
+  end
+
+  describe 'when there are no errors' do
+    before do
+      allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return([])
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return([])
+    end
+
+    it 'should return nil' do
+      semantic_form_for(@new_post) do |builder|
+        expect(builder.semantic_errors(:title)).to be_nil
+      end
+    end
+  end
+
+  describe 'when there is one error on base and options with class is passed' do
+    before do
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
+    end
+
+    it 'should render an unordered list with given class' do
+      semantic_form_for(@new_post) do |builder|
+        expect(builder.semantic_errors(:class => "awesome")).to have_tag('ul.awesome li', text: 'one base error')
+      end
+    end
+  end
+
+  describe 'when :base is passed in as an argument' do
+    before do
+      allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
+    end
+
+    it 'should ignore :base and only render base errors once' do
+      semantic_form_for(@new_post) do |builder|
+        expect(builder.semantic_errors(:base)).to have_tag('ul li', :count => 1)
+        expect(builder.semantic_errors(:base)).not_to have_tag('ul li', :text => "Base #{@base_error}")
+      end
+    end
+  end
+
+  context 'when configure FormBuilder.semantic_errors_link_to_inputs is true' do
+    before do
+      Formtastic::FormBuilder.semantic_errors_link_to_inputs = true
+    end
+
+    after do
+      Formtastic::FormBuilder.semantic_errors_link_to_inputs = false
+    end
+
+
+    describe 'when there is only one error on base' do
+      before do
+        allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      end
+
+      it 'should render an unordered list' do
+        semantic_form_for(@new_post) do |builder|
+          expect(builder.semantic_errors).to have_tag('ul.errors li', text: 'one base error')
+        end
+      end
+    end
+
+    describe 'when there is more than one error on base' do
+      before do
+        allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_errors)
+      end
+
+      it 'should render an unordered list' do
+        semantic_form_for(@new_post) do |builder|
+          expect(builder.semantic_errors).to have_tag('ul.errors')
+          @base_errors.each do |error|
+            expect(builder.semantic_errors).to have_tag('ul.errors li', :text => error)
+          end
+        end
+      end
+    end
+
+    describe 'when there are errors on title' do
+      before do
+        allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return(@title_errors)
+        allow(@errors).to receive(:[]).with(errors_matcher(: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)
+          expect(builder.semantic_errors(:title)).to have_tag('ul.errors li a', :text => title_name << " " << @title_errors.to_sentence)
+        end
+      end
+    end
+
+    describe 'when there are errors on title and base' do
+      before do
+        allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return(@title_errors)
+        allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      end
+
+      it 'should render an unordered list where base has no link, and title error attribute links to title input field' do
+        semantic_form_for(@new_post) do |builder|
+          title_name = builder.send(:localized_string, :title, :title, :label) || builder.send(:humanized_attribute_name, :title)
+          expect(builder.semantic_errors(:title)).to \
+            have_tag('ul.errors li a',
+              with: { href: "##{@new_post.model_name}_title" },
+              text: title_name << " " << @title_errors.to_sentence
+            )
+          expect(builder.semantic_errors(:title)).to have_tag('ul.errors li', text: 'one base error')
+        end
+      end
+    end
+
+    describe 'when there are no errors' do
+      before do
+        allow(@errors).to receive(:[]).with(errors_matcher(:title)).and_return([])
+        allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return([])
+      end
+
+      it 'should return nil' do
+        semantic_form_for(@new_post) do |builder|
+          expect(builder.semantic_errors(:title)).to be_nil
+        end
+      end
+    end
+
+    describe 'when there is one error on base and options with class is passed' do
+      before do
+        allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      end
+
+      it 'should render an unordered list with given class' do
+        semantic_form_for(@new_post) do |builder|
+          expect(builder.semantic_errors(class: "awesome")).to have_tag('ul.awesome li', text: 'one base error')
+        end
+      end
+    end
+
+    describe 'when :base is passed in as an argument' do
+      before do
+        allow(@errors).to receive(:[]).with(errors_matcher(:base)).and_return(@base_error)
+      end
+
+      it 'should ignore :base and only render base errors once' do
+        semantic_form_for(@new_post) do |builder|
+          expect(builder.semantic_errors(:base)).to have_tag('ul li', count: 1)
+          expect(builder.semantic_errors(:base)).not_to have_tag('ul li', text: "Base #{@base_error}")
+        end
+      end
+    end
+  end # context 'when semantic_errors_link_to_inputs is true'
+end

data/formtastic-6.0.0/spec/i18n_spec.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+RSpec.describe 'Formtastic::I18n' do
+
+  FORMTASTIC_KEYS = [:required, :yes, :no, :create, :update].freeze
+
+  it "should be defined" do
+    expect { Formtastic::I18n }.not_to raise_error
+  end
+
+  describe "default translations" do
+    it "should be defined" do
+      expect { Formtastic::I18n::DEFAULT_VALUES }.not_to raise_error
+      expect(Formtastic::I18n::DEFAULT_VALUES.is_a?(::Hash)).to eq(true)
+    end
+
+    it "should exists for the core I18n lookup keys" do
+      expect((Formtastic::I18n::DEFAULT_VALUES.keys & FORMTASTIC_KEYS).size).to eq(FORMTASTIC_KEYS.size)
+    end
+  end
+
+  describe "when I18n locales are available" do
+
+    before do
+      @formtastic_strings = {
+          :yes            => 'Default Yes',
+          :no             => 'Default No',
+          :create         => 'Default Create %{model}',
+          :update         => 'Default Update %{model}',
+          :custom_scope   => {
+              :duck           => 'Duck',
+              :duck_pond      => '%{ducks} ducks in a pond'
+            }
+        }
+      ::I18n.backend.store_translations :en, :formtastic => @formtastic_strings
+    end
+
+    after do
+      ::I18n.backend.reload!
+    end
+
+    it "should translate core strings correctly" do
+      ::I18n.backend.store_translations :en, {:formtastic => {:required => 'Default Required'}}
+      expect(Formtastic::I18n.t(:required)).to  eq("Default Required")
+      expect(Formtastic::I18n.t(:yes)).to       eq("Default Yes")
+      expect(Formtastic::I18n.t(:no)).to        eq("Default No")
+      expect(Formtastic::I18n.t(:create, :model => 'Post')).to eq("Default Create Post")
+      expect(Formtastic::I18n.t(:update, :model => 'Post')).to eq("Default Update Post")
+    end
+
+    it "should all belong to scope 'formtastic'" do
+      expect(Formtastic::I18n.t(:duck, :scope => [:custom_scope])).to eq('Duck')
+    end
+
+    it "should override default I18n lookup args if these are specified" do
+      expect(Formtastic::I18n.t(:duck_pond, :scope => [:custom_scope], :ducks => 15)).to eq('15 ducks in a pond')
+    end
+
+    it "should be possible to override default values" do
+      expect(Formtastic::I18n.t(:required, :default => 'Nothing found!')).to eq('Nothing found!')
+    end
+
+  end
+
+  describe "when no I18n locales are available" do
+
+    before do
+      ::I18n.backend.reload!
+    end
+
+    it "should use default strings" do
+      (Formtastic::I18n::DEFAULT_VALUES.keys).each do |key|
+        expect(Formtastic::I18n.t(key, :model => '%{model}')).to eq(Formtastic::I18n::DEFAULT_VALUES[key])
+      end
+    end
+
+  end
+
+  describe "I18n string lookups" do
+
+    include FormtasticSpecHelper
+
+    before do
+      @output_buffer = ActionView::OutputBuffer.new ''
+      mock_everything
+
+      ::I18n.backend.store_translations :en, {:formtastic => {
+          :labels => {
+              :author   => { :name => "Top author name translation" },
+              :post     => {:title => "Hello post!", :author => {:name => "Hello author name!"}},
+              :project  => {:title => "Hello project!"},
+            }
+        }, :helpers => {
+          :label => {
+            :post => {:body => "Elaborate..." },
+            :author => { :login => "Hello login" }
+          }
+        }}
+
+      allow(@new_post).to receive(:title)
+      allow(@new_post).to receive(:column_for_attribute).with(:title).and_return(double('column', :type => :string, :limit => 255))
+    end
+
+    after do
+      ::I18n.backend.reload!
+    end
+
+    it "lookup scopes should be defined" do
+      with_config :i18n_lookups_by_default, true do
+        expect { Formtastic::I18n::SCOPES }.not_to raise_error
+      end
+    end
+
+    it "should be able to translate with namespaced object" do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:title))
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Hello post!/)
+      end
+    end
+
+    it "should be able to translate without form-object" do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
+          concat(builder.input(:title))
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Hello project!/)
+      end
+    end
+
+    it "should be able to translate when method name is same as model" do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
+          concat(builder.input(:author))
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Author/)
+      end
+    end
+
+    it 'should be able to translate nested objects with nested translations' do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          concat(builder.semantic_fields_for(:author) do |f|
+            concat(f.input(:name))
+          end)
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Hello author name!/)
+      end
+    end
+
+    it 'should be able to translate nested objects with top level translations' do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          builder.semantic_fields_for(:author) do |f|
+            concat(f.input(:name))
+          end
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Hello author name!/)
+      end
+    end
+
+    it 'should be able to translate nested objects with nested object translations' do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          builder.semantic_fields_for(:project) do |f|
+            concat(f.input(:title))
+          end
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Hello project!/)
+      end
+    end
+
+    it 'should be able to translate nested forms with top level translations' do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(:post) do |builder|
+          builder.semantic_fields_for(:author) do |f|
+            concat(f.input(:name))
+          end
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Hello author name!/)
+      end
+    end
+
+    it 'should be able to translate helper label as Rails does' do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:body))
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Elaborate/)
+      end
+    end
+
+    it 'should be able to translate nested helper label as Rails does' do
+      with_config :i18n_lookups_by_default, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          concat(builder.inputs(:for => :author) do |f|
+            concat(f.input(:login))
+          end)
+        end)
+        expect(output_buffer.to_str).to have_tag("form label", :text => /Hello login/)
+      end
+    end
+
+    # TODO: Add spec for namespaced models?
+
+  end
+
+end

data/formtastic-6.0.0/spec/input_class_finder_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'formtastic/input_class_finder'
+
+RSpec.describe Formtastic::InputClassFinder do
+  it_behaves_like 'Specialized Class Finder' do
+    let(:default) { Formtastic::Inputs }
+    let(:namespaces_setting) { :input_namespaces }
+  end
+end

data/formtastic-6.0.0/spec/inputs/base/collections_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+require 'fast_spec_helper'
+require 'inputs/base/collections'
+
+class MyInput
+  include Formtastic::Inputs::Base::Collections
+end
+
+RSpec.describe MyInput do
+  let(:builder) { double }
+  let(:template) { double }
+  let(:model_class) { double }
+  let(:model) { double(:class => model_class) }
+  let(:model_name) { "post" }
+  let(:method) { double }
+  let(:options) { Hash.new }
+  
+  let(:instance) { MyInput.new(builder, template, model, model_name, method, options) }
+
+  # class Whatever < ActiveRecord::Base
+  #   enum :status => [:active, :archived]
+  # end
+  #
+  # Whatever.statuses
+  #
+  # Whatever.new.status
+  #
+  # f.input :status
+  describe "#collection_from_enum" do
+    
+    let(:method) { :status }
+
+    context "when an enum is defined for the method" do
+      before do
+        statuses = ActiveSupport::HashWithIndifferentAccess.new("active"=>0, "inactive"=>1)
+        allow(model_class).to receive(:statuses) { statuses }
+        allow(model).to receive(:defined_enums) { {"status" => statuses } }
+        allow(model).to receive(:model_name).and_return(double(i18n_key: model_name))
+      end
+
+      context 'no translations available' do
+        it 'returns an Array of EnumOption objects based on the enum options hash' do
+          expect(instance.collection_from_enum).to eq [["Active", "active"],["Inactive", "inactive"]]
+        end
+      end
+
+      context 'with translations' do
+        before do
+          ::I18n.backend.store_translations :en, :activerecord => {
+            :attributes => {
+              :post => {
+                :statuses => {
+                  :active => "I am active",
+                  :inactive => "I am inactive"
+                }
+              }
+            }
+          }
+        end
+        it 'returns an Array of EnumOption objects based on the enum options hash' do
+          expect(instance.collection_from_enum).to eq [["I am active", "active"],["I am inactive", "inactive"]]
+        end
+
+        after do
+          ::I18n.backend.store_translations :en, {}
+        end
+      end
+    end
+
+    context "when an enum is not defined" do
+      it 'returns nil' do
+        expect(instance.collection_from_enum).to eq nil
+      end
+    end
+  end
+
+  describe '#collection' do
+    context 'when the raw collection is a string' do
+      it 'returns the string' do
+        allow(instance).to receive(:raw_collection).and_return("one_status_only")
+        expect(instance.collection).to eq "one_status_only"
+      end
+    end
+
+    context 'when the raw collection is an array of strings' do
+      it 'returns the array of symbols' do
+        allow(instance).to receive(:raw_collection).and_return(["active", "inactive", "pending"])
+        expect(instance.collection).to be_an(Array)
+        expect(instance.collection).to eq ["active", "inactive", "pending"]
+      end
+    end
+
+    context 'when the raw collection is an array of arrays' do
+      it 'returns the array of arrays' do
+        allow(instance).to receive(:raw_collection).and_return([["inactive", "0"], ["active", "1"], ["pending", "2"]])
+        expect(instance.collection).to be_an(Array)
+        expect(instance.collection).to eq [["inactive", "0"], ["active", "1"], ["pending", "2"]]
+      end
+    end
+
+    context 'when the raw collection is an array of symbols' do
+      it 'returns the array of symbols' do
+        allow(instance).to receive(:raw_collection).and_return([:active, :inactive, :pending])
+        expect(instance.collection).to be_an(Array)
+        expect(instance.collection).to eq [:active, :inactive, :pending]
+      end
+    end
+
+    context 'when the raw collection is a hash' do
+      it 'will be mapped into array form' do
+        allow(instance).to receive(:raw_collection).and_return({ inactive: 0, active: 1, pending: 2 })
+        expect(instance.collection).to be_an(Array)
+        expect(instance.collection).to eq [[:inactive, 0], [:active, 1], [:pending, 2]]
+      end
+    end
+  end
+
+end
+