rubocop_spinel 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 181952a5cd39ea77e09f06705fa528e4809df649d9c5c4debfd9472bd2482969
-  data.tar.gz: 4f02b1d78610162c64abfba70f2931a0ff24d8f36290dc48c16dce1e931c83e8
+  metadata.gz: cb90d1e8bfc12fb703fdade6e8b05a163c5740166faaf0ebfee8ead533d5657d
+  data.tar.gz: 9fd52ef2c11aefb539f86884930d77953f153d071513d54e231a47ab6d791724
 SHA512:
-  metadata.gz: 96dd8ba28322ca56841c207f226114b735fcf7428f76889cc30bd783b0b95ea187b89336a63a1b1cbe75c6fcc6def4d133b0a1dc938d17697efffcac2a64aa3e
-  data.tar.gz: e13207e7ac428dbb3e00ae775aea510c2f7f7e89778c5f363cce637835993e31fd55a1b8f4643372405a3c479fc39c3c2e8dd559688def0290fcb0042f9e2ca4
+  metadata.gz: 32ff355cd84068325e7ae7aad49c4512c95539cab59d9d7bf6f346797d5ab1040681d432742a67c1436de4d600adde44f9f6edbe98c7927d52d4bef0bae7e022
+  data.tar.gz: b730ed44bd08d28dc7e1ceedd10498aaef9c633f5a676d29c13c7e72e4c57ecb1d50c8c79df300600cd389e5f0ecb3172c9b0d39d3b8b0f010e0b76300b83a71

data/.justfile

@@ -22,7 +22,8 @@ test:
   rake test
 
 test-spinel:
-  bundle exec rubocop -r ./lib/rubocop_spinel --only Spinel/Unsupported ../spinel/test ../spinel/spinel_codegen.rb
+  bundle exec rubocop -c test/test_spinel.yml -r ./lib/rubocop_spinel --only Spinel/Unsupported \
+    ../spinel/test ../spinel/benchmark/bm_send_bmethod.rb ../spinel/spinel_codegen.rb
 
 test-watch *ARGS:
   watchexec --stop-timeout=0 --clear clear just test "{{ARGS}}"

data/AGENTS.md

@@ -7,6 +7,7 @@
 - After changes, run `just check`
 - Use `just fmt` / `just lint`, not rubocop or prettier directly
 - Keep commit messages under 80 chars
+- PR titles/bodies: super succinct, 1-2 short sentences or 1-2 bullets max
 - Fail fast; don't be overly defensive
 
 ## Layout

data/README.md

@@ -36,12 +36,18 @@ class << self ...
 sample.rb:9:1: C: Spinel/Unsupported: Spinel does not support threads or mutexes.
 Thread.new { puts Example.bad }
 ^^^^^^
-````
+```
 
 ## Changelog
 
-#### 0.0.1 (unreleased)
+#### 0.2.0 (May '26)
 
-```
+- allow `recv.instance_eval { ... }` ([Spinel #15](https://github.com/matz/spinel/pull/15))
+- allow `def m(&block); instance_eval(&block); end` ([Spinel #124](https://github.com/matz/spinel/pull/124))
+- allow static `define_method(:name) { ... }` ([Spinel 26e6aae](https://github.com/matz/spinel/commit/26e6aae))
+- allow no-argument `module_function` in module bodies ([Spinel #295](https://github.com/matz/spinel/pull/295))
+- allow module singleton accessors ([Spinel #126](https://github.com/matz/spinel/issues/126))
 
-```
+#### 0.1.0 (Apr '26)
+
+- first release

data/lib/rubocop/cop/spinel/unsupported.rb

@@ -7,23 +7,23 @@ module RuboCop
         BANNED_METHODS = %i[
           class_eval
           const_get
-          define_method
           define_singleton_method
           eval
           extend
-          instance_eval
           method_missing
           module_eval
-          module_function
           public_send
           remove_method
           singleton_method
           undef_method
         ].freeze
-        RESTRICT_ON_SEND = (BANNED_METHODS + %i[prepend send]).freeze
+        RESTRICT_ON_SEND = (BANNED_METHODS + %i[define_method instance_eval module_function prepend send]).freeze
         TOP_LEVEL_CONSTS = %i[Mutex Thread].freeze
 
         def on_send(node)
+          return handle_define_method(node) if node.method_name == :define_method
+          return handle_instance_eval(node) if node.method_name == :instance_eval
+          return handle_module_function(node) if node.method_name == :module_function
           # `prepend` is only unsupported as a module/class feature.
           return handle_prepend(node) if node.method_name == :prepend
           return if allowed_send?(node)
@@ -40,11 +40,31 @@ module RuboCop
 
         # `class << self` compiles in Spinel but does not work correctly.
         def on_sclass(node)
+          return if supported_singleton_accessor?(node)
+
           add_offense(node, message: "Spinel does not support singleton classes.")
         end
 
         private
 
+        def handle_define_method(node)
+          return if supported_define_method?(node)
+
+          add_offense(node.loc.selector, message: message_for(:define_method))
+        end
+
+        def handle_instance_eval(node)
+          return if supported_instance_eval?(node)
+
+          add_offense(node.loc.selector, message: message_for(:instance_eval))
+        end
+
+        def handle_module_function(node)
+          return if supported_module_function?(node)
+
+          add_offense(node.loc.selector, message: message_for(:module_function))
+        end
+
         # Spinel rewrites receiver-style `obj.send(:name)` during parsing.
         def allowed_send?(node)
           node.method_name == :send && node.receiver && node.first_argument&.sym_type?
@@ -61,6 +81,68 @@ module RuboCop
           node.method_name == :prepend && node.receiver.nil?
         end
 
+        def supported_define_method?(node)
+          node.receiver.nil? && node.block_node && node.arguments.one? && node.first_argument&.sym_type?
+        end
+
+        def supported_module_function?(node)
+          node.receiver.nil? && !node.arguments? && module_body?(node)
+        end
+
+        def module_body?(node)
+          singleton_owner(node)&.module_type?
+        end
+
+        # Spinel supports `recv.instance_eval { ... }` and the exact
+        # `def m(&block); instance_eval(&block); end` trampoline shape.
+        def supported_instance_eval?(node)
+          supported_instance_eval_block?(node) || supported_instance_eval_trampoline?(node)
+        end
+
+        def supported_instance_eval_block?(node)
+          node.receiver && node.block_node && !node.arguments?
+        end
+
+        def supported_instance_eval_trampoline?(node)
+          return false unless node.receiver.nil? && node.arguments.one?
+
+          block_pass = node.first_argument
+          return false unless block_pass&.block_pass_type?
+
+          forwarded = block_pass.children.first
+          return false unless forwarded&.lvar_type?
+
+          method_def = node.each_ancestor(:def, :defs).first
+          return false unless method_def&.body == node
+
+          block_arg = method_def.arguments.children.first
+          return false unless method_def.arguments.children.one? && block_arg&.blockarg_type?
+
+          forwarded.children.first == block_arg.children.first
+        end
+
+        def supported_singleton_accessor?(node)
+          return false unless node.children.first&.self_type?
+          return false unless singleton_owner(node)&.module_type?
+
+          singleton_body(node).all? { supported_singleton_accessor_call?(_1) }
+        end
+
+        def singleton_owner(node)
+          node.each_ancestor.find { _1.class_type? || _1.module_type? }
+        end
+
+        def singleton_body(node)
+          return [] unless node.body
+
+          node.body.begin_type? ? node.body.children : [node.body]
+        end
+
+        def supported_singleton_accessor_call?(node)
+          node.send_type? && node.receiver.nil? && node.method?(:attr_accessor) &&
+            node.arguments.all?(&:sym_type?)
+        end
+
         def top_level_const?(node)
           node.namespace.nil? || node.namespace.cbase_type?
         end

data/lib/rubocop/spinel/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Spinel
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop_spinel
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - gurgeous
@@ -88,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Custom RuboCop cops for Spinel compatibility.
 test_files: []