elisp2any 0.0.4 → 0.0.6

data/lib/elisp2any/commentary.rb

@@ -1,15 +1,13 @@
-require "elisp2any/top_heading"
+require "forwardable"
 require "elisp2any/paragraph"
 require "elisp2any/blanklines"
 
 module Elisp2any
   class Commentary
-    attr_reader :paragraphs
-
     def self.scan(scanner)
       pos = scanner.pos
-      heading = TopHeading.scan(scanner) or return
-      unless heading.content == "Commentary:"
+      heading = Elisp2any.scan_top_heading(scanner) or return
+      unless heading == "Commentary:"
         scanner.pos = pos
         return
       end
@@ -19,11 +17,16 @@ module Elisp2any
         paragraphs << par
         Blanklines.scan(scanner) # optional
       end
-      new(paragraphs:)
+      new(paragraphs)
     end
 
-    def initialize(paragraphs:)
+    def initialize(paragraphs)
       @paragraphs = paragraphs
     end
+
+    extend Forwardable # :nodoc:
+    def_delegators :@paragraphs, :each, :size
+
+    include Enumerable
   end
 end

data/lib/elisp2any/expression.rb

@@ -1,13 +1,89 @@
+require "strscan"
+
 module Elisp2any
   class Expression
-    attr_reader :content
-
     def self.scan(scanner)
-      content = scanner.scan(/t\b/) or return
-      new(content:)
+      scanner = StringScanner.new(scanner) unless scanner.respond_to?(:skip)
+      if scanner.skip("(")
+        exps = []
+        while (exp = scan(scanner))
+          exps << exp
+          spaces = scanner.scan(/[ \n]+/)
+          exps << spaces if spaces
+        end
+        scanner.skip(")") or raise Error, scanner.inspect
+        new(exps)
+      elsif scanner.skip("'")
+        exp = scan(scanner) or raise Error, scanner.inspect
+        new({ quoted: exp })
+      elsif scanner.skip("\"")
+        content = +""
+        while !scanner.eos? && !scanner.match?("\\") && !scanner.match?('"')
+          content << scanner.getch
+        end
+        scanner.skip('"') or raise Error, scanner.inspect
+        new(content)
+      elsif scanner.skip("#'")
+        exp = scan(scanner) or raise Error, scanner.inspect
+        new({ function: exp })
+      else
+        name = scanner.scan(/[a-z0-9_?.:-]+/) or return
+        new(name.to_sym)
+      end
+    end
+
+    def source
+      case @content
+      in { quoted: }
+        "'#{self.class.source(quoted)}"
+      in String
+        @content
+      in { function: }
+        "#'#{self.class.source(function)}"
+      in Array
+        result = +"("
+        @content.each { |exp| result << self.class.source(exp) }
+        "#{result})"
+      in Symbol
+        @content.to_s
+      end
+    end
+
+    def self.source(arg)
+      case arg
+      in Symbol
+        arg.to_s
+      in Array
+        result = +"("
+        arg.sum { |ele| result << source(ele) }
+        "#{result})"
+      in Expression
+        arg.source
+      in String
+        arg
+      else
+        raise arg.inspect
+      end
+    end
+
+    def deconstruct_keys(*keys)
+      result = {}
+      keys => [keys]
+      keys.each do |key|
+        case key
+        in :content
+          result[:content] = @content
+        else # nop
+        end
+      end
+      result
+    end
+
+    def deconstruct
+      [*@content]
     end
 
-    def initialize(content:)
+    def initialize(content)
       @content = content
     end
   end

data/lib/elisp2any/footer_line.rb

@@ -0,0 +1,28 @@
+require "forwardable"
+
+module Elisp2any
+  class FooterLine
+    def self.scan(scanner)
+      scanner = StringScanner.new(scanner) unless scanner.respond_to?(:pos)
+      pos = scanner.pos
+      heading = Elisp2any.scan_top_heading(scanner) or return
+      cscanner = StringScanner.new(heading)
+      unless (filename = Elisp2any.scan_filename(cscanner))
+        scanner.pos = pos
+        return
+      end
+      unless cscanner.skip(/ ends here\n?/)
+        scanner.pos = pos
+        return
+      end
+      new(filename)
+    end
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    extend Forwardable # :nodoc:
+    def_delegator :@filename, :==
+  end
+end

data/lib/elisp2any/header_line.rb

@@ -1,6 +1,5 @@
 require "elisp2any/comment"
-require "elisp2any/filename"
-require "elisp2any/header_line_variables"
+require "elisp2any/expression"
 
 module Elisp2any
   class HeaderLine
@@ -9,12 +8,12 @@ module Elisp2any
     def self.scan(scanner)
       scanner = StringScanner.new(scanner) unless scanner.respond_to?(:pos)
       pos = scanner.pos
-      unless (heading = TopHeading.scan(scanner))
+      unless (heading = Elisp2any.scan_top_heading(scanner))
         scanner.pos = pos
         return
       end
-      cscanner = StringScanner.new(heading.content)
-      unless (filename = Filename.scan(cscanner))
+      cscanner = StringScanner.new(heading)
+      unless (filename = Elisp2any.scan_filename(cscanner))
         scanner.pos = pos
         return
       end
@@ -25,7 +24,7 @@ module Elisp2any
       description = +""
       variables = nil
       until cscanner.eos?
-        if (variables = HeaderLineVariables.scan(cscanner)) # nop
+        if (variables = scan_variables(cscanner)) # nop
           break
         else
           description << cscanner.getch
@@ -35,9 +34,43 @@ module Elisp2any
         scanner.pos = pos
         return
       end
-      new(filename: filename.content, description:, variables: variables.variables)
+      new(filename:, description:, variables:)
     end
 
+    def self.scan_variables(scanner)
+      scanner = StringScanner.new(scanner) unless scanner.respond_to?(:pos)
+      scanner.skip(/ *-[*]- +/) or return
+      variables = {}
+      until scanner.skip(/ +-[*]- */)
+        if scanner.eos?
+          raise Error, "unexpected end"
+        elsif (assign = scan_assignments(scanner))
+          variables[assign[:variable]] = assign[:expression]
+        elsif scanner.skip(";")
+          break
+        else
+          raise Error, scanner.inspect
+        end
+      end
+      variables
+    end
+    private_class_method :scan_variables
+
+    def self.scan_assignments(scanner)
+      pos = scanner.pos
+      variable = Elisp2any.scan_variable(scanner) or return
+      unless scanner.skip(/ *: */)
+        scanner.pos = pos
+        return
+      end
+      unless (expression = Expression.scan(scanner))
+        scanner.pos = pos
+        return
+      end
+      { variable:, expression: }
+    end
+    private_class_method :scan_assignments
+
     def initialize(filename:, description:, variables:)
       @filename = filename
       @description = description

data/lib/elisp2any/heading.rb

@@ -3,7 +3,8 @@ require 'forwardable'
 
 module Elisp2any
   class Heading
-    attr_reader :level, :content
+    attr_reader :level
+    attr_accessor :content
 
     def self.scan(scanner)
       pos = scanner.pos
@@ -12,10 +13,26 @@ module Elisp2any
         scanner.pos = pos
         return
       end
-      new(:TODO, comment.colons - 3, comment.content)
+      new(:TODO, comment.colons - 3,
+          comment.content # do not scan as text at this point
+         )
     end
 
-    # TODO
+    def deconstruct_keys(*keys)
+      result = {}
+      keys => [keys]
+      keys.each do |key|
+        case key
+        in :level
+          result[:level] = @level
+        in :content
+          result[:content] = @content
+        end
+      end
+      result
+    end
+
+    # TODO: delete node.  Use kwargs.
     def initialize(node, level, content) # :nodoc:
       @node = node
       @level = level
@@ -45,7 +62,7 @@ module Elisp2any
       @content.match(/\A(?<name>.+?)\.el ends here\Z/)[:name]
     end
 
-    extend Forwardable
+    extend Forwardable # :nodoc:
     def_delegator :@level, :<=>
   end
 end

data/lib/elisp2any/html_renderer/index.html.erb

@@ -1,23 +1,23 @@
 <!doctype html>
 <html>
     <head>
-	<meta charset="UTF-8">
-	<meta name="viewport" content="width=device-width, initial-scale=1">
-	<title><%= name %></title>
-	<link rel="stylesheet" href="<%= @css %>">
+	    <meta charset="UTF-8">
+	    <meta name="viewport" content="width=device-width, initial-scale=1">
+	    <title><%= name %></title>
+	    <link rel="stylesheet" href="<%= @css %>">
     </head>
     <body>
-	<main>
-	    <h1><%= name %></h1>
-	    <p><%= synopsis %></p>
-	    <h2>Commentary</h2>
-	    <% commentary.each do |paragraph| %>
-		<p><%= render_paragraph(paragraph) %></p>
-	    <% end %>
-	    <h2>Code</h2>
-	    <% code.each do |block| %>
-		<%= render_block(block, level: 2) %>
-	    <% end %>
-	</main>
+	    <main>
+	        <h1><%= name %></h1>
+	        <p><%= synopsis %></p>
+	        <h2>Commentary</h2>
+	        <% commentary.each do |paragraph| %>
+		        <p><%= render_paragraph(paragraph) %></p>
+	        <% end %>
+	        <h2>Code</h2>
+	        <% code.each do |block| %>
+		        <%= render_block(block, level: 2) %>
+	        <% end %>
+	    </main>
     </body>
 </html>

data/lib/elisp2any/html_renderer.erb

@@ -0,0 +1,22 @@
+<!doctype html>
+<html>
+    <head>
+	    <meta charset="UTF-8">
+	    <meta name="viewport" content="width=device-width, initial-scale=1">
+	    <title><%= name %></title>
+	    <link rel="stylesheet" href="<%= @css %>">
+    </head>
+    <body>
+	    <main>
+	        <h1><%= name %><small> &mdash; <%= synopsis %></small></h1>
+            <div style="text-align:right"><%= render(header_line.variables) %></div>
+	        <% commentary.each do |paragraph| %>
+		        <%= render(paragraph) %>
+	        <% end %>
+	        <h2>Code</h2>
+	        <% self.code.each do |block| %>
+		        <%= render(block) %>
+	        <% end %>
+	    </main>
+    </body>
+</html>

data/lib/elisp2any/html_renderer.rb

@@ -4,17 +4,66 @@ require 'cgi/util'
 require_relative 'inline_code'
 require_relative 'heading'
 require_relative 'paragraph'
-require_relative 'code_block'
+require_relative 'codeblock'
 
 module Elisp2any
   class HTMLRenderer
-    def initialize(file, css: nil)
+    def initialize(file, css: nil, mode:)
       @file = file
       @css = css || "https://unpkg.com/mvp.css"
+      @mode = mode
     end
 
-    def render
-      erb_render('index.html.erb')
+    # Write gradually?
+    def render(node = nil)
+      if node
+        case node
+        in Paragraph
+          par = node.sum(+"") { |line| render(line) }
+          "<p>#{par}</p>"
+        in Line
+          begin
+            node.sum(+"") { |chunk| render(chunk) }
+          rescue => e
+            warn node.inspect
+            raise e
+          end
+        in String
+          h(node)
+        in [] # huh?  nop.
+        in Section
+          result = render(node.heading)
+          node.blocks.each { |blo| result << render(blo) }
+          node.sections.each { |sec| result << render(sec) }
+          result
+        in Heading[level:, content:]
+          lev = level + 2
+          "<h#{lev}>#{render(content)}</h#{lev}>"
+        in Codeblock
+          "<pre><code>#{h(node.source.chomp)}</code></pre>"
+        in { code: }
+          "<code>#{h(code)}</code>"
+        in Hash
+          result = node.sum(+"<dl>") do |key, value|
+            "<dt>#{render(key)}</dt><dd>#{render(value)}</dd>"
+          end
+          "#{result}</dl>"
+        in Expression
+          "<code>#{h(node.source)}</code>"
+        in Text
+          node.sum(+"") { |ele| render(ele) }
+        else
+          raise Error, node.inspect
+        end
+      else
+        case @mode
+        in :old
+          erb_render('index.html.erb')
+        in :new
+          source = ::File.read(::File.join(__dir__, 'html_renderer.erb'))
+          ERB.new(source).result(binding)
+        end
+      end
     end
 
     private
@@ -24,26 +73,48 @@ module Elisp2any
       paragraph.each do |line|
         line.each do |chunk|
           case chunk
-          when InlineCode
+          in InlineCode
             html << "<code>#{h(chunk.content)}</code>"
-          when String
+          in String
             html << h(chunk)
+          in { code: }
+            html << "<code>#{h(code)}</code>"
+          else
+            raise Error, chunk.inspect
           end
         end
       end
       html
     end
 
-    def render_block(block, level:)
+    # TODO: remove level
+    def render_block(block, level: nil)
       html = ''
       case block
       when Heading
-        name = "h#{level + block.level - 1}"
+        lev = level
+        if level
+          lev = level + block.level - 1
+        else
+          lev = block.level
+        end
+        name = "h#{lev}"
         html << "<#{name}>#{h(block.content)}</#{name}>"
       when Paragraph
         html << render_paragraph(block)
-      when CodeBlock
+      when Codeblock
         html << "<pre><code>#{h(block.content)}</code></pre>"
+      when [] # huh?  nop
+      when Section
+        render_block(block.heading)
+        block.blocks.each do |blo|
+          render_block(blo)
+        end
+        block.sections.each do |sec|
+          render_block(sec)
+        end
+      else
+        raise Error, block.inspect
       end
       html
     end
@@ -53,11 +124,26 @@ module Elisp2any
       ERB.new(source).result(binding)
     end
 
-    def h(string)
-      CGI.escape_html(string)
+    def h(arg)
+      case arg
+      in String
+        CGI.escape_html(arg)
+      in Array
+        arg.map do |ele|
+          h(ele)
+        end.join
+      in Symbol
+        h(arg.to_s)
+      in Expression
+        h(arg.source)
+      in Integer
+        h(arg.to_s)
+      in Aside
+        h(arg.content)
+      end
     end
 
     extend Forwardable # :nodoc:
-    def_delegators :@file, :name, :synopsis, :commentary, :code
+    def_delegators :@file, :name, :synopsis, :commentary, :code, :header_line
   end
 end

data/lib/elisp2any/inline_code.rb

@@ -1,4 +1,5 @@
 module Elisp2any
+  # TODO: delete
   class InlineCode
     attr_reader :content
 

data/lib/elisp2any/line.rb

@@ -2,6 +2,7 @@ require 'strscan'
 require 'forwardable'
 require_relative 'inline_code'
 require "elisp2any/comment"
+require "elisp2any/text"
 
 module Elisp2any
   class Line
@@ -15,7 +16,8 @@ module Elisp2any
       unless comment.padding[0] == " "
         raise Error, "line comment should have a whitespace padding"
       end
-      new(["#{comment.padding[1..]}#{comment.content}"])
+      content = "#{comment.padding[1..]}#{comment.content}"
+      new(Text.scan(content).to_a)
     end
 
     def initialize(chunks) # :nodoc:
@@ -42,8 +44,8 @@ module Elisp2any
       new(chunks)
     end
 
-    extend Forwardable
-    def_delegators :@chunks, :each
+    extend Forwardable # :nodoc:
+    def_delegators :@chunks, :each, :deconstruct
 
     include Enumerable
   end

data/lib/elisp2any/paragraph.rb

@@ -3,8 +3,6 @@ require "elisp2any/line"
 
 module Elisp2any
   class Paragraph
-    attr_reader :lines
-
     def self.scan(scanner)
       scanner = StringScanner.new(scanner) unless scanner.respond_to?(:skip)
       lines = []
@@ -25,12 +23,13 @@ module Elisp2any
       @end_row = end_row
     end
 
+    # TODO: delete
     def code?
       false
     end
 
-    extend Forwardable
-    def_delegators :@lines, :empty?, :clear, :<<, :each
+    extend Forwardable # :nodoc:
+    def_delegators :@lines, :empty?, :clear, :<<, :each, :deconstruct, :size
     def_delegators :@node, :adjucent?
 
     include Enumerable

data/lib/elisp2any/section.rb

@@ -1,25 +1,49 @@
+require "forwardable"
 require "elisp2any/heading"
-require "elisp2any/paragraph"
 require "elisp2any/blanklines"
+require "elisp2any/text"
 
 module Elisp2any
   class Section
-    attr_reader :heading
+    attr_reader :heading,
+                # TODO: gather blocks and sections
+                :blocks,
+                :sections
 
     def self.scan(scanner)
       heading = Heading.scan(scanner) or return
+      heading.content = Text.scan(heading.content)
       Blanklines.scan(scanner) # optional
-      paragraphs = []
-      while (par = Paragraph.scan(scanner))
-        paragraphs << par
+      blocks = []
+      while (blo = Paragraph.scan(scanner) || Codeblock.scan(scanner))
+        blocks << blo
         Blanklines.scan(scanner) # optional
       end
-      new(heading:, paragraphs:)
+      pos = scanner.pos
+      sections = []
+      while (section = scan(scanner))
+        if section.level == heading.level + 1
+          sections << section
+          pos = scanner.pos
+        elsif section.level >= heading.level + 2
+          raise Error, "too demoted heading"
+        else
+          scanner.pos = pos
+          break
+        end
+      end
+      new(heading:, blocks:, sections:)
     end
 
-    def initialize(heading:, paragraphs:)
+    def initialize(heading:, blocks:, sections:)
       @heading = heading
-      @paragraphs = paragraphs
+      @blocks = blocks
+      @sections = sections
     end
+
+    alias paragraphs blocks # TODO: delete
+
+    extend Forwardable # :nodoc:
+    def_delegator :@heading, :level
   end
 end

data/lib/elisp2any/text.rb

@@ -0,0 +1,33 @@
+require "forwardable"
+
+module Elisp2any
+  class Text
+    def self.scan(scanner)
+      scanner = StringScanner.new(scanner) unless scanner.respond_to?(:skip)
+      tokens = []
+      until scanner.eos?
+        if scanner.skip(/`(?<content>[^']+)'/)
+          tokens << { code: scanner[:content] }
+        else
+          char = scanner.getch
+          case tokens
+          in [*, String => last]
+            last << char
+          else
+            tokens << char
+          end
+        end
+      end
+      new(tokens)
+    end
+
+    def initialize(tokens)
+      @tokens = tokens
+    end
+
+    extend Forwardable # :nodoc:
+    def_delegators :@tokens, :each, :deconstruct
+
+    include Enumerable
+  end
+end

data/lib/elisp2any/version.rb

@@ -1,3 +1,4 @@
 module Elisp2any
-  VERSION = '0.0.4'
+  # Version of this library.
+  VERSION = '0.0.6'
 end

data/lib/elisp2any.rb

@@ -1,8 +1,26 @@
 require_relative 'elisp2any/version'
-require_relative 'elisp2any/file'
+require_relative 'elisp2any/heading'
 
 module Elisp2any
   autoload :HeaderLine, "elisp2any/header_line.rb"
   autoload :Blanklines, "elisp2any/blanklines.rb"
   Error = Class.new(StandardError)
+
+  def self.scan_filename(scanner) # :nodoc:
+    scanner.scan(/[a-z]+[.]el\b/)
+  end
+
+  def self.scan_variable(scanner) # :nodoc:
+    scanner.scan(/[a-z-]+\b/)
+  end
+
+  def self.scan_top_heading(scanner) # :nodoc:
+    pos = scanner.pos
+    heading = Heading.scan(scanner) or return
+    unless heading.level.zero?
+      scanner.pos = pos
+      return
+    end
+    heading.content
+  end
 end