rubocop-crystal 0.0.2 → 0.0.4

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/interpolation_in_single_quotes_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe RuboCop::Cop::Crystal::InterpolationInSingleQuotes, :config do
+  it 'does not register an offense when a non-interpolated string is in double quotes' do
+    expect_no_offenses(<<~RUBY)
+      "foo"
+    RUBY
+  end
+
+  it 'does not register an offense when an interpolated string is in double quotes' do
+    expect_no_offenses(<<~'RUBY')
+      "foo #{bar}"
+    RUBY
+  end
+
+  it 'does not register an offense when a non-interpolated string is in single quotes' do
+    expect_no_offenses(<<~RUBY)
+      'foo'
+    RUBY
+  end
+
+  it 'registers an offense when an interpolated string is in single quotes' do
+    expect_offense(<<~'RUBY')
+      'foo #{bar}'
+      ^^^^^^^^^^^^ Crystal does not support the use of single-quote deliminated strings to avoid interpolation.
+    RUBY
+
+    expect_correction(<<~'RUBY')
+      %q(foo #{bar})
+    RUBY
+  end
+end

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

@@ -0,0 +1,35 @@
+RSpec.describe RuboCop::Cop::Crystal::MethodNameStartingWithUppercaseLetter, :config do
+  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 lowercase letter in Crystal.
+        bar
+      end
+    RUBY
+  end
+
+  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 lowercase letter in Crystal.
+        bar
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when the first letter of a method name is lowercase' do
+    expect_no_offenses(<<~RUBY)
+      def foo
+        bar
+      end
+    RUBY
+  end
+
+  it 'does not register an offense when the first letter of a method name is lowercase regardless of the rest of the method name' do
+    expect_no_offenses(<<~RUBY)
+      def fOO
+        bar
+      end
+    RUBY
+  end
+end

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/spec/rubocop/cop/crystal/require_relative_spec.rb

@@ -0,0 +1,51 @@
+RSpec.describe RuboCop::Cop::Crystal::RequireRelative, :config do
+  it 'registers an offense when requiring a file in the same directory' do
+    expect_offense(<<~RUBY)
+      require_relative 'foo'
+      ^^^^^^^^^^^^^^^^^^^^^^ Crystal does not support require_relative.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      require './foo'
+    RUBY
+  end
+
+  it 'registers an offense when requiring a file path starting with ./' do
+    expect_offense(<<~RUBY)
+      require_relative './foo'
+      ^^^^^^^^^^^^^^^^^^^^^^^^ Crystal does not support require_relative.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      require './foo'
+    RUBY
+  end
+
+  it 'registers an offense when requiring a file path starting with ../' do
+    expect_offense(<<~RUBY)
+      require_relative '../foo'
+      ^^^^^^^^^^^^^^^^^^^^^^^^^ Crystal does not support require_relative.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      require '../foo'
+    RUBY
+  end
+
+  it 'registers an offense when requiring a file path starting with /' do
+    expect_offense(<<~RUBY)
+      require_relative '/foo'
+      ^^^^^^^^^^^^^^^^^^^^^^^ Crystal does not support require_relative.
+    RUBY
+
+    expect_correction(<<~RUBY)
+      require '/foo'
+    RUBY
+  end
+
+  it 'does not register an offense on non-relative requires' do
+    expect_no_offenses(<<~RUBY)
+      require '../foo'
+    RUBY
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubocop-crystal'
+require 'rubocop/rspec/support'
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.raise_errors_for_deprecations!
+  config.raise_on_warning = true
+  config.fail_if_no_examples = true
+
+  config.order = :random
+  Kernel.srand config.seed
+end