nandoc 0.0.1

data/lib/nandoc/support/path-tardo.rb

@@ -0,0 +1,85 @@
+module NanDoc
+  module PathTardo
+    #
+    # This is like a really basic xpath for data structures
+    # that are composed of arrays and hashes
+    #
+    def tardo_array_index str
+      /\A\[(-?\d+)\]\Z/ =~ str ? $1.to_i : nil
+    end
+    module_function :tardo_array_index
+
+    def hash_to_paths hash, prefix=nil
+      paths = []
+      hash.each do |k,v|
+        ch_prefix = [prefix, k].compact.join('/')
+        if v.kind_of?(Hash)
+          paths.concat hash_to_paths(v, ch_prefix)
+        else
+          paths.push ch_prefix
+        end
+      end
+      paths
+    end
+
+    def path_tardo hash_or_array, path_tardo, prefix = ''
+      /\A([^\/]+)(?:\/(.+))?\Z/ =~ path_tardo or
+        fail("no parse: #{path_tardo}")
+      head, tail = $1, $2
+      value = nil
+      found = nil
+      if idx = tardo_array_index(head)
+        if idx > 0 && idx >= hash_or_array.size
+          found = false
+        elsif idx < 0 && (idx*-1) > hash_or_array.size
+          found = false
+        else
+          found = true
+          value = hash_or_array.slice(idx)
+        end
+      else
+        if hash_or_array.key?(head)
+          found = true
+          value = hash_or_array[head]
+        else
+          found = false
+        end
+      end
+      if ! found
+        Tardo::NotFound.new(prefix, head, hash_or_array)
+      elsif tail
+        local_full_path =
+          [ prefix.empty? ? nil : prefix, head ].compact.join('/')
+        path_tardo(value, tail, local_full_path)
+      else
+        Tardo::Found.new(value)
+      end
+    end
+    module Tardo
+      class NotFound < Struct.new(:prefix, :head, :hash_or_array)
+        def found?; false end
+        def error_message
+          sub_msg =
+          if idx = PathTardo.tardo_array_index(head)
+            "#{idx} is a nonexistant offset"
+          else
+            "a \"#{head}\" key does not exist"
+          end
+          context_msg =
+          if prefix.empty?
+            nil
+          elsif hash_or_array.kind_of?(Array)
+            "in \"#{prefix}\" array,"
+          else
+            "in hash \"#{prefix}\","
+          end
+          msg = [context_msg, sub_msg].compact.join(' ')
+          msg
+        end
+      end
+      class Found < Struct.new(:value)
+        def found?; true end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module NanDoc
+  module RegexpEnhance
+    #
+    # Just gives pre-1.9 regexes the ability to have named captures
+    #
+    # Usage:
+    #
+    #   re = /(foo*)bar(baz*)/
+    #   RegexpEnhance.names(re, :the_foo, :the_baz)
+    #   md = re.match("fooobarbazzzz")
+    #   md[:the_foo] # => 'fooo'
+    #
+    class << self
+      def names re, *list
+        to(re) do |re|
+          re.names(*list)
+        end
+        nil
+      end
+      def to re, &block
+        re.extend(self)
+        re.regexp_enhance_init
+        block.call(re)
+        nil
+      end
+    end
+    def regexp_enhance_init
+      @names ||= []
+      class << self
+        alias_method :orig_match, :match
+        def match str
+          md = super
+          MatchData.to(md, self) if md
+          md
+        end
+      end
+    end
+    def names *list
+      if list.any?
+        @names = list
+      else
+        @names
+      end
+    end
+    module MatchData
+      class << self
+        def to(md, re)
+          md.extend self
+          md.match_data_enhanced_init(re)
+          nil
+        end
+      end
+      def match_data_enhanced_init re
+        @names = re.names
+        class << self # @todo see if this doesn't break by moving defs out
+          alias_method :fetch_orig, :[]
+          attr_reader :names
+          def [](mixed)
+            return fetch_orig(mixed) unless mixed.kind_of?(Symbol)
+            fail("no such named capture: #{mixed.inspect}") unless
+              @names.include?(mixed)
+            offset = @names.index(mixed) + 1
+            fetch_orig offset
+          end
+        end
+      end
+
+      #
+      # @return [Hash] of the named captures in the MatchData
+      #
+      def to_hash
+        Hash[ names.map{ |n| [n, self[n] ] } ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__)+'/diff-proxy.rb'
+
+module NanDoc
+  class SiteDiff
+    #
+    # This is a reworking of what's in site-merge (which doesn't really
+    # do anything useful attotw, if it still even works.)
+    # it's a wrapper around diff proxy that knows what folder(s) & file(s) we
+    # do and don't want to take into account when showing a sitewide diff.
+    # Specifically it's expected use is for comparing <my-site>/(* ~ output)
+    # with its protoype.
+    #
+
+    include NanDoc::Config::Accessors   # file_utils()
+    include NanDoc::PathTardo           # debug-ging e.g. hash_to_paths()
+    NanDoc.persistent_delegate_to(self) # empty_tmpdir()
+    include Treebis::DirAsHash          # dir_as_hash()
+    include Treebis::Capture3           # capture3()
+
+    def initialize src_path, dest_path
+      @skip_these = %w(
+        output
+        tmp
+        **/*.orig.rb
+        **/*.diff
+        treebis-task.rb
+      )
+      @src_path, @dst_path = src_path, dest_path
+    end
+
+    def get_diff_object
+      file_utils.notice('comparing these:',
+        "#{@src_path.inspect} -> #{@dst_path.inspect}"
+      )
+      src_hash = dir_as_hash(@src_path, :skip => @skip_these)
+      dst_hash = dir_as_hash(@dst_path, :skip => @skip_these)
+      dir = empty_tmpdir('site-diff')
+      src_path = dir + '/a'
+      dst_path = dir + '/b'
+      hash_to_dir src_hash, src_path, file_utils
+      hash_to_dir dst_hash, dst_path, file_utils
+      diff = NanDoc::DiffProxy.diff(src_path, dst_path, :relative_to=>dir)
+      diff
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__)+'/diff-proxy.rb'
+
+module NanDoc
+  class SiteMerge
+    include Treebis::DirAsHash
+    include Treebis::Capture3
+    NanDoc.persistent_delegate_to(self) # empty_tmpdir()
+
+    def initialize site_creator
+      @creator = site_creator
+    end
+    def site_merge opts, args
+      existing_site_path = args.first
+      task_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
+      out, err, diff = capture3 do
+        $stdout.puts(
+        "#------------------ (this is for the merge hack:) -----------------")
+        @tmpdir = empty_tmpdir('ridiculous')
+        existing_subset_path = temp_site_subset(existing_site_path)
+        generated_site_path  = temp_generated_site opts
+        order = [existing_subset_path, generated_site_path]
+        order.reverse! if opts[:merge_hack_reverse]
+        diff = DiffProxy.diff(order[0], order[1], :relative_to => @tmpdir)
+        # you could delete the tempdirs now. we will leave them there
+        diff
+      end
+      fail("hack failed: #{err.inspect}") unless err.empty?
+      $stderr.puts out # write out to err here
+      $stderr.puts diff.command
+      $stderr.puts <<-HERE.gsub(/^ +/,'')
+      #---------------- (above is stderr, below is stdout) ------------------
+      HERE
+      $stdout.puts diff.to_s
+      diff
+    end
+  private
+    def temp_site_subset path
+      subset_in_memory = dir_as_hash(path, :skip=>['output'])
+      @file_utils = NanDoc::Config.file_utils
+      subset_on_disk = @tmpdir+'/user-site'
+      hash_to_dir(subset_in_memory, subset_on_disk, @file_utils)
+      subset_on_disk
+    end
+    def temp_generated_site opts
+      put_it_here = @tmpdir+'/generated-site'
+      chops = opts.dup
+      chops.delete(:datasource)
+      @creator.run(chops, [put_it_here], :_merge=>false)
+      remove_output_directory(put_it_here)
+      put_it_here
+    end
+    def remove_output_directory put_it_here
+      dir = put_it_here + '/output'
+      fail("fail") unless File.directory?(dir)
+      fail("fail") unless Dir[dir+'/*'].empty?
+      @file_utils.remove_entry_secure(dir)
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module NanDoc
+  module SiteMethods
+
+    def deduce_site_path_or_fail args
+      if args.any?
+        deduce_site_path_from_args args
+      else
+        deduce_site_path_from_persistent_data
+      end
+    end
+
+  private
+
+    def config_path_for_site_path path
+      path + '/config.yaml'
+    end
+
+    def deduce_site_path_from_args args
+      if File.exist?(args.first)
+        path = args.first
+        unless path == persistent_get('last_site_path')
+          persistent_set('last_site_path', path)
+        end
+        path
+      else
+        task_abort <<-D.gsub(/^  */,'')
+          site path not found: #{args.first.inspect}
+          usage: #{usage}
+          #{invite_to_more_command_help}
+        D
+      end
+    end
+
+    def deduce_site_path_from_persistent_data
+      if path = persistent_get('last_site_path')
+        if File.exist?(path)
+          path
+        else
+          persistent_set('last_site_path',false)
+          task_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(
+        'no site path provided and no site path in persistent data file '<<
+        "(#{NanDoc.dotfile_path})\n"<<
+        <<-D.gsub(/^ */,'')
+        usage: #{usage}
+        #{invite_to_more_command_help}
+        D
+        )
+      end
+    end
+
+    #
+    # you just get the raw file data tree, it's not merged in with any
+    # DEFAULT_CONFIG stuff or anything
+    #
+    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
+        File.exist?(config_path)
+      YAML.load_file config_path
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+module NanDoc
+  class StreamColorizer
+    module RuleList; end
+    module SecretParent; end
+    include RuleList;
+    def dup
+      other = self.class.new
+      other.stylesheet = stylesheet.dup
+      other.rule_list = rule_list.dup
+      other.state_set = state_set.dup
+      other
+    end
+    def initialize(*a, &b)
+      rule_list_init
+      @stylesheet = {}
+      if a.any? || block_given?
+        merge(*a, &b)
+      end
+    end
+    attr_writer :rule_list
+    def filter string, out
+      found = rule_list.detect{ |x| x.match(string) }
+      use_state = found ? found.state : :plain
+      state = get_state_or_fail(use_state)
+      string = string.dup
+      while next_state_name = state.process(string, out)
+        state = get_state_or_fail(next_state_name)
+      end
+      nil
+    end
+    def merge(&block)
+      yield(self) if block_given?
+      self
+    end
+    def spawn(*a, &b)
+      other = dup
+      other.merge(*a, &b)
+      other
+    end
+    attr_writer :state_set
+    attr_accessor :stylesheet
+    def stylesheet_merge other
+      @stylesheet.merge!(other)
+    end
+
+  #
+  # api private classes:
+  #
+
+    module RuleList
+      def rule_list_init
+        @rule_list = []
+        @state_set = {}
+      end
+      def add_regex_rule re, opts
+        fail("no") unless opts[:state]
+        @rule_list.push RegexRule.make(re, opts[:state], {})
+      end
+      def add_regex_rule_neg re, opts
+        fail("no") unless opts[:state]
+        @rule_list.push RegexRule.make(re, opts[:state], {:neg=>true})
+      end
+      def define_state name, &block
+        state = State.new(self, name, &block)
+        fail("no") if @state_set.key?(state.name)
+        @state_set[state.name] = state
+      end
+      def get_state_or_fail name
+        state = @state_set[name]
+        state or fail("no such state: #{name.inspect}")
+        state
+      end
+      attr_reader :rule_list
+      def when(re_or_symbol, opts=nil, &block)
+        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)
+        else
+          fail("unrecongized signature: `#{self.class}#when("<<
+            "[#{re_or_symbol.class}],[#{opts.class}],[#{block.class}])")
+        end
+      end
+      def when_not re, opts
+        add_regex_rule_neg re, opts
+      end
+      attr_reader :state_set
+    end
+    class RegexRule
+      class << self
+        def make regex, state, opts
+          if opts[:neg]
+            RegexRuleNeg.new(regex, state)
+          else
+            RegexRule.new(regex, state)
+          end
+        end
+      end
+      def initialize regex, state
+        @regex = regex
+        @state = state or fail('no')
+      end
+      attr_reader :regex, :state
+      def match str
+        @regex =~ str
+      end
+    end
+    class RegexRuleNeg < RegexRule
+      def match str
+        ! super
+      end
+    end
+    class State
+      include RuleList, Treebis::Colorize, NanDoc::SecretParent
+      def initialize parent, name, &block
+        self.parent = parent
+        rule_list_init
+        fail('no') unless Symbol === name
+        @name = name
+        @style = nil
+        @trailing_whitespace_style = nil
+        block.call(self)
+      end
+      attr_accessor :name
+      def next_line str, alter=false
+        res = false
+        if str == ''
+          nil
+        elsif alter
+          if /\A([^\n]+)(?:\n?)(.*)\Z/m =~ str
+            res = $1
+            str.replace($2)
+          else
+            fail("fail: #{str.inspect}")
+          end
+        else
+          if /\A([^\n]+)/ =~ str
+            res = $1
+          else
+            fail("fail: #{str.inspect}")
+          end
+        end
+        res
+      end
+      def process string, out
+        ret = nil
+        while line = next_line(string)
+          if other = rule_list.detect{|x| x.match(string)}
+            next_state_name = other.state
+            ret = next_state_name
+            break
+          else
+            next_line(string, true) # alter string
+            use_line = nil
+            if @trailing_whitespace_style
+              /\A(|.*[^[:space:]])([[:space:]]*)\Z/ =~ line or fail('oops')
+              head, tail = $1, $2
+              colored_head = colorize(head, *colors)
+              use_line = colored_head.dup
+              unless tail.empty?
+                ws_style = parent.stylesheet[@trailing_whitespace_style] or
+                  style_not_found_failure('@trailing_whitespace_style')
+                colored_tail = colorize(tail, *ws_style)
+                use_line.concat colored_tail
+              end
+            else
+              use_line = colorize(line, *colors)
+            end
+            out.puts use_line
+          end
+        end
+        ret
+      end
+      def colors
+        @colors ||= begin
+          if style.nil?
+            []
+          else
+            parent.stylesheet[style] or style_not_found_failure
+          end
+        end
+      end
+      def style *a
+        case a.size
+        when 0; @style
+        when 1; @style = a.first
+        else fail('no')
+        end
+      end
+      def trailing_whitespace_style *a
+        case a.size
+        when 0; @trailing_whitespace_style
+        when 1; @trailing_whitespace_style = a.first
+        else fail('no')
+        end
+      end
+      def style_not_found_failure which = '@style'
+        value = instance_variable_get(which)
+        fail("#{which} not found: #{value.inspect}")
+      end
+    end
+  end
+end