juli 2.0.0

data/lib/juli/command/file_entry.rb

@@ -0,0 +1,12 @@
+module Juli
+  module Command
+    # used in both Juli::Command::Sitemap Juli::Command::RecentUpdate
+    class FileEntry
+      attr_accessor :path, :mtime
+      def initialize(path, mtime)
+        @path   = path
+        @mtime  = mtime
+      end
+    end
+  end
+end

data/lib/juli/command/recent_update.rb

@@ -0,0 +1,52 @@
+module Juli::Command
+  # generate recent_updates.shtml which lists recent updated entries.
+  # The file is for server-side-include(SSI).
+  class RecentUpdate
+    include Juli::Util
+    include Juli::Visitor::Html::TagHelper
+  
+    # define maximum file limit in order to reduce process time.
+    FILE_LIMIT = 20
+
+    # cache recent_update
+    def initialize
+      @file = []
+      Dir.chdir(juli_repo){
+        Dir.glob('**/*.txt'){|f|
+          @file << FileEntry.new(f, File.stat(f).mtime)
+        }
+        @file.sort!{|a,b| b.mtime <=> a.mtime}
+      }
+    end
+
+    def run(opts)
+      File.open(File.join(conf['output_top'], 'recent_update.shtml'), 'w') do |f|
+        f.write(gen(opts))
+      end
+    end
+
+  private
+    def gen(opts)
+      title   = I18n.t('recent_updates')
+      content_tag(:table, :class=>'juli_recent_update') do
+        content_tag(:tr, content_tag(:th, title, :colspan=>2)) +
+        begin
+          result = ''
+          for i in 0..FILE_LIMIT-1 do
+            f = @file[i]
+            break if !f
+            result +=
+              content_tag(:tr) do
+                content_tag(:td) do
+                  content_tag(:a, f.path.gsub(/.txt$/, ''),
+                    :href=>f.path.gsub(/.txt$/, conf['ext'])) + "\n<br/>"
+                end +
+                content_tag(:td, f.mtime.strftime('%Y/%m/%d'))
+              end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/juli/command/sitemap.rb

@@ -0,0 +1,55 @@
+module Juli::Command
+  # generate sitemap.html and sitemap_order_by_mtime_DESC.html
+  # under $JULI_REPO
+  class Sitemap
+    include Juli::Util
+    include Juli::Visitor::Html::TagHelper
+
+    # cache File info
+    def initialize
+      @file = []
+      Dir.chdir(juli_repo){
+        Dir.glob('**/*.txt'){|f|
+          @file << FileEntry.new(f, File.stat(f).mtime)
+        }
+      }
+    end
+
+    def run(opts)
+      sitemap_sub('sitemap.html'){|files| files.sort}
+      sitemap_sub('sitemap_order_by_mtime_DESC.html'){|files|
+        files.sort{|a,b| File.stat(a).mtime <=> File.stat(b).mtime}.reverse
+      }
+    end
+
+  private
+    # === INPUTS
+    # name::  basename without extention for sitemap
+    # block:: sort condition
+    def sitemap_sub(name, &block)
+      Dir.chdir(juli_repo) {
+        outdir = File.join(conf['output_top'])
+        FileUtils.mkdir(outdir) if !File.directory?(outdir)
+        body  = ''
+        count = 0
+        for textfile in yield(Dir.glob('**/*.txt')) do
+          count += 1
+          body += sprintf("<tr><td class='num'>%d</td><td><a href='%s'>%s</a></td><td>%s</td></tr>\n",
+                      count,
+                      textfile.gsub(/.txt$/, conf['ext']),  # url
+                      textfile.gsub(/.txt$/, ''),           # label
+                      File.stat(textfile).mtime.strftime("%Y/%m/%d %H:%M:%S"))
+        end
+
+        title       = I18n.t('sitemap')
+        prototype   = 'prototype.js'
+        javascript  = 'juli.js'
+        stylesheet  = 'juli.css'
+        erb         = ERB.new(File.read(find_template(name)))
+        File.open(out_filename(name), 'w') do |f|
+          f.write(erb.result(binding))
+        end
+      }
+    end
+  end
+end

data/lib/juli/command/tag.rb

@@ -0,0 +1,81 @@
+# coding: UTF-8
+
+module Juli::Command
+  # generate _tag.shtml which shows tag-search-result HTML page.
+  class Tag
+    include Juli::Util
+    include Juli::Visitor::Html::TagHelper
+  
+    def initialize
+      @tag_macro = Juli::Macro::Tag.new
+    end
+
+    def run(opts)
+      # tag list
+      body = content_tag(:a, '', :name=>'top').force_encoding('UTF-8') +
+             "<h2>#{I18n.t('tag_list')}</h2>\n".force_encoding('UTF-8')
+      for tag, val in @tag_macro.tag_db do
+        body += gen_tag_list(tag)
+      end
+      body += gen_tag_list(
+                  Juli::Macro::Tag::NO_TAG,
+                  I18n.t(Juli::Macro::Tag::NO_TAG))
+      body += "\n\n" + '<br/>'*50
+
+      # tag detail
+      for tag, val in @tag_macro.tag_db do
+        body += gen_tag_detail(tag)
+      end
+      body += gen_tag_detail(
+                  Juli::Macro::Tag::NO_TAG,
+                  I18n.t(Juli::Macro::Tag::NO_TAG))
+
+      title       = I18n.t('tag_list')
+      contents    = ''
+      prototype   = 'prototype.js'
+      javascript  = 'juli.js'
+      stylesheet  = 'juli.css'
+      erb = ERB.new(File.read(find_template('simple.html')))
+      File.open(File.join(conf['output_top'], '_tag.shtml'), 'w') do |f|
+        f.write(erb.result(binding))
+      end
+    end
+
+  private
+    def gen_tag_list(tag, tag_label=tag)
+      (content_tag(:a, tag_label,
+          :class  => sprintf("juli_tag_%02d", @tag_macro.tag_weight_ratio(tag)),
+          :href   => "##{tag}") + ' ').force_encoding('UTF-8')
+    end
+
+    def gen_tag_detail(tag, tag_label=tag)
+      content_tag(:a, '', :name=>tag).force_encoding('UTF-8') +
+      content_tag(:h2, tag_label).force_encoding('UTF-8') +
+      '<table>' +
+      begin
+        s = ''
+        for page in @tag_macro.pages(@tag_macro.to_utf8(tag)) do
+          file = page + '.txt'
+          if !File.exist?(file)
+            # Non-exist file may occur by manual delete/rename so that
+            # delete the entry from tag-DB and don't produce tag entry 
+            # from the tag-list page.
+            @tag_macro.delete_page(file)
+            next
+          end
+
+          page_utf8 = @tag_macro.to_utf8(page)
+          s += sprintf("<tr><td><a href='%s'>%s</a></td><td>%s</td></tr>\n",
+              page_utf8 + @tag_macro.to_utf8(conf['ext']),
+              page_utf8,
+              File.stat(file).mtime.strftime("%Y/%m/%d %H:%M"))
+        end
+        s
+      end +
+      '</table>' + 
+      '<br/>' +
+      '<a href="#top">' + I18n.t('back_to_top') + '</a>' +
+      '<br/>'*30
+    end
+  end
+end

data/lib/juli/line_parser.y

@@ -0,0 +1,212 @@
+# Text *line* parser for Juli format.
+class Juli::LineParser
+  options no_result_var
+
+rule
+  line
+    : elements            { @root = val[0] }
+
+  elements
+    : /* none */          { LineAbsyn::ArrayNode.new }
+    | elements element    { val[0].add(val[1]) }
+
+  element
+    : STRING              { LineAbsyn::StringNode.new(val[0]) }
+    | WIKINAME            { LineAbsyn::WikiName.new(val[0]) }
+    | TAG                 { LineAbsyn::StringNode.new(val[0]) }
+    | URL                 { LineAbsyn::Url.new(val[0]) }
+    | MACRO               { LineAbsyn::Macro.new(val[0][0], val[0][1]) }
+end
+---- header
+module Juli::LineAbsyn
+  class Node
+    def accept(visitor)
+      visitor.visit_node(self)
+    end
+  end
+  
+  class StringNode < Node
+    attr_accessor :str
+  
+    def initialize(str)
+      @str = str
+    end
+  
+    def accept(visitor)
+      visitor.visit_string(self)
+    end
+  end
+
+  class WikiName < StringNode
+    def accept(visitor)
+      visitor.visit_wikiname(self)
+    end
+  end
+
+  class Url < StringNode
+    def accept(visitor)
+      visitor.visit_url(self)
+    end
+  end
+
+  class Macro < Node
+    attr_accessor :name, :rest
+
+    def initialize(name, rest)
+      @name = name
+      @rest = rest
+    end
+  
+    def accept(visitor)
+      visitor.visit_macro(self)
+    end
+  end
+
+  class ArrayNode < Node
+    attr_accessor :array
+  
+    def initialize
+      @array      = Array.new
+    end
+  
+    def add(child)
+      @array << child
+      self
+    end
+  
+    def accept(visitor)
+      visitor.visit_array(self)
+    end
+  end
+
+  # define Visitor default actions
+  class Visitor
+    def visit_node(n); end
+
+    def visit_array(n)
+      for n in n.array do
+        n.accept(self)
+      end
+    end
+
+    def visit_string(n); end
+    def visit_wikiname(n); end
+    def visit_url(n); end
+    def visit_macro(n); end
+  end
+
+  # visitor for debug
+  class DebugVisitor < Visitor
+    attr_reader :array
+
+    def initialize
+      @array = []
+    end
+
+    def visit_string(n)
+      @array << n.str
+    end
+
+    def visit_wikiname(n)
+      @array << sprintf("W:%s", n.str)
+    end
+
+    def visit_url(n)
+      @array << sprintf("U:%s", n.str)
+    end
+
+    def visit_macro(n)
+      @array << sprintf("M:%s:%s", n.name, n.rest)
+    end
+  end
+end
+
+---- inner
+  # parse one line and return absyn tree for the line
+  def parse(line, wikinames)
+    @remain     = line
+    @wikinames  = wikinames
+    yyparse self, :scan
+    @root
+  end
+
+private
+  # Wikiname scanning algorithm is as follows:
+  #
+  # 1. input: [..............................................................]
+  # 2. scan longest wikiname in wikiname-dictionary:
+  #           [<---heading_remain---->LONGEST_WIKINAME<---trailing_remain--->]
+  # 3. for remaining in head & trail, do 2. above recursively
+  def scan(&block)
+    scan_r(@remain, &block)
+    yield [false, nil]
+  end
+
+  URL = '(https?|mailto|ftp):[\w\.\?&/@%^=~#-]+'
+
+  # recursive scan
+  def scan_r(str, &block)
+    for w in @wikinames do
+      case str
+      # to escape wikiname string in <a>...</a>, it is prior to wikiname
+      #
+      # If word in <a ...>word</a> tag is a wikiname, it would be produced to
+      # <a ...><a ...>word</a></a> because it is a wikiname.  In order to
+      # avoid this, two ways can be considered:
+      #
+      # 1. introduce escape notation.  e.g. rdoc \word
+      # 2. introduce special inline escape logic just for <a>...</a>
+      #
+      # I choose latter for simple usage.
+      when /\A([^<]*)(<a[^>]*>[^<]*<\/a>)(.*)\z/m
+        scan_r($1, &block)
+        yield [:STRING, $2]   # <a>...</a> is just string even wikiname be there
+        scan_r($3, &block)
+        return
+
+      # to escape wikiname string in HTML tag, it is prior to wikiname
+      when /\A([^<]*)(<[^>]*>)(.*)\z/m
+        scan_r($1, &block)
+        yield [:STRING, $2]   # <a>...</a> is just string even wikiname be there
+        scan_r($3, &block)
+        return
+
+      # escape of escape: \\{ -> \{
+      when /\A([^\\]*)\\\\\{(.*)\z/m
+        scan_r($1, &block)
+        yield [:STRING, '\\{']
+        scan_r($2, &block)
+        return
+
+      # explicit escape by \{!...}
+      when /\A([^\\]*)\\\{!([^}]+)\}(.*)\z/m
+        scan_r($1, &block)
+        yield [:STRING, $2]
+        scan_r($3, &block)
+        return
+
+      # macro \{command rest}
+      when /\A([^\\]*)\\\{(\w+)\s*([^}]*)\}(.*)\z/m
+        scan_r($1, &block)
+        yield [:MACRO, [$2, $3]]
+        scan_r($4, &block)
+        return
+      
+      # URL is piror to wikiname
+      when /\A(|.*[^\w])(#{URL})(.*)\z/m
+        scan_r($1, &block)
+        yield [:URL, $2]
+        scan_r($4, &block)    # not $3 since URL itself has (...)
+        return
+
+      when /\A(.*)#{w}(.*)\z/m
+        scan_r($1, &block)
+        yield [:WIKINAME, w]
+        scan_r($2, &block)
+        return
+      end
+    end
+    yield [:STRING, str]
+  end
+
+---- footer

data/lib/juli/macro.rb

@@ -0,0 +1,39 @@
+module Juli
+  module Macro
+    class Base
+      include Juli::Util
+
+      # called on 'juli init' to generate config sample template.
+      def self.conf_template
+        ''
+      end
+
+      # called when juli(1) starts.
+      def initialize
+      end
+
+      # called on setting up conf to set default key=val
+      def set_conf_default(conf)
+      end
+
+      # called on each parsed document
+      def on_root(file, root, visitor = nil)
+      end
+
+      # called on each macro as "\{macro_name args...}" in text.
+      # String should be returned.
+      def run(*args)
+        ''
+      end
+
+      # called at final on each parsed document
+      def after_root(file, root)
+      end
+
+    end
+
+    Dir.glob(File.join(File.dirname(__FILE__), 'macro/*.rb')){|m|
+      require File.join('juli/macro', File.basename(m))
+    }
+  end
+end