elisp2any 0.0.6 → 0.0.7

data/lib/elisp2any/blanklines.rb

@@ -1,20 +0,0 @@
-require "forwardable"
-
-module Elisp2any
-  class Blanklines
-    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)
-    end
-
-    def initialize(count) # :nodoc:
-      @count = count
-    end
-
-    extend Forwardable # :nodoc:
-    def_delegator :@count, :to_i
-  end
-end

data/lib/elisp2any/code.rb

@@ -1,49 +0,0 @@
-require "forwardable"
-require "elisp2any/paragraph"
-require "elisp2any/blanklines"
-require "elisp2any/section"
-
-module Elisp2any
-  class Code
-    def self.scan(scanner)
-      pos = scanner.pos
-      heading = Elisp2any.scan_top_heading(scanner) or return
-      unless heading == "Code:"
-        scanner.pos = pos
-        return
-      end
-      Blanklines.scan(scanner) # optional
-      paragraphs = []
-      while (par = Paragraph.scan(scanner))
-        paragraphs << par
-        Blanklines.scan(scanner) # optional
-      end
-      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(blocks)
-    end
-
-    def initialize(blocks)
-      @blocks = blocks
-    end
-
-    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

@@ -1,56 +0,0 @@
-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

@@ -1,19 +0,0 @@
-module Elisp2any
-  class Comment
-    attr_reader :colons, :content, :padding
-
-    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])
-    end
-
-    def initialize(colons:, content:, padding:)
-      @colons = colons
-      @content = content
-      @padding = padding
-    end
-  end
-end

data/lib/elisp2any/commentary.rb

@@ -1,32 +0,0 @@
-require "forwardable"
-require "elisp2any/paragraph"
-require "elisp2any/blanklines"
-
-module Elisp2any
-  class Commentary
-    def self.scan(scanner)
-      pos = scanner.pos
-      heading = Elisp2any.scan_top_heading(scanner) or return
-      unless heading == "Commentary:"
-        scanner.pos = pos
-        return
-      end
-      Blanklines.scan(scanner) # optional
-      paragraphs = []
-      while (par = Paragraph.scan(scanner))
-        paragraphs << par
-        Blanklines.scan(scanner) # optional
-      end
-      new(paragraphs)
-    end
-
-    def initialize(paragraphs)
-      @paragraphs = paragraphs
-    end
-
-    extend Forwardable # :nodoc:
-    def_delegators :@paragraphs, :each, :size
-
-    include Enumerable
-  end
-end

data/lib/elisp2any/expression.rb

@@ -1,90 +0,0 @@
-require "strscan"
-
-module Elisp2any
-  class Expression
-    def self.scan(scanner)
-      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)
-      @content = content
-    end
-  end
-end

data/lib/elisp2any/footer_line.rb

@@ -1,28 +0,0 @@
-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,80 +0,0 @@
-require "elisp2any/comment"
-require "elisp2any/expression"
-
-module Elisp2any
-  class HeaderLine
-    attr_reader :filename, :description, :variables
-
-    def self.scan(scanner)
-      scanner = StringScanner.new(scanner) unless scanner.respond_to?(:pos)
-      pos = scanner.pos
-      unless (heading = Elisp2any.scan_top_heading(scanner))
-        scanner.pos = pos
-        return
-      end
-      cscanner = StringScanner.new(heading)
-      unless (filename = Elisp2any.scan_filename(cscanner))
-        scanner.pos = pos
-        return
-      end
-      unless cscanner.skip(/ +--- +/)
-        scanner.pos = pos
-        return
-      end
-      description = +""
-      variables = nil
-      until cscanner.eos?
-        if (variables = scan_variables(cscanner)) # nop
-          break
-        else
-          description << cscanner.getch
-        end
-      end
-      if description.empty?
-        scanner.pos = pos
-        return
-      end
-      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
-      @variables = variables
-    end
-  end
-end

data/lib/elisp2any/heading.rb

@@ -1,68 +0,0 @@
-require 'strscan'
-require 'forwardable'
-
-module Elisp2any
-  class Heading
-    attr_reader :level
-    attr_accessor :content
-
-    def self.scan(scanner)
-      pos = scanner.pos
-      comment = Comment.scan(scanner) or return
-      unless comment.colons >= 3
-        scanner.pos = pos
-        return
-      end
-      new(:TODO, comment.colons - 3,
-          comment.content # do not scan as text at this point
-         )
-    end
-
-    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
-      @content = content
-    end
-
-    # Returns nil if failed
-    def name_and_synopsis # :nodoc:
-      scanner = StringScanner.new(@content)
-      name = scanner.scan_until(/\.el/) or return
-      name = name[nil...-3] or return
-      scanner.skip(/\s+---\s+/) or return
-      scanner.skip(/(?<synopsis>.+?)(:?\s+-\*- .+? -\*-)?\Z/) or return
-      synopsis = scanner[:synopsis]
-      return name, synopsis
-    end
-
-    def commentary? # :nodoc:
-      @level == 1 && @content == 'Commentary:'
-    end
-
-    def code? # :nodoc:
-      @level == 1 && @content == 'Code:'
-    end
-
-    def final_name # :nodoc:
-      @content.match(/\A(?<name>.+?)\.el ends here\Z/)[:name]
-    end
-
-    extend Forwardable # :nodoc:
-    def_delegator :@level, :<=>
-  end
-end

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

@@ -1,23 +0,0 @@
-<!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 %></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

@@ -1,22 +0,0 @@
-<!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

@@ -1,149 +0,0 @@
-require 'erb'
-require 'forwardable'
-require 'cgi/util'
-require_relative 'inline_code'
-require_relative 'heading'
-require_relative 'paragraph'
-require_relative 'codeblock'
-
-module Elisp2any
-  class HTMLRenderer
-    def initialize(file, css: nil, mode:)
-      @file = file
-      @css = css || "https://unpkg.com/mvp.css"
-      @mode = mode
-    end
-
-    # 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
-
-    def render_paragraph(paragraph)
-      html = ''
-      paragraph.each do |line|
-        line.each do |chunk|
-          case chunk
-          in InlineCode
-            html << "<code>#{h(chunk.content)}</code>"
-          in String
-            html << h(chunk)
-          in { code: }
-            html << "<code>#{h(code)}</code>"
-          else
-            raise Error, chunk.inspect
-          end
-        end
-      end
-      html
-    end
-
-    # TODO: remove level
-    def render_block(block, level: nil)
-      html = ''
-      case block
-      when Heading
-        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
-        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
-
-    def erb_render(path)
-      source = ::File.read(::File.join(__dir__, 'html_renderer', path))
-      ERB.new(source).result(binding)
-    end
-
-    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, :header_line
-  end
-end

data/lib/elisp2any/inline_code.rb

@@ -1,10 +0,0 @@
-module Elisp2any
-  # TODO: delete
-  class InlineCode
-    attr_reader :content
-
-    def initialize(content)
-      @content = content
-    end
-  end
-end