marko 0.1.0

data/lib/assets/init/README.md

@@ -0,0 +1,61 @@
+% Marko Demo Project
+
+Welcome to your new [Marko](https://github.com/nvoynov/clerq) project!
+
+# Structure
+
+This project has the following structure:
+
+- [bin/](bin/) - output folder
+- [bin/assets/](bin/assets/) - assets folder
+- [src/](src/) - markup sources
+- [tt/](tt/) - templates
+- [marko.yml](marko.yml) - project configuration
+- [Rakefile](Rakefile) - Rakefile
+- [README.md](README.md)
+
+# Interface
+
+Run `marko` command in your console to see basic command-line interface.
+
+Extend it yourself through Rakefile
+
+# Git Repository
+
+[Git How To](https://githowto.com/)
+
+Incorporates changes from a remote repository:
+
+    git pull
+
+Create a new branch to start any activity with the repository:
+
+    git branch <branch_name>
+
+Make changes and commit your work:
+
+    git add .
+    git commit -m "branch_name - commit description"
+
+When your changes finished, incorporate changes from the remote repository and merge the `master` branch to your `branch_name`:
+
+    git checkout master
+    git pull
+    git checkout <branch_name>
+    git merge master
+
+Resolve all conflicts and commit changes:
+
+    git add .
+    git commit -m "branch_name conflicts resolved"
+
+Merge your changes to the `master` branch:
+
+    git checkout master
+    git merge <branch_name>
+
+Push your changes to the remote repository:
+
+    git push
+
+Create a merge request if you are not allowed to push to the `master` branch.

data/lib/assets/init/Rakefile

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'marko'
+require 'marko/markup'
+
+namespace :marko do
+
+  # @todo pandoc: bin/arfifact.docx: openBinaryFile: permission denied (Permission denied)
+  #   Success! Find the artifact in bin/arfifact.docx
+  #
+  desc 'Publish the artifact'
+  task :publish do
+    output = 'bin/arfifact'
+    `marko c -o #{output}.md`
+    pandoc = `pandoc #{output}.md -o #{output}.docx`
+    File.delete("#{output}.md")
+    puts "Success! Find the artifact in #{output}.docx"
+  end
+
+  desc 'Print table of contents'
+  task :toc, :query do |t, args|
+    args.with_defaults(query: '')
+    tree = Marko.assemble
+    query = args.query
+    unless query.empty?
+      tree = tree.find_node(query)
+      unless tree
+        puts "Nothing to be printed!"
+        return
+      end
+      tree.orphan!
+    end
+    tree.each do |n|
+      if n.root?
+        puts "% #{n.title}" if n.root?
+        next
+      end
+      title = n.title.empty? ? n.id : n.title
+      puts '#' * n.nesting_level + " #{title} ##{n.id}"
+    end
+  end
+
+  desc 'Print @@todo'
+  task :todo do
+    tree = Marko.assemble
+    tree.to_a.drop(1)
+      .select{|n| n.body =~ /@@todo/}
+      .each{|n|
+        list = n.body
+          .scan(/@@todo.*$/)
+          .map{_1.sub(/@@todo/, '')}
+          .map{"  #{_1.strip}"}
+          .join(?\n)
+        puts n[:origin]
+        puts list
+        puts
+      }
+  end
+
+  def datestamp
+    Time.new.strftime('%Y%m%d')
+  end
+
+  def timestamp
+    Time.new.to_s
+  end
+
+  desc 'Punch meeting munutes'
+  task :mm, :extra do |t, args|
+    args.with_defaults(extra: '')
+    extra = args.extra
+    Dir.mkdir('mm') unless Dir.exist?('mm')
+    body = MINUTES % timestamp
+    name = "minutes-#{datestamp}#{extra.empty? ? '' : ?_ + extra}"
+    name = File.join('mm', name)
+    errm = "Minutes exists already. Maybe you can provide [EXTRA]?"
+    fail errm if File.exist?(name)
+    File.write(name, body)
+  end
+
+  MINUTES = <<~EOF.freeze
+    %% Meeting Minutes %s
+
+    # Attendants
+
+    1.
+    2.
+
+    # Questions
+
+    1.
+    2.
+
+    # Decisions
+
+    1.
+    2.
+  EOF
+
+end

data/lib/assets/init/tt/artifact.md.tt

@@ -0,0 +1,3 @@
+<%= @node.header %>
+<%= @node.meta   %>
+<%= @node.body   %>

data/lib/marko/artifact.rb

@@ -0,0 +1,3 @@
+module Marko
+  Artifact = Struct.new(:id, :title, :template, :filename)
+end

data/lib/marko/assembler.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "gadgets"
+require_relative "config"
+require_relative "loader"
+require_relative "tree_node"
+
+module Marko
+
+  # The strategy for assembling sources into artifact tree
+  class Assembler < Service
+
+    class Failure # < StandardError
+      attr_reader :errors
+      def initialize(message, *errors)
+        @errors = errors
+        super(
+          errors
+            .map{|e| e.lines.map{|l| "  #{l}"}.join }
+            .unshift(message + ?\n)
+            .join
+        )
+      end
+    end
+
+    # @return [TreeNode]
+    def call
+      @block.(:stage, 'loading sources') if @block
+      buffer, errors = Loader.(&@block)
+      fail Failure.new('markup parsing errors', *errors) if errors.any?
+      @block.(:stage, 'tree assemblage') if @block
+      tree = assemble(buffer)
+      @block.(:stage, 'tree enrichment') if @block
+      injectid(tree)
+      @block.(:stage, 'tree validation') if @block
+      errors = validate(tree)
+      fail Failure.new('tree validation errors', *errors) if errors.any?
+      tree
+    end
+
+    protected
+
+    # @param buff [Array<TreeNode>]
+    # @return [TreeNode]
+    def assemble(buff)
+      art = Marko.artifact
+      TreeNode.new(art.title, id: '0').tap {|root|
+        # @todo buff.inject(root, :<<) wrong but why?
+        buff.each{|n| root << n}
+        root.items
+          .select{|node| node[:parent] && node[:parent] != node.parent_id}
+          .each{|node|
+            parent = root.find{|n| n.id == node[:parent]}
+            next unless parent # is must be left under root
+            parent << node
+            node.delete_meta(:parent)
+            root.delete_item(node)
+          }
+      }
+    end
+
+    def injectid(tree)
+      counter = {}
+      tree
+        .select {|node| node.id.empty?}
+        .each do |node|
+          index = counter[node.parent] || 1
+          counter[node.parent] = index + 1
+          id = index.to_s.rjust(2, '0')
+          id = '.' + id unless node.parent == tree
+          node[:id] = id
+        end
+    end
+
+    def validate(tree)
+      validator = ValidatorPlug.plugged
+      validator.(tree)
+    end
+
+  end
+
+end

data/lib/marko/cli.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "services"
+include Marko::Services
+
+module Marko
+  module CLI
+    extend self
+
+    def punch(dir, args = ARGV)
+      if Dir.exist?(dir)
+        puts "Directory '#{dir}' already exist!"
+        return
+      end
+      storage.punch(dir)
+      puts "Marko directory created!"
+      log = Dir.chdir(dir) { Dir.glob('**/*') }
+      puts log.map{ "  created #{dir}/#{_1}" }.join(?\n)
+      kwargs = options(:new, args)
+      editor = kwargs.fetch(:editor, '')
+      Dir.chdir(dir) { `#{editor} .` } unless editor.empty?
+    end
+
+    def punch_demo(args = ARGV)
+      # pp options(:demo, args)
+      log = storage.punch_demo
+      puts "Marko Demo cloned!\n#{log}"
+      kwargs = options(:demo, args)
+      editor = kwargs.fetch(:editor, '')
+      Dir.chdir(log) { `#{editor} .` } unless editor.empty?
+    end
+
+    def compile(args = ARGV)
+      unless storage.marko_home?
+        puts "Marko directory required!"
+        return
+      end
+      kwargs = options(:compile, args)
+      verbose = kwargs.delete(:verbose) { false }
+      pulsefn = method(verbose ? :pulse_verbose : :pulse_concise)
+      result = Compile.(**kwargs, &pulsefn)
+      puts "compiled #{result}\nSuccess!"
+    rescue Marko::Assembler::Failure => e
+      puts "Assembler failed with #{e.errors.size} #{e.message}"
+      puts "Failure"
+    end
+
+    def banner
+      puts "#{BANNER}\nUsage:"
+      PARSER.each{|_, cmd| puts "\n  #{cmd}"}
+    end
+
+    protected
+
+    def storage
+      StoragePlug.plugged
+    end
+
+    def pulse_verbose(events, payload)
+      case events
+      when :stage
+        puts "#{payload}.."
+      when :source
+        print "  #{payload}.."
+      when :errors
+        unless payload.empty?
+          puts "#{payload.size} errors #{payload.join}"
+        else
+          puts "OK"
+        end
+      end
+    end
+
+    def pulse_concise(events, payload)
+      case events
+      when :stage
+        puts "#{payload}.."
+      end
+    end
+
+    def options(cmd, args = ARGV)
+      {}.tap{|opt| PARSER[cmd].parse(args, into: opt)}
+    end
+
+    # \    ^__^
+    #   \  (oo)\_______
+    #      (__)\       )\/\
+    #          ||----w |
+    #          ||     ||
+    BANNER = <<~EOF.freeze
+      ~ Marko v0.1.3 ~ Markup Compiler
+      ~ https://github.io/nvoynov/marko
+    EOF
+
+    PARSER = {
+      new: OptionParser.new {|cmd|
+        ban = "marko new|n DIRECTORY [OPTIONS]".ljust(35, ?\s)
+        cmd.banner = ban + "Create a new Marko project"
+        cmd.on('-e EDITOR', '--editor EDITOR',
+          'Open the project in EDITOR', String)
+      },
+      demo: OptionParser.new {|cmd|
+        ban = "marko demo|d [OPTIONS]".ljust(35, ?\s)
+        cmd.banner = ban + "Clone Marko Demo project"
+        cmd.on('-e EDITOR', '--editor EDITOR',
+          'Open the project in EDITOR', String)
+      },
+      compile: OptionParser.new {|cmd|
+        ban = "marko compile|c [OPTIONS]".ljust(35, ?\s)
+        cmd.banner = ban + "Compile Marko artifact"
+        cmd.on('-t TEMPLATE', '--template TEMPLATE',
+          'Template to render', String)
+        cmd.on('-o FILENAME', '--filename FILENAME',
+          'Render to filename', String)
+        cmd.on('-v', '--verbose', 'Run verbosely')
+      }
+    }.freeze
+
+  end
+end

data/lib/marko/compiler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "tree_node"
+require_relative "gadgets"
+
+module Marko
+  class Compiler
+    extend Pluggable
+    def call(tree, template, filename, &block)
+      @tree = MustbeTreeNode.(tree)
+      @template = MustbeString.(template)
+      @filename = MustbeString.(filename)
+      @block = block
+    end
+  end
+end

data/lib/marko/config.rb

@@ -0,0 +1,20 @@
+
+require_relative "parser"
+require_relative "storage"
+require_relative "compiler"
+require_relative "validator"
+
+module Marko
+
+  # default abstract starters that must be replugged later
+  ParserPlug = Parser.plug
+  StoragePlug = Storage.plug
+  CompilerPlug = Compiler.plug
+  ValidatorPlug = Validator.plug
+
+  def self.artifact
+    storage = StoragePlug.plugged
+    storage.artifact
+  end
+
+end

data/lib/marko/gadgets/pluggable.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Marko
+  # Pluggable mixin serves for dependency injection
+  #
+  # @example
+  #   class Storage
+  #     extend Pluggable
+  #     def call
+  #     end
+  #   end
+  #
+  #   StoragePort = Storage.port
+  #
+  #   class SequelStorage < Storage
+  #   end
+  #
+  #   StoragePort.plugged = SequelStorage.new
+  #
+  #   require 'forwardable'
+  #   class Service
+  #     extend Forwardable
+  #     def_delegator :StoragePort, :plugged, :storage
+  #     def call
+  #       storage.call
+  #     end
+  #   end
+  module Pluggable
+
+    def plug
+      klass = self
+      Module.new {
+        extend Plug;
+        plug klass
+      }
+    end
+
+    module Plug
+      def plug(klass)
+        @klass = klass
+      end
+
+      def plugged
+        fail "unknown @klass" unless @klass
+        @plugged ||= @klass.new
+      end
+
+      def plugged=(obj)
+        fail ArgumentError.new("required an instance of #{@klass}"
+        ) unless obj.is_a?(@klass)
+        @plugged = obj
+      end
+    end
+  end
+end

data/lib/marko/gadgets/sentry.rb

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

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

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

data/lib/marko/loader.rb

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

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