rubocop-crystal 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbaf055e01ff70c7c189f9b6a73c94bf6ffbc50d7c0a335103177b5b8b52fb4a
-  data.tar.gz: ff97d8c93dd042f6dc9288a4adc97dc975c953fda4cc3e4c4af3b7ca7b8fb795
+  metadata.gz: 3e7cede16a18df18a0021747a7a5305d1503af8229d0a2790242b3b4ac5e27c2
+  data.tar.gz: 2373953ed41151d8a00749f28db4ac84ff144db91e02413b50e71f4d97c5627b
 SHA512:
-  metadata.gz: 479c9f1a1c18e2147ebbbc22e8c4aa77d683e5601653d3ddbfa565ba7bee08d94aef3b92e1fabe41afcd5250a529a0a36672623db22a4206e840a40176d7fa4e
-  data.tar.gz: 262807664ebcfa6e7ae82af586e2c1535378184bfc20cb722932d62a6e6f75465acbd6781b79720a5cfec94460dea4ed31d55080f5192b1203b23c15ccf5b34a
+  metadata.gz: e33199a6a2a74eb3e7739f0b2355b58e65b89d6bcc9001c4c62e246eea89fa7cb098dfb274da12b7dac220f90de5d672d94f2abb27d078c8a2ec273f8b81f990
+  data.tar.gz: bccb8bb8fba84d6b2208cb578bcbcc7e7a3c6c2202cee707e8fe511018ff128cb4dd6113aefd11912df78a9971183ea8497fe344b684002aa3144279756732c4

data/.rubocop.yml

@@ -15,6 +15,7 @@ Gemspec/RequiredRubyVersion:
 
 InternalAffairs/OnSendWithoutOnCSend:
   Exclude:
+    - 'lib/rubocop/cop/crystal/require_at_top_level.rb'
     - 'lib/rubocop/cop/crystal/require_relative.rb'
 
 Layout/LineLength:

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.0.4 (2025-09-21)
+
+### New features
+
+* Add Crystal/EnumerableReduce cop ([@zopolis4][])
+* Add Crystal/EnumerableSize cop ([@zopolis4][])
+* Add Crystal/FileReadLines cop ([@zopolis4][])
+* Add Crystal/MethodReturningChar cop ([@zopolis4][])
+* Add Crystal/RequireAtTopLevel cop ([@zopolis4][])
+
+### Changes
+
+* Add files ending in .cr to the list of files to be checked in the default config ([@zopolis4][])
+
 ## 0.0.3 (2025-04-28)
 
 ### New features

data/README.md

@@ -10,7 +10,7 @@ Getting static type information about Ruby files isn't the difficult part, the p
 
 Inserting Crystal types into Ruby code is a no-go, because that causes `Lint/Syntax` errors in RuboCop.
 
-Possible paths foward:
+Possible paths forward:
 - Modify the parser to accept Crystal type declarations, or at least not break on them.
 - Modify Crystal to accept type declarations from `.rbs` and/or `.rbi` files.
 - Modify Crystal to accept type declarations from sorbet/rbs-inline/other annotations.

data/config/default.yml

@@ -1,10 +1,27 @@
 AllCops:
   DisabledByDefault: true
+  inherit_mode:
+    merge:
+      - Include
+  Include:
+    - '**/*.cr'
+
+Crystal/EnumerableReduce:
+  Description: 'This cop replaces .inject with .reduce and converts reducer functions to their block counterparts.'
+  Enabled: true
+
+Crystal/EnumerableSize:
+  Description: 'This cop replaces .length and .count with .size when they are used as aliases for .size'
+  Enabled: true
 
 Crystal/FileExtension:
   Description: 'This cop renames files ending in `.rb` to `.cr`.'
   Enabled: true
 
+Crystal/FileReadLines:
+  Description: "This cop replaces Ruby's IO.readlines with Crystal's File.read_lines or IO.each_line."
+  Enabled: true
+
 Crystal/InterpolationInSingleQuotes:
   Description: "This cop uses %q in place of ' if the enclosed string would be affected by interpolation."
   Enabled: true
@@ -13,6 +30,14 @@ Crystal/MethodNameStartingWithUppercaseLetter:
   Description: 'This cop detects method names that start with uppercase letters.'
   Enabled: true
 
+Crystal/MethodReturningChar:
+  Description: 'This cop detects methods that, in Crystal, return the Char type instead of a 1-character string, and modifies them accordingly.'
+  Enabled: true
+
+Crystal/RequireAtTopLevel:
+  Description: 'This cop detects instances of require that are not at the top level.'
+  Enabled: true
+
 Crystal/RequireRelative:
   Description: 'This cop replaces require_relative with require while maintaining behavior.'
   Enabled: true

data/lib/rubocop/cop/crystal/enumerable_reduce.rb

@@ -0,0 +1,58 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # Ruby has Enumerable.inject, which can take either a block or a reducer function,
+      # and an optional initial value. Enumerable.reduce is an alias of this.
+      # Crystal only has Enumerable.reduce, which does not support reducer functions.
+      #
+      # @example
+      #   # bad
+      #   x.inject { |r,v| r + v }
+      #   x.inject(:+)
+      #   x.reduce(:+)
+      #
+      #   # good
+      #   x.reduce { |r,v| r + v }
+      #
+      #   # bad
+      #   x.inject(y) { |r,v| r + v }
+      #   x.inject(y, :+)
+      #   x.reduce(y, :+)
+      #
+      #   # good
+      #   x.reduce(y) { |r,v| r + v }
+      #
+      class EnumerableReduce < Base
+        extend AutoCorrector
+
+        MSG = 'Crystal has .reduce instead of .inject'
+        RESTRICT_ON_SEND = %i[inject reduce]
+
+        def on_send(node)
+          new_node = node.receiver.source
+          new_node << if node.csend_type?
+                        '&.'
+                      else
+                        '.'
+                      end
+          new_node << 'reduce'
+          if node.arguments?
+            if node.parent&.block_type?
+              new_node << "(#{node.first_argument.source})"
+            else
+              new_node << "(#{node.first_argument.source})" if node.arguments.size == 2
+              new_node << " { |r,v| r.#{node.last_argument.source.delete_prefix(':')}(v) }"
+            end
+          end
+
+          return if node.source == new_node
+
+          add_offense(node.selector) do |corrector|
+            corrector.replace(node, new_node)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/enumerable_size.rb

@@ -0,0 +1,31 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # Crystal does not have the .length or .count methods as aliases to .size
+      #
+      # @example
+      #   # bad
+      #   x.length
+      #   x.count
+      #
+      #   # good
+      #   x.size
+      #
+      class EnumerableSize < Base
+        extend AutoCorrector
+
+        MSG = 'Crystal does not have the .length or .count methods as aliases to .size'
+        RESTRICT_ON_SEND = %i[count length]
+
+        def on_send(node)
+          return if node.arguments? || node.parent&.block_type?
+
+          add_offense(node.selector) do |corrector|
+            corrector.replace(node.selector, 'size')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/file_extension.rb

@@ -13,6 +13,7 @@ module RuboCop
       #
       class FileExtension < Base
         extend AutoCorrector
+
         MSG = 'Crystal files have `.cr` extensions, while Ruby files have `.rb` extensions.'
 
         def on_new_investigation

data/lib/rubocop/cop/crystal/file_read_lines.rb

@@ -0,0 +1,115 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # Ruby has IO.readlines, which supports chomp (false by default), limit and separator arguments, and has special behaviors for empty and nil separators.
+      # Crystal has File.read_lines, which only supports the chomp (true by default) argument, and IO.each_line, which supports limit and separator arguments,
+      # but does not have special behaviors for empty and nil separators, so we recreate that ourselves.
+      #
+      # @example
+      #   # bad
+      #   File.readlines('foo')
+      #   IO.readlines('foo')
+      #
+      #   # good
+      #   File.read_lines('foo', chomp: false)
+      #
+      #   # bad
+      #   File.readlines('foo', 'b', 3)
+      #   IO.readlines('foo', 'b', 3)
+      #
+      #   # good
+      #   File.open('foo').each_line('b', 3).to_a
+      #
+      #   # bad
+      #   File.readlines('foo', nil)
+      #   IO.readlines('foo', nil)
+      #
+      #   # bad
+      #   File.readlines("foo", '')
+      #   IO.readlines("foo", '')
+      #
+      #   # good
+      #   File.open("foo").each_line("\n").to_a.join.split(/\n{2,}/).reject { |e| e.empty? }.reverse.map_with_index {|e, i| i == 0 ? e : "#{e}\n\n" }.reverse
+      #
+      class FileReadLines < Base
+        extend AutoCorrector
+
+        MSG = 'Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line'
+        RESTRICT_ON_SEND = %i[readlines]
+
+        # @!method no_arguments?(node)
+        def_node_matcher :no_arguments?, <<~PATTERN
+          (send (send (const {nil? cbase} :File) ... ) :readlines)
+        PATTERN
+
+        # @!method path_argument?(node)
+        def_node_matcher :path_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_))
+        PATTERN
+
+        # @!method path_and_chomp_argument?(node)
+        def_node_matcher :path_and_chomp_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str _) (hash (pair (sym :chomp) _)))
+        PATTERN
+
+        # TODO: Do this properly once https://github.com/rubocop/rubocop-ast/pull/386 is merged.
+        # @!method path_and_empty_separator_argument?(node)
+        def_node_matcher :path_and_empty_separator_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (str empty?))
+        PATTERN
+
+        # @!method path_and_nil_separator_argument?(node)
+        def_node_matcher :path_and_nil_separator_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) nil)
+        PATTERN
+
+        # @!method path_and_separator_argument?(node)
+        def_node_matcher :path_and_separator_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (str $_))
+        PATTERN
+
+        # @!method path_and_limiter_argument?(node)
+        def_node_matcher :path_and_limiter_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (int $_))
+        PATTERN
+
+        # @!method path_separator_and_limiter_argument?(node)
+        def_node_matcher :path_separator_and_limiter_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (str $_) (int $_))
+        PATTERN
+
+        def on_send(node)
+          if no_arguments?(node)
+            autocorrect(node, node.source.sub('.readlines', '.each_line.to_a'))
+          elsif (path = path_argument?(node))
+            autocorrect(node, "File.read_lines(\"#{path}\", chomp: false)")
+          elsif path_and_chomp_argument?(node)
+            autocorrect(node, node.source.sub(/(File|IO)\.readlines/, 'File.read_lines'))
+          elsif (path = path_and_empty_separator_argument?(node))
+            # TODO: There's probably a slightly cleaner way to replicate Ruby's "paragraph" separator behavior.
+            autocorrect(node, "File.open(\"#{path}\").each_line(\"\\n\").to_a.join.split(/\\n{2,}/).reject { |e| e.empty? }.reverse.map_with_index {|e, i| i == 0 ? e : \"\#{e}\\n\\n\" }.reverse")
+          elsif (path = path_and_nil_separator_argument?(node))
+            # TODO: Crystal might technically support this more cleanly, although this doesn't appear to be documented.
+            # https://github.com/crystal-lang/crystal/blob/1.17.1/src/io.cr#L818-L822
+            autocorrect(node, "[File.open(\"#{path}\").each_line(chomp: false).to_a.join]")
+          elsif (path, separator = path_and_separator_argument?(node))
+            autocorrect(node, "File.open(\"#{path}\").each_line(\"#{separator}\").to_a")
+          elsif (path, limiter = path_and_limiter_argument?(node))
+            autocorrect(node, "File.open(\"#{path}\").each_line(#{limiter}).to_a")
+          elsif (path, separator, limiter = path_separator_and_limiter_argument?(node))
+            autocorrect(node, "File.open(\"#{path}\").each_line(\"#{separator}\", #{limiter}).to_a")
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def autocorrect(node, replacement)
+          add_offense(node.selector) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/interpolation_in_single_quotes.rb

@@ -16,6 +16,7 @@ module RuboCop
       #
       class InterpolationInSingleQuotes < Base
         extend AutoCorrector
+
         MSG = 'Crystal does not support the use of single-quote deliminated strings to avoid interpolation.'
 
         def on_str(node)

data/lib/rubocop/cop/crystal/method_name_starting_with_uppercase_letter.rb

@@ -19,7 +19,7 @@ module RuboCop
       #   foo(bar)
       #
       class MethodNameStartingWithUppercaseLetter < Base
-        MSG = 'Method names must start with a lowecase letter in Crystal.'
+        MSG = 'Method names must start with a lowercase letter in Crystal.'
 
         def on_def(node)
           add_offense(node.loc.name) if node.method_name.to_s.chr.capitalize!.nil?

data/lib/rubocop/cop/crystal/method_returning_char.rb

@@ -0,0 +1,54 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # In Crystal, certain methods return a single character of type Char, while in Ruby they return a 1-character string.
+      # Chars and 1-character strings are treated differently in Crystal, and will not count as equal even if they contain the same content.
+      #
+      # @example
+      #   # bad
+      #   x.chars
+      #
+      #   # good
+      #   x.chars.map { |c| c.to_s }
+      #
+      #   # bad
+      #   x.each_char { |c| y << c }
+      #
+      #   # good
+      #   x.each_char { |c| y << c.to_s }
+      #
+      class MethodReturningChar < Base
+        extend AutoCorrector
+
+        MSG = 'In Crystal, this method returns the Char type instead of a 1-character string.'
+        RESTRICT_ON_SEND = %i[chars each_char]
+
+        # @!method map_to_s?(node)
+        def_node_matcher :map_to_s?, <<~PATTERN
+          (block (send (call (...) :chars) :map) (args (arg :c)) (send (lvar :c) :to_s))
+        PATTERN
+
+        def on_send(node)
+          if node.method?(:chars) && !map_to_s?(node.parent&.parent)
+            add_offense(node.selector) do |corrector|
+              corrector.insert_after(node.selector, '.map { |c| c.to_s }')
+            end
+          elsif node.method?(:each_char)
+            nodes_to_correct = []
+            node.parent.body.each_descendant do |n|
+              # If a node is an lvar with the same name as the character argument and it does not have a .to_s, it needs to be corrected.
+              nodes_to_correct << n if n.lvar_type? && n.source == node.parent.first_argument.source.gsub('|', '') && !n.parent.method?(:to_s)
+            end
+
+            return if nodes_to_correct.empty?
+
+            add_offense(node.selector) do |corrector|
+              nodes_to_correct.each { |n| corrector.insert_after(n, '.to_s') }
+            end
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/require_at_top_level.rb

@@ -0,0 +1,35 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # As of Crystal 0.7.7, require is only allowed at the top level:
+      # https://github.com/crystal-lang/crystal/releases/tag/0.7.7
+      # ^ "(breaking change) require is now only allowed at the top-level, never inside other types or methods."
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     require 'bar'
+      #   end
+      #
+      #   class Foo
+      #     require 'bar'
+      #   end
+      #
+      #   module Foo
+      #     require 'bar'
+      #   end
+      #
+      #   # good
+      #   require 'bar'
+      #
+      class RequireAtTopLevel < Base
+        MSG = 'Crystal does not allow require anywhere other than the top level.'
+        RESTRICT_ON_SEND = [:require]
+
+        def on_send(node)
+          add_offense(node) if %i[def class module].include?(node.parent&.type)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/require_relative.rb

@@ -19,6 +19,7 @@ module RuboCop
       #
       class RequireRelative < Base
         extend AutoCorrector
+
         MSG = 'Crystal does not support require_relative.'
         RESTRICT_ON_SEND = [:require_relative]
 

data/lib/rubocop/cop/crystal_cops.rb

@@ -1,4 +1,9 @@
+require_relative 'crystal/enumerable_reduce'
+require_relative 'crystal/enumerable_size'
 require_relative 'crystal/file_extension'
+require_relative 'crystal/file_read_lines'
 require_relative 'crystal/interpolation_in_single_quotes'
 require_relative 'crystal/method_name_starting_with_uppercase_letter'
+require_relative 'crystal/method_returning_char'
+require_relative 'crystal/require_at_top_level'
 require_relative 'crystal/require_relative'

data/lib/rubocop/crystal/plugin.rb

@@ -6,7 +6,7 @@ module RuboCop
       def about
         LintRoller::About.new(
           name: 'rubocop-crystal',
-          version: '0.0.3',
+          version: '0.0.4',
           homepage: 'https://github.com/Zopolis4/rubocop-crystal',
           description: 'A RuboCop extension for converting Ruby to Crystal.'
         )

data/rubocop-crystal.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |spec|
   spec.name     = 'rubocop-crystal'
   spec.summary  = 'A RuboCop extension for converting Ruby to Crystal.'
-  spec.version  = '0.0.3'
+  spec.version  = '0.0.4'
   spec.license  = 'GPL-3.0-or-later'
   spec.author   = 'Zopolis4'
   spec.email    = 'creatorsmithmdt@gmail.com'
@@ -13,5 +13,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'lint_roller'
-  spec.add_dependency 'rubocop', '>= 1.72.1'
+  spec.add_dependency 'rubocop', '>= 1.80.2'
 end

data/spec/rubocop/cop/crystal/enumerable_reduce_spec.rb

@@ -0,0 +1,101 @@
+RSpec.describe RuboCop::Cop::Crystal::EnumerableReduce, :config do
+  it 'registers an offense when .inject is used with a block and no initial value' do
+    expect_offense(<<~RUBY)
+      x.inject { |r,v| r + v }
+        ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.reduce { |r,v| r + v }
+    RUBY
+  end
+
+  it 'registers an offense when &.inject is used with a block and no initial value' do
+    expect_offense(<<~RUBY)
+      x&.inject { |r,v| r + v }
+         ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x&.reduce { |r,v| r + v }
+    RUBY
+  end
+
+  it 'registers an offense when .inject is used with a block and an initial value' do
+    expect_offense(<<~RUBY)
+      x.inject(y) { |r,v| r + v }
+        ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.reduce(y) { |r,v| r + v }
+    RUBY
+  end
+
+  it 'registers an offense when .inject is used with a reducer function and no initial value' do
+    expect_offense(<<~RUBY)
+      x.inject(:+)
+        ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.reduce { |r,v| r.+(v) }
+    RUBY
+  end
+
+  it 'registers an offense when .inject is used with a reducer function and an initial value' do
+    expect_offense(<<~RUBY)
+      x.inject(4, :+)
+        ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.reduce(4) { |r,v| r.+(v) }
+    RUBY
+  end
+
+  it 'registers an offense when .reduce is used with a reducer function and no initial value' do
+    expect_offense(<<~RUBY)
+      x.reduce(:prepend)
+        ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.reduce { |r,v| r.prepend(v) }
+    RUBY
+  end
+
+  it 'registers an offense when &.reduce is used with a reducer function and no initial value' do
+    expect_offense(<<~RUBY)
+      x&.reduce(:prepend)
+         ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x&.reduce { |r,v| r.prepend(v) }
+    RUBY
+  end
+
+  it 'registers an offense when .reduce is used with a reducer function and an initial value' do
+    expect_offense(<<~RUBY)
+      x.reduce("foo", :prepend)
+        ^^^^^^ Crystal has .reduce instead of .inject
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.reduce("foo") { |r,v| r.prepend(v) }
+    RUBY
+  end
+
+  it 'does not register an offense when .reduce is used with a block and no initial value' do
+    expect_no_offenses(<<~RUBY)
+      x.reduce { |r,v| r + v }
+    RUBY
+  end
+
+  it 'does not register an offense when &.reduce is used with a block and no initial value' do
+    expect_no_offenses(<<~RUBY)
+      x&.reduce { |r,v| r + v }
+    RUBY
+  end
+end

data/spec/rubocop/cop/crystal/enumerable_size_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe RuboCop::Cop::Crystal::EnumerableSize, :config do
+  it 'registers an offense when .length is used' do
+    expect_offense(<<~RUBY)
+      x.length
+        ^^^^^^ Crystal does not have the .length or .count methods as aliases to .size
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.size
+    RUBY
+  end
+
+  it 'registers an offense when &.length is used' do
+    expect_offense(<<~RUBY)
+      x&.length
+         ^^^^^^ Crystal does not have the .length or .count methods as aliases to .size
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x&.size
+    RUBY
+  end
+
+  it 'registers an offense when .count is used with no argument and no block' do
+    expect_offense(<<~RUBY)
+      x.count
+        ^^^^^ Crystal does not have the .length or .count methods as aliases to .size
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.size
+    RUBY
+  end
+
+  it 'does not register an offense when .count is used with an argument and no block' do
+    expect_no_offenses(<<~RUBY)
+      x.count(y)
+    RUBY
+  end
+
+  it 'does not register an offense when &.count is used with an argument and no block' do
+    expect_no_offenses(<<~RUBY)
+      x&.count(y)
+    RUBY
+  end
+
+  it 'does not register an offense when .count is used with a block and no argument' do
+    expect_no_offenses(<<~RUBY)
+      x.count {|e| e > 2 }
+    RUBY
+  end
+
+  it 'does not register an offense when .count is used with an argument and a block' do
+    expect_no_offenses(<<~RUBY)
+      x.count(y) {|e| e > 2 }
+    RUBY
+  end
+
+  it 'does not register an offense when .size is used' do
+    expect_no_offenses(<<~RUBY)
+      x.size
+    RUBY
+  end
+end

data/spec/rubocop/cop/crystal/file_read_lines_spec.rb

@@ -0,0 +1,156 @@
+RSpec.describe RuboCop::Cop::Crystal::FileReadLines, :config do
+  it 'registers an offense when File.readlines is used with a path argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo")
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.read_lines("foo", chomp: false)
+    RUBY
+  end
+
+  it 'registers an offense when IO.readlines is used with a path argument' do
+    expect_offense(<<~RUBY)
+      IO.readlines("foo")
+         ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.read_lines("foo", chomp: false)
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path argument and chomp: false' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", chomp: false)
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.read_lines("foo", chomp: false)
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path argument and chomp: true' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", chomp: true)
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.read_lines("foo", chomp: true)
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path and a single-character separator argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", "a")
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.open("foo").each_line("a").to_a
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path and a multi-character separator argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", "quz")
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.open("foo").each_line("quz").to_a
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path and a nil separator argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", nil)
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      [File.open("foo").each_line(chomp: false).to_a.join]
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path and an empty string separator argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", "")
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~'RUBY')
+      File.open("foo").each_line("\n").to_a.join.split(/\n{2,}/).reject { |e| e.empty? }.reverse.map_with_index {|e, i| i == 0 ? e : "#{e}\n\n" }.reverse
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path and a limiter argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", 2)
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.open("foo").each_line(2).to_a
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path, single-character separator, and limiter argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", "b", 3)
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.open("foo").each_line("b", 3).to_a
+    RUBY
+  end
+
+  it 'registers an offense when File.readlines is used with a path, multi-character separator, and limiter argument' do
+    expect_offense(<<~RUBY)
+      File.readlines("foo", "quz", 3)
+           ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.open("foo").each_line("quz", 3).to_a
+    RUBY
+  end
+
+  it 'registers an offense when .readlines is used on a File object' do
+    expect_offense(<<~RUBY)
+      File.open("foo").readlines
+                       ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.open("foo").each_line.to_a
+    RUBY
+  end
+
+  it 'registers an offense when .readlines is used on a chained File object' do
+    expect_offense(<<~RUBY)
+      File.new(File.expand_path("foo", "bar")).readlines
+                                               ^^^^^^^^^ Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line
+    RUBY
+
+    expect_correction(<<~RUBY)
+      File.new(File.expand_path("foo", "bar")).each_line.to_a
+    RUBY
+  end
+
+  it 'does not register an offense when .readlines is used from a non File/IO class' do
+    expect_no_offenses(<<~RUBY)
+      Bar.readlines("foo")
+    RUBY
+  end
+
+  it 'does not register an offense when .readlines is used on a non File/IO object' do
+    expect_no_offenses(<<~RUBY)
+      Bar.open("foo").readlines
+    RUBY
+  end
+end

data/spec/rubocop/cop/crystal/method_name_starting_with_uppercase_letter_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe RuboCop::Cop::Crystal::MethodNameStartingWithUppercaseLetter, :co
   it 'registers an offense when the first letter of a method name is capitalized' do
     expect_offense(<<~RUBY)
       def Foo
-          ^^^ Method names must start with a lowecase letter in Crystal.
+          ^^^ Method names must start with a lowercase letter in Crystal.
         bar
       end
     RUBY
@@ -11,7 +11,7 @@ RSpec.describe RuboCop::Cop::Crystal::MethodNameStartingWithUppercaseLetter, :co
   it 'registers an offense when all the letters of a method name are capitalized' do
     expect_offense(<<~RUBY)
       def FOO
-          ^^^ Method names must start with a lowecase letter in Crystal.
+          ^^^ Method names must start with a lowercase letter in Crystal.
         bar
       end
     RUBY

data/spec/rubocop/cop/crystal/method_returning_char_spec.rb

@@ -0,0 +1,150 @@
+RSpec.describe RuboCop::Cop::Crystal::MethodReturningChar, :config do
+  it 'registers an offense when .chars is used without converting the elements of the array to strings' do
+    expect_offense(<<~RUBY)
+      x.chars
+        ^^^^^ In Crystal, this method returns the Char type instead of a 1-character string.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.chars.map { |c| c.to_s }
+    RUBY
+  end
+
+  it 'registers an offense when &.chars is used without converting the elements of the array to strings' do
+    expect_offense(<<~RUBY)
+      x&.chars
+         ^^^^^ In Crystal, this method returns the Char type instead of a 1-character string.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x&.chars.map { |c| c.to_s }
+    RUBY
+  end
+
+  it 'registers an offense when .chars is used in a chain ending in a block without converting the elements of the array to strings' do
+    expect_offense(<<~RUBY)
+      x.chars.each { |c| puts c}
+        ^^^^^ In Crystal, this method returns the Char type instead of a 1-character string.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.chars.map { |c| c.to_s }.each { |c| puts c}
+    RUBY
+  end
+
+  it 'registers an offense when .chars is used on a string literal in a chain ending in a block without converting the elements of the array to strings' do
+    expect_offense(<<~RUBY)
+      "foo".chars.each { |c| puts c}
+            ^^^^^ In Crystal, this method returns the Char type instead of a 1-character string.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      "foo".chars.map { |c| c.to_s }.each { |c| puts c}
+    RUBY
+  end
+
+  it 'registers an offense when .chars is used on a variable in a chain ending in a block without converting the elements of the array to strings' do
+    expect_offense(<<~RUBY)
+      x = "foo"
+      x.chars.each { |c| puts c}
+        ^^^^^ In Crystal, this method returns the Char type instead of a 1-character string.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x = "foo"
+      x.chars.map { |c| c.to_s }.each { |c| puts c}
+    RUBY
+  end
+
+  it 'registers an offense when .each_char is used without converting the character to a string' do
+    expect_offense(<<~RUBY)
+      x.each_char { |c| puts c }
+        ^^^^^^^^^ In Crystal, this method returns the Char type instead of a 1-character string.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.each_char { |c| puts c.to_s }
+    RUBY
+  end
+
+  it 'registers an offense when .each_char with a multiline block is used without converting each instance of the character to a string' do
+    expect_offense(<<~RUBY)
+      x.each_char do |c|
+        ^^^^^^^^^ In Crystal, this method returns the Char type instead of a 1-character string.
+        puts foo if c == y
+        bar
+        z << c
+      end
+    RUBY
+
+    expect_correction(<<~RUBY)
+      x.each_char do |c|
+        puts foo if c.to_s == y
+        bar
+        z << c.to_s
+      end
+    RUBY
+  end
+
+  it 'does not register an an offense when .chars is used with converting the elements of the array to strings' do
+    expect_no_offenses(<<~RUBY)
+      x.chars.map { |c| c.to_s }
+    RUBY
+  end
+
+  it 'does not register an an offense when &.chars is used with converting the elements of the array to strings' do
+    expect_no_offenses(<<~RUBY)
+      x&.chars.map { |c| c.to_s }
+    RUBY
+  end
+
+  it 'does not register an offense when .chars is used in a chain ending in a block with converting the elements of the array to strings' do
+    expect_no_offenses(<<~RUBY)
+      x.chars.map { |c| c.to_s }.each { |c| puts c}
+    RUBY
+  end
+
+  it 'does not register an offense when .chars is used on a string literal in a chain ending in a block with converting the elements of the array to strings' do
+    expect_no_offenses(<<~RUBY)
+      "foo".chars.map { |c| c.to_s }.each { |c| puts c}
+    RUBY
+  end
+
+  it 'does not register an offense when .chars is used on a variable in a chain ending in a block with converting the elements of the array to strings' do
+    expect_no_offenses(<<~RUBY)
+      x = "foo"
+      x.chars.map { |c| c.to_s }.each { |c| puts c}
+    RUBY
+  end
+
+  it 'does not register an offense when .each_char is used with converting the character to a string' do
+    expect_no_offenses(<<~RUBY)
+      x.each_char { |c| puts c.to_s }
+    RUBY
+  end
+
+  it 'does not register an offense when .each_char with a multiline block is used with converting each instance of the character to a string' do
+    expect_no_offenses(<<~RUBY)
+      x.each_char do |c|
+        puts foo if c.to_s == y
+        bar
+        z << c.to_s
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when .each_char is used with no instances of the character' do
+    expect_no_offenses(<<~RUBY)
+      x.each_char { |c| puts x }
+    RUBY
+  end
+
+  it 'does not register an offense when .each_char with a multiline block is used with no instances of the character' do
+    expect_no_offenses(<<~RUBY)
+      x.each_char do |c|
+        puts x
+        foo if y == z
+      end
+    RUBY
+  end
+end

data/spec/rubocop/cop/crystal/require_at_top_level_spec.rb

@@ -0,0 +1,42 @@
+RSpec.describe RuboCop::Cop::Crystal::RequireAtTopLevel, :config do
+  it 'registers an offense when require is inside a function' do
+    expect_offense(<<~RUBY)
+      def foo
+        require 'bar'
+        ^^^^^^^^^^^^^ Crystal does not allow require anywhere other than the top level.
+      end
+    RUBY
+  end
+
+  it 'registers an offense when require is inside a class' do
+    expect_offense(<<~RUBY)
+      class Foo
+        require 'bar'
+        ^^^^^^^^^^^^^ Crystal does not allow require anywhere other than the top level.
+      end
+    RUBY
+  end
+
+  it 'registers an offense when require is inside a module' do
+    expect_offense(<<~RUBY)
+      module Foo
+        require 'bar'
+        ^^^^^^^^^^^^^ Crystal does not allow require anywhere other than the top level.
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when require is at the top level' do
+    expect_no_offenses(<<~RUBY)
+      require 'bar'
+    RUBY
+  end
+
+  it 'does not register an offense when a funciton does not contain require' do
+    expect_no_offenses(<<~RUBY)
+      def foo
+        bar
+      end
+    RUBY
+  end
+end

data/test/string.rb

@@ -3,7 +3,7 @@ require_relative 'harness'
 =begin
 The Alternative Instruction Set is a relatively unknown 32-bit RISC ISA.
 It is found inside certain VIA C3 CPUs, and is responsible for emulating x86 instructions.
-This isn't relevant in the slightest, but I had to put something in this commment, and I think it's cool.
+This isn't relevant in the slightest, but I had to put something in this comment, and I think it's cool.
 =end
 
 Test.assert_equal 'foo', "foo"
@@ -25,6 +25,9 @@ Test.assert_unequal '#{1 + 1}', '2'
 
 Test.assert_equal '#{foo}'"bar", '#{foo}bar'
 
+Test.assert_equal 'a'.chars[0], "a"
+"bbb".each_char {|c| Test.assert_equal c, 'b' }
+
 i = 3
 
 while i > 0 do
@@ -36,3 +39,37 @@ until i > 3 do
   i += 1
 end
 Test.assert_equal 4, i
+
+x = [0, 1, 1, 2, 3, 4]
+
+Test.assert_equal x.length, 6
+Test.assert_equal x.count, 6
+Test.assert_equal x.size, 6
+
+Test.assert_equal x.count(1), 2
+Test.assert_equal x.count {|e| e > 1}, 3
+
+Test.assert_equal x.inject { |r,v| r + v }, 11
+Test.assert_equal x.inject(4) { |r,v| r - v }, -7
+
+Test.assert_equal x.inject(:+), 11
+Test.assert_equal x.reduce(:+), 11
+Test.assert_equal x.inject(4, :-), -7
+Test.assert_equal x.reduce(4, :-), -7
+
+# TODO: This could be done using a true Tempfile, but Crystal removed theirs in https://github.com/crystal-lang/crystal/pull/6485.
+File.write('temp', "first line\nsecond line\n\nfourth line\nfifth line")
+
+Test.assert_equal File.readlines('temp'), ["first line\n", "second line\n", "\n", "fourth line\n", 'fifth line']
+Test.assert_equal File.readlines('temp', chomp: true), ['first line', 'second line', '', 'fourth line', 'fifth line']
+Test.assert_equal File.readlines('temp', ''), ["first line\nsecond line\n\n", "fourth line\nfifth line"]
+Test.assert_equal File.readlines('temp', nil), ["first line\nsecond line\n\nfourth line\nfifth line"]
+Test.assert_equal File.readlines('temp', 't'), ['first', " line\nsecond line\n\nfourt", "h line\nfift", 'h line']
+Test.assert_equal File.readlines('temp', 'fi'), ['fi', "rst line\nsecond line\n\nfourth line\nfi", 'fth line']
+Test.assert_equal File.readlines('temp', 7), ['first l', "ine\n", 'second ', "line\n", "\n", 'fourth ', "line\n", 'fifth l', 'ine']
+# TODO: These are waiting on https://github.com/crystal-lang/crystal/issues/16134.
+# Technically, we could fix the single-character separator by converting it to a Char, but that obviously won't work for the multi-character one, so we need to wait regardless.
+# Test.assert_equal File.readlines('temp', 'e', 10), ['first line', "\nse", 'cond line', "\n\nfourth l", 'ine', "\nfifth lin", 'e']
+# Test.assert_equal File.readlines('temp', 'li', 4), ["firs", "t li", "ne\ns", "econ", "d li", "ne\n\n", "four", "th l", "ine\n", "fift", 'h li', 'ne']
+
+File.delete('temp')

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-crystal
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Zopolis4
 bindir: bin
 cert_chain: []
-date: 2025-04-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lint_roller
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: 1.80.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.72.1
+        version: 1.80.2
 email: creatorsmithmdt@gmail.com
 executables: []
 extensions: []
@@ -53,16 +53,26 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-crystal.rb
+- lib/rubocop/cop/crystal/enumerable_reduce.rb
+- lib/rubocop/cop/crystal/enumerable_size.rb
 - lib/rubocop/cop/crystal/file_extension.rb
+- lib/rubocop/cop/crystal/file_read_lines.rb
 - lib/rubocop/cop/crystal/interpolation_in_single_quotes.rb
 - lib/rubocop/cop/crystal/method_name_starting_with_uppercase_letter.rb
+- lib/rubocop/cop/crystal/method_returning_char.rb
+- lib/rubocop/cop/crystal/require_at_top_level.rb
 - lib/rubocop/cop/crystal/require_relative.rb
 - lib/rubocop/cop/crystal_cops.rb
 - lib/rubocop/crystal.rb
 - lib/rubocop/crystal/plugin.rb
 - rubocop-crystal.gemspec
+- spec/rubocop/cop/crystal/enumerable_reduce_spec.rb
+- spec/rubocop/cop/crystal/enumerable_size_spec.rb
+- spec/rubocop/cop/crystal/file_read_lines_spec.rb
 - spec/rubocop/cop/crystal/interpolation_in_single_quotes_spec.rb
 - spec/rubocop/cop/crystal/method_name_starting_with_uppercase_letter_spec.rb
+- spec/rubocop/cop/crystal/method_returning_char_spec.rb
+- spec/rubocop/cop/crystal/require_at_top_level_spec.rb
 - spec/rubocop/cop/crystal/require_relative_spec.rb
 - spec/spec_helper.rb
 - test/harness.rb
@@ -86,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.7.1
 specification_version: 4
 summary: A RuboCop extension for converting Ruby to Crystal.
 test_files: []