elisp2any 0.0.4 → 0.0.6

data/README.md

@@ -15,12 +15,22 @@ $ elisp2any --input /path/to/input/file --output /path/to/output/file
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies.
-Then, run `rake test` to run the tests.
-You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Two paragraph types:
 
-To install this gem onto your local machine, run `bundle exec rake install`.
-To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+```emacs-lisp
+;; This is a major one.
+
+;; This is another major one (1), and a minor one.
+;;
+;; This is still (1) but another minor one.
+```
+
+Heading levels:
+
+```emacs-lisp
+;;; Level 2
+;;;; Level 3
+```
 
 ## Contributing
 

data/Rakefile

@@ -7,49 +7,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-default_tasks = %i[test]
-
-rubocop = true
-
-begin
-  require 'rubocop/rake_task'
-rescue LoadError
-  rubocop = false
-end
-
-if rubocop
-  RuboCop::RakeTask.new
-  default_tasks << :rubocop
-end
-
-task default: default_tasks
-
-require 'rdoc/task'
-RDoc::Task.new do |rdoc|
-  readme = 'README.md'
-  rdoc.main = readme
-  rdoc.rdoc_files.include(readme, 'lib/**/*.rb')
-end
-
-desc 'start API document server'
-task :serve_api do
-  serve('html')
-end
-
-desc 'generate type signatures'
-task :sig do
-  sh 'typeprof', *Dir['lib/**/*.rb'], 'sig/elisp2any.rbs', '-o', 'sig/elisp2any.gen.rbs'
-end
-
-desc 'start HTML fixture server'
-task :serve_fixture do
-  serve('fixtures/init')
-end
-
-def serve(path)
-  sh 'ruby', '-run', '-e', 'httpd', path
-end
-
-file 'fixtures/init/adoc/index.html' => 'fixtures/init/index.adoc' do |t|
-  sh 'asciidoctor', t.source, '--out-file', t.name
-end
+task default: :test

data/exe/elisp2any

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/elisp2any'
-require_relative '../lib/elisp2any/html_renderer'
 require 'optparse'
 
+$LOAD_PATH << File.join(__dir__, "../lib")
+require 'elisp'
+
 input = $stdin
 output = $stdout
 css = nil
@@ -22,6 +23,4 @@ OptionParser.new do |parser|
   end
 end.parse!
 
-file = Elisp2any::File.parse(input)
-renderer = Elisp2any::HTMLRenderer.new(file, css:)
-output.write(renderer.render)
+Elisp.parse(input).write(output, css:)

data/lib/elisp/comment.rb

@@ -0,0 +1,93 @@
+class Elisp::Comment
+  def initialize(content)
+    @content = content
+  end
+
+  def <<(content)
+    @content << "\n#{content}"
+  end
+
+  def to_minor_para
+    Elisp::MinorPara.new(@content)
+  end
+
+  def html
+    self.class.parse(@content)
+  end
+end
+
+class Elisp::DocStringParser
+  URI_PATTERN = URI.regexp
+  URI_PATTERN_WITH_ANGLES = /[<](?<uri>#{ URI_PATTERN })[>]/
+  EMAIL = Regexp.new(URI::MailTo::EMAIL_REGEXP.to_s
+                       .sub(/\A[(][?]-mix:\\A/, "(?-mix:")
+                       .sub(/\\z[)]\z/, ")"))
+  EMAIL_WITH_ANGLES = /[<](?<address>#{ EMAIL })[>]/
+
+  def initialize(source)
+    @scanner = StringScanner.new(source)
+  end
+
+  def html
+    result = +""
+    normal = +""
+    until @scanner.eos?
+      if @scanner.skip(/[`](?<code>[A-Za-z!.-]+)[']/)
+        result << normal
+        normal.clear
+        code = CGI.escape_html(@scanner[:code])
+        result << "<code>#{code}</code>"
+        normal.clear
+      elsif @scanner.skip(/\\\\=(?<quote>['`])/)
+        normal << @scanner[:quote]
+      elsif (uri = scan_http_uri)
+        result << normal
+        normal.clear
+        result << html_url(uri)
+      elsif (address = scan_email)
+        result << normal
+        normal.clear
+        uri = CGI.escape(address)
+        address = CGI.escape_html(address)
+        result << %(<a href="mailto:#{uri}">#{address}</a>)
+      else
+        normal << @scanner.getch
+      end
+    end
+    result << normal
+    normal.clear
+    result
+  end
+
+  def scan_email
+    if (address = @scanner.scan(EMAIL))
+      address
+    elsif @scanner.skip(EMAIL_WITH_ANGLES)
+      @scanner[:address]
+    else
+      return
+    end
+  end
+
+  def scan_http_uri
+    if (uri = @scanner.scan(URI_PATTERN))
+    elsif @scanner.skip(URI_PATTERN_WITH_ANGLES)
+      uri = @scanner[:uri]
+    else
+      return
+    end
+    uri = URI(uri)
+    unless uri.is_a?(URI::HTTP)
+      @scanner.unscan
+      return
+    end
+    uri
+  end
+
+  def html_url(url)
+    url = url.to_s
+    ref = CGI.escape(url)
+    label = CGI.escape_html(url)
+    %(<a class="pure-url" href="#{ref}">#{label}</a>)
+  end
+end

data/lib/elisp/parser.rb

@@ -0,0 +1,188 @@
+class Elisp::Parser
+  HEADER_LINE = %r{
+    ;;;[ ]
+    (?<title>[a-z]+[.]el)[ ]---[ ](?<desc>.*?)
+    (?:[ ]+-[*]-[ ](?<vars>lexical-binding:[ ]?t);?[ ]-[*]-)?
+    \n+
+  }x
+  COMMENT = / *;; (?<comment>.*)\n/
+  CODE = %r{
+    (?<content>
+      (?:
+        [A-Za-z0-9&,.:=?_#'`<>()\[\]\t +*/-]
+        | [?]\\.
+        | "(?:[^\\"]|\\(?:.|\n))*"
+      )+?
+      (?:[ ]*;.*)?
+      | ;;;[#][#][#]autoload.*
+    )
+    \n
+  }x
+  BLANKLINES = /\n+/
+  CODE_OR_BLANKLINES = Regexp.union(CODE, BLANKLINES)
+  DEFAULT_CSS = <<~END_CSS
+    <style>
+      :root {
+        --sidebar-width: 200px;
+      }
+      body {
+        display: flex;
+      }
+      main {
+        max-width: 80rem;
+        margin: auto auto auto var(--sidebar-width);
+        padding-left: 0.5rem;
+        border-box: box-sizing;
+      }
+      .sidebar {
+        padding-right: 0.5rem;
+        width: var(--sidebar-width);
+        position: fixed;
+        boxed-sizing: border-box;
+        overflow-y: auto;
+        height: 100%;
+      }
+      .sidebar details ul {
+        position: relative;
+        left: -1.5rem;
+      }
+      .description {
+        font-style: italic;
+      }
+      pre {
+        font-family: serif;
+      }
+      pre[class="code"] {
+        border-left: solid;
+        padding-left: 0.5rem;
+        white-space: pre-wrap;
+      }
+    </style>
+  END_CSS
+  HEADING = %r{
+    ;;;(?<level>;*)[ ](?<title>.+)\n
+    (?:(?:;;)?\n)*
+  }x
+
+  def initialize(input)
+    @scanner = StringScanner.new(input.read)
+    @state = :start
+    @nodes = []
+  end
+
+  def parse
+    until @scanner.eos?
+
+      if @state == :start && @scanner.skip(HEADER_LINE)
+        @nodes << Elisp::Heading.new(@scanner[:title], level: 1)
+        @nodes << Elisp::Desc.new(@scanner[:desc])
+        @nodes << Elisp::Variables.new(@scanner[:vars])
+        @state = :after_header_line
+
+      elsif [:after_header_line,
+             :after_major_para,
+             :after_minor_para,
+             :after_code,
+             :after_page_delimiter,
+             :after_heading].include?(@state) &&
+            @scanner.skip(HEADING)
+        level = @scanner[:level].size
+        title = @scanner[:title]
+        if level.zero?
+          if ["Commentary:", "Code:"].include?(title)
+            title.chop!
+          elsif title.match?(/[a-z]+[.]el ends here/)
+            next  # validate file name?
+          end
+        end
+        @nodes << Elisp::Heading.new(title, level: level + 2)
+        @state = :after_heading
+
+      elsif [:after_heading,
+             :after_major_para,
+             :after_minor_para,
+             :after_code,
+             :after_header_line].include?(@state) &&
+            @scanner.skip(COMMENT)
+        @nodes << Elisp::Comment.new(@scanner[:comment])
+        @state = :after_comment
+
+      elsif @state == :after_comment && @scanner.skip(";;\n")
+        @nodes[-1] = @nodes.last.to_minor_para
+        @state = :after_minor_para
+
+      elsif @state == :after_comment && @scanner.skip(COMMENT)
+        @nodes.last << @scanner[:comment]
+
+      elsif @state == :after_comment && @scanner.skip(BLANKLINES)
+        make_major_para
+        @state = :after_major_para
+
+      elsif [:after_major_para, :after_page_delimiter, :after_heading].include?(@state) &&
+            @scanner.skip(CODE)
+        @nodes << Elisp::Code.new(@scanner[:content])
+        @state = :after_code
+
+      elsif @state == :after_comment && @scanner.skip(CODE)
+        make_major_para
+        @nodes << Elisp::Code.new(@scanner[:content])
+        @state = :after_code
+
+      elsif @state == :after_code && @scanner.skip(CODE_OR_BLANKLINES)
+        @nodes.last << @scanner[:content]
+
+      elsif @state == :after_code && @scanner.skip(/\f\n+/)
+        @nodes << PageDelimiter.new
+        @state = :after_page_delimiter
+
+      else
+        raise Elisp::Error, <<~MESSAGE
+          parse failed
+          --- rest line (#{@state}) ---
+          #{@scanner.rest.lines.first.inspect}
+          --- scanner ---
+          #{@scanner.inspect}
+        MESSAGE
+      end
+    end
+    self
+  end
+
+  def make_major_para
+    paras = [@nodes.pop.to_minor_para]
+    while (node = @nodes.pop)
+      if node.is_a?(Elisp::MinorPara)
+        paras.unshift(node)
+      else
+        @nodes.push(node)
+        break
+      end
+    end
+    @nodes << Elisp::MajorPara.new(paras)
+  end
+
+  def write(output, css: nil)
+    css = css ? %(<link rel="stylesheet" href="#{CGI.escape(css)}">) : DEFAULT_CSS
+    sidebar = Elisp::Sidebar.new(@nodes.select { |node| node.is_a?(Elisp::Heading) \
+                                                          && node.level >= 2 })
+                .html
+    body = @nodes.map(&:html).join("\n")
+    output.write(<<~END_HTML)
+      <!doctype html>
+      <html>
+        <head>
+          #{css}
+          <meta charset="utf8">
+        </head>
+        <body>
+          <nav class="sidebar">
+            #{sidebar}
+          </nav>
+          <main>
+            #{body}
+          </main>
+        </body>
+      </html>
+    END_HTML
+  end
+end

data/lib/elisp.rb

@@ -0,0 +1,142 @@
+require "strscan"
+require "cgi"
+require "uri"
+
+class Elisp
+  Error = Class.new(StandardError)
+
+  def self.parse(input)
+    Elisp::Parser.new(input).parse
+  end
+end
+
+class Elisp::Sidebar
+  def initialize(headings)
+    @headings = headings
+  end
+
+  def html
+    rest = @headings.dup
+    result = +""
+    while (head = rest.shift)
+      level = head.level
+      subheadings = []
+      while (heading = rest.shift)
+        if heading.level > level
+          subheadings << heading
+        else
+          rest.unshift(heading)
+          break
+        end
+      end
+      sub_sidebar =
+        subheadings.empty? ? nil
+          : (html = self.class.new(subheadings).html
+            "<details open>#{html}</details>")
+      content = CGI.escape_html(head.content)
+      result << <<~END_HTML
+        <li>
+          <a href="##{head.html_id}">#{content}</a>
+          #{sub_sidebar}
+        </li>
+      END_HTML
+    end
+    "<ul>#{result}</ul>"
+  end
+end
+
+class PageDelimiter
+  def html = "<hr>"
+end
+
+class Elisp::Heading
+  attr_reader :level, :content
+
+  def initialize(content, level: 2)
+    @content = content
+    @level = level
+  end
+
+  def html
+    name = "h#{@level}"
+    content = CGI.escape_html(@content)
+    <<~END_HTML
+      <#{name} id="#{html_id}">
+        #{content}
+        <a href="##{html_id}">#</a>
+      </#{name}>
+    END_HTML
+  end
+
+  def html_id
+    content = CGI.escape(@content)
+    "#{@level}-#{content}"
+  end
+end
+
+class Elisp::Desc
+  def initialize(content)
+    @content = content
+  end
+
+  def html
+    content = CGI.escape_html(@content)
+    %(<p class="description">#{content}</p>)
+  end
+end
+
+class Elisp::Variables
+  def initialize(content)
+    @content = content
+  end
+
+  def html
+    content = CGI.escape_html(@content)
+    <<~END_HTML
+      <article>
+        Header line variables:
+        <pre><code>#{content}</code></pre>
+      </article>
+    END_HTML
+  end
+end
+
+class Elisp::MajorPara
+  def initialize(paras)
+    @paras = paras
+  end
+
+  def html
+    paras = @paras.map(&:html).join("\n")
+    "<article>#{paras}</article>"
+  end
+end
+
+class Elisp::MinorPara
+  def initialize(content)
+    @content = content
+  end
+
+  def html
+    content = Elisp::DocStringParser.new(@content).html
+    "<pre>#{content}</pre>"
+  end
+end
+
+class Elisp::Code
+  def initialize(content)
+    @content = content
+  end
+
+  def <<(content)
+    @content << "\n#{content}"
+  end
+
+  def html
+    content = CGI.escape_html(@content)
+    %(<pre class="code"><code>#{content}</code></pre>)
+  end
+end
+
+require_relative "elisp/comment"
+require_relative "elisp/parser"

data/lib/elisp2any/aside.rb

@@ -0,0 +1,23 @@
+require "elisp2any/comment"
+
+module Elisp2any
+  class Aside
+    def self.scan(scanner)
+      pos = scanner.pos
+      com = Comment.scan(scanner) or return
+      unless com.colons == 1
+        scanner.pos = pos
+        return
+      end
+      new(com.content)
+    end
+
+    def source
+      ";#{@content}\n"
+    end
+
+    def initialize(content)
+      @content = content
+    end
+  end
+end

data/lib/elisp2any/blanklines.rb

@@ -1,17 +1,20 @@
+require "forwardable"
+
 module Elisp2any
   class Blanklines
-    attr_reader :count
-
     def self.scan(scanner)
       scanner = StringScanner.new(scanner) unless scanner.respond_to?(:skip)
       count = 0
       count += 1 while !scanner.eos? && scanner.skip(/ *\n/)
       count.zero? and return
-      new(count:)
+      new(count)
     end
 
-    def initialize(count:) # :nodoc:
+    def initialize(count) # :nodoc:
       @count = count
     end
+
+    extend Forwardable # :nodoc:
+    def_delegator :@count, :to_i
   end
 end

data/lib/elisp2any/code.rb

@@ -1,16 +1,14 @@
-require "elisp2any/top_heading"
+require "forwardable"
 require "elisp2any/paragraph"
 require "elisp2any/blanklines"
 require "elisp2any/section"
 
 module Elisp2any
   class Code
-    attr_reader :paragraphs, :sections
-
     def self.scan(scanner)
       pos = scanner.pos
-      heading = TopHeading.scan(scanner) or return
-      unless heading.content == "Code:"
+      heading = Elisp2any.scan_top_heading(scanner) or return
+      unless heading == "Code:"
         scanner.pos = pos
         return
       end
@@ -20,16 +18,32 @@ module Elisp2any
         paragraphs << par
         Blanklines.scan(scanner) # optional
       end
-      section = Section.scan(scanner)
-      unless section.heading.level == 1
-        raise "TODO"
+      blocks = [paragraphs]
+      pos = scanner.pos
+      while (section = Section.scan(scanner))
+        if section.heading.level == 1
+          blocks << section
+          pos = scanner.pos
+        else
+          scanner.pos = pos
+          break
+        end
       end
-      new(paragraphs:, sections: [section])
+      new(blocks)
+    end
+
+    def initialize(blocks)
+      @blocks = blocks
     end
 
-    def initialize(paragraphs:, sections:)
-      @paragraphs = paragraphs
-      @sections = sections
+    def sections
+      @blocks.drop(1)
     end
+
+    extend Forwardable # :nodoc:
+    def_delegator :@blocks, :first, :paragraphs
+    def_delegator :@blocks, :each
+
+    include Enumerable
   end
 end

data/lib/elisp2any/codeblock.rb

@@ -0,0 +1,56 @@
+require "forwardable"
+require "elisp2any/expression"
+require "elisp2any/blanklines"
+require "elisp2any/aside"
+
+module Elisp2any
+  class Codeblock # :nodoc:
+    def self.scan(scanner)
+      scanner = StringScanner.new(scanner) unless scanner.respond_to?(:skip)
+      expressions = []
+      while (exp = Expression.scan(scanner) ||
+                   scanner.scan(/[ \n]+/) ||
+                   Aside.scan(scanner))
+        expressions << exp
+      end
+      expressions.empty? and return
+      Blanklines.scan(scanner) # optional
+      new(:TODO, expressions:)
+    end
+
+    def source
+      @expressions.sum(+"") do |exp|
+        case exp
+        in String
+          exp
+        else
+          exp.source
+        end
+      end
+    end
+
+    # TODO: delete node
+    # TODO: Remove default empty array
+    def initialize(node, expressions: []) # :nodoc:
+      @node = node
+      @expressions = expressions
+    end
+
+    def append(source, end_byte) # :nodoc:
+      @node.append(source, end_byte)
+    end
+
+    def content
+      if @node.respond_to?(:content)
+        @node.content
+      else
+        @expressions
+      end
+    end
+
+    extend Forwardable # :nodoc:
+    def_delegator :@expressions, :each
+
+    include Enumerable
+  end
+end

data/lib/elisp2any/comment.rb

@@ -5,7 +5,9 @@ module Elisp2any
     def self.scan(scanner)
       scanner = StringScanner.new(scanner) unless scanner.respond_to?(:skip)
       scanner.skip(/(?<colons>;+)(?<padding> *)(?<content>.*)\n?/) or return
-      new(colons: scanner[:colons].size, content: scanner[:content], padding: scanner[:padding])
+      new(colons: scanner[:colons].size,
+          content: scanner[:content],
+          padding: scanner[:padding])
     end
 
     def initialize(colons:, content:, padding:)