seeing_is_believing 2.0.0.beta1 → 2.0.0.beta2

data/lib/seeing_is_believing/binary/line_formatter.rb

@@ -1,47 +0,0 @@
-class SeeingIsBelieving
-  class Binary
-    class LineFormatter
-      attr_accessor :line, :separator, :result, :options
-
-      def initialize(line, separator, result, options)
-       self.line      = line
-       self.separator = separator
-       self.result    = result.gsub "\n", '\n'
-       self.options   = options
-      end
-
-      def call
-        return line unless sep_plus_result.start_with? separator
-        return line unless formatted_line.start_with? "#{line_with_padding}#{separator}"
-        formatted_line
-      end
-
-      private
-
-      def line_length
-        options.fetch :line_length, Float::INFINITY
-      end
-
-      def result_length
-        options.fetch :result_length, Float::INFINITY
-      end
-
-      def sep_plus_result
-        @sep_plus_result ||= truncate "#{separator}#{result}", result_length
-      end
-
-      def formatted_line
-        @formatted_line ||= truncate "#{line_with_padding}#{sep_plus_result}", line_length
-      end
-
-      def line_with_padding
-        "%-#{options[:pad_to]}s" % line
-      end
-
-      def truncate(string, length)
-        return string if string.size <= length
-        string.slice(0, length).sub(/.{0,3}$/) { |last_chars| last_chars.gsub /./, '.' }
-      end
-    end
-  end
-end

data/lib/seeing_is_believing/binary/remove_previous_annotations.rb

@@ -1,75 +0,0 @@
-require 'seeing_is_believing/remove_inline_comments'
-
-class SeeingIsBelieving
-  class Binary
-    class RemovePreviousAnnotations
-      def self.call(code)
-        new(code).call
-      end
-
-      def initialize(code)
-        self.code     = code
-        self.comments = { result:    [],
-                          exception: [],
-                          stdout:    [],
-                          stderr:    [],
-                        }
-      end
-
-      def call
-        RemoveInlineComments.call code, additional_rewrites: remove_whitespace_preceeding_comments do |comment|
-          if    comment.text[/\A#\s*=>/] then comments[:result]    << comment; true
-          elsif comment.text[/\A#\s*~>/] then comments[:exception] << comment; true
-          elsif comment.text[/\A#\s*>>/] then comments[:stdout]    << comment; true
-          elsif comment.text[/\A#\s*!>/] then comments[:stderr]    << comment; true
-          else                                                                 false
-          end
-        end
-      end
-
-      private
-
-      attr_accessor :code, :comments
-
-      def remove_whitespace_preceeding_comments
-        lambda do |buffer, rewriter|
-          comments[:result].each    { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, false }
-          comments[:exception].each { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, true  }
-          comments[:stdout].each    { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, true  }
-          comments[:stderr].each    { |comment| remove_whitespace_before comment.location.expression.begin_pos, buffer, rewriter, true  }
-        end
-      end
-
-      # any whitespace before the index (on the same line) will be removed
-      # if the preceeding whitespace is at the beginning of the line, the newline will be removed
-      # if there is a newline before all of that, and remove_preceeding_newline is true, it will be removed as well
-      def remove_whitespace_before(index, buffer, rewriter, remove_preceeding_newline)
-        end_pos   = index
-        begin_pos = end_pos - 1
-        begin_pos -= 1 while code[begin_pos] =~ /\s/ && code[begin_pos] != "\n"
-        begin_pos -= 1 if code[begin_pos] == "\n"
-        begin_pos -= 1 if code[begin_pos] == "\n" && remove_preceeding_newline
-        return if begin_pos.next == end_pos
-        rewriter.remove Parser::Source::Range.new(buffer, begin_pos.next, end_pos)
-      end
-
-      # returns comments in groups that are on consecutive lines
-      def adjacent_comments(comments, buffer)
-        comments          = comments.sort_by { |comment| comment.location.begin_pos }
-        current_chunk     = 0
-        last_line_seen    = -100
-        chunks_to_comment = comments.chunk do |comment|
-          line, col = buffer.decompose_position comment.location.begin_pos
-          if last_line_seen.next == line
-            last_line_seen = line
-            current_chunk
-          else
-            last_line_seen = line
-            current_chunk += 1
-          end
-        end
-        chunks_to_comment.map &:last
-      end
-    end
-  end
-end

data/lib/seeing_is_believing/queue.rb

@@ -1,55 +0,0 @@
-class SeeingIsBelieving
-  class Queue
-    class While
-      attr_accessor :queue, :conditional
-
-      def initialize(queue, &conditional)
-        self.queue, self.conditional = queue, conditional
-      end
-
-      def each(&block)
-        block.call queue.dequeue while !queue.empty? && conditional.call(queue.peek)
-      end
-    end
-  end
-
-  class Queue
-    attr_accessor :value_generator
-
-    def initialize(&value_generator)
-      self.value_generator = value_generator
-    end
-
-    def dequeue
-      return if permanently_empty?
-      peek.tap { @next_value = nil }
-    end
-
-    def peek
-      return if permanently_empty?
-      @next_value ||= value_generator.call.tap { |value| @permanently_empty = value.nil? }
-    end
-
-    def empty?
-      permanently_empty? || peek.nil?
-    end
-
-    def each(&block)
-      block.call dequeue until empty?
-    end
-
-    def until(&block)
-      While.new(self) { |*args| !block.call(*args) }
-    end
-
-    def while(&block)
-      While.new self, &block
-    end
-
-    private
-
-    def permanently_empty?
-      @permanently_empty
-    end
-  end
-end

data/lib/seeing_is_believing/remove_inline_comments.rb

@@ -1,46 +0,0 @@
-require 'parser/current'
-
-class SeeingIsBelieving
-  module RemoveInlineComments
-    module NonLeading
-      def self.call(code)
-        ranges = []
-
-        nonleading_comments = lambda do |buffer, rewriter|
-          ranges.sort_by(&:begin_pos)
-                .drop_while.with_index(1) { |range, index|
-                  line, col = buffer.decompose_position range.begin_pos
-                  index == line && col.zero?
-                }
-                .each { |range| rewriter.remove range }
-        end
-
-        RemoveInlineComments.call code, additional_rewrites: nonleading_comments do |comment|
-          ranges << comment.location
-          false
-        end
-      end
-    end
-
-    extend self
-
-    # selector is a block that will receive the comment object
-    # if it returns true, the comment will be removed
-    def self.call(code, options={}, &selector)
-      selector            ||= Proc.new { true }
-      additional_rewrites   = options.fetch :additional_rewrites, Proc.new {}
-      buffer                = Parser::Source::Buffer.new "strip_comments"
-      buffer.source         = code
-      parser                = Parser::CurrentRuby.new
-      rewriter              = Parser::Source::Rewriter.new(buffer)
-      ast, comments         = parser.parse_with_comments(buffer)
-      comments.select { |comment| comment.type == :inline }
-              .select { |comment| selector.call comment }
-              .each   { |comment| rewriter.remove comment.location.expression }
-      additional_rewrites.call buffer, rewriter
-      rewriter.process
-    rescue Parser::SyntaxError => e
-      raise SyntaxError, e.message
-    end
-  end
-end

data/lib/seeing_is_believing/syntax_analyzer.rb

@@ -1,61 +0,0 @@
-require 'ripper'
-require 'parser/current'
-
-class SeeingIsBelieving
-  class SyntaxAnalyzer < Ripper::SexpBuilder
-
-    # HELPERS
-
-    def self.parsed(code)
-      instance = new code
-      instance.parse
-      instance
-    end
-
-    # SYNTACTIC VALIDITY
-
-    def self.begins_multiline_comment?(line)
-      line == '=begin'
-    end
-
-    def self.ends_multiline_comment?(line)
-      line == '=end'
-    end
-
-    def self.begin_and_end_comments_are_complete?(code)
-      code.scan(/^=(?:begin|end)$/)
-          .each_slice(2)
-          .all? { |b, e| b == '=begin' && e == '=end' }
-    end
-
-    # MISC
-
-    def self.begins_data_segment?(line)
-      line == '__END__'
-    end
-
-    # COMMENTS
-
-    def self.line_is_comment?(line)
-      line =~ /^\s*#/
-    end
-
-    def self.ends_in_comment?(code)
-      # must do the newline hack or it totally fucks up on comments like "# Transfer-Encoding: chunked"
-      code =~ /^=end\Z/ || parsed("\n#{code.lines.to_a.last.to_s}").has_comment?
-    end
-
-    def self.unclosed_comment?(code)
-      !begin_and_end_comments_are_complete?(code)
-    end
-
-    def has_comment?
-      @has_comment
-    end
-
-    def on_comment(*)
-      @has_comment = true
-      super
-    end
-  end
-end

data/lib/seeing_is_believing/tracks_line_numbers_seen.rb

@@ -1,19 +0,0 @@
-class SeeingIsBelieving
-  module TracksLineNumbersSeen
-    INITIAL_LINE_NUMBER = 1 # uhm, should this change to 0?
-
-    def track_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
-      self
-    end
-
-    def min_line_number
-      @min_line_number || INITIAL_LINE_NUMBER
-    end
-
-    def max_line_number
-      @max_line_number || INITIAL_LINE_NUMBER
-    end
-  end
-end

data/spec/binary/line_formatter_spec.rb

@@ -1,53 +0,0 @@
-require 'seeing_is_believing/binary/line_formatter'
-
-describe SeeingIsBelieving::Binary::LineFormatter do
-  def result_for(line, separator, result, options={})
-    described_class.new(line, separator, result, options).call
-  end
-
-  specify 'it returns the consolidated result if there are no truncations' do
-    result_for('1', '=>', '12345').should == '1=>12345'
-  end
-
-  specify 'result_length truncates a result to the specified length, using elipses up to that length if appropriate'  do
-    line      = '1'
-    separator = '=>'
-    result    = '12345'
-    result_for(line, separator, result, result_length: Float::INFINITY).should == '1=>12345'
-    result_for(line, separator, result, result_length: 7).should == '1=>12345'
-    result_for(line, separator, result, result_length: 6).should == '1=>1...'
-    result_for(line, separator, result, result_length: 5).should == '1=>...'
-    result_for(line, separator, result, result_length: 4).should == '1'
-    result_for(line, separator, result, result_length: 0).should == '1'
-  end
-
-  specify 'line_length truncates a result to the specified length, minus the length of the line' do
-    line      = '1'
-    separator = '=>'
-    result    = '12345'
-    result_for(line, separator, result).should == '1=>12345'
-    result_for(line, separator, result, line_length: Float::INFINITY).should == '1=>12345'
-    result_for(line, separator, result, line_length: 8).should == '1=>12345'
-    result_for(line, separator, result, line_length: 7).should == '1=>1...'
-    result_for(line, separator, result, line_length: 6).should == '1=>...'
-    result_for(line, separator, result, line_length: 5).should == '1'
-    result_for(line, separator, result, line_length: 0).should == '1'
-  end
-
-  specify 'pad_to will pad the length that the line is displayed in' do
-    result_for('1', '=>', '2', pad_to: 0).should == '1=>2'
-    result_for('1', '=>', '2', pad_to: 1).should == '1=>2'
-    result_for('1', '=>', '2', pad_to: 2).should == '1 =>2'
-  end
-
-  specify 'pad_to is ignored when separator/result will not be printed' do
-    result_for('1', '=>', '12345', pad_to: 2,   line_length: 2).should == '1'
-    result_for('1', '=>', '12345', pad_to: 2, result_length: 2).should == '1'
-  end
-
-  specify 'they can all work together' do
-    result_for('1', '=>', '12345', line_length: 100, result_length: 100, pad_to: 2).should == '1 =>12345'
-    result_for('1', '=>', '12345', line_length:   8, result_length: 100, pad_to: 2).should == '1 =>1...'
-    result_for('1', '=>', '12345', line_length: 100, result_length:   6, pad_to: 2).should == '1 =>1...'
-  end
-end

data/spec/binary/remove_previous_annotations_spec.rb

@@ -1,198 +0,0 @@
-require 'seeing_is_believing/binary/remove_previous_annotations'
-
-describe SeeingIsBelieving::Binary::RemovePreviousAnnotations do
-  def call(code)
-    indentation = code[/\A */]
-    code        = code.gsub /^#{indentation}/, ''
-    described_class.call(code).chomp
-  end
-
-  # show some examples of what it should not remove
-
-  example { call("1#=>1").should == "1" }
-  example { call("1 #=>1").should == "1" }
-  example { call("1  #=>1").should == "1" }
-  example { call("1  #=> 1").should == "1" }
-  example { call("1   #=> 1").should == "1" }
-  example { call("1  #=>  1").should == "1" }
-  example { call("\n1 # => 1").should == "\n1" }
-
-  example { call("1#~>1").should == "1" }
-  example { call("1 #~>1").should == "1" }
-  example { call("1  #~>1").should == "1" }
-  example { call("1  #~> 1").should == "1" }
-  example { call("1   #~> 1").should == "1" }
-  example { call("1  #~>  1").should == "1" }
-  example { call("\n1 # ~> 1").should == "\n1" }
-
-  example { call("# >> 1").should == "" }
-  example { call("# !> 1").should == "" }
-
-  example { call(<<-CODE).should == "1" }
-  1
-  # >> 2
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # >> 2
-  CODE
-
-  example { call(<<-CODE).should == "1\n" }
-  1
-
-
-  # >> 2
-  CODE
-
-  example { call(<<-CODE).should == "1\n" }
-  1
-
-
-    # >> 2
-  # >> 2
-   # >> 2
-  CODE
-
-
-  example { call(<<-CODE).should == "1\n" }
-  1
-
-
-  # >> 2
-  # >> 3
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-  # !> 2
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # !> 2
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # !> 2
-  # !> 3
-  CODE
-
-  example { call(<<-CODE).should == "1\n" }
-  1
-
-
-    # !> 2
-  # !> 2
-   # !> 2
-  CODE
-
-
-  example { call(<<-CODE).should == "1" }
-  1
-  # ~>2
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # ~> 2
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # ~> 2
-  # ~> 3
-  CODE
-
-  example { call(<<-CODE).should == "1\n" }
-  1
-
-
-    # ~> 2
-  # ~> 2
-   # ~> 2
-  CODE
-
-  example { call(<<-CODE).should == "1\n" }
-  1 # ~> error
-
-
-    # ~> error again
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # >> 1
-  # >> 2
-
-  # !> 3
-  # !> 4
-
-  # ~> 5
-  # ~> 6
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # >> 1
-
-  # >> 2
-
-  # !> 3
-
-  # !> 4
-
-  # ~> 5
-
-  # ~> 6
-  CODE
-
-  example { call(<<-CODE).should == "1" }
-  1
-
-  # >> 1
-  # >> 2
-  # !> 3
-  # !> 4
-  # ~> 5
-  # ~> 6
-  CODE
-
-  example { call(<<-CODE).should == "1\n3" }
-  1
-  # >> 1
-  # >> 2
-  3
-  # !> 4
-  # !> 5
-  CODE
-
-  example { call(<<-CODE).should == "1\n3\n6" }
-  1
-  # >> 1
-  # >> 2
-  3
-  # !> 4
-  # !> 5
-  6
-  # ~> 7
-  # ~> 8
-  CODE
-
-  example { call(<<-CODE).should == "1\n\nputs \"omg\"" }
-  1  # => 1
-
-  puts "omg"  # ~> RuntimeError: omg
-
-  # ~> RuntimeError
-  CODE
-
-end