marko 0.3.0 → 0.4.0

data/lib/marko/errors.rb

@@ -0,0 +1,38 @@
+module Marko
+
+  # Marko error
+  class MarkoError < StandardError
+  end
+
+  # Parser error
+  class ParserError < MarkoError
+    attr_reader :filename
+    attr_reader :lineno
+    attr_reader :markup
+
+    def initialize(msg, filename, lineno, markup)
+      @filename = filename
+      @lineno = lineno
+      @markup = markup
+      super(msg)
+    end
+  end
+
+  # Stage like load/compile errors
+  class StageError < MarkoError
+    attr_reader :errors
+
+    def initialize(msg, errors)
+      @errors = errors
+      super(msg)
+    end
+  end
+
+  class ValidatorError < MarkoError
+  end
+  
+  # Compiler error
+  class CompilerError < MarkoError
+  end
+  
+end

data/lib/marko/model/markup.rb

@@ -0,0 +1,33 @@
+module Marko
+  module Model
+
+    # Raw Markup
+    class Markup
+      # @return [String]
+      attr_reader :filename
+      # @return [Intger]
+      attr_reader :lineno
+      # @return [String]
+      attr_reader :content
+      
+      def initialize(filename, lineno, content)
+        @filename = filename
+        @lineno = lineno
+        @content = content
+      end
+
+      def header
+        @content.lines.first
+      end
+
+      def level
+        header.scan(/^#+/).first&.size
+      end
+
+      def to_s
+        "#{filename}:#{lineno.to_s.rjust(2,'0')} >> #{header}".strip
+      end
+    end
+    
+  end
+end

data/lib/marko/model/topic.rb

@@ -0,0 +1,126 @@
+require_relative 'tree_node'
+require_relative 'markup'
+require 'forwardable'
+
+module Marko
+  module Model
+
+    # Topic
+    class Topic
+      include TreeNode
+      extend Forwardable
+      def_delegators :metadata, :[], :[]=
+      def_delegator :markup, :level, :markup_level
+      def_delegator :markup, :filename, :markup_filename
+      def_delegator :markup, :content, :markup_content
+      def_delegator :markup, :lineno, :markup_lineno
+      
+      # @return [String]
+      attr_reader :title
+      # @return [String]
+      attr_reader :content
+      # @return [Hash]
+      attr_reader :metadata
+      # @return [Markup]
+      attr_reader :markup
+      
+      # @param title [String]
+      # @param content [String]
+      # @param metadata [Hash]
+      def initialize(title, content, **metadata)
+        @parent = nil
+        @items = []
+        @title = title
+        @content = content
+        @metadata = metadata
+        @markup = metadata.delete(:markup)
+      end
+
+      def to_s
+        to_a
+          .map{ "<#Topic id: #{it.id}, title: #{it.title}, level: #{it.nesting_level}>"}
+          .join(?\n)
+      end
+      
+      def each(&block)
+        super(&block)
+        items.each do |e|
+          e.each(&block)
+        end
+      end
+
+      def add(item)
+        item.parent = self
+        @items << item
+        self
+      end
+
+      def delete(item)
+        @items.delete(item)
+      end
+
+      # @return [Array<String>] macro links in content
+      def links
+        return [] if @content.empty?
+        @content.scan(/\[\[([\w\.]*)\]\]/).flatten.uniq
+      end
+
+      def find_by_id(ref)
+        find{ it.id == ref } || root.find{ it.id == ref }
+      end
+      
+      # @return [Array<String>] ids in order_index but out of @items
+      def lost_order_index
+        order_index.reject{ item(it) }
+      end
+      
+      # def parent_id
+      #   @metdata[:parent_id]
+      # end
+
+      # sort of dynamic id
+      def id
+        @metadata.fetch(:id, '').then do |e|
+          e = parent.id + e if e.start_with?(?.) && parent
+          e
+        end
+      end
+      
+      def id=(id)
+        @metadata[:id] = id
+      end
+
+      protected
+
+      def parent=(parent)
+        @parent = parent
+      end      
+  
+      def order_index
+        @order_index = @metadata
+          .fetch(:order_index, '')
+          .strip
+          .split(/\s{1,}/)
+      end
+
+      # @return [Array<Topic>] ordered list of child nodes
+      def items
+        return @items unless order_index.any?
+        [].tap do |ary|
+          src = @items.dup
+          order_index.each do |i|
+            node = item(i)
+            ary << src.delete(node) if node
+          end
+          ary.concat(src)
+        end
+      end
+      
+      def item(id)
+        @items.find{|n| n.id == id || n.id.end_with?(id) }
+      end
+
+    end
+    
+  end
+end

data/lib/marko/model/tree_node.rb

@@ -0,0 +1,34 @@
+module Marko
+  module Model
+
+    # Tree node
+    module TreeNode
+      include Enumerable
+       
+      # @return [TreeNode]
+      attr_reader :parent
+
+      def each(&block)
+        yield self
+      end
+
+      def add(item)
+        fail "#{self.class}##{__method__} must be overridden"
+      end
+
+      def root
+        parent ? parent.root : self
+      end
+
+      def root?
+        parent.nil?
+      end
+
+      def nesting_level
+        return 0 if root?
+        parent.nesting_level + 1
+      end
+    end
+    
+  end
+end

data/lib/marko/model.rb

@@ -0,0 +1,10 @@
+require_relative 'model/tree_node'
+require_relative 'model/topic'
+require_relative 'model/markup'
+
+module Marko
+
+  # Model
+  module Model
+  end
+end

data/lib/marko/parser/metadata.rb

@@ -0,0 +1,28 @@
+module Marko
+  module Parser
+
+    # Metadata parser
+    class Metadata
+      # @param text [String]
+      # @return [Hash]
+      def parse(text)
+        return {} if text&.empty?
+
+        text
+          .split(/[;,\n]/)
+          .map(&:strip)
+          .reject(&:empty?)
+          .map{ parse_attr(it) }
+          .to_h
+      end
+
+      protected
+
+      def parse_attr(text)
+        k, v = text.split(?:)
+        [k.strip.to_sym, v&.strip || true]
+      end
+    end
+    
+  end
+end

data/lib/marko/parser/source.rb

@@ -0,0 +1,52 @@
+require_relative 'topic'
+require_relative '../errors'
+
+module Marko
+  module Parser
+
+    # Source parser
+    class Source
+      def initialize
+        @topic = Topic.new
+      end 
+      
+      # @param markups [Array<Model::Markup>]
+      # @return [Array<Model::Topic, ParserError>]
+      def parse(markups)
+        results = markups.map do |e|
+          begin
+            @topic.parse(e)
+          rescue => ex
+            puts ex.full_message
+            Marko::ParserError.new(ex.message, e.filename, e.lineno, e.content)
+          end
+        end
+        
+        errors = results.reject{ it.is_a?(Model::Topic) }
+        topics = results.select{ it.is_a?(Model::Topic) }
+
+        adjusted = []
+        topics.each do |e|
+          if e.markup_level == 1
+            adjusted << e
+            next
+          end
+
+          finder = proc{ it.markup_level == e.markup_level - 1 }
+          parent = adjusted.last&.select(&finder)&.last
+
+          unless parent
+            errors << Marko::ParserError.new('wrong header level',
+              e.markup_filename, e.markup_lineno, e.markup_content)
+            next
+          end
+
+          parent.add(e)
+        end
+
+        adjusted + errors
+      end        
+    end
+    
+  end
+end

data/lib/marko/parser/topic.rb

@@ -0,0 +1,33 @@
+require_relative '../model'
+require_relative 'metadata'
+
+module Marko
+  module Parser
+
+    # Topic parser
+    class Topic
+      def initialize
+        @metadata = Metadata.new
+      end 
+      
+      # @param markup [Model::Markup]
+      # @return [Model::Topic]
+      def parse(markup)
+        text = markup.content
+        first = text.lines.first
+        match = first.match(/\W+(.*)/)
+        title = match[1]&.strip || ''
+
+        rest = text.lines.drop(1).join
+        match = rest.match(/^({{([\s\S]*?)}})?(.*)?$/m)
+        metadata = match[2]&.strip || ''
+        content  = match[3]&.strip || ''
+        metadata = @metadata.parse(metadata)
+
+        Model::Topic.new(title, content,
+          **{markup: markup}.merge(metadata))
+      end
+    end
+    
+  end
+end

data/lib/marko/parser.rb

@@ -1,19 +1,8 @@
-# frozen_string_literal: true
-
-require_relative "gadgets"
-
-module Marko
-
-  # The class for pasing content into TreeNode
-  class Parser
-    extend Pluggable
-
-    # @param content [String] content to parse
-    # @param source [String] content source
-    # @return [Array<TreeNode>, Array<String>] parsed nodes, errors
-    def call(content, source, &block)
-      fail "the abstract method must be overriden"
-    end
-  end
-
-end
+require_relative 'parser/metadata'
+require_relative 'parser/topic'
+require_relative 'parser/source'
+
+module Marko
+  module Parser
+  end
+end

data/lib/marko/renderers/artifact.rb

@@ -0,0 +1,29 @@
+require_relative 'topic'
+
+module Marko
+  module Renderers
+
+    # Artifact renderer
+    class Artifact < Renderer
+      def initialize
+        @topic = Topic.new
+      end
+      
+      # @param topic [Model::Topic]
+      def render(topic)
+        root = <<~STR
+          ---
+          \% #{topic.title}
+          \% #{topic[:author]}
+          \% #{Time.now.strftime('%Y-%b-%d')}          
+          ...
+        STR
+        
+        topic.to_a.drop(1)
+          .map{ @topic.render(it) }
+          .unshift(root)
+          .join(NN)
+      end
+    end
+  end
+end

data/lib/marko/renderers/content.rb

@@ -0,0 +1,37 @@
+require_relative 'link'
+require_relative 'nested_list'
+require_relative 'nested_tree'
+
+module Marko
+  module Renderers
+
+    # Content renderer
+    class Content < Renderer
+      def initialize
+        @link = Link.new
+        @list = NestedList.new
+        @tree = NestedTree.new        
+      end
+
+      # @param topic [Model::Topic]
+      def render(topic)
+        String.new(topic.content).tap do |processed|
+          # links substitution
+          topic.links.uniq.each do |link|
+            ref = topic.root.find_by_id(link) || link
+            processed.gsub!("[[#{link}]]", @link.render(ref))
+          end
+
+          processed.gsub!(/@@list/, @list.render(topic)) \
+            if processed =~ /@@list/
+            
+          processed.gsub!(/@@tree/, @tree.render(topic)) \
+            if processed =~ /@@tree/
+            
+          processed.gsub!(/@@skip.*$/m, '') \
+            if processed =~ /@@skip/
+        end
+      end
+    end
+  end
+end

data/lib/marko/renderers/link.rb

@@ -0,0 +1,19 @@
+require_relative 'url'
+
+module Marko
+  module Renderers
+
+    # Link renderer
+    class Link < Renderer
+      def initialize
+        @url = Url.new
+      end
+      
+      def render(topic)
+        return "[#{topic}](#unknown)" unless topic.respond_to?(:title)
+        "[#{topic.title}](#{@url.render(topic.id)})"
+      end
+    end
+    
+  end
+end

data/lib/marko/renderers/metadata.rb

@@ -0,0 +1,34 @@
+require_relative 'renderer'
+
+module Marko
+  module Renderers
+
+    # Metadata renderer
+    class Metadata < Renderer
+      def render(topic)
+        metadata = topic.metadata
+          .except(:id, :parent, :origin, :order_index)
+          .then{ {id: topic.id}.merge(it) }
+    
+        max_key_length = metadata.keys.map{ it.to_s.size }.max + 4
+        max_val_length = metadata.values.map{ it.to_s.size }.max
+        table_starter =
+          [ max_key_length, max_val_length
+          ].map{ ?- * it }
+           .join(?\s) 
+
+        make_row = proc{|k, v|
+          "__#{k.to_s.capitalize}__".ljust(max_key_length) + ?\s + v.to_s
+        }
+          
+        metadata
+          .map(&make_row)
+          .unshift(table_starter)  
+          .unshift(": Metadata\n")
+          .push(table_starter)
+          .join(?\n) 
+          .then{ "\n#{it}\n" }
+      end
+    end
+  end
+end

data/lib/marko/renderers/nested_list.rb

@@ -0,0 +1,21 @@
+require_relative 'link'
+
+module Marko
+  module Renderers
+
+    # Nested topics list renderer
+    class NestedList < Renderer
+      def initialize
+        @link = Link.new
+      end
+
+      # @param topic [Model::Topic]
+      def render(topic)
+        topic
+          .select{ it.parent == topic }
+          .map{"- #{@link.render(it)}"}
+          .join(?\n)
+      end
+    end
+  end
+end

data/lib/marko/renderers/nested_tree.rb

@@ -0,0 +1,22 @@
+require_relative 'link'
+
+module Marko
+  module Renderers
+
+    # Nested topics tree renderer
+    class NestedTree < Renderer
+      def initialize
+        @link = Link.new
+      end
+
+      # @param topic [Model::Topic]
+      def render(topic)
+        level = topic.nesting_level + 1
+        mkindent = proc{ '  ' * (it.nesting_level - level) }
+        topic.drop(1)
+          .map{"#{mkindent.(it)}- #{@link.render(it)}"}
+          .join(?\n)
+      end
+    end
+  end
+end

data/lib/marko/renderers/renderer.rb

@@ -0,0 +1,17 @@
+module Marko
+  module Renderers
+
+    # Renderer interface
+    class Renderer
+      # @param model [Object]
+      # @return [String]
+      def render(model)
+        fail "#{self.class}##{__method__} must be overridden"
+      end
+
+      NL = ?\n
+      NN = "\n\n"
+    end
+    
+  end
+end

data/lib/marko/renderers/title.rb

@@ -0,0 +1,16 @@
+require_relative 'url'
+
+module Marko
+  module Renderers
+
+    # Title renderer
+    class Title < Renderer
+      def render(topic)
+        head = ?# * topic.nesting_level
+        title = topic.title.empty? ? topic.id.split(/\./).last : topic.title
+        url = Url.new.render(topic.id)
+        "#{head} #{title} {#{url}}"  
+      end
+    end
+  end
+end

data/lib/marko/renderers/topic.rb

@@ -0,0 +1,24 @@
+require_relative 'title'
+require_relative 'metadata'
+require_relative 'content'
+
+module Marko
+  module Renderers
+
+    # Topic renderer
+    class Topic < Renderer
+      def initialize
+        @title = Title.new
+        @metadata = Metadata.new
+        @content = Content.new
+      end
+      
+      def render(topic)
+        [ @title, @metadata, @content
+        ].map{ it.render(topic) }
+          .reject(&:empty?)
+         .join(?\n)
+      end
+    end
+  end
+end

data/lib/marko/renderers/url.rb

@@ -0,0 +1,16 @@
+module Marko
+  module Renderers
+
+    # Url renderer
+    class Url < Renderer
+      def render(string)
+        string.downcase
+          .gsub(/\W{1,}/, ?-)
+          .sub(/^-/, '')
+          .sub(/-$/, '')
+          .then{ "##{it}" }
+      end
+    end
+    
+  end
+end

data/lib/marko/renderers.rb

@@ -0,0 +1,17 @@
+require_relative 'renderers/renderer'
+require_relative 'renderers/url'
+require_relative 'renderers/link'
+require_relative 'renderers/title'
+require_relative 'renderers/metadata'
+require_relative 'renderers/nested_list'
+require_relative 'renderers/nested_tree'
+require_relative 'renderers/content'
+require_relative 'renderers/topic'
+require_relative 'renderers/artifact'
+
+module Marko
+
+  # Renderers
+  module Renderers
+  end
+end

data/lib/marko/scanner.rb

@@ -0,0 +1,39 @@
+require_relative 'model'
+
+module Marko
+
+  # Source scanner
+  class Scanner
+    # @param text [String]
+    # @return [Array<Model::Markup>]
+    def scan(filename)
+      @source = filename
+      content = File.read(filename) 
+      scan_topics(content)
+        .select{ it.content.start_with?(?#) }
+    end
+
+    protected
+
+    def scan_topics(text)
+      quote, buffer, lineno = false, [], 0
+      origin = proc{
+        Model::Markup.new(@source,
+          lineno - buffer.size + 1, buffer.join)
+      }
+
+      [].tap{|ary|
+        text.each_line do |line|
+          if line =~ /^#/ && !quote && buffer.any?
+            ary << origin.()
+            buffer.clear
+          end
+          lineno += 1
+          buffer << line
+          quote = !quote if line.start_with?('```')
+        end
+        ary << origin.() if buffer.any?
+      }
+    end
+  end
+end