seeing_is_believing 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+proving_grounds/*
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    seeing_is_believing (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.1.4)
+    cucumber (1.2.1)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 2.11.0)
+      json (>= 1.4.6)
+    diff-lcs (1.1.3)
+    gherkin (2.11.5)
+      json (>= 1.4.6)
+    json (1.7.6)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cucumber (~> 1.2.1)
+  rspec (~> 2.12.0)
+  seeing_is_believing!

data/bin/seeing_is_believing

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path '../../lib', __FILE__
+require 'seeing_is_believing/example_use'
+
+ARGV.each do |filename|
+  puts SeeingIsBelieving::ExampleUse.new(File.read filename).call
+end

data/features/binary.feature

@@ -0,0 +1,35 @@
+Feature: Running the binary
+  They say seeing is believing. So to believe that this works
+  I want to see that it works by making a binary to use the lib.
+
+  It should be approximately like xmpfilter, except that it should
+  run against every line.
+
+  Scenario: Some basic functionality
+    Given the file "f.rb":
+    """
+    a = '12'
+    a + a
+
+    5.times do |i|
+      i * 2
+    end
+    """
+    When I run "seeing_is_believing f.rb"
+    And stderr is empty
+    Then 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
+
+    """
+
+  Scenario: Printing within the file
+  Scenario: Raising exceptions
+  Scenario: Requiring other files
+  Scenario: Syntactically invalid file

data/features/step_definitions/steps.rb

@@ -0,0 +1,19 @@
+Given 'the file "$filename":' do |filename, body|
+  CommandLineHelpers.write_file filename, body
+end
+
+When 'I run "$command"' do |command|
+  @last_executed = CommandLineHelpers.execute command
+end
+
+Then /^(stderr|stdout) is:$/ do |stream_name, output|
+  @last_executed.send(stream_name).should == output
+end
+
+Then 'the exit status is $status' do |status|
+  @last_executed.exitstatus.to_s.should == status
+end
+
+Then /^(stderr|stdout) is empty$/ do |stream_name|
+  @last_executed.send(stream_name).should == ''
+end

data/features/support/env.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+require 'open3'
+
+
+module CommandLineHelpers
+  Invocation = Struct.new :stdout, :stderr, :status do
+    def exitstatus
+      status.exitstatus
+    end
+  end
+
+  extend self
+
+  def write_file(filename, body)
+    in_proving_grounds do
+      File.open(filename, 'w') { |file| file.write body }
+    end
+  end
+
+  def execute(command)
+    in_proving_grounds do
+      command = "PATH=#{bin_dir}:$PATH #{command}"
+      Invocation.new *Open3.capture3(command)
+    end
+  end
+
+  def in_proving_grounds(&block)
+    Dir.chdir proving_grounds_dir, &block
+  end
+
+  def proving_grounds_dir
+    File.join root_dir, 'proving_grounds'
+  end
+
+  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
+    end
+  end
+
+  def make_proving_grounds
+    FileUtils.mkdir_p proving_grounds_dir
+  end
+
+  def bin_dir
+    File.join root_dir, "bin"
+  end
+end
+
+CommandLineHelpers.make_proving_grounds

data/lib/seeing_is_believing.rb

@@ -0,0 +1,58 @@
+require 'stringio'
+
+require 'seeing_is_believing/result'
+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
+  end
+
+  def call
+    @memoized_result ||= begin
+      program = ''
+      program << expression_list.call until stream.eof?
+      $seeing_is_believing_current_result = @result # can we make this a threadlocal var on the class?
+      TOPLEVEL_BINDING.eval record_exceptions_in(program), 'program.rb', 1
+      @result
+    end
+  end
+
+  private
+
+  attr_reader :stream
+
+  def expression_list
+    @expression_list ||= ExpressionList.new generator: lambda { stream.gets.chomp },
+                                            on_complete: lambda { |line, children, completions, line_number|
+                                              @result.contains_line_number line_number
+                                              expression = [line, *children, *completions].join("\n")
+                                              if expression == ''
+                                                expression
+                                              else
+                                                record_yahself expression, line_number
+                                              end
+                                            }
+  end
+
+  def to_stream(string_or_stream)
+    return string_or_stream if string_or_stream.respond_to? :gets
+    StringIO.new string_or_stream
+  end
+
+  def record_yahself(line, line_number)
+    "($seeing_is_believing_current_result.record_result(#{line_number}, (#{line})))\n"
+  end
+
+  def record_exceptions_in(code)
+    require 'pp'
+    "begin;"\
+      "#{code};"\
+    "rescue Exception;"\
+      "line_number = $!.backtrace.first[/:\\d+:/][1..-2].to_i;"\
+      "$seeing_is_believing_current_result.record_exception line_number, $!;"\
+    "end"
+  end
+end

data/lib/seeing_is_believing/example_use.rb

@@ -0,0 +1,40 @@
+require 'seeing_is_believing'
+
+class SeeingIsBelieving
+  class ExampleUse
+    def initialize(body)
+      self.body = body
+    end
+
+    def call
+      body.each_line.with_index 1 do |line, index|
+        write_line line.chomp, results[index], line_length
+      end
+      output
+    end
+
+    private
+
+    attr_accessor :body
+
+    def results
+      @results ||= SeeingIsBelieving.new(body).call
+    end
+
+    def output
+      @result ||= ''
+    end
+
+    def write_line(line, results, line_length)
+      if results.any?
+        output << sprintf("%-#{line_length}s# => %s\n", line, results.join(', '))
+      else
+        output << line << "\n"
+      end
+    end
+
+    def line_length
+      @line_length ||= body.each_line.map(&:chomp).map(&:length).max + 2
+    end
+  end
+end

data/lib/seeing_is_believing/expression_list.rb

@@ -0,0 +1,74 @@
+require 'open3'
+
+class SeeingIsBelieving
+  class ExpressionList
+    PendingExpression = Struct.new :expression, :children do
+      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.debug_stream = options.fetch :debug_stream, $stdout
+      self.should_debug = options.fetch :debug, false
+      self.generator    = options.fetch :generator
+      self.on_complete  = options.fetch :on_complete
+      self.line_number  = 0
+      self.list         = []
+    end
+
+    def call
+      expression = nil
+      begin
+        generate
+        expression = reduce_expressions
+      end until list.empty?
+      expression
+    end
+
+    private
+
+    attr_accessor :debug_stream, :should_debug, :generator, :on_complete, :line_number, :list
+
+    def generate
+      @line_number += 1
+      expression = generator.call
+      debug? && debug("GENERATED: #{expression.inspect}, ADDING IT TO #{inspected_list}")
+      @list << PendingExpression.new(expression, [])
+    end
+
+    def inspected_list
+      "[#{@list.map { |pe| pe.inspect debug? }.join(', ')}]"
+    end
+
+    def debug?
+      @should_debug
+    end
+
+    def debug(message)
+      @debug_stream.puts message
+    end
+
+    def reduce_expressions
+      @list.size.times do |i|
+        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,
+                                  @list[i].children,
+                                  @list[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
+                                  @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(', ')}]")
+        return result
+      end
+    end
+
+    def valid_ruby?(expression)
+      Open3.capture3('ruby -c', stdin_data: expression).last.success?
+    end
+  end
+end

data/lib/seeing_is_believing/result.rb

@@ -0,0 +1,48 @@
+class SeeingIsBelieving
+  class Result
+    attr_reader :min_line_number, :max_line_number
+
+    def initialize
+      @min_line_number = @max_line_number = 1
+    end
+
+    def record_result(line_number, value)
+      contains_line_number line_number
+      results[line_number] << value.inspect
+      value
+    end
+
+    def record_exception(line_number, exception)
+      contains_line_number line_number
+      @exception_line_number = line_number
+      @exception = exception
+    end
+
+    def [](line_number)
+      results[line_number]
+    end
+
+    # uhm, maybe switch to #each and including Enumerable?
+    def to_a
+      (min_line_number..max_line_number).map do |line_number|
+        [line_number, [*self[line_number], *Array(exception_at line_number)]]
+      end
+    end
+
+    def contains_line_number(line_number)
+      @min_line_number = line_number if line_number < @min_line_number
+      @max_line_number = line_number if line_number > @max_line_number
+    end
+
+    private
+
+    def exception_at(line_number)
+      return unless @exception_line_number == line_number
+      @exception
+    end
+
+    def results
+      @results ||= Hash.new { |hash, line_number| hash[line_number] = [] }
+    end
+  end
+end

data/lib/seeing_is_believing/version.rb

@@ -0,0 +1,3 @@
+class SeeingIsBelieving
+  VERSION = '0.0.1'
+end

data/seeing_is_believing.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "seeing_is_believing/version"
+
+Gem::Specification.new do |s|
+  s.name        = "seeing_is_believing"
+  s.version     = SeeingIsBelieving::VERSION
+  s.authors     = ["Josh Cheek"]
+  s.email       = ["josh.cheek@gmail.com"]
+  s.homepage    = "https://github.com/JoshCheek/seeing_is_believing"
+  s.summary     = %q{Records results of every line of code in your file}
+  s.description = %q{Records the results of every line of code in your file (intended to be like xmpfilter), inspired by Brett Victor's JavaScript example in his talk "Inventing on Principle"}
+
+  s.rubyforge_project = "seeing_is_believing"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec",    "~> 2.12.0"
+  s.add_development_dependency "cucumber", "~> 1.2.1"
+end

data/spec/expression_list_spec.rb

@@ -0,0 +1,107 @@
+require 'seeing_is_believing/expression_list'
+
+describe SeeingIsBelieving::ExpressionList do
+
+  def call(generations, options={}, &block)
+    options = { on_complete: block, generator: -> { generations.shift || raise("EMPTY!") } }.merge(options)
+    described_class.new(options).call
+  end
+
+  example 'example: multiple children' do
+    block_invocations = 0
+    result = call %w[a( b+ c x\\ + y )] do |line, children, completions, line_number|
+      case line_number
+      when 3
+        line.should == 'b+'
+        children.should == []
+        completions.should == ['c']
+        block_invocations += 1
+        'b+c'
+      when 6
+        line.should == 'x\\'
+        children.should == []
+        completions.should == ['+', 'y']
+        block_invocations += 10
+        'x\\+y'
+      when 7
+        line.should == 'a('
+        children.should == ['b+c', 'x\\+y']
+        completions.should == [')']
+        block_invocations += 100
+        'ALL DONE!'
+      else
+        raise "line_number: #{line_number.inspect}"
+      end
+    end
+    result.should == 'ALL DONE!'
+    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 = call expressions do |line, children, completions, line_number|
+      case line_number
+      when 3
+        [line, children, completions].should == ['    n1 + n2', [], []]
+        block_invocations += 1
+      when 4
+        [line, children, completions].should == ['  [2].map do |n2|', ['    n1 + n2'], ['  end']]
+        block_invocations += 10
+      when 5
+        [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"
+  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 = call expressions do |line, children, completions, line_number|
+      case line_number
+      when 3
+        [line, children, completions].should == ["n1 + n2", [], []]
+        block_invocations += 1
+      when 4
+        # 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 "line_number: #{line_number.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"\
+  end
+end

data/spec/seeing_is_believing_spec.rb

@@ -0,0 +1,116 @@
+require 'seeing_is_believing'
+require 'stringio'
+
+describe SeeingIsBelieving do
+  def invoke(input)
+    described_class.new(input).call
+  end
+
+  def values_for(input)
+    invoke(input).to_a.map(&:last)
+  end
+
+  def stream(string)
+    StringIO.new string
+  end
+
+  it 'takes a string or stream and returns a result of the line numbers (counting from 1) and each inspected result from that line' do
+    input  = "1+1\n'2'+'2'"
+    output = [[1, ["2"]], [2, ['"22"']]]
+    invoke(input).to_a.should == output
+    invoke(stream input).to_a.should == output
+  end
+
+  it 'remembers context of previous lines' do
+    values_for("a=12\na*2").should == [['12'], ['24']]
+  end
+
+  it 'can be invoked multiple times, returning the same result' do
+    believer = described_class.new("$xyz||=1\n$xyz+=1")
+    believer.call.to_a.should == [[1, ['1']], [2, ['2']]]
+    believer.call.to_a.should == [[1, ['1']], [2, ['2']]]
+  end
+
+  it 'is evaluated at the toplevel' do
+    values_for('self').should == [['main']]
+  end
+
+  it 'records the value immediately, so that it is correct even if the result is mutated' do
+    values_for("a = 'a'\na << 'b'").should == [['"a"'], ['"ab"']]
+  end
+
+  it 'records each value when a line is evaluated multiple times' do
+    values_for("(1..2).each do |i|\ni\nend").should == [[], ['1', '2'], ['1..2']]
+  end
+
+  it 'evalutes to an empty array for lines that it cannot understand' do
+    values_for("[3].map do |n|\n n*2\n end").should == [[], ['6'], ['[6]']]
+    values_for("[1].map do |n1|
+                  [2].map do |n2|
+                    n1 + n2
+                  end
+                end").should == [[], [], ['3'], ['[3]'], ['[[3]]']]
+
+    values_for("[1].map do |n1|
+                  [2].map do |n2| n1 + n2
+                  end
+                end").should == [[], [], ['[3]'], ['[[3]]']]
+
+    values_for("[1].map do |n1|
+                  [2].map do |n2|
+                    n1 + n2 end
+                end").should == [[], [], ['[3]'], ['[[3]]']]
+
+    values_for("[1].map do |n1|
+                  [2].map do |n2|
+                    n1 + n2 end end").should == [[], [], ['[[3]]']]
+
+    values_for("[1].map do |n1|
+                  [2].map do |n2| n1 + n2 end end").should == [[], ['[[3]]']]
+
+    values_for("[1].map do |n1| [2].map do |n2| n1 + n2 end end").should == [['[[3]]']]
+
+    values_for("[1].map do |n1|
+                  [2].map do |n2|
+                    n1 + n2
+                end end").should == [[], [], ['3'], ['[[3]]']]
+
+    values_for("[1].map do |n1| [2].map do |n2|
+                  n1 + n2
+                end end").should == [[], ['3'], ['[[3]]']]
+
+    values_for("[1].map do |n1| [2].map do |n2|
+                  n1 + n2 end end").should == [[], ['[[3]]']]
+
+    values_for("[1].map do |n1| [2].map do |n2|
+                  n1 + n2 end
+                end").should == [[], [], ['[[3]]']]
+
+    values_for("1 +
+                    2").should == [[], ['3']]
+  end
+
+  it 'has no output for empty lines' do
+    values_for('').should == [[]]
+    values_for("1\n\n2").should == [['1'],[],['2']]
+  end
+
+  it 'stops executing on errors and reports them' do
+    result = values_for("12\nraise Exception, 'omg!'\n12")
+    result[0].should == ['12']
+
+    result[1].size.should == 1
+    exception = result[1].first
+    exception.class.should == Exception
+    exception.message.should == 'omg!'
+
+    result[2].should == []
+    result.size.should == 3
+  end
+
+  # something about printing to stdout
+  # something about printing to stderr
+  # something about when the whole input is invalid
+  # something about multi-line strings
+  # does not fuck up __LINE__ macro
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: seeing_is_believing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Josh Cheek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70170924125400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: *70170924125400
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &70170924124580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: *70170924124580
+description: Records the results of every line of code in your file (intended to be
+  like xmpfilter), inspired by Brett Victor's JavaScript example in his talk "Inventing
+  on Principle"
+email:
+- josh.cheek@gmail.com
+executables:
+- seeing_is_believing
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- bin/seeing_is_believing
+- features/binary.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+- lib/seeing_is_believing.rb
+- lib/seeing_is_believing/example_use.rb
+- lib/seeing_is_believing/expression_list.rb
+- lib/seeing_is_believing/result.rb
+- lib/seeing_is_believing/version.rb
+- seeing_is_believing.gemspec
+- spec/expression_list_spec.rb
+- spec/seeing_is_believing_spec.rb
+homepage: https://github.com/JoshCheek/seeing_is_believing
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: seeing_is_believing
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Records results of every line of code in your file
+test_files:
+- features/binary.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+- spec/expression_list_spec.rb
+- spec/seeing_is_believing_spec.rb