active_scaffold 3.4.17 → 3.4.18

data/test/misc/attribute_params_test.rb

@@ -41,7 +41,7 @@ class AttributeParamsTest < MiniTest::Test
 
   def test_saving_has_many_select
     buildings = 2.times.map { Building.create }
-    model = update_record_from_params(Person.new, :create, :first_name, :last_name, :buildings, :first_name => 'First', :last_name => '', :buildings => ['', *buildings.map{|b| b.id.to_s}]) # checkbox_list always add a hidden tag with empty value
+    model = update_record_from_params(Person.new, :create, :first_name, :last_name, :buildings, :first_name => 'First', :last_name => '', :buildings => ['', *buildings.map { |b| b.id.to_s }]) # checkbox_list always add a hidden tag with empty value
     assert_equal 'First', model.first_name
     assert_nil model.last_name
     assert_equal buildings.map(&:id), model.building_ids
@@ -52,7 +52,7 @@ class AttributeParamsTest < MiniTest::Test
     model = update_record_from_params(model, :update, :first_name, :last_name, :buildings, :first_name => 'Name', :last_name => 'Last', :buildings => ['']) { raise ActiveRecord::Rollback }
     assert_equal 'Name', model.first_name
     assert_equal 'Last', model.last_name
-    assert_equal [model.id]*2, buildings.map{|b| b.reload.owner_id}, 'owners should not be saved'
+    assert_equal [model.id] * 2, buildings.map { |b| b.reload.owner_id }, 'owners should not be saved'
     assert model.building_ids.blank?, 'buildings should be cleared'
     assert model.buildings.blank?, 'buildings should be cleared'
     assert_equal 0, model.buildings.size
@@ -63,7 +63,7 @@ class AttributeParamsTest < MiniTest::Test
     assert_equal 'Last', model.last_name
     assert model.building_ids.blank?, 'buildings should be cleared'
     assert model.buildings.blank?, 'buildings should be cleared'
-    assert_equal [nil]*2, buildings.map{|b| b.reload.owner_id}, 'buildings should be saved'
+    assert_equal [nil] * 2, buildings.map { |b| b.reload.owner_id }, 'buildings should be saved'
     assert model.save
     assert_equal 0, model.reload.buildings_count
   end
@@ -182,23 +182,23 @@ class AttributeParamsTest < MiniTest::Test
     people = 2.times.map { Person.create }
     assert people.all?(&:persisted?)
 
-    model = update_record_from_params(Building.new, :create, :name, :tenants, :name => 'Tower', :tenants => ['', *people.map{|b| b.id.to_s}]) # checkbox_list always add a hidden tag with empty value
+    model = update_record_from_params(Building.new, :create, :name, :tenants, :name => 'Tower', :tenants => ['', *people.map { |b| b.id.to_s }]) # checkbox_list always add a hidden tag with empty value
     assert_equal 'Tower', model.name
     assert model.tenants.present?
-    assert_equal [nil]*2, people.map {|p| p.floor(true)}, 'floor should not be saved yet'
+    assert_equal [nil] * 2, people.map { |p| p.floor(true) }, 'floor should not be saved yet'
     assert model.save
-    assert_equal [model.id]*2, model.floors.map(&:building_id)
-    assert_equal [model.id]*2, people.map {|p| p.floor(true).building_id}, 'floor should be saved'
+    assert_equal [model.id] * 2, model.floors.map(&:building_id)
+    assert_equal [model.id] * 2, people.map { |p| p.floor(true).building_id }, 'floor should be saved'
 
     model = update_record_from_params(model, :update, :name, :tenants, :name => 'Skyscrapper', :tenants => ['']) { raise ActiveRecord::Rollback }
     assert_equal 'Skyscrapper', model.name
-    assert_equal [model.id]*2, people.map {|p| p.floor(true).building_id}, 'previous floor should not be deleted'
+    assert_equal [model.id] * 2, people.map { |p| p.floor(true).building_id }, 'previous floor should not be deleted'
     assert model.tenants.empty?, 'tenants should be cleared'
 
     model.reload
     model = update_record_from_params(model, :update, :name, :tenants, :name => 'Skyscrapper', :tenants => [''])
     assert_equal 'Skyscrapper', model.name
-    assert_equal [nil]*2, people.map {|p| p.floor(true)}, 'previous floor should be deleted'
+    assert_equal [nil] * 2, people.map { |p| p.floor(true) }, 'previous floor should be deleted'
     assert model.tenants.empty?, 'tenants should be cleared'
     assert model.save
   end
@@ -346,7 +346,7 @@ class AttributeParamsTest < MiniTest::Test
 
   def test_saving_has_many_polymorphic_select
     contacts = 2.times.map { Contact.create }
-    
+
     model = update_record_from_params(Person.new, :create, :first_name, :contacts, :first_name => 'Me', :contacts => ['', contacts.first.id.to_s])
     assert_equal 'Me', model.first_name
     assert model.contacts.present?
@@ -354,48 +354,49 @@ class AttributeParamsTest < MiniTest::Test
     assert_equal [model.id], model.contacts.map(&:contactable_id)
     assert_equal model.id, contacts.first.reload.contactable.id, 'contactable should be saved'
     assert_equal 1, model.reload.contacts_count
-    
-    model = update_record_from_params(model, :update, :first_name, :contacts, :first_name => 'Name', :contacts => ['', *contacts.map{|c| c.id.to_s}])
+
+    model = update_record_from_params(model, :update, :first_name, :contacts, :first_name => 'Name', :contacts => ['', *contacts.map { |c| c.id.to_s }])
     assert_equal 'Name', model.first_name
     assert model.contacts.present?
     assert model.save
-    assert_equal [model.id]*2, model.contacts.map(&:contactable_id)
-    assert_equal [model.id]*2, contacts.map {|c| c.reload.contactable.id}, 'contactable should be saved'
+    assert_equal [model.id] * 2, model.contacts.map(&:contactable_id)
+    assert_equal [model.id] * 2, contacts.map { |c| c.reload.contactable.id }, 'contactable should be saved'
     assert_equal 2, model.reload.contacts_count
-    
+
     model = update_record_from_params(model, :update, :first_name, :contacts, :first_name => 'Name', :contacts => [''])
     assert_equal 'Name', model.first_name
     assert model.contacts.empty?
     assert model.save
-    assert_equal [nil]*2, contacts.map {|c| c.reload.contactable}, 'contactable should be saved'
+    assert_equal [nil] * 2, contacts.map { |c| c.reload.contactable }, 'contactable should be saved'
     assert_equal 0, model.reload.contacts_count
   end
 
   def test_saving_habtm_select
     roles = 2.times.map { Role.create }
-    
+
     model = update_record_from_params(Person.new, :create, :first_name, :roles, :first_name => 'Me', :roles => ['', roles.first.id.to_s])
     assert_equal 'Me', model.first_name
     assert model.roles.present?
     assert model.save
     assert_equal [[model.id]], model.roles.map(&:person_ids)
     assert_equal [model.id], roles.first.reload.person_ids, 'role should be saved'
-    
-    model = update_record_from_params(model, :update, :first_name, :roles, :first_name => 'Name', :roles => ['', *roles.map{|c| c.id.to_s}])
+
+    model = update_record_from_params(model, :update, :first_name, :roles, :first_name => 'Name', :roles => ['', *roles.map { |c| c.id.to_s }])
     assert_equal 'Name', model.first_name
     assert model.roles.present?
     assert model.save
-    assert_equal [[model.id]]*2, model.roles.map(&:person_ids)
-    assert_equal [[model.id]]*2, roles.map {|r| r.reload.person_ids}, 'roles should be saved'
-    
+    assert_equal [[model.id]] * 2, model.roles.map(&:person_ids)
+    assert_equal [[model.id]] * 2, roles.map { |r| r.reload.person_ids }, 'roles should be saved'
+
     model = update_record_from_params(model, :update, :first_name, :roles, :first_name => 'Name', :roles => [''])
     assert_equal 'Name', model.first_name
     assert model.roles.empty?
     assert model.save
-    assert roles.all? {|r| r.reload.people.empty?}, 'roles should be saved'
+    assert roles.all? { |r| r.reload.people.empty? }, 'roles should be saved'
   end
 
   protected
+
   def update_record_from_params(record, action, *columns, &block)
     params = columns.extract_options!.with_indifferent_access
     new_record = nil
@@ -416,9 +417,9 @@ class AttributeParamsTest < MiniTest::Test
 end
 
 class Controller
-  def self.helper_method(*args); end
-  def self.before_filter(*args); end
-  
+  def self.helper_method(*); end
+  def self.before_filter(*); end
+
   include ActiveScaffold::Core
   include ActiveScaffold::Helpers::ControllerHelpers
   include ActiveScaffold::AttributeParams
@@ -427,6 +428,7 @@ class Controller
   def logger
     @logger ||= Logger.new(STDOUT)
   end
+
   def flash
     @flash ||= ActionDispatch::Flash::FlashHash.new
   end

data/test/misc/calculation_test.rb

@@ -3,31 +3,38 @@ require 'test_helper'
 class ClassWithFinder
   include ActiveScaffold::Finder
   def conditions_for_collection; end
+
   def conditions_from_params; end
+
   def conditions_from_constraints; end
+
   def joins_for_collection; end
+
   def custom_finder_options
     {}
   end
+
   def beginning_of_chain
     active_scaffold_config.model
   end
+
   def conditional_get_support?; end
+
   def params; {}; end
 end
 
 class CalculationTest < MiniTest::Test
   def setup
     @buildings = []
-    @buildings << Building.create {|b| b.create_owner(:first_name => 'foo')}
+    @buildings << Building.create { |b| b.create_owner(:first_name => 'foo') }
     @buildings << Building.create(:name => 'foo bar')
     @buildings << Building.create
-    
+
     @klass = ClassWithFinder.new
     @klass.stubs(:active_scaffold_config).returns(mock { stubs(:model).returns(Building) })
     @klass.stubs(:active_scaffold_session_storage).returns({})
   end
-  
+
   def teardown
     @buildings.each(&:destroy).map(&:owner).compact.each(&:destroy)
   end

data/test/misc/configurable_test.rb

@@ -40,20 +40,19 @@ class ConfigurableTest < MiniTest::Test
     ## test normal block behaviors
     ##
     # functions
-    assert_equal hello, configurable_class.configure {hello}
+    assert_equal hello, configurable_class.configure { hello }
     # variables
-    assert_equal configurable_class, configurable_class.configure {configurable_class}
+    assert_equal configurable_class, configurable_class.configure { configurable_class }
     # constants
-    assert_equal ConfigurableTest::HELLO, configurable_class.configure {ConfigurableTest::HELLO}
+    assert_equal ConfigurableTest::HELLO, configurable_class.configure { ConfigurableTest::HELLO }
 
     ##
     ## test extra "localized" block behavior
     ##
     # functions
-    assert_equal configurable_class.foo, configurable_class.configure {foo}
+    assert_equal configurable_class.foo, configurable_class.configure { foo }
     # constants - not working
-#    assert_equal configurable_class.FOO, configurable_class.configure {FOO}
-
+    #    assert_equal configurable_class.FOO, configurable_class.configure {FOO}
   end
 
   def test_class_configuration
@@ -73,25 +72,25 @@ class ConfigurableTest < MiniTest::Test
     ## test normal block behaviors
     ##
     # functions
-    assert_equal hello, ExtendedClass.configure {hello}
+    assert_equal hello, ExtendedClass.configure { hello }
     # variables
-    assert_equal ExtendedClass, ExtendedClass.configure {ExtendedClass}
+    assert_equal ExtendedClass, ExtendedClass.configure { ExtendedClass }
     # constants
-    assert_equal ConfigurableTest::HELLO, ExtendedClass.configure {ConfigurableTest::HELLO}
+    assert_equal ConfigurableTest::HELLO, ExtendedClass.configure { ConfigurableTest::HELLO }
 
     ##
     ## test extra "localized" block behavior
     ##
     # functions
-    assert_equal ExtendedClass.foo, ExtendedClass.configure {foo}
+    assert_equal ExtendedClass.foo, ExtendedClass.configure { foo }
     # constants - not working
-#    assert_equal ExtendedClass.FOO, ExtendedClass.configure {FOO}
+    #    assert_equal ExtendedClass.FOO, ExtendedClass.configure {FOO}
   end
 
   def test_arity
     # this is the main style
-    assert_equal 'foo', ExtendedClass.configure {'foo'}
+    assert_equal 'foo', ExtendedClass.configure { 'foo' }
     # but we want to let people accept the configurable class as the first argument, too
-    assert_equal 'bar', ExtendedClass.configure {|a| a.foo}
+    assert_equal 'bar', ExtendedClass.configure { |a| a.foo } # rubocop:disable Style/SymbolProc
   end
 end

data/test/misc/constraints_test.rb

@@ -2,9 +2,9 @@ require 'test_helper'
 
 module ModelStubs
   class ModelStub < ActiveRecord::Base
-    abstract_class = true
+    self.abstract_class = true
     def self.columns; @columns ||= [ColumnMock.new('foo', '')] end
-    def self.columns_hash; @hash ||= Hash[@columns.map{|c| [c.name, c]}] end
+    def self.columns_hash; @hash ||= Hash[@columns.map { |c| [c.name, c] }] end
     def self.table_name
       @table_name || to_s.split('::').last.underscore.pluralize
     end
@@ -83,7 +83,7 @@ end
 
 class ConstraintsTestObject
   # stub out what the mixin expects to find ...
-  def self.before_filter(*args); end
+  def self.before_filter(*); end
   def self.helper_method(*); end
   attr_accessor :active_scaffold_preload
   attr_accessor :active_scaffold_references
@@ -123,7 +123,7 @@ class ConstraintsTest < MiniTest::Test
     assert_constraint_condition({:address => 11}, [{'addresses.id' => 11}], 'find the user with address #11')
     # reverse of a has_many :through
     assert_constraint_condition({:subscription => {:service => 5}}, [{'services.id' => 5}], 'find all users subscribed to service #5')
-    assert(@test_object.active_scaffold_references.include?({:subscription => :service}), 'multi-level association include')
+    assert(@test_object.active_scaffold_references.include?(:subscription => :service), 'multi-level association include')
 
     @test_object.active_scaffold_config = config_for('subscription')
     # belongs_to (vs has_one)
@@ -179,7 +179,7 @@ class ConstraintsTest < MiniTest::Test
 
   def test_constraint_conditions_for_associations_with_primary_key_option
     @test_object.active_scaffold_config = config_for('primary_key_location')
-    #user = ModelStubs::PrimaryKeyUser.new(:id => 1, :name => 'User Name')
+    # user = ModelStubs::PrimaryKeyUser.new(:id => 1, :name => 'User Name')
     ModelStubs::PrimaryKeyUser.expects(:find).with(1).returns(stub(:id => 1, :name => 'User Name'))
     assert_constraint_condition({'user' => 1}, [{'primary_key_locations.username' => 'User Name'}], 'association with primary-key constraint')
   end
@@ -192,6 +192,6 @@ class ConstraintsTest < MiniTest::Test
   end
 
   def config_for(klass, namespace = nil)
-    super(klass, "model_stubs/")
+    super(klass, 'model_stubs/')
   end
 end

data/test/misc/convert_numbers_format_test.rb

@@ -6,7 +6,7 @@ class NumberModel < ActiveRecord::Base
     @columns ||= [ColumnMock.new('id', '', 'int(11)'), ColumnMock.new('number', '', 'double(10,2)')]
   end
   def self.columns_hash
-    @hash ||= Hash[@columns.map{|c| [c.name, c]}]
+    @hash ||= Hash[@columns.map { |c| [c.name, c] }]
   end
 end
 
@@ -57,7 +57,7 @@ class ConvertNumbersFormatTest < MiniTest::Test
     assert_equal 1000, convert_number('1,000')
     assert_equal 1000, convert_number('+1,000')
     assert_equal -1000, convert_number('-1,000')
-    assert_equal 1000000, convert_number('1,000,000')
+    assert_equal 1_000_000, convert_number('1,000,000')
   end
 
   def test_english_format_with_separator_and_delimiter_using_english_language
@@ -66,7 +66,7 @@ class ConvertNumbersFormatTest < MiniTest::Test
     assert_equal 1234.1, convert_number('1,234.100')
     assert_equal 1234.345, convert_number('+1,234.345')
     assert_equal -1234.345, convert_number('-1,234.345')
-    assert_equal 1234000.1, convert_number('1,234,000.100')
+    assert_equal 1_234_000.1, convert_number('1,234,000.100')
   end
 
   def test_english_format_with_decimal_separator_using_spanish_language
@@ -97,7 +97,7 @@ class ConvertNumbersFormatTest < MiniTest::Test
     assert_equal 1000, convert_number('1.000')
     assert_equal 1000, convert_number('+1.000')
     assert_equal -1000, convert_number('-1.000')
-    assert_equal 1000000, convert_number('1.000.000')
+    assert_equal 1_000_000, convert_number('1.000.000')
   end
 
   def test_spanish_format_with_separator_and_decimal_using_spanish_language
@@ -106,7 +106,7 @@ class ConvertNumbersFormatTest < MiniTest::Test
     assert_equal 1230.1, convert_number('1.230,100')
     assert_equal 1234.345, convert_number('+1.234,345')
     assert_equal -1234.345, convert_number('-1.234,345')
-    assert_equal 1234000.1, convert_number('1.234.000,100')
+    assert_equal 1_234_000.1, convert_number('1.234.000,100')
   end
 
   def test_english_currency_format_with_decimal_separator_using_russian_language
@@ -139,10 +139,11 @@ class ConvertNumbersFormatTest < MiniTest::Test
   end
 
   private
+
   def convert_number(value, format = nil)
     record = NumberModel.new
     @config.columns[:number].options[:format] = format unless format.nil?
-    update_record_from_params(record, @config.create.columns, HashWithIndifferentAccess.new({:number => value}))
+    update_record_from_params(record, @config.create.columns, HashWithIndifferentAccess.new(:number => value))
     record.number
   end
 end

data/test/misc/finder_test.rb

@@ -3,16 +3,23 @@ require 'test_helper'
 class ClassWithFinder
   include ActiveScaffold::Finder
   def conditions_for_collection; end
+
   def conditions_from_params; end
+
   def conditions_from_constraints; end
+
   def joins_for_collection; end
+
   def custom_finder_options
     {}
   end
+
   def beginning_of_chain
     active_scaffold_config.model
   end
+
   def conditional_get_support?; end
+
   def params; {}; end
 end
 
@@ -28,14 +35,11 @@ class FinderTest < MiniTest::Test
       ActiveScaffold::DataStructures::Column.new(:a, ModelStub),
       ActiveScaffold::DataStructures::Column.new(:b, ModelStub)
     ]
-    tokens = [
-      'foo',
-      'bar'
-    ]
+    tokens = %w(foo bar)
 
     expected_conditions = [
-		['"model_stubs"."a" LIKE ? OR "model_stubs"."b" LIKE ?', '%foo%', '%foo%'],
-		['"model_stubs"."a" LIKE ? OR "model_stubs"."b" LIKE ?', '%bar%', '%bar%']
+      ['"model_stubs"."a" LIKE ? OR "model_stubs"."b" LIKE ?', '%foo%', '%foo%'],
+      ['"model_stubs"."a" LIKE ? OR "model_stubs"."b" LIKE ?', '%bar%', '%bar%']
     ]
     assert_equal expected_conditions, ClassWithFinder.create_conditions_for_columns(tokens, columns)
 
@@ -50,9 +54,9 @@ class FinderTest < MiniTest::Test
 
   def test_method_sorting
     column = ActiveScaffold::DataStructures::Column.new('a', ModelStub)
-    column.sort_by :method => proc{self}
+    column.sort_by :method => proc { self }
 
-    collection = [16000, 2853, 98765, 6188, 4]
+    collection = [16_000, 2853, 98_765, 6188, 4]
     assert_equal collection.sort, @klass.send(:sort_collection_by_column, collection, column, 'asc')
     assert_equal collection.sort.reverse, @klass.send(:sort_collection_by_column, collection, column, 'desc')
 
@@ -66,13 +70,13 @@ class FinderTest < MiniTest::Test
   end
 
   def test_count_with_group
-    @klass.expects(:custom_finder_options).returns({:group => :a})
-    relation_class.any_instance.expects(:count).returns({'foo' => 5, 'bar' => 4})
+    @klass.expects(:custom_finder_options).returns(:group => :a)
+    relation_class.any_instance.expects(:count).returns('foo' => 5, 'bar' => 4)
     relation_class.any_instance.expects(:limit).with(20).returns(ModelStub.where(nil))
     relation_class.any_instance.expects(:offset).with(0).returns(ModelStub.where(nil))
     page = @klass.send :find_page, :per_page => 20, :pagination => true
     page.items
-    
+
     assert_kind_of Integer, page.pager.count
     assert_equal 2, page.pager.count
     assert_equal 1, page.pager.number_of_pages
@@ -89,7 +93,7 @@ class FinderTest < MiniTest::Test
 
   def test_infinite_pagination
     ModelStub.expects(:count).never
-    page = @klass.send :find_page, :pagination => :infinite
+    @klass.send :find_page, :pagination => :infinite
   end
 
   def test_condition_for_column
@@ -98,6 +102,7 @@ class FinderTest < MiniTest::Test
   end
 
   private
+
   def relation_class
     @klass.active_scaffold_config.model.send(:relation).class
   end

data/test/misc/lang_test.rb

@@ -1,11 +1,10 @@
 require 'test_helper'
 
 class LocalizationTest < MiniTest::Test
-
   def test_localization
-    assert_equal "Dutch", as_(:dutch)
-    assert_equal "dutch", as_('dutch')
+    assert_equal 'Dutch', as_(:dutch)
+    assert_equal 'dutch', as_('dutch')
     I18n.backend.store_translations :en, :active_scaffold => {:create_model => 'Create %{model}'}
-    assert_equal "Create Test", as_(:create_model, :model => 'Test')
+    assert_equal 'Create Test', as_(:create_model, :model => 'Test')
   end
 end