pbsimply 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d364901d22b774c9f9aecabde031611aec62d3d3edc49e05b47a34abb83f68c8
+  data.tar.gz: 779d8544a9e359d4ec94562c92dd898b1995b4e66d55796d3e4659b161e4ec7b
+SHA512:
+  metadata.gz: 801b0b10d12598699b8cee2c91bff275f7feed4da3433f9499b633742b65d5a589bd6eee80280403f2c08b8e209014eb3b20a9ebf1905c7dfcdb58c452c044f0
+  data.tar.gz: 5f181d1a737bebcc3d28981d8a37ca43e925aab5b08678db20e48272024ab25aaded146e06ac1e5e6026c96dd4bc629a94d67644853dc8f44d0cc77342d01b50

data/bin/pbsimply

@@ -0,0 +1,26 @@
+
+require 'pbsimply'
+
+config = PBSimply.load_config
+
+pbs_class = case config["pbsimply_processor"]
+when "redcarpet"
+  PBSimply::Processor::PbsRedCarpet
+when "kramdown"
+  PBSimply::Processor::PbsKramdown
+when "cmark"
+  PBSimply::Processor::PbsCommonMark
+when "rdoc_markdown"
+  PBSimply::Processor::PbsRMakrdown
+when "rdoc"
+  PBSimply::Processor::PbsRDoc
+else
+  PBSimply::Processor::Pandoc
+end
+
+# Alias for compatibility.
+PureBuilder = pbs_class
+
+pbs = pbs_class.new(config)
+pbs.treat_cmdline
+pbs.main

data/bin/pbsimply-testserver

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+# -*- mode: ruby; coding: UTF-8 -*-
+
+require 'webrick'
+require 'yaml'
+
+File.open(".pbsimply.yaml") do |f|
+  @config = YAML.load(f)
+end
+
+srv = WEBrick::HTTPServer.new({ :DocumentRoot => @config["outdir"],
+                                :BindAddress => '127.0.0.1',
+                                :Port => (@config["testserver_port"] || 8000 )})
+trap("INT"){ srv.shutdown }
+srv.start

data/lib/pbsimply.rb

@@ -0,0 +1,1071 @@
+#!/bin/env ruby
+require 'yaml'
+require 'erb'
+require 'date'
+require 'fileutils'
+require 'optparse'
+
+class PBSimply
+  # Use Oj as JSON library for frontmatter passing if possible.
+  begin
+    require 'oj'
+    JSON_LIB = Oj
+  rescue LoadError
+    require 'json'
+    JSON_LIB = JSON
+  end
+
+  # ACCS namespace.
+  module ACCS
+    DEFINITIONS = {}
+
+    # Built-in Accs index eRuby string.
+    INDEX = <<'EOF'
+<%= YAML.dump(
+  {
+    "title" => @index["title"],
+    "date" => @index["date"],
+    "author" => @index["author"]
+  }
+) %>
+---
+
+<%
+articles = Hash.new {|h,k| h[k] = Array.new }
+
+if @config["accs_across_category"]
+  @indexes.each {|filename, index| articles["default"].push index }
+else
+  @indexes.each {|filename, index| articles[(index["category"] || "default")].push index }
+end
+
+%>
+
+% articles.keys.sort.each do |catname|
+% cat = articles[catname]
+
+% unless articles.length == 1
+# <%= catname %>
+% end
+
+<%
+  sort_method = case @config["accs_sort_by"]
+  when "title"
+    lambda {|i| [i["title"].to_s, i["date"]] }
+  when "name"
+    lambda {|i| [i["_filename"].to_s, i["title"].to_s, i["date"]] }
+  when "serial"
+    lambda {|i| [i["serial"].to_s, i["date"], i["_filename"].to_s] }
+  else
+    lambda {|i| [i["date"], i["title"].to_s, i["_last_update"].to_i] }
+  end
+
+  list = if @config["accs_order"] == "desc"
+    cat.sort_by(&sort_method).reverse
+  else
+    cat.sort_by(&sort_method)
+  end
+
+  list.each do |i|
+%>* [<%= i["title"] %>](<%= i["page_url"] %>)
+<% end %>
+
+% end
+EOF
+  end
+
+  # Abstruct super class.
+  class DocDB
+    def dump(object)
+      File.open(File.join(@dir, ".indexes.#{@ext}"), "w") do |f|
+        f.write @store_class.dump(object)
+      end
+    end
+
+    def load
+      File.open(File.join(@dir, ".indexes.#{@ext}"), "r") do |f|
+        next @store_class.load(f)
+      end
+    end
+
+    def exist?
+      File.exist?(File.join(@dir, ".indexes.#{@ext}"))
+    end
+
+    def path
+      File.join(@dir, ".indexes.#{@ext}")
+    end
+
+    def cmp_obj(frontmatter)
+      @store_class.load(@store_class.dump(frontmatter))
+    end
+
+    class Marshal < DocDB
+      def initialize(dir)
+        @dir = dir
+        @store_class = ::Marshal
+        @ext = "rbm"
+      end
+
+      def cmp_obj(frontmatter)
+        frontmatter.dup
+      end
+    end
+
+    class JSON < DocDB
+      def initialize(dir)
+        @dir = dir
+        @store_class = ::JSON
+        @ext = "json"
+      end
+    end
+
+    class Oj < DocDB::JSON
+      def initialize(dir)
+        require 'oj'
+        @dir = dir
+        @ext = "json"
+        @store_class = ::Oj
+      end
+    end
+
+    class YAML < DocDB
+      def initialize(dir)
+        @dir = dir
+        @store_class = ::YAML
+        @ext = "yaml"
+      end
+    end
+  end
+
+
+  POST_PROCESSORS = {
+    ".rb" => "ruby",
+    ".pl" => "perl",
+    ".py" => "python",
+    ".lua" => "lua",
+    ".bash" => "bash",
+    ".zsh" => "zsh",
+    ".php" => "php",
+    ".sed" => ["sed", ->(script, target) { ["-f", script, target] } ]
+  }
+
+  ###############################################
+  #               SETUP FUNCTIONS               #
+  ###############################################
+
+  # Load config file.
+  def self.load_config
+    config = nil
+    begin
+      File.open(".pbsimply.yaml") do |f|
+        config = YAML.load(f)
+      end
+    rescue
+      abort "Failed to load config file (./.pbsimply.yaml)"
+    end
+
+    # Required values
+    config["outdir"] or abort "Output directory is not set (outdir)."
+    config["template"] ||= "./template.html"
+
+    config
+  end
+
+  # initialize phase,
+  def setup_config(dir)
+    ENV["pbsimply_outdir"] = @config["outdir"]
+    @docobject[:config] = @config
+
+    if @singlemode
+      outdir = [@config["outdir"], @dir.sub(%r:/[^/]*$:, "")].join("/")
+    else
+      outdir = [@config["outdir"], @dir].join("/")
+    end
+
+    p dir
+
+    # Format for Indexes database
+    @db = case @config["dbstyle"]
+    when "yaml"
+      DocDB::YAML.new(dir)
+    when "json"
+      DocDB::JSON.new(dir)
+    when "oj"
+      DocDB::Oj.new(dir)
+    else
+      DocDB::Marshal.new(dir)
+    end
+
+    @frontmatter.merge!(@config["default_meta"]) if @config["default_meta"]
+
+    # Merge ACCS Frontmatter
+    if @accs_processing && @config["alt_frontmatter"]
+      @frontmatter.merge!(@config["alt_frontmatter"])
+    end
+
+    unless File.exist? outdir
+      STDERR.puts "destination directory is not exist. creating (only one step.)"
+      FileUtils.mkdir_p outdir
+    end
+  end
+
+  def initialize(config)
+    @config = config
+    @docobject = {}
+    @this_time_processed = []
+
+    # --metadata-file
+    @frontmatter = {}
+
+    @refresh = false # Force generate all documents.
+    @skip_index = false # Don't register to index.
+    @outfile = nil # Fixed output filename
+    @add_meta = nil
+    @accs = nil
+    @accs_index = {}
+    @now = Time.now
+  end
+
+  # Process command-line
+  def treat_cmdline(dir=nil)
+    # Options definition.
+    opts = OptionParser.new
+    opts.on("-f", "--force-refresh") { @refresh = true }
+    opts.on("-X", "--ignore-ext") { @ignore_ext = true }
+    opts.on("-I", "--skip-index") { @skip_index = true }
+    opts.on("-o FILE", "--output") {|v| @outfile = v }
+    opts.on("-m FILE", "--additional-metafile") {|v| @add_meta = YAML.load(File.read(v))}
+    opts.parse!(ARGV)
+
+    if File.exist?(".pbsimply-bless.rb")
+      require "./.pbsimply-bless.rb"
+    end
+
+    # Set target directory.
+    @dir = ARGV.shift unless dir
+    @dir ||= "."
+    ENV["pbsimply_subdir"] = @dir
+  end
+
+  # Load document index database (.indexes.${ext}).
+  def load_index
+    if @db.exist?
+      @indexes = @db.load
+    else
+      @indexes = Hash.new
+    end
+    @docobject[:indexes] = @indexes
+  end
+
+  def target_file_extensions
+    [".md"]
+  end
+
+  # Accessor reader.
+  def doc
+    @docobject
+  end
+
+  attr :indexes
+
+
+  ###############################################
+  #            PROCESSING FUNCTIONS             #
+  ###############################################
+
+  # Directory mode's main function.
+  # Read Frontmatters from all documents and proc each documents.
+  def proc_dir
+    draft_articles = []
+    target_docs = []
+    @indexes_orig = {}
+    STDERR.puts "in #{@dir}..."
+
+    STDERR.puts "Checking Frontmatter..."
+    Dir.foreach(@dir) do |filename|
+      next if filename == "." || filename == ".."
+      if filename =~ /^\./ || filename =~ /^draft-/
+        draft_articles.push filename.sub(/^(?:\.|draft-)/, "")
+        next
+      end
+      next unless File.file?([@dir, filename].join("/"))
+
+      if !@ignore_ext and not target_file_extensions.include? File.extname filename
+        next
+      end
+
+      STDERR.puts "Checking frontmatter in #{filename}"
+      frontmatter, pos = read_frontmatter(@dir, filename)
+      frontmatter = @frontmatter.merge frontmatter
+      frontmatter.merge!(@add_meta) if @add_meta
+
+      if frontmatter["draft"]
+        @indexes.delete(filename) if @indexes[filename]
+        draft_articles.push filename
+        next
+      end
+
+      @indexes_orig[filename] = @indexes[filename]
+      @indexes[filename] = frontmatter
+
+      # Push to target documents without checking modification.
+      target_docs.push([filename, frontmatter, pos])
+    end
+
+    # Delete turn to draft article.
+    draft_articles.each do |df|
+      STDERR.puts "#{df} was turn to draft. deleting..."
+      [df, (df + ".html"), File.basename(df, ".*"), (File.basename(df, ".*") + ".html")].each do |tfn|
+        tfp = File.join(@config["outdir"], @dir, tfn)
+        File.delete tfp if File.file?(tfp)
+      end
+    end
+
+    # Save index.
+    @db.dump(@indexes) unless @skip_index
+
+    STDERR.puts "Blessing..."
+
+    # Modify frontmatter `BLESSING`
+    target_docs.each do |filename, frontmatter, pos|
+      if @config["bless_style"] == "cmd"
+        bless_cmd(frontmatter)
+      else
+        bless_ruby(frontmatter)
+      end
+    end
+
+    STDERR.puts "Checking modification..."
+
+    target_docs.delete_if {|filename, frontmatter, pos| !check_modify([@dir, filename], frontmatter)}
+
+    STDERR.puts "Okay, Now ready. Process documents..."
+
+    # Proccess documents
+    target_docs.each do |filename, frontmatter, pos|
+      ext = File.extname filename
+      @index = frontmatter
+      File.open(File.join(@dir, filename)) do |f|
+        f.seek(pos)
+        File.open(".current_document#{ext}", "w") {|fo| fo.write f.read}
+      end
+
+      STDERR.puts "Processing #{filename}"
+      generate(@dir, filename, frontmatter)
+    end
+
+    @db.dump(@indexes) unless @skip_index
+
+    post_plugins
+
+    # ACCS processing
+    if @accs && !target_docs.empty?
+      process_accs
+    end
+  end
+
+  # Run PureBuilder Simply.
+  def main
+    # If target file is regular file, run as single mode.
+    @singlemode = true if File.file?(@dir)
+
+    # Check single file mode.
+    if @singlemode
+      # Single file mode
+      if @dir =~ %r:(.*)/([^/]+):
+        dir = $1
+        filename = $2
+      else
+        dir = "."
+        filename = @dir
+      end
+      @dir = dir
+      setup_config(dir)
+
+      load_index
+
+      frontmatter, pos = read_frontmatter(dir, filename)
+      frontmatter = @frontmatter.merge frontmatter
+      @index = frontmatter
+
+      ext = File.extname filename
+      File.open(File.join(dir, filename)) do |f|
+        f.seek(pos)
+        File.open(".current_document#{ext}", "w") {|fo| fo.write f.read}
+      end
+
+      generate(dir, filename, frontmatter)
+
+      post_plugins(frontmatter)
+
+    else
+      # Normal (directory) mode.
+      setup_config(@dir)
+      load_index
+
+      @accs = true if File.exist?(File.join(@dir, ".accs.yaml"))
+
+      # Check existing in indexes.
+      @indexes.delete_if {|k,v| ! File.exist?([@dir, k].join("/")) }
+
+      proc_dir
+    end
+  ensure
+    # Clean up temporary files.
+    Dir.children(".").each do |fn|
+      if fn[0, 22] == ".pbsimply-defaultfiles.yaml" or
+         fn[0, 21] == ".pbsimply-frontmatter" or
+         fn[0, 17] == ".current_document"
+        File.delete fn
+      end
+    end
+  end
+
+  def pre_plugins(procdoc, frontmatter)
+    if File.directory?(".pre_generate")
+      STDERR.puts("Processing with pre plugins")
+      script_file = File.join(".pre_generate", script_file)
+      Dir.entries(".pre_generate").sort.each do |script_file|
+        next if script_file =~ /^\./
+        STDERR.puts "Running script: #{File.basename script_file}"
+        pre_script_result = nil
+        script_cmdline = case
+        when File.executable?(script_file)
+          [script_file, procdoc]
+        when POST_PROCESSORS[File.extname(script_file)]
+          [POST_PROCESSORS[File.extname(script_file)], script_file, procdoc]
+        else
+          ["perl", script_file, procdoc]
+        end
+        IO.popen({"pbsimply_doc_frontmatter" => YAML.dump(frontmatter)}, script_cmdline) do |io|
+          pre_script_result = io.read
+        end
+        File.open(procdoc, "w") {|f| f.write pre_script_result}
+      end
+    end
+  end
+
+  def post_plugins(frontmatter=nil)
+    if File.directory?(".post_generate")
+
+      STDERR.puts("Processing with post plugins")
+
+      @this_time_processed.each do |v|
+        STDERR.puts "Processing #{v[:dest]} (from #{v[:source]})"
+        procdoc = v[:dest]
+        frontmatter ||= @indexes[File.basename v[:source]]
+        File.open(".pbsimply-frontmatter.json", "w") {|f| f.write JSON_LIB.dump(frontmatter)}
+        Dir.entries(".post_generate").sort.each do |script_file|
+          next if script_file =~ /^\./
+          STDERR.puts "Running script: #{script_file}"
+          script_file = File.join(".post_generate", script_file)
+          post_script_result = nil
+          script_cmdline = case
+          when File.executable?(script_file)
+            [script_file, procdoc]
+          when POST_PROCESSORS[File.extname(script_file)]
+            [POST_PROCESSORS[File.extname(script_file)], script_file, procdoc]
+          else
+            ["perl", script_file, procdoc]
+          end
+          IO.popen({"pbsimply_frontmatter" => ".pbsimply-frontmatter.json", "pbsimply_indexes" => @db.path}, script_cmdline) do |io|
+            post_script_result = io.read
+          end
+
+          File.open(procdoc, "w") {|f| f.write post_script_result}
+        end
+      end
+    end
+  end
+
+  def generate(dir, filename, frontmatter)
+    print_fileproc_msg(filename) # at sub-class
+
+    # Preparing and pre script.
+    orig_filepath = [dir, filename].join("/")
+    ext = File.extname(filename)
+    procdoc = sprintf(".current_document%s", ext)
+    pre_plugins(procdoc, frontmatter)
+
+    doc = process_document(dir, filename, frontmatter, orig_filepath, ext, procdoc) # at sub-class
+
+    ##### Post eRuby
+    if @config["post_eruby"]
+      STDERR.puts "Porcessing with eRuby."
+      doc = ERB.new(doc, nil, "%<>").result(binding)
+    end
+
+    # Write out
+    outext = frontmatter["force_ext"] || ".html"
+    outpath = case
+    when @outfile
+      @outfile
+    when @accs_processing
+      File.join(@config["outdir"], @dir, "index") + outext
+    else
+      File.join(@config["outdir"], @dir, File.basename(filename, ".*")) + outext
+    end
+
+    File.open(outpath, "w") do |f|
+      f.write(doc)
+    end
+
+    # Mark processed
+    @this_time_processed.push({source: orig_filepath, dest: outpath})
+  end
+
+  # letsaccs
+  #
+  # This method called on the assumption that processed all documents and run as directory mode.
+  def process_accs
+    STDERR.puts "Processing ACCS index..."
+    if File.exist?(File.join(@dir, ".accsindex.erb"))
+      erbtemplate = File.read(File.join(@dir, ".accsindex.erb"))
+    elsif File.exist?(".accsindex.erb")
+      erbtemplate = File.read(".accsindex.erb")
+    else
+      erbtemplate = ACCS::INDEX
+    end
+
+    # Get infomation
+    @accs_index = YAML.load(File.read([@dir, ".accs.yaml"].join("/")))
+
+    @accs_index["title"] ||= (@config["accs_index_title"] || "Index")
+    @accs_index["date"] ||= Time.now.strftime("%Y-%m-%d")
+    @accs_index["pagetype"] = "accs_index"
+
+    @index = @frontmatter.merge @accs_index
+
+    doc = ERB.new(erbtemplate, trim_mode: "%<>").result(binding)
+    File.open(File.join(@dir, ".index.md"), "w") do |f|
+      f.write doc
+    end
+
+    accsmode
+    @dir = File.join(@dir, ".index.md")
+    main
+  end
+
+  ###############################################
+  #      PRIVATE METHODS (treat document)       #
+  ###############################################
+
+  private
+
+  # Turn on ACCS processing mode.
+  def accsmode
+    @accs_processing = true
+    @singlemode = true
+    @skip_index = true
+  end
+
+  # Read Frontmatter from the document.
+  # This method returns frontmatter, pos.
+  # pos means position at end of Frontmatter on the file.
+  def read_frontmatter(dir, filename)
+    frontmatter = nil
+    pos = nil
+
+    if File.exist? File.join(dir, ".meta." + filename)
+      # Load standalone metadata YAML.
+      frontmatter = YAML.load(File.read(File.join(dir, (".meta." + filename))))
+      pos = 0
+    else
+
+      case File.extname filename
+      when ".md"
+
+        # Load Markdown's YAML frontmatter.
+        File.open(File.join(dir, filename)) do |f|
+          l = f.gets
+          next unless l && l.chomp == "---"
+
+          lines = []
+
+          while l = f.gets
+            break if l.nil?
+
+            break if  l.chomp == "---"
+            lines.push l
+          end
+
+          next if f.eof?
+
+          begin
+            frontmatter = YAML.load(lines.join)
+          rescue => e
+            STDERR.puts "!CRITICAL: Cannot parse frontmatter."
+            raise e
+          end
+
+          pos = f.pos
+        end
+
+      when ".rst"
+        # ReSTRUCTURED Text
+
+        File.open(File.join(dir, filename)) do |f|
+          l = f.gets
+          if l =~ /:([A-Za-z_-]+): (.*)/ #docinfo
+            frontmatter = { $1 => [$2.chomp] }
+            last_key = $1
+
+            # Read docinfo
+            while(l = f.gets)
+              break if l =~ /^\s*$/ # End of docinfo
+              if l =~ /^\s+/ # Continuous line
+                docinfo_lines.last.push($'.chomp)
+              elsif l =~ /:([A-Za-z_-]+): (.*)/
+                frontmatter[$1] = [$2.chomp]
+                last_key = $1
+              end
+            end
+
+            # Treat docinfo lines
+            frontmatter.each do |k,v|
+              v = v.join(" ")
+              #if((k == "author" || k == "authors") && v.include?(";")) # Multiple authors.
+              if(v.include?(";")) # Multiple element.
+                v = v.split(/\s*;\s*/)
+
+              elsif k == "date" # Date?
+                # Datetime?
+                if v =~ /[0-2][0-9]:[0-6][0-9]/
+                  v = DateTime.parse(v)
+                else
+                  v = Date.parse(v)
+                end
+              elsif v == "yes" || v == "true"
+                v = true
+              else # Simple String.
+                nil # keep v
+              end
+
+              frontmatter[k] = v
+            end
+
+          elsif l && l.chomp == ".." #YAML
+            # Load ReST YAML that document begins comment and block is yaml.
+            lines = []
+
+            while(l = f.gets)
+              if(l !~ /^\s*$/ .. l =~ /^\s*$/)
+                if l=~ /^\s*$/
+                  break
+                else
+                  lines.push l
+                end
+              end
+            end
+            next if f.eof?
+
+
+            # Rescue for failed to read YAML.
+            begin
+              frontmatter = YAML.load(lines.map {|i| i.sub(/^\s*/, "") }.join)
+            rescue
+              STDERR.puts "Error in parsing ReST YAML frontmatter (#{$!})"
+              next
+            end
+          else
+            next
+          end
+
+          pos = f.pos
+
+        end
+      end
+    end
+
+    abort "This document has no frontmatter" unless frontmatter
+    abort "This document has no title." unless frontmatter["title"]
+
+
+    ### Additional meta values. ###
+    frontmatter["source_directory"] = dir # Source Directory
+    frontmatter["source_filename"] = filename # Source Filename
+    frontmatter["source_path"] = File.join(dir, filename) # Source Path
+    # URL in site.
+    this_url = (File.join(dir, filename)).sub(/^[\.\/]*/) { @config["self_url_prefix"] || "/" }.sub(/\.[a-zA-Z0-9]+$/, ".html")
+    frontmatter["page_url"] = this_url
+    # URL in site with URI encode.
+    frontmatter["page_url_encoded"] = ERB::Util.url_encode(this_url)
+    frontmatter["page_url_encoded_external"] = ERB::Util.url_encode((File.join(dir, filename)).sub(/^[\.\/]*/) { @config["self_url_external_prefix"] || "/" }.sub(/\.[a-zA-Z0-9]+$/, ".html"))
+    frontmatter["page_html_escaped"] = ERB::Util.html_escape(this_url)
+    frontmatter["page_html_escaped_external"] = ERB::Util.html_escape((File.join(dir, filename)).sub(/^[\.\/]*/) { @config["self_url_external_prefix"] || "/" }.sub(/\.[a-zA-Z0-9]+$/, ".html"))
+    # Title with URL Encoded.
+    frontmatter["title_encoded"] = ERB::Util.url_encode(frontmatter["title"])
+    frontmatter["title_html_escaped"] = ERB::Util.html_escape(frontmatter["title"])
+    fts = frontmatter["timestamp"]
+    fts = fts.to_datetime if Time === fts
+    if DateTime === fts
+      frontmatter["timestamp_xmlschema"] = fts.xmlschema
+      frontmatter["timestamp_jplocal"] = fts.strftime('%Y年%m月%d日 %H時%M分%S秒')
+      frontmatter["timestamp_rubytimestr"] = fts.strftime('%a %b %d %H:%M:%S %Z %Y')
+      frontmatter["timestamp_str"] = fts.strftime("%Y-%m-%d %H:%M:%S %Z")
+    elsif Date === fts
+      frontmatter["timestamp_xmlschema"] = fts.xmlschema
+      frontmatter["timestamp_jplocal"] = fts.strftime('%Y年%m月%d日')
+      frontmatter["timestamp_rubytimestr"] = fts.strftime('%a %b %d')
+      frontmatter["timestamp_str"] = fts.strftime("%Y-%m-%d")
+    elsif Date === frontmatter["Date"]
+      fts = frontmatter["Date"]
+      frontmatter["timestamp_xmlschema"] = fts.xmlschema
+      frontmatter["timestamp_jplocal"] = fts.strftime('%Y年%m月%d日')
+      frontmatter["timestamp_rubytimestr"] = fts.strftime('%a %b %d')
+      frontmatter["timestamp_str"] = fts.strftime("%Y-%m-%d")
+    end
+
+    fsize = FileTest.size(File.join(dir, filename))
+    mtime = File.mtime(File.join(dir, filename)).to_i
+
+    frontmatter["_filename"] ||= filename
+    frontmatter["pagetype"] ||= "post"
+
+    frontmatter["_size"] = fsize
+    frontmatter["_mtime"] = mtime
+    frontmatter["_last_proced"] = @now.to_i
+
+    if File.extname(filename) == ".md"
+      frontmatter["_docformat"] = "Markdown"
+    elsif File.extname(filename) == ".rst" || File.extname(filename) == ".rest"
+      frontmatter["_docformat"] = "ReST"
+    end
+
+    frontmatter["date"] ||= @now.strftime("%Y-%m-%d %H:%M:%S")
+
+    return frontmatter, pos
+  end
+
+  # Check is the article modified? (or force update?)
+  def check_modify(path, frontmatter)
+    modify = true
+    index = @indexes_orig[path[1]].dup || {}
+    frontmatter = @db.cmp_obj(frontmatter)
+    index.delete("_last_proced")
+    frontmatter.delete("_last_proced")
+
+    if index == frontmatter
+      STDERR.puts "#{path[1]} is not modified."
+      modify = false
+    else
+      STDERR.puts "#{path[1]} last modified at #{frontmatter["_mtime"]}, last processed at #{@indexes_orig[path[1]]&.[]("_last_proced") || 0}"
+      frontmatter["last_update"] = @now.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    if @refresh
+      # Refresh (force update) mode.
+      true
+    else
+      modify
+    end
+  end
+
+  def bless_ruby(frontmatter)
+    # BLESSING (Always)
+    if PureBuilder.const_defined?(:BLESS) && Proc === PureBuilder::BLESS
+      begin
+        PureBuilder::BLESS.(frontmatter, self)
+      rescue
+        STDERR.puts "*** BLESSING PROC ERROR ***"
+        raise
+      end
+    end
+
+    # BLESSING (ACCS)
+    if @accs && PureBuilder::ACCS.const_defined?(:BLESS) && Proc === PureBuilder::ACCS::BLESS
+      begin
+        PureBuilder::ACCS::BLESS.(frontmatter, self)
+      rescue
+        STDERR.puts "*** ACCS BLESSING PROC ERROR ***"
+        raise
+      end
+    end
+
+    # ACCS DEFINITIONS
+    if @accs
+      if Proc === PureBuilder::ACCS::DEFINITIONS[:next]
+        i = PureBuilder::ACCS::DEFINITIONS[:next].call(frontmatter, self)
+        frontmatter["next_article"] = i if i
+      end
+      if Proc === PureBuilder::ACCS::DEFINITIONS[:prev]
+        i = PureBuilder::ACCS::DEFINITIONS[:prev].call(frontmatter, self)
+        frontmatter["prev_article"] = i if i
+      end
+    end
+
+    autobless(frontmatter)
+  end
+
+  def bless_cmd(frontmatter)
+    File.open(".pbsimply-frontmatter.json", "w") {|f| f.write JSON_LIB.dump(frontmatter) }
+    # BLESSING (Always)
+    if @config["bless_cmd"]
+      (Array === @config["bless_cmd"] ? system(*@config["bless_cmd"]) : system(@config["bless_cmd"]) ) or abort "*** BLESS COMMAND RETURNS NON-ZERO STATUS"
+    end
+    # BLESSING (ACCS)
+    if @config["bless_accscmd"]
+      (Array === @config["bless_accscmd"] ? system({"pbsimply_frontmatter" => ".pbsimply-frontmatter.json", "pbsimply_indexes" => @db.path}, *@config["bless_accscmd"]) : system({"pbsimply_frontmatter" => ".pbsimply-frontmatter.json", "pbsimply_indexes" => @db.path}, @config["bless_accscmd"]) ) or abort "*** BLESS COMMAND RETURNS NON-ZERO STATUS"
+    end
+    mod_frontmatter = JSON.load(File.read(".pbsimply-frontmatter.json"))
+    frontmatter.replace(mod_frontmatter)
+
+    autobless(frontmatter)
+  end
+
+  # Blessing automatic method with configuration.
+  def autobless(frontmatter)
+    catch(:accs_rel) do
+      # find Next/Prev page on accs
+      if @accs && @config["blessmethod_accs_rel"]
+        # Preparing. Run at once.
+        if !@article_order
+          @rev_article_order_index = {}
+
+          case @config["blessmethod_accs_rel"]
+          when "numbering"
+            @article_order = @indexes.to_a.sort_by {|i| i[1]["_filename"].to_i }
+          when "date"
+            begin
+              @article_order = @indexes.to_a.sort_by {|i| i[1]["date"]}
+            rescue
+              abort "*** Automatic Blessing Method Error: Maybe some article have no date."
+            end
+          when "timestamp"
+            begin
+              @article_order = @indexes.to_a.sort_by {|i| i[1]["timestamp"]}
+            rescue
+              abort "*** Automatic Blessing Method Error: Maybe some article have no timetsamp."
+            end
+          when "lexical"
+            @article_order = @indexes.to_a.sort_by {|i| i[1]["_filename"]}
+          end
+          @article_order.each_with_index {|x,i| @rev_article_order_index[x[0]] = i }
+        end
+
+        throw(:accs_rel) unless index = @rev_article_order_index[frontmatter["_filename"]]
+        if @article_order[index + 1]
+          frontmatter["next_article"] = {"url" => @article_order[index + 1][1]["page_url"],
+                                         "title" => @article_order[index + 1][1]["title"]}
+        end
+        if index > 0
+          frontmatter["prev_article"] = {"url" => @article_order[index - 1][1]["page_url"],
+                                         "title" => @article_order[index - 1][1]["title"]}
+        end
+      end
+    end
+  end
+
+  ###############################################
+  #           DOCUMENT PROCESSORS               #
+  ###############################################
+
+
+  module Processor
+
+    # Pandoc processor
+    class Pandoc < PBSimply
+      def initialize(config)
+        @pandoc_default_file = {}
+
+        # -d
+        @pandoc_default_file = {
+          "to" => "html5",
+          "standalone" => true
+        }
+        super
+      end
+
+      def setup_config(dir)
+        super
+        @pandoc_default_file["template"] = @config["template"]
+
+        if @config["css"]
+          if @config["css"].kind_of?(String)
+            @pandoc_default_file["css"] = [@config["css"]]
+          elsif @config["css"].kind_of?(Array)
+            @pandoc_default_file["css"] = @config["css"]
+          else
+            abort "css in Config should be a String or an Array."
+          end
+        end
+
+        if @config["toc"]
+          @pandoc_default_file["toc"] = true
+        end
+
+        if Hash === @config["pandoc_additional_options"]
+          @pandoc_default_file.merge! @config["pandoc_additional_options"]
+        end
+
+      end
+
+      # Invoke pandoc, parse and format and write out.
+      def print_fileproc_msg(filename)
+        STDERR.puts "#{filename} is going Pandoc."
+      end
+
+      def process_document(dir, filename, frontmatter, orig_filepath, ext, procdoc)
+        doc = nil
+
+        File.open(".pbsimply-defaultfiles.yaml", "w") {|f| YAML.dump(@pandoc_default_file, f)}
+        File.open(".pbsimply-frontmatter.yaml", "w") {|f| YAML.dump(frontmatter, f)}
+
+        # Go Pandoc
+        pandoc_cmdline = ["pandoc"]
+        pandoc_cmdline += ["-d", ".pbsimply-defaultfiles.yaml", "--metadata-file", ".pbsimply-frontmatter.yaml", "-M", "title:#{frontmatter["title"]}"]
+        pandoc_cmdline += ["-f", frontmatter["input_format"]] if frontmatter["input_format"]
+        pandoc_cmdline += [ procdoc ]
+        IO.popen((pandoc_cmdline)) do |io|
+          doc = io.read
+        end
+
+        # Abort if pandoc returns non-zero status
+        if $?.exitstatus != 0
+          abort "Pandoc returns exit code #{$?.exitstatus}"
+        end
+
+        doc
+      end
+
+      def target_file_extensions
+        [".md", ".rst"]
+      end
+    end
+
+    # RDoc family Base
+    class PbsRBase < PBSimply
+      def initialize(config)
+        require 'rdoc'
+        require 'rdoc/markup/to_html'
+
+        @rdoc_options = RDoc::Options.new
+        @rdoc_markup = RDoc::Markup.new
+
+        super
+      end
+
+      def process_document(dir, filename, frontmatter, orig_filepath, ext, procdoc)
+        # Getting HTML string.
+        rdoc = RDoc::Markup::ToHtml.new(@rdoc_options, @rdoc_markup)
+        article_body = rdoc.convert(get_markup_document(procdoc))
+
+        # Process with eRuby temaplte.
+        erb_template = ERB.new(File.read(@config["template"]), trim_mode: '%<>')
+        doc = erb_template.result(binding)
+
+        doc
+      end
+    end
+
+    # RDoc/Markdown processor
+    class PbsRMakrdown < PbsRBase
+      def initialize(config)
+        require 'rdoc'
+        require 'rdoc/markdown'
+        super
+      end
+
+      def print_fileproc_msg(filename)
+        STDERR.puts "#{filename} generate with RDoc/Markdown"
+      end
+
+      def get_markup_document procdoc
+        RDoc::Markdown.parse(File.read procdoc)
+      end
+    end
+
+    # RDoc processor
+    class PbsRDoc < PbsRBase
+      def print_fileproc_msg(filename)
+        STDERR.puts "#{filename} generate with RDoc"
+      end
+
+      def get_markup_document procdoc
+        File.read procdoc
+      end
+
+      def target_file_extensions
+        [".rdoc"]
+      end
+    end
+
+    class PbsRedCarpet < PBSimply
+      def initialize(config)
+        require 'redcarpet'
+        super
+      end
+
+      def setup_config(dir)
+        super
+        @rc_extension = @config["redcarpet_extensions"] || {}
+      end
+
+      def print_fileproc_msg(filename)
+        STDERR.puts "#{filename} generate with Redcarpet Markdown"
+      end
+
+      def process_document(dir, filename, frontmatter, orig_filepath, ext, procdoc)
+        # Getting HTML string.
+        markdown = Redcarpet::Markdown.new(Redcarpet::Render::HTML, **@rc_extension)
+        article_body = markdown.render(File.read procdoc)
+
+        # Process with eRuby temaplte.
+        erb_template = ERB.new(File.read(@config["template"]), trim_mode: '%<>')
+        doc = erb_template.result(binding)
+
+        doc
+      end
+    end
+
+    class PbsKramdown < PBSimply
+      def initialize(config)
+        require 'kramdown'
+        super
+      end
+
+      def print_fileproc_msg(filename)
+        STDERR.puts "#{filename} generate with Kramdown"
+      end
+
+      def process_document(dir, filename, frontmatter, orig_filepath, ext, procdoc)
+        # Set feature options
+        features = @config["kramdown_features"] || {}
+
+        # Getting HTML string.
+        markdown = Kramdown::Document.new(File.read(procdoc), **features)
+        article_body = markdown.to_html
+
+        # Process with eRuby temaplte.
+        erb_template = ERB.new(File.read(@config["template"]), trim_mode: '%<>')
+        doc = erb_template.result(binding)
+
+        doc
+      end
+    end
+
+    class PbsCommonMark < PBSimply
+      def initialize(config)
+        require 'commonmarker'
+        super
+      end
+
+      def print_fileproc_msg(filename)
+        STDERR.puts "#{filename} generate with CommonMarker (cmark-gfm)"
+      end
+
+      def process_document(dir, filename, frontmatter, orig_filepath, ext, procdoc)
+        # Getting HTML string.
+        article_body = CommonMarker.render_doc(File.read(procdoc), :DEFAULT, [:table, :strikethrough]).to_html
+
+        # Process with eRuby temaplte.
+        erb_template = ERB.new(File.read(@config["template"]), trim_mode: '%<>')
+        doc = erb_template.result(binding)
+
+        doc
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: pbsimply
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Masaki Haruka
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Pre compile, static serving headless CMS
+email:
+- yek@reasonset.net
+executables:
+- pbsimply
+- pbsimply-testserver
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pbsimply
+- bin/pbsimply-testserver
+- lib/pbsimply.rb
+homepage: https://github.com/reasonset/purebuilder-simply
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.29
+signing_key:
+specification_version: 4
+summary: PureBuiler Simply
+test_files: []