seeing_is_believing 1.0.1 → 2.0.0.beta1

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 1.0.1
+  prerelease: 6
+  version: 2.0.0.beta1
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 2.0.0.pre6
     none: false
@@ -23,7 +23,7 @@ dependencies:
   prerelease: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
         version: 2.0.0.pre6
     none: false
@@ -140,10 +140,10 @@ files:
 - lib/seeing_is_believing/debugger.rb
 - lib/seeing_is_believing/error.rb
 - lib/seeing_is_believing/evaluate_by_moving_files.rb
-- lib/seeing_is_believing/expression_list.rb
 - lib/seeing_is_believing/hard_core_ensure.rb
 - lib/seeing_is_believing/has_exception.rb
 - lib/seeing_is_believing/line.rb
+- lib/seeing_is_believing/program_rewriter.rb
 - lib/seeing_is_believing/queue.rb
 - lib/seeing_is_believing/remove_inline_comments.rb
 - lib/seeing_is_believing/result.rb
@@ -157,9 +157,9 @@ files:
 - spec/binary/remove_previous_annotations_spec.rb
 - spec/debugger_spec.rb
 - spec/evaluate_by_moving_files_spec.rb
-- spec/expression_list_spec.rb
 - spec/hard_core_ensure_spec.rb
 - spec/line_spec.rb
+- spec/program_rewriter_spec.rb
 - spec/queue_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/syntax_analyzer_spec.rb
@@ -179,9 +179,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
   none: false
 requirements: []
 rubyforge_project: seeing_is_believing
@@ -200,9 +200,9 @@ test_files:
 - spec/binary/remove_previous_annotations_spec.rb
 - spec/debugger_spec.rb
 - spec/evaluate_by_moving_files_spec.rb
-- spec/expression_list_spec.rb
 - spec/hard_core_ensure_spec.rb
 - spec/line_spec.rb
+- spec/program_rewriter_spec.rb
 - spec/queue_spec.rb
 - spec/seeing_is_believing_spec.rb
 - spec/syntax_analyzer_spec.rb

data/lib/seeing_is_believing/expression_list.rb

@@ -1,101 +0,0 @@
-require 'open3'
-require 'seeing_is_believing/debugger'
-require 'seeing_is_believing/syntax_analyzer'
-
-# can we get better debugging support so that we don't need to drop ANSI escape sequences in the middle of strings?
-class SeeingIsBelieving
-  class ExpressionList
-    PendingExpression = Struct.new :expression, :children do
-      # coloured debug because there's so much syntax that I get lost trying to parse the output
-      def inspect(debug=false)
-        colour1 = colour2 = lambda { |s| s }
-        colour1 = lambda { |s| "\e[30;46m#{s}\e[0m" } if debug
-        colour2 = lambda { |s| "\e[37;46m#{s}\e[0m" } if debug
-        "#{colour1['PE(']}#{colour2[expression.inspect]}#{colour1[',' ]}#{colour2[children.inspect]}#{colour1[')']}"
-      end
-    end
-
-    def initialize(options)
-      self.debugger       = options.fetch :debugger, Debugger.new(enabled: false)
-      self.get_next_line  = options.fetch :get_next_line
-      self.peek_next_line = options.fetch :peek_next_line
-      self.on_complete    = options.fetch :on_complete
-    end
-
-    def call
-      offset, expressions, expression = 0, [], nil
-      begin
-        pending_expression = generate(expressions)
-
-        debugger.context debugger_context do
-          "GENERATED: #{pending_expression.expression.inspect}, ADDING IT TO #{inspected_expressions expressions}"
-        end
-
-        expression = reduce expressions, offset unless next_line_modifies_current?
-
-        offset += 1
-      end until expressions.empty?
-      return expression, offset
-    end
-
-    private
-
-    attr_accessor :debugger, :get_next_line, :peek_next_line, :on_complete, :expressions
-
-    def debugger_context
-      "EXPRESSION EVALUATION"
-    end
-
-    def generate(expressions)
-      expression = get_next_line.call
-      raise SyntaxError unless expression
-      if expressions.last && SyntaxAnalyzer.unfinished_here_doc?(expressions.last.expression)
-        expressions.last.expression << "\n" << expression # more stupid \n -.-
-      else
-        expressions << PendingExpression.new(expression, [])
-      end
-      expressions.last
-    end
-
-    def next_line_modifies_current?
-      # method invocations can be put on the next line, and begin with a dot.
-      # I think that's the only case we need to worry about.
-      # e.g: `3\n.times { |i| p i }`
-      peek_next_line.call && SyntaxAnalyzer.next_line_modifies_current?(peek_next_line.call)
-    end
-
-    def inspected_expressions(expressions)
-      "[#{expressions.map { |pe| pe.inspect debugger.enabled? }.join(', ')}]"
-    end
-
-    def reduce(expressions, offset)
-      expressions.size.times do |i|
-        expression = expressions[i..-1].map { |e| [e.expression, *e.children] }
-                                       .flatten
-                                       .join("\n")        # must use newline otherwise can get expressions like `a\\+b` that should be `a\\\n+b`, former is invalid
-        return if children_will_never_be_valid? expression
-        next unless valid_ruby? expression
-        result = on_complete.call(expressions[i].expression,
-                                  expressions[i].children,
-                                  expressions[i+1..-1].map { |pe| [pe.expression, pe.children] }.flatten, # hmmm, not sure this is really correct, but it allows it to work for my use cases
-                                  offset)
-        expressions.replace expressions[0, i]
-        expressions[i-1].children << result unless expressions.empty?
-        debugger.context(debugger_context) { "REDUCED: #{result.inspect}, LIST: #{inspected_expressions expressions}" }
-        return result
-      end
-    end
-
-    def valid_ruby?(expression)
-      valid = SyntaxAnalyzer.valid_ruby? expression
-      debugger.context(debugger_context) { "#{valid ? "\e[32mIS VALID:" : "\e[31mIS NOT VALID:"}: #{expression.inspect}\e[0m" }
-      valid
-    end
-
-    def children_will_never_be_valid?(expression)
-      analyzer = SyntaxAnalyzer.new(expression)
-      analyzer.parse
-      analyzer.unclosed_string? || analyzer.unclosed_regexp? || SyntaxAnalyzer.unclosed_comment?(expression)
-    end
-  end
-end

data/spec/expression_list_spec.rb

@@ -1,277 +0,0 @@
-require 'seeing_is_believing/expression_list'
-
-describe SeeingIsBelieving::ExpressionList do
-
-  def list_for(generations, options={}, &block)
-    described_class.new({
-      on_complete:    block,
-      get_next_line:  -> { generations.shift || raise("EMPTY!") },
-      peek_next_line: -> { generations.first },
-    }.merge(options))
-  end
-
-  def call(generations, options={}, &block)
-    list_for(generations, options, &block).call
-  end
-
-  example 'example: multiple children' do
-    block_invocations = 0
-    result, size = call %w[begin b+ c x\\ + y end] do |line, children, completions, offset|
-      case offset
-      when 2
-        line.should == 'b+'
-        children.should == []
-        completions.should == ['c']
-        block_invocations += 1
-        'b+c'
-      when 5
-        line.should == 'x\\'
-        children.should == []
-        completions.should == ['+', 'y']
-        block_invocations += 10
-        "x+y"
-      when 6
-        line.should == 'begin'
-        children.should == ['b+c', 'x+y']
-        completions.should == ['end']
-        block_invocations += 100
-        'ALL DONE!'
-      else
-        raise "offset: #{offset.inspect}"
-      end
-    end
-    result.should == 'ALL DONE!'
-    size.should == 7
-    block_invocations.should == 111
-  end
-
-
-  example 'example: nested children' do
-    block_invocations = 0
-    expressions = [ '[1].map do |n1|',
-                    '  [2].map do |n2|',
-                    '    n1 + n2',
-                    '  end',
-                    'end',
-                  ]
-    result, size = call expressions do |line, children, completions, offset|
-      case offset
-      when 2
-        [line, children, completions].should == ['    n1 + n2', [], []]
-        block_invocations += 1
-      when 3
-        [line, children, completions].should == ['  [2].map do |n2|', ['    n1 + n2'], ['  end']]
-        block_invocations += 10
-      when 4
-        [line, children, completions].should == ['[1].map do |n1|',
-                                                 ["  [2].map do |n2|\n    n1 + n2\n  end"],
-                                                 ['end']]
-        block_invocations += 100
-      else
-        raise "line_number: #{line_number.inspect}"
-      end
-      [line, *children, *completions].join("\n")
-    end
-    block_invocations.should == 111
-    result.should ==  "[1].map do |n1|\n"\
-                      "  [2].map do |n2|\n"\
-                      "    n1 + n2\n"\
-                      "  end\n"\
-                      "end"
-    size.should == 5
-  end
-
-
-  example 'example: completions that have children' do
-    block_invocations = 0
-    expressions = [ "[1].map do |n1|",
-                      "[2].map do |n2|",
-                        "n1 + n2",
-                     "end end",
-                  ]
-    result, size = call expressions do |line, children, completions, offset|
-      case offset
-      when 2
-        [line, children, completions].should == ["n1 + n2", [], []]
-        block_invocations += 1
-      when 3
-        # not really sure what this *should* be like, but if this is the result,
-        # then it will work for the use cases I need it for
-        [line, *children, *completions].should == ["[1].map do |n1|",
-                                                   "[2].map do |n2|",
-                                                   "n1 + n2",
-                                                   'end end']
-        block_invocations += 10
-      else
-        raise "offset: #{offset.inspect}"
-      end
-      [line, *children, *completions].join("\n")
-    end
-    block_invocations.should == 11
-    result.should == "[1].map do |n1|\n"\
-                      "[2].map do |n2|\n"\
-                        "n1 + n2\n"\
-                     "end end"
-    size.should == 4
-  end
-
-  example 'example: completions who requires its children to be considered for the expression to be valid' do
-    block_invocations = 0
-    result, size = call ["if true &&", "true", "1", "end"] do |line, children, completions, offset|
-      case offset
-      when 1
-        [line, children, completions].should == ['true', [], []]
-        block_invocations += 1
-      when 2
-        [line, children, completions].should == ['1', [], []]
-        block_invocations += 10
-      when 3
-        [line, children, completions].should == ['if true &&', ['true', '1'], ['end']]
-        block_invocations += 100
-      end
-      [line, *children, *completions].join("\n")
-    end
-    block_invocations.should == 111
-    result.should == "if true &&\ntrue\n1\nend"
-    size.should == 4
-  end
-
-  example 'example: multiline strings with valid code in them' do
-    block_invocations = 0
-    call ["'", "1", "'"] do |*expressions, offset|
-      expressions.join('').should == "'1'"
-      offset.should == 2
-      block_invocations += 1
-    end
-    block_invocations.should == 1
-  end
-
-  example 'example: multiline regexps with valid code in them' do
-    block_invocations = 0
-    call ['/', '1', '/'] do |*expressions, offset|
-      expressions.join('').should == "/1/"
-      offset.should == 2
-      block_invocations += 1
-    end
-    block_invocations.should == 1
-  end
-
-  example "example: =begin/=end comments" do
-    block_invocations = 0
-    call ['=begin', '1', '=end'] do |*expressions, offset|
-      expressions.join('').should == "=begin1=end"
-      offset.should == 2
-      block_invocations += 1
-    end
-    block_invocations.should == 1
-  end
-
-  example "example: heredoc" do
-    pending 'Not sure how to do this, for now just catch it at a higher level' do
-      result, size = call ['strings = [<<A, <<-B]', '1', 'A', '2', ' B'] do |*expressions, offset|
-        offset.should == 1
-        expressions.should == ['strings = [<<A, <<B]']
-        'zomg!'
-      end
-      result.should == "zomg!\n1\nA\n2\n B"
-      size.should == 5
-    end
-  end
-
-  example "example: method invocations on next line", not_implemented: true do
-    pending 'I need to *actually* parse the Ruby in order to be able to identify where to split the expressions :('
-    # example 1: consume the expression with lines after
-    list = list_for ['a', '.b', ' .c', 'irrelevant'] do |*expressions, offset|
-      flat_expressions = expressions.flatten.join('')
-      case offset
-      when 0
-        flat_expressions.should == 'a'
-        'A'
-      when 1
-        flat_expressions.should == 'A.b'
-        'A.B'
-      when 2
-        flat_expressions.should == 'A.B .c'
-        'A.B.C'
-      else
-        raise "O.o"
-      end
-    end
-    list.call.should == ['A.B.C', 3]
-
-    # example 2: consume the expression with no lines after
-    list = list_for ['a', '.b'] do |*expressions, offset|
-      flat_expressions = expressions.flatten.join('')
-      case offset
-      when 0
-        flat_expressions.should == 'a'
-        'A'
-      when 1
-        flat_expressions.should == 'A.b'
-        'A.B'
-      else
-        raise "O.o"
-      end
-    end
-    list.call.should == ['A.B', 2]
-  end
-
-  example "example: method invocations on next line with the first line not being its own expression", not_implemented: true do
-    pending 'I need to *actually* parse the Ruby in order to be able to identify where to split the expressions :('
-    list = list_for ['x = a', '.b', ' .c', 'irrelevant'] do |*expressions, offset|
-      flat_expressions = expressions.flatten.join('')
-      case offset
-      when 0
-        flat_expressions.should == 'a'
-        'A'
-      when 1
-        flat_expressions.should == 'A.b'
-        'A.B'
-      when 2
-        flat_expressions.should == 'x = A.B .c'
-        'X=A.B.C'
-      else
-        raise "O.o"
-      end
-    end
-    list.call.should == ['X=A.B.C', 3]
-
-    list = list_for ['puts a', '.b', ' .c', 'irrelevant'] do |*expressions, offset|
-      flat_expressions = expressions.flatten.join('')
-      case offset
-      when 0
-        flat_expressions.should == 'a'
-        'A'
-      when 1
-        flat_expressions.should == 'A.b'
-        'A.B'
-      when 2
-        flat_expressions.should == 'puts A.B .c'
-        'PUTS A.B.C'
-      else
-        raise "O.o"
-      end
-    end
-    list.call.should == ['PUTS A.B.C', 3]
-  end
-
-  example "example: smoke test debug option" do
-    debugger = SeeingIsBelieving::Debugger.new
-    call(%w[a+ b], debugger: debugger) { |*expressions, _| expressions.join("\n") }
-    debugger.to_s.should include "GENERATED"
-    debugger.to_s.should include "REDUCED"
-  end
-
-  # in reality, the problem may just lie with our lib
-  # but it should be correct in most cases
-  it 'Raises a syntax error if it cannot generate the expression' do
-    generations = ["'"]
-    expect do
-      described_class.new(
-        on_complete:    -> { "" },
-        get_next_line:  -> { generations.shift },
-        peek_next_line: -> { generations.first }
-      ).call
-    end.to raise_error SyntaxError
-  end
-end