nandoc 0.0.1

data/lib/nandoc/commands/diff.rb

@@ -0,0 +1,279 @@
+support =  File.expand_path('../../support', __FILE__)
+require support + '/diff-proxy.rb'
+require support + '/path-tardo.rb'
+require support + '/site-methods.rb'
+
+module NanDoc::Commands
+  class Diff < ::Cri::Command
+    NanDoc.persistent_delegate_to(self) # persistent_set(), persistent_get()
+    include NanDoc::CliCommandHelpers, NanDoc::PathTardo, NanDoc::SiteMethods
+
+    def name; 'diff' end
+
+    def aliases; [ 'd' ] end
+
+    def short_desc; 'maybe push and pull some stuff (nanDoc hack)' end
+
+    def long_desc
+      <<-LONG_DESC.gsub(/\n +/,' ')
+      Patch a subtree of <my-site>/content with the same subtree in
+      <my-site>/output with (--content-to-output|-c). (default). Opposite
+      direction with -C.
+
+      Patch a subtree of <prototypes>/<the-prototype> with the same
+      subtree of <my-site>/content with (--content-to-prototype|-p).
+      (For patching nanDoc prototypes.) Opposite direction with -P.
+
+      This operates on a subset of the indicated trees, for now either
+      the css folders in <my-site>/output/ and <my-site>/content/ or the
+      layout folders between the prototype and the <my-site>.  Indicate
+      which with -s (css|layouts) (default: css)
+
+      So, with this wierd chain, you can tweak your CSS, for example,
+      in the generated output and then push these changes all the way back to
+      the prototype with -cY and then -pY
+
+      Or you can undo your changes pulling all the way back from the prototype
+      with -PY and then -CY
+      LONG_DESC
+    end
+
+    def usage;
+    'nandoc diff [-c|-C|-p|-P] [-s (css|layouts|js|root)] [-Y [-b]] [<path>]'
+    end
+
+    def option_definitions
+      pttp = 'pass-thru to patch. only for use with -Y'
+      [ { :long => 'backup', :short => 'b', :argument=>:none,
+          :desc => pttp
+        },
+        { :long => 'content-to-output', :short => 'c', :argument => :none,
+          :desc => 'show diff or patch content with output (default)'
+        },
+        { :long => 'content-to-proto', :short => 'P', :argument => :none,
+          :desc => 'show diff or patch content with proto (sure why not)'
+        },
+        { :long => 'dry-run',  :short => 'r', :argument => :none,
+          :desc => pttp
+        },
+        { :long => 'output-to-content', :short => 'C', :argument => :none,
+          :desc => 'show diff or patch output with content (kind of weird)'
+        },
+        { :long => 'patch', :short => 'Y', :argument => :none,
+          :desc => 'apply the patch to the target (no undo!)'
+        },
+        { :long => 'proto-to-content', :short => 'p', :argument => :none,
+          :desc => ("show diff or patch prototype with content\n"<<
+                    (' '*22)+"(this would be for patching/altering nandoc)")
+        },
+        { :long => 'subset', :short => 's', :argument => :required,
+          :desc => "'css' or 'layouts' or 'js' (default: css)"
+        }
+      ]
+    end
+
+    def run opts, args
+      opts = normalize_opts opts
+      site_path = deduce_site_path_or_fail(args)
+      src, dest = deduce_src_and_dest site_path, opts
+      subset = subsets.parse(opts)
+      if opts[:patch] # @todo this doesn't belong here probably
+        patch_opts = process_patch_opts(opts, src, dest, site_path)
+        go_patch src, dest, subset, site_path, patch_opts
+      else
+        process_diff_opts(opts) and fail("no more opts for this guy")
+        go_diff src, dest, subset, site_path
+      end
+    end
+
+  private
+
+    def deduce_root_paths src, dest, site_path
+      @diff_method = :diff_root_subset
+      path_src = deduce_subfolder_path site_path, src
+      path_dst = deduce_subfolder_path site_path, dest
+      if path_src == path_dst
+        task_abort("source and destination paths are the same. "<<
+        "did you forget -p or -P ?\nusage: #{usage}\n"<<
+        invite_to_more_command_help)
+      end
+      [path_src, path_dst]
+    end
+
+    def deduce_subfolder_path site_path, which, sub=nil
+      tox =
+      case which
+        when :output;  [site_path, sub ? 'output' : nil, sub]
+        when :content; [site_path, sub ? 'content': nil, sub]
+        when :proto;   [proto_path(site_path), sub ? 'content' : nil, sub]
+        else fail(
+          "implement me: get #{which.to_s} subpath")
+      end
+      File.join(tox.compact)
+    end
+
+    def deduce_subfolder_paths sub, src, dest, site_path
+      paths = [src, dest].map do |which|
+        deduce_subfolder_path site_path, which, sub
+      end
+      paths
+    end
+
+    def deduce_layout_paths src, dest, site_path
+      if [src, dest].index(:output)
+        task_abort "Sorry, it doesn't make sense to look at layout " <<
+        "in output directory because there is none.\n" <<
+        "Please use -P or -p to compare layout btwn proto and <my-site>.\n"<<
+        "usage: #{usage}\n#{invite_to_more_command_help}"
+      end
+      paths = [src, dest].map do |which|
+        case which
+          when :content; site_path + '/layouts'
+          when :proto;   proto_path(site_path)+'/layouts'
+          else fail(
+            "implement me: get #{which.to_s} path from #{src.inspect}")
+        end
+      end
+      paths
+    end
+
+    def deduce_paths src, dest, subset, site_path
+      paths = case subset
+        when 'css';     deduce_subfolder_paths 'css', src, dest, site_path
+        when 'layouts'; deduce_layout_paths src, dest, site_path
+        when 'js';      deduce_subfolder_paths 'js', src, dest, site_path
+        when 'root';    deduce_root_paths src, dest, site_path
+        else; fail("unimplemented subset: #{subset}")
+      end
+      src_path, dest_path = paths
+      assert_path "source path",      src_path
+      assert_path "destination path", dest_path
+      [src_path, dest_path]
+    end
+
+    def deduce_src_and_dest site_path, opts
+      flag = exclusive_opt_flags(opts) do
+        flags :content_to_output, :content_to_proto,
+              :output_to_content, :proto_to_content
+        default '-c', :content_to_output
+      end
+      /\A(.+)_to_(.+)\Z/ =~ flag.to_s or fail("no: #{flag}")
+      src, dest = $1.to_sym, $2.to_sym
+      [src, dest]
+    end
+
+    def diff_normal src_path, dest_path
+      NanDoc::DiffProxy.diff(src_path, dest_path)
+    end
+
+    def diff_root_subset src, dest
+      require File.expand_path('../../support/site-diff.rb', __FILE__)
+      thing = NanDoc::SiteDiff.new(src, dest)
+      thing.get_diff_object
+    end
+
+    def get_diff_object(*a)
+      @diff_method = :diff_normal
+      src_path, dest_path = deduce_paths(*a)
+      diff = case @diff_method # no send() b/c trace stacks look dumb
+        when :diff_normal;      diff_normal(src_path, dest_path)
+        when :diff_root_subset; diff_root_subset(src_path, dest_path)
+      end
+      if diff.error?
+        task_abort diff.error
+      end
+      diff
+    end
+
+    def go_diff(*a)
+      diff = get_diff_object(*a)
+      $stderr.puts diff.command
+      if $stdout.tty? && NanDoc::Config.colorize?
+        diff.colorize($stdout, :styles => NanDoc::Config.diff_stylesheet)
+      else
+        $stdout.puts diff.to_s
+      end
+    end
+
+    def go_patch *a
+      patch_opts = a.pop
+      pass_thru = patch_opts[:pass_thru] or fail('suxxorz')
+      diff = get_diff_object(*a)
+
+      # Make a tempdir and write the diff to a file
+      tmpdir = empty_tmpdir('for-a-patch')
+      Treebis::Task.new do
+        notice 'command', diff.command
+        write 'diff', diff.to_s
+      end.on(tmpdir).run
+
+      # Patch this sucker and pray we didn't mess up too badly
+      Treebis::Task.new do
+        from tmpdir
+        apply 'diff', pass_thru
+      end.on('.').run
+    end
+
+    def subsets
+      cmd = self
+      @subsets ||= OptEnum.new do |oe|
+        command cmd
+        name :subset
+        values %w(css layouts js root)
+        default 'css'
+      end
+    end
+
+    def proto_path site_path
+      config = parse_config_for_site_path site_path
+      result = path_tardo(config, 'data_sources/[0]/site_prototype')
+      if result.found?
+        thing_in_config = result.value
+        full_path = "proto/#{thing_in_config}"
+        full_path
+      else
+        task_abort(
+          result.error_message + " in " + config_path_for_site_path(site_path)
+        )
+      end
+    end
+
+    PatchPassThru = [:backup, :dry_run, :directory]
+    def process_diff_opts opts
+      if (bad = opts.keys & PatchPassThru).any?
+        bads = bad.map{|x| unnormalize_opt_key(x)}.join('and')
+        task_abort "#{bads} cannot be used with diffing only patching.\n"<<
+          "usage: #{usage}\n#{invite_to_more_command_help}"
+      end
+    end
+
+    def process_patch_opts opts, src, dest, site_path
+      keys = opts.keys & PatchPassThru
+      switches = keys.map{|k| unnormalize_opt_key(k)}
+      switch_h = Hash[switches.zip(Array.new(switches.size, ''))]
+      switch_h['--posix'] = '' # always on else patches don't work
+      process_patch_opts_for_directory switch_h, opts, src, dest, site_path
+      {:pass_thru => switch_h }
+    end
+
+    #
+    # when applying a root-based patch to a prototype we will have to change
+    # directory to that prototype, just for when we apply the patch. and..?
+    #
+    def process_patch_opts_for_directory switch_h, opts, src, dest, site_path
+      return unless opts[:subset] == 'root'
+      if ! opts[:proto_to_content]
+        task_abort("we need to test this for root patching for this target")
+      end
+      # it's not explicitly an available pass-thru option
+      fail("huh?") if switch_h['--directory'] ||
+        switch_h.keys.grep(/^-p\d+$/).any?
+      proto = proto_path(site_path)
+      # for a path like './a/Rules', we cd to the root of the proto, so we
+      # want to disregard two levels of path context.
+      switch_h['-p2'] = ''
+      switch_h['--directory'] = proto
+      nil
+    end
+  end
+end

data/lib/nandoc/config.rb

@@ -0,0 +1,58 @@
+module NanDoc
+  module Config
+    extend self
+
+    #
+    # this name etc etc
+    #
+
+    @orphan_surrogate_filename = Root + '/proto/misc/orphan-surrogate.md'
+    attr_accessor :orphan_surrogate_filename
+
+
+    #
+    # in the future make this smarter.  i don't like now nanoc handles color
+    # (a command line argument?) There should be an autodetect, and/or set
+    # last setting in sticky json file; or however it is it is done. @todo
+    #
+    def colorize?
+      true
+    end
+
+    #
+    # everybody wants to look like git
+    #
+    def diff_stylesheet
+      @diff_stylesheet ||= {
+        :header => [:bold, :yellow],
+        :add    => [:bold, :green],
+        :remove => [:bold, :red],
+        :range  => [:bold, :magenta]
+      }
+    end
+
+    #
+    # some FileUtils actions are wrapped with this proxy to allow
+    # formatting and customizations from the typical FileUtils actions,
+    # to indent and colorize the notice stream sorta like nanoc does
+    #
+
+    def file_utils
+      @file_utils ||= begin
+        Treebis::FileUtilsProxy.new do |fu|
+          fu.pretty!
+          fu.color?{ NanDoc::Config.colorize? }
+          fu.prefix = ' ' * 6 # like nanoc
+          fu.ui = proc{ $stdout }
+          # it's normally $stderr, it needs to be reference-like
+          # so that capture3 will work!
+        end
+      end
+    end
+    module Accessors
+      def file_utils
+        NanDoc::Config.file_utils
+      end
+    end
+  end
+end

data/lib/nandoc/cri-hacks.rb

@@ -0,0 +1,13 @@
+module Cri
+  class Base
+    # hack
+    include NanDoc::TaskCommon
+    def remove_command command_class
+      if idx = @commands.index{|x| x.kind_of?(command_class) }
+        @commands.delete_at(idx)
+      else
+        task_abort("command not found of class #{command_class}")
+      end
+    end
+  end
+end

data/lib/nandoc/data-source.rb

@@ -0,0 +1,239 @@
+module NanDoc
+
+  class DataSource < ::Nanoc3::DataSources::FilesystemUnified
+    #
+    # Make a Nanoc3 DataSource class as necessary to A) pull in
+    # content files that exist outside of the <my-site>/content directory and
+    # B) allow one of those files to act as the root index page for the
+    # generated site, as indicated by config.yaml. and C) rescue orphan
+    # files that have a parent directory but no parent file, and
+    # D) to see as text files without an extension (e.g. README)
+    #
+    # Some of the hacks in this file are the worst in the whole project. @todo
+    #
+
+
+    include NanDoc::TaskCommon # task_abort()
+
+    def initialize *a
+      super(*a)
+
+      # hack to see as text files without an extension!
+      unless @site.config[:text_extensions].include?(nil)
+        @site.config[:text_extensions].unshift(nil)
+      end
+      @hax_filename_for_last = nil
+      @config = a.last
+      @basenames = @config[:source_file_basenames] or
+        fail("must have source_file_basenames in config.yaml  "<<
+          "for nandoc to work."
+        )
+      @hax_mode = false # this gets turned on when we are doing s/thing weird
+      @hax_root_found = false
+    end
+
+    #
+    # the content filename for ../README is ../README
+    #
+    def filename_for(base_filename, ext)
+      return super unless @hax_mode && ext.nil?
+      if @hax_filename_for_last != base_filename
+        @hax_filename_for_last = base_filename
+        return super
+      else
+        base_filename
+      end
+    end
+
+
+    #
+    # Hack the items returned by this datasource object to include also
+    # files outside of the <my-site>/content directory, e.g. README.md
+    # or README/**/*, NEWS.md, based on settings in the config.
+    #
+    # Rescue orphan nodes with no parent page somehow.
+    #
+    def items
+      _ = Nanoc3::Item # autoload it now for easier step debug-ging
+      these = super
+      dot_dot_names = @basenames.map{|x| "../#{x}"}
+      @hax_mode = true
+      additional = dot_dot_names.map do |basename|
+        if File.file?(basename) # was different
+          load_objects(basename, 'item', Nanoc3::Item)
+        else
+          load_objects(basename, 'item', Nanoc3::Item)
+        end
+      end.compact.flatten(1)
+      @hax_mode = false
+      error_for_no_files(dot_dot_names) if additional.empty?
+      res = these + additional
+      orphan_rescue(res)
+      res
+    end
+
+  private
+
+    #
+    # a hook to grab the folder name that later gets stripped out
+    # also a supremely ugly hack to get e.g. ../README.md
+    #
+    def all_split_files_in dir_name
+      return super unless @hax_mode
+      @hax_last_dirname = dir_name
+      ret = super
+      lone_files = ["#{dir_name}.md", dir_name]
+      lone_file = find_first_file(lone_files)
+      if lone_file  # e.g. '../README.md', 'README'
+        @hax_last_filename = lone_file.dup
+        class << lone_file
+          #
+          # supremely fragile hack:
+          # make it so that it ignores the next + operation in the first
+          # line of Nanoc3::DataSources::Filesystem#all_split_files_in()
+          # this is shorter and easier than overriding and rewring
+          # the above function but it is a supreme haxie guaranteed to fail
+          # one day!!!
+          #
+          def + _; self end
+        end
+        other = super(lone_file)
+        ret.merge!(other)
+      end
+      ret
+    end
+
+    # removed old deal_with_index_page_children in e7bf7ee
+
+    #
+    # We crap out if we didn't find any weird files because after all
+    # this is NanDoc.
+    #
+    def error_for_no_files files
+      task_abort <<-HERE.gsub(/\n +/,"\n").strip
+      No matching content file(s) found at or under (#{files.join(', ')})
+      from here. (This corresponds to the 'source_file_basenames' setting in
+      config.yaml.)  Did you generate the NanDoc site in the right directory?
+      HERE
+    end
+
+    def find_first_file names
+      names.detect{ |n| File.file?(n) }
+    end
+
+    #
+    # We don't seem to want any urls with uppercase characters in them
+    # because .. not sure.  But the rsync by default downcases our files.
+    # It's probably a good habbit to do this.  If we want to accept a variety
+    # of casing with our server that's ok but internally we should keep it consistent
+    # and simple.  (This causes gotchas sometimes when moving from a case-insensitive
+    # filesystem like that of OSX to a case-sensitive one like that of debian.)
+    # The titles of items, on the other hand ...
+    #
+    def identifier_normalize identifier
+      if /[A-Z]/ =~ identifier
+        use_identifier = identifier.downcase
+      else
+        use_identifier = identifier
+      end
+      use_identifier
+    end
+
+    #
+    # more crazy hacks - normally content/foo/bar.html => "/foo/bar/" but
+    # for this case we don't want to have stripped the containing folder,
+    # *and* we try to hack it so that it's laid alongside content in
+    # the content folder for the final site. (or not, here)
+    # also we need to make sure one item is '/' somehow
+    # @todo unhack this whole page
+    #
+    # @todo some stuff that happens in the orphanage should happen here
+    # instead
+    #
+    def identifier_for_filename fn
+      return super unless @hax_mode
+      if 'md' == fn # there has to be a better way :(
+        no_dot_dot = dot_dot_strip_assert(@hax_last_filename)
+        if no_dot_dot == @config[:use_as_main_index] # 'README.md'
+          identifier = '/' # overwrite the index.html generated by nandoc!
+        else
+          # '../README.md' => 'README.md' => '/README/'
+          identifier = super(no_dot_dot)
+        end
+      else
+        if fn
+          if dot_dot_has?(fn)
+            fail("fix this -- should never have dot dot name here: #{hn}")
+          end
+          identifier = super(fn)
+        else
+          identifier = dot_dot_strip_assert(@hax_last_dirname)+'/'
+        end
+      end
+      # before we get to resuce orphans we need to make sure we have
+      # resolved some file as a site root.  First one wins.
+      if ! @hax_root_found
+        shorter = slash_strip_assert(identifier)
+        if @basenames.include?(shorter)
+          @hax_root_found = true
+          identifier = '/'
+        end
+      end
+      use_identifier = identifier_normalize(identifier)
+      use_identifier
+    end
+
+    #
+    # A) Experimentally generate index pages for child nodes without them
+    # B) merge many filesystem roots to one docroot (hack!) per 'basenames'
+    # (undefined on name collision)
+    #
+    def orphan_rescue items
+      require File.expand_path('../support/orphanage.rb', __FILE__)
+      Orphanage.rescue_orphans(@config, items)
+    end
+
+  private
+
+    module ItemMethods
+      # must have @items.  make public if u need it
+
+      def find_parent item_identifier
+        parent_path = parent_identifier(item_identifier)
+        parent = @items.find { |p| p.identifier == parent_path }
+        parent
+      end
+      def identifier_bare_rootname identifier
+        /\A\/([^\/]+)\// =~ identifier and $1
+      end
+      def identifier_bare_rootname_assert identifier
+        identifier_bare_rootname(identifier) or
+          fail("hack fail: couldn't find rootname for #{identifier.inspect}")
+      end
+      # exactly one leading and one trailing slash
+      def slash_strip identifier
+        /\A\/(.+)\/\Z/ =~ identifier and $1
+      end
+      def slash_strip_assert identifier
+        slash_strip(identifier) or fail("hack fail: #{identifier}")
+      end
+      def parent_identifier identifier
+        identifier.sub(/[^\/]+\/$/, '')
+      end
+      def site_root
+        @site_root ||= @items.find{|x| x.identifier == '/' }
+      end
+      def dot_dot_has? str
+        /\A\.\./ =~ str
+      end
+      def dot_dot_strip str
+        /\A\.\.(.*)\Z/ =~ str and $1
+      end
+      def dot_dot_strip_assert str
+        dot_dot_strip(str) or
+          fail("hack fail: no leading dot dot: #{str.inspect}")
+      end
+    end
+    include ItemMethods
+  end
+end