nandoc 0.0.1

data/lib/nandoc/support-modules.rb

@@ -0,0 +1,270 @@
+module NanDoc
+  module CliCommandHelpers
+    def command_name
+      (/::([_a-z0-9]+)\Z/i =~ self.class.to_s and base = $1) or fail('no')
+      base.gsub(/([a-z])([A-Z])/){ "#{$1}-#{$2}" }.downcase
+    end
+    def invite_to_more_command_help
+      "see `nandoc help #{command_name}` for more information."
+    end
+    def invocation_name
+      File.basename($PROGRAM_NAME)
+    end
+  end
+  module StringFormatting; end
+  module OptsNormalizer
+    def normalize_opts opts
+      opts = opts.dup
+      opts.keys.select{|x| x.to_s.index('-') }.each do |k|
+        opts[k.to_s.gsub('-','_').to_sym] = opts.delete(k)
+      end
+      opts
+    end
+    def unnormalize_opt_keys keys
+      keys.map{|x| unnormalize_opt_key(x)}
+    end
+    def unnormalize_opt_key key
+      "--#{key.to_s.gsub('_','-')}"
+    end
+
+    #
+    # only call this if you are like a ::Cri::Command object with
+    # all the nanDoc hacks. ick.  This is a temprary hack.  Trollop et al
+    # do this better.
+    #
+    def exclusive_opt_flags opts, &block
+      Exclusive.new(&block).parse(self, opts)
+    end
+
+    class Exclusive
+      include OptsNormalizer
+      def initialize &block
+        @exclusive_flag_keys = nil
+        @default_short = nil
+        @default_key = nil
+        @notice_stream = $stderr
+        instance_eval(&block)
+        fail('definition block needs at least flags()') unless
+          @exclusive_flag_keys
+      end
+      def flags * exclusive_flag_keys
+        @exclusive_flag_keys = exclusive_flag_keys
+      end
+      # params: [short_name_string] name_key
+      def default *a
+        if a.first.kind_of?(String)
+          @default_short = a.shift
+        end
+        if a.first.kind_of?(Symbol)
+          @default_key = a.shift
+        else
+          fail("bad args: #{a.first.inspect}")
+        end
+        fail("extra args: #{a.inspect}") if a.any?
+      end
+      def notice_stream mixed
+        @notice_stream = mixed
+      end
+      def parse cmd, opts
+        these = @exclusive_flag_keys & opts.keys
+        if these.empty? && @default_key
+          if @notice_stream
+            msg =
+            ["using default: "+unnormalize_opt_key(@default_key),
+              @default_short ? "(#{@default_short})" : nil
+            ].compact.join(' ')
+            @notice_stream.puts msg
+          end
+          these.push(@default_key)
+        end
+        if these.size > 1
+          flags = unnormalize_opt_keys(@exclusive_flag_keys)
+          cmd.task_abort <<-ABORT.gsub(/^  */,'')
+            #{flags.join(' and ')} are mutually exclusive.
+            usage: #{cmd.usage}
+            #{cmd.invite_to_more_command_help}
+          ABORT
+        end
+        these.first
+      end
+    end
+    class OptEnum
+      include OptsNormalizer, StringFormatting
+      def initialize(&block)
+        instance_eval(&block)
+      end
+      def command cmd
+        @command = cmd
+      end
+      def default str
+        @default = str
+      end
+      def name name
+        @name = name
+      end
+      def parse opts
+        found = nil
+        if opts.key?(@name)
+          v = opts[@name]
+          re = /\A#{Regexp.escape(v)}/
+          founds = @values.grep(re)
+          case founds.size
+            when 0; invalid(v)
+            when 1; found = founds.first
+            else found = founds.detect{|f| f==v} or too_many(founds)
+          end
+        elsif(@default)
+          found = @default
+        else
+          found = nil
+        end
+        opts[@name] = found if found # normalize short versions
+        found
+      end
+      def values *v
+        v = v.first if v.size==1 && Array === v
+        @values = v
+      end
+    private
+      def coda
+        "usage: #{@command.usage}\n#{@command.invite_to_more_command_help}"
+      end
+      def invalid val
+        @command.task_abort("invalid value #{val.inspect} for "<<
+          "#{long_name}. #{valid_values_are}\n#{coda}")
+      end
+      def long_name
+        unnormalize_opt_key(@name)
+      end
+      def too_many these
+        @command.task_abort("did you mean " <<
+          oxford_comma(these,' or ', &quoted)<<" for #{long_name}?\n#{coda}")
+      end
+      def valid_values_are
+        "valid values are " << oxford_comma(@values,&quoted)
+      end
+    end
+  end
+  module PathHelper
+    def assert_path name, *paths
+      paths.each do |p|
+        unless File.exist?(p)
+          task_abort("#{name} does not exist: #{p}")
+        end
+      end
+    end
+  end
+  module StringFormatting
+    def basename_no_extension str
+      /([^\/\.]+)(?:\.[^\.\/]+)?\Z/ =~ str ? $1 : nil
+    end
+    def indent str, indent
+      str.gsub(/^/, indent)
+    end
+    def no_blank_lines str
+      str.gsub(/\n[[:space:]]*\n/, "\n")
+    end
+    def no_leading_ws str
+      str.sub(/\A[[:space:]]+/, '')
+    end
+    def no_trailing_ws str
+      str.sub(/[[:space:]]+\Z/, '')
+    end
+    def oxford_comma items, final = ' and ', &quoter
+      items = items.map(&quoter) if quoter
+      these = []
+      these.push final if items.size > 1
+      these.concat(Array.new(items.size-2,', ')) if items.size > 2
+      these.reverse!
+      items.zip(these).flatten.compact.join
+    end
+    def quoted
+      proc{|x| "\"#{x}\"" }
+    end
+
+    #
+    # must respond to tab() and tabs()
+    # reindent a block by striping leading whitespace from lines evenly
+    # and then re-indenting each line according to our indent.
+    # this could be simpler, it has been more complicated
+    # we do it languidly because we can
+    #
+    def reindent h1, offset=0
+      indent_by = tab * (tabs+offset)
+      unindent_by = (/\A([[:space:]]+)/ =~ h1 && $1) or
+        fail('regex fail -- not sure if we need this to be so strict')
+      h2 = no_blank_lines(h1) # careful. will mess up with <pre> etc
+      return h2 if unindent_by == indent_by
+      h3 = unindent(h2, unindent_by)
+      h4 = indent(h3, indent_by)
+      h4
+    end
+
+    def unindent str, by
+      str.gsub(/^#{Regexp.escape(by)}/, '')
+    end
+  end
+  module SecretParent
+    #
+    # 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
+  module SharedAttrReader
+    #
+    # 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
+  module TaskCommon
+    def task_abort msg
+      if msg.index("for more info") # not mr. right, mr. right now
+        tail = ''
+      else
+        last = msg[-1].chr
+        tail = ".?!".index(last) ? '  ' : ("\n"==last ? '' : '.  ')
+        tail << 'Aborting.'
+      end
+      $stderr.puts "nanDoc: #{msg}#{tail}"
+      exit 1
+    end
+  end
+  module CliCommandHelpers
+    include OptsNormalizer, TaskCommon, PathHelper
+  end
+  module PathHelper
+    include TaskCommon
+  end
+end

data/lib/nandoc/test/diff-to-string.rb

@@ -0,0 +1,251 @@
+require 'stringio'
+
+##
+# turn the output of Diff::LCS.diff into a string similar
+# to what would be retured by `diff`, optionally make it looks
+# *sorta* like colorized output from git-diff
+#
+# @todo move this to minitest branch
+# @todo this gives different results than diff for some stuff!!??
+#
+# poor man's diff:
+#   file_a, file_b = ARGV.shift(2)
+#   puts DiffToString.files_diff(file_a, file_b)
+#
+#
+class DiffToString
+  module Style
+    Codes = {:red=>'31', :green=>'32', :bold=>'1', :red_bg=>'41',
+      :magenta => '35'
+    }
+    def stylize str, *codes
+      if 1 == codes.size
+        if codes.first.nil?
+          return str
+        elsif codes.first.kind_of?(Array)
+          codes = codes.first
+        end
+      end
+      codes = codes.map{|c| Codes[c]}
+      "\033[#{codes * ';'}m#{str}\033[0m";
+    end
+  end
+  include Style
+
+  class << self
+    # these are just convenience wrappers for instance methods
+    %w(diff files_diff strings_diff gitlike!).each do |meth|
+      define_method(meth){|*a| new.send(meth,*a) }
+    end
+  end
+  def initialize
+    @add_style = nil
+    @add_header    = '%sa%s'
+    @change_header = '%sc%s'
+    @context       = nil
+    @del_header    = '%sd%s'
+    @del_style = nil
+    @last_range = nil
+    @left  = '<'
+    @line_no_style = nil
+    @right = '>'
+    @separator_line = '---'
+    @trailing_whitespace_style = nil
+  end
+  attr_accessor :arr1, :arr2 # this is awful bleeding
+  def context= mixed
+    fail("no #{mixed.inspect}") unless mixed.kind_of?(Fixnum) && mixed >= 0
+    @context = mixed == 0 ? nil : mixed
+  end
+  def gitlike!
+    common_header = '@@ -%s, +%s @@'
+    @add_header =  common_header
+    @add_style = [:bold, :green]
+    @change_header = common_header
+    @del_style = [:bold, :red]
+    @del_header = common_header
+    @header_style = [:bold, :magenta]
+    @left  = '-'
+    @right = '+'
+    @separator_line = nil
+    @trailing_whitespace_style = [:red_bg]
+    self
+  end
+  def arrays_diff arr1, arr2, opts={}
+    diff = Diff::LCS.diff(arr1, arr2)
+    @arr1, @arr2 = arr1, arr2
+    consume_opts_for_diff(opts)
+    diff_to_str diff, opts
+  end
+  def diff mixed1, mixed2, opts={}
+    case (x=[mixed1.class, mixed2.class])
+    when [Array,Array];   arrays_diff(mixed1,mixed2,opts)
+    when [String,String]; strings_diff(mixed1,mixed2,opts)
+    else "no diff strategy for #{x.inspect}"
+    end
+  end
+  def files_diff a, b, opts={:sep=>"\n"}
+    str1 = File.read(a)
+    str2 = File.read(b)
+    strings_diff(str1, str2, opts)
+  end
+  def strings_diff a, b, opts={}
+    opts = opts.merge(:sep=>"\n")
+    arr1 = str_to_arr a, opts[:sep]
+    arr2 = str_to_arr b, opts[:sep]
+    arrays_diff(arr1, arr2, opts)
+  end
+  def str_to_arr str, sep
+    str.split(sep, -1)
+  end
+  def diff_to_str diff, opts
+    consume_opts_for_diff opts
+    @out = StringIO.new
+    @offset_offset = -1
+    diff.each do |chunk|
+      context_pre(chunk) if @context
+      dels = []
+      adds = []
+      start_add = last_add = start_del = last_del = nil
+      chunk.each do |change|
+        case change.action
+        when '+'
+          start_add ||= change.position + 1
+          last_add = change.position + 1
+          adds.push change.element
+        when '-'
+          start_del ||= change.position + 1
+          last_del = change.position + 1
+          dels.push change.element
+        else
+          fail("no: #{change.action}")
+        end
+      end
+      if adds.any? && dels.any?
+        puts_change_header start_del, last_del, start_add, last_add
+      elsif adds.any?
+        puts_add_header start_add, last_add
+      else
+        puts_del_header start_del, last_del
+      end
+      @offset_offset -= ( dels.size - adds.size )
+      dels.each do |del|
+        puts_del "#{@left} #{del}"
+      end
+      if adds.any? && dels.any?
+        puts_sep
+      end
+      adds.each do |add|
+        puts_add "#{@right} #{add}"
+      end
+      context_post(chunk) if @context
+    end
+    @out.rewind
+    @out.read
+  end
+private
+  def consume_opts_for_diff opts
+    if opts[:colors]
+      opts.delete[:colors]
+      gitlike!
+    end
+    if opts[:context]
+      self.context = opts.delete(:context)
+    end
+  end
+  def context_pre chunk
+    pos = chunk.first.position - 1
+    puts_range_safe pos - @context, pos
+  end
+  def context_post chunk
+    pos = chunk.last.position + 1
+    puts_range_safe pos, pos + @context
+  end
+  def other_offset start
+    start + @offset_offset
+  end
+  def puts_del str
+    puts_change str, @del_style
+  end
+  def puts_add str
+    puts_change str, @add_style
+  end
+  def puts_add_header start_add, last_add
+    str = @add_header % [other_offset(start_add), range(start_add,last_add)]
+    @out.puts(stylize(str, @header_style))
+  end
+  def puts_change str, style
+    # separate string into three parts! main string,
+    # trailing non-newline whitespace, and trailing newlines
+    # we want to highlite the trailing whitespace, but if we are
+    # colorizing it we need to exclude the final trailing newlines
+    # for puts to work correctly
+    if /^(.*[^\s]|)([\t ]*)([\n]*)$/ =~ str
+      main_str, ws_str, nl_str = $1, $2, $3
+      @out.print(stylize(main_str, style))
+      @out.print(stylize(ws_str, @trailing_whitespace_style))
+      @out.puts(nl_str)
+    else
+      # hopefully regex never fails but it might
+      @out.puts(stylize(str, style))
+    end
+  end
+  def puts_change_header start_del, last_del, start_add, last_add
+    str = @change_header %
+      [range(start_del,last_del), range(start_add,last_add)]
+    @out.puts(stylize(str, @header_style))
+  end
+  def puts_del_header start_del, last_del
+    str =  @del_header % [range(start_del,last_del), other_offset(start_del)]
+    @out.puts(stylize(str, @header_style))
+  end
+  def puts_range_safe start, final
+    start = [start, 0].max
+    final = [@arr1.size-1, final].min
+    if @last_range
+      start = [@last_range[1]+1, start].max
+      # assume sequential for now! no need to check about previous
+      # ones in front of us
+    end
+    return if start >= final
+    @last_range = [start, final]
+    @out.puts @arr1[start..final].map{|x| "  #{x}"}
+    # @todo i don't know if i'm reading the chunks right
+  end
+  def puts_sep
+    if @separator_line
+      @out.puts(@separator_line)
+    end
+  end
+  def range min, max
+    if min == max
+      min
+    else
+      "#{min},#{max}"
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+class DiffToString::TestCase < Test::Unit::TestCase
+  def test_context
+    before = <<-B
+      alpha
+      beta
+      gamma
+      tau
+    B
+    after = <<-A
+      alpha
+      gamma
+      zeta
+      tau
+    A
+    puts DiffToString.diff(before.split("\n"), after.split("\n"),
+      :colors=>true, :context=>3)
+  end
+end
+Test::Unit::UI::Console::TestRunner.run(DiffToString::TestCase)
+end

data/lib/nandoc/test/minitest-extlib.rb

@@ -0,0 +1,53 @@
+require 'diff/lcs'
+require(File.dirname(__FILE__)+'/diff-to-string.rb')
+
+module MiniTest
+  module Assertions
+
+    ##
+    # Fails unless <tt>exp == act</tt>.
+    # On failure use diff to show the diff, if +exp+
+    # and +act+ are of the same class and
+    #
+
+    def assert_no_diff exp, act, msg=nil, opts={}
+      if opts.kind_of?(String)
+        opts = {:sep=>opts}
+      end
+      opts = {:sep=>"\n"}.merge(opts)
+      msg = message(msg) do
+        exp_kind, act_kind = [exp,act].map do |x|
+          [String, Array].detect{|c| x.kind_of?(c)}
+        end
+        if exp_kind != act_kind
+          "Expecting #{exp_kind.inspect} had #{act_kind.inspect}"
+        elsif exp_kind.nil?
+          "Will only do diff for strings and arrays, not #{exp.class}"
+        else
+          differ = DiffToString.gitlike!
+          if exp_kind == String
+            use_exp = exp.split(opts[:sep], -1)
+            use_act = act.split(opts[:sep], -1)
+          else
+            use_exp = exp
+            use_act = act
+          end
+          diff = Diff::LCS.diff(use_exp, use_act)
+          if diff.empty?
+            fail("test test fail -- never expecting empty diff here")
+          else
+            differ.arr1 = use_exp
+            differ.arr2 = use_act # awful
+            differ.diff_to_str(diff, :context=>3)
+          end
+        end
+      end
+      if re = opts[:ignoring]
+        exp, act = [exp, act].map do |str|
+          str.kind_of?(String) ? str.gsub(re, re.source) : str
+        end
+      end
+      assert(exp == act, msg)
+    end
+  end
+end

data/lib/nandoc/treebis/NOGIT-DOCS/NEWS.md

@@ -0,0 +1,5 @@
+# treebis news
+
+## 0.0.0 (2010-99-99)
+
+* born but not a birther

data/lib/nandoc/treebis/NOGIT-README.md

@@ -0,0 +1,65 @@
+## treebis
+
+### in short,
+Treebis is a minimal (small) task utility written in ruby designed expressly for wrapping common actions for moving, copying and altering filetrees.  It's geared towards things like generators.  Its look is comparable to a Rake task.  Its effect is comparable to a shell script composed of mkdir, mv, cp commands etc.
+
+This document is overkill.  Treebis is underkill.
+
+### it is:
+  - task wrapper for external commands that make filetrees, e.g.
+    - maybe the generators in things like rails, ramaze, nandoc
+  - copies filetrees to filetrees
+  - removes filetrees from filetrees
+  - applies diffs to filetrees
+  - different ways to represent trees and diffs - heredocs, diffs, filesystem.
+  - under 500 lines of code (?) (~300 SLOC ATTOTW)
+  - near 100% test coverage (?)
+
+### it is not:
+  - a vcs or vcs wrapper (version control system)
+  - atomic
+  - a replacement for the heavy hitters used by web frameworks
+  - Safe.  Little sanity checking and error checking is done.  At present it
+    it is mostly a wrapper around FileUtils and patch.  If you refer to files
+    that aren't there or try to read/move/remove files you don't have the
+    permissions to do so with, you will see the errors as you would from
+    FileUtils.
+
+### faq
+
+#### Q: why use it?
+
+#### A:
+<p class='ans'>Because you want a consistent way to wrap these common tasks that doesn't explicitly rely on shelling out to the underlying system, or other hodgepodges.  (also see 'why did you make this?')
+</p>
+
+#### Q: why not use it?
+
+#### A:
+Because it doesn't do what you want or it does what you do not want.
+
+#### Q: why is it named "Treebis?"
+
+#### A:
+because it rhymes with "Jeebus."
+
+#### Q: why did you make this?
+
+#### A:
+by the third or fourth time i found myself re-writing this same kind of thing for different projects (or bleeding from its absence), i decided to abstract it.  It's more readable than a bunch of FileUtils statements, it's more portable than a bunch of bash scripts (sorta), it's divorced from any heavy (or light) web frameworks, and it paves the way for possible future enhancements like atomicitiy and units of work; and wouldn't it be nice if every generator of every project used the same library?
+
+### requirements
+  - ruby 1.8.7
+  - GNU patch 2.5.8 (if the diff-patching functionality is to be used)
+      (most versions of patch will likely work; it uses unified diffs.)
+
+### installation
+  @todo
+
+### usage
+  @todo
+
+### future unfulfilled promises made today:
+  - dry run
+  - erb
+  - two-pass units of work !!??

data/lib/nandoc/treebis/nandoc.persistent.json

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

data/lib/nandoc.rb

@@ -0,0 +1,48 @@
+# this kind of sucks but for a wicked hack to work with symlinks
+# we have to wrap this sucker.
+
+unless Object.const_defined?('NanDoc')
+
+require 'nanoc3'
+require 'nanoc3/cli'
+
+module NanDoc
+  #
+  # i make the D big so i can see it
+  # i move my head away from the microphone when i breathe
+  #
+  Root = File.expand_path('../..',__FILE__)
+end
+
+me = File.dirname(__FILE__)+'/nandoc'
+
+# order is important:
+require me + '/support-modules.rb'
+require 'treebis' # gem
+require me + '/config.rb'
+
+module NanDoc
+  Treebis::PersistentDotfile.extend_to(self,
+    './nandoc.persistent.json',
+    :file_utils => Config.file_utils
+  )
+end
+
+# order is not important: (alphabetical:)
+require me + '/commands/create-nandoc-site.rb'
+require me + '/commands/diff.rb'
+require me + '/cri-hacks.rb'
+require me + '/data-source.rb'
+require me + '/filters.rb'
+require me + '/helpers.rb'
+require me + '/item-class-hacks.rb'
+
+Nanoc3::DataSource.register ::NanDoc::DataSource, :nandoc
+Nanoc3::Filter.register ::NanDoc::Filters::General, :nandoc
+
+shared_base = Nanoc3::CLI::Base.shared_base
+shared_base.remove_command Nanoc3::CLI::Commands::CreateSite
+shared_base.add_command    NanDoc::CreateNanDocSite.new
+shared_base.add_command    NanDoc::Commands::Diff.new
+
+end