Merge branch 'release-0.1.0'

Author: paulgoetze

README.md

@@ -1,5 +1,8 @@
 # CodeBreaker
 
+[![Build Status](https://travis-ci.org/daigaku-ruby/code_breaker.svg?branch=master)](https://travis-ci.org/daigaku-ruby/code_breaker)
+[![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
 that are called on them.
 
@@ -21,18 +24,16 @@ programming tasks in learning tools like [Daigaku](https://github.com/daigaku-ru
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'code_breaker', github: 'daigaku-ruby/code_breaker'
+gem 'code_breaker'
 ```
 
 And then execute:
 
     $ bundle
 
-Or download and install it yourself as:
+Or install it yourself as:
 
-    $ git clone git@github.com:daigaku-ruby/code_breaker.git
-    $ cd code_breaker
-    $ rake install
+    $ gem install 'code_breaker'
 
 ## Usage
 
@@ -43,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)
-# => [:crazy_number, :'=', Rational, :+, Fixnum, :-, Complex, :*, Float]
+# => {:lvasgn=>[:crazy_number, [Rational, :+, Fixnum, :-, Complex, :*, Float]]}
 
 code_snippet = '"hello" + "World"'
 CodeBreaker.parse(code_snippet)
@@ -66,6 +67,10 @@ parser.input
 # => "\"hello\"+\"world\""
 ```
 
+## Implemented syntax
+
+For an overview of the implemented syntax and examples for certain parsed Ruby statement please see the project's [Wiki](https://github.com/daigaku-ruby/code_breaker/wiki).
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

lib/code_breaker.rb

@@ -1,5 +1,5 @@
-require "code_breaker/version"
-require "code_breaker/parser"
+require 'code_breaker/version'
+require 'code_breaker/parser'
 
 module CodeBreaker
 

lib/code_breaker/parsable.rb

@@ -0,0 +1,8 @@
+require 'code_breaker/parsable/node'
+require 'code_breaker/parsable/wrappers'
+require 'code_breaker/parsable/variable_types'
+require 'code_breaker/parsable/data_types'
+require 'code_breaker/parsable/assignments'
+require 'code_breaker/parsable/ranges'
+require 'code_breaker/parsable/keywords'
+require 'code_breaker/parsable/language_elements'

lib/code_breaker/parsable/assignments.rb

@@ -0,0 +1,50 @@
+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
+
+        # 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
+
+      end
+
+    end
+  end
+end

lib/code_breaker/parsable/data_types.rb

@@ -0,0 +1,60 @@
+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_true_node(node)
+          TrueClass
+        end
+
+        def parse_false_node(node)
+          FalseClass
+        end
+
+        def parse_str_node(node)
+          String
+        end
+
+        # interpolated executed string
+        def parse_xstr_node(node)
+          { node.type => parse_children(node).first }
+        end
+
+        def parse_sym_node(node)
+          Symbol
+        end
+
+        def parse_float_node(node)
+          Float
+        end
+
+        def parse_regexp_node(node)
+          Regexp
+        end
+
+        def parse_int_node(node)
+          node.children[0].class
+        end
+
+        def parse_hash_node(node)
+          { node.type => parse_children(node).inject(:merge).to_h }
+        end
+
+        def parse_pair_node(node)
+          { parse(node.children[0]) => parse(node.children[1]) }
+        end
+
+        alias :parse_array_node :parse_as_hash
+      end
+    end
+  end
+end

lib/code_breaker/parsable/keywords.rb

@@ -0,0 +1,104 @@
+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_module_node  :parse_as_hash
+        alias :parse_yield_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 :parse_rescue_node  :parse_as_hash
+        alias :parse_resbody_node  :parse_as_hash
+        alias :parse_case_node  :parse_as_hash
+
+        def parse_loop_node(node)
+          condition = node.children[0]
+          body = node.children[1]
+
+          { node.type => parse(condition), do: parse(body) }
+        end
+
+        alias :parse_while_node :parse_loop_node
+        alias :parse_until_node :parse_loop_node
+
+        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
+
+        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
+        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]
+
+          { node.type => value }
+        end
+
+        def parse_return_node(node)
+          children = parse_children(node)
+          values = children.length == 1 ? children[0] : children
+
+          { node.type => values }
+        end
+
+        def parse_kwbegin_node(node)
+          rescue_given = node.children.first.type == :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
+        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)
+
+          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])
+
+          { when: when_part, then: then_part }
+        end
+      end
+
+    end
+  end
+end

lib/code_breaker/parsable/language_elements.rb

@@ -0,0 +1,34 @@
+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
+      end
+    end
+  end
+end

lib/code_breaker/parsable/node.rb

@@ -0,0 +1,52 @@
+module CodeBreaker
+  module Parsable
+    module Node
+
+      def parse(node)
+        return if node.nil?
+
+        if node.kind_of?(Symbol)
+          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
+        end
+      end
+
+      def parse_as_hash(node)
+        { node.type => parse_children(node) }
+      end
+
+      def parse_as_last_child_hash(node)
+        { node.type => node.children.last }
+      end
+
+      def parse_as_node_type(node)
+        node.type
+      end
+
+      def method_missing(method, *args, &block)
+        node_type = method.to_s.match(/^parse_(.+)_node$/).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
+        end
+      end
+
+    end
+  end
+end

lib/code_breaker/parsable/ranges.rb

@@ -0,0 +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
+      end
+    end
+  end
+end