seeing_is_believing 3.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c0318721dea2259939dac9f239eaf465f9a7d605
-  data.tar.gz: a9c3681770369df1da596a736c266ff51624603e
+  metadata.gz: ae473580cc4e716bb259237bd9a3f9f0e3983591
+  data.tar.gz: ac008a8042513f1facb360b0056c68f62abc29bb
 SHA512:
-  metadata.gz: 06109b5b546f05c712f17d3856fb5faf8e41579a00758dd3fe05a4bec5dd12028a532c6429529db257a15aebfe4bee5a574999f714f0ac2e22ab1986eafc267c
-  data.tar.gz: 12f47cae8b1613713ec81bc66a7156d89ed15a967b8c1b3a54af4bdc520cb25541bf2327cadf452eef2da14f4cf35ec4cd103c4718a3319ecbd1bdc035e076a4
+  metadata.gz: c1d3d802588b733162f26ef0a55985b9dd1987759f96f45e6af5de45ba531654fb6e92a2db8c6498ce4fc6a8ed0dee44bbc9bbac0d3d01e98b698e903484d186
+  data.tar.gz: 7268519db2a550356f6ca29044ac68177678dd6509f9bcdcd6f24c23676eae14d79167b8a88ee5cb3aa84ce0e76d6ae87259127c4390863863c5ae442af2845d

data/Readme.md

@@ -44,12 +44,73 @@ end
 `$ seeing_is_believing simple_example.rb` will print:
 
 ```ruby
-
 5.times do |i|  # => 5
   i * 2         # => 0, 2, 4, 6, 8
 end             # => 5
 ```
 
+`$ seeing_is_believing simple_example.rb --json` will print:
+
+```json
+{"stdout":"","stderr":"","exitstatus":0,"exception":null,"lines":{"1":["5"],"2":["0","2","4","6","8"],"3":["5"]}}
+```
+
+Protips
+=======
+
+These things have been useful for integrating.
+
+If you want to execute from some specific dir (eg if your editor is in the wrong dir)
+try using `Dir.chdir` at the top of the script.
+Eg I used that [here](https://github.com/JoshCheek/seeing_is_believing/issues/58#issuecomment-91600783)
+so I could run with a full Rails app available in "Completely against the real env".
+
+If you want some specific file to be available in that environment, require the fullpath to the file.
+Eg I used that [here](https://github.com/JoshCheek/seeing_is_believing/issues/58#issuecomment-91600783)
+to load up the Rils schema in "Running against the real schema".
+
+You can also set the `$LOAD_PATH` to a gem you're working on and then require files as if
+it was installed.
+
+You work with `gets` by setting `$stdin` to the `DATA` segment and writing inputs there.
+
+```ruby
+$stdin = DATA
+
+puts "What's your name?"
+name = gets.chomp
+puts "What's your favourite colour?"
+colour = gets.chomp
+puts "#{name}'s favourite colour is #{colour}."
+
+# >> What's your name?
+# >> What's your favourite colour?
+# >> Josh's favourite colour is brown.
+
+__END__
+Josh
+brown
+```
+
+Rescue lines you expect to explode so that it displays the expected result and continues evaluating.
+
+```ruby
+lambda { |x| x }.call()     rescue $!  # => #<ArgumentError: wrong number of arguments (given 0, expected 1)>
+lambda { |x| x }.call(1)               # => 1
+lambda { |x| x }.call(1, 2) rescue $!  # => #<ArgumentError: wrong number of arguments (given 2, expected 1)>
+```
+
+Use `fork` to look at what a program does when run two different ways.
+
+```ruby
+class A
+  fork && raise("omg")  # => nil
+rescue
+  $!                    # => #<RuntimeError: omg>
+else
+  :nothing_raised       # => :nothing_raised
+end                     # => #<RuntimeError: omg>, :nothing_raised
+```
 
 Use The Lib
 ===========

data/features/xmpfilter-style.feature

@@ -319,6 +319,52 @@ Feature: Xmpfilter style
     """
 
 
+  Scenario: When there are no results for the previous line it looks further back (#77)
+    Given the file "heredocs_and_blank_lines.rb":
+    """
+    # =>
+
+    <<DOC
+    1
+    DOC
+    # =>
+
+    2
+
+    # =>
+
+    if true
+      3
+      # =>
+    else
+      4
+      # =>
+    end
+    """
+    When I run "seeing_is_believing --xmpfilter-style heredocs_and_blank_lines.rb"
+    Then stdout is:
+    """
+    # =>
+
+    <<DOC
+    1
+    DOC
+    # => "1\n"
+
+    2
+
+    # => 2
+
+    if true
+      3
+      # => 3
+    else
+      4
+      # =>
+    end
+    """
+
+
 
   Scenario: Xmpfilter uses the same comment formatting as normal
     Given the file "xmpfilter_result_lengths.rb":

data/lib/seeing_is_believing/binary/annotate_marked_lines.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 require 'seeing_is_believing/code'
 
-
 # *sigh* need to find a way to join the annotators.
 # They are sinful ugly, kinda hard to work with,
 # and absurdly duplicated.
@@ -11,16 +10,37 @@ class SeeingIsBelieving
     # Based on the behaviour of xmpfilger (a binary in the rcodetools gem)
     # See https://github.com/JoshCheek/seeing_is_believing/issues/44 for more details
     class AnnotateMarkedLines
+      def self.map_markers_to_linenos(program, markers)
+        value_regex      = markers[:value][:regex]
+        recordable_lines = []
+        inspect_linenos  = []
+        pp_map           = {}
+        WrapExpressions.call program, before_each: -> line_number {
+          recordable_lines << line_number
+          ''
+        }
+
+        Code.new(program).inline_comments.each do |c|
+          next unless c.text[value_regex]
+          if c.whitespace_col == 0
+            lineno = c.line_number
+            loop do
+              lineno -= 1
+              break if recordable_lines.include?(lineno) || lineno.zero?
+            end
+            pp_map[c.line_number] = lineno
+          else
+            inspect_linenos << c.line_number
+          end
+        end
+
+        return inspect_linenos, pp_map
+      end
+
       def self.code_rewriter(markers)
         lambda do |program|
-          inspect_linenos = []
-          pp_linenos      = []
-          value_regex     = markers[:value][:regex]
-          Code.new(program).inline_comments.each do |c|
-            next unless c.text[value_regex]
-            c.whitespace_col == 0 ? pp_linenos      << c.line_number - 1
-                                  : inspect_linenos << c.line_number
-          end
+          inspect_linenos, pp_map = map_markers_to_linenos(program, markers)
+          pp_linenos = pp_map.values
 
           should_inspect = false
           should_pp      = false
@@ -81,6 +101,7 @@ class SeeingIsBelieving
             include_lines << exception_lineno
           end
 
+          _, pp_map = self.class.map_markers_to_linenos(@body, @options[:markers])
           new_body = RewriteComments.call @body, include_lines: include_lines do |comment|
             exception_on_line  = exception_lineno == comment.line_number
             annotate_this_line = comment.text[value_regex]
@@ -93,12 +114,13 @@ class SeeingIsBelieving
               whitespace = " " if whitespace.empty?
               [whitespace, FormatComment.call(0, exception_prefix, exception_result, @options)]
             elsif normal_annotation
-              result = @results[comment.line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
-              [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, result, @options)]
+              annotation = @results[comment.line_number].map { |result| result.gsub "\n", '\n' }.join(', ')
+              [comment.whitespace, FormatComment.call(comment.text_col, value_prefix, annotation, @options)]
             elsif pp_annotation
-              result = @results[comment.line_number-1, :pp].map { |result| result.chomp }.join("\n,") # ["1\n2", "1\n2", ...
-              swap_leading_whitespace_in_multiline_comment(result)
-              comment_lines = result.each_line.map.with_index do |comment_line, result_offest|
+              result     = @results[pp_map[comment.line_number], :pp]
+              annotation = result.map { |result| result.chomp }.join("\n,") # ["1\n2", "1\n2", ...
+              swap_leading_whitespace_in_multiline_comment(annotation)
+              comment_lines = annotation.each_line.map.with_index do |comment_line, result_offest|
                 if result_offest == 0
                   FormatComment.call(comment.whitespace_col, value_prefix, comment_line.chomp, @options)
                 else

data/lib/seeing_is_believing/version.rb

@@ -1,3 +1,3 @@
 class SeeingIsBelieving
-  VERSION = '3.0.0'
+  VERSION = '3.0.1'
 end

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -98,11 +98,17 @@ class SeeingIsBelieving
       case ast.type
       when :args, :redo, :retry, :alias, :undef, :null_node
         # no op
-      when :defs, :class, :module
+      when :defs, :module
         add_to_wrappings ast
         add_children ast, true
       when :rescue, :ensure, :return, :break, :next, :splat, :kwsplat
         add_children ast
+      when :class
+        name,      * = ast.children
+        namespace, * = name.children
+        add_to_wrappings ast
+        wrap_recursive namespace
+        add_children ast, true
       when :if
         if ast.location.kind_of? Parser::Source::Map::Ternary
           add_to_wrappings ast unless ast.children.any? { |child| code.void_value? child }
@@ -196,8 +202,14 @@ class SeeingIsBelieving
           add_to_wrappings ast
         end
         add_children ast
-      when :str, :dstr, :xstr, :regexp
+      when :str
+        add_to_wrappings ast
+
+      when :dstr, :regexp
         add_to_wrappings ast
+        ast.children
+           .select { |child| child.type == :begin }
+           .each { |child| add_children child }
 
       when :hash
         # method arguments might not have braces around them

data/spec/wrap_expressions_spec.rb

@@ -217,9 +217,9 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("alias $a $b")).to eq "alias $a $b"
     end
 
-    it 'wraps syscalls, but not code interpolated into them' do
+    it 'wraps syscalls, and the code interpolated into them' do
       expect(wrap("`a\nb`")).to eq "<`a\nb`>"
-      expect(wrap("`a\n\#{1\n2\n3}b`")).to eq "<`a\n\#{1\n2\n3}b`>"
+      expect(wrap("`a\n\#{1\n2\n3}b`")).to eq "<`a\n\#{<1>\n<2>\n3}b`>"
     end
   end
 
@@ -586,12 +586,10 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap("/a\nb/i")).to eq "</a\nb/i>"
     end
 
-    # eventually it would be nice if it wraped the interpolated portion,
-    # when the end of the line was not back inside the regexp
-    it 'wraps regexes with interpolation, but not the interpolated portion' do
+    it 'wraps regexes with interpolation, including the interpolated portion' do
       expect(wrap("/a\#{1}/")).to eq "</a\#{1}/>"
-      expect(wrap("/a\n\#{1}\nb/")).to eq "</a\n\#{1}\nb/>"
-      expect(wrap("/a\n\#{1\n}b/")).to eq "</a\n\#{1\n}b/>"
+      expect(wrap("/a\n\#{1}\nb/")).to eq "</a\n\#{<1>}\nb/>"
+      expect(wrap("/a\n\#{1\n}b/")).to eq "</a\n\#{<1>\n}b/>"
     end
   end
 
@@ -612,12 +610,10 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
       expect(wrap(%'"a\nb"')).to eq %'<"a\nb">'
     end
 
-    # eventually it would be nice if it wraped the interpolated portion,
-    # when the end of the line was not back inside the string
-    it 'wraps strings with interpolation, but not the interpolated portion' do
+    it 'wraps strings with interpolation, including the interpolated portion' do
       expect(wrap('"a#{1}"')).to eq '<"a#{1}">'
-      expect(wrap(%'"a\n\#{1}\nb"')).to eq %'<"a\n\#{1}\nb">'
-      expect(wrap(%'"a\n\#{1\n}b"')).to eq %'<"a\n\#{1\n}b">'
+      expect(wrap(%'"a\n\#{1}\nb"')).to eq %'<"a\n\#{<1>}\nb">'
+      expect(wrap(%'"a\n\#{1\n}b"')).to eq %'<"a\n\#{<1>\n}b">'
     end
 
     it 'wraps %, %q, %Q' do
@@ -709,21 +705,30 @@ RSpec.describe SeeingIsBelieving::WrapExpressions do
   end
 
   describe 'class definitions' do
-    it 'does not wrap the class definition, does wrap the body' do
+    it 'does wraps the class definition, and body' do
       expect(wrap("class A\n1\nend")).to eq "<class A\n<1>\nend>"
     end
 
-    it 'does not wrap the superclass definition' do
+    it 'does wraps the superclass definition' do
       expect(wrap("class A < B\nend")).to eq "<class A < <B>\nend>"
     end
 
-    it 'wraps the rescue body' do
+    it 'wraps the rescue, else, ensure body' do
+      expect(wrap("class A < B\n1\nrescue\n2\nelse\n3\nensure\n4\nend")).to eq "<class A < <B>\n<1>\nrescue\n<2>\nelse\n<3>\nensure\n<4>\nend>"
+    end
+
+    it 'wraps the else body' do
       expect(wrap("class A < B\n1\nrescue\n2\nend")).to eq "<class A < <B>\n<1>\nrescue\n<2>\nend>"
     end
 
-    it 'does not wrap the singleton class' do
+    it 'wraps the singleton class' do
       expect(wrap("class << self\n end")).to eq "<class << <self>\n end>"
     end
+
+    it 'wraps the namespace' do
+      expect(wrap("class A::B\nend")).to eq "<class <A>::B\nend>"
+      expect(wrap("class (\n1\nObject\n)::String\nend")).to eq "<class <(\n<1>\n<Object>\n)>::String\nend>"
+    end
   end
 
   describe 'module definitions' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seeing_is_believing
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-08 00:00:00.000000000 Z
+date: 2016-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -261,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: seeing_is_believing
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Records results of every line of code in your file