nandoc 0.0.3 → 0.0.4

data/lib/nandoc/spec-doc/playback/support/sexp-scanner.rb

@@ -0,0 +1,61 @@
+module NanDoc::SpecDoc::Playback
+  class SexpScanner
+    def initialize sexp
+      @sexp = sexp
+      @offset = 0
+      @last = @sexp.size - 1
+    end
+    def chimp arr
+      arr.size == 1 ? arr.first : arr
+    end
+    def current
+      @sexp[@offset]
+    end
+    def eos?
+      @offset > @last
+    end
+    def rest
+      @sexp[@offset..-1]
+    end
+    attr_reader :sexp
+    def scan a, *b
+      current = self.current or return nil
+      search = [a,*b]
+      ret = nil
+      if current[0..search.size-1] == search
+        ret = current
+        @offset += 1
+      end
+      ret
+    end
+    def scan_assert a, *b
+      ret = scan(a, *b)
+      if ! ret
+        fail("expecting #{a.inspect} had #{current.inspect}")
+      end
+      ret
+    end
+    def skip_to_after a, *b
+      search = [a, *b]
+      last = search.size - 1
+      idx = @sexp.index{ |n| n[0..last] == search }
+      ret = false
+      if idx
+        @offset = idx + 1
+        ret = @offset
+      end
+      ret
+    end
+    def skip_to_after_assert a, *b
+      idx = skip_to_after(a, *b)
+      if ! idx
+        search = [a, *b]
+        last = search.size - 1
+        nn = @sexp.select{ |n| n[0..last] == search }
+        nn = nn.map{ |n| chimp(n[1..-1]).inspect }
+        fail("#{chimp(search).inspect} not found. had:(#{nn.join(', ')})")
+      end
+      idx
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+me = File.dirname(__FILE__)+'/support'
+require me + '/playback-methods.rb'
+require me + '/sexp-scanner.rb'

data/lib/nandoc/spec-doc/playback/terminal/color-to-html.rb

@@ -0,0 +1,100 @@
+module NanDoc; end
+module NanDoc::SpecDoc; end
+module NanDoc::SpecDoc::Playback; end
+class NanDoc::SpecDoc::Playback::Terminal; end
+module NanDoc::SpecDoc::Playback::Terminal::ColorToHtml
+
+
+  include Nanoc3::Helpers::HTMLEscape
+  alias_method :h, :html_escape
+
+
+  # look for things that look like prompts and make them brighter
+  # @todo html escape vis-a-vis blah
+  def prompt_highlight str
+    lines = str.split("\n")
+    linez = lines.map do |line|
+      line.sub( %r!\A(~[^>]*>)?(.*)\Z! ) do
+        tags = [];
+        tags.push "<span class='prompt'>#{h($1)}</span>" if $1
+        tags.push "<span class='normal'>#{h($2)}</span>" unless $2.empty?
+        tags.join('')
+      end
+    end
+    html = linez.join("\n")
+    html
+  end
+  
+  def prompt_highlight2 prompt, cmd
+    "<span class='prompt'>#{h(prompt)}</span>"<<
+    "<span class='normal'>#{h(cmd)}</span>\n"
+  end
+  
+  # this sucks.
+  #
+  # the other side of these associations lives in trollop-subset.css
+  Code2CssClass = {
+    '1' => 'bright',  '30' => 'black', '31' => 'red', '32' => 'green',
+    '33' => 'yellow', '34' => 'blue', '35' => 'magenta', '36' => 'cyan',
+    '37' => 'white'
+  }      
+  def terminal_color_to_html str
+    return nil unless str.index("\e[") # save a whale
+    scn = StringScanner.new(str)
+    sexp = []
+    while true
+      foo = scn.scan(/(.*?)(?=\e\[)/m)
+      if ! foo
+        blork = scn.scan_until(/\Z/m) or fail("worglebezoik")
+        sexp.push([:content, blork]) unless blork.empty?
+        break;
+      end
+      foo or fail("oopfsh")
+      sexp.push([:content, foo]) unless foo.empty?
+      bar = scn.scan(/\e\[/) or fail("goff")
+      baz = scn.scan(/\d+(?:;\d+)*/)
+      baz or fail("narghh")
+      if '0'==baz
+        sexp.push([:pop])
+      else
+        sexp.push([:push, *baz.split(';')])
+      end
+      biff = scn.scan(/m/) or fail("noiflphh")
+    end
+    html = terminal_colorized_sexp_to_html sexp
+    html
+  end
+private
+  def terminal_code_to_css_class code
+    Code2CssClass[code] or
+      fail("sorry, no known code for #{code.inspect}. "<<
+      "(maybe you should make one?)")
+  end
+  def terminal_colorized_sexp_to_html sexp
+    i = -1;
+    last = sexp.length - 1;
+    parts = []
+    catch(:done) do
+      while (i+=1) <= last
+        codes = nil
+        while i <= last && sexp[i].first == :push
+          codes ||= []
+          codes.concat sexp[i][1..-1]
+          i += 1
+        end
+        if codes
+          classes = codes.map{|c| terminal_code_to_css_class(c) }*' '
+          parts.push "<span class='#{classes}'>"
+        end
+        throw :done if i > last
+        case sexp[i].first
+          when :content; parts.push(sexp[i][1])
+          when :pop; parts.push('</span>')
+          else; fail('fook');
+        end
+      end
+    end
+    html = parts*''
+    html
+  end
+end

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

@@ -0,0 +1,3 @@
+me = File.dirname(__FILE__) + '/playback'
+require me + '/support'
+require me + '/players'

data/lib/nandoc/spec-doc/recordings.rb

@@ -0,0 +1,55 @@
+module NanDoc::SpecDoc
+
+  class Recordings < Array
+    #
+    # everything that nandoc does during test runs gets written
+    # to one of these.  It's like a Sexp structure.
+    #
+
+    @for_test_case = {}
+    @for_key = {}
+
+    class << self
+      attr_accessor :for_test_case, :for_key
+      def get test_case
+        @for_test_case[test_case.class] ||= new(test_case.class)
+      end
+      def get_for_key key
+        @for_key[key] ||= new(key)
+      end
+      def report_test_case_not_found tc
+        msgs = ["no recordings found for #{tc}"]
+        msgs.join('  ')
+      end
+    end
+
+    def add name, *data
+      # this might change if we need to group by method name
+      push [name, *data]
+    end
+
+    def get_first_sexp_for_test_method meth
+      first = index([:method, meth]) or return nil
+      last = (first+1..length-1).detect do |i|
+        self[i].first == :method && self[i][1] != meth
+      end
+      last = last ? (last - 1) : (length - 1)
+      ret = self[first..last]
+      ret
+    end
+
+    def initialize test_case
+      @test_case = test_case
+    end
+
+    def note &block
+      push [:note, block]
+    end
+
+    def report_recording_not_found meth_name
+      "no recordings found for #{meth_name}"
+    end
+
+    attr_reader :test_case
+  end
+end

data/lib/nandoc/spec-doc/ruby2ruby-standin.rb

@@ -0,0 +1,37 @@
+module NanDoc::SpecDoc
+  module Ruby2RubyStandin
+    def leading_indent str
+      /\A([ \t]*)/ =~ str && $1
+    end
+    def re_for_line_with_same_indent_as str
+      ind = leading_indent(str)
+      re = /\A#{Regexp.escape(ind)}(?=[^ \t])/
+      re
+    end
+    def re_for_here here
+      /\A[ \t]*#{Regexp.escape(here)}[ \t]*\n?\Z/
+    end
+    def re_for_unindent_gsub indent
+      re = /\A#{Regexp.escape(indent)}/
+      re
+    end
+    def reindent_content raw_content, indent
+      return raw_content if indent == ''
+      # of all non-blank lines find the minimum indent.
+      x = raw_content.scan(/^[[:space:]]+(?=[^[:space:]])/).map(&:length).min
+      # if for some reason the content has less indent than the fences,
+      # don't alter any of it.
+      return raw_content if x < indent.length
+      re = /^#{Regexp.new(indent)}/
+      unindented_content = raw_content.gsub(re, '')
+      unindented_content
+    end
+    def string_diff_assert long, short
+      idx = long.index(short) or fail("short not found in long -- "<<
+      "#{short.inspect} in #{long.inspect}")
+      head = long[0,idx] # usu. ''
+      tail = long[idx + short.length..-1]
+      head + tail
+    end
+  end
+end

data/lib/nandoc/spec-doc/test-case-agent.rb

@@ -51,7 +51,7 @@ module NanDoc::SpecDoc
     end
   private
     def recordings
-      Recordings.get(@test_case)
+      ::NanDoc::SpecDoc::Recordings.get(@test_case)
     end
   end
 end

data/lib/nandoc/spec-doc/{mini-test.rb → test-framework/mini-test/proxy.rb}

@@ -1,16 +1,17 @@
-require 'stringio'
-require File.expand_path('../../test/minitest-extlib.rb', __FILE__)
+require 'nandoc/spec-doc/test-framework/proxy'
 
-module NanDoc::SpecDoc::MiniTest
-  class Proxy < ::NanDoc::SpecDoc::TestFrameworkProxy
+module NanDoc::SpecDoc::TestFramework::MiniTest
+  class Proxy < ::NanDoc::SpecDoc::TestFramework::Proxy
+    #
+    # our central nexus interflux for all interactions that require mini-test
+    #
+
+  private
 
-    def initialize(*a)
-      super(*a)
+    def initialize
       @hacked_minitest = false
     end
 
-  private
-
     #
     # given
     # @param [String] the natural sounding string name as it appears in
@@ -79,27 +80,4 @@ module NanDoc::SpecDoc::MiniTest
       return 0
     end
   end
-
-
-  #
-  # These are the methods that will be available to nandoc-enhanced tests.
-  # For now it is recommended to leave this as just the one method nandoc(),
-  # which will return the TestCaseAgent.
-  #
-  module SpecInstanceMethods
-    class << self
-      def include_to mod
-        unless mod.ancestors.include?(::MiniTest::Spec)
-          fail(
-           "Sorry, for now SpecDoc can only extend MiniTest::Spec "<<
-           " tests.  Couldn't extend #{mod}."
-          )
-        end
-        mod.send(:include, self)
-      end
-    end
-    def nandoc
-      @nandoc_agent ||= ::NanDoc::SpecDoc::TestCaseAgent.new(self)
-    end
-  end
 end

data/lib/nandoc/spec-doc/{test-framework-proxy.rb → test-framework/proxy.rb}

@@ -1,41 +1,14 @@
-module NanDoc::SpecDoc
-  class TestFrameworkProxy
+module NanDoc::SpecDoc::TestFramework
+  class Proxy
+  protected
     # abstract baseclass, an agent that runs tests
 
-    def initialize gem_root
-      @gem_root = gem_root
-    end
-
-    def get_sexp testfile, testname
-      TestFrameworkProxy.sexp_cache[testfile][testname] ||= begin
-        build_sexp testfile, testname
-      end
-    end
-
-    def build_sexp testfile, testname
-      load_file testfile
-      test_case, meth_name = find_test testname
-      run_test_case_method testfile, testname, test_case, meth_name
-      recs = ::NanDoc::SpecDoc::Recordings.for_test_case[test_case] or
-        fail(::NanDoc::SpecDoc::Recordings.
-                               report_test_case_not_found(test_case))
-      sexp = recs.get_first_sexp_for_test_method(meth_name) or
-        fail recs.report_recording_not_found(meth_name)
-      sexp
-    end
-
     @sexp_cache = Hash.new{ |h,k| h[k] = {} }
     class << self
       attr_reader :sexp_cache
     end
 
-  protected
-
-    #
-    # the stream to write to when things like a specdoc test run fails
-    #
-    def err
-      $stderr
+    def initialize
     end
 
     def handle_failed_tests runner, testfile, testname
@@ -48,31 +21,35 @@ module NanDoc::SpecDoc
       exit(1);
     end
 
-    def load_file testfile
-      path = testdir + '/' + testfile
-      fail("test file not found: #{path.inspect}") unless File.file?(path)
-      # if you need to, do a diff
-      require path
+    # the stream to write to when things like a specdoc test run fails
+    def err
+      $stderr
+    end
+
+    def sexp_build testfile, testname
+      NanDoc::Project.instance.require_test_file(testfile)
+      test_case, meth_name = find_test testname
+      run_test_case_method testfile, testname, test_case, meth_name
+      recs = ::NanDoc::SpecDoc::Recordings.for_test_case[test_case] or
+        fail(::NanDoc::SpecDoc::Recordings.
+                               report_test_case_not_found(test_case))
+      sexp = recs.get_first_sexp_for_test_method(meth_name) or
+        fail recs.report_recording_not_found(meth_name)
+      sexp
+    end
+
+  public
+    def sexp_get testfile, testname
+      Proxy.sexp_cache[testfile][testname] ||= begin
+        sexp_build testfile, testname
+      end
     end
 
-    #
+  protected
     # default way to read what the test run wrote to stdout
-    #
     def testout_str
       @testout.rewind
       @testout.read
     end
-
-    #
-    # default way to deduce the root directory that holds the tests
-    #
-    def testdir
-      @testdir ||= begin
-        tries = [@gem_root+'/test', @gem_root+'/spec']
-        found = tries.detect{ |path| File.directory?(path) }
-        fail("Couldn't find test dir for gem at (#{tries*', '})") unless found
-        found
-      end
-    end
   end
 end

data/lib/nandoc/spec-doc.rb

@@ -4,10 +4,16 @@ unless Object.const_defined?('NanDoc')
   require File.expand_path('../../nandoc.rb', __FILE__)
 end
 
+
+# @todo get this right
+unless NanDoc.const_defined?('SpecDoc') # TO_HERE_HACK
+
 me = File.dirname(__FILE__)+'/spec-doc'
-require me + '/support-modules.rb'
+require me + '/agent-instance-methods.rb'
+require me + '/code-snippet.rb'
+require me + '/parse-trace.rb'
+require me + '/recordings.rb'
 require me + '/test-case-agent.rb'
-require me + '/test-framework-dispatcher.rb'
 
 module NanDoc
   module SpecDoc
@@ -20,27 +26,65 @@ module NanDoc
       def include_to mod
         if Object.const_defined?('MiniTest') &&
             mod.ancestors.include?(::MiniTest::Spec)
-          require File.dirname(__FILE__)+'/spec-doc/mini-test.rb'
-          ::NanDoc::SpecDoc::MiniTest::SpecInstanceMethods.include_to mod
+          require 'nandoc/extlib/minitest.rb'
+          SpecInstanceMethods.include_to mod
         else
-          fail("don't know how to enhance test module: #{mod}")
+          GenericInstanceMethods.include_to mod
         end
       end
+
+      #
+      # no reason not to use the conventional callback
+      # in cases where we are not passing parameters to the enhancement
+      #
+      alias_method :included, :include_to
     end
 
-    def initialize gem_root
-      @sexp_cache = Hash.new{|h,k| h[k] = {}}
-      @test_framework_dispatcher = TestFrameworkDispatcher.new(gem_root)
+    #
+    # Experimental nandoc hook to give random ass objects a hook to some
+    # kind of SpecDoc agent thing that can a) not necessarily be a test case
+    # but b) still write recordings somehow.  let's see what happens.  hook.
+    #
+    module GenericInstanceMethods
+      class << self
+        def include_to mod
+          mod.send(:include, self)
+        end
+      end
+      def nandoc
+        @nandoc_agent ||= begin
+          require File.dirname(__FILE__)+'/spec-doc/generic-agent'
+          GenericAgent.new(self)
+        end
+      end
     end
 
     #
-    # only run any test method at most once, just to keep recordings clean
+    # These are the methods that will be available to nandoc-enhanced tests.
+    # For now it is recommended to leave this as just the one method nandoc(),
+    # which will return the TestCaseAgent.
     #
-    def get_sexp testfile, testname
-      sexp = @sexp_cache[testfile][testname] ||= begin
-        @test_framework_dispatcher.get_sexp testfile, testname
+    module SpecInstanceMethods
+      class << self
+        def include_to mod
+          #
+          # This used to be MiniTest::Spec-specific, now it's not, but here
+          # for reference:
+          #
+          # unless mod.ancestors.include?(::MiniTest::Spec)
+          #   fail(
+          #    "Sorry, for now SpecDoc can only extend MiniTest::Spec "<<
+          #    " tests.  Couldn't extend #{mod}."
+          #   )
+          # end
+          mod.send(:include, self)
+        end
+      end
+      def nandoc
+        @nandoc_agent ||= TestCaseAgent.new(self)
       end
-      sexp
     end
   end
 end
+
+end # TO_HERE_HACK

data/lib/nandoc/support/regexp-enhance.rb

@@ -35,6 +35,12 @@ module NanDoc
         end
       end
     end
+    def match_assert str, name=nil
+      match(str) or begin
+        use_name = name || "/#{source}/"
+        fail("#{use_name} failed to match #{str.inspect}")
+      end
+    end
     def names *list
       if list.any?
         @names = list

data/lib/nandoc/support/regexp.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__)+'/regexp-enhance.rb'
+
+module NanDoc
+  class Regexp < ::Regexp
+    def initialize re, *names
+      super(re)
+      RegexpEnhance.to(self) do |me|
+        me.names(*names) if names.any?
+      end
+    end
+  end
+end

data/lib/nandoc/support/secret-parent.rb

@@ -0,0 +1,21 @@
+module NanDoc
+  module SecretParent
+    #
+    # @dependencies: none
+    # @api private
+    # set parent attribute without it showing up in inspect() dumps
+    #
+    def parent= mixed
+      fail("no clear_parent() available yet.") unless mixed
+      @has_parent = !! mixed
+      class << self; self end.send(:define_method, :parent){mixed}
+      mixed # maybe chain assignmnet of 1 parent to several cx at once
+    end
+    def parent?
+      instance_variable_defined?('@has_parent') && @has_parent # no warnings
+    end
+    def parent
+      nil
+    end
+  end
+end

data/lib/nandoc/support/shared-attr-reader.rb

@@ -0,0 +1,32 @@
+module NanDoc
+  module SharedAttrReader
+    #
+    # @api private
+    # @dependencies none
+    #
+    # this is a specialized form of delegator pattern: let one object
+    # use the responses from another object for a set of accessors
+    #
+    def shared_attr_reader *list
+      fail('no inehiritance yet') if method_defined?(:shared=)
+      sm = Module.new
+      name = self.to_s+'::SharedAttrReaders'
+      sing = class << sm; self end
+      sing.send(:define_method, :name){name}
+      sing.send(:alias_method, :inspect, :name)
+      list.each do |attrib|
+        sm.send(:define_method, attrib){ shared.send(attrib) }
+      end
+      fail('no') if method_defined?(:shared)
+      define_method(:shared){ self }
+      define_method(:shared=) do |source|
+        sing = class << self; self end
+        sing.send(:define_method, :shared){ source }
+        sing.send(:include, sm) # wow cool that this works w/o having
+                                # to Module#undef_method
+        source
+      end
+      nil
+    end
+  end
+end

data/lib/nandoc/support/site-merge.rb

@@ -11,7 +11,7 @@ module NanDoc
     end
     def site_merge opts, args
       existing_site_path = args.first
-      task_abort("it's not exist: #{path}") unless
+      command_abort("it's not exist: #{path}") unless
         File.exist?(existing_site_path)
       # nanoc writes to stdout so we do too, but here we want to write
       # to stderr these notices, and write the diff to stdout

data/lib/nandoc/support/site-methods.rb

@@ -23,7 +23,7 @@ module NanDoc
         end
         path
       else
-        task_abort <<-D.gsub(/^  */,'')
+        command_abort <<-D.gsub(/^  */,'')
           site path not found: #{args.first.inspect}
           usage: #{usage}
           #{invite_to_more_command_help}
@@ -37,14 +37,14 @@ module NanDoc
           path
         else
           persistent_set('last_site_path',false)
-          task_abort <<-D.gsub(/^  */,'')
+          command_abort <<-D.gsub(/^  */,'')
           previous site path is stale (#{path.inspect}) and no site provided
           usage: #{usage}
           #{invite_to_more_command_help}
           D
         end
       else
-        task_abort(
+        command_abort(
         'no site path provided and no site path in persistent data file '<<
         "(#{NanDoc.dotfile_path})\n"<<
         <<-D.gsub(/^ */,'')
@@ -61,7 +61,7 @@ module NanDoc
     #
     def parse_config_for_site_path path
       config_path = config_path_for_site_path( path )
-      task_abort("config file for app not found: #{config_path}") unless
+      command_abort("config file for app not found: #{config_path}") unless
         File.exist?(config_path)
       YAML.load_file config_path
     end

data/lib/nandoc/support/stream-colorizer.rb

@@ -72,7 +72,7 @@ module NanDoc
       end
       attr_reader :rule_list
       def when(re_or_symbol, opts=nil, &block)
-        if re_or_symbol.kind_of?(Regexp) && Hash===opts && ! block_given?
+        if re_or_symbol.kind_of?(::Regexp) && Hash===opts && ! block_given?
           add_regex_rule(re_or_symbol, opts)
         elsif re_or_symbol.kind_of?(Symbol) && opts.nil? && block_given?
           define_state(re_or_symbol, &block)