code_breaker 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3b10f45d7870b6729fc5b5632f03351e45014589
-  data.tar.gz: 40d6687ab9d31cda37ef4cf9d0bb881899e7f047
+SHA256:
+  metadata.gz: 34e130c3a963be818c41a997843620e65a3e89aa4daa4aad2d0ffdb8aa380087
+  data.tar.gz: e55c8809962f90a39ff8b5ad73f7cb1b3b45d2572f8954578fefabfe8ba00051
 SHA512:
-  metadata.gz: 052ec71488e79e1e53bf761976fc16ba2c409469a6c0f8de0be8d41b14db445804564b90ec1007a694e7c1eb287772e1493993434593d30a9152faeef41d804f
-  data.tar.gz: e02cf3f28507ca5ae3e52ae2a031b73665921aa99e684bc7a1b150820a73a8043fef8ee5fed76b9b9cb3b0835a866838d979391f9c42e99e1e00432da0c40740
+  metadata.gz: 42ed1c04674bb3049df6c4a1805cda4e17594ca84f99d48ceb159a9d96580d0061bb9d4c774bb33b0f77dcdb106ab145c616aaaa2a456e0825f2ac3ae213e847
+  data.tar.gz: dbb5fe81fa8690056f738496add777f80ae6aab7ab3d36fac9834096cd9ded694bd8ebf744fbfb2926ca83b37039231d23b15679249a922f98a39d5f86932dd1

data/.github/workflows/main.yml

@@ -0,0 +1,33 @@
+name: Ruby CI
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-latest, macos-latest, windows-latest ]
+        ruby: [ 2.5, 2.6, 2.7, ruby-head ]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - uses: actions/cache@v2
+      with:
+        path: vendor/bundle
+        key: ${{ matrix.os }}-gems-${{ hashFiles('**/Gemfile.lock') }}
+        restore-keys: |
+          ${{ matrix.os }}-gems-
+    - name: Install dependencies
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+    - name: Run Tests
+      run: bundle exec rake default

data/README.md

@@ -1,6 +1,6 @@
 # CodeBreaker
 
-[![Build Status](https://travis-ci.org/daigaku-ruby/code_breaker.svg?branch=master)](https://travis-ci.org/daigaku-ruby/code_breaker)
+[![Build Status](https://github.com/daigaku-ruby/code_breaker/workflows/Ruby%20CI/badge.svg)](https://github.com/daigaku-ruby/code_breaker/workflows/Ruby%20CI/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
@@ -13,7 +13,7 @@ sum = Rational(2, 3) + 4
 ```
 
 By breaking down this line into the receiver classes and called methods you can
-check e.g. whether a code snippet assigns the sum of a Rational and a Fixnum to
+check e.g. whether a code snippet assigns the sum of a Rational and an Integer to
 a variable with the name `sum`.
 
 Testing global code snippets might be important for testing the code of simple
@@ -44,7 +44,7 @@ require 'code_breaker'
 
 code_snippet = 'crazy_number = Rational(3, 5) + 42 - Complex(2.3, 6.4) * 1.2'
 CodeBreaker.parse(code_snippet)
-# => {:lvasgn=>[:crazy_number, [Rational, :+, Fixnum, :-, Complex, :*, Float]]}
+# => {:lvasgn=>[:crazy_number, [Rational, :+, Integer, :-, Complex, :*, Float]]}
 
 code_snippet = '"hello" + "World"'
 CodeBreaker.parse(code_snippet)
@@ -79,10 +79,8 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/daigaku-ruby/code_breaker. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
-
+Bug reports and pull requests are welcome on GitHub at https://github.com/daigaku-ruby/code_breaker. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant code of conduct](http://contributor-covenant.org/version/1/2/0).
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/Rakefile

@@ -1,6 +1,6 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "code_breaker"
+require 'bundler/setup'
+require 'code_breaker'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "code_breaker"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/code_breaker.gemspec

@@ -4,33 +4,33 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'code_breaker/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "code_breaker"
+  spec.name          = 'code_breaker'
   spec.version       = CodeBreaker::VERSION
-  spec.authors       = ["Paul Götze"]
-  spec.email         = ["paul.christoph.goetze@gmail.com"]
+  spec.authors       = ['Paul Götze']
+  spec.email         = ['paul.christoph.goetze@gmail.com']
 
-  spec.summary       = %q{Breaking a Ruby code snippet into a sequence of classes and their connecting methods.}
-  spec.description   = %q{Breaking a Ruby code snippet into a sequence of classes and their connecting methods.}
-  spec.homepage      = "https://github.com/daigaku-ruby/code_breaker"
-  spec.license       = "MIT"
+  spec.summary       = 'Breaking a Ruby code snippet into a sequence of classes and their connecting methods.'
+  spec.description   = 'Breaking a Ruby code snippet into a sequence of classes and their connecting methods.'
+  spec.homepage      = 'https://github.com/daigaku-ruby/code_breaker'
+  spec.license       = 'MIT'
 
   # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
   # delete this section to allow pushing this gem to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
   end
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '~> 2.5'
 
-  spec.add_dependency "parser", "~> 2.2"
-  spec.add_dependency "activesupport", "~> 4"
+  spec.add_dependency 'parser', '~> 2.7'
 
-  spec.add_development_dependency "bundler", "~> 1.10"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", " ~> 3.2"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake',    '~> 13.0'
+  spec.add_development_dependency 'rspec',   '~> 3.9'
 end

data/lib/code_breaker.rb

@@ -2,7 +2,6 @@ require 'code_breaker/version'
 require 'code_breaker/parser'
 
 module CodeBreaker
-
   def self.parse(code)
     CodeBreaker::Parser.new(code).run
   end

data/lib/code_breaker/parsable/assignments.rb

@@ -1,50 +1,60 @@
-require 'active_support/concern'
-
 module CodeBreaker
   module Parsable
     module Assignments
-
-      extend ActiveSupport::Concern
       include Parsable::Node
 
-      included do
-        alias :parse_lvasgn_node :parse_as_hash # local variable assignment
-        alias :parse_ivasgn_node :parse_as_hash # instance variable assignment
-        alias :parse_cvasgn_node :parse_as_hash # class variable assignment
-        alias :parse_gvasgn_node :parse_as_hash # global variable assignment
-        alias :parse_op_asgn_node :parse_as_hash # operation assignment
-        alias :parse_or_asgn_node :parse_as_hash # or assignment
-        alias :parse_and_asgn_node :parse_as_hash # and assignment
-
-        # multiple assignment
-        def parse_masgn_node(node)
-          lhs, rhs = parse_children(node)
-
-          values = if rhs.kind_of?(Hash) && rhs.has_key?(:array)
-            rhs[:array]
-          else
-            [rhs] + (1...lhs.count).map { NilClass }
-          end
-
-          { node.type => { lhs => values } }
-        end
+      # local variable assignment
+      alias_method :parse_lvasgn_node, :parse_as_hash
 
-        # multiple left hand side
-        def parse_mlhs_node(node)
-          parse_children(node).map(&:values).flatten
-        end
+      # instance variable assignment
+      alias_method :parse_ivasgn_node, :parse_as_hash
 
-        # constant assignment
-        def parse_casgn_node(node)
-          name = node.children[1]
-          children = node.children[2]
-          value = children.nil? ? name : [name, parse(node.children[2])]
+      # class variable assignment
+      alias_method :parse_cvasgn_node, :parse_as_hash
 
-          { node.type => value }
-        end
+      # global variable assignment
+      alias_method :parse_gvasgn_node, :parse_as_hash
+
+      # operation assignment
+      alias_method :parse_op_asgn_node, :parse_as_hash
+
+      # or assignment
+      alias_method :parse_or_asgn_node, :parse_as_hash
+
+      # and assignment
+      alias_method :parse_and_asgn_node, :parse_as_hash
+
+      # multiple assignment
+      def parse_masgn_node(node)
+        lhs, rhs = parse_children(node)
+        values   = multiple_assignment_values(lhs, rhs)
 
+        { node.type => { lhs => values } }
       end
 
+      # multiple left hand side
+      def parse_mlhs_node(node)
+        parse_children(node).map(&:values).flatten
+      end
+
+      # constant assignment
+      def parse_casgn_node(node)
+        name     = node.children[1]
+        children = node.children[2]
+        value    = children.nil? ? name : [name, parse(node.children[2])]
+
+        { node.type => value }
+      end
+
+      private
+
+      def multiple_assignment_values(lhs, rhs)
+        if rhs.is_a?(Hash) && rhs.key?(:array)
+          rhs[:array]
+        else
+          [rhs] + (1...lhs.count).map { NilClass }
+        end
+      end
     end
   end
 end

data/lib/code_breaker/parsable/data_types.rb

@@ -1,57 +1,64 @@
-require 'active_support/concern'
-
 module CodeBreaker
   module Parsable
     module DataTypes
-
-      extend ActiveSupport::Concern
       include Parsable::Node
 
-      included do
-        def parse_nil_node(node)
-          NilClass
-        end
+      def parse_nil_node(node)
+        NilClass
+      end
 
-        def parse_true_node(node)
-          TrueClass
-        end
+      def parse_true_node(node)
+        TrueClass
+      end
 
-        def parse_false_node(node)
-          FalseClass
-        end
+      def parse_false_node(node)
+        FalseClass
+      end
 
-        def parse_str_node(node)
-          String
-        end
+      def parse_str_node(node)
+        String
+      end
 
-        # interpolated executed string
-        def parse_xstr_node(node)
-          { node.type => parse_children(node).first }
-        end
+      # interpolated executed string
+      def parse_xstr_node(node)
+        { node.type => parse_children(node).first }
+      end
 
-        def parse_sym_node(node)
-          Symbol
+      # interpolated string
+      def parse_dstr_node(node)
+        values = parse_as_hash(node)[node.type].map do |value|
+          if value.is_a?(Array)
+            value.flatten(1)
+          else
+            value
+          end
         end
 
-        def parse_float_node(node)
-          Float
-        end
+        { node.type => values }
+      end
 
-        def parse_regexp_node(node)
-          Regexp
-        end
+      def parse_sym_node(node)
+        Symbol
+      end
 
-        def parse_int_node(node)
-          node.children[0].class
-        end
+      def parse_float_node(node)
+        Float
+      end
 
-        def parse_pair_node(node)
-          { parse(node.children[0]) => parse(node.children[1]) }
-        end
+      def parse_regexp_node(node)
+        Regexp
+      end
 
-        alias :parse_hash_node :parse_as_hash
-        alias :parse_array_node :parse_as_hash
+      def parse_int_node(node)
+        node.children[0].class
       end
+
+      def parse_pair_node(node)
+        { parse(node.children[0]) => parse(node.children[1]) }
+      end
+
+      alias_method :parse_hash_node,  :parse_as_hash
+      alias_method :parse_array_node, :parse_as_hash
     end
   end
 end

data/lib/code_breaker/parsable/keywords.rb

@@ -1,102 +1,95 @@
-require 'active_support/concern'
-
 module CodeBreaker
   module Parsable
     module Keywords
-
-      extend ActiveSupport::Concern
       include Parsable::Node
 
-      included do
-        alias :parse_or_node      :parse_as_hash
-        alias :parse_and_node     :parse_as_hash
-        alias :parse_def_node     :parse_as_hash
-        alias :parse_yield_node   :parse_as_hash
-        alias :parse_rescue_node  :parse_as_hash
-        alias :parse_resbody_node :parse_as_hash
+      alias_method :parse_or_node,      :parse_as_hash
+      alias_method :parse_and_node,     :parse_as_hash
+      alias_method :parse_def_node,     :parse_as_hash
+      alias_method :parse_yield_node,   :parse_as_hash
+      alias_method :parse_rescue_node,  :parse_as_hash
+      alias_method :parse_resbody_node, :parse_as_hash
 
-        alias :parse_break_node   :parse_as_node_type
-        alias :parse_next_node    :parse_as_node_type
-        alias :parse_retry_node   :parse_as_node_type
-        alias :parse_self_node    :parse_as_node_type
+      alias_method :parse_break_node,   :parse_as_node_type
+      alias_method :parse_next_node,    :parse_as_node_type
+      alias_method :parse_retry_node,   :parse_as_node_type
+      alias_method :parse_self_node,    :parse_as_node_type
 
-        def parse_loop_node(node)
-          condition = node.children[0]
-          body = node.children[1]
+      def parse_loop_node(node)
+        condition = node.children[0]
+        body      = node.children[1]
 
-          { node.type => parse(condition), do: parse(body) }
-        end
+        { node.type => parse(condition), do: parse(body) }
+      end
 
-        alias :parse_while_node :parse_loop_node
-        alias :parse_until_node :parse_loop_node
+      alias_method :parse_while_node, :parse_loop_node
+      alias_method :parse_until_node, :parse_loop_node
 
-        def parse_for_node(node)
-          variable  = node.children[0]
-          range     = node.children[1]
-          body      = node.children[2]
+      def parse_for_node(node)
+        variable  = node.children[0]
+        range     = node.children[1]
+        body      = node.children[2]
 
-          { node.type => parse(variable), in: parse(range), do: parse(body) }
-        end
+        { node.type => parse(variable), in: parse(range), do: parse(body) }
+      end
 
-        def parse_if_node(node)
-          condition = node.children[0]
-          if_body = node.children[1]
-          else_body = node.children[2]
+      def parse_if_node(node)
+        condition = node.children[0]
+        if_body   = node.children[1]
+        else_body = node.children[2]
 
-          clause = { node.type => parse(condition), then: parse(if_body) }
-          clause[:else] = parse(else_body) if else_body
+        clause = { node.type => parse(condition), then: parse(if_body) }
+        clause[:else] = parse(else_body) if else_body
 
-          clause
-        end
+        clause
+      end
 
-        def parse_module_node(node)
-          name = parse(node.children[0])
-          body = node.children[1].nil? ? nil : parse(node.children[1])
-          value = body ? [name, body] : [name]
+      def parse_module_node(node)
+        name  = parse(node.children[0])
+        body  = node.children[1].nil? ? nil : parse(node.children[1])
+        value = body ? [name, body] : [name]
 
-          { node.type => value }
-        end
+        { node.type => value }
+      end
 
-        def parse_return_node(node)
-          children = parse_children(node)
-          values = children.length == 1 ? children[0] : children
+      def parse_return_node(node)
+        children = parse_children(node)
+        values   = children.length == 1 ? children[0] : children
 
-          { node.type => values }
-        end
+        { node.type => values }
+      end
 
-        def parse_kwbegin_node(node)
-          rescue_given = node.children.first.type == :rescue
+      def parse_kwbegin_node(node)
+        rescue_given = node.children.first.type == :rescue
 
-          if rescue_given
-            rescue_part = parse(node.children.first)[:rescue]
+        if rescue_given
+          rescue_part = parse(node.children.first)[:rescue]
 
-            {
-              begin: rescue_part.first,
-              rescue: rescue_part.last[:resbody].first
-            }
-          else
-            { begin: parse(node.children.last) }
-          end
+          {
+            begin: rescue_part.first,
+            rescue: rescue_part.last[:resbody].first
+          }
+        else
+          { begin: parse(node.children.last) }
         end
+      end
 
-        def parse_case_node(node)
-          case_part = parse(node.children.first)
-          when_parts = node.children[1...-1].map { |child| parse(child) }
-          else_part = parse(node.children.last)
+      def parse_case_node(node)
+        case_part  = parse(node.children.first)
+        when_parts = node.children[1...-1].map { |child| parse(child) }
+        else_part  = parse(node.children.last)
 
-          statement = { case: when_parts.unshift(case_part) }
-          statement[:case] << { else: else_part } if else_part
-          statement
-        end
+        statement = { case: when_parts.unshift(case_part) }
+        statement[:case] << { else: else_part } if else_part
+        statement
+      end
 
-        def parse_when_node(node)
-          when_part = parse(node.children[0])
-          then_part = parse(node.children[1])
+      def parse_when_node(node)
+        when_part = parse(node.children[0])
+        then_part = parse(node.children[1])
 
-          { when: when_part, then: then_part }
-        end
+        { when: when_part, then: then_part }
       end
-
     end
   end
 end

data/lib/code_breaker/parsable/language_elements.rb

@@ -1,34 +1,36 @@
-require 'active_support/concern'
-
 module CodeBreaker
   module Parsable
     module LanguageElements
-
-      extend ActiveSupport::Concern
       include Parsable::Node
 
-      included do
-        alias :parse_block_node :parse_as_hash
-        alias :parse_args_node :parse_as_hash
-        alias :parse_arg_node :parse_as_last_child_hash
-        alias :parse_blockarg_node :parse_as_last_child_hash
-        alias :parse_restarg_node :parse_as_last_child_hash
-        alias :parse_optarg_node :parse_as_hash # optional argument
-        alias :parse_kwarg_node :parse_as_last_child_hash # keyword argument
-        alias :parse_kwoptarg_node :parse_as_hash # optional keyword argument
-        alias :parse_kwrestarg_node :parse_as_last_child_hash # keyword rest argument
-
-        def parse_block_pass_node(node)
-          { node.type => node.children.first.children.last }
-        end
-
-        def parse_splat_node(node)
-          children = parse_children(node).flatten(1)
-          values = children.length == 1 ? children[0] : children
-
-          { node.type =>  values }
-        end
+      alias_method :parse_block_node,    :parse_as_hash
+      alias_method :parse_args_node,     :parse_as_hash
+      alias_method :parse_arg_node,      :parse_as_last_child_hash
+      alias_method :parse_blockarg_node, :parse_as_last_child_hash
+      alias_method :parse_restarg_node,  :parse_as_last_child_hash
+
+      # optional argument
+      alias_method :parse_optarg_node, :parse_as_hash
+
+      # keyword argument
+      alias_method :parse_kwarg_node, :parse_as_last_child_hash
+
+      # optional keyword argument
+      alias_method :parse_kwoptarg_node, :parse_as_hash
+
+      # keyword rest argument
+      alias_method :parse_kwrestarg_node, :parse_as_last_child_hash
+
+      def parse_block_pass_node(node)
+        { node.type => node.children.first.children.last }
+      end
+
+      def parse_splat_node(node)
+        children = parse_children(node).flatten(1)
+        values   = children.length == 1 ? children[0] : children
+
+        { node.type => values }
       end
     end
   end
-end
+end

data/lib/code_breaker/parsable/node.rb

@@ -1,21 +1,22 @@
 module CodeBreaker
   module Parsable
     module Node
-
       def parse(node)
-        return if node.nil?
-
-        if node.kind_of?(Symbol)
+        if node.is_a?(Symbol)
           node
+        elsif node.nil?
+          parse_nil_node(node)
         else
           send("parse_#{node.type}_node", node)
         end
       end
 
-      def parse_children(node)
-        node.children.reduce([]) do |nodes, child|
-          nodes << parse(child) unless child.nil?
-          nodes
+      def parse_children(node, compact: true)
+        children = node.children
+        children = children.compact if compact
+
+        children.each_with_object([]) do |child, nodes|
+          nodes << parse(child)
         end
       end
 
@@ -32,21 +33,24 @@ module CodeBreaker
       end
 
       def method_missing(method, *args, &block)
-        node_type = method.to_s.match(/^parse_(.+)_node$/).captures.first
+        matches = method.to_s.match(/^parse_(.+)_node$/)
+        node_type = matches ? matches.captures.first : []
 
         if node_type.empty?
           super
         else
-          message = [
-            "Breaking the node type \"#{node_type}\" is not yet implemented.",
-            "You can open an issue on this in the project's Github repo under:",
-            "https://github.com/daigaku-ruby/code_breaker/issues/new\n"
-          ].join("\n")
-
-          raise NotImplementedError, message
+          raise NotImplementedError, not_implemented_message(node_type)
         end
       end
 
+      def not_implemented_message(node_type)
+        [
+          %(Breaking the node type "#{node_type}" is not yet implemented.),
+          'You can open an issue on this in the project’s Github repo under:',
+          'https://github.com/daigaku-ruby/code_breaker/issues/new',
+          ''
+        ].join("\n")
+      end
     end
   end
 end

data/lib/code_breaker/parsable/ranges.rb

@@ -1,15 +1,16 @@
-require 'active_support/concern'
-
 module CodeBreaker
   module Parsable
     module Ranges
-
-      extend ActiveSupport::Concern
       include Parsable::Node
 
-      included do
-        alias :parse_irange_node :parse_as_hash # inclusive range a..b
-        alias :parse_erange_node :parse_as_hash # exclusive range a...b
+      # inclusive range a..b, a.., ..b
+      def parse_irange_node(node)
+        { node.type => parse_children(node, compact: false) }
+      end
+
+      # exclusive range a...b, a..., ...b
+      def parse_erange_node(node)
+        { node.type => parse_children(node, compact: false) }
       end
     end
   end

data/lib/code_breaker/parsable/variable_types.rb

@@ -1,19 +1,21 @@
-require 'active_support/concern'
-
 module CodeBreaker
   module Parsable
     module VariableTypes
-
-      extend ActiveSupport::Concern
       include Parsable::Node
 
-      included do
-        alias :parse_const_node :parse_as_last_child_hash
-        alias :parse_lvar_node :parse_as_last_child_hash # local variable
-        alias :parse_ivar_node :parse_as_last_child_hash # instance variable
-        alias :parse_cvar_node :parse_as_last_child_hash # class variable
-        alias :parse_gvar_node :parse_as_last_child_hash # global variable
-      end
+      alias_method :parse_const_node, :parse_as_last_child_hash
+
+      # local variable
+      alias_method :parse_lvar_node, :parse_as_last_child_hash
+
+      # instance variable
+      alias_method :parse_ivar_node, :parse_as_last_child_hash
+
+      # class variable
+      alias_method :parse_cvar_node, :parse_as_last_child_hash
+
+      # global variable
+      alias_method :parse_gvar_node, :parse_as_last_child_hash
     end
   end
 end

data/lib/code_breaker/parsable/wrappers.rb

@@ -1,23 +1,17 @@
-require 'active_support/concern'
-
 module CodeBreaker
   module Parsable
     module Wrappers
-
-      extend ActiveSupport::Concern
       include Parsable::Node
 
-      included do
-        def parse_send_node(node)
-          if [:Rational, :Complex].include?(node.children[1])
-            return node.children[1].to_s.constantize
-          end
-
-          parse_children(node).flatten(1)
+      def parse_send_node(node)
+        if [:Rational, :Complex].include?(node.children[1])
+          return Kernel.const_get(node.children[1].to_s)
         end
 
-        alias :parse_begin_node :parse_children
+        parse_children(node).flatten(1)
       end
+
+      alias_method :parse_begin_node, :parse_children
     end
   end
 end

data/lib/code_breaker/parser.rb

@@ -1,6 +1,5 @@
 require 'code_breaker/parsable'
 require 'parser/current'
-require 'active_support/inflector'
 
 module CodeBreaker
   class Parser
@@ -21,12 +20,12 @@ module CodeBreaker
     def run
       unless @output
         ast = ::Parser::CurrentRuby.parse(input)
-        @output = parse(ast.loc.node)
+        @output = ast.nil? ? [] : parse(ast.loc.node)
       end
 
       @output
     end
 
-    alias :output :run
+    alias output run
   end
 end

data/lib/code_breaker/version.rb

@@ -1,3 +1,3 @@
 module CodeBreaker
-  VERSION = "0.1.1"
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_breaker
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Paul Götze
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-22 00:00:00.000000000 Z
+date: 2020-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -16,70 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.9'
 description: Breaking a Ruby code snippet into a sequence of classes and their connecting
   methods.
 email:
@@ -88,9 +74,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -122,17 +108,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 3.1.3
 signing_key: 
 specification_version: 4
 summary: Breaking a Ruby code snippet into a sequence of classes and their connecting

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.0
-before_install: gem install bundler -v 1.10.6