rubocop-greenroom 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2bc6ffc2c1db29089a00155da4b0146f48242684cf671bf8ee9a13768c2ac32a
+  data.tar.gz: 238286bb8cf29ae8dd6fc0da0da83862c8ebd5de462da05097f6d63254c30e62
+SHA512:
+  metadata.gz: 6f8f35105863b02830d0e12de9705d950133f0e671046d60c562161e1e4a3171e9b72aeac31e562c8ace4040dce0837c8d6173a202efe6979072681a0afe338e
+  data.tar.gz: 41c77a641b78a0b7ddfcf0c7c159fccb219f66ddd1b635f4140d0cfde0e02cce1930ec11e97d91b5521a54fe8761f260c48e916763dab67ed714d3c63cf34e9d

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-08-22
+
+- Add `Greenroom/ScienceBlockShape`, which requires `use`, `try`, and
+  `compare` once each and in that order inside a `Scientist.run` block.
+- Add `Greenroom/UnsafeScienceBody`, which reports a `return` or a `binding`
+  that moves into a `use` or `try` block.
+- Add `Greenroom/CandidateIsPrivate`, which requires the method a `try` block
+  calls to be private when the same file defines it.
+- Ship the cops as a lint_roller plugin, so a host adds them through the
+  `plugins` key of its RuboCop configuration.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Greenroom contributors
+
+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,18 @@
+# rubocop-greenroom
+
+`rubocop-greenroom` reports structural problems that RuboCop can identify from one Ruby file.
+
+Add the plugin to the host application's `.rubocop.yml`:
+
+```yaml
+plugins:
+  - rubocop-greenroom
+```
+
+The plugin enables three cops:
+
+- `Greenroom/ScienceBlockShape` requires one `use`, one `try`, and one `compare` call in that order.
+- `Greenroom/UnsafeScienceBody` reports unsafe `return` and `binding` expressions in `use` and `try` bodies.
+- `Greenroom/CandidateIsPrivate` reports a visible same-class candidate definition that is public or protected.
+
+These cops inspect one file. A separate diff checker verifies that a `use` body preserves the previous method body.

data/config/default.yml

@@ -0,0 +1,14 @@
+Greenroom/ScienceBlockShape:
+  Description: Requires use, try, and compare once, in that order.
+  Enabled: true
+  VersionAdded: '0.1'
+
+Greenroom/UnsafeScienceBody:
+  Description: Rejects return and binding in science bodies when they change behavior.
+  Enabled: true
+  VersionAdded: '0.1'
+
+Greenroom/CandidateIsPrivate:
+  Description: Requires a same-class candidate method to be private when its definition is visible.
+  Enabled: true
+  VersionAdded: '0.1'

data/lib/rubocop/cop/greenroom/candidate_is_private.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Greenroom
+      # Requires the candidate method that `try` calls to be private.
+      #
+      # A candidate is scaffolding. Once the experiment wins, a later change
+      # folds the candidate into the method body and deletes the scaffolding. A
+      # public candidate invites a caller from outside the class, and that
+      # deletion then breaks the caller. A private one keeps the deletion
+      # inside the class that owns it.
+      #
+      # The cop answers only when this file shows the answer: the `try` body
+      # must be one call to the object itself, and the definition must sit in
+      # the same class. A definition in another file leaves this cop quiet,
+      # because the gate that reads the whole change decides that case.
+      class CandidateIsPrivate < Base
+        include VisibilityHelp
+
+        MSG = "A candidate method must be private."
+
+        def on_block(node)
+          return unless science_try_block?(node)
+
+          candidate_call = node.body
+          return unless candidate_call&.send_type?
+          return unless candidate_call.receiver.nil? || candidate_call.receiver.self_type?
+
+          class_node = node.each_ancestor.find(&:class_type?)
+          return unless class_node
+
+          definition = candidate_definition(class_node, candidate_call.method_name)
+          return unless definition
+          return if node_visibility(definition) == :private
+
+          add_offense(node)
+        end
+
+        private
+
+        def science_try_block?(node)
+          return false unless node.send_node.method?(:try)
+
+          science_block = node.each_ancestor.find(&:block_type?)
+          return false unless science_block
+
+          science_send = science_block.send_node
+          receiver = science_send.receiver
+          return false unless science_send.method?(:run) && receiver&.const_name == "Scientist"
+
+          try_receiver = node.send_node.receiver
+          argument_name = science_block.arguments.one? && science_block.arguments.first.children.first
+          try_receiver&.lvar_type? && try_receiver.children.first == argument_name
+        end
+
+        def candidate_definition(class_node, method_name)
+          class_node.each_descendant(:def).find do |definition|
+            definition.method_name == method_name &&
+              definition.each_ancestor.find(&:class_type?) == class_node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/greenroom/science_block_shape.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Greenroom
+      # Requires a `Scientist.run` block to hold `use`, `try`, and `compare`,
+      # once each, in that order, and to hold nothing else.
+      #
+      # The order carries weight beyond taste. The gate that decides whether a
+      # change may merge compares the method body before the change against the
+      # body inside `use`. A fixed shape lets it find `use` directly, and a
+      # free arrangement would put a search in front of that comparison. A
+      # reader who wants to write the shape by hand also gets one form to copy
+      # rather than several.
+      #
+      # This cop reports what one file shows, so silence means that this cop
+      # cannot tell rather than that a change is accepted.
+      class ScienceBlockShape < Base
+        MSG = "A Scientist.run block must contain use, try, and compare once, in that order."
+
+        def on_block(node)
+          return unless science_block?(node)
+
+          calls = body_expressions(node).map { |expression| science_call(expression, node) }
+          add_offense(node.send_node) unless calls == %i[use try compare]
+        end
+
+        private
+
+        def science_block?(node)
+          send_node = node.send_node
+          receiver = send_node.receiver
+          send_node.method?(:run) && receiver&.const_type? && receiver.const_name == "Scientist"
+        end
+
+        def body_expressions(node)
+          body = node.body
+          return [] unless body
+
+          body.begin_type? ? body.children : [body]
+        end
+
+        def science_call(expression, science_block)
+          return unless expression.block_type?
+
+          send_node = expression.send_node
+          receiver = send_node.receiver
+          argument_name = science_block.arguments.one? && science_block.arguments.first.children.first
+          return unless receiver&.lvar_type? && receiver.children.first == argument_name
+
+          send_node.method_name
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/greenroom/unsafe_science_body.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Greenroom
+      # Rejects the two constructs that change meaning when a method body moves
+      # into a science block.
+      #
+      # A greenroom change moves an existing body, unchanged, into the `use`
+      # block. Most constructs survive that move: a trial of `yield`, of
+      # `rescue` and `ensure` written directly in the method, of `__method__`,
+      # of local variables, and of a constant read from the same lexical place,
+      # each behaved the same before and after the move. Two did not, and this
+      # cop names those two. The trial covered one form of each construct, so
+      # treat the list as measured rather than complete.
+      #
+      # `return` leaves the enclosing method from inside the block, so the
+      # comparison and the publication never run, and the experiment reports
+      # nothing while appearing to work.
+      #
+      # `binding` reports the block's local variables rather than the method's,
+      # so the same expression describes a different scope after the move.
+      #
+      # This cop reports what one file shows. The gate that decides whether a
+      # change may merge reads the version before the change as well, so
+      # silence here means that this cop cannot tell, rather than that a change
+      # is accepted.
+      class UnsafeScienceBody < Base
+        RETURN_MESSAGE = "A return in a science body bypasses comparison and publication."
+        BINDING_MESSAGE = "A binding in a science body observes the block scope."
+
+        def on_return(node)
+          add_offense(node, message: RETURN_MESSAGE) if unsafe_return?(node)
+        end
+
+        def on_send(node)
+          return unless node.receiver.nil? && node.method?(:binding)
+          return unless science_body_ancestor(node)
+
+          add_offense(node, message: BINDING_MESSAGE)
+        end
+
+        private
+
+        # Walks outward and answers for the nearest scope that a `return`
+        # leaves. A `return` inside a nested `def` or a lambda returns from
+        # that def or that lambda, and it goes to the same place before and
+        # after the move, so this cop stays quiet. A `proc` and an ordinary
+        # block both return from the enclosing method, so they carry the same
+        # hazard as a bare `return` and this cop reports them.
+        def unsafe_return?(node)
+          node.each_ancestor do |ancestor|
+            return false if ancestor.def_type? || ancestor.defs_type?
+            return false if ancestor.block_type? && ancestor.lambda?
+            return true if science_body_block?(ancestor)
+          end
+
+          false
+        end
+
+        def science_body_ancestor(node)
+          node.each_ancestor.find { |ancestor| science_body_block?(ancestor) }
+        end
+
+        # A block counts as a science body when it is `use` or `try` called on
+        # the parameter that `Scientist.run` yielded. Matching the parameter
+        # rather than the method name alone keeps the cop quiet about an
+        # unrelated `use` or `try` that happens to sit inside another block.
+        def science_body_block?(node)
+          return false unless node.block_type? && %i[use try].include?(node.send_node.method_name)
+
+          science_block = node.each_ancestor.find(&:block_type?)
+          return false unless science_block
+
+          science_send = science_block.send_node
+          receiver = science_send.receiver
+          return false unless science_send.method?(:run) && receiver&.const_name == "Scientist"
+
+          body_receiver = node.send_node.receiver
+          argument_name = science_block.arguments.one? && science_block.arguments.first.children.first
+          body_receiver&.lvar_type? && body_receiver.children.first == argument_name
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/greenroom/plugin.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+require "pathname"
+
+module RuboCop
+  module Greenroom
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: "rubocop-greenroom",
+          version: VERSION,
+          homepage: "https://github.com/meganemura/greenroom",
+          description: "RuboCop rules for Greenroom science blocks"
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join("../../../config/default.yml")
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/greenroom/version.rb

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

data/lib/rubocop-greenroom.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require_relative "rubocop/greenroom/version"
+require_relative "rubocop/greenroom/plugin"
+require_relative "rubocop/cop/greenroom/science_block_shape"
+require_relative "rubocop/cop/greenroom/unsafe_science_body"
+require_relative "rubocop/cop/greenroom/candidate_is_private"

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-greenroom
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- meganemura
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.88'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.88'
+description: Checks the single-file structure of Greenroom science blocks.
+email:
+- meganemura@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-greenroom.rb
+- lib/rubocop/cop/greenroom/candidate_is_private.rb
+- lib/rubocop/cop/greenroom/science_block_shape.rb
+- lib/rubocop/cop/greenroom/unsafe_science_body.rb
+- lib/rubocop/greenroom/plugin.rb
+- lib/rubocop/greenroom/version.rb
+homepage: https://github.com/meganemura/greenroom
+licenses:
+- MIT
+metadata:
+  default_lint_roller_plugin: RuboCop::Greenroom::Plugin
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/meganemura/greenroom
+  source_code_uri: https://github.com/meganemura/greenroom
+  changelog_uri: https://github.com/meganemura/greenroom/blob/main/gems/rubocop-greenroom/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+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: 4.0.16
+specification_version: 4
+summary: RuboCop rules for Greenroom science blocks
+test_files: []