giblish 0.8.2 → 1.0.0.rc2

data/lib/giblish/indexbuilders/dotdigraphadoc.rb

@@ -0,0 +1,174 @@
+require_relative "../utils"
+
+module Giblish
+  # Provides a graphviz-formatted digraph of the provided node<->id ref map.
+  #
+  # See https://graphviz.gitlab.io/doc/conv_info/lang.html for one definition of the
+  # language.
+  #
+  # A short example:
+  #
+  # [graphviz,target="docdeps",format="svg",svg-type="inline"]
+  # ....
+  # digraph document_deps {
+  #   bgcolor="#33333310"
+  #   node [shape=note,
+  #         fillcolor="#ebf26680",
+  #         style="filled,solid"
+  #       ]
+  #
+  # rankdir="LR"
+  #
+  #
+  # "D-3"[label="D-3\n Doc 3", URL="file3.html" ]
+  # "D-2"[label="D-2\n Doc 2", URL="my/file2.html" ]
+  # "D-1"[label="D-1\n Doc 1", URL="my/subdir/file1.html" ]
+  # "D-1" -> { "D-2" "D-3"}
+  # "D-2" -> { "D-1"}
+  # "D-3"
+  # }
+  # ....
+  class DotDigraphAdoc
+    # info_2_ids:: A {ConversionInfo => [doc id refs]} hash.
+    #
+    # The following properties are expected from the ConversionInfo:
+    # title:: String
+    # doc_id:: String
+    # dst_rel_path:: String - the relative path from a the repo top to a doc
+    #                in the dst tree
+    #
+    # target::
+    # format::
+    # opts:: additional options {"opt" => "value"}. Currently supported:
+    #
+    # cachedir:: the directory to use for storing files produced during diagram generation.
+    # svg-type:: how to embed svg images
+    #
+    def initialize(info_2_ids:, target: "gibgraph", format: "svg", opts: {"svg-type" => "inline"})
+      @info_2_ids = info_2_ids
+      @target = target
+      @format = format
+      @opts = opts
+
+      @noid_docs = {}
+      @next_id = 0
+    end
+
+    def source
+      <<~DOC_STR
+        #{graph_header}
+        #{generate_labels}
+        #{generate_deps}
+        #{graph_footer}
+      DOC_STR
+    end
+
+    private
+
+    def graph_header
+      opt_str = @opts.collect { |key, value| "#{key}=\"#{value}\"" }.join(",")
+      <<~DOC_STR
+        [graphviz,target="#{@target}",format="#{@format}",#{opt_str}]
+        ....
+        digraph document_deps {
+          bgcolor="#33333310"
+          labeljust=l
+          node [shape=note,
+                fillcolor="#ebf26680",
+                style="filled,solid"
+              ]
+
+        rankdir="LR"
+
+      DOC_STR
+    end
+
+    def graph_footer
+      <<~DOC_STR
+        }
+        ....
+      DOC_STR
+    end
+
+    def make_dot_entry(doc_dict, conv_info)
+      title = if conv_info&.title.nil?
+        ""
+      else
+        # remove html markup in the title for displaying in the tree
+        stripped_title = conv_info.title.gsub(/<.*?>/, "")
+        stripped_title.tr!('"', "'")
+        Giblish.break_line(stripped_title, 16).join("\n")
+      end
+
+      # title = conv_info&.title.nil? ? "" : Giblish.break_line(conv_info.title, 16).join("\n")
+      # create the label used to display the node in the graph
+      dot_entry = if conv_info.docid.nil?
+        doc_id = next_fake_id
+        @noid_docs[conv_info] = doc_id
+        "\"#{doc_id}\"[label=\"-\n#{title}\""
+      else
+        doc_id = conv_info.docid
+        "\"#{conv_info.docid}\"[label=\"#{conv_info.docid}\n#{title}\""
+      end
+
+      # add clickable links in the case of html output (this is not supported
+      # out-of-the-box for pdf).
+      rp = conv_info.dst_rel_path
+      dot_entry += case rp.extname
+                   when ".html"
+                     ", URL=\"#{rp}\" ]"
+                   else
+                     " ]"
+      end
+      doc_dict[doc_id] = dot_entry
+    end
+
+    # create an entry in the 'dot' description for each
+    # document, sort them according to descending doc id to
+    # get them displayed in the opposite order in the graph
+    def generate_labels
+      node_dict = {}
+      @info_2_ids.each_key do |conv_info|
+        next unless conv_info.converted
+
+        make_dot_entry node_dict, conv_info
+      end
+      # sort the nodes by reverse doc id
+      node_dict = node_dict.sort.reverse.to_h
+
+      # produce the string with all node entries
+      node_dict.map do |_k, v|
+        v
+      end.join("\n")
+    end
+
+    def generate_deps
+      dep_str = ""
+      @info_2_ids.each do |conv_info, targets|
+        # set either the real or the generated id as source
+        src_part = if conv_info.docid.nil?
+          "\"#{@noid_docs[conv_info]}\""
+        else
+          "\"#{conv_info.docid}\""
+        end
+
+        if targets.length.zero?
+          dep_str += "#{src_part}\n"
+          next
+        end
+
+        dep_str += "#{src_part} -> {" + targets.reduce("") do |acc, target|
+          acc + " \"#{target}\""
+        end
+        # replace last comma with newline
+        dep_str += "}\n"
+      end
+      dep_str
+    end
+
+    def next_fake_id
+      @next_id += 1
+      "_generated_id_#{@next_id.to_s.rjust(4, "0")}"
+    end
+  end
+end

data/lib/giblish/indexbuilders/standard_index.erb

@@ -0,0 +1,10 @@
+= Documents under '<%= @title %>'
+Generated at: <%= Time.now.strftime("%Y-%m-%d %H:%M") %>
+:icons: font
+
+<%= tree_summary %>
+
+== Document Details
+
+<%= document_details %>
+

data/lib/giblish/indexbuilders/subtree_indices.rb

@@ -0,0 +1,132 @@
+require "erb"
+require_relative "verbatimtree"
+require_relative "d3treegraph"
+
+module Giblish
+  class SubtreeIndexBase < SubtreeSrcItf
+    attr_reader :src_location
+
+    DEFAULT_INDEX_ERB = "/standard_index.erb"
+
+    def initialize(pathtree, output_basename)
+      @pathtree = pathtree
+      @output_basename = output_basename
+      @src_location = pathtree.pathname.dirname
+      @title = pathtree.segment
+    end
+
+    def adoc_source
+      erb_template = File.read(__dir__ + DEFAULT_INDEX_ERB)
+      ERB.new(erb_template, trim_mode: "<>").result(binding)
+    end
+
+    def tree_summary
+      VerbatimTree.new(@pathtree.sort_leaf_first!, {dir_index_base_name: @output_basename}).source
+      # str = "++++\n"
+      # str += D3TreeGraph.new(tree: @pathtree, options: {dir_index_base_name: @output_basename}).source
+      # str += "\n++++"
+      # str
+    end
+
+    def document_details
+      details_str = ""
+
+      @pathtree.traverse_preorder do |_level, node|
+        next unless node.leaf?
+
+        d = node.data
+        details_str << (d.converted ? document_detail(node) : document_detail_fail(d))
+      end
+      details_str
+    end
+
+    protected
+
+    def document_detail_fail(node_data)
+      <<~FAIL_INFO
+        === #{node_data.src_basename}
+
+        Source file::
+        #{node_data.src_node.segment}
+
+        Error detail::
+        #{node_data.error_msg}
+
+        ''''
+
+      FAIL_INFO
+    end
+
+    # Show some details about file content
+    def document_detail(node)
+      node_data = node.data
+      <<~DETAIL_SRC
+        [[#{Giblish.to_valid_id(node.pathname.to_s, "_", "_", true)}]]
+        === pass:[#{node_data.title.encode("utf-8")}]
+
+        #{"Doc id::\n_#{node_data.docid}_" unless node_data.docid.nil?}
+
+        #{"Purpose::\n#{node_data.purpose_str}" unless node_data.purpose_str.to_s.empty?}
+
+        #{if node_data.stderr.empty?
+            ""
+          else
+            "Conversion issues::\n"\
+            "#{node_data.stderr.gsub(/^/, " * ")}"
+          end
+        }
+
+        Source file::
+        #{node_data.src_node.segment}
+
+        '''
+
+      DETAIL_SRC
+    end
+  end
+
+  # Generates a directory index with history info for all files under the
+  # given subdir node.
+  class SubtreeIndexGit < SubtreeIndexBase
+    # The fixed heading of the table used to display file history
+    HISTORY_TABLE_HEADING = <<~HISTORY_HEADER
+      File history::
+  
+      [cols=\"2,3,8,3\",options=\"header\"]
+      |===
+      |Date |Author |Message |Sha1
+    HISTORY_HEADER
+
+    HISTORY_TABLE_FOOTING = <<~HIST_FOOTER
+      
+      |===\n\n
+    HIST_FOOTER
+
+    def subtitle(dst_node)
+      "from #{dst_node.data.branch}"
+    end
+
+    def document_detail_fail(node_data)
+      super(node_data) + generate_history_info(node_data)
+    end
+
+    def document_detail(node_data)
+      super(node_data) + generate_history_info(node_data)
+    end
+
+    def generate_history_info(node_data)
+      return "Could not find history information\n\n" unless node_data.respond_to?(:history)
+
+      # Generate table rows of history information
+      rows = node_data.history.collect do |h|
+        <<~HISTORY_ROW
+          |#{h.date.strftime("%Y-%m-%d")}
+          |#{h.author}
+          |#{h.message}  
+          |#{h.sha1[0..7]} ... 
+        HISTORY_ROW
+      end.join("\n\n")
+      HISTORY_TABLE_HEADING + rows + HISTORY_TABLE_FOOTING
+    end
+  end
+end

data/lib/giblish/indexbuilders/templates/circles.html.erb

@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<style>
+
+ html, body{
+   height: 100%;
+   margin: 0;
+   padding: 0;
+ }
+
+ .node {
+   cursor: pointer;
+ }
+
+ .node:hover {
+   stroke: #000;
+   stroke-width: 1.5px;
+ }
+
+ .node--leaf {
+   fill: white;
+ }
+
+ .label {
+   font: 11px "Helvetica Neue", Helvetica, Arial, sans-serif;
+   text-anchor: middle;
+   text-shadow: 0 1px 0 #fff, 1px 0 0 #fff, -1px 0 0 #fff, 0 -1px 0 #fff;
+ }
+
+ .label,
+ .node--root,
+ .node--leaf {
+   pointer-events: none;
+ }
+
+</style>
+<svg width="100%" height="100%"></svg>
+<script src="https://d3js.org/d3.v4.min.js"></script>
+<script>
+ // Copied from https://bl.ocks.org/mbostock/7607535
+ var width = window.innerWidth,
+     height = window.innerHeight;
+ var svg = d3.select("svg"),
+     margin = 20,
+     diameter = Math.min(width, height),
+     g = svg.append("g").attr("transform", "translate(" + diameter / 2 + "," + diameter / 2 + ")");
+
+ var color = d3.scaleLinear()
+               .domain([-1, 5])
+               .range(["hsl(152,80%,80%)", "hsl(228,30%,40%)"])
+               .interpolate(d3.interpolateHcl);
+
+ var pack = d3.pack()
+              .size([diameter - margin, diameter - margin])
+              .padding(2);
+
+ root = <%= tree.to_json %>;
+ root = d3.hierarchy(root)
+          .sum(function(d) { return d.children.length + 1; })
+          .sort(function(a, b) { return b.value - a.value; });
+
+ var focus = root,
+     nodes = pack(root).descendants(),
+     view;
+
+ var circle = g.selectAll("circle")
+               .data(nodes)
+               .enter().append("circle")
+               .attr("class", function(d) { return d.parent ? d.children ? "node" : "node node--leaf" : "node node--root"; })
+               .style("fill", function(d) { return d.children ? color(d.depth) : null; })
+               .on("click", function(d) { if (focus !== d) zoom(d), d3.event.stopPropagation(); });
+
+ var text = g.selectAll("text")
+             .data(nodes)
+             .enter().append("text")
+             .attr("class", "label")
+             .style("fill-opacity", function(d) { return d.parent === root ? 1 : 0; })
+             .style("display", function(d) { return d.parent === root ? "inline" : "none"; })
+             .text(function(d) { return d.data.name; });
+
+ var node = g.selectAll("circle,text");
+
+ svg
+   .style("background", color(-1))
+   .on("click", function() { zoom(root); });
+
+ zoomTo([root.x, root.y, root.r * 2 + margin]);
+
+ function zoom(d) {
+   var focus0 = focus; focus = d;
+
+   var transition = d3.transition()
+                      .duration(d3.event.altKey ? 7500 : 750)
+                      .tween("zoom", function(d) {
+                        var i = d3.interpolateZoom(view, [focus.x, focus.y, focus.r * 2 + margin]);
+                        return function(t) { zoomTo(i(t)); };
+                      });
+
+   transition.selectAll("text")
+             .filter(function(d) { return d.parent === focus || this.style.display === "inline"; })
+             .style("fill-opacity", function(d) { return d.parent === focus ? 1 : 0; })
+             .on("start", function(d) { if (d.parent === focus) this.style.display = "inline"; })
+             .on("end", function(d) { if (d.parent !== focus) this.style.display = "none"; });
+ }
+
+ function zoomTo(v) {
+   var k = diameter / v[2]; view = v;
+   node.attr("transform", function(d) { return "translate(" + (d.x - v[0]) * k + "," + (d.y - v[1]) * k + ")"; });
+   circle.attr("r", function(d) { return d.r * k; });
+ }
+</script>

data/lib/giblish/indexbuilders/templates/flame.html.erb

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html>
+  <head>
+
+    <meta charset="utf-8">
+    <link rel="stylesheet" type="text/css" href="https://cdn.jsdelivr.net/gh/spiermar/d3-flame-graph@1.0.4/dist/d3.flameGraph.min.css">
+    <style>
+     html, body{
+         height: 100%;
+         margin: 0;
+         padding: 0;
+         font-size: 14px;
+     }
+    </style>
+    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/d3/4.10.0/d3.min.js"></script>
+    <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/d3-tip/0.7.1/d3-tip.min.js"></script>
+    <script type="text/javascript" src="https://cdn.jsdelivr.net/gh/spiermar/d3-flame-graph@1.0.4/dist/d3.flameGraph.min.js"></script>
+
+  </head>
+  <body>
+
+    <div class="container">
+      <div id="chart">
+      </div>
+    </div>
+    <script>
+     // Uses D3js flamegraph: https://github.com/spiermar/d3-flame-graph
+     var flameGraph = d3.flameGraph()
+                        .width(window.innerWidth)
+                        .cellHeight(18)
+                        .transitionDuration(750)
+                        .transitionEase(d3.easeCubic)
+                        .sort(true)
+                        .title("");
+
+     var tip = d3.tip()
+                 .direction("s")
+                 .offset([8, 0])
+                 .attr('class', 'd3-flame-graph-tip')
+                 .html(function(d) { return "name: " + d.data.name + ", value: " + d.data.value; });
+
+     flameGraph.tooltip(tip);
+
+     function setValue(d) {
+         var val = 0;
+         for( var i=0; i<d.children.length; i++){
+             setValue(d.children[i]);
+             val += d.children[i].value;
+         }
+         d.value = val == 0 ? 1 : val;
+     }
+
+     root = <%= tree.to_json %>;
+     setValue(root)
+     d3.select("#chart")
+       .datum(root)
+       .call(flameGraph);
+    </script>
+
+  </body>
+</html>