Merge branch 'release/1.0.0' into develop

Author: paulgoetze

README.md

@@ -1,6 +1,6 @@
 # CodeBreaker
 
-[![Build Status](https://travis-ci.org/daigaku-ruby/code_breaker.svg?branch=main)](https://travis-ci.org/daigaku-ruby/code_breaker)
+[![Build Status](https://github.com/daigaku-ruby/code_breaker/workflows/main/badge.svg)](https://github.com/daigaku-ruby/code_breaker/workflows/main/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/code_breaker.svg)](http://badge.fury.io/rb/code_breaker)
 
 CodeBreaker breaks a line of Ruby code into its receiver classes and the methods
@@ -44,10 +44,6 @@ require 'code_breaker'
 
 code_snippet = 'crazy_number = Rational(3, 5) + 42 - Complex(2.3, 6.4) * 1.2'
 CodeBreaker.parse(code_snippet)
-# for Ruby < v2.4.0:
-# => {:lvasgn=>[:crazy_number, [Rational, :+, Fixnum, :-, Complex, :*, Float]]}
-#
-# for Ruby >= v2.4.0:
 # => {:lvasgn=>[:crazy_number, [Rational, :+, Integer, :-, Complex, :*, Float]]}
 
 code_snippet = '"hello" + "World"'

spec/code_breaker/parser/assignments_spec.rb

@@ -5,31 +5,31 @@
     context 'for a local variable assignment' do
       it 'returns a Hash with key :lvasgn' do
         input  = "name = 'John Doe' + 24.to_s"
-        output = { lvasgn: [:name, [String, :+, fixnum_or_integer, :to_s]] }
+        output = { lvasgn: [:name, [String, :+, Integer, :to_s]] }
         expect(input).to be_parsed_as output
       end
     end
 
     context 'for an instance variable assignment' do
       it 'returns a Hash with key :ivasgn' do
         input  = "@name = 'John Doe' + 24.to_s"
-        output = { ivasgn: [:@name, [String, :+, fixnum_or_integer, :to_s]] }
+        output = { ivasgn: [:@name, [String, :+, Integer, :to_s]] }
         expect(input).to be_parsed_as output
       end
     end
 
     context 'for a class variable assignment' do
       it 'returns a Hash with key :cvasgn' do
         input  = "@@name = 'John Doe' + 24.to_s"
-        output = { cvasgn: [:@@name, [String, :+, fixnum_or_integer, :to_s]] }
+        output = { cvasgn: [:@@name, [String, :+, Integer, :to_s]] }
         expect(input).to be_parsed_as output
       end
     end
 
     context 'for a global variable assignment' do
       it 'returns a Hash with key :cvasgn' do
         input  = "$name = 'John Doe' + 24.to_s"
-        output = { gvasgn: [:'$name', [String, :+, fixnum_or_integer, :to_s]] }
+        output = { gvasgn: [:'$name', [String, :+, Integer, :to_s]] }
         expect(input).to be_parsed_as output
       end
     end
@@ -45,13 +45,13 @@
     context 'for a multiple variable assignment' do
       it 'returns an assignment hash if RHS is an Array' do
         input  = "x, y = ['holy', 108]"
-        output = { masgn: { [:x, :y] => [String, fixnum_or_integer] } }
+        output = { masgn: { [:x, :y] => [String, Integer] } }
         expect(input).to be_parsed_as output
       end
 
       it 'returns an assignment hash if RHS is a variable list' do
         input  = "x, y = 'holy', 108"
-        output = { masgn: { [:x, :y] => [String, fixnum_or_integer] } }
+        output = { masgn: { [:x, :y] => [String, Integer] } }
         expect(input).to be_parsed_as output
       end
 
@@ -65,7 +65,7 @@
     context 'for an operation assignment' do
       it 'returns a Hash with key :op_asgn' do
         input  = 'a += 1'
-        output = { op_asgn: [{ lvasgn: [:a] }, :+, fixnum_or_integer] }
+        output = { op_asgn: [{ lvasgn: [:a] }, :+, Integer] }
         expect(input).to be_parsed_as output
       end
     end

spec/code_breaker/parser/data_types_spec.rb

@@ -15,21 +15,18 @@
         it "returns #{output} for #{input}" do
           expect(input).to be_parsed_as output
         end
+      end
 
-        it 'returns Fixnum or Integer for 1' do
-          expect(1).to be_parsed_as fixnum_or_integer
-        end
-
-        it 'returns Bignum or Integer for 4_611_686_018_427_387_904' do
-          expect(4_611_686_018_427_387_904).to be_parsed_as bignum_or_integer
-        end
+      it 'returns Integer for integers' do
+        expect(1).to be_parsed_as Integer
+        expect(4_611_686_018_427_387_904).to be_parsed_as Integer
       end
     end
 
     context 'for a root node representing an Array' do
       it 'returns a Hash with key :array and an Array of items' do
         input  = "[1, 'apple', :a, Day]"
-        output = { array: [fixnum_or_integer, String, Symbol, { const: :Day }] }
+        output = { array: [Integer, String, Symbol, { const: :Day }] }
         expect(input).to be_parsed_as output
       end
     end
@@ -59,7 +56,7 @@
     context 'for a root node representing an interpolated string' do
       it 'returns a Hash with key :dstr and an Array of interpolation values' do
         input  = '"#{1 + 2} interpolated string #{\'here\'}"'
-        output = { dstr: [[fixnum_or_integer, :+, fixnum_or_integer], String, [String]] }
+        output = { dstr: [[Integer, :+, Integer], String, [String]] }
         expect(input).to be_parsed_as output
       end
     end

spec/code_breaker/parser/keywords_spec.rb

@@ -6,7 +6,7 @@
       context "for a root node representing an #{connector} connection" do
         it 'returns a Hash with key :or and the connected children' do
           input  = "1.to_s #{connector} 5.5"
-          output = { or: [[fixnum_or_integer, :to_s], Float] }
+          output = { or: [[Integer, :to_s], Float] }
           expect(input).to be_parsed_as output
         end
       end
@@ -16,7 +16,7 @@
       context "for a root node representing an #{connector} connection" do
         it 'returns a Hash with key :and and the connected children' do
           input  = "1.to_s #{connector} 5.5"
-          output = { and: [[fixnum_or_integer, :to_s], Float] }
+          output = { and: [[Integer, :to_s], Float] }
           expect(input).to be_parsed_as output
         end
       end
@@ -26,15 +26,15 @@
       context 'with only an if clause' do
         it 'returns a Hash with key :if and the if clause body' do
           input  = "'2'.to_i if 2 == '2'"
-          output = { if: [fixnum_or_integer, :==, String], then: [String, :to_i] }
+          output = { if: [Integer, :==, String], then: [String, :to_i] }
           expect(input).to be_parsed_as output
         end
       end
 
       context 'with an if/then clause' do
         it 'returns a Hash with key :if and the if clause body' do
           input  = "if 2 == '2' then '2'.to_i end"
-          output = { if: [fixnum_or_integer, :==, String], then: [String, :to_i] }
+          output = { if: [Integer, :==, String], then: [String, :to_i] }
           expect(input).to be_parsed_as output
         end
       end
@@ -43,7 +43,7 @@
         it 'returns a Hash with key :if and the if clause body' do
           input  = "if 2 == '2' then '2'.to_i else Rational(2, 3).to_s end"
           output = {
-            if: [fixnum_or_integer, :==, String],
+            if: [Integer, :==, String],
             then: [String, :to_i],
             else: [Rational, :to_s]
           }
@@ -56,7 +56,7 @@
         it 'returns a Hash with key :if and the if clause body' do
           input  = "if 2 == '2' then '2'.to_i elsif true then Object.new end"
           output = {
-            if: [fixnum_or_integer, :==, String],
+            if: [Integer, :==, String],
             then: [String, :to_i],
             else: {
               if: TrueClass,
@@ -124,7 +124,7 @@
             module: [
               { const: :Breakable },
               [
-                { casgn: [:CONST, fixnum_or_integer] },
+                { casgn: [:CONST, Integer] },
                 { casgn: [:OTHER_CONST, [String, :freeze]] }
               ]
             ]
@@ -138,21 +138,21 @@
     context 'for a root node representing a return' do
       it 'returns a Hash with key :return and the returned value' do
         input  = 'return 3'
-        output = { return: fixnum_or_integer }
+        output = { return: Integer }
         expect(input).to be_parsed_as output
       end
 
       it 'returns a Hash with key :return and the returned values as Array' do
         input  = 'return 3 + 2'
-        output = { return: [fixnum_or_integer, :+, fixnum_or_integer] }
+        output = { return: [Integer, :+, Integer] }
         expect(input).to be_parsed_as output
       end
     end
 
     context 'for a root node representing a yield' do
       it 'returns a Hash with key :yield and the types of given arguments' do
         input  = "yield(3, 'beer')"
-        output = { yield: [fixnum_or_integer, String] }
+        output = { yield: [Integer, String] }
         expect(input).to be_parsed_as output
       end
 
@@ -184,7 +184,7 @@
         input  = "for i in 1..5 do\nputs i\nend"
         output = {
           for: { lvasgn: [:i] },
-          in: { irange: [fixnum_or_integer, fixnum_or_integer] },
+          in: { irange: [Integer, Integer] },
           do: [:puts, { lvar: :i }]
         }
 
@@ -247,9 +247,9 @@
             {
               case: [
                 { lvar: :state },
-                { when: Symbol, then: [fixnum_or_integer, :to_s] },
-                { when: Symbol, then: [fixnum_or_integer, :to_s] },
-                { else: fixnum_or_integer }
+                { when: Symbol, then: [Integer, :to_s] },
+                { when: Symbol, then: [Integer, :to_s] },
+                { else: Integer }
               ]
             }
           ]
@@ -266,8 +266,8 @@
             {
               case: [
                 { lvar: :state },
-                { when: Symbol, then: [fixnum_or_integer, :to_s] },
-                { when: Symbol, then: [fixnum_or_integer, :to_s] },
+                { when: Symbol, then: [Integer, :to_s] },
+                { when: Symbol, then: [Integer, :to_s] },
                 { else: NilClass }
               ]
             }

spec/code_breaker/parser/language_elements_spec.rb

@@ -7,7 +7,7 @@
         input  = '5.times { |n| n.to_s }'
         output = {
           block: [
-            [fixnum_or_integer, :times],
+            [Integer, :times],
             { args: [{ arg: :n }] },
             [{ lvar: :n }, :to_s]
           ]
@@ -22,7 +22,7 @@
         input  = '[1, 2].reduce(0) { |sum, n| sum += n }'
         output = {
           block: [
-            [{ array: [fixnum_or_integer, fixnum_or_integer] }, :reduce, fixnum_or_integer],
+            [{ array: [Integer, Integer] }, :reduce, Integer],
             { args: [{ arg: :sum }, { arg: :n }] },
             { op_asgn: [{ lvasgn: [:sum] }, :+, { lvar: :n }] }
           ]
@@ -35,7 +35,7 @@
     context 'for a root node representing a block pass' do
       it 'returns an array with a Hash with the :block_pass key' do
         input  = '[1, 2].map &:to_s'
-        output = [{ array: [fixnum_or_integer, fixnum_or_integer] }, :map, { block_pass: :to_s }]
+        output = [{ array: [Integer, Integer] }, :map, { block_pass: :to_s }]
         expect(input).to be_parsed_as output
       end
     end
@@ -79,7 +79,7 @@
             {
               args: [
                 { arg: :name },
-                { optarg: [:options, { hash: [{ Symbol => fixnum_or_integer }] }] }
+                { optarg: [:options, { hash: [{ Symbol => Integer }] }] }
               ]
             },
             String
@@ -134,7 +134,7 @@
       context 'for a root node representing a splat operator' do
         it 'returns a Hash with key :splat and the splat values' do
           input  = 'puts(*[1,2])'
-          output = [:puts, { splat: { array: [fixnum_or_integer, fixnum_or_integer] } }]
+          output = [:puts, { splat: { array: [Integer, Integer] } }]
           expect(input).to be_parsed_as output
         end
       end

spec/code_breaker/parser/ranges_spec.rb

@@ -13,7 +13,7 @@
     context 'for a root node representing an exclusive range' do
       it 'returns a Hash with key :erange and the bounding types' do
         input  = '1.2...4'
-        output = { erange: [Float, fixnum_or_integer] }
+        output = { erange: [Float, Integer] }
         expect(input).to be_parsed_as output
       end
     end

spec/code_breaker/parser/wrappers_spec.rb

@@ -14,14 +14,14 @@
     context 'for a simple method call on Objects' do
       it 'returns an Array with the classes and methods' do
         input  = '1 + 3.5 * Rational(2,3) - Complex(1, 2)'
-        output = [fixnum_or_integer, :+, Float, :*, Rational, :-, Complex]
+        output = [Integer, :+, Float, :*, Rational, :-, Complex]
         expect(input).to be_parsed_as output
       end
 
       describe 'with braces' do
         it 'returns a nested Array with the classes and methods' do
           input  = '((1 + 3.5) - Rational(2,3)) * Complex(1, 2)'
-          output = [[[fixnum_or_integer, :+, Float], :-, Rational], :*, Complex]
+          output = [[[Integer, :+, Float], :-, Rational], :*, Complex]
           expect(input).to be_parsed_as output
         end
       end

spec/spec_helper.rb

@@ -2,7 +2,3 @@
 require 'code_breaker'
 
 Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |f| require f }
-
-RSpec.configure do |config|
-  config.include VersionHelpers
-end