marko 0.3.0 → 0.4.0

data/lib/marko/markup/macro.rb

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

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

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-require "psych"
-require 'fileutils'
-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)
-        furnish(storage)
-      end
-
-      def furnish(directory)
-        Dir.chdir(directory) {
-          marko_directories.each{|dir| Dir.mkdir dir }
-          src = File.join(Marko.root, 'lib', 'assets', 'init', '.')
-          cp_r src, Dir.pwd
-          artifact
-        }
-      end
-
-      # create demo project
-      def punch_demo
-        return if Dir.exist?(DEMO)
-        mkdir_p DEMO
-        furnish DEMO
-        demo = File.join(Marko.demo, '.')
-        cp_r demo, DEMO
-        Dir.glob("#{DEMO}/**/*", File::FNM_DOTMATCH).tap(&:shift)
-      end
-
-      # create samples dir
-      def punch_samples
-        return if Dir.exist?(SAMPLES)
-        mkdir_p SAMPLES
-        samples = File.join(Marko.samples, '.')
-        cp_r samples, SAMPLES
-        Dir.glob("#{SAMPLES}/**/*", File::FNM_DOTMATCH).tap(&:shift)
-      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
-        artf = NULLFACT
-        head, body = Psych.dump(artf).lines.then{|ln|
-          [ln.first, ln.drop(1).join]
-        }
-
-        unless File.exist?(ARTIFACT)
-          File.write(ARTIFACT, body)
-          return artf
-        end
-
-        body = File.read(ARTIFACT)
-        obj = Psych.load(head + body, freeze: true,
-          permitted_classes: [Symbol, Marko::Artifact])
-        obj.is_a?(Artifact) ? obj : artf
-      end
-
-      protected
-
-      ARTIFACT = 'marko.yml'.freeze
-      SOURCE = 'src'.freeze
-      BINARY = 'bin'.freeze
-      SAMPLE = 'tt'.freeze
-      ASSETS = File.join(BINARY, 'assets').freeze
-      DEMO = File.join('.marko', 'demo').freeze
-      SAMPLES = File.join('.marko', 'samples').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

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

@@ -1,24 +0,0 @@
-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/services/assemble.rb

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

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

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

data/lib/marko/storage.rb

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