to_source 0.2.15 → 0.2.16

data/.gitignore

@@ -1,6 +1,6 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
-.rbx
-*.rbc
+/*.gem
+/.bundle
+/Gemfile.lock
+/pkg/*
+/.rbx
+/tmp

data/Changelog.md

@@ -1,3 +1,7 @@
+# v0.2.15 2013-01-25
+
+* [fixed] Handle Rubinius::AST::Case
+
 # v0.2.15 2013-01-24
 
 * [fixed] Emit dynamic regexp literals with split groups correctly

data/README.md

@@ -7,7 +7,7 @@ to_source
 
 Reverse parser to generate source code from the Rubinius AST. Also works well under MRI using the mutant-melbourne gem.
 
-Currently only support 1.9 mode!
+Currently only support for 1.9 mode!
 
 Installation
 ------------

data/bin/to_source

@@ -11,6 +11,7 @@ ARGV.each do |path|
     $stdout.puts(ToSource.to_source(ast))
   rescue
     ast.ascii_graph
+    $stderr.puts("Error in: #{path}")
     raise
   end
 end

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 40
-total_score: 619
+total_score: 719

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 22.2
+threshold: 21.4

data/config/roodi.yml

@@ -5,17 +5,17 @@ AssignmentInConditionalCheck:    {}
 CaseMissingElseCheck:            {}
 ClassLineCountCheck:
   line_count: 324
-ClassNameCheck:                  
-  pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/
+#ClassNameCheck:                  
+#  pattern: !ruby/regexp /\A(?:[A-Z]+|[A-Z][a-z](?:[A-Z]?[a-z])+)\z/
 ClassVariableCheck:              {}
 CyclomaticComplexityBlockCheck:
   complexity: 2
 CyclomaticComplexityMethodCheck:
-  complexity: 4
+  complexity: 5
 EmptyRescueBodyCheck:            {}
 ForLoopCheck:                    {}
 MethodLineCountCheck:
-  line_count: 9
+  line_count: 11
 MethodNameCheck:
   pattern: !ruby/regexp /\A(?:[a-z\d](?:_?[a-z\d])+[?!=]?|\[\]=?|==|<=>|<<|[+*&|-])\z/
 ModuleLineCountCheck:

data/config/site.reek

@@ -1,4 +1,7 @@
 ---
+UnusedParameters:
+  exclude:
+    - ToSource::Command#run 
 UncommunicativeParameterName:
   accept: []
   exclude: []
@@ -8,7 +11,7 @@ UncommunicativeParameterName:
   - !ruby/regexp /[0-9]$/
   - !ruby/regexp /[A-Z]/
 LargeClass:
-  max_methods: 11
+  max_methods: 14 # TODO move down to 10
   exclude: []
   enabled: true
   max_instance_variables: 3
@@ -53,7 +56,7 @@ NestedIterators:
   enabled: true
   max_allowed_nesting: 1
 LongMethod:
-  max_statements: 7
+  max_statements: 8 # TODO bring down to 5-6
   exclude: []
   enabled: true
 Duplication:

data/config/yardstick.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 63.4
+threshold: 100

data/lib/to_source.rb

@@ -45,7 +45,7 @@ require 'to_source/emitter/element_assignment'
 require 'to_source/emitter/if'
 require 'to_source/emitter/loop'
 require 'to_source/emitter/ensure'
-require 'to_source/emitter/receiver_case'
+require 'to_source/emitter/case'
 require 'to_source/emitter/when'
 require 'to_source/emitter/splat_when'
 require 'to_source/emitter/unless'

data/lib/to_source/command.rb

@@ -1,44 +1,106 @@
 module ToSource
+  # Abstract base class for emitter command
   class Command
     include Adamantium::Flat
 
+    # A null command
     NULL = Class.new(self) do
+
+      # Run command
+      #
+      # @param [State] _state
+      #
+      # @return [self]
+      #
+      # @api private
+      #
       def run(_state)
+        self
       end
     end.new.freeze
 
+    # Command that emits token
     class Token < self
+
+      # Return token content
+      #
+      # @return [String]
+      #
+      # @api private
+      #
       attr_reader :content
 
+      # Run command
+      #
+      # @param [State] state
+      #
+      # @return [self]
+      #
+      # @api private
+      #
       def run(state)
         state.push(self)
+        self
       end
 
     private
 
+      # Initialize object
+      #
+      # @param [String] content
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def initialize(content)
         @content = content
       end
+
     end
 
+    # Command that does a shift
     class Shift < self
       include Equalizer.new(:width)
 
+      # Return shift width
+      #
+      # @return [Fixnum]
+      #
+      # @api private
+      #
       attr_reader :width
 
+      # Run command
+      #
+      # @param [State] state
+      #
+      # @return [self]
+      #
+      # @api private
+      #
       def run(state)
         state.shift(width)
+        self
       end
 
     private
 
+      # Initialize command
+      #
+      # @param [Fixnum] width
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def initialize(width)
         @width = width
       end
 
       INDENT   = Shift.new( 2)
       UNINDENT = Shift.new(-2)
-
     end
+
   end
 end

data/lib/to_source/emitter.rb

@@ -1,89 +1,278 @@
 module ToSource
+  # Abstract base class for emitter
   class Emitter
     include Adamantium::Flat, Equalizer.new(:node)
 
+    # The emitter registry
     REGISTRY = {}
 
-    def self.handle(node_class)
-      REGISTRY[node_class]=self
-    end
-
+    # Build emitter for node
+    #
+    # @param [Rubinius::AST::Node] node
+    # @param [Array] buffer
+    #
+    # @return [Emitter]
+    #
+    # @api private
+    #
     def self.build(node, buffer = [])
       REGISTRY.fetch(node.class).new(node, buffer)
     end
 
+    # Run emitter for node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [String]
+    #
+    # @api private
+    #
     def self.run(node)
       build(node).source
     end
 
+    # Declare predicates
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.predicate(*names)
+      names.each do |name|
+        define_predicate(name)
+      end
+    end
 
-    def source
-      state = State.new
-      buffer.each do |command|
-        state.execute(command)
+    private_class_method :predicate
+
+    # Declare node delegators
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.delegate(*names)
+      names.each do |name|
+        define_delegator(name)
       end
-      state.source
     end
 
+    private_class_method :delegate
+
+    # Register emitter for node class
+    #
+    # @param [Class:Rubinius::AST::Node] node_class
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.handle(node_class)
+      REGISTRY[node_class]=self
+    end
+
+    private_class_method :handle
+
+    # Define node delegator
+    #
+    # @param [Symbol] name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.define_delegator(name)
+      define_method(name) do
+        node.public_send(name)
+      end
+      private(name)
+    end
+
+    private_class_method :define_delegator
+
+    # Define predicate
+    #
+    # @param [Symbol] name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.define_predicate(name)
+      predicate = :"#{name}?"
+      define_method(predicate) do
+        !!send(name)
+      end
+      private(predicate)
+    end
+
+    private_class_method :define_delegator
+
+    # Return buffer
+    #
+    # @return [Array<Command>]
+    #
+    # @api private
+    #
+    attr_reader :buffer
+
+    # Return node
+    #
+    # @return [Rubinius::AST::Node]
+    #
+    # @api private
+    # 
     attr_reader :node
 
+    # Initialize object
+    #
+    # @param [Rubinius::AST::Node] node
+    # @param [Array<Command>] buffer
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(node, buffer)
+      @node, @buffer = node, buffer
+      dispatch
+    end
+
+    # Return source
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def source
+      buffer.each_with_object(State.new) do |command, state|
+        state.execute(command)
+      end.source
+    end
+
   private
 
+    # Push command
+    #
+    # @param [Command] command
+    #
+    # @return [undefined]
+    #
+    # @api private
+    # 
     def push(command)
       buffer.push(command)
     end
 
+    # Emit new line
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
     def new_line
       emit("\n")
     end
 
+    # Emit single whitespace
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
     def space
       emit(' ')
     end
 
+    # Emit end keyword
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
     def emit_end
       emit(:end)
     end
 
+    # Push indent command
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
     def indent
       push(Command::Shift::INDENT)
     end
 
+    # Push unindent command
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
     def unindent
       push(Command::Shift::UNINDENT)
     end
 
-    def emit(name)
-      push(Command::Token.new(name))
+    # Push token with content
+    #
+    # @param [String] content
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def emit(content)
+      push(Command::Token.new(content))
     end
 
-    def visit(node)
-      self.class.build(node, buffer)
-    end
-
-    def run(emitter, node = self.node)
-      emitter.new(node, buffer)
+    # Run block indented
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def indented
+      indent
+      yield
+      unindent
     end
 
-    def self.delegate(*names)
-      names.each do |name|
-        define_delegator(name)
-      end
+    # Run block in parantheses
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def parantheses
+      emit('(')
+      yield
+      emit(')')
     end
 
-    def self.define_delegator(name)
-      define_method(name) do
-        node.public_send(name)
-      end
-      private name
+    # Visit descendant node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def visit(node)
+      self.class.build(node, buffer)
     end
 
-    attr_reader :buffer
-
-    def initialize(node, buffer)
-      @node, @buffer = node, buffer
-      dispatch
+    # Run emitter on buffer
+    #
+    # @param [Class:Emitter] emitter
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def run(emitter, node = self.node)
+      emitter.new(node, buffer)
     end
-
   end
 end