marko 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c3511e83282f71094f00c81bd8d926df0b0b9ecd7fa90fe978111e4b2d51afb
-  data.tar.gz: 34810477d8a4449873eda8799ccd57f47726d35884c721d46e0c606119ca91c9
+  metadata.gz: 5831f616f2b1b2ae35890d79e685dd75efbe0553ebce040b04ce501656667cba
+  data.tar.gz: f6aaa2fdb7814193c221791b77331510374fc85a265e48138a4501be00f0ab26
 SHA512:
-  metadata.gz: 3f0c0838b0c0f7328d927664e56caf58f787175bd0aa9883700b6a12377c1483e979138f021f8d3588bc287131292e889d6af0cecebfd29780a83588cb2e8291
-  data.tar.gz: d7441f513814ad56d4c91cbd09ace4cdd56e5cbaef5598f15f15dbb66b2770eb54fab2fd1580920df1375ee0f1f6ec0427b4df52fb871f432a4fb50a591fc85e
+  metadata.gz: b23fe86805352e1b60fec19a059ac39dd4015096d1127f5dfcea157b36a6e3a922f85b66740ab23ef4718ea7d2bec71fbb0e04df4fd396867d887c8c82827233
+  data.tar.gz: f761d82d937f881cf92d2d21830a082f786d82c4b87a329d0ddfcc5564b3521ed823190ff702844cd71261dd223dcbd4c7ee4ef6ebf08c86a188322a9ffe8615

data/.dockerignore

@@ -0,0 +1,12 @@
+# Ignore all
+*
+
+# Allow sources
+!/bin/
+!/app/
+!/lib/
+!Gemfile
+!Gemfile.lock
+
+# Ignore backups
+**/*~

data/.rubocop.yml

@@ -0,0 +1,45 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+AllCops:
+  TargetRubyVersion: 3.4.X
+  DisableByDefault: true
+  Exclude:
+    - 'test/**/*'
+
+Style:
+  Enabled: true
+
+Style/LambdaCall:
+  Enabled: false
+
+Style/KeywordParametersOrder:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Style/CharacterLiteral:
+  Enabled: false
+  
+Style/StringLiterals:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/StringConcatenation:
+  Enabled: false
+
+Metrics:
+  Enabled: false
+  
+Layout:
+  Enabled: false

data/CHANGELOG.md

@@ -1,13 +1,19 @@
 ---
 title: Marko Changelog
 keywords:
-- ruby
-- markup-compiler
+  - ruby
+  - markup-compiler
 ...
 
-## [Unreleased]
+## [Unreleased] 2025-Sep-04
 
-- [ ] add order_index to Artifact?
+Marko redesigned and simplified
+
+- new model, renderers, and tasks design
+- added the abiltiy to change root artifact order_index
+- removed Sancho dependency
+- lost @@todo macro
+- lost demo, but might be returned
 
 ## [0.3.0] - 2023-11-22
 

data/Dockerfile

@@ -0,0 +1,11 @@
+FROM ruby:3.4.4 as build
+WORKDIR /app
+COPY Gemfile .
+# COPY Gemfile.lock .
+ENV BUNDLER_WITHOUT development test
+RUN gem update --system && bundle install
+ADD . .
+
+FROM ruby:3.4.4
+COPY --from=build /app /app
+CMD ["/bin/app", "help"]

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 nvoynov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -5,9 +5,9 @@ keywords:
 - markup-compiler
 ...
 
-Marko is a markup compiler that builds a tree from separated sources and compiles it into a single deliverable artifact.
+Marko is a markup compiler that builds a tree from separated Markdown sources and compiles it into a single artifact.
 
-Marko supplies a "docs-as-code" approach for compiling bulky software artifacts by providing source storage, original plain text markup, compiler templates, Ruby- and a command-line interface for assembling and compiling.
+Marko supplies a "docs-as-code" approach for assembling bulky software artifacts by providing sources storage, original plain text markup, and command-line interface for assembling and compiling.
 
 Having assembled the artifact, it can be analyzed, enriched by extra data, etc.; it can serve as a source for deriving subdued artifacts.  
 
@@ -25,27 +25,25 @@ Install the gem by executing:
 
 Marko provides just basic command-line interface for creating new projects and assembling artifacts - run `$ marko` to see the details.
 
-In addition to the standard CLI, Marko supplies you with Rakefile, that also serves as custom automation example. You can run `rake -T` to see available commands.
+In addition to the standard CLI, one can automate some work with Rakefile.
 
-To help you with task automation, Marko provides `Marko.assemble` for assembling and `Marko.compile` for compiling artifacts (you could already spot it inside Rakefile.) See [Automation](#automation) section for examples.
+To help you with task automation, Marko provides `Marko.assemble` for assembling and `Marko.compile` for compiling artifacts. See some examples in the [Automation](#automation) section.
 
 ### Structure
 
-`marko new PROJECT` command will create a new Marko project inside the `PROJECT` directory with following structure:
+`marko punch PROJECT` command will create a new Marko project inside the `PROJECT` directory with following structure:
 
-- [bin/](bin/) - output folder for `build`
-- [bin/assets/](bin/assets/) - assets folder
-- [src/](src/) - markup sources
-- [tt/](tt/) - compiler templates
-- [marko.yml](marko.yml) - project configuration
-- [Rakefile](Rakefile) - Rake automation file
-- [README.md](README.md) - this file
+- `bin` - output artifact folder
+- `src` - markup sources
+- `marko.yml` - configuration file
+- `README.md`
+- `CHANGELOG.md`
 
 ### Markup
 
-The basic and the only Marko entity is [TreeNode](#github-link) with `id`, `meta`, `body`, and `items` properties.
+The basic and the only Marko entity is [Topic](lib/marko/model/topic.rb) with `id`, `title`, `content`, and `metadata` properties.
 
-And the primary activity is just writing source files consisting of the TreeNode, where the source actually just a regular Markdown with an optional metadata excerpt. All lines from `#` until the next `#` are considered TreeNode.
+The the primary activity is just writing source files consisting of the Topic, where the source actually just a regular Markdown with an optional metadata excerpt. All lines from `#` until the next `#` are considered TreeNode.
 
 Let's see it by example and assume one has a few separate sources `content.md`, `uc.signup.md`, and `uc.signin.md`.
 `content.md`
@@ -95,7 +93,7 @@ body markup
 # Functional requirements
 ```
 
-So all the assemblage magic is just linking TreeNode by using `id`, `parent`, and `order_index` attributes; where `id` and `parent` are just nodes identifiers, and `order_index` is just an array of identifiers that point out the order of getting `items`.
+So all the assemblage magic is just linking Topics by using `id`, `parent`, and `order_index` attributes; where `id` and `parent` are just nodes identifiers, and `order_index` is just an array of identifiers that point out the order of getting `items`.
 
 ### Metadata
 
@@ -118,25 +116,13 @@ The TreeNode.body can include macros. The most helpful one is `[[reference.id]]`
 - `@@todo` will skip text with the macro till the end of the line
 - `@@skip` will skip the text after the macro
 
-### Templates
+### marko.yml configuraton
 
-Marko uses templates placed under the `tt` folder to compile sources into artifacts. You can use and customize the default one or design your own for particular purposes. It's just pure ERB, where Marko renders collection of decorated TreeNodes.
+The `marko.yml` configuration file provide a few configuration parametera like artifact name, title, author and order_index.
 
-```
-% @model.each do |node|
-<%= node.text %>
-% end
-```
-
-The `marko.yml` configuration file sets the building process's default template and other default values.
-
-```yml
-title: Artifact
-template: tt/default.md.tt
-filename: bin/artifact.md
-```
+You can change it any time and it will affect the next assemble/ compile run
 
-### Automation
+### Automation (UNDER CONSTRUCTION)
 
 Following quick example will assemble tree, remove TreeNode with id == 'hint', and compile the tree. You can also see Rakefile for other examples.
 

data/Rakefile

@@ -1,17 +1,8 @@
 # frozen_string_literal: true
 
-# require "rake"
-# require "sancho"
-# tasks, folders = Sancho.tasks
-# Rake.application.rake_require tasks, folders
-
 require "bundler/gem_tasks"
-require "rake/testtask"
+require "minitest/test_task"
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/test_*.rb"]
-end
+Minitest::TestTask.create
 
 task default: :test

data/exe/marko

@@ -1,22 +1,4 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "marko"
-include Marko
-
-command = ARGV.shift
-case command
-when nil
-  CLI.banner
-when /(n|new)/
-  dir = ARGV.shift
-  CLI.punch(dir)
-when /(c|compile)/
-  CLI.compile
-when /(d|demo)/
-  CLI.punch_demo
-when /(samples)/
-  CLI.punch_samples
-else
-  CLI.banner
-end
+#!/usr/bin/env ruby
+require 'marko'
+
+Marko::CLI::parse(ARGV)

data/lib/basic.rb

@@ -0,0 +1,27 @@
+
+# open String and provide some helpful methods
+class String 
+  # @return [String] with remove non-word characters
+  #   and adding ?n prfix when it starts from number
+  def sanitize
+    gsub(/[^\w\s]/, '')
+      .gsub(/\s{1,}/, ' ')
+      .then{ it.start_with?(/\d/) ? "n#{it}" : it }
+  end
+
+  def underscore 
+    gsub(/\s{1,}/, ?_)
+  end
+
+  # @return [String] "snake_case" from "CamelCase"
+  def snakecase
+    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .downcase
+  end
+
+  # @return [String] "CamelCase" fron "snake_case"
+  def camelcase
+    split(/_/).map(&:capitalize).join
+  end
+end

data/lib/marko/chain.rb

@@ -0,0 +1,44 @@
+require_relative 'config'
+require_relative 'tasks'
+
+module Marko
+  
+  # Chain feature
+  module Chain
+
+    # @param chain [Array<Marko::Tasks>]
+    # @param payload [Object]
+    def self.call(chain, payload)
+      achain = chain.dup
+      while step = achain.shift
+        print "  #{step.class}.. "
+        payload = step.call(payload)
+        puts "OK"
+      end
+      payload      
+    end    
+  end
+
+  def self.assemble(pattern)
+    chain = [
+      Tasks::Load.new,
+      Tasks::Scan.new,
+      Tasks::Parse.new,
+      Tasks::Assemble.new(Marko.read_config(Marko::CONFIG)),
+      Tasks::Validate.new
+    ]
+    Chain.call(chain, pattern)
+  end
+  
+  def self.compile(pattern)
+    chain = [
+      Tasks::Load.new,
+      Tasks::Scan.new,
+      Tasks::Parse.new,
+      Tasks::Assemble.new(Marko.read_config(Marko::CONFIG)),
+      Tasks::Validate.new,
+      Tasks::Compile.new
+    ]
+    Chain.call(chain, pattern)
+  end
+end

data/lib/marko/cli.rb

@@ -1,129 +1,119 @@
-# 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 copied!"
-      puts log.map{"  #{_1}"}.join(?\n)
-
-      kwargs = options(:demo, args)
-      editor = kwargs.fetch(:editor, '')
-      Dir.chdir(log) { `#{editor} .` } unless editor.empty?
-    end
-
-    def punch_samples(args = ARGV)
-      log = storage.punch_samples
-      puts "Marko Samples copied!"
-      puts log.map{"  #{_1}"}.join(?\n)
-    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 v#{Marko::VERSION} ~ 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
+require_relative '../basic'
+require_relative 'config'
+require_relative 'chain'
+
+module Marko
+
+  # Commanmd line interface
+  module CLI
+    extend self
+
+    def parse(args)
+      command = args.shift
+      case command&.to_sym
+      when :punch
+        punch(args.shift)
+      when :assemble, :a
+        assemble
+      when :compile, :c
+        compile
+      when :help
+        puts "Marko didn't get you", BANNER
+      else
+        puts "Marko didn't get you", BANNER
+      end
+    end
+
+    protected
+
+    def assemble
+      exit_unless_marko('assemble')
+
+      rescue_marko_errors do
+        puts "Marko artifact assemblage:"
+        Marko.assemble(File.join('src', '**/*.md'))
+        puts "Marko artifact assembled!"
+      end
+    end
+    
+    def compile 
+      exit_unless_marko('compile')
+      
+      rescue_marko_errors do
+        puts "Marko artifact compilation:"
+        compiled = Marko.compile(File.join('src', '**/*.md'))
+
+        config = Marko.read_config(Marko::CONFIG)
+        artifact = config.artifact
+        filename = File.join('bin', artifact)
+        File.write(filename, compiled)
+        puts "Marko artifact compiled!",
+          "Find it in #{filename}"
+      end
+    end
+
+    def rescue_marko_errors
+      yield
+    rescue Marko::StageError => e
+      puts "Marko failed", e.message,
+        e.errors.map{ "  #{it.message}" }
+    end
+
+    def exit_unless_marko(command)
+      return if File.exist?(Marko::CONFIG)
+      puts "Marko '#{command}' requires Marko #{Marko::CONFIG}"
+      exit
+    end
+
+    def punch(dir)
+      unless dir
+        puts "required DIRECTORY"
+        exit
+      end
+      
+      dir = dir.sanitize.underscore.downcase        
+      Dir.mkdir(dir)
+      Dir.chdir(dir) do
+        Dir.mkdir 'bin'
+        Dir.mkdir 'src'
+        config = Config.new(
+          title: dir,
+          author: 'one')
+        Marko.write_config(Marko::CONFIG, config)
+        File.write('README.md', '% README')      
+        File.write('CHANGELOG.md', CHANGELOG)      
+      end
+
+      pattern = File.join(dir, '*')
+      punched = Dir[pattern]
+        .map{ "  #{it}" }
+        .join(?\n)
+
+      puts "Marko punched", punched
+    end    
+    
+    CHANGELOG = <<~STR
+      % CHANGELOG
+
+      ## Unreleased
+
+      ## [v0.1.0] #{Time.now.strftime('%Y-%b-%d')}
+
+      Marko punched
+    STR
+
+    BANNER = <<~STR
+      Marko Markdown generator v#{VERSION}
+
+      Usage:
+        # create a new Marko directory
+        marko punch DIRECTORY
+
+        # assemble Marko tree
+        marko assemble|a
+
+        # compile Marko artifact
+        marko compile|c
+    STR
+  end
+end

data/lib/marko/config.rb

@@ -1,20 +1,30 @@
-
-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
+require 'psych'
+
+module Marko
+
+  VERSION = '0.4.0'
+
+  CONFIG = 'marko.yml'
+  
+  Config = Data.define(:artifact, :title, :author, :order_index) do
+    def initialize(artifact: 'artifact.md', title: 'title',
+      author: 'author', order_index: '')
+      super
+    end
+  end
+
+  def self.read_config(filename)
+    dump = File.read(filename)
+    Psych.load(dump)
+      .transform_keys(&:to_sym)
+      .then{ Config.new(**it) }
+  end
+
+  def self.write_config(filename, config = Config.new)
+    data = config.to_h.transform_keys(&:to_s)
+    
+    dump = Psych.dump(data)
+    File.write(filename, dump)
+  end
+
+end