marko 0.1.0

data/lib/marko/markup/decorator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Marko
+  module Markup
+
+    class Decorator < SimpleDelegator
+
+      def initialize(obj)
+        super(obj)
+        @macroproc = MacroProcPlug.plugged
+      end
+
+      def find_node(ref)
+        obj = super(ref)
+        return nil unless obj
+        self.class.new(obj)
+      end
+
+      def url
+        id.downcase
+          .gsub(/\W{1,}/, '-')
+          .gsub(/^-/, '')
+          .gsub(/-$/, '')
+          .then{"##{_1}"}
+      end
+
+      def ref
+        "[#{title}](#{url})"
+      end
+
+      def title
+        str = super
+        str = ".#{id.split(/\./).last}" if str.empty?
+        str
+      end
+
+      def header
+        return "% #{title}\n" if root?
+        "#{'#' * nesting_level} #{title.strip} {#{url}}\n"
+      end
+
+      def meta
+        hsh = super.dup
+        hsh[:id] = id # full id will be there
+        hsh.delete(:order_index)
+        hsh.delete(:parent)
+        hsh.delete(:origin)
+        len = hsh.keys.map(&:length).max
+        [].tap{|ary|
+          ary << "key | value"
+          ary << "--- | -----"
+          hsh.each{|k,v| ary << "#{k} | #{v}"}
+        }.join(?\n) + ?\n
+      end
+
+      def body
+        text = @macroproc.process(super, self)
+        text.strip + ?\n
+      end
+    end
+
+  end
+end

data/lib/marko/markup/macro.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative "decorator"
+require_relative "../gadgets"
+
+module Marko
+  module Markup
+
+    # @todo confusing circular depenencies
+    #    List/Tree/Link Macros -> Decorator
+    #    Decorator#body -> MacroProcessor
+
+    # Base class for macro substitutions
+    # @example
+    #   class Todo < Macro
+    #     @pattern = /@@todo[^\n]*\n/
+    #     def subs(sample, obj = nil)
+    #       # code that returns <substitution>
+    #       # for the sample parameter
+    #     end
+    #   end
+    #
+    #   text = "bla-bla-bla @@todo foo\nbla-bla-bla"
+    #   Todo.new.gsub!(text)
+    #   # => "bla-bla-bla <substitution for @@todo foo>"
+    #
+    class Macro
+      def self.pattern
+        @pattern
+      end
+
+      # @return [Regexp] pattern to process
+      def pattern
+        self.class.pattern
+      end
+
+      # substitutes all occured #pattern it text
+      def gsub!(text, obj = nil)
+        fn = subfn(text, obj)
+        text.scan(pattern).each(&fn)
+      end
+
+      protected
+
+      # build substitution for the text sample
+      # @param sample [String] sample for substitution
+      # @param obj [Object] might be used for substitution
+      # @return [String] substitution for text
+      def subs(sample, obj)
+        fail '#subs must be overridden'
+      end
+
+      def subfn(source, obj)
+        fn = proc{|source, obj, sample|
+          source.sub!(sample, subs(sample, obj))
+        }.curry
+        fn.(source, obj)
+      end
+    end
+
+    class MLink < Macro
+      @pattern = /\[\[[\w\.]*\]\]/
+
+      # the macro requires obj [Decorator]
+      def subs(sample, node)
+        capture = /\[\[([\w\.]*)\]\]/
+        ref = sample
+          .match(capture)
+          .captures.first
+        obj = node.find_node(ref)
+        obj ? obj.ref : "[#{ref}](#lost-link)"
+      end
+    end
+
+    class MList < Macro
+      @pattern = /@@list/
+
+      def subs(sample, node)
+        # @todo require sentry Decorator
+        # MustbeTreeNode.(node)
+        node.items
+          .map{|n| d = Decorator.new(n); "- #{d.ref}" }
+          .join(?\n) + ?\n
+      end
+    end
+
+    class MTree < Macro
+      @pattern = /@@tree/
+
+      def subs(sample, node)
+        level = node.nesting_level + 1
+        node.to_a.drop(1)
+          .inject([]){|memo, n| memo << Decorator.new(n)}
+          .map{|n| "#{'   ' * (n.nesting_level - level)}- #{n.ref}" }
+          .join(?\n) + ?\n
+      end
+    end
+
+    # @todo there is no sense to have such macro for releases
+    #  instead it might be helpful to have some custom
+    #  todo command that will create a file with nodes
+    #  and list of todo for each node
+    #
+    # class MTodo < Macro
+    #   @pattern = /@@todo[^\n]*\n/
+    #
+    #   def subs(sample, obj = nil)
+    #     capture = /@@todo([^\n]*)\n/
+    #     payload = sample.match(capture)
+    #       .captures
+    #       .first
+    #       .strip
+    #     "__TODO__ #{payload}\n"
+    #   end
+    # end
+
+    # inline @@todo macro
+    # @todo remove line with \n when it starts from @@todo
+    class MTodo < Macro
+      @pattern = /.*@@todo.*$/
+
+      def subs(sample, obj = nil)
+        cap = /(.*)@@todo.*$/
+        m = sample.match(cap)
+        m[1].strip + sample.gsub(pattern, '')
+      end
+    end
+
+    class MSkip < Macro
+      @pattern = /@@skip.*$/m
+
+      def subs(sample, obj = nil)
+        ''
+      end
+    end
+
+    MustbeMacro = Sentry.new(:macro, "must be Macro"
+    ) {|v| v.is_a? Macro }
+
+    # Macro processor
+    # @example
+    #   processor = MacroProcessor.new
+    #   processor << Toc.new
+    #   processor << Todo.new
+    #   processor.('bla bla @@todo, bla bla @@list')
+    #   # => 'bla bla <substitute @@todo>, bla bla..'
+    class MacroProcessor
+      extend Marko::Pluggable
+
+      def initialize
+        @macros = {}
+        self.<<(MList.new)
+        self.<<(MTree.new)
+        self.<<(MLink.new)
+        self.<<(MTodo.new)
+        self.<<(MSkip.new)
+      end
+
+      def <<(macro)
+        MustbeMacro.(macro)
+        @macros[macro.pattern] = macro
+        macro
+      end
+
+      def process(text, obj)
+        fail 'No macro registered' unless @macros.any?
+        String.new(text).tap {|str|
+          @macros.values.each{|m| m.gsub!(str, obj) }
+        }
+      end
+
+      alias :call :process
+    end
+
+  end
+end

data/lib/marko/markup/parser.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "../parser"
+require_relative "../tree_node"
+
+module Marko
+  module Markup
+
+    class Parser < Marko::Parser
+
+      # @see Parser#call
+      def call(content, source, &block)
+        @source = source
+        parse(content, &block)
+      end
+
+      protected
+
+      def parse(content, &block)
+        result, errors = [], [], []
+        scan_treenode(content)
+          .map{|origin|
+            begin
+              parse_treenode(origin.markup)
+                .tap{|n| n[:origin] = origin }
+            rescue => e
+              errmsg = "wrong markup #{origin} #{e.message}\n"
+              errors << errmsg
+              nil
+            end
+          }
+          .compact
+          .each{|node|
+            parent = find_parent(result, node[:origin].level)
+            unless parent
+              origin = node[:origin].to_s
+              errors << "wrong header #{origin}\n"
+              parent = result # it goes to the root!
+            end
+            parent << node
+          }
+
+        [result, errors]
+      end
+
+      def find_parent(ary, level)
+        return ary if level == 1
+        parent = ary.last
+        l = 1
+        while parent && (l+1) < level
+          parent = parent.last
+          l += 1
+        end
+        parent
+      end
+
+      Origin = Struct.new(:origin, :lineno, :markup) do
+        def header
+          @header ||= markup.lines.first
+        end
+
+        def level
+          @level ||= header.scan(/^#*/).first.size
+        end
+
+        def to_s
+          "#{origin}:#{lineno.to_s.rjust(2,'0')} >> #{header}".strip
+        end
+      end
+
+      # @return [Array<Origin>]
+      def scan_treenode(text)
+        quote, buffer, lineno = false, [], 0
+        origin = proc{
+          Origin.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
+
+      def parse_treenode(text)
+        head, *tail = text.lines
+        m = head.match(/^(#+)(.*)/)
+        title = m[2]&.strip || ''
+
+        m = tail.join.match(/^({{([\s\S]*?)}})?(.*)?$/m)
+        meta = parse_metadata(m[2]&.strip || '')
+        body = m[3]&.strip || ''
+
+        TreeNode.new(title, body, **meta)
+      end
+
+      def parse_metadata(text)
+        return {} if text.empty?
+        atrbfn = method(:parse_attribute).to_proc
+        text
+          .split(/[;,\n]/)
+          .map(&:strip)
+          .reject(&:empty?)
+          .map(&atrbfn)
+          .to_h
+      end
+
+      def parse_attribute(text)
+        atr, val = text.split(?:)
+        [atr.strip.to_sym, val&.strip || 'true']
+      end
+    end
+
+  end
+end

data/lib/marko/markup/storage.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+require "psych"
+require 'fileutils'
+require "securerandom"
+require_relative "../storage"
+
+module Marko
+  module Markup
+
+    # File Storage
+    class Storage < Marko::Storage
+      include FileUtils
+
+      Failure = Class.new(StandardError)
+
+      # @see Storage#create
+      def punch(storage)
+        fail Failure, "Directory already exists" if Dir.exist?(storage)
+        Dir.mkdir(storage)
+        Dir.chdir(storage) {
+          marko_directories.each{|dir| Dir.mkdir dir }
+          src = File.join(Marko.root, 'lib', 'assets', 'init', '.')
+          cp_r src, Dir.pwd
+        }
+      end
+
+      # create demo project
+      def punch_demo
+        demo = File.join(Dir.home, DEMO)
+        unless Dir.exist?(demo)
+          punch(demo)
+          assets = File.join(Marko.root, 'lib', 'assets', 'demo', '.')
+          cp_r assets, demo
+        end
+        demo
+      end
+
+      # @see Storage#sources
+      def sources
+        marko_home!
+        ptrn = File.join(SOURCE, '**', '*.md')
+        Dir.glob ptrn
+      end
+
+      # @see Storage#content
+      def content(source)
+        marko_home!
+        File.read(source)
+      end
+
+      def write(filename, content = '')
+        backup(filename)
+        File.open(filename, 'w') do |f|
+          f.puts(content) unless content.empty?
+          yield(f) if block_given?
+        end
+      end
+
+      def marko_home?
+        marko_directories.all?{ Dir.exist? _1 }
+      end
+
+      # @see Marko::Strorage#artifact
+      def artifact
+        return Psych.load_file(ARTIFACT).freeze if File.exist?(ARTIFACT)
+        art = Artifact.new(SecureRandom.uuid,
+          'Marko Artifact',
+          'tt/artifact.md.tt',
+          'tt/marko-artifact.md'
+        )
+        File.write(ARTIFACT, Psych.dump(art))
+        art.freeze
+      end
+
+      protected
+
+      ARTIFACT = 'marko.yml'.freeze
+      SOURCE = 'src'.freeze
+      BINARY = 'bin'.freeze
+      SAMPLE = 'tt'.freeze
+      ASSETS = File.join(BINARY, 'assets').freeze
+      DEMO = 'marko_demo'.freeze
+
+      def marko_directories
+        [SOURCE, BINARY, ASSETS, SAMPLE]
+      end
+
+
+      def marko_home!
+        fail Failure, "Marko project required!" unless marko_home?
+      end
+
+      def backup(filename)
+        cp(filename, filename + ?~) if File.exist?(filename)
+      end
+
+    end
+
+  end
+end

data/lib/marko/markup/validator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "../validator"
+
+module Marko
+  module Markup
+    class Validator < Marko::Validator
+
+      def initialize
+        @inspectors = []
+        @inspectors << TheSameId.new
+        @inspectors << LostParent.new
+        @inspectors << LostIndex.new
+        @inspectors << LostLink.new
+      end
+
+      # see Marko::Validator#call
+      def call(tree)
+        [].tap{|errors|
+          @inspectors.each{|spectr| errors.concat(spectr.(tree)) }
+        }
+      end
+
+    end
+
+    class Inspector
+      def call(tree)
+        select(tree).then{ report(_1) }
+      end
+
+      def select(tree)
+        fail "the abstract method must be overriden"
+      end
+
+      def report(errs)
+        fail "the abstract method must be overriden"
+      end
+
+    end
+
+    class TheSameId < Inspector
+      def select(tree)
+        fn = proc{|n, memo| memo[n.id] ||= []; memo[n.id] << n}
+        tree
+          .each_with_object({}, &fn)
+          .select{|_, v| v.size > 1}
+      end
+
+      def report(errs)
+        # the same id [ref] found twice
+        #   src/source2.md:22 >> ## header
+        #   src/source3.md:11 >> ## header
+        errs.map{|id, nodes|
+          sources = nodes.map{|n| "  #{n[:origin]}\n"}.join
+          "the same id [#{id}] found in\n#{sources}"
+        }
+      end
+    end
+
+    class LostParent < Inspector
+      def select(tree)
+        tree.select{|n| n[:parent] && n.parent_id != n[:parent]}
+      end
+
+      def report(errs)
+        # lost parent [ref] src/source2.md:22 >> ## header
+        errs.map{|n| "lost parent [#{n[:parent]}] found in #{n[:origin]}\n"}
+      end
+    end
+
+    class LostIndex < Inspector
+      def select(tree)
+        lost = proc{|n| n.order_index.reject{|i| n.find_item(i)}}
+        tree
+          .select{|n| n.order_index.any? && lost.(n).any?}
+          .map{|n| [n[:origin], lost.(n)]} # @todo second time calculation
+      end
+
+      def report(errs)
+        # lost index [a, b] src/source2.md:22 >> ## header
+        errs.map{|orig, lost| "lost index [#{lost.join(', ')}] in #{orig}\n" }
+      end
+    end
+
+    class LostLink < Inspector
+      def select(tree)
+        lost = proc{|n| n.links.reject{|i| n.find_node(i)}}
+        tree
+          .select{|n| lost.(n).any? }
+          .map{|n| [n[:origin], lost.(n)]} # @todo second time #lost calculation
+      end
+
+       # @todo report link line number in the origin
+      def report(errs)
+        # lost links [ref] src/source2.md:22 >> ## header
+        errs.map{|orig, lost| "lost link [#{lost.join(', ')}] in #{orig}\n"}
+      end
+    end
+
+  end
+end

data/lib/marko/markup.rb

@@ -0,0 +1,24 @@
+require_relative "markup/parser"
+require_relative "markup/storage"
+require_relative "markup/validator"
+require_relative "markup/macro"
+require_relative "markup/decorator"
+require_relative "markup/compiler"
+require_relative "config"
+
+
+module Marko
+
+  ParserPlug.plug Markup::Parser
+  StoragePlug.plug Markup::Storage
+  CompilerPlug.plug Markup::Compiler
+  ValidatorPlug.plug Markup::Validator
+
+  # ParserPlug = Markup::Parser.plug
+  # StoragePlug = Markup::Storage.plug
+  # @todo let Decorator know
+  MacroProcPlug = Markup::MacroProcessor.plug
+  # ValidatorPlug = Markup::Validator.plug
+  # CompilerPlug = Markup::Compiler.plug
+
+end

data/lib/marko/parser.rb

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

data/lib/marko/services/assemble.rb

@@ -0,0 +1,16 @@
+require_relative "../gadgets"
+require_relative "../assembler"
+
+module Marko
+  module Services
+
+    # Assemblage service
+    # @todo assemble projects bu url
+    class Assemble < Service
+      def call
+        Assembler.(&@block)
+      end
+    end
+
+  end
+end

data/lib/marko/services/compile.rb

@@ -0,0 +1,30 @@
+require_relative "../gadgets"
+require_relative "../assembler"
+
+module Marko
+  module Services
+
+    # Compitation service
+    class Compile < Service
+      def initialize(tree: nil, template: '', filename: '', &block)
+        @tree = MustbeTreeNode.(tree) if tree
+        @template = MustbeString.(template)
+        @filename = MustbeString.(filename)
+        @block = block
+
+        art = Marko.artifact
+        @template = art.template if @template.empty?
+        @filename = art.filename if @filename.empty?
+      end
+
+      def call
+        storage = StoragePlug.plugged
+        compiler = CompilerPlug.plugged
+        erb = storage.content(@template)
+        @tree = Assembler.(&@block) unless @tree
+        compiler.(@tree, erb, @filename, &@block) # => filename
+      end
+    end
+
+  end
+end

data/lib/marko/services.rb

@@ -0,0 +1,2 @@
+require_relative "services/assemble"
+require_relative "services/compile"

data/lib/marko/storage.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "gadgets"
+require_relative "artifact"
+
+module Marko
+
+  # The base class that represents sources repository
+  class Storage
+    extend Pluggable
+
+    # create a new repository
+    # @param repository [String] the name for the repository
+    def punch(repository)
+      fail "the abstract method must be overriden"
+    end
+
+    # @retrun [Array<String>] array of sources inside the repository
+    def sources
+      fail "the abstract method must be overriden"
+    end
+
+    # @param source [Striing] source to retrieve content
+    # @return [String] content of :source
+    def content(source)
+      fail "the abstract method must be overriden"
+    end
+
+    # @return [Artifact] artifact settings
+    def artifact
+      fail "the abstract method must be overriden"
+    end
+
+  end
+
+end