nandoc 0.0.1

data/lib/nandoc/helpers/menu-bouncy.rb

@@ -0,0 +1,109 @@
+module NanDoc::Helpers::NanDocHelpers
+
+  #
+  # render topnav with one level of menu dropdows
+  # with buggy animated opening and closing.
+  #
+  # usage example:
+  #     nandoc_menu_bouncy(binding) do |it|
+  #       it.separator = These['❧']
+  #       it.tabs = 4
+  #     end
+  #
+  def nandoc_menu_bouncy binding, &block
+    MenuBouncy.new(binding, &block).render
+  end
+
+  #
+  # @api private
+  #
+  class MenuBouncy
+    include NanDoc::StringFormatting
+    def initialize(binding, &block)
+      @separator_default = '>'
+      @tab = '  '
+      @tabs = 0
+      @item = eval('@item', binding)
+      block.call(self)
+    end
+    attr_accessor :separator_default, :tab, :tabs
+    alias_method :separator=, :separator_default=
+    alias_method :separator, :separator_default
+    alias_method :menu_item_bullet_right, :separator_default
+    def render
+      item = @item
+      chunks = []
+      if item.nandoc_sorted_visible_children.any?
+        chunks.push render_branch(item)
+      else
+        chunks.push render_leaf(item)
+      end
+      while item = item.parent
+        chunks.push render_branch(item)
+      end
+      html = chunks.reverse.join('')
+      html2 = reindent html
+      html2.strip
+    end
+  private
+    def render_branch item
+      [
+        render_branch_label(item),
+        render_branch_sep_hack(item)
+      ].join
+    end
+    def render_branch_label item
+      <<-H
+        <div class='nanoc-sidebar-h2  nandoc-menu-lvl-1'>
+          #{render_link_or_label(item)}
+        </div>
+      H
+    end
+    def render_branch_sep_hack item
+      lines = [<<-H
+        <div class='bouncy-lvl1-sep'>#{separator}
+          <div class='bouncy-lvl2-menu'>
+      H
+      ]
+      cx = item.nandoc_sorted_visible_children
+      hh = cx.map{ |x| render_level_2_item(x) }
+      lines.concat hh
+      lines.push <<-H
+          </div>
+        </div>
+      H
+      lines.join
+    end
+    def render_level_2_item item
+      <<-H
+            <div class='bouncy-lvl2-item'>
+              <span class='bouncy-lvl2-content'>
+                #{render_link_or_label(item)}
+              </span>
+              <span class='bouncy-lvl2-sep'>#{menu_item_bullet_right}</span>
+            </div>
+      H
+    end
+    def render_label item
+      item.nandoc_title
+    end
+    def render_leaf item
+      <<-H
+        <div class='nanoc-sidebar-h2  nandoc-menu-lvl-1'>
+          #{render_label(item)}
+        </div>
+      H
+    end
+    def render_link_default item
+      "<a href='#{item.identifier}'>#{item.nandoc_title}</a>"
+    end
+    alias_method :render_link, :render_link_default
+    def render_link_or_label item
+      if item == @item
+        render_label item
+      else
+        render_link item
+      end
+    end
+  end
+end

data/lib/nandoc/helpers/site-map.rb

@@ -0,0 +1,157 @@
+module NanDoc::Helpers::NanDocHelpers
+
+  #
+  # @see default.html for example usage.
+  #
+  def nandoc_sitemap binding, name=nil, &block
+    name ||= SiteMap.next_unique_name
+    SiteMap.singleton(name, binding, &block).render_parent
+  end
+
+  #
+  # @api private
+  #
+  class SiteMap
+    extend BlockAttrAccessor, NanDoc::SharedAttrReader
+    include NanDoc::SecretParent
+    module Glyphs; end # forward declaration
+    include Glyphs
+    @singletons = {}
+    @next_unique_name = -1
+    class << self
+      def next_unique_name
+        @next_unique_name += 1
+        @next_unique_name
+      end
+      def singleton(name, binding, &block)
+        @singletons[name] ||= begin
+          sing = new
+          sing.init_root(binding, &block)
+          sing
+        end
+      end
+    end
+    def initialize
+      @tab = '  '
+    end
+    attr_accessor :glyphs, :item, :is_first, :is_last,
+                  :root_identifier, :tabs, :tab
+    attr_reader :level
+    block_attr_accessor :children, :render_child # defines *_proc
+    shared_attr_reader :children_proc, :glyphs, :tab, :render_child_proc,
+      :render_parent_proc # children will access root nodes's attrs for these
+
+    def init_root binding, &block
+      block.call(self)
+      @is_first = @is_last = true
+      @level = 0
+      @item = nil
+      @tabs ||= 0
+      root = eval('@items',binding).find{|x| x.identifier == root_identifier}
+      children_populate_recursive [root]
+    end
+    def init_child parent, item
+      self.parent = parent
+      @item = item
+      self.shared = parent.shared # this does a lot, see SharedAttrReader
+      @level = parent.level + 1
+      @tabs =  parent.tabs + 1
+      cx = children_proc.call(@item)
+      children_populate_recursive cx
+    end
+    def children_populate_recursive cx
+      if cx.any? # keep our @children nil unless we have any children
+       last_idx = cx.size - 1
+        @children = cx.each.with_index.map do |item, idx|
+          map = self.class.new
+          map.is_first = idx == 0
+          map.is_last  = idx == last_idx
+          map.init_child self, item
+          map
+        end
+      end
+    end
+
+    def merge_opts opts
+      fail("just for setting tabs for now") unless opts.keys == [:tabs]
+      @tabs = opts[:tabs]
+      opts
+    end
+
+    # @return [String] <ul> for e.g.  Sets block if given.
+    def render_parent &block
+      if block_given?
+        @render_parent_proc = block
+        class << self
+          attr_accessor :render_parent_proc
+        end
+        nil
+      elsif @children.nil?
+        nil
+      else
+        h1 = render_parent_proc.call(self)
+        h2 = reindent(h1).strip
+        h2
+      end
+    end
+
+    # @return [String] chunk of <li's> for eg.
+    def render_children opts={}
+      these = @children.map do |map|
+        map.merge_opts opts
+        h1 = render_child_proc.call(map)
+        h2 = map.reindent(h1)
+        h3 = h2.strip
+        h3
+      end
+      last = @children.last
+      hz = these.join("\n" + last.tab * last.tabs) if last
+      hz
+    end
+  end
+
+  module SiteMap::Glyphs
+    # http://www.alanwood.net/unicode/box_drawing.html
+    Blank  = '&nbsp;'
+    DownLf = '&#9488;' # ┐
+    DownRt = '&#9484;' # ┌
+    HvVtLf = '&#9515;' # ┫
+    HvVert = '&#9475;' # ┃
+    UpLeft = '&#9496;' # ┘
+    UpRite = '&#9492;' # └
+    Vertic = '&#9474;' # │
+    VertLf = '&#9508;' # ┤
+    VertRt = '&#9500;' # ├
+    VtHori = '&#9532;' # ┼
+    ArcUpL = '&#9583;' # ╯
+    DashQV =' &#9482;' # ┊
+
+    UseThisForBlanks = proc{|node| DashQV }
+    # DashQV is nice b/c fixed width
+
+    def glyphs_right_for_child
+      @glyphs_right_for_child ||= begin
+        case level
+        when 0; []     # e.g. the object that is rendering [home]
+        when 1; []     # e.g. home, the (lvl2) children have no inheirited
+        else
+          x = [ is_last ? UseThisForBlanks.call(self) : HvVert ]
+          x.concat(parent.glyphs_right_for_child) if parent
+          x
+        end
+      end
+    end
+
+    def glyphs_right
+      case level
+      when 0; fail('never')
+      when 1; ''
+      else
+        these = [ is_last ? ArcUpL : HvVtLf ]
+        these.concat( parent.glyphs_right_for_child ) if parent
+        # these.concat Array.new([0, level-1].max, DashQV)
+        these.join('')
+      end
+    end
+  end
+end

data/lib/nandoc/helpers/top-nav.rb

@@ -0,0 +1,47 @@
+module NanDoc::Helpers::NanDocHelpers
+
+  #
+  # nandoc_topnav do |sm|
+  #   sm.binding = binding
+  #   sm.item { |i| <<-H
+  #     <span class='nanoc-sidebar-h2'>#{i.nandoc_title}</span>
+  #   H
+  #   }
+  #   sm.current_item { |i| <<-H
+  #     <span class='nanoc-sidebar-h2'>#{i.nandoc_title}</span>
+  #   H
+  #   }
+  #   sm.separator { <<-H
+  #     <span class='nanoc-sep'>&#10087;</span>
+  #   H
+  #   }
+  #
+
+  def nandoc_topnav &block
+    TopNav.new(&block).render
+  end
+
+  class TopNav
+    extend BlockAttrAccessor
+    def initialize(&b)
+      block_attr_accessor_init
+      @current_item = @items = @item = nil
+      b.call(self)
+    end
+    block_attr_accessor :current_item, :item, :separator
+    attr_accessor :binding
+    def render
+      item = eval('@item', @binding)
+      temdoz = [@current_item_proc.call(item)]
+      while item = item.parent
+        temdoz.concat [@separator_proc.call, @item_proc.call(item)]
+      end
+      temdoz.reverse
+    end
+    class << self
+      def home_page &b
+        @home_page ||= b.call
+      end
+    end
+  end
+end

data/lib/nandoc/helpers.rb

@@ -0,0 +1,42 @@
+module NanDoc::Helpers
+  module NanDocHelpers
+    # @todo-now test this
+    include NanDoc::StringFormatting # indent() unindent() no_blank_lines()
+    module BlockAttrAccessor
+      attr_accessor :block_attr_accessors
+      class << self
+        def extended mod
+          mod.instance_variable_set('@block_attr_accessors', []) unless
+            mod.instance_variable_defined?('@block_attr_accessors')
+          mod.send(:define_method, :block_attr_accessor_init) do
+            self.class.block_attr_accessors.each do |name|
+              instance_variable_set("@#{name}_proc",nil) unless
+                instance_variable_defined?("@#{name}_proc")
+            end
+          end
+        end
+      end
+      def block_attr_accessor *names
+        names.each do |setter_name|
+          @block_attr_accessors.push(setter_name) # etc
+          attr_name = "@#{setter_name}_proc"
+          getter_name = "#{setter_name}_proc"
+          define_method(setter_name) do |&block|
+            raise ArgumentError.new(
+              "no block given for #{self.class}##{setter_name}"
+            ) unless block
+            instance_variable_set attr_name, block
+          end
+          define_method(getter_name) do
+            instance_variable_get attr_name
+          end
+        end
+      end
+    end
+  end
+end
+
+here = File.dirname(__FILE__)+'/helpers'
+require here + '/menu-bouncy.rb'
+require here + '/site-map.rb'
+require here + '/top-nav.rb'

data/lib/nandoc/item-class-hacks.rb

@@ -0,0 +1,57 @@
+class Nanoc3::Item
+  #
+  # hacks we use for stuff like sitemap and topnav generation
+  #
+  class << self
+    def sorted_visible_children
+      @svc ||= begin
+        proc do |node|
+          node.children.select{|c| c.nandoc_visible? }.sort_by(&:nandoc_title)
+        end
+      end
+    end
+  end
+
+
+  include NanDoc::StringFormatting # basename_no_extension()
+
+  attr_accessor :identifier # know what you are doing if you set it
+
+  #
+  # come up with some title by any means necessary
+  #
+  def nandoc_title
+    if @attributes[:title]
+      @attributes[:title]
+    elsif ! nandoc_content_node?
+      identifier
+    elsif no_ext = basename_no_extension(@attributes[:content_filename])
+      no_ext.gsub(/[-_]/, ' ') # we could do wiki-name like crap
+    elsif ! (foo = File.basename(@attributes[:content_filename])).empty?
+      foo
+    else
+      identifier == '/' ? 'HOME' : identifier.gsub('/',' - ')
+    end
+  end
+
+  def nandoc_content_node?
+    /\A\/(?:css|js|vendor)\// !~ identifier # @todo will have to change!
+  end
+
+  def nandoc_content_leaf?
+    nandoc_content_node? # hm
+  end
+
+  def nandoc_content_branch?
+    false # hm
+  end
+
+  def nandoc_sorted_visible_children
+    self.class.sorted_visible_children.call(self)
+  end
+
+  def nandoc_visible?
+    !self[:hidden] && path && nandoc_content_node?
+  end
+
+end

data/lib/nandoc/nandoc.persistent.json

@@ -0,0 +1,3 @@
+{
+  "tmpdir": "/var/folders/Uc/UcTP6K3aF5O604wVlmM89E+++TQ/-Tmp-/treebis"
+}

data/lib/nandoc/parse-readme.rb

@@ -0,0 +1,95 @@
+module NanDoc
+  class ParseReadme
+    #
+    # If you are really really crazy then you don't like
+    # repeating yourself between your gemspec and your README with regard to
+    # the project summary and description.
+    #
+    # This is a quick and dirty hack to parse your README (or similary
+    # formatted file) in a really rough way for when you are building your
+    # gemspec -- it doesn't use a markdown parser or whatever.  It scans the
+    # README file for a line like "## Summary" and reads the next line with
+    # content after it. (ditto "## Description" etc.)
+    #
+    # See the Rakefile of this project for example usage.
+    #
+    # @see note below near 'jeweler'
+    #
+
+    def initialize(path=nil, &block)
+      @parsed_content = {}
+      @lines = nil
+      @path = path and get_lines!
+      instance_eval(&block) if block_given?
+    end
+    class << self
+      alias_method :parse, :new
+      def description file
+        DeferredParse.new(file, :description)
+      end
+      def summary file
+        DeferredParse.new(file, :summary)
+      end
+    end
+    attr_accessor :lines
+    def path name
+      @path = name
+      get_lines!
+      name
+    end
+    def parse_section *names
+      names.each do |name|
+        re = /\A#* ?#{Regexp.escape(name.to_s)}\Z/i
+        idx = (@lines.index{|x| re =~ x } or
+          fail("#{name.to_s.inspect} section not found in #{path}")) + 1
+        idx += 1 while @lines[idx] && /\A[[:space:]]+\Z/ =~ @lines[idx]
+        line = @lines[idx] or
+          fail("couldn't find content following #{name.to_s} section")
+        @parsed_content[name] = line.strip
+        class << self; self end.send(:define_method, name) do
+          @parsed_content[name]
+        end
+      end
+      nil
+    end
+    alias_method :parse_sections, :parse_section
+  private
+    def get_lines!
+      @lines = File.open(@path).lines.map
+    end
+    class DeferredParse
+      #
+      # This whole thing is a ridiculously fragile and secret hack
+      # that is maybe pointless @todo
+      # The point is to defer opening and parsing the README file unless
+      # necessary.  (But it didn't work as intended, but no big deal.)
+      #
+      # If you use it is is recommended that you use jeweler and the
+      # gemspec:debug task to check its work.
+      #
+
+      @files = {}
+      class << self
+        attr_reader :files
+      end
+      def initialize path, section
+        @path, @section = path, section
+        @as_string = nil
+      end
+      def strip
+        as_string.strip
+      end
+      def to_s
+        as_string # can't simply alias it b/c it is private
+      end
+    private
+      def as_string
+        @as_string ||= begin
+          parse = (self.class.files[@path] ||= ParseReadme.new(@path))
+          parse.parse_section(@section) unless parse.respond_to?(@section)
+          parse.send(@section)
+        end
+      end
+    end
+  end
+end

data/lib/nandoc/spec-doc/mini-test.rb

@@ -0,0 +1,105 @@
+require 'stringio'
+require File.expand_path('../../test/minitest-extlib.rb', __FILE__)
+
+module NanDoc::SpecDoc::MiniTest
+  class Proxy < ::NanDoc::SpecDoc::TestFrameworkProxy
+
+    def initialize(*a)
+      super(*a)
+      @hacked_minitest = false
+    end
+
+  private
+
+    #
+    # given
+    # @param [String] the natural sounding string name as it appears in
+    #   documentation,
+    # @return [Array] a pair of strings: suite name and method name
+    #
+    def find_test str
+      meth_tail = str.gsub(/\W+/, '_').downcase
+      # i *think* we want *not* to escape it below
+      filter =  /\Atest_\d{4}_#{meth_tail}\Z/
+      found_meths = []
+      found_pairs = []
+      ::MiniTest::Unit::TestCase.test_suites.each do |suite|
+        if (foundfound = suite.test_methods.grep(filter)).any?
+          found_pairs.push [suite, foundfound]
+          found_meths.concat foundfound
+        end
+      end
+      case found_meths.size
+      when 0;
+        fail("no tests were found whose name matches the pattern #{filter}")
+      when 1;
+        ff = found_pairs.first
+        [ff[0], ff[1][0]] # suite and method name
+      else
+        fail("found more than one test matching the pattern for \"#{str}\""<<
+        " -- (#{found_meths.join(', ')})")
+      end
+    end
+
+    #
+    # do whatever you have to do to prepare minitest to run nandoc-enabled
+    # tests
+    #
+    def hack_minitest
+      return if @hacked_minitest
+      @testout = StringIO.new
+      ::MiniTest::Unit.output = @testout
+        # this is set but ignored which is ok. it gets method names and dots
+      sing = class << ::MiniTest::Unit; self end
+      sing.send(:define_method, :autorun){ } # override it to do nothing!!
+      @hacked_minitest = true
+    end
+
+    #
+    # given
+    # @param [String] testfile name (just semantic not formal)
+    # @param [String] testname (just semantic not formal)
+    # @param [String] a test case name and
+    # @param [String] a method name,
+    # run the test in question which will hopefully write to the recordings
+    # experimentally
+    # @return an exit status of 0 if everything's ok
+    #
+    def run_test_case_method testfile, testname, test_case, meth_name
+      hack_minitest unless @hacked_minitest
+      unambig_re = /\A#{Regexp.escape(meth_name)}\Z/
+      runner = ::MiniTest::Unit.new
+      runner.instance_variable_set('@verbose', true)
+      test_count, ass_count = runner.run_test_suites unambig_re
+      fail("didn't run any tests for #{unambig_re.source}") unless
+        test_count == 1
+      if runner.report.any?
+        return handle_failed_tests(runner, testfile, testname)
+      end
+      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