run the linter

Author: GrantBirki

lib/entitlements/backend/github_org/controller.rb

@@ -83,7 +83,7 @@ def calculate
           validate_no_dupes!       # calls read() for each group
 
           if changes.any?
-            print_differences(key: group_name, added: [], removed: [], changed: changes, ignored_users: ignored_users)
+            print_differences(key: group_name, added: [], removed: [], changed: changes, ignored_users:)
             @actions.concat(changes)
           else
             logger.debug "UNCHANGED: No GitHub organization changes for #{group_name}"
@@ -398,11 +398,11 @@ def categorized_changes
               if removed.key?(member.downcase)
                 # Already removed from a previous role. Therefore this is a move to a different role.
                 removed.delete(member.downcase)
-                moved[member.downcase] = { member: member, role: role }
+                moved[member.downcase] = { member:, role: }
               else
                 # Not removed from a previous role. Suspect this is an addition to the org (if we later spot a removal
                 # from a role, then the code below will update that to be a move instead).
-                added[member.downcase] = { member: member, role: role }
+                added[member.downcase] = { member:, role: }
               end
             end
 
@@ -414,12 +414,12 @@ def categorized_changes
               else
                 # Not added to a previous role. Suspect this is a removal from the org (if we later spot an addition
                 # to another role, then the code above will update that to be a move instead).
-                removed[member.downcase] = { member: member, role: role }
+                removed[member.downcase] = { member:, role: }
               end
             end
           end
 
-          { added: added, removed: removed, moved: moved }
+          { added:, removed:, moved: }
         end
 
         # Admins or members who are both `invited` and `pending` do not need to be re-invited. We're waiting for them

lib/entitlements/backend/github_org/service.rb

@@ -44,7 +44,7 @@ def sync(implementation, role)
         Contract String, String => C::Bool
         def add_user_to_organization(user, role)
           Entitlements.logger.debug "#{identifier} add_user_to_organization(user=#{user}, org=#{org}, role=#{role})"
-          new_membership = octokit.update_organization_membership(org, user: user, role: role)
+          new_membership = octokit.update_organization_membership(org, user:, role:)
 
           # Happy path
           if new_membership[:role] == role
@@ -70,7 +70,7 @@ def add_user_to_organization(user, role)
         Contract String => C::Bool
         def remove_user_from_organization(user)
           Entitlements.logger.debug "#{identifier} remove_user_from_organization(user=#{user}, org=#{org})"
-          result = octokit.remove_organization_membership(org, user: user)
+          result = octokit.remove_organization_membership(org, user:)
 
           # If we removed the user, remove them from the cache of members, so that any GitHub team
           # operations in this organization will ignore this user.

lib/entitlements/backend/github_team/controller.rb

@@ -61,12 +61,12 @@ def calculate
             end
 
             if diff[:metadata] && diff[:metadata][:create_team]
-              added << Entitlements::Models::Action.new(team_slug, provider.read(group), group, group_name, ignored_users: ignored_users)
+              added << Entitlements::Models::Action.new(team_slug, provider.read(group), group, group_name, ignored_users:)
             else
-              changed << Entitlements::Models::Action.new(team_slug, provider.read(group), group, group_name, ignored_users: ignored_users)
+              changed << Entitlements::Models::Action.new(team_slug, provider.read(group), group, group_name, ignored_users:)
             end
           end
-          print_differences(key: group_name, added: added, removed: [], changed: changed)
+          print_differences(key: group_name, added:, removed: [], changed:)
 
           @actions = added + changed
         end

lib/entitlements/backend/github_team/models/team.rb

@@ -27,7 +27,7 @@ def initialize(team_id:, team_name:, members:, ou:, metadata:)
             @team_id = team_id
             @team_name = team_name.downcase
             @team_dn = ["cn=#{team_name.downcase}", ou].join(",")
-            super(dn: @team_dn, members: Set.new(members.map { |m| m.downcase }), metadata: metadata)
+            super(dn: @team_dn, members: Set.new(members.map { |m| m.downcase }), metadata:)
           end
         end
       end

lib/entitlements/backend/github_team/provider.rb

@@ -127,7 +127,7 @@ def commit(entitlement_group)
           # Create the new team and invalidate the cache
           if github_team.nil?
             team_name = entitlement_group.cn.downcase
-            github.create_team(entitlement_group: entitlement_group)
+            github.create_team(entitlement_group:)
             github.invalidate_predictive_cache(entitlement_group)
             @github_team_cache.delete(team_name)
             github_team = github.read_team(entitlement_group)
@@ -168,7 +168,7 @@ def create_github_team_group(entitlement_group)
             team_name: entitlement_group.cn.downcase,
             members: Set.new,
             ou: github.ou,
-            metadata: metadata
+            metadata:
           )
         end
 

lib/entitlements/backend/github_team/service.rb

@@ -78,7 +78,7 @@ def read_team(entitlement_group)
                 team_id: -1,
                 team_name: team_identifier,
                 members: cached_members,
-                ou: ou,
+                ou:,
                 metadata: team_metadata
               )
 
@@ -108,7 +108,7 @@ def read_team(entitlement_group)
                   team_id: teamdata[:team_id],
                   team_name: team_identifier,
                   members: Set.new(teamdata[:members]),
-                  ou: ou,
+                  ou:,
                   metadata: team_metadata
                 )
               rescue TeamNotFound
@@ -380,7 +380,7 @@ def graphql_team_data(team_slug)
             break
           end
 
-          { members: result, team_id: team_id, parent_team_name: parent_team_name }
+          { members: result, team_id:, parent_team_name: }
         end
 
         # Ensure that the given team ID actually matches up to the team slug on GitHub. This is in place
@@ -425,7 +425,7 @@ def add_user_to_team(user:, team:, role: "member")
           end
           Entitlements.logger.debug "#{identifier} add_user_to_team(user=#{user}, org=#{org}, team_id=#{team.team_id}, role=#{role})"
           validate_team_id_and_slug!(team.team_id, team.team_name)
-          result = octokit.add_team_membership(team.team_id, user, role: role)
+          result = octokit.add_team_membership(team.team_id, user, role:)
           result[:state] == "active" || result[:state] == "pending"
         end
 

lib/entitlements/service/github.rb

@@ -82,7 +82,7 @@ def org_members
           member_count = result.count { |_, role| role == "member" }
           Entitlements.logger.debug "Currently #{org} has #{admin_count} admin(s) and #{member_count} member(s)"
 
-          { cache: cache, value: result }
+          { cache:, value: result }
         end
 
         Entitlements.cache[:github_org_members][org_signature][:value]
@@ -354,9 +354,9 @@ def graphql_http_post_real(query)
             data = JSON.parse(response.body)
             if data.key?("errors")
               Entitlements.logger.error "Errors reported: #{data['errors'].inspect}"
-              return { code: 500, data: data }
+              return { code: 500, data: }
             end
-            { code: response.code.to_i, data: data }
+            { code: response.code.to_i, data: }
           rescue JSON::ParserError => e
             Entitlements.logger.error "#{e.class} #{e.message}: #{response.body.inspect}"
             { code: 500, data: { "body" => response.body } }

spec/acceptance/tests/spec_helper.rb

@@ -64,7 +64,7 @@ def run(fixture_dir, args = [])
   command_parts = [binary, "--config-file", configfile] + args
   command = command_parts.map { |i| Shellwords.escape(i) }.join(" ")
   stdout, stderr, exitstatus = Open3.capture3(command)
-  OpenStruct.new({ stdout: stdout, stderr: stderr, exitstatus: exitstatus.exitstatus, success?: exitstatus.exitstatus == 0 })
+  OpenStruct.new({ stdout:, stderr:, exitstatus: exitstatus.exitstatus, success?: exitstatus.exitstatus == 0 })
 end
 
 def log(priority, pattern)

spec/unit/entitlements/backend/github_org/controller_spec.rb

@@ -588,7 +588,7 @@
       let(:answer2) { { "monalisa" => "ADMIN", "ragamuffin" => "ADMIN", "blackmanx" => "MEMBER", "toyger" => "MEMBER" } }
 
       it "invalidates the cache and consults the API" do
-        cache[:predictive_state] = { by_dn: { org1_admin_dn => { members: admins, metadata: nil }, org1_member_dn => { members: members, metadata: nil } }, invalid: Set.new }
+        cache[:predictive_state] = { by_dn: { org1_admin_dn => { members: admins, metadata: nil }, org1_member_dn => { members:, metadata: nil } }, invalid: Set.new }
 
         allow(Entitlements::Data::Groups::Calculated).to receive(:read_all)
           .with("foo-githuborg", {

spec/unit/entitlements/backend/github_team/provider_spec.rb

@@ -19,8 +19,8 @@
   let(:russian_blue) { Entitlements::Models::Person.new(uid: "russian_blue") }
   let(:members) { Set.new(%w[SnowShoe russian_blue]) }
   let(:dn) { "cn=cats,ou=Github,dc=github,dc=fake" }
-  let(:group) { Entitlements::Models::Group.new(dn: dn, description: ":smile_cat:", members: Set.new([snowshoe, russian_blue]), metadata: {"application_owner" => "russian_blue"}) }
-  let(:team) { Entitlements::Backend::GitHubTeam::Models::Team.new(team_id: 1001, team_name: "cats", members: members, ou: "ou=kittensinc,ou=GitHub,dc=github,dc=fake", metadata: {"application_owner" => "russian_blue"}) }
+  let(:group) { Entitlements::Models::Group.new(dn:, description: ":smile_cat:", members: Set.new([snowshoe, russian_blue]), metadata: {"application_owner" => "russian_blue"}) }
+  let(:team) { Entitlements::Backend::GitHubTeam::Models::Team.new(team_id: 1001, team_name: "cats", members:, ou: "ou=kittensinc,ou=GitHub,dc=github,dc=fake", metadata: {"application_owner" => "russian_blue"}) }
   let(:member_strings_set) { Set.new(members.map(&:downcase)) }
   let(:subject) { described_class.new(config: provider_config) }
 
@@ -189,9 +189,9 @@
   end
 
   describe "#change_ignored?" do
-    let(:group1) { Entitlements::Models::Group.new(dn: dn, description: ":smile_cat:", members: Set.new([snowshoe])) }
-    let(:group2) { Entitlements::Models::Group.new(dn: dn, description: ":smile_cat:", members: Set.new([russian_blue])) }
-    let(:action) { Entitlements::Models::Action.new(dn, group1, group2, "foo", ignored_users: ignored_users) }
+    let(:group1) { Entitlements::Models::Group.new(dn:, description: ":smile_cat:", members: Set.new([snowshoe])) }
+    let(:group2) { Entitlements::Models::Group.new(dn:, description: ":smile_cat:", members: Set.new([russian_blue])) }
+    let(:action) { Entitlements::Models::Action.new(dn, group1, group2, "foo", ignored_users:) }
 
     context "all adds/removes ignored" do
       let(:ignored_users) { Set.new([snowshoe, russian_blue].map(&:uid)) }
@@ -260,7 +260,7 @@
 
       allow(subject).to receive(:github).and_return(github)
       expect(github).to receive(:read_team).with(entitlement_group).and_return(nil)
-      expect(github).to receive(:create_team).with({entitlement_group: entitlement_group}).and_return(true)
+      expect(github).to receive(:create_team).with({entitlement_group:}).and_return(true)
       expect(github).to receive(:invalidate_predictive_cache).with(entitlement_group).and_return(nil)
       expect(github).to receive(:read_team).with(entitlement_group).and_return(github_team)
       expect(github).to receive(:sync_team).with(entitlement_group, github_team).and_return(true)