rubocop-openproject 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 32626e1f367406ced02e2379b7a390a9c8d9012ce29174a7aefa3cfae33375d9
+  data.tar.gz: 31d990582ddf0efa6ae5f3905d2024bb4dc525160061315a983ea510f45f9fe2
+SHA512:
+  metadata.gz: 2b488bcfd9c6dd063ef385c69afe15ba12e5a7ea0419065796e392e8564d1c42e02ca9f78288e9f7b6fcb7c8ed0e81ea03a179c886f0742faf42ca4dd8346d43
+  data.tar.gz: 0b913ebb1d53d3c90f9faa66cc21c044d4b076d23495dbd37042c5b91c78e9d41b212db7972b38502c7cf09dd7040104d15774094c312819eec15c379e1a8ff7

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.3
+  NewCops: enable
+
+Naming/FileName:
+ Exclude:
+   - lib/rubocop-openproject.rb
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Metrics/BlockLength:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-07-05
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Christophe Bliard
+
+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,35 @@
+# rubocop-openproject
+
+This is a collection of the cops written to be used in the
+[OpenProject repository](https://github.com/opf/openproject).
+
+## Installation
+
+Add this gem to the `Gemfile`:
+
+```ruby
+gem "rubocop-openproject", require: false
+```
+
+Run `bundle install`.
+
+Finally in the `.rubocop.yml` file, add the following:
+
+```
+require:
+  - rubocop-openproject
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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/opf/rubocop-openproject.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList["spec/**/*_spec.rb"]
+end
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]
+
+desc "Generate a new cop with a template"
+task :new_cop, [:cop] do |_task, args|
+  require "rubocop"
+
+  cop_name = args.fetch(:cop) do
+    warn "usage: bundle exec rake new_cop[Department/Name]"
+    exit!
+  end
+
+  generator = RuboCop::Cop::Generator.new(cop_name)
+
+  generator.write_source
+  generator.write_spec
+  generator.inject_require(root_file_path: "lib/rubocop/cop/open_project_cops.rb")
+  generator.inject_config(config_file_path: "config/default.yml")
+
+  puts generator.todo
+end

data/config/default.yml

@@ -0,0 +1,14 @@
+OpenProject/AddPreviewForViewComponent:
+  Description: 'Add a preview for the ViewComponent.'
+  Enabled: true
+  VersionAdded: '0.1.0'
+
+OpenProject/NoDoEndBlockWithRSpecCapybaraMatcherInExpect:
+  Description: 'Use `{ .. }` syntax with Capybara rspec matchers instead of `do .. end`.'
+  Enabled: true
+  VersionAdded: '0.1.0'
+
+OpenProject/UseServiceResultFactoryMethods:
+  Description: 'Use ServiceResult factory methods instead of ServiceResult.new.'
+  Enabled: true
+  VersionAdded: '0.1.0'

data/lib/rubocop/cop/open_project/add_preview_for_view_component.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module OpenProject
+      # A lookbook preview must exist for each ViewComponent.
+      #
+      # Components are located in `app/components` and previews are searched in
+      # `lookbook/previews`.
+      class AddPreviewForViewComponent < Base
+        COMPONENT_PATH = "/app/components/"
+        PREVIEW_PATH = "/lookbook/previews/"
+
+        def on_class(node)
+          path = node.loc.expression.source_buffer.name
+          return unless path.include?(COMPONENT_PATH) && path.end_with?(".rb")
+
+          preview_path = path.sub(COMPONENT_PATH, PREVIEW_PATH).sub(".rb", "_preview.rb")
+
+          return if File.exist?(preview_path)
+
+          message = "Missing Lookbook preview for #{path}. Expected preview to exist at #{preview_path}."
+          add_offense(node.loc.name, message:)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/open_project/no_do_end_block_with_rspec_capybara_matcher_in_expect.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module OpenProject
+      # As +do .. end+ block has less precedence than method call, a +do .. end+
+      # block at the end of a rspec matcher will be an argument to the +to+ method,
+      # which is not handled by Capybara matchers (teamcapybara/capybara/#2616).
+      #
+      # @example
+      #
+      #   # bad
+      #   expect(page).to have_selector("input") do |input|
+      #     input.value == "hello world"
+      #   end
+      #
+      #   # good
+      #   expect(page).to have_selector("input") { |input| input.value == "hello world" }
+      #
+      #   # good
+      #   expect(page).to have_selector("input", value: "hello world")
+      #
+      #   # good
+      #   match_input_with_hello_world = have_selector("input") do |input|
+      #     input.value == "hello world"
+      #   end
+      #   expect(page).to match_input_with_hello_world
+      #
+      #   # good
+      #   expect(foo).to have_received(:bar) do |arg|
+      #     arg == :baz
+      #   end
+      #
+      class NoDoEndBlockWithRSpecCapybaraMatcherInExpect < Base
+        CAPYBARA_MATCHER_METHODS = %w[selector css xpath text title current_path link button
+                                      field checked_field unchecked_field select table
+                                      sibling ancestor].flat_map do |matcher_type|
+                                        ["have_#{matcher_type}", "have_no_#{matcher_type}"]
+                                      end
+
+        MSG = "The `do .. end` block is associated with `to` and not with Capybara matcher `%<matcher_method>s`."
+
+        def_node_matcher :expect_to_with_block?, <<~PATTERN
+          # ruby-parse output
+          (block
+            (send
+              (send nil? :expect ...)
+              :to
+              ...
+            )
+            ...
+          )
+        PATTERN
+
+        def_node_matcher :rspec_matcher, <<~PATTERN
+          (send
+            (send nil? :expect...)
+            :to
+            (:send nil? $_matcher_method ...)
+          )
+        PATTERN
+
+        def on_block(node)
+          return unless expect_to_with_block?(node)
+          return unless capybara_matcher?(node)
+
+          add_offense(offense_range(node), message: offense_message(node))
+        end
+
+        private
+
+        def capybara_matcher?(node)
+          matcher_name = node.send_node.arguments.first.method_name.to_s
+          CAPYBARA_MATCHER_METHODS.include?(matcher_name)
+        end
+
+        def offense_range(node)
+          node.send_node.loc.selector.join(node.loc.end)
+        end
+
+        def offense_message(node)
+          rspec_matcher(node.send_node) do |matcher_method|
+            format(MSG, matcher_method:)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/open_project/use_service_result_factory_methods.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module OpenProject
+      # Favor usage of ServiceResult factory methods instead of using
+      # `success: true/false` in constructor.
+      #
+      # @example
+      #   # bad
+      #   ServiceResult.new(success: true, result: 'result')
+      #
+      #   # bad
+      #   ServiceResult.new(success: false, errors: ['error'])
+      #
+      #   # good
+      #   ServiceResult.success(result: 'result')
+      #
+      #   # good
+      #   ServiceResult.failure(errors: ['error'])
+      #
+      #   # good
+      #   ServiceResult.new(success: some_value)
+      #
+      #   # good
+      #   ServiceResult.new(**kwargs)
+      class UseServiceResultFactoryMethods < Base
+        extend AutoCorrector
+
+        MSG = "Use ServiceResult.%<factory_method>s(...) instead of ServiceResult.new(success: %<success_value>s, ...)."
+        MSG_IMPLICIT_FAILURE = "Use ServiceResult.failure instead of ServiceResult.new."
+
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        def_node_matcher :service_result_constructor?, <<~PATTERN
+          (send
+            $(const nil? :ServiceResult) :new
+            ...
+          )
+        PATTERN
+
+        def_node_matcher :constructor_with_explicit_success_arg, <<~PATTERN
+          (send
+            (const nil? :ServiceResult) :new
+            (hash
+              <
+                $(pair (sym :success) ({true | false}))
+                ...
+              >
+            )
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless service_result_constructor?(node)
+
+          if success_argument_present?(node)
+            add_offense_if_explicit_success_argument(node)
+          elsif success_argument_possibly_present?(node)
+            return # rubocop:disable Style/RedundantReturn
+          else
+            add_offense_for_implicit_failure(node)
+          end
+        end
+
+        private
+
+        def success_argument_present?(node)
+          hash_argument = node.arguments.find(&:hash_type?)
+          return false unless hash_argument
+
+          hash_argument.keys.any? { |key| key.sym_type? && key.value == :success }
+        end
+
+        def success_argument_possibly_present?(node)
+          return true if node.arguments.find(&:forwarded_args_type?)
+
+          hash_argument = node.arguments.find(&:hash_type?)
+          return false unless hash_argument
+
+          hash_argument.children.any?(&:kwsplat_type?)
+        end
+
+        def add_offense_if_explicit_success_argument(node)
+          constructor_with_explicit_success_arg(node) do |success_argument|
+            message = format(MSG, success_value: success_value(success_argument),
+                                  factory_method: factory_method(success_argument))
+            add_offense(success_argument, message:) do |corrector|
+              corrector.replace(node.loc.selector, factory_method(success_argument))
+              corrector.remove(removal_range(node, success_argument))
+            end
+          end
+        end
+
+        def add_offense_for_implicit_failure(node)
+          add_offense(node.loc.selector, message: MSG_IMPLICIT_FAILURE) do |corrector|
+            corrector.replace(node.loc.selector, "failure")
+          end
+        end
+
+        def success_value(success_argument)
+          success_argument.value.source
+        end
+
+        def factory_method(success_argument)
+          success_argument.value.source == "true" ? "success" : "failure"
+        end
+
+        def removal_range(node, success_argument)
+          if sole_argument?(success_argument)
+            all_parameters_range(node)
+          else
+            success_parameter_range(success_argument)
+          end
+        end
+
+        def sole_argument?(arg)
+          arg.parent.loc.expression == arg.loc.expression
+        end
+
+        def all_parameters_range(node)
+          node.loc.selector.end.join(node.loc.expression.end)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def success_parameter_range(success_argument)
+          if success_argument.left_sibling
+            success_argument.left_sibling.loc.expression.end.join(success_argument.loc.expression.end)
+          else
+            success_argument.loc.expression.begin.join(success_argument.right_sibling.loc.expression.begin)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/rubocop/cop/open_project_cops.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "open_project/add_preview_for_view_component"
+require_relative "open_project/no_do_end_block_with_rspec_capybara_matcher_in_expect"
+require_relative "open_project/use_service_result_factory_methods"

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

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

data/lib/rubocop/open_project.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "open_project/version"
+require "yaml"
+
+module RuboCop
+  # This module contains custom RuboCop cops and configuration for the OpenProject project.
+  # It loads the default configuration from a YAML file and sets up necessary constants.
+  module OpenProject
+    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-openproject.rb

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

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-openproject
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- OpenProject GmbH
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-07-05 00:00:00.000000000 Z
+dependencies:
+- !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'
+description: Custom cops written for OpenProject
+email:
+- info@openproject.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/default.yml
+- lib/rubocop-openproject.rb
+- lib/rubocop/cop/open_project/add_preview_for_view_component.rb
+- lib/rubocop/cop/open_project/no_do_end_block_with_rspec_capybara_matcher_in_expect.rb
+- lib/rubocop/cop/open_project/use_service_result_factory_methods.rb
+- lib/rubocop/cop/open_project_cops.rb
+- lib/rubocop/open_project.rb
+- lib/rubocop/open_project/inject.rb
+- lib/rubocop/open_project/version.rb
+homepage: https://github.com/opf/rubocop-openproject
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/opf/rubocop-openproject
+  source_code_uri: https://github.com/opf/rubocop-openproject
+  changelog_uri: https://github.com/opf/rubocop-openproject/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.14
+signing_key:
+specification_version: 4
+summary: RuboCop cops for OpenProject
+test_files: []