rubocop-disable_syntax 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2043bf5a5a0901cb7335082d5536484f634272a0a3f9cc6d8146e75b2663a0ab
+  data.tar.gz: 9a87b08496dc0cd0b42c6ee5a373cc9b6d5f42166148f15f7f26939f3b8d1259
+SHA512:
+  metadata.gz: 7501434582cfcae34bb8c03ea062cefa44201d3c51cd308a7ea1f33de68ef4d3410dde6c82221bcbee1867c0460b4edacd6ba12d8381c2ede6ba93b56255bbbf
+  data.tar.gz: 5ac9ed8490f18910f3b27a9157a143b2e7751dde4a81e921ec126567f5984d74d37a00c153f2f5811b593c99e24b8285e58c9b6f8f6fb09fc287d72e139f23fb

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## master (unreleased)
+
+## 0.1.0 (2023-09-26)
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 fatkodima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# rubocop-disable_syntax
+
+[![Build Status](https://github.com/fatkodima/rubocop-disable_syntax/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/fatkodima/rubocop-disable_syntax/actions/workflows/ci.yml)
+
+`rubocop-disable_syntax` is a [RuboCop](https://github.com/rubocop/rubocop) plugin that allows to disable some unfavorite ruby syntax such as `unless`, safe navigation etc.
+
+## Requirements
+
+- ruby 2.7+
+- rubocop 1.50+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rubocop-disable_syntax', group: :development, require: false
+```
+
+And then run:
+
+```sh
+$ bundle install
+```
+
+## Usage
+
+You need to tell RuboCop to load the `rubocop-disable_syntax` extension.
+
+Put this into your `.rubocop.yml`.
+
+```yaml
+require:
+  - rubocop-disable_syntax
+```
+
+All the ruby syntax features are enabled by default and so this gem acts as a no-op. You need to manually configure
+which ruby features you want to disable:
+
+```yml
+Style/DisableSyntax:
+  DisableSyntax:
+    - unless
+    - ternary
+    - safe_navigation
+    - endless_methods
+    - arguments_forwarding
+    - numbered_parameters
+    - pattern_matching
+    - shorthand_hash_syntax
+    - and_or_not
+    - until
+    - percent_literals
+```
+
+* `unless` - no `unless` keyword
+* `ternary` - no ternary operator (`condition ? foo : bar`)
+* `safe_navigation` - no safe navigation operator (`&.`)
+* `endless_methods` - no endless methods (`def foo = 1`)
+* `arguments_forwarding` - no arguments forwarding (`foo(...)`, `foo(*)`, `foo(**)`, `foo(&)`)
+* `numbered_parameters` - no numbered parameters (`foo.each { puts _1 }`)
+* `pattern_matching` - no pattern matching
+* `shorthand_hash_syntax` - no shorthand hash syntax (`{ x:, y: }`)
+* `and_or_not` - no `and`/`or`/`not` keywords (should use `&&`/`||`/`!` instead)
+* `until` - no `until` keyword
+* `percent_literals` - no any `%` style literals (`%w[foo bar]`, `%i[foo bar]`, `%q("str")`, `%r{/regex/}`)
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake` to run the linter and tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/fatkodima/rubocop-disable_syntax.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/config/default.yml

@@ -0,0 +1,17 @@
+Style/DisableSyntax:
+  Description: 'Forbid some unfavorite ruby syntax, such as `unless`, safe navigation etc.'
+  Enabled: true
+  VersionAdded: '0.1'
+  SupportedDisableSyntax:
+    - unless
+    - ternary
+    - safe_navigation
+    - endless_methods
+    - arguments_forwarding
+    - numbered_parameters
+    - pattern_matching
+    - shorthand_hash_syntax
+    - and_or_not
+    - until
+    - percent_literals
+  DisableSyntax: []

data/lib/rubocop/cop/style/disable_syntax.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class DisableSyntax < Base
+        extend AutoCorrector
+
+        def on_if(node)
+          if node.unless? && !unless_allowed?
+            add_offense(node, message: "Do not use `unless`.") do |corrector|
+              corrector.replace(node.loc.keyword, "if")
+              corrector.wrap(node.condition, "!(", ")")
+            end
+          elsif node.ternary? && !ternary_allowed?
+            add_offense(node, message: "Do not use ternary operator.")
+          end
+        end
+
+        def on_csend(node)
+          if !safe_navigation_allowed?
+            add_offense(node, message: "Do not use `&.`.")
+          end
+          on_send(node)
+        end
+
+        def on_send(node)
+          if !arguments_forwarding_allowed? && arguments_forwarding?(node)
+            add_offense(node, message: "Do not use arguments forwarding.")
+          elsif node.prefix_not? && !and_or_not_allowed?
+            add_offense(node, message: "Use `!` instead of `not`.") do |corrector|
+              corrector.replace(node.loc.selector, "!")
+            end
+          end
+        end
+
+        def on_def(node)
+          if node.endless? && !endless_methods_allowed?
+            add_offense(node, message: "Do not use endless methods.") do |corrector|
+              arguments = node.arguments.any? ? node.arguments.source : ""
+
+              corrector.replace(node, <<~RUBY.strip)
+                def #{node.method_name}#{arguments}
+                  #{node.body.source}
+                end
+              RUBY
+            end
+          end
+        end
+        alias on_defs on_def
+
+        def on_numblock(node)
+          if !numbered_parameters_allowed?
+            add_offense(node, message: "Do not use numbered parameters.")
+          end
+        end
+
+        def on_case_match(node)
+          if !pattern_matching_allowed?
+            add_offense(node, message: "Do not use pattern matching.")
+          end
+        end
+
+        def on_hash(node)
+          return if shorthand_hash_syntax_allowed? || node.pairs.none?(&:value_omission?)
+
+          add_offense(node, message: "Do not use shorthand hash syntax.") do |corrector|
+            node.pairs.each do |pair|
+              if pair.value_omission?
+                hash_key_source = pair.key.source
+                corrector.replace(pair, "#{hash_key_source}: #{hash_key_source}")
+              end
+            end
+          end
+        end
+
+        def on_and(node)
+          if node.semantic_operator? && !and_or_not_allowed?
+            add_offense(node, message: "Use `#{node.alternate_operator}` instead of `#{node.operator}`.") do |corrector|
+              corrector.replace(node.loc.operator, node.alternate_operator)
+            end
+          end
+        end
+        alias on_or on_and
+
+        def on_until(node)
+          return if until_allowed?
+
+          add_offense(node, message: "Do not use `until`.") do |corrector|
+            corrector.replace(node.loc.keyword, "while")
+            corrector.wrap(node.condition, "!(", ")")
+          end
+        end
+
+        def on_array(node)
+          if node.percent_literal? && !percent_literals_allowed?
+            add_offense(node, message: "Do not use `%` literals for arrays.")
+          end
+        end
+
+        def on_regexp(node)
+          if node.percent_r_literal? && !percent_literals_allowed?
+            add_offense(node, message: "Do not use `%` literals for regexes.")
+          end
+        end
+
+        def on_str(node)
+          if !percent_literals_allowed? && str_percent_literal?(node)
+            add_offense(node, message: "Do not use `%` literals for strings.")
+          end
+        end
+
+        private
+          def unless_allowed?
+            !disable_syntax.include?("unless")
+          end
+
+          def ternary_allowed?
+            !disable_syntax.include?("ternary")
+          end
+
+          def safe_navigation_allowed?
+            !disable_syntax.include?("safe_navigation")
+          end
+
+          def endless_methods_allowed?
+            !disable_syntax.include?("endless_methods")
+          end
+
+          def arguments_forwarding_allowed?
+            !disable_syntax.include?("arguments_forwarding")
+          end
+
+          def arguments_forwarding?(send_node)
+            send_node.arguments.any? do |arg|
+              (arg.block_pass_type? && arg.source == "&") || # foo(&)
+                arg.forwarded_args_type? || # foo(...)
+                arg.forwarded_restarg_type? || # foo(*)
+                (arg.hash_type? && arg.source == "**") # foo(**)
+            end
+          end
+
+          def numbered_parameters_allowed?
+            !disable_syntax.include?("numbered_parameters")
+          end
+
+          def pattern_matching_allowed?
+            !disable_syntax.include?("pattern_matching")
+          end
+
+          def shorthand_hash_syntax_allowed?
+            !disable_syntax.include?("shorthand_hash_syntax")
+          end
+
+          def and_or_not_allowed?
+            !disable_syntax.include?("and_or_not")
+          end
+
+          def until_allowed?
+            !disable_syntax.include?("until")
+          end
+
+          def percent_literals_allowed?
+            !disable_syntax.include?("percent_literals")
+          end
+
+          def str_percent_literal?(node)
+            if node.loc.respond_to?(:begin) && node.loc.begin
+              node.loc.begin.source.start_with?("%")
+            end
+          end
+
+          def disable_syntax
+            @disable_syntax ||= begin
+              supported_disable_syntax = cop_config.fetch("SupportedDisableSyntax", [])
+              disable_syntax = cop_config.fetch("DisableSyntax", [])
+              if (extra_syntax = disable_syntax - supported_disable_syntax).any?
+                raise "Unknown `DisableSyntax` value(s): #{extra_syntax.join(', ')}"
+              end
+
+              disable_syntax
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rubocop/disable_syntax/inject.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# The original code is from https://github.com/rubocop/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+# See https://github.com/rubocop/rubocop-rspec/blob/master/MIT-LICENSE.md
+module RuboCop
+  module DisableSyntax
+    # 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).tap(&:make_excludes_absolute)
+        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/rubocop/disable_syntax/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module DisableSyntax
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop/disable_syntax.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "disable_syntax/version"
+
+module RuboCop
+  module DisableSyntax
+    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/rubocop-disable_syntax.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+require_relative "rubocop/disable_syntax"
+require_relative "rubocop/disable_syntax/version"
+require_relative "rubocop/disable_syntax/inject"
+
+RuboCop::DisableSyntax::Inject.defaults!
+
+require_relative "rubocop/cop/style/disable_syntax"

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-disable_syntax
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- fatkodima
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.50'
+description:
+email:
+- fatkodima123@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-disable_syntax.rb
+- lib/rubocop/cop/style/disable_syntax.rb
+- lib/rubocop/disable_syntax.rb
+- lib/rubocop/disable_syntax/inject.rb
+- lib/rubocop/disable_syntax/version.rb
+homepage: https://github.com/fatkodima/rubocop-disable_syntax
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/fatkodima/rubocop-disable_syntax
+  source_code_uri: https://github.com/fatkodima/rubocop-disable_syntax
+  changelog_uri: https://github.com/fatkodima/rubocop-disable_syntax/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A RuboCop plugin that allows to disable some unfavorite ruby syntax, such
+  as `unless`, safe navigation etc.
+test_files: []