inclusive-code 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 495cf47e5d18f5dad603026d5314bdfeeaeae01a045884444e2eb6316fc1ae68
+  data.tar.gz: 774b4de9e09abae3ec9c80373a9a6d3af1f63593df0ddd18a4922ad2deb92c46
+SHA512:
+  metadata.gz: c6cf747c66926af9c1bc9d6c7fcdc0cf52ee3ee9b3c20c17238989a5a2983c569bea8929dfcade6cf5f60333fb604a5a6ff961e8abc7d9b842c0692e4d07e281
+  data.tar.gz: e850f2f2cfae0a2ece5efd6368c8d8e45a3f31544aff933b4fccd802bcbb4bce420854472dc83c609c01aeaa6b1c8fc0a43060ebb52fa9a1af34897fc40aec88

data/README.md

@@ -0,0 +1 @@
+## TODO: add usage instructions for rubocop gem

data/config/default.yml

@@ -0,0 +1,4 @@
+Flexport/InclusiveCode:
+  Description: "Warns on usage of flagged terms, suggests alternatives and allows for exceptions as configured."
+  Enabled: true
+  VersionAdded: "0.1.0"

data/lib/inclusive-code.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+require_relative 'inclusive_code/flexport'
+require_relative 'inclusive_code/flexport/version'
+require_relative 'inclusive_code/flexport/inject'
+
+InclusiveCode::Flexport::Inject.defaults!
+
+require_relative 'inclusive_code/cop/inclusive_code'

data/lib/inclusive_code/cop/inclusive_code.rb

@@ -0,0 +1,139 @@
+module InclusiveCode
+  module Cop
+    module Flexport
+      # This cop encourages use of inclusive language to help programmers avoid
+      # using terminology that is derogatory, hurtful, or perpetuates discrimination,
+      # either directly or indirectly, in their code.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   BLACKLIST_COUNTRIES = "blacklist_countries".freeze
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   BLOCKLIST_COUNTRIES = "blocklist_countries".freeze
+      #
+      #
+      class InclusiveCode < Cop
+        include RangeHelp
+
+        SEVERITY = "warning".freeze
+
+        MSG = "🚫 Use of non_inclusive word: `%<non_inclusive_word>s`. Consider using these suggested alternatives: `%<suggestions>s`.".freeze
+
+        NON_INCLUSIVE_WORDS_ALTERNATIVES_HASH = YAML.load_file(global_config_path)["flagged_terms"]
+
+        ALL_NON_INCLUSIVE_WORDS = NON_INCLUSIVE_WORDS_ALTERNATIVES_HASH.keys
+
+        NON_INCLUSIVE_WORDS_REGEX = Regexp.new(
+          ALL_NON_INCLUSIVE_WORDS.join("|"),
+          Regexp::IGNORECASE,
+        )
+
+        def self.get_allowed_string(non_inclusive_word)
+          allowed = NON_INCLUSIVE_WORDS_ALTERNATIVES_HASH[non_inclusive_word]["allowed"]
+          snake_case = allowed.map { |e| e.tr(" ", "_").underscore }
+          pascal_case = snake_case.map(&:camelize)
+          (allowed + snake_case + pascal_case).join("|")
+        end
+
+        ALLOWED = ALL_NON_INCLUSIVE_WORDS.collect do |word|
+          [
+            word,
+            get_allowed_string(word),
+          ]
+        end.to_h
+
+        ALLOWED_REGEX = Regexp.new(ALLOWED.values.reject(&:blank?).join("|"), Regexp::IGNORECASE)
+
+        def investigate(processed_source)
+          processed_source.lines.each_with_index do |line, line_number|
+            if line.match(NON_INCLUSIVE_WORDS_REGEX)
+              ALL_NON_INCLUSIVE_WORDS.each do |non_inclusive_word|
+                allowed = ALLOWED[non_inclusive_word]
+                if allowed.blank?
+                  scan_regex = /(?=#{non_inclusive_word})/i
+                else
+                  scan_regex = /(?=#{non_inclusive_word})(?!(#{ALLOWED[non_inclusive_word]}))/i
+                end
+                locations = line.enum_for(
+                  :scan,
+                  scan_regex,
+                ).map { Regexp.last_match&.offset(0)&.first }
+                next if locations.blank?
+                locations.each do |location|
+                  range = source_range(
+                    processed_source.buffer,
+                    line_number + 1,
+                    location,
+                    non_inclusive_word.length,
+                  )
+                  add_offense(
+                    range,
+                    location: range,
+                    message: create_message(non_inclusive_word),
+                    severity: SEVERITY,
+                  )
+                end
+              end
+            end
+          end
+          # Also error for non-inclusive language in file names
+          path = processed_source.path
+          if path.nil?
+            return
+          end
+          non_inclusive_words_match = path.match(NON_INCLUSIVE_WORDS_REGEX)
+          if non_inclusive_words_match && !path.match(ALLOWED_REGEX)
+            range = source_range(processed_source.buffer, 1, 0)
+            add_offense(
+              range,
+              location: range,
+              message: create_message(non_inclusive_words_match[0]),
+              severity: SEVERITY,
+            )
+          end
+        end
+
+        def autocorrect(arg_pair)
+          word_to_correct = arg_pair.source
+          word_to_correct_downcase = word_to_correct.downcase
+          return if !NON_INCLUSIVE_WORDS_ALTERNATIVES_HASH.key?(word_to_correct_downcase)
+          return if NON_INCLUSIVE_WORDS_ALTERNATIVES_HASH[word_to_correct_downcase]["suggestions"].blank?
+          corrected = NON_INCLUSIVE_WORDS_ALTERNATIVES_HASH[word_to_correct_downcase]["suggestions"][0]
+
+          # Only respects case if it is capitalized or uniform (all upper or all lower)
+          to_upcase = word_to_correct == word_to_correct.upcase
+          if to_upcase
+            corrected = corrected.upcase
+          elsif word_to_correct == word_to_correct.capitalize
+            corrected = corrected.capitalize
+          end
+
+          ->(corrector) do
+            corrector.insert_before(arg_pair, corrected)
+            corrector.remove(arg_pair)
+          end
+        end
+
+        private
+
+        def create_message(non_inclusive_word)
+          format(
+            MSG,
+            non_inclusive_word: non_inclusive_word,
+            suggestions: NON_INCLUSIVE_WORDS_ALTERNATIVES_HASH[non_inclusive_word]["suggestions"].join(", "),
+          )
+        end
+
+        def global_config_path
+          cop_config['GlobalConfigPath']
+        end
+      end
+    end
+  end
+end

data/lib/inclusive_code/flexport.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'inclusive_code/flexport/version'
+
+module InclusiveCode
+  module Flexport
+    class Error < StandardError; end
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end

data/lib/inclusive_code/flexport/inject.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT-LICENSE.md
+module InclusiveCode
+  module Flexport
+    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+    # bit of our configuration.
+    module Inject
+      def self.defaults!
+        path = CONFIG_DEFAULT.to_s
+        hash = ConfigLoader.send(:load_yaml_configuration, path)
+        config = Config.new(hash, path)
+        puts "configuration from #{path}" if ConfigLoader.debug?
+        config = ConfigLoader.merge_with_default(config, path)
+        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      end
+    end
+  end
+end

data/lib/inclusive_code/flexport/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module InclusiveCode
+  module Flexport
+    VERSION = '0.1.0'
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: inclusive-code
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Flexport Engineering
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.70.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.70.0
+description: ''
+email:
+- dev@flexport.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- config/default.yml
+- lib/inclusive-code.rb
+- lib/inclusive_code/cop/inclusive_code.rb
+- lib/inclusive_code/flexport.rb
+- lib/inclusive_code/flexport/inject.rb
+- lib/inclusive_code/flexport/version.rb
+homepage: https://github.com/flexport/rubocop-flexport
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.7.7
+signing_key:
+specification_version: 4
+summary: Inclusive Language RuboCop.
+test_files: []