rubocop-mangrove 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c0b629613576ae8b27696cb189bffaedd892ee5f428c3aaa31eeb2da988318ee
+  data.tar.gz: 26f618e9b5b17794dc0c1b3fd6b85619ce29b9699efb4cceb57d675cc62e1fc2
+SHA512:
+  metadata.gz: 8d5ff48c0c8d3a8ae9156820033c6a75b2d12dcb0c4803f8887dde7a263cf5b6b5bbffcd0f918ef7db1bfc271c6f65210990668e21c2b0ff784c46c646175723
+  data.tar.gz: 277aea0678c9dd5ac14cd2653544600f0fd93a7856b433cf7fc6b047e1c3a1983e96a95b76cefc49b2abfa00fdc60fd18c74e8d92dda9cac6fe3c4030e1ab67d

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,58 @@
+Naming/FileName:
+ Exclude:
+   - lib/rubocop-mangrove.rb
+
+AllCops:
+  TargetRubyVersion: 3.2
+
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/LineLength:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+
+Style/BlockDelimiters:
+  EnforcedStyle: always_braces
+  AllowedMethods:
+  - describe
+  - context
+  - it
+
+Style/Documentation:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+

data/README.md

@@ -0,0 +1,12 @@
+```
+git config core.hooksPath hooks
+bundle exec rspec -f d
+bundle exec rubocop -DESP
+bundle exec srb typecheck
+bundle exec ordinare --check
+bundle exec ruboclean
+bundle exec yardoc -o docs/ --plugin yard-sorbet
+rake build
+rake release
+```
+

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task(:check) {
+  system("bundle exec ordinare --check") &&
+    system("bundle exec rubocop -DESP") &&
+    system("bundle exec rspec -f d")
+}
+
+task default: :check

data/config/default.yml

@@ -0,0 +1,6 @@
+# Write it!
+
+Mangrove/UnhandledUnwrap:
+  Description: 'Unhandled calling of #unwrap!'
+  Enabled: true
+  VersionAdded: "0.1.0"

data/lib/rubocop/cop/mangrove/unhandled_unwrap.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "parser/current"
+require "unparser"
+
+module RuboCop
+  module Cop
+    module Mangrove
+      class UnhandledUnwrap < Base
+        extend ::RuboCop::Cop::AutoCorrector
+
+        MSG = "unwrap! is used inside method that is not rescuing ControlSignal"
+
+        def on_def(node)
+          exam(node)
+        end
+
+        def on_defs(node)
+          exam(node)
+        end
+
+        # def on_block(node)
+        #  examinate(node)
+        # end
+
+        private
+
+        def_node_matcher :calling_unwrap?, <<~PATTERN
+          `(send ... :unwrap!)
+        PATTERN
+
+        def_node_matcher :rescuing_signal?, <<~PATTERN
+          (rescue <(resbody <(array <(const ... :ControlSignal) ...>) ...>) ...>)
+        PATTERN
+
+        def_node_matcher :rescuing_signal_with_ensure?, <<~PATTERN
+          (ensure <(rescue <(resbody <(array <(const ... :ControlSignal) ...>) ...>) ...>) ...>)
+        PATTERN
+
+        def exam(node)
+          return unless calling_unwrap?(node)
+
+          rescuing_control_signal = node.children.any? { |child_node|
+            rescuing_signal?(child_node) || rescuing_signal_with_ensure?(child_node)
+          }
+
+          return if rescuing_control_signal
+
+          add_offense(node) { |corrector|
+            source = node.source
+            ast = ::Parser::CurrentRuby.parse(source)
+            source_buffer = ::Parser::Source::Buffer.new("", source: node.source)
+            rewriter = ::RuboCop::Cop::Mangrove::UnhandledUnwrap::Rewriter.new
+            corrector.replace(node, rewriter.rewrite(source_buffer, ast))
+          }
+        end
+
+        class Rewriter < Parser::TreeRewriter
+          def on_def(node)
+            indent = node.location.expression.begin.column
+            code = ::Unparser.unparse(with_rescue(node))
+            indented_code = code.lines.map.with_index { |line, index| index.zero? ? line : (" " * indent) + line }
+            replace(node.location.expression, indented_code)
+          end
+
+          def on_defs(node)
+            indent = node.location.expression.begin.column
+            code = ::Unparser.unparse(with_rescue(node))
+            indented_code = code.lines.map.with_index { |line, index| index.zero? ? line : (" " * indent) + line }
+            replace(node.location.expression, indented_code)
+          end
+
+          def on_block(node)
+            indent = node.location.expression.begin.column
+            code = ::Unparser.unparse(with_rescue(node))
+            indented_code = code.lines.map.with_index { |line, index| index.zero? ? line : (" " * indent) + line }
+            replace(node.location.expression, indented_code)
+          end
+
+          private
+
+          def rescue_node(body)
+            ::Parser::AST::Node.new(:rescue, [
+              body,
+              nil
+            ])
+          end
+
+          def add_rescue_node(parent)
+            children = parent.children.dup
+            # nilの場合はblockをこちらで包む必要がある
+            # nilではない場合はすでに包まれているのでこちらで包む必要はない
+            method_body_index = children.length - 1
+            method_body = children[method_body_index]
+
+            children[method_body_index] = rescue_node(method_body)
+            parent.updated(nil, children)
+          end
+
+          def use_rescue_node(parent)
+            children = parent.children.dup
+
+            rescue_index = children.find_index { _1.respond_to?(:type) && _1.type == :rescue }
+
+            rescue_node_on_ast = children[rescue_index]
+            updated_rescue_node_on_ast = insert_rescue_body_node(rescue_node_on_ast)
+            children[rescue_index] = updated_rescue_node_on_ast
+
+            parent.updated(nil, children)
+          end
+
+          def insert_rescue_body_node(rescue_node)
+            rescue_node_children = rescue_node.children.dup
+            rescue_body_node_index = rescue_node_children.find_index { _1.respond_to?(:type) && _1.type == :resbody }
+
+            # when rescue is newly inserted
+            rescue_body_node_index = rescue_node_children.length - 1 if rescue_body_node_index.nil?
+
+            rescue_node_children.insert(rescue_body_node_index, rescue_body_node)
+            rescue_node.updated(nil, rescue_node_children)
+          end
+
+          def use_ensure_node(ensure_node)
+            # ensureのchildrenの最後から2番目（最後のrescue）に追加する
+
+            ensure_node_children = ensure_node.children.dup
+
+            rescue_index = ensure_node_children.find_index { _1.respond_to?(:type) && _1.type == :rescue }
+
+            ensure_node = add_rescue_node(ensure_node) if rescue_index.nil?
+
+            use_rescue_node(ensure_node)
+          end
+
+          def with_rescue(parent)
+            children = parent.children.dup
+            ensure_index = children.find_index { _1.respond_to?(:type) && _1.type == :ensure }
+
+            if ensure_index.nil?
+              rescue_index = children.find_index { _1.respond_to?(:type) && _1.type == :rescue }
+
+              parent = add_rescue_node(parent) if rescue_index.nil?
+
+              use_rescue_node(parent)
+            else
+              updated_ensure_node = use_ensure_node(children[ensure_index])
+              children[ensure_index] = updated_ensure_node
+              parent.updated(nil, children)
+            end
+          end
+
+          def rescue_body_node
+            ::Parser::AST::Node.new(:resbody, [
+              ::Parser::AST::Node.new(:array, [
+                ::Parser::AST::Node.new(:const, [
+                  ::Parser::AST::Node.new(:const, [
+                    ::Parser::AST::Node.new(:const, [
+                      ::Parser::AST::Node.new(:cbase),
+                      :Mangrove
+                    ]),
+                    :ControlFlow
+                  ]),
+                  :ControlSignal
+                ])
+              ]),
+              ::Parser::AST::Node.new(:lvasgn, [:e]),
+              ::Parser::AST::Node.new(:send, [
+                ::Parser::AST::Node.new(:const, [
+                  ::Parser::AST::Node.new(:const, [
+                    ::Parser::AST::Node.new(:const, [
+                      ::Parser::AST::Node.new(:cbase),
+                      :Mangrove
+                    ]),
+                    :Result
+                  ]),
+                  :Err
+                ]),
+                :new,
+                ::Parser::AST::Node.new(:send, [
+                  ::Parser::AST::Node.new(
+                    :lvar, [:e]
+                  ),
+                  :inner_value
+                ])
+              ])
+            ])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mangrove_cops.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "mangrove/unhandled_unwrap"

data/lib/rubocop/mangrove/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 Mangrove
+    # 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/mangrove/version.rb

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

data/lib/rubocop/mangrove.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "mangrove/version"
+
+module RuboCop
+  module Mangrove
+    class Error < StandardError; end
+    # Your code goes here...
+    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-mangrove.rb

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

data/sig/rubocop/mangrove.rbs

@@ -0,0 +1,6 @@
+module Rubocop
+  module Mangrove
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-mangrove
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kazuma Murata
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Type Utility for Ruby.
+email:
+- kazzix14@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- README.md
+- Rakefile
+- config/default.yml
+- lib/rubocop-mangrove.rb
+- lib/rubocop/cop/mangrove/unhandled_unwrap.rb
+- lib/rubocop/cop/mangrove_cops.rb
+- lib/rubocop/mangrove.rb
+- lib/rubocop/mangrove/inject.rb
+- lib/rubocop/mangrove/version.rb
+- sig/rubocop/mangrove.rbs
+homepage: https://github.com/kazzix14/mangrove
+licenses: []
+metadata:
+  homepage_uri: https://github.com/kazzix14/mangrove
+  source_code_uri: https://github.com/kazzix14/rubocop-mangrove
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.18
+signing_key:
+specification_version: 4
+summary: Type Utility for Ruby.
+test_files: []