hamdown_core 0.5.0

data/lib/hamdown_core/ast.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module HamdownCore
+  module Ast
+    module HasChildren
+      def initialize(*)
+        super
+        self.children ||= []
+      end
+
+      def <<(ast)
+        self.children << ast
+      end
+
+      def to_h
+        super.merge(children: children.map(&:to_h))
+      end
+    end
+
+    Root = Struct.new(:children) do
+      include HasChildren
+
+      def to_h
+        super.merge(type: 'root')
+      end
+    end
+
+    Doctype = Struct.new(:doctype, :filename, :lineno) do
+      def to_h
+        super.merge(type: 'doctype')
+      end
+    end
+
+    Element = Struct.new(
+      :children,
+      :tag_name,
+      :static_class,
+      :static_id,
+      :old_attributes,
+      :new_attributes,
+      :oneline_child,
+      :self_closing,
+      :nuke_inner_whitespace,
+      :nuke_outer_whitespace,
+      :object_ref,
+      :filename,
+      :lineno,
+    ) do
+      include HasChildren
+
+      def initialize(*)
+        super
+        self.static_class ||= ''
+        self.static_id ||= ''
+        self.self_closing ||= false
+        self.nuke_inner_whitespace ||= false
+        self.nuke_outer_whitespace ||= false
+      end
+
+      def to_h
+        super.merge(
+          type: 'element',
+          oneline_child: oneline_child && oneline_child.to_h,
+        )
+      end
+
+      # XXX: For compatibility
+      def attributes
+        attrs = old_attributes || ''
+        if new_attributes
+          if attrs.empty?
+            attrs = new_attributes
+          else
+            attrs += ", #{new_attributes}"
+          end
+        end
+        attrs
+      end
+    end
+
+    Script = Struct.new(
+      :children,
+      :script,
+      :keyword,
+      :escape_html,
+      :preserve,
+      :filename,
+      :lineno,
+    ) do
+      include HasChildren
+
+      def initialize(*)
+        super
+        if escape_html.nil?
+          self.escape_html = true
+        end
+        if preserve.nil?
+          self.preserve = false
+        end
+      end
+
+      def to_h
+        super.merge(type: 'script')
+      end
+    end
+
+    SilentScript = Struct.new(:children, :script, :keyword, :filename, :lineno) do
+      include HasChildren
+
+      def to_h
+        super.merge(type: 'silent_script')
+      end
+    end
+
+    HtmlComment = Struct.new(:children, :comment, :conditional, :filename, :lineno) do
+      include HasChildren
+
+      def initialize(*)
+        super
+        self.comment ||= ''
+        self.conditional ||= ''
+      end
+
+      def to_h
+        super.merge(type: 'html_comment')
+      end
+    end
+
+    HamlComment = Struct.new(:children, :filename, :lineno) do
+      include HasChildren
+
+      def to_h
+        super.merge(type: 'haml_comment')
+      end
+    end
+
+    Text = Struct.new(:text, :escape_html, :filename, :lineno) do
+      def initialize(*)
+        super
+        if escape_html.nil?
+          self.escape_html = true
+        end
+      end
+
+      def to_h
+        super.merge(type: 'text')
+      end
+
+      def markdownable?
+        true
+      end
+    end
+
+    class MdHeader < Text; end
+    class MdList < Text; end
+    class MdQuote < Text; end
+    class MdImageTitle < Text; end
+    class MdImage < Text; end
+    class MdLinkTitle < Text; end
+    class MdLink < Text; end
+
+    Filter = Struct.new(:name, :texts, :filename, :lineno) do
+      def initialize(*)
+        super
+        self.texts ||= []
+      end
+
+      def to_h
+        super.merge(type: 'filter')
+      end
+    end
+
+    Empty = Struct.new(:filename, :lineno) do
+      def to_h
+        super.merge(type: 'empty')
+      end
+    end
+  end
+end

data/lib/hamdown_core/cli.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require 'optparse'
+require_relative 'version'
+
+module HamdownCore
+  module Cli
+    def self.call(argv)
+      file_name = OptionParser.new.tap do |parser|
+        parser.version = VERSION
+      end.parse!(argv).first
+
+      if file_name.nil? || file_name.size == 0
+        puts 'Error: No file.'
+        puts 'Use it like: "exe/hamdown_core path_to/file.hd > output.html"'
+        return nil
+      end
+
+      content = File.open(file_name, 'r').read
+      output = Engine.call(content)
+      puts output
+    end
+  end
+end

data/lib/hamdown_core/compiler.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module HamdownCore
+  module Compiler
+    class << self
+      def call(ast_root)
+        strings = []
+        strings = render_strings(ast_root.children, 0)
+        strings.join("\n")
+      end
+
+      private
+
+      # TODO: refactoring
+      def render_strings(ast_nodes, space_deep = 0)
+        strings = []
+        ast_nodes.each do |node|
+          case node
+          when HamdownCore::Ast::Filter
+            str = (' ' * space_deep)
+            str += ":#{node.name}"
+            strings << str
+            node.texts.each do |row|
+              row = (' ' * (space_deep + 2)) + row
+              strings << row
+            end
+          when HamdownCore::Ast::SilentScript
+            str = (' ' * space_deep)
+            str += "- #{node.script}"
+            strings << str
+          when HamdownCore::Ast::Script
+            str = (' ' * space_deep)
+            if node.escape_html == true
+              str += "= #{node.script}"
+            else
+              str += "!= #{node.script}"
+            end
+            strings << str
+          when HamdownCore::Ast::Text
+            strings << (' ' * space_deep + "#{node.text}")
+          when HamdownCore::Ast::HtmlComment
+            strings << (' ' * space_deep + "/ #{node.comment}")
+          when HamdownCore::Ast::Empty
+            # NODE: or add spaces?
+            strings << ''
+          when HamdownCore::Ast::Element
+            str = (' ' * space_deep)
+
+            str += "%#{node.tag_name}"
+
+            if node.static_id.size > 0
+              str += "##{node.static_id}"
+            end
+
+            if node.static_class.size > 0
+              str += ".#{node.static_class.gsub(' ', '.')}"
+            end
+
+            if !node.new_attributes.nil?
+              props = []
+              node.new_attributes.split(',').each do |str|
+                l,r = str.split(' => ')
+                l.gsub!("\"", '')
+                r.gsub!("\"", "'")
+                props << "#{l}=#{r}"
+              end
+              str += "(#{props.join(' ')})"
+            end
+
+            if !node.old_attributes.nil?
+              str += "{#{node.old_attributes}}"
+            end
+
+            if !node.oneline_child.nil?
+              substr = render_strings([node.oneline_child]).first
+              unless substr.start_with?('=')
+                substr = " #{substr}"
+              end
+              str += substr
+            end
+
+            strings << str
+          end
+
+          if node.respond_to?(:children) && node.children.size > 0
+            render_strings(node.children, space_deep + 2).each do |str|
+              strings << str
+            end
+          end
+        end
+        strings
+      end
+    end
+  end
+end

data/lib/hamdown_core/element_parser.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+require 'strscan'
+require_relative 'ast'
+require_relative 'error'
+require_relative 'ruby_multiline'
+require_relative 'script_parser'
+require_relative 'utils'
+
+module HamdownCore
+  class ElementParser
+    def initialize(line_parser)
+      @line_parser = line_parser
+    end
+
+    ELEMENT_REGEXP = /\A%([-:\w]+)([-:\w.#]*)(.+)?\z/o
+
+    def parse(text)
+      m = text.match(ELEMENT_REGEXP)
+      unless m
+        syntax_error!('Invalid element declaration')
+      end
+
+      element = Ast::Element.new
+      element.filename = @line_parser.filename
+      element.lineno = @line_parser.lineno
+      element.tag_name = m[1]
+      element.static_class, element.static_id = parse_class_and_id(m[2])
+      rest = m[3] || ''
+
+      element.old_attributes, element.new_attributes, element.object_ref, rest = parse_attributes(rest)
+      element.nuke_inner_whitespace, element.nuke_outer_whitespace, rest = parse_nuke_whitespace(rest)
+      element.self_closing, rest = parse_self_closing(rest)
+      element.oneline_child = ScriptParser.new(@line_parser).parse(rest)
+
+      element
+    end
+
+    private
+
+    def parse_class_and_id(class_and_id)
+      classes = []
+      id = ''
+      scanner = StringScanner.new(class_and_id)
+      until scanner.eos?
+        unless scanner.scan(/([#.])([-:_a-zA-Z0-9]+)/)
+          syntax_error!('Illegal element: classes and ids must have values.')
+        end
+        case scanner[1]
+        when '.'
+          classes << scanner[2]
+        when '#'
+          id = scanner[2]
+        end
+      end
+
+      [classes.join(' '), id]
+    end
+
+    OLD_ATTRIBUTE_BEGIN = '{'
+    NEW_ATTRIBUTE_BEGIN = '('
+    OBJECT_REF_BEGIN = '['
+
+    def parse_attributes(rest)
+      old_attributes = nil
+      new_attributes = nil
+      object_ref = nil
+
+      loop do
+        case rest[0]
+        when OLD_ATTRIBUTE_BEGIN
+          if old_attributes
+            break
+          end
+          old_attributes, rest = parse_old_attributes(rest)
+        when NEW_ATTRIBUTE_BEGIN
+          if new_attributes
+            break
+          end
+          new_attributes, rest = parse_new_attributes(rest)
+        when OBJECT_REF_BEGIN
+          if object_ref
+            break
+          end
+          object_ref, rest = parse_object_ref(rest)
+        else
+          break
+        end
+      end
+
+      [old_attributes, new_attributes, object_ref, rest]
+    end
+
+    def parse_old_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      loop do
+        depth = Utils.balance(s, '{', '}', depth)
+        if depth == 0
+          attr = s.pre_match + s.matched
+          return [attr[1, attr.size - 2], s.rest]
+        elsif /,\s*\z/ === text && @line_parser.has_next?
+          text << "\n" << @line_parser.next_line
+        else
+          syntax_error!('Unmatched brace')
+        end
+      end
+    end
+
+    def parse_new_attributes(text)
+      text = text.dup
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = 1
+      loop do
+        pre_pos = s.pos
+        depth = Utils.balance(s, '(', ')', depth)
+        if depth == 0
+          t = s.string.byteslice(pre_pos...s.pos - 1)
+          return [parse_new_attribute_list(t), s.rest]
+        elsif @line_parser.has_next?
+          text << "\n" << @line_parser.next_line
+        else
+          syntax_error!('Unmatched paren')
+        end
+      end
+    end
+
+    def parse_new_attribute_list(text)
+      s = StringScanner.new(text)
+      attributes = []
+      until s.eos?
+        name = scan_key(s)
+        s.skip(/\s*/)
+
+        if scan_operator(s)
+          s.skip(/\s*/)
+          value = scan_value(s)
+        else
+          value = 'true'
+        end
+        spaces = s.scan(/\s*/)
+        line_count = spaces.count("\n")
+
+        attributes << "#{name.inspect} => #{value},#{"\n" * line_count}"
+      end
+      attributes.join
+    end
+
+    def scan_key(scanner)
+      scanner.scan(/[-:\w]+/).tap do |name|
+        unless name
+          syntax_error!('Invalid attribute list (missing attribute name)')
+        end
+      end
+    end
+
+    def scan_operator(scanner)
+      scanner.skip(/=/)
+    end
+
+    def scan_value(scanner)
+      quote = scanner.scan(/["']/)
+      if quote
+        scan_quoted_value(scanner, quote)
+      else
+        scan_variable_value(scanner)
+      end
+    end
+
+    def scan_quoted_value(scanner, quote)
+      re = /((?:\\.|\#(?!\{)|[^#{quote}\\#])*)(#{quote}|#\{)/
+      pos = scanner.pos
+      loop do
+        unless scanner.scan(re)
+          syntax_error!('Invalid attribute list (mismatched quotation)')
+        end
+        if scanner[2] == quote
+          break
+        end
+        depth = Utils.balance(scanner, '{', '}')
+        if depth != 0
+          syntax_error!('Invalid attribute list (mismatched interpolation)')
+        end
+      end
+      str = scanner.string.byteslice(pos - 1..scanner.pos - 1)
+
+      # Even if the quote is single, string interpolation is performed in Haml.
+      str[0] = '"'
+      str[-1] = '"'
+      str
+    end
+
+    def scan_variable_value(scanner)
+      scanner.scan(/(@@?|\$)?\w+/).tap do |var|
+        unless var
+          syntax_error!('Invalid attribute list (invalid variable name)')
+        end
+      end
+    end
+
+    def parse_object_ref(text)
+      s = StringScanner.new(text)
+      s.pos = 1
+      depth = Utils.balance(s, '[', ']')
+      if depth == 0
+        [s.pre_match[1, s.pre_match.size - 1], s.rest]
+      else
+        syntax_error!('Unmatched brackets for object reference')
+      end
+    end
+
+    def parse_nuke_whitespace(rest)
+      m = rest.match(/\A(><|<>|[><])(.*)\z/)
+      if m
+        nuke_whitespace = m[1]
+        [
+          nuke_whitespace.include?('<'),
+          nuke_whitespace.include?('>'),
+          m[2],
+        ]
+      else
+        [false, false, rest]
+      end
+    end
+
+    def parse_self_closing(rest)
+      if rest[0] == '/'
+        if rest.size > 1
+          syntax_error!("Self-closing tags can't have content")
+        end
+        [true, '']
+      else
+        [false, rest]
+      end
+    end
+
+    def syntax_error!(message)
+      raise Error.new(message, @line_parser.lineno)
+    end
+  end
+end

data/lib/hamdown_core/engine.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require_relative 'parser'
+require_relative 'transformer'
+require_relative 'compiler'
+
+module HamdownCore
+  module Engine
+    def self.call(content)
+      ast = HamdownCore::Parser.new.call(content)
+      transformed_ast = HamdownCore::Transformer.call(ast)
+      puts HamdownCore::Compiler.call(transformed_ast)
+    end
+  end
+end

data/lib/hamdown_core/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module HamdownCore
+  class Error < StandardError
+    attr_accessor :lineno
+
+    def initialize(message, lineno)
+      super(message)
+      @lineno = lineno
+    end
+  end
+end

data/lib/hamdown_core/filter_parser.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require_relative 'ast'
+
+module HamdownCore
+  class FilterParser
+    def initialize(indent_tracker)
+      @ast = nil
+      @indent_level = nil
+      @indent_tracker = indent_tracker
+    end
+
+    def enabled?
+      !@ast.nil?
+    end
+
+    def start(name, filename, lineno)
+      @ast = Ast::Filter.new
+      @ast.name = name
+      @ast.filename = filename
+      @ast.lineno = lineno
+    end
+
+    def append(line)
+      indent, text = @indent_tracker.split(line)
+      if text.empty?
+        @ast.texts << ''
+        return
+      end
+      indent_level = indent.size
+
+      if @indent_level
+        if indent_level < @indent_level
+          # Finish filter
+          @indent_level = nil
+          ast = @ast
+          @ast = nil
+          return ast
+        end
+      elsif indent_level > @indent_tracker.current_level
+        # Start filter
+        @indent_level = indent_level
+      else
+        # Empty filter
+        @ast = nil
+        return nil
+      end
+
+      text = line[@indent_level..-1]
+      @ast.texts << text
+      nil
+    end
+
+    def finish
+      @ast
+    end
+  end
+end