seeing_is_believing 0.0.2 → 0.0.3

data/Readme.md

@@ -2,65 +2,59 @@ Seeing Is Believing
 ===================
 
 Evaluates a file, recording the results of each line of code.
-You can then use this to display output values like Bret Victor does with JavaScript in his talk ["Inventing on Principle"][inventing_on_principle].
+You can then use this to display output values like Bret Victor does with JavaScript in his talk [Inventing on Principle][inventing_on_principle].
 Except, obviously, his is like a million better.
 
 Reeaally rough at the moment, but it works for simple examples.
 
 Also comes with a binary to show how it might be used.
 
-Install
-=======
-
-    gem install seeing_is_believing
-
 Use
 ===
 
-    $ cat proving_grounds/basic_functionality.rb
-
-```ruby
-a = '12'
-a + a
-
-5.times do |i|
-  i * 2
-end
-```
-
-    $ seeing_is_believing proving_grounds/basic_functionality.rb
-
 ```ruby
-a = '12'        # => "12"
-a + a           # => "1212"
-
+# $ seeing_is_believing proving_grounds/basic_functionality.rb
 5.times do |i|
   i * 2         # => 0, 2, 4, 6, 8
 end             # => 5
-```
-
-    $ cat proving_grounds/raises_exception.rb
 
-```ruby
-1 + 1
-raise "ZOMG!"
-1 + 1
+def meth(n)
+  n             # => "12", "34"
+end             # => nil
+meth "12"       # => "12"
+meth "34"       # => "34"
 ```
 
-    $ bin/seeing_is_believing proving_grounds/raises_exception.rb 2>/dev/null
-
 ```ruby
+# $ bin/seeing_is_believing proving_grounds/raises_exception.rb 2>/dev/null
 1 + 1          # => 2
 raise "ZOMG!"  # ~> RuntimeError: ZOMG!
 1 + 1
 ```
 
-    $ bin/seeing_is_believing proving_grounds/raises_exception.rb 1>/dev/null
-
 ```bash
+# $ bin/seeing_is_believing proving_grounds/raises_exception.rb 1>/dev/null
 ZOMG!
 ```
 
+Install
+=======
+
+    $ gem install seeing_is_believing
+
+Or if you haven't fixed your gem home, and you aren't using any version managers:
+
+    $ sudo gem install seeing_is_believing
+
+Known Issues
+============
+
+* comments will kill it, probably going to have to actually parse the code to fix this
+* multi-line strings will probably kill it, probably going to have to actually parse the code to fix this
+* I have no idea what happens if you talk to stdout/stderr directly. This should become a non-issue if we evaluate it in its own process like xmpfilter.
+* If it dies, it will take your program with it. Same as above. (e.g. running the binary against itself will cause it to recursively invoke itself forever WARNING: DON'T REALLY DO THAT, ITS CRAYAZAY)
+* No idea what happens if you give it a syntactically invalid file. It probably just raises an exception, but might possibly freeze up or something.
+
 License
 =======
 

data/features/binary.feature

@@ -8,24 +8,34 @@ Feature: Running the binary
   Scenario: Some basic functionality
     Given the file "basic_functionality.rb":
     """
-    a = '12'
-    a + a
-
     5.times do |i|
       i * 2
     end
+
+    def meth(n)
+      n
+    end
+
+    # some invocations
+    meth "12"
+    meth "34"
     """
     When I run "seeing_is_believing basic_functionality.rb"
     Then stderr is empty
     And the exit status is 0
     And stdout is:
     """
-    a = '12'        # => "12"
-    a + a           # => "1212"
-
     5.times do |i|
       i * 2         # => 0, 2, 4, 6, 8
     end             # => 5
+
+    def meth(n)
+      n             # => "12", "34"
+    end             # => nil
+
+    # some invocations
+    meth "12"       # => "12"
+    meth "34"       # => "34"
     """
 
   Scenario: Raising exceptions
@@ -48,3 +58,6 @@ Feature: Running the binary
   Scenario: Printing within the file
   Scenario: Requiring other files
   Scenario: Syntactically invalid file
+  Scenario: Passing a nonexistent file
+  Scenario: Evaluating a file that requires other files, from a different directory
+  Scenario: Passing the file on stdin

data/features/support/env.rb

@@ -34,10 +34,8 @@ module CommandLineHelpers
 
   def root_dir
     @root_dir ||= begin
-      dir = Dir.pwd
-      until Dir.glob("#{dir}/*").map(&File.method(:basename)).include?("features")
-        dir = File.expand_path File.dirname dir
-      end
+      dir = File.expand_path Dir.pwd
+      dir = File.dirname dir until Dir["#{dir}/*"].map { |fn| File.basename fn }.include?('lib')
       dir
     end
   end

data/lib/seeing_is_believing/example_use.rb

@@ -10,7 +10,9 @@ class SeeingIsBelieving
 
     def call
       body.each_line.with_index 1 do |line, index|
-        write_line line.chomp, results[index]
+        line_results = results[index]
+        self.exception = line_results.exception if line_results.has_exception?
+        output << format_line(line.chomp, line_results)
       end
       output
     end
@@ -19,9 +21,7 @@ class SeeingIsBelieving
       @result ||= ''
     end
 
-    def has_exception?
-      !!@exception
-    end
+    alias has_exception? exception
 
     private
 
@@ -31,19 +31,23 @@ class SeeingIsBelieving
       @results ||= SeeingIsBelieving.new(body).call
     end
 
-    def write_line(line, results)
-      if results.any?
-        output << sprintf("%-#{line_length}s# => %s\n", line, results.join(', '))
-      elsif results.has_exception?
-        self.exception = results.exception
-        output << sprintf("%-#{line_length}s# ~> %s: %s\n", line, results.exception.class, results.exception.message)
-      else
-        output << line << "\n"
-      end
+    # max line length of the body + 2 spaces for padding
+    def line_length
+      @line_length ||= 2 + body.each_line
+                               .map(&:chomp)
+                               .reject { |line| SyntaxAnalyzer.ends_in_comment? line }
+                               .map(&:length)
+                               .max
     end
 
-    def line_length
-      @line_length ||= body.each_line.map(&:chomp).map(&:length).max + 2
+    def format_line(line, line_results)
+      if line_results.has_exception?
+        sprintf "%-#{line_length}s# ~> %s: %s\n", line, line_results.exception.class, line_results.exception.message
+      elsif line_results.any?
+        sprintf "%-#{line_length}s# => %s\n", line, line_results.join(', ')
+      else
+        line + "\n"
+      end
     end
   end
 end

data/lib/seeing_is_believing/expression_list.rb

@@ -1,8 +1,10 @@
 require 'open3'
+require 'seeing_is_believing/syntax_analyzer'
 
 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
@@ -54,6 +56,7 @@ class SeeingIsBelieving
 
     def reduce_expressions
       @list.size.times do |i|
+        # uhm, should this expression we are checking for validity consider the children?
         expression = @list[i..-1].map(&:expression).join("\n") # must use newline otherwise can get expressions like `a\\+b` that should be `a\\\n+b`, former is invalid
         next unless valid_ruby? expression
         result = on_complete.call(@list[i].expression,
@@ -62,13 +65,13 @@ class SeeingIsBelieving
                                   @line_number)
         @list = @list[0, i]
         @list[i-1].children << result unless @list.empty?
-        debug? && debug("RESULT: #{result.inspect}, LIST: [#{@list.map { |e| e.inspect debug? }.join(', ')}]")
+        debug? && debug("REDUCED: #{result.inspect}, LIST: #{inspected_list}")
         return result
       end
     end
 
     def valid_ruby?(expression)
-      Open3.capture3('ruby -c', stdin_data: expression).last.success?
+      SyntaxAnalyzer.valid_ruby? expression
     end
   end
 end

data/lib/seeing_is_believing/result.rb

@@ -1,27 +1,11 @@
 class SeeingIsBelieving
+
   class Result
-    class Line
-      attr_reader :results
+    module HasException
       attr_accessor :exception
-
-      def initialize
-        @results = []
-      end
-
-      def <<(result)
-        results << result
-      end
-
-      def any?
-        results.any?
-      end
-
-      def join(*args)
-        results.join(*args)
-      end
-
       alias has_exception? exception
     end
+
     attr_reader :min_line_number, :max_line_number
 
     def initialize
@@ -46,7 +30,7 @@ class SeeingIsBelieving
     # probably not really useful, just exists to satisfy the tests
     def to_a
       (min_line_number..max_line_number).map do |line_number|
-        [line_number, [*self[line_number].results, *Array(self[line_number].exception)]]
+        [line_number, [*self[line_number], *Array(self[line_number].exception)]]
       end
     end
 
@@ -58,7 +42,9 @@ class SeeingIsBelieving
     private
 
     def results
-      @results ||= Hash.new { |hash, line_number| hash[line_number] = Line.new }
+      @results ||= Hash.new do |hash, line_number|
+        hash[line_number] = Array.new.extend HasException
+      end
     end
   end
 end

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -0,0 +1,49 @@
+require 'ripper'
+
+class SyntaxAnalyzer < Ripper::SexpBuilder
+
+  # I don't actually know if all of the error methods should invoke has_error!
+  # or just parse errors. I don't actually know how to produce the other errors O.o
+  #
+  # Here is what it is defining as of ruby-1.9.3-p125:
+  #   on_alias_error
+  #   on_assign_error
+  #   on_class_name_error
+  #   on_param_error
+  #   on_parse_error
+  instance_methods.grep(/error/i).each do |error_meth|
+    class_eval "
+      def #{error_meth}(*)
+        @has_error = true
+        super
+      end
+    "
+  end
+
+  def on_comment(*)
+    @has_comment = true
+    super
+  end
+
+  def self.parsed(code)
+    instance = new code
+    instance.parse
+    instance
+  end
+
+  def self.valid_ruby?(code)
+    !parsed(code).has_error?
+  end
+
+  def self.ends_in_comment?(code)
+    parsed(code.lines.to_a.last.to_s).has_comment?
+  end
+
+  def has_error?
+    @has_error
+  end
+
+  def has_comment?
+    @has_comment
+  end
+end

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/seeing_is_believing.rb

@@ -6,8 +6,8 @@ require 'seeing_is_believing/expression_list'
 # might not work on windows b/c of assumptions about line ends
 class SeeingIsBelieving
   def initialize(string_or_stream)
-    @stream      = to_stream string_or_stream
-    @result      = Result.new
+    @stream = to_stream string_or_stream
+    @result = Result.new
   end
 
   def call
@@ -29,10 +29,10 @@ class SeeingIsBelieving
                                             on_complete: lambda { |line, children, completions, line_number|
                                               @result.contains_line_number line_number
                                               expression = [line, *children, *completions].join("\n")
-                                              if expression == ''
-                                                expression
+                                              if expression == '' || ends_in_comment?(expression)
+                                                expression + "\n"
                                               else
-                                                record_yahself expression, line_number
+                                                record_yahself(expression, line_number) + "\n"
                                               end
                                             }
   end
@@ -43,16 +43,20 @@ class SeeingIsBelieving
   end
 
   def record_yahself(line, line_number)
-    "($seeing_is_believing_current_result.record_result(#{line_number}, (#{line})))\n"
+    "($seeing_is_believing_current_result.record_result(#{line_number}, (#{line})))"
   end
 
   def record_exceptions_in(code)
-    require 'pp'
+    # must use newline after code, or comments will comment out rescue section
     "begin;"\
-      "#{code};"\
+      "#{code}\n"\
     "rescue Exception;"\
       "line_number = $!.backtrace.first[/:\\d+:/][1..-2].to_i;"\
       "$seeing_is_believing_current_result.record_exception line_number, $!;"\
     "end"
   end
+
+  def ends_in_comment?(expression)
+    SyntaxAnalyzer.ends_in_comment? expression
+  end
 end

data/spec/expression_list_spec.rb

@@ -104,4 +104,13 @@ describe SeeingIsBelieving::ExpressionList do
                         "n1 + n2\n"\
                      "end end"\
   end
+
+  example "example; smoke test debug option" do
+    stream = StringIO.new
+    result = call %w[a+ b], debug: true, debug_stream: stream do |line, children, completions, line_number|
+      [line, *children, *completions].join("\n")
+    end
+    stream.string.should include "GENERATED"
+    stream.string.should include "REDUCED"
+  end
 end

data/spec/seeing_is_believing_spec.rb

@@ -90,6 +90,12 @@ describe SeeingIsBelieving do
                     2").should == [[], ['3']]
   end
 
+  it 'does not record expressions that end in a comment' do
+    values_for("1
+                2 # on internal expression
+                3 # at end of program").should == [['1'], [], []]
+  end
+
   it 'has no output for empty lines' do
     values_for('').should == [[]]
     values_for("1\n\n2").should == [['1'],[],['2']]
@@ -108,6 +114,7 @@ describe SeeingIsBelieving do
     result.size.should == 3
   end
 
+  # it ignores lines that end in comments
   # something about printing to stdout
   # something about printing to stderr
   # something about when the whole input is invalid

data/spec/syntax_analyzer_spec.rb

@@ -0,0 +1,19 @@
+require 'seeing_is_believing'
+
+describe SeeingIsBelieving::SyntaxAnalyzer do
+  it 'knows if syntax is valid' do
+    is_valid = lambda { |code| described_class.valid_ruby? code }
+    is_valid['+'].should be_false
+    is_valid['1+2'].should be_true
+  end
+
+  it 'knows if the last line is a comment' do
+    is_comment = lambda { |code| described_class.ends_in_comment? code }
+    is_comment['# whatev'].should be_true
+    is_comment['a # whatev'].should be_true
+    is_comment["a \n b # whatev"].should be_true
+    is_comment['a'].should be_false
+    is_comment["a # whatev \n b"].should be_false
+    is_comment[""].should be_false
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-02 00:00:00.000000000 Z
+date: 2013-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70263953788620 !ruby/object:Gem::Requirement
+  requirement: &70251047915180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.12.0
   type: :development
   prerelease: false
-  version_requirements: *70263953788620
+  version_requirements: *70251047915180
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70263953787880 !ruby/object:Gem::Requirement
+  requirement: &70251047914440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: 1.2.1
   type: :development
   prerelease: false
-  version_requirements: *70263953787880
+  version_requirements: *70251047914440
 description: Records the results of every line of code in your file (intended to be
   like xmpfilter), inspired by Bret Victor's JavaScript example in his talk "Inventing
   on Principle"
@@ -55,10 +55,12 @@ files:
 - lib/seeing_is_believing/example_use.rb
 - lib/seeing_is_believing/expression_list.rb
 - lib/seeing_is_believing/result.rb
+- lib/seeing_is_believing/syntax_analyzer.rb
 - lib/seeing_is_believing/version.rb
 - seeing_is_believing.gemspec
 - spec/expression_list_spec.rb
 - spec/seeing_is_believing_spec.rb
+- spec/syntax_analyzer_spec.rb
 homepage: https://github.com/JoshCheek/seeing_is_believing
 licenses: []
 post_install_message: 
@@ -89,3 +91,4 @@ test_files:
 - features/support/env.rb
 - spec/expression_list_spec.rb
 - spec/seeing_is_believing_spec.rb
+- spec/syntax_analyzer_spec.rb