marko 0.1.0 → 0.4.0

data/lib/marko/gadgets/sentry.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Marko
-  # Factory module for guarding method arguments
-  #
-  # @example
-  #
-  #   ShortString = Sentry.new(:str, "must be String[3..100]"
-  #   ) {|v| v.is_a?(String) && v.size.between?(3,100)}
-  #
-  #   ShortString.(str)         => "str"
-  #   ShortString.(nil)         => ArgumentError ":str must be String[3..100]"
-  #   ShortString.error(nil)    => ":str must be String[3..100]"
-  #   ShortString.error!(nil)   => ArgumentError":str must be String[3..100]"
-  #   ShortString.(nil, :name)  => ArgumentError ":name must be String[3..100]"
-  #   ShortString.(nil, 'John Doe', 'Ups!') => ArgumentError ":John Doe Ups!"
-  #
-  module Sentry
-
-    # creates a new Sentry
-    # @param key [Symbol|String] key for error message
-    # @param msg [String] error message
-    # @param blk [&block] validation block that should return boolen
-    # @return [Sentry] based on key, msg, and validation block
-    def self.new(key, msg, &blk)
-      # origin ;)
-      argerror = ->(val, msg, cnd) {
-        fail ArgumentError, msg unless cnd
-        val
-      }
-      Module.new do
-        include Sentry
-        extend self
-
-        @key = argerror.(key, ":key must be Symbol|String",
-          key.is_a?(String) || key.is_a?(Symbol))
-        @msg = argerror.(msg, ":msg must be String", msg.is_a?(String))
-        @blk = argerror.(blk, "&blk must be provided", block_given?)
-      end
-    end
-
-    # returns error message for invalid :val
-    # @param val [Object] value to be validated
-    # @param key [Symbol|String] key for error message
-    # @param msg [String] optional error message
-    # @return [String] error message for invalid :val or nil when :val is valid
-    def error(val, key = @key, msg = @msg)
-      ":#{key} #{msg}" unless @blk.(val)
-    end
-
-    # guards :val
-    # @todo @see Yard!
-    # @param val [Object] value to be returned if it valid
-    # @param key [Symbol|String] key for error message
-    # @param msg [String] optional error message
-    # @return [Object] valid :val or raieses ArgumentError when invalid
-    def error!(val, key = @key, msg = @msg)
-      return val if @blk.(val)
-      fail ArgumentError, ":#{key} #{msg}", caller[0..-1]
-    end
-
-    # @todo how do describe in Yard?
-    alias :call :error!
-  end
-
-end

data/lib/marko/gadgets/service.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Marko
-  # Service like ServiceObject, Command, etc.
-  #
-  # @example just call without parameters
-  #   class BoldService < Service
-  #     def call
-  #       42
-  #     end
-  #   end
-  #
-  # @example with parameters
-  #   class PlusService < Service
-  #     def initialize(a, b)
-  #       @a, @b = a, b
-  #     end
-  #
-  #     def call
-  #       42
-  #     end
-  #   end
-  #
-  class Service
-    Failure = Class.new(StandardError)
-
-    class << self
-      def call(*args, **kwargs, &block)
-        new(*args, **kwargs, &block).call
-      end
-
-      def inherited(klass)
-        klass.const_set(:Failure, Class.new(klass::Failure))
-        super
-      end
-    end
-
-    private_class_method :new
-
-    def initialize(*args, **kwargs, &block)
-      @args = args
-      @kwargs = kwargs
-      @block = block
-    end
-
-    def call
-      fail Failure, "#{self.class.name}#call must be overrided"
-    end
-
-  end
-
-end

data/lib/marko/gadgets.rb

@@ -1,3 +0,0 @@
-require_relative "gadgets/sentry"
-require_relative "gadgets/pluggable"
-require_relative "gadgets/service"

data/lib/marko/loader.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "gadgets"
-require_relative "config"
-
-module Marko
-
-  # The strategy class for loading sources from repository
-  class Loader < Service
-    # load markup sources, parse and return TreeNode buffer
-    #
-    # @example
-    #   fn = proc{|event, paylod| ... }
-    #   buffer, errors = loader.(&fn)
-    #   fail "Failed" if errors.any?
-    #   # procced ...
-    #
-    # @param block [&block] aka proc {|event, payload| ..}
-    # @return [Array<TreeNode>, Array<String>] where
-    #   the first item is buffer and the second is array<error>
-    def call
-      buffer = []
-      errors = []
-      parser = ParserPlug.plugged
-      storage = StoragePlug.plugged
-      storage.sources.each do |source|
-        @block.(:source, source) if @block
-        content = storage.content(source)
-        buff, errs = parser.(content, source, &@block)
-        buffer.concat(buff)
-        errors.concat(errs)
-        @block.(:errors, errs) if @block
-      end
-      [buffer.flatten, errors]
-    end
-  end
-
-end

data/lib/marko/markup/compiler.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-require_relative "../compiler"
-require_relative "../config"
-
-module Marko
-  module Markup
-
-    class Compiler < Marko::Compiler
-
-      # @see Marko::Compliler#call
-      def call(tree, template, filename, &block)
-        super(tree, template, filename, &block)
-        compile
-      end
-
-      protected
-
-      def compile
-        storage = StoragePlug.plugged
-        erbgen = ERB.new(@template, trim_mode: '-')
-        payload = @tree.map{|n| Decorator.new(n)}
-        storage.write(@filename){|f|
-          payload.each{|node|
-            @node = node
-            text = erbgen.result(binding)
-            f.puts text
-          }
-        }
-        @filename
-      end
-    end
-
-  end
-end

data/lib/marko/markup/decorator.rb

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

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