andyw8-seeing_is_believing 4.2.0

data/lib/seeing_is_believing/swap_files.rb

@@ -0,0 +1,90 @@
+require 'seeing_is_believing/error'
+require 'seeing_is_believing/hard_core_ensure'
+
+class SeeingIsBelieving
+  class SwapFiles
+    # Might honeslty make more sense to break this out into 2 different classes.
+    # We've got to do some confusing state accounting since there are really 2
+    # algorithms here:
+    #
+    # if the file exists:
+    #   make sure there isn't a backup (could cause the user to lose their file)
+    #   back the file up
+    #   write the rewritten code to the file
+    #   if we are told to show the user program
+    #     move the backup over the top of the rewritten file
+    #     do nothing in the ensure block
+    #   else
+    #     in the ensure block: move the backup over the top of the rewritten file
+    # if the file DNE:
+    #   write the rewritten code to the file
+    #   if we are told to show the user program
+    #     write the user program to the file
+    #   delete the file in the ensure block
+    def self.call(*args, &block)
+      new(*args, &block).call
+    end
+
+    def initialize(file_path, backup_path, user_program, rewritten_program, &block)
+      self.file_path         = file_path
+      self.block             = block
+      self.backup_path       = backup_path
+      self.user_program      = user_program
+      self.rewritten_program = rewritten_program
+    end
+
+    def call
+      HardCoreEnsure.call \
+        code: -> {
+          File.exist? backup_path and
+            raise TempFileAlreadyExists.new(file_path, backup_path)
+
+          @has_file = File.exist? file_path
+
+          if @has_file
+            File.rename file_path, backup_path
+            @needs_restore = true
+          end
+
+          save_file rewritten_program
+
+          block.call self
+        },
+        ensure: -> {
+          set_back_to_initial_conditions
+        }
+    end
+
+    def show_user_program
+      if @needs_restore
+        restore
+      else
+        save_file user_program
+      end
+    end
+
+    private
+
+    attr_accessor :block, :file_path, :backup_path, :rewritten_program, :user_program
+
+    def restore
+      File.rename(backup_path, file_path)
+      @needs_restore = false
+    end
+
+
+    def save_file(program)
+      File.open file_path, 'w', external_encoding: "utf-8" do |f|
+        f.write program.to_s
+      end
+    end
+
+    def set_back_to_initial_conditions
+      if @needs_restore
+        restore
+      elsif !@has_file
+        File.delete(file_path)
+      end
+    end
+  end
+end

data/lib/seeing_is_believing/the_matrix.rb

@@ -0,0 +1,97 @@
+require_relative 'safe'
+require_relative 'version'
+require_relative 'event_stream/producer'
+require 'socket'
+require 'timeout'
+
+using SeeingIsBelieving::Safe
+
+sib_vars     = Marshal.load ENV["SIB_VARIABLES.MARSHAL.B64"].unpack('m0').first
+event_stream = Timeout.timeout(1) do
+  begin
+    Socket.tcp("localhost", sib_vars.fetch(:event_stream_port))
+  rescue Errno::ECONNREFUSED
+    sleep 0.1
+    retry
+  end
+end
+
+$SiB = SeeingIsBelieving::EventStream::Producer.new(event_stream)
+$SiB.record_ruby_version      RUBY_VERSION
+$SiB.record_sib_version       SeeingIsBelieving::VERSION
+$SiB.record_filename          sib_vars.fetch(:filename)
+$SiB.record_num_lines         sib_vars.fetch(:num_lines)
+$SiB.record_max_line_captures sib_vars.fetch(:max_line_captures)
+
+STDOUT.sync = true
+STDOUT.binmode
+STDERR.binmode
+STDIN.set_encoding "utf-8"
+stdout, stderr = STDOUT, STDERR
+
+finish = lambda do
+  $SiB.finish!
+  event_stream.close
+  stdout.flush unless stdout.closed?
+  stderr.flush unless stderr.closed?
+end
+
+real_exec      = method :exec
+real_fork      = method :fork
+real_exit_bang = method :exit!
+fork_defn      = lambda do |*args|
+  result = real_fork.call(*args)
+  $SiB.send :forking_occurred_and_you_are_the_child, event_stream unless result
+  result
+end
+Kernel.module_eval do
+  private
+
+  define_method :warn do |*args, &block|
+    $stderr.puts(*args)
+  end
+
+  alias :exec :exec # disable warning
+  define_method :exec do |*args, &block|
+    $SiB.record_exec(args)
+    finish.call
+    real_exec.call(*args, &block)
+  end
+
+  alias :exit! :exit! # disable warning
+  define_method :exit! do |status=false|
+    finish.call
+    real_exit_bang.call(status)
+  end
+
+  alias :fork :fork
+  define_method :fork, &fork_defn
+end
+
+module Process
+  class << self
+    alias :fork :fork
+  end
+end
+
+Kernel.define_singleton_method  :fork, &fork_defn
+Process.define_singleton_method :fork, &fork_defn
+
+
+# Some things need to be recorded and readded as they are called from Ruby C code and it blows up in really difficult to dianose ways -.-
+symbol_to_s         = Symbol.instance_method(:to_s)
+exception_message   = Exception.instance_method(:message)
+exception_backtrace = Exception.instance_method(:backtrace)
+
+# Guarding against hostile users (e.g. me) that do ridiculous things like blowing away these constants
+exception_class = Exception
+symbol_class    = Symbol
+
+at_exit do
+  exception_class.class_eval { define_method :message,   exception_message }
+  exception_class.class_eval { define_method :backtrace, exception_backtrace }
+  symbol_class.class_eval    { define_method :to_s,      symbol_to_s }
+  exitstatus = ($! ? $SiB.record_exception(nil, $!) : 0)
+  finish.call
+  real_exit_bang.call(exitstatus) # clears exceptions so they don't print to stderr and change the processes actual exit status (we recorded what it should be)
+end

data/lib/seeing_is_believing/version.rb

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

data/lib/seeing_is_believing/wrap_expressions.rb

@@ -0,0 +1,265 @@
+require 'seeing_is_believing/code'
+
+# comprehensive list of syntaxes that can come up
+# https://github.com/whitequark/parser/blob/master/doc/AST_FORMAT.md
+class SeeingIsBelieving
+  class WrapExpressions
+
+    def self.call(program, wrappings)
+      new(program, wrappings).call
+    end
+
+    def initialize(program, wrappings)
+      self.before_all  = wrappings.fetch :before_all,  -> { '' }
+      self.after_all   = wrappings.fetch :after_all,   -> { '' }
+      self.before_each = wrappings.fetch :before_each, -> * { '' }
+      self.after_each  = wrappings.fetch :after_each,  -> * { '' }
+      self.wrappings   = {}
+      self.code        = Code.new(program, 'program-without-annotations')
+      code.syntax.valid? || raise(::SyntaxError, code.syntax.error_message)
+    end
+
+    def call
+      @called ||= begin
+        wrap_recursive code.root
+
+        wrappings = wrappings().sort_by(&:first)
+
+        wrappings.each do |line_num, (range, _last_col, meta)|
+          case meta
+          when :total_fucking_failure
+            rewriter.replace range,  '.....TOTAL FUCKING FAILURE!.....'
+          when :match_current_line
+            rewriter.insert_before range, '~' # Regexp#~
+          end
+        end
+
+        wrappings.each do |line_num, (range, _last_col, _meta)|
+          rewriter.insert_before range, before_each.call(line_num)
+        end
+
+        wrappings.each do |line_num, (range, _last_col, _meta)|
+          rewriter.insert_after range, after_each.call(line_num)
+        end
+
+        rewriter.insert_before root_range, before_all.call
+        rewriter.insert_after  root_range, after_all_text
+        rewriter.process
+      end
+    end
+
+    private
+
+    attr_accessor :before_all, :after_all, :before_each, :after_each
+    attr_accessor :code, :wrappings
+
+    def buffer
+      code.buffer
+    end
+
+    def rewriter
+      code.rewriter
+    end
+
+    def root_range
+      code.root.location.expression
+    end
+
+    def after_all_text
+      after_all_text         = after_all.call
+      data_segment_code      = "__END__\n"
+      code_after_end_of_file = buffer.source[root_range.end_pos, data_segment_code.size]
+      ends_in_data_segment   = code_after_end_of_file.chomp == data_segment_code.chomp
+      if ends_in_data_segment
+        "#{after_all_text}\n"
+      else
+        after_all_text
+      end
+    end
+
+    def add_to_wrappings(range_or_ast, meta=nil)
+      range = range_or_ast
+      if range.kind_of? ::AST::Node
+        location = range_or_ast.location
+        # __ENCODING__ becomes:  (const (const nil :Encoding) :UTF_8)
+        # Where the inner const doesn't have a location because it doesn't correspond to a real token.
+        # There is not currently a way to turn this off, but it would be nice to have one like __LINE__ does
+        # https://github.com/whitequark/parser/blob/e2249d7051b1adb6979139928e14a81bc62f566e/lib/parser/builders/default.rb#L333-343
+        return unless location.respond_to? :expression
+        range = location.expression
+      end
+      line, col = buffer.decompose_position range.end_pos
+      _, prev_col, _ = wrappings[line]
+      wrappings[line] = (!wrappings[line] || prev_col < col ? [range, col, meta] : wrappings[line] )
+    end
+
+    def add_children(ast, omit_first = false)
+      (omit_first ? ast.children.drop(1) : ast.children)
+        .each { |child| wrap_recursive child }
+    end
+
+    def add_interpolations_in(ast)
+      ast.children
+         .select { |child| child.type == :begin }
+         .each { |child| add_children child }
+    end
+
+    def wrap_recursive(ast)
+      return wrappings unless ast.kind_of? ::AST::Node
+      case ast.type
+      when :args, :redo, :retry, :alias, :undef, :null_node, :iflipflop, :eflipflop
+        # no op
+      when :defs, :module
+        add_to_wrappings ast
+        add_children ast, true
+      when :ensure, :return, :break, :next, :splat, :kwsplat
+        add_children ast
+      when :rescue
+        add_to_wrappings ast if inline_rescue? ast
+        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 }
+          add_children ast
+        else
+          keyword = ast.location.keyword.source # if, elsif, unless, else, ....
+          if (keyword == 'if' || keyword == 'unless') && ast.children.none? { |child| code.void_value? child }
+            add_to_wrappings ast
+          end
+          add_children ast
+        end
+      when :when, :pair # pair is 1=>2
+        wrap_recursive ast.children.last
+      when :resbody
+        _exception_type, _variable_name, body = ast.children
+        wrap_recursive body
+      when :array
+        add_to_wrappings ast
+        the_begin = ast.location.begin
+        if !the_begin
+          # a = 1,2,3
+          add_children ast
+        elsif the_begin.source !~ /\A%/
+          # normal array
+          add_children ast
+        elsif the_begin.source =~ /\A%/
+          # array of literals
+
+          ast.children.each do |child|
+            t = child.type
+            if t == :dsym || t == :dstr
+              add_interpolations_in child
+            end
+          end
+        end
+      when :block
+        add_to_wrappings ast
+
+        # a {} comes in as
+        #   (block
+        #     (send nil :a)
+        #     (args) nil)
+        #
+        # a.b {} comes in as
+        #   (block
+        #     (send
+        #       (send nil :a) :b)
+        #     (args) nil)
+        #
+        # we don't want to wrap the send itself, otherwise could come in as <a>{}
+        # but we do want ot wrap its first child so that we can get <<a>\n.b{}>
+        #
+        # I can't think of anything other than a :send that could be the first child
+        # but I'll check for it anyway.
+        the_send = ast.children[0]
+        wrap_recursive the_send.children.first if the_send.type == :send
+        add_children ast, true
+      when :masgn
+        # we must look at RHS because [1,<<A] and 1,<<A are both allowed
+        #
+        # in the first case, we must take the end_pos of the array,
+        # or we'll insert the after_each in the wrong location
+        #
+        # in the second, there is an implicit Array wrapped around it, with the wrong end_pos,
+        # so we must take the end_pos of the last arg
+        array = ast.children.last
+        if array.type != :array # e.g. `a, b = c`
+          add_to_wrappings ast
+          add_children ast, true
+        elsif array.location.expression.source.start_with? '['
+          add_to_wrappings ast
+          add_children ast, true
+        else
+          begin_pos = ast.location.expression.begin_pos
+          end_pos   = array.children.last.location.expression.end_pos
+          range     = code.range_for(begin_pos, end_pos)
+          add_to_wrappings range
+          add_children ast.children.last
+        end
+      when :lvasgn,   # a   = 1
+           :ivasgn,   # @a  = 1
+           :gvasgn,   # $a  = 1
+           :cvasgn,   # @@a = 1
+           :casgn,    # A   = 1
+           :or_asgn,  # a ||= b
+           :and_asgn, # a &&= b
+           :op_asgn   # a += b, a -= b, a *= b, etc
+
+        # a=b gets wrapped <a=b>
+        # but we don't wrap the lvar in `for a in range`
+        if ast.children.last.kind_of? ::AST::Node
+          begin_pos = ast.location.expression.begin_pos
+          end_pos   = ast.children.last.location.expression.end_pos
+          range     = code.range_for(begin_pos, end_pos)
+          add_to_wrappings range
+          add_children ast, true
+        end
+      when :send
+        _target, message, * = ast.children
+        meta = (:total_fucking_failure if message == :__TOTAL_FUCKING_FAILURE__)
+        add_to_wrappings ast, meta
+        add_children ast
+      when :begin
+        if ast.location.expression.source.start_with?("(") && # e.g. `(1)` we want `<(1)>`
+          !code.void_value?(ast)                              # e.g. `(return 1)` we want `(return <1>)`
+          add_to_wrappings ast
+        end
+        add_children ast
+      when :str
+        add_to_wrappings ast
+
+      when :regexp, :dstr, :xstr, :dsym
+        add_to_wrappings ast
+        add_interpolations_in ast
+
+      when :hash
+        # method arguments might not have braces around them
+        # in these cases, we want to record the value, not the hash
+        add_to_wrappings ast, meta if ast.location.begin
+        add_children ast
+
+      when :block_pass, :preexe, :postexe
+        add_children ast # strange, I'm not too sure about this :/
+
+      when :match_current_line # ie `if /abc/; ...; end`
+        add_to_wrappings ast, :match_current_line
+
+      else
+        add_to_wrappings ast
+        add_children ast
+      end
+    end
+
+    def inline_rescue?(ast)
+      primary_code, rescue_body, _else_body = ast.children
+      return false unless primary_code
+      primary_code.loc.expression.last_line == rescue_body.loc.expression.first_line
+    end
+  end
+end

data/lib/seeing_is_believing/wrap_expressions_with_inspect.rb

@@ -0,0 +1,19 @@
+require 'seeing_is_believing/wrap_expressions'
+class SeeingIsBelieving
+  module WrapExpressionsWithInspect
+    def self.call(program)
+      # NOTE: if it received the AST, it could figure out if it needs
+      # to always wrap the expression in parentheses
+      WrapExpressions.call program,
+        before_all: -> {
+          "BEGIN { $SiB.file_loaded };"
+        },
+        before_each: -> line_number {
+          "$SiB.record_result(:inspect, #{line_number}, ("
+        },
+        after_each:  -> line_number {
+          ")) { |v| v.inspect }"
+        }
+    end
+  end
+end

data/lib/seeing_is_believing.rb

@@ -0,0 +1,69 @@
+require 'tmpdir'
+
+require 'seeing_is_believing/result'
+require 'seeing_is_believing/version'
+require 'seeing_is_believing/debugger'
+require 'seeing_is_believing/wrap_expressions_with_inspect'
+require 'seeing_is_believing/hash_struct'
+require 'seeing_is_believing/evaluate_by_moving_files'
+require 'seeing_is_believing/event_stream/handlers/debug'
+require 'seeing_is_believing/event_stream/handlers/update_result'
+
+class SeeingIsBelieving
+  class Options < HashStruct
+    predicate(:event_handler)     { EventStream::Handlers::UpdateResult.new Result.new }
+    predicate(:local_cwd)         { false }
+    attribute(:filename)          { nil }
+    attribute(:encoding)          { nil }
+    attribute(:stdin)             { "" }
+    attribute(:require_files)     { ['seeing_is_believing/the_matrix'] }
+    attribute(:load_path_dirs)    { [File.realpath(__dir__)] }
+    attribute(:timeout_seconds)   { 0 }
+    attribute(:debugger)          { Debugger::Null }
+    attribute(:max_line_captures) { Float::INFINITY }
+    attribute(:rewrite_code)      { WrapExpressionsWithInspect }
+  end
+
+  def self.call(*args)
+    new(*args).call
+  end
+
+  attr_reader :options
+  def initialize(program, options={})
+    @program = program
+    @program += "\n" unless @program.end_with? "\n"
+    @options = Options.new options
+  end
+
+  def call
+    @memoized_result ||= Dir.mktmpdir("seeing_is_believing_temp_dir") { |dir|
+      filename    = options.filename || File.join(dir, 'program.rb')
+      new_program = options.rewrite_code.call @program
+
+      options.debugger.context("REWRITTEN PROGRAM") { new_program }
+
+      EvaluateByMovingFiles.call \
+        filename,
+        @program,
+        new_program,
+        event_handler:     event_handler(options.debugger, options.event_handler),
+        provided_input:    options.stdin,
+        require_files:     options.require_files,
+        load_path_dirs:    options.load_path_dirs,
+        encoding:          options.encoding,
+        timeout_seconds:   options.timeout_seconds,
+        max_line_captures: options.max_line_captures,
+        local_cwd:         options.local_cwd?
+
+      options.event_handler
+    }
+  end
+
+  private
+
+  # If we need debugging, wrap a debugging handler around the current handler
+  def event_handler(debugger, current_handler)
+    return current_handler unless debugger.enabled?
+    EventStream::Handlers::Debug.new debugger, current_handler
+  end
+end

data/seeing_is_believing.gemspec

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+$:.push File.realpath("lib", __dir__)
+require "seeing_is_believing/version"
+
+Gem::Specification.new do |s|
+  s.name        = "andyw8-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 Bret Victor's JavaScript example in his talk "Inventing on Principle"}
+  s.license     = "WTFPL"
+
+  s.files         = `git ls-files`.split("\n") - ['docs/seeing is believing.psd'] # remove psd b/c it boosts the gem size from 50kb to 20mb O.o
+  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_dependency             "parser",      ">= 2.7", "< 4"
+  s.add_dependency             "childprocess","~> 4.1"
+  s.add_dependency             "ffi",         "~> 1.15"
+
+  s.add_development_dependency "pry"
+  s.add_development_dependency "haiti",       ">= 0.1", "< 0.3"
+  s.add_development_dependency "rake",        "~> 13.0"
+  s.add_development_dependency "rspec",       "~>  3.6"
+  s.add_development_dependency "bundler",     "~>  2.0"
+  s.add_development_dependency "cucumber",    "~>  2.4"
+  s.add_development_dependency "ripper-tags", "~>  0.3"
+
+  s.post_install_message = <<'Omg, frogs <3'.gsub(/(gg+)/) { |capture| "\e[32m#{capture.gsub 'g', '.'}\e[0m" }.gsub("brown", "\e[33m").gsub("off", "\e[0m")
+              .7
+     .      .M
+      .  . .N
+      M.  ..O
+     =. .. .M
+     N . .  .N
+      O.. . . O
+        MN:. . M
+           OM...N
+             N .OM                 brown.NM8MMMMMMoff
+             O ..N             brown...MM=:Z7?Z7??MMMMIMMOM8Noff
+             M...O        brown,MMMMMMMMMM$$:=ZZ$~:$?7ZMMMMM8?Moff
+           .N .  M       brownMMI$7:==?:77MMMM7$O~+~ZO~~I=7ZMMMMoff
+           O$...N        brownM=$ZZI=MMM7ZZI=?MMZ+:$I?8Z~?ZO~=ZIMMoff
+        .MN ...O         brownM~?Z==ZZZ=MM$$=$ZZMMO=~~?$=$Z~~OO+=MMoff
+        OM ...,M      DAAAAAAAAAAAAAAAAAAAAAAAMbrown=Z=+OOI=+ZO$O+MMoff
+      NOM.. . N     DAAAAAAAAAAAAM?:DAAAAAAAAAAAAMbrown$ZZ?$+IZ7+8?M8off
+     NOM.....O     DAAAAAAAAM:ggggDAAAAAAAAAAAAAAMbrown78OI+D=78=$MMoff
+    NO.. ...MN     DAAAAAAAMgggggggDAAAAAAAAAAAAAM,MMbrownMO7?I8Z7OMoff
+   MN.... ..O       DAAAAAMgggggggggDAAAAAAAAAAAAMgg~MMbrown?NMM7O8MMoff
+  NOM..  ..MN        DAAMggggggggggggDAAAAAAAAAAMgggggggMMbrown7.MMMoff
+ NOM.. .. .OM         MggggggggggggggggDAAAAAAAMgggggggggggMM:M
+ NOM. .. ..NO        Mggggggggggggggggggg~DAAMggggggggggggggI,,M
+ NOM.. .. .MN       MMgggbrownZMMMMMMoffggggggggggggggggggggggggggggg=MM
+ NOM. . ... O       MggbrownMMMNMMMMMMMMZoffgggggggggggggggggggggggggg$MI
+ NOM8.. .. .MM      MZbrownMMMMMMMMMMMMMMMoffgggggggggM~gggggggggggggggMM
+  NOM .. . . NOM    Mgggggggggggggggggggggggg8M$ggggggggggggggggMM
+   NOMO. . . . .    M.MMMMMMMMMMMMNMMMMNMMMMMMggggggggggggggggggMM,
+     NOMM8.  .     M:MM  MMggggggggggggggggggggggggggggggggggggggMM
+           .    .MMMM     brownMMMMgggggggggggggbrown7ZMMggggggggggggggggggMM
+               .MNOM      brownMMMMMMMMMMMMMMMMMMMggggggggggggggggggggOMM
+                 H         brownMMMMMMMMMMMMMMMMMggggggg,ggggggggggggggMM
+                            brownMMMMMMMMMMMM=gggggggggMMggggggggggggggMMN
+                              brown:MMMMggggggggggggggggMgggggggMggggggMMM
+                                 MMMggggggggggggggMNggggg:7gggggggMMM .MMMMMM
+   Seeing                        MMMMgggggggggMgggMgggggMgggggggggMMMMggggggMM
+                                 MggMMMgggggggMgggMgggg=IggggggggMMgggggggggM
+      is                         MggMMMMgggggMggggMggggMgggggMMM:ggggggggggMM
+                                MMggM  MMMgggMgggMMgggMggggMMMgggggggggggggM,
+  Believing                    .MggMM   MMMMMMgggMggggMgggggggggggggggggggMM
+                       ggMMMMMMMMggM   MggMMMgggMMgggOMggggggggggggggMNggMM
+                     MgggggggggggggM  MMMggMMgggMMMMMMMgggggggggggggMgg+MM
+                     :MM7ggggMggIMM  D ggM?MgggMM     MgggggggggggMMggMM,
+                          .MggMgg    ggg gM+gggM      NMggggggggMMMggMM
+                                  .MM+gZMMgggggM       MMMMMMMMMMggggM
+                                  MIgg8MM,ggggMM           .MMMggMggM
+                                 MMMgggMMMMggMI       ggOMMMggOMMggMM
+                                MgggMDggggM M        MgggggNMMggMMggM
+                                MMMMgggggM ggM      .M:gggMggggMggggM
+                                           MM          MMMMggggggMMMI
+Omg, frogs <3
+end

data/spec/binary/alignment_specs.rb

@@ -0,0 +1,27 @@
+# This is mostly tested in the cukes, but some are hard to hit
+
+require 'seeing_is_believing/binary/align_chunk'
+
+RSpec.describe '1-off alignment specs' do
+  def chunk(code)
+    code << "\n"
+    SeeingIsBelieving::Binary::AlignChunk.new code
+  end
+
+  describe 'AlignChunk' do
+    it 'considers entirely whitespace lines to be a chunk separator' do
+      empty_line      = chunk "aaaaa\n\n1"
+      whitespace_line = chunk "aaaaa\n   \t   \n1"
+      expect(whitespace_line.line_length_for 1).to eq empty_line.line_length_for(1)
+      expect(whitespace_line.line_length_for 3).to eq empty_line.line_length_for(3)
+    end
+
+    it 'is not fooled by whitespace on the first/last line' do
+      expect(chunk("   \na\n   ").line_length_for(2)).to eq 3
+    end
+
+    it 'is not fooled by trailing whitespace in general' do
+      expect(chunk("a         ").line_length_for(1)).to eq 3
+    end
+  end
+end