Spaces

.rubocop.yml

   Exclude:
     - 'app/models/activity.rb'
 
-# Offense count: 2
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: space, no_space
-Layout/SpaceAroundEqualsInParameterDefault:
-  Exclude:
-    - 'app/helpers/authentication_helper.rb'
-    - 'app/models/activity.rb'
-
-# Offense count: 1
-# Cop supports --auto-correct.
-# Configuration parameters: AllowForAlignment.
-Layout/SpaceAroundOperators:
-  Exclude:
-    - 'app/controllers/activities_controller.rb'
-
-# Offense count: 7
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle, EnforcedStyleForEmptyBraces.
-# SupportedStyles: space, no_space
-# SupportedStylesForEmptyBraces: space, no_space
-Layout/SpaceBeforeBlockBraces:
-  Exclude:
-    - 'app/controllers/activities_controller.rb'
-    - 'app/controllers/api/activities_controller.rb'
-    - 'app/controllers/groups_controller.rb'
-
-# Offense count: 4
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle, EnforcedStyleForEmptyBrackets.
-# SupportedStyles: space, no_space, compact
-# SupportedStylesForEmptyBrackets: space, no_space
-Layout/SpaceInsideArrayLiteralBrackets:
-  Exclude:
-    - 'app/controllers/members_controller.rb'
-    - 'config/environments/production.rb'
-
-# Offense count: 9
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle, EnforcedStyleForEmptyBraces, SpaceBeforeBlockParameters.
-# SupportedStyles: space, no_space
-# SupportedStylesForEmptyBraces: space, no_space
-Layout/SpaceInsideBlockBraces:
-  Exclude:
-    - 'app/controllers/activities_controller.rb'
-    - 'app/controllers/api/activities_controller.rb'
-    - 'app/controllers/groups_controller.rb'
-    - 'config/puma.rb'
-
-# Offense count: 20
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle, EnforcedStyleForEmptyBraces.
-# SupportedStyles: space, no_space, compact
-# SupportedStylesForEmptyBraces: space, no_space
-Layout/SpaceInsideHashLiteralBraces:
-  Exclude:
-    - 'app/models/activity.rb'
-    - 'app/models/person.rb'
-    - 'config/environments/production.rb'
-    - 'test/controllers/activities_controller_test.rb'
-    - 'test/controllers/api/activities_controller_test.rb'
-    - 'test/controllers/api/groups_controller_test.rb'
-    - 'test/controllers/api/people_controller_test.rb'
-    - 'test/controllers/groups_controller_test.rb'
-    - 'test/controllers/members_controller_test.rb'
-    - 'test/controllers/people_controller_test.rb'
-
-# Offense count: 4
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: space, no_space
-Layout/SpaceInsideParens:
-  Exclude:
-    - 'app/controllers/activities_controller.rb'
-
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: IndentationWidth.

app/controllers/activities_controller.rb

                            .joins(:person)
                            .where(is_organizer: true)
                            .order('people.first_name ASC')
-                           .map{|p| p.person.full_name}
+                           .map { |p| p.person.full_name }
                            .join(', ')
     @ownparticipant = @activity.participants
                                .find_by(person: current_person)
     @subgroup_ids = @activity.subgroups
                              .order(name: :asc)
                              .pluck(:name, :id)
-    @subgroup_ids.prepend( [I18n.t('activities.subgroups.filter_nofilter'), 'all'] )
-    @subgroup_ids.append( [I18n.t('activities.subgroups.filter_nogroup'), 'withoutgroup'] )
+    @subgroup_ids.prepend([I18n.t('activities.subgroups.filter_nofilter'), 'all'])
+    @subgroup_ids.append([I18n.t('activities.subgroups.filter_nogroup'), 'withoutgroup'])
   end
 
   # GET /activities/new
     @non_organizers = @activity.participants.where(is_organizer: [false, nil])
     @organizers = @activity.organizers
 
-    @non_organizers_options = @non_organizers.map{|p| [p.person.full_name, p.id] }
-    @organizers_options     = @organizers.map{|p| [p.person.full_name, p.id] }
+    @non_organizers_options = @non_organizers.map { |p| [p.person.full_name, p.id] }
+    @organizers_options     = @organizers.map { |p| [p.person.full_name, p.id] }
 
     @non_organizers_options.sort!
     @organizers_options.sort!

app/controllers/api/activities_controller.rb

 
     absent = as.where(attending: false)
 
-    presentnames = present.map{|p| p.person.first_name }
+    presentnames = present.map { |p| p.person.first_name }
 
-    unknownnames = unknown.map{|p| p.person.first_name }
+    unknownnames = unknown.map { |p| p.person.first_name }
 
-    absentnames = absent.map{|p| p.person.first_name }
+    absentnames = absent.map { |p| p.person.first_name }
 
     if presentnames.positive?
       present_mess = I18n.t('activities.participant.these_present', count: present.count, names: presentnames.join(', '))

app/controllers/groups_controller.rb

     @upcoming_ps = Participant
                    .where(person: current_person)
                    .where(activity: @upcoming)
-                   .map{ |p| [p.activity_id, p]}
+                   .map { |p| [p.activity_id, p] }
                    .to_h
   end
 

app/controllers/members_controller.rb

   include GroupsHelper
   before_action :set_group
   before_action :set_member, only: [:show, :edit, :update, :destroy, :promote, :demote]
-  before_action :require_leader!, except: [ :index ]
+  before_action :require_leader!, except: [:index]
 
   # GET /members
   # GET /members.json

app/helpers/authentication_helper.rb

 module AuthenticationHelper
   # Create a new Session and set the relevant cookies.
-  def log_in(user, remember, new=true)
+  def log_in(user, remember, new = true)
     reset_session
 
     expiry = 6.hours.since

app/models/activity.rb

 
   # Create multiple Activities from data in a CSV file, assign to a group, return.
   def self.from_csv(content, group)
-    reader = CSV.parse(content, {headers: true, skip_blanks: true})
+    reader = CSV.parse(content, { headers: true, skip_blanks: true })
 
     result = []
     reader.each do |row|
   end
 
   # Assign a subgroup to all attending participants without one.
-  def assign_subgroups!(mail= false)
+  def assign_subgroups!(mail = false)
     # Sanity check: we need subgroups to divide into.
     return unless self.subgroups.any?
 

app/models/person.rb

 
   # Create multiple Persons from data found in a csv file, return those.
   def self.from_csv(content)
-    reader = CSV.parse(content, {headers: true, skip_blanks: true})
+    reader = CSV.parse(content, { headers: true, skip_blanks: true })
 
     result = []
     reader.each do |row|

config/environments/production.rb

   config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?
 
   # Compress JavaScripts and CSS.
-  config.assets.js_compressor = Uglifier.new({harmony: true})
+  config.assets.js_compressor = Uglifier.new({ harmony: true })
   # config.assets.css_compressor = :sass
 
   # Do not fallback to assets pipeline if a precompiled asset is missed.
   config.log_level = :debug
 
   # Prepend all log lines with the following tags.
-  config.log_tags = [ :request_id ]
+  config.log_tags = [:request_id]
 
   # Use a different cache store in production.
   # config.cache_store = :mem_cache_store

config/puma.rb

 
 # Specifies the `port` that Puma will listen on to receive requests, default is 3000.
 #
-bind	ENV.fetch("PUMA_BIND") { 'tcp://127.0.0.1:3000'}
+bind	ENV.fetch("PUMA_BIND") { 'tcp://127.0.0.1:3000' }
 
 # Specifies the `environment` that Puma will run in.
 #

test/controllers/activities_controller_test.rb

 
   test "should create activity" do
     assert_difference('Activity.count') do
-      post activities_url, params: { activity: { } }
+      post activities_url, params: { activity: {} }
     end
 
     assert_redirected_to activity_url(Activity.last)
   end
 
   test "should update activity" do
-    patch activity_url(@activity), params: { activity: { } }
+    patch activity_url(@activity), params: { activity: {} }
     assert_redirected_to activity_url(@activity)
   end
 

test/controllers/api/activities_controller_test.rb

 
   test "should create api_activity" do
     assert_difference('Api::Activity.count') do
-      post api_activities_url, params: { api_activity: { } }
+      post api_activities_url, params: { api_activity: {} }
     end
 
     assert_redirected_to api_activity_url(Api::Activity.last)
   end
 
   test "should update api_activity" do
-    patch api_activity_url(@api_activity), params: { api_activity: { } }
+    patch api_activity_url(@api_activity), params: { api_activity: {} }
     assert_redirected_to api_activity_url(@api_activity)
   end
 

test/controllers/api/groups_controller_test.rb

 
   test "should create api_group" do
     assert_difference('Api::Group.count') do
-      post api_groups_url, params: { api_group: { } }
+      post api_groups_url, params: { api_group: {} }
     end
 
     assert_redirected_to api_group_url(Api::Group.last)
   end
 
   test "should update api_group" do
-    patch api_group_url(@api_group), params: { api_group: { } }
+    patch api_group_url(@api_group), params: { api_group: {} }
     assert_redirected_to api_group_url(@api_group)
   end
 

test/controllers/api/people_controller_test.rb

 
   test "should create api_person" do
     assert_difference('Api::Person.count') do
-      post api_people_url, params: { api_person: { } }
+      post api_people_url, params: { api_person: {} }
     end
 
     assert_redirected_to api_person_url(Api::Person.last)
   end
 
   test "should update api_person" do
-    patch api_person_url(@api_person), params: { api_person: { } }
+    patch api_person_url(@api_person), params: { api_person: {} }
     assert_redirected_to api_person_url(@api_person)
   end
 

test/controllers/groups_controller_test.rb

 
   test "should create group" do
     assert_difference('Group.count') do
-      post groups_url, params: { group: { } }
+      post groups_url, params: { group: {} }
     end
 
     assert_redirected_to group_url(Group.last)
   end
 
   test "should update group" do
-    patch group_url(@group), params: { group: { } }
+    patch group_url(@group), params: { group: {} }
     assert_redirected_to group_url(@group)
   end
 

test/controllers/members_controller_test.rb

 
   test "should create member" do
     assert_difference('Member.count') do
-      post members_url, params: { member: { } }
+      post members_url, params: { member: {} }
     end
 
     assert_redirected_to member_url(Member.last)
   end
 
   test "should update member" do
-    patch member_url(@member), params: { member: { } }
+    patch member_url(@member), params: { member: {} }
     assert_redirected_to member_url(@member)
   end
 

test/controllers/people_controller_test.rb

 
   test "should create person" do
     assert_difference('Person.count') do
-      post people_url, params: { person: { } }
+      post people_url, params: { person: {} }
     end
 
     assert_redirected_to person_url(Person.last)
   end
 
   test "should update person" do
-    patch person_url(@person), params: { person: { } }
+    patch person_url(@person), params: { person: {} }
     assert_redirected_to person_url(@person)
   end