grizzly-rb 1.0.0

data/bin/test

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+mspec/bin/mspec ruby-spec/core/array
+RETURN1=$?
+
+echo
+echo
+
+mspec/bin/mspec ruby-spec/core/enumerable
+RETURN2=$?
+
+echo
+echo
+
+mspec/bin/mspec ruby-spec/core/enumerator
+RETURN3=$?
+
+echo
+echo
+
+mspec/bin/mspec spec/enumerator
+RETURN4=$?
+
+echo
+echo
+
+mspec/bin/mspec spec/skipped_tests/core/array/
+RETURN5=$?
+
+RETURN=$(($RETURN1 + $RETURN2 + $RETURN3 + $RETURN4 + $RETURN5))
+
+echo $RETURN
+
+if [ $RETURN -gt "0" ]; then
+echo "Tests failed"
+exit 1
+fi
+exit 0

data/config/mspec_override.rb

@@ -0,0 +1,44 @@
+require "yaml"
+require "singleton"
+require "byebug"
+require_relative "../lib/grizzly"
+
+class MyCollectionArray < Grizzly::Collection; end
+
+class SkippedTests
+  include Singleton
+
+  attr_accessor :source
+
+  def tests
+    YAML.load(File.read(source))["tests"]
+  end
+
+  def skip?(block_details)
+    tests.any? { |t| block_details.include?(t) }
+  end
+end
+
+file_path = File.expand_path(File.dirname(__FILE__))
+SkippedTests.instance.source = File.join(file_path, "skipped_tests.yml")
+
+module MSpec
+  def self.protect(location, &block)
+    begin
+      @env.instance_exec(&block)
+      return true
+    rescue SystemExit => e
+      raise e
+    rescue SkippedSpecError => e
+      @skips << [e, block]
+      return false
+    rescue Object => exc
+      return true if SkippedTests.instance.skip?(block.to_s)
+      # File.open("failed-specs.txt", "a") { |f| f.write "#{block.to_s}\n"}
+
+      actions :exception, ExceptionState.new(current && current.state, location, exc)
+      register_exit 1
+      return false
+    end
+  end
+end

data/config/skipped_tests.yml

@@ -0,0 +1,104 @@
+tests:
+  # Enumerator
+  - core/enumerator/initialize_spec.rb:27
+  - shared/enumerator/enum_for.rb:6
+  # Array
+  - core/array/allocate_spec.rb:4
+  - core/array/flatten_spec.rb:79
+  - core/array/flatten_spec.rb:89
+  - core/array/flatten_spec.rb:248
+  - core/array/pack/buffer_spec.rb:26
+  - core/array/partition_spec.rb:37
+  - core/array/to_a_spec.rb:5
+  - core/array/to_a_spec.rb:11
+  - core/array/zip_spec.rb:62
+
+todo:
+
+
+unskipped_enumerables:
+  - core/enumerable/group_by_spec.rb:28
+  - core/enumerable/group_by_spec.rb:6
+  - core/enumerable/minmax_by_spec.rb:10
+  - core/enumerable/minmax_by_spec.rb:14
+  - core/enumerable/minmax_by_spec.rb:19
+  - core/enumerable/minmax_by_spec.rb:26
+  - core/enumerable/minmax_by_spec.rb:33
+  - core/enumerable/minmax_by_spec.rb:38
+  - core/enumerable/minmax_spec.rb:16
+  - core/enumerable/partition_spec.rb:14
+  - core/enumerable/partition_spec.rb:6
+  - core/enumerable/reject_spec.rb:19
+  - core/enumerable/reject_spec.rb:6
+  - core/enumerable/shared/find_all.rb:10
+  - core/enumerable/shared/find_all.rb:25
+  - core/enumerable/shared/take.rb:7
+  - core/enumerable/shared/take.rb:12
+  - core/enumerable/shared/take.rb:19
+  - core/enumerable/shared/take.rb:23
+  - core/enumerable/shared/take.rb:31
+  - core/enumerable/shared/take.rb:36
+  - core/enumerable/shared/take.rb:50
+  - core/enumerable/shared/take.rb:55
+  - core/enumerable/sort_by_spec.rb:6
+  - core/enumerable/sort_by_spec.rb:25
+  - core/enumerable/sort_by_spec.rb:30
+  - core/enumerable/sort_by_spec.rb:35
+  - core/enumerable/sort_spec.rb:5
+  - core/enumerable/sort_spec.rb:11
+  - core/enumerable/sort_spec.rb:22
+  - core/enumerable/sort_spec.rb:31
+  - core/enumerable/sort_spec.rb:46
+  - core/enumerable/sort_spec.rb:51
+  - core/enumerable/zip_spec.rb:6
+  - core/enumerable/zip_spec.rb:36
+  - shared/enumerable/minmax.rb:2
+  - shared/enumerable/minmax.rb:7
+  - shared/enumerable/minmax.rb:12
+
+unskipped_array:
+  - core/array/compact_spec.rb:21
+  - core/array/difference_spec.rb:14
+  - core/array/drop_spec.rb:60
+  - core/array/drop_while_spec.rb:24
+  - core/array/first_spec.rb:76
+  - core/array/flatten_spec.rb:79
+  - core/array/last_spec.rb:70
+  - core/array/max_spec.rb:4
+  - core/array/min_spec.rb:4
+  - core/array/multiply_spec.rb:88
+  - core/array/permutation_spec.rb:26
+  - core/array/permutation_spec.rb:35
+  - core/array/plus_spec.rb:34
+  - core/array/pop_spec.rb:115
+  - core/array/reject_spec.rb:36
+  - core/array/reverse_spec.rb:18
+  - core/array/rotate_spec.rb:63
+  - core/array/sample_spec.rb:69
+  - core/array/shared/collect.rb:11
+  - core/array/shared/difference.rb:33
+  - core/array/shared/intersection.rb:67
+  - core/array/shared/select.rb:19
+  - core/array/shared/slice.rb:427
+  - core/array/shared/slice.rb:431
+  - core/array/shared/slice.rb:435
+  - core/array/shared/slice.rb:439
+  - core/array/shared/slice.rb:443
+  - core/array/shared/slice.rb:447
+  - core/array/shared/union.rb:62
+  - core/array/shift_spec.rb:116
+  - core/array/shuffle_spec.rb:24
+  - core/array/slice_spec.rb:217
+  - core/array/slice_spec.rb:221
+  - core/array/slice_spec.rb:225
+  - core/array/slice_spec.rb:229
+  - core/array/slice_spec.rb:233
+  - core/array/slice_spec.rb:237
+  - core/array/sort_spec.rb:167
+  - core/array/take_spec.rb:36
+  - core/array/take_while_spec.rb:24
+  - core/array/transpose_spec.rb:47
+  - core/array/union_spec.rb:17
+  - core/array/uniq_spec.rb:94
+  - core/array/values_at_spec.rb:61
+

data/conversion/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "rubocop"
+gem "rspec"
+gem "byebug"

data/conversion/Gemfile.lock

@@ -0,0 +1,53 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    byebug (11.1.3)
+    diff-lcs (1.5.0)
+    json (2.6.2)
+    parallel (1.22.1)
+    parser (3.1.2.1)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    regexp_parser (2.6.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.1)
+    rubocop (1.36.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.20.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.21.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.3.0)
+
+PLATFORMS
+  ruby
+  x86_64-darwin-20
+  x86_64-darwin-21
+
+DEPENDENCIES
+  byebug
+  rspec
+  rubocop
+
+BUNDLED WITH
+   2.3.22

data/conversion/bin/rspec

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/conversion/lib/cops/array_initialization.rb

@@ -0,0 +1,95 @@
+module RuboCop
+  module Cop
+    module Style
+      class ArrayInitialization < Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ERROR_MSG_LITERAL = "an Array should not be initialized with the literal constructor []"
+        ERROR_MSG_NEW = "an Array should not be initialized with .new"
+        ERROR_MSG_TO_A = "an Array should not be initialized with #to_a"
+
+        def_node_matcher :array_literal, <<~PATTERN
+          (array $...)
+        PATTERN
+
+        def_node_matcher :array_create, <<~PATTERN
+          (send (const ...) :new (array ...))
+        PATTERN
+
+        def_node_matcher :array_spec_matched, <<~PATTERN
+          (send (send ...) :== (array ...))
+        PATTERN
+
+        def_node_matcher :generic_array_initialization, <<~PATTERN
+          (send (const nil? :Array) :new $...)
+        PATTERN
+
+        def_node_matcher :to_a_initialization, <<~PATTERN
+          (send (...) :to_a)
+        PATTERN
+
+        def_node_matcher :to_a_already_parsed, <<~PATTERN
+          (send $(...) :new (...))
+        PATTERN
+
+        def on_send(node)
+          on_send_generic_initialization(node)
+          on_send_to_a_initialization(node)
+        end
+
+        def on_send_generic_initialization(node)
+          return unless (expression = generic_array_initialization(node))
+
+          add_offense(node, message: ERROR_MSG_NEW) do |corrector|
+            a, b = expression.map(&:source)
+            corrector.replace node, format_correction(first: a , second: b)
+          end
+        end
+
+        def on_send_to_a_initialization(node)
+          return if to_a_already_parsed(node.parent)&.source == cop_config['InitializeArrayWith']
+          return unless to_a_initialization(node)
+
+          add_offense(node, message: ERROR_MSG_TO_A) do |corrector|
+            corrector.replace node, format_correction(first: node.source)
+          end
+        end
+
+        def on_array(node)
+          return if array_create(node.parent)
+          return if array_spec_matched(node.parent)
+          return unless (expression = array_literal(node))
+
+          add_offense(node, message: ERROR_MSG_LITERAL) do |corrector|
+            corrector.replace node, format_correction(first: expression_to_string(expression))
+          end
+        end
+
+        private
+
+        def expression_to_string(expression)
+          expression.map do |node|
+            case node.type
+            when :int
+              node.value
+            when :true
+              true
+            when :false
+              false
+            else
+              node.value
+            end
+          end
+        end
+
+        def format_correction(first: nil, second: nil, constant: cop_config['InitializeArrayWith'])
+          result = "#{constant}.new(#{first})"
+          if second
+            result = %Q{#{constant}.new(#{first}, #{second})}
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/conversion/lib/cops/enumerator_initialization.rb

@@ -0,0 +1,56 @@
+module RuboCop
+  module Cop
+    module Style
+      class EnumeratorInitialization < Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ERROR_MSG_TO_ENUM = "#to_enum initialization needs to be wrapped"
+        ERROR_MSG_NEW = "#new Enumerator initialization needs to be wrapped"
+
+        def_node_matcher :already_wrapped, <<~PATTERN
+          (send $(...) :new (...))
+        PATTERN
+
+        def_node_matcher :to_enum_initialization, <<~PATTERN
+          (send (...) :to_enum ...)
+        PATTERN
+
+
+        def_node_matcher :new_initialization, <<~PATTERN
+          (send (const nil? :Enumerator) :new ...)
+        PATTERN
+
+        def_node_matcher :new_block_initialization, <<~PATTERN
+          (block (send (const nil? :Enumerator) :new ...) ...)
+        PATTERN
+
+        def on_send(node)
+          return if already_wrapped(node.parent)&.source == cop_config['InitializeEnumeratorWith']
+          return if new_block_initialization(node.parent)
+
+          error = case
+            when to_enum_initialization(node) then ERROR_MSG_TO_ENUM
+            when new_initialization(node)     then ERROR_MSG_NEW
+            end
+
+          return unless error
+
+          add_offense(node, message: error) do |corrector|
+            constant = cop_config['InitializeEnumeratorWith']
+            corrector.replace node, "#{constant}.new(#{node.source})"
+          end
+        end
+
+        def on_block(node)
+          return if already_wrapped(node.parent)&.source == cop_config['InitializeEnumeratorWith']
+          return unless new_block_initialization(node)
+
+          add_offense(node, message: ERROR_MSG_NEW) do |corrector|
+            constant = cop_config['InitializeEnumeratorWith']
+            corrector.replace node, "#{constant}.new(#{node.source})"
+          end
+        end
+      end
+    end
+  end
+end

data/conversion/lib/cops/grep_implementation.rb

@@ -0,0 +1,36 @@
+module RuboCop
+  module Cop
+    module Style
+      class GrepImplementation < Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ERROR_MSG = "#grep and grep_v cannot be implemented"
+
+        def_node_matcher :enumerable_grep_spec, <<~PATTERN
+          (block (send nil? :describe (str "Enumerable#grep")) ...)
+        PATTERN
+
+        def_node_matcher :enumerable_grep_v_spec, <<~PATTERN
+          (block (send nil? :describe (str "Enumerable#grep_v")) ...)
+        PATTERN
+
+        def_node_matcher :grep_spec_already_skipped, <<~PATTERN
+          (block (send nil? :ruby_bug ...) ...)
+        PATTERN
+
+        def on_block(node)
+          return if grep_spec_already_skipped(node.parent)
+          return unless (expression = enumerable_grep_spec(node) || enumerable_grep_v_spec(node))
+
+          add_offense(node, message: ERROR_MSG) do |corrector|
+            corrector.replace node, <<~RUBY
+              ruby_bug '#11808', ''...'#{cop_config['GrepSupportRubyVersion']}' do
+              #{node.source}
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/conversion/lib/cops/instance_of_array.rb

@@ -0,0 +1,24 @@
+module RuboCop
+  module Cop
+    module Style
+      class InstanceOfArray < Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ERROR_MSG = "instance_of should not be of Array"
+
+        def_node_matcher :instance_of_literal, <<~PATTERN
+          (send nil? :be_an_instance_of (const nil? :Array))
+        PATTERN
+
+        def on_send(node)
+          return unless instance_of_literal(node)
+
+          add_offense(node, message: ERROR_MSG) do |corrector|
+            constant_to_replace = cop_config['NewInstanceOf']
+            corrector.replace(node, "be_an_instance_of(#{constant_to_replace})")
+          end
+        end
+      end
+    end
+  end
+end

data/conversion/lib/cops/subclass_initialization.rb

@@ -0,0 +1,47 @@
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Style
+      class SubclassInitialization < Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ERROR_MSG = "instance_of should not be of Array"
+
+        def_node_matcher :sublclass_literal, <<~PATTERN
+          (send (const (const ... ) :MyArray ) :[] $...)
+        PATTERN
+
+        def on_send(node)
+          return unless (expression = sublclass_literal(node))
+
+          add_offense(node, message: ERROR_MSG) do |corrector|
+            constant_to_replace = cop_config['InitializeArrayWith']
+            corrector.replace(node, "#{constant_to_replace}.new(#{expression.map(&:value)})")
+          end
+        end
+      end
+    end
+  end
+end
+
+
+# (index
+#     (const
+#       (const nil :ArraySpecs) :MyArray)
+#     (int 1)
+#     (int 2)
+#     (int 3)
+#     (int 4)
+#     (int 5)))
+
+
+# s(:ivasgn, :@array,
+#   s(:send,
+#     s(:const,
+#       s(:const, nil, :ArraySpecs), :MyArray), :[],
+#     s(:int, 1),
+#     s(:int, 2),
+#     s(:int, 3),
+#     s(:int, 4),
+#     s(:int, 5)))

data/conversion/lib/cops.rb

@@ -0,0 +1,6 @@
+require "rubocop"
+require_relative "cops/array_initialization"
+require_relative "cops/instance_of_array"
+require_relative "cops/subclass_initialization"
+require_relative "cops/grep_implementation"
+require_relative "cops/enumerator_initialization"