nandoc 0.0.3 → 0.0.4

data/lib/nandoc/helpers.rb

@@ -1,7 +1,7 @@
 module NanDoc::Helpers
   module NanDocHelpers
     # @todo-now test this
-    include NanDoc::StringFormatting # indent() unindent() no_blank_lines()
+    include NanDoc::StringMethods # indent() unindent() no_blank_lines()
     module BlockAttrAccessor
       attr_accessor :block_attr_accessors
       class << self

data/lib/nandoc/html/tags.rb

@@ -0,0 +1,65 @@
+module NanDoc::Html
+  class Tags
+
+    def initialize
+      @current = nil
+      @content = []
+    end
+
+    attr_reader :content
+    attr_reader :current
+
+    def push_raw str
+      flush if @current
+      @content.push str
+    end
+
+    def push_smart name, classes, content
+      tag = normalize_tag(name, classes)
+      if @current != tag
+        flush if @current
+        @current = tag
+        @content.push render_open_tag(tag)
+      end
+      @content.push content
+      nil
+    end
+
+    def push_tag_now name, classes, content
+      tag = normalize_tag(name, classes)
+      @content.push render_open_tag(tag)
+      @content.push content
+      @content.push render_close_tag(tag)
+      nil
+    end
+
+    def to_html
+      flush if @current
+      @content.join('')
+    end
+
+  private
+
+    def flush
+      if @current
+        @content.push render_close_tag(@current)
+        @current = nil
+      end
+    end
+
+    def render_close_tag tag
+      name = tag.first
+      "</#{name}>"
+    end
+
+    def render_open_tag tag
+      name, classes = tag
+      "<#{name} class='#{classes.join(' ')}'>"
+    end
+
+    def normalize_tag name, classes
+      classes = classes.kind_of?(Array) ? classes : [classes]
+      [name, classes]
+    end
+  end
+end

data/lib/nandoc/html.rb

@@ -0,0 +1,6 @@
+module NanDoc::Html
+end
+
+me = File.dirname(__FILE__)+'/html'
+require me + '/tags.rb'
+  

data/lib/nandoc/parse-readme.rb

@@ -1,4 +1,8 @@
 module NanDoc
+  #
+  # @dependencies: none
+  #
+
   class ParseReadme
     #
     # If you are really really crazy then you don't like

data/lib/nandoc/spec-doc/agent-instance-methods.rb

@@ -0,0 +1,24 @@
+module NanDoc::SpecDoc
+  module AgentInstanceMethods
+    # share things between MockPrompt and TestCaseAgent
+
+    # we used to use first method, now we use first test_ method
+    def method_name_to_record caller
+      line = caller.detect{ |x| x =~ /in `test_/ } or fail('hack fail')
+      method = line =~ /in `(.+)'\Z/ && $1 or fail("hack fail")
+      method
+    end
+
+    def recordings
+      @recordings ||=  NanDoc::SpecDoc::Recordings.get(test_case)
+    end
+
+    def story story_name
+      method = method_name_to_record(caller)
+      rec = recordings
+      rec.add(:method, method)
+      rec.add(:story, story_name)
+      nil
+    end
+  end
+end

data/lib/nandoc/spec-doc/code-snippet.rb

@@ -0,0 +1,59 @@
+module NanDoc::SpecDoc
+  class CodeSnippet
+    #
+    # internally this does deferred parsing of the thing
+    # a code snippet holds meta information (or maybe content)
+    # for record_ruby nandoc commands in tests.
+    #
+
+    def initialize matches_hash
+      @start_at = matches_hash
+      @stop_at = nil
+      @lines_proc = nil
+    end
+    attr_reader :start_at
+    %w(method line file).each do |meth|
+      sym = meth.to_sym
+      define_method(meth){ || @start_at[sym] }
+    end
+    def describe
+      last = method ? ":in `#{method}'" : ''
+      "#{file}:#{line}#{tail}"
+    end
+    # just hide all the lines from dumps to make irb debugging prettier
+    def file_lines
+      @lines_proc ||= begin
+        stop_at_assert    # not really appropriate here
+        same_file_assert  # not really appropriate here
+        all_lines = File.open(@start_at[:file],'r').lines.map # sure why not
+        proc{ all_lines }
+      end
+      @lines_proc.call
+    end
+    def line_start
+      @start_at[:line]
+    end
+    def line_stop
+      @stop_at[:line]
+    end
+    def lines_raw
+      @lines_raw ||= file_lines[line_start..(line_stop-2)]
+    end
+    def string_raw
+      @string_raw ||= lines_raw.join('')
+    end
+    def stop_at data=nil
+      data ? (@stop_at = data) : @stop_at
+    end
+  private
+    def same_file_assert
+      @stop_at[:file] == @start_at[:file] or fail("I want life to be"<<
+      " simple. start and stop files must be the same: "<<
+      ([@stop_at, @start_at].map{ |x| File.basename(x)}*' and '))
+    end
+    def stop_at_assert
+      stop_at or fail("no record_ruby_stop() found in method "<<
+      "after #{describe}")
+    end
+  end
+end

data/lib/nandoc/spec-doc/generic-agent.rb

@@ -0,0 +1,40 @@
+module NanDoc::SpecDoc
+  class GenericAgent
+    #
+    # Experimental doohickey that lets random ass objects record
+    # things.
+    #
+
+    include ParseTrace
+
+    def initialize whatever
+      @whatever = whatever
+    end
+
+    def record_ruby
+      caller_info = parse_trace_assert(caller.first)
+      snip = CodeSnippet.new(caller_info)
+      recordings.add(:record_ruby, snip)
+      @last_snip = snip
+      nil
+    end
+
+    def record_ruby_stop
+      line = caller.first
+      caller_info = parse_trace_assert(line)
+      @last_snip or fail("no record_start in method before "<<
+      "record_stop at #{line}")
+      @last_snip.stop_at caller_info
+    end
+
+    # override the one that requires we are in a method
+    def story name
+      recordings.add :story, name
+    end
+
+  private
+    def recordings
+      Recordings.get_for_key(:generic)
+    end
+  end
+end

data/lib/nandoc/spec-doc/mock-prompt.rb

@@ -1,11 +1,5 @@
-# @todo figure out how to get the symlink hack to work and avoid
-#   this nonsense all the while letting this be a valid requireable file
-require(File.expand_path('../../../nandoc.rb',__FILE__)) unless
-  Object.const_defined?('NanDoc')
-require(File.expand_path('../../spec-doc.rb',__FILE__)) unless
-  NanDoc.const_defined?('SpecDoc')
-require(File.dirname(__FILE__)+'/mini-test.rb') unless
-  NanDoc::SpecDoc.const_defined?('MiniTest')
+require 'nandoc'
+require 'nandoc/spec-doc'
 
 module NanDoc
   class MockPrompt
@@ -115,7 +109,7 @@ module NanDoc
       re = /^#{Regexp.escape(string)}/
       str.gsub(re, '')
     end
-
+  public
     attr_reader :test_case
   end
 end

data/lib/nandoc/spec-doc/parse-trace.rb

@@ -0,0 +1,25 @@
+require 'nandoc/support/regexp'
+
+module NanDoc::SpecDoc
+  module ParseTrace
+    #
+    # @return [Regexp] enhanced regex that parses a stack trace line
+    #
+    def parse_trace
+      @parse_trace_re ||= begin
+        NanDoc::Regexp.new(
+          /\A(.*):(\d+)(?::in `([^']+)')?\Z/,
+          :file, :line, :method
+        )
+      end
+    end
+    def parse_trace_assert line
+      md = parse_trace.match(line) or
+        fail("couldn't parse trace line: #{line}")
+      h = md.to_hash
+      /\A\d+\Z/ =~ h[:line] or fail("not line: #{h[:line]}.inspect")
+      h[:line] = h[:line].to_i
+      h
+    end
+  end
+end

data/lib/nandoc/spec-doc/playback/html.rb

@@ -0,0 +1,2 @@
+me = File.dirname(__FILE__)+'/html'
+require me + '/foo-bar.rb'

data/lib/nandoc/spec-doc/playback/players/method.rb

@@ -0,0 +1,64 @@
+require 'nandoc/spec-doc/playback'
+
+module NanDoc::SpecDoc::Playback
+  class Method
+    # "playback" a recorded ruby (test?) method, generating html
+
+    @handlers = {
+      :cd          => [:class, 'Terminal', :run_cd],
+      :cd_end      => [:class, 'Terminal', :run_cd_end],
+      :command     => [:class, 'Terminal', :run_command],
+      :note        => [:class, self, :run_note],
+      :out         => [:class, 'Terminal', :run_out],
+      :out_begin   => [:class, 'Terminal', :run_out_begin],
+      :record_ruby => [:class, 'Ruby', :run_record_ruby],
+      :story       => [:stop]
+    }
+    class << self
+      attr_reader :handlers
+    end
+
+    include PlaybackMethods
+
+  private
+    def initialize test_file_path=nil, things=nil
+      @test_file_path = test_file_path
+      @things = things
+    end
+    def handlers
+      Method.handlers
+    end
+  public
+    def make_html doc
+      fail("need one or two things") unless (1..2).include?(@things.size)
+      fail("can't run method tag filter without at @test_file_path") unless
+        @test_file_path
+      proj = NanDoc::Project.instance
+      proxy = proj.test_framework_proxy_for_file(@test_file_path)
+      sexp = proxy.sexp_get @test_file_path, @things.first
+      run_sexp(doc, sexp, *@things[1..-1])
+      nil
+    end
+    def run_note out, scn
+      node = scn.scan_assert(:note)
+      note_content = node[1].call
+      out.push_raw note_content
+      nil
+    end
+  private
+    def run_sexp doc, sexp, story=nil
+      scn = SexpScanner.new(sexp)
+      scn.scan_assert(:method)
+      scn.skip_to_after_assert(:story, story) if story
+      node = scn.current or fail("unexpected end of sexp")
+      run_sexp_with_handlers(doc, scn)
+      if ! scn.eos?
+        node = scn.current
+        if :method != node.first
+          fail("#{self.class} has no handler for #{node.first.inspect}")
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/nandoc/spec-doc/playback/players/ruby.rb

@@ -0,0 +1,158 @@
+require 'syntax/convertors/html'
+require 'nandoc/spec-doc/ruby2ruby-standin'
+
+# require 'nandoc/spec-doc/playback'
+
+
+module NanDoc::SpecDoc::Playback
+  class Ruby
+    # playback things like as if my name was sega
+    #
+
+    include NanDoc::SpecDoc::Ruby2RubyStandin # re_for_*
+    include PlaybackMethods
+    include Singleton
+
+    class << self
+      alias_method :get_tag_filter, :instance
+    end
+
+    def initialize
+      @here = NanDoc::Regexp.new( /\A(.*)(?:, ?<<-'?([A-Z]+))/,
+                                     :keep,          :here)
+
+      @inspect = NanDoc::Regexp.new(
+        /\A([ \t]*)(?:nandoc\.inspect[ \t]*)(.+)\Z/,
+        :indent,   :tail)
+
+      @prefix = '# '
+
+      @re_out = NanDoc::Regexp.new(/\A[ \t]*nandoc\.out\([ \t]*<<-'?([A-Z]+)/)
+
+      @re_until_do = /\A[ \t]*\)[ \t]*do[ \t]*\Z/
+    end
+
+    def run_record_ruby out, scn
+      node = scn.scan_assert(:record_ruby)
+      code = node[1]
+      @file_lines = code.file_lines.dup # we change the originals
+      while ! scn.eos? && [:inspect, :out].include?(curr = scn.current.first)
+        case curr
+        when :inspect; process_inspect(scn)
+        when :out;     process_out(scn)
+        else fail("do me: #{curr.inspect}")
+        end
+      end
+      these = @file_lines[code.start_at[:line]..code.stop_at[:line]-2]
+      block = these.join('')
+      unind = unindent(block)
+      unind.chomp! # sure why not
+      conv = ::Syntax::Convertors::HTML.for_syntax('ruby')
+      html = conv.convert(unind, false)
+      out.push_smart 'pre', 'ruby', html
+      nil
+    end
+
+  private
+
+    # @todo stuff could be cleaned up to use StringScanner but why?
+
+    # @return void. change @file_lines
+    def inspect_oneline node
+      offset = node[2][:line] - 1
+      line = @file_lines[offset]
+      /\A([ \t]*)nandoc.inspect *([^,]+), *([^,]+)\n\Z/ =~ line or fail(
+        "DocSpec hack fail: Why can't we parse this inspect "<<
+        " line?\n#{line.inspect}")
+      ind, keep, val = $1, $2, $3 # actually we don't want $3
+      replace_with = "#{ind}#{keep}\n#{ind}#{@prefix}#{node[1]}\n"
+      # assume no newlines in value when the whole thing was oneline
+      @file_lines[offset] = replace_with
+      nil
+    end
+
+    # @return void. change @file_lines
+    def process_inspect scn
+      node = scn.scan_assert(:inspect)
+      offset = node[2][:line] - 1
+      act = @file_lines[offset]
+      md = @inspect.match_assert(act)
+      md = md.to_hash
+      tail = md[:tail]
+      my_lines = []
+      md2 = @here.match(tail) or return inspect_oneline(node)
+      md2 = md2.to_hash
+      ind = leading_indent(@file_lines[offset])
+      my_lines.push "#{ind}#{md2[:keep]}\n"
+      re = re_for_here(md2[:here])
+      j = offset + 1
+      last = @file_lines.length - 1
+      until re =~ @file_lines[j] || j > last
+        back_one = @file_lines[j].sub(/\A(?:  |\t)/,'')
+        my_lines.push back_one.sub(/\A([\t ]*)/){ "#{$1}#{@prefix}" }
+        j += 1
+      end
+      j > last && fail("DocSpec hack fail: #{md2[:here]} not found "<<
+        "anywhere before EOF")
+      (offset..j).each do |k|
+        @file_lines[k] = nil
+      end
+      (0..my_lines.length-1).each do |k|
+        l = offset+k
+        @file_lines[l] = my_lines[k]
+      end
+      nil
+    end
+
+
+    # the block content gets output as if it's bare ruby,
+    # the output (whether it was expected or actual we don't care)
+    # gets output with leading comment markers.  All of this nonsense is
+    # bs proof of concept that needs to get blown away by ruby2ruby or
+    # something
+    #
+    def process_out scn
+      node = scn.scan_assert(:out)
+      call_offset = node[2][:line] - 1
+      first = @file_lines[call_offset]
+      @re_out.match_assert(first, 'nandoc.out line')
+      j = call_offset + 1
+      last = @file_lines.length - 1
+      j += 1 until j > last || @re_until_do =~ @file_lines[j]
+      j <= last or fail("DocSpec hack fail: Couldn't find do block "<<
+        "anywhere before EOF with #{ReUntilDo}")
+      do_line = @file_lines[j]
+      re = re_for_line_with_same_indent_as(do_line)
+      repl_lines = []
+      j += 1
+      repl_from_here = j
+      j += 1 until j > last || re =~ @file_lines[j]
+      j <= last or fail("DocSpec hack fail: Couldn't find end of do "<<
+        "block anywhere before EOF with #{re}")
+      offset_of_line_with_end = j
+      repl_lines = @file_lines[repl_from_here..offset_of_line_with_end-1]
+      repl_lines.any? or fail("DocSpec hack fail -- no lines")
+      ind_short = leading_indent(do_line)
+      ind_long  = leading_indent(repl_lines.first)
+      ind_diff = string_diff_assert(ind_long, ind_short)
+      unindent = re_for_unindent_gsub(ind_diff)
+      repl_lines.map{ |x| x.sub!(unindent, '') }
+        # this changes @file_lines val
+      (0..repl_lines.length-1).each do |l|
+        actual_offset = call_offset + l
+        @file_lines[actual_offset] = repl_lines[l]
+      end
+      erase_from_here = call_offset + repl_lines.length
+      (erase_from_here..offset_of_line_with_end).each do |l|
+        @file_lines[l] = nil
+      end
+      # this is so fragile, it requires multiline blah blah
+      commented_content = node[1].gsub(/^/m, "#{ind_short}#{@prefix}")
+      @file_lines[erase_from_here] = commented_content
+      nil
+    end
+    def re_for_here here
+      /\A[ \t]*#{Regexp.escape(here)}[ \t]*\n?\Z/
+    end
+  end
+end

data/lib/nandoc/spec-doc/playback/players/terminal.rb

@@ -0,0 +1,93 @@
+require 'nandoc/spec-doc/playback'
+require 'nandoc/spec-doc/playback/terminal/color-to-html'
+
+module NanDoc::SpecDoc::Playback
+  class Terminal
+    # playback things like as if my name was sega
+    #
+
+    include PlaybackMethods
+    include Singleton
+    include ColorToHtml
+    include Nanoc3::Helpers::HTMLEscape
+
+    class << self
+      alias_method :get_tag_filter, :instance
+    end
+
+    def initialize
+      @ellipsis_default = '...'
+      @prompt_str_default = '~ > '
+      @prompt_str = nil
+    end
+
+    def fake_pwd_push new_dir
+      /\A(.+) > \Z/ =~ prompt_str or
+        fail("can't determine cwd from #{prmpt_str.inspect}")
+      new_pwd = "#{$1}/#{new_dir}"
+      @old_prompts ||= []
+      @old_prompts.push prompt_str
+      @prompt_str = "#{new_pwd} > "
+      nil
+    end
+
+    def fake_pwd_pop
+      @prompt_str = @old_prompts.pop
+    end
+
+    attr_accessor :ellipsis_default
+
+    attr_accessor :prompt_str_default
+
+    def prompt_str
+      @prompt_str ||= @prompt_str_default
+    end
+
+    def run_cd out, scn
+      node = scn.scan_assert(:cd)
+      the_new_directory = node[1]
+      html = prompt_highlight2(prompt_str, "cd #{the_new_directory}")
+      fake_pwd_push the_new_directory
+      out.push_smart 'pre', 'terminal', html
+      nil
+    end
+
+    def run_cd_end out, scn
+      _ = scn.scan_assert(:cd_end)
+      fake_pwd_pop
+      nil
+    end
+
+    def run_command out, scn
+      node = scn.scan_assert(:command)
+      command_content = node[1]
+      html = prompt_highlight2(prompt_str, command_content)
+      out.push_smart 'pre', 'terminal', html
+      nil
+    end
+
+    def run_out out, scn
+      node = scn.scan_assert(:out)
+      raw = node[1]
+      html = terminal_color_to_html(raw) || html_escape(raw)
+      out.push_smart 'pre', 'terminal', html
+      nil
+    end
+
+    def run_out_begin out, scn
+      node = scn.scan_assert(:out_begin)
+      lines = [node[1].strip]
+      if node = scn.scan(:cosmetic_ellipsis)
+        lines.push node[1]
+      else
+        lines.push ellipsis_default
+      end
+      node = scn.scan_assert(:out_end)
+      lines.push node[1]
+      raw = lines.join("\n")
+      html = terminal_color_to_html(raw) || html_escape(raw)
+      out.push_smart 'pre', 'terminal', html
+      nil
+    end
+  end
+end

data/lib/nandoc/spec-doc/playback/players.rb

@@ -0,0 +1,4 @@
+me = File.dirname(__FILE__)+'/players'
+require me + '/method.rb'
+require me + '/ruby.rb'
+require me + '/terminal.rb'

data/lib/nandoc/spec-doc/playback/support/playback-methods.rb

@@ -0,0 +1,44 @@
+module NanDoc::SpecDoc::Playback
+  module PlaybackMethods
+    def get_tag_filter record
+      record.first == :class or fail("not a class record #{record.inspect}")
+      ret = nil
+      mixed = record[1]
+      if mixed.kind_of?(Class)
+        if self.kind_of?(mixed)
+          ret = self
+        else
+          ret = mixed.get_tag_filter
+        end
+      else
+        pb = NanDoc::SpecDoc::Playback
+        cls = pb.const_defined?(mixed) && pb.const_get(mixed)
+        # we need the extra check below for Terminal,
+        # which in some cases can have sub-files/modules loaded w/o it
+        # there is room to make more advanced loaders, e.g. with ::Foo::Bar
+        if ! ( cls && cls.respond_to?(:get_tag_filter) )
+          thing = mixed.gsub(/([a-z])([A-Z])/){ "#{$1}-#{$2}" }.downcase
+          require "nandoc/spec-doc/playback/#{thing}.rb"
+        end
+        cls = pb.const_get(mixed)
+        ret = cls.get_tag_filter
+      end
+      ret
+    end
+
+    def run_sexp_with_handlers doc, scn
+      these = handlers
+      while node = scn.current
+        if these.key?(node.first)
+          record = these[node.first]
+          break if record.first == :stop
+          handler = get_tag_filter(record)
+          handler.send(record[2], doc, scn)
+        else
+          break
+        end
+      end
+      nil
+    end
+  end
+end