metanorma-cli 1.1.6 → 1.1.7

data/lib/metanorma/cli/compiler.rb

@@ -0,0 +1,56 @@
+module Metanorma
+  module Cli
+    class Compiler
+      def initialize(file, options)
+        @file = file
+        @options = options
+        @extract = (options.delete(:extract) || "").split(",")
+        @extensions = (options.delete(:extensions) || "").split(",")
+      end
+
+      def compile
+        compile_file
+      end
+
+      def self.compile(file, options)
+        new(file, options).compile
+      end
+
+      private
+
+      attr_reader :file, :options, :extract, :extensions
+
+      def compile_file
+        Compile.new.compile( file, serialize_options)
+      end
+
+      def serialize_options
+        serialize(options.merge(customize_options))
+      end
+
+      def customize_options
+        extract_option.merge(extension_option)
+      end
+
+      def extract_option
+        Hash.new.tap do |hash|
+          hash[:extract] = extract[0]
+          hash[:extract_type] =
+            extract.size > 0 ? extract[0..-1].map(&:to_sym) : []
+        end
+      end
+
+      def extension_option
+        !extensions.empty? ? { extension_keys: extensions.map(&:to_sym) } : {}
+      end
+
+      def serialize(options)
+        Hash.new.tap do |hash|
+          options.each do |key, value|
+            hash[key.to_sym] = value unless value.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metanorma/cli/generator.rb

@@ -0,0 +1,124 @@
+require "pathname"
+require "fileutils"
+require "metanorma/cli/ui"
+
+module Metanorma
+  module Cli
+    class Generator
+      def initialize(name, type:, doctype:, **options)
+        @name = name
+        @type = type
+        @doctype = doctype
+        @options = options
+      end
+
+      def run
+        if name && document_path.exist?
+          return unless overwrite?(document_path)
+          document_path.rmtree
+        end
+
+        create_metanorma_document
+      end
+
+      # Generator.run
+      #
+      # This interface find / downloads the specified template
+      # and then run the generator to create a new metanorma
+      # document.
+      #
+      # By default it usages the default templates but user can
+      # also provide a remote git teplate repo using --template
+      # ooption, and in that case it will use that template.
+      #
+      def self.run(name, type:, doctype:, **options)
+        new(name, options.merge(type: type, doctype: doctype)).run
+      end
+
+      private
+
+      attr_reader :name, :type, :doctype, :options
+
+      def document_path
+        @document_path ||= Pathname.pwd.join(name)
+      end
+
+      def create_metanorma_document
+        type_template = type_specific_template
+
+        unless type_template.empty?
+          templates = base_templates.merge(type_template)
+          templates.each { |source, dest| create_file(source, dest) }
+        else
+          UI.say(
+            "Sorry, could not generate the document!\n" \
+            "Template's are missing, please provide valid template URL"
+          )
+        end
+      end
+
+      def find_template(type)
+        Cli::GitTemplate.find_or_download_by(type)
+      end
+
+      def overwrite?(document_path)
+        options[:overwrite] == true || ask_to_confirm(document_path) === "yes"
+      end
+
+      def base_templates
+        base_template_root = Cli.templates_path.join("base")
+        build_template_hash(dir_files(base_template_root), base_template_root)
+      end
+
+      def type_specific_template
+        type_template_path = custom_template || find_template(type)
+        doctype_templates  = dir_files(type_template_path, doctype)
+        build_template_hash(doctype_templates, type_template_path, doctype)
+      end
+
+      def custom_template
+        if options[:template]
+          Cli::GitTemplate.download(type, repo: options[:template])
+        end
+      end
+
+      def build_template_hash(elements, source_root, type = nil)
+        type_template_path = [source_root, type].join("/")
+
+        Hash.new.tap do |hash|
+          elements.each do |element|
+            hash[element] = element.gsub(type_template_path, "")
+          end
+        end
+      end
+
+      def create_file(source, destination)
+        target_path = [document_path, destination].join("/")
+        target_path = Pathname.new(target_path)
+
+        unless target_path.dirname.exist?
+          FileUtils.mkdir_p(target_path.dirname)
+        end
+
+        file_creation_message(name, destination)
+        FileUtils.copy_entry(source, target_path)
+      end
+
+      def dir_files(*arguments)
+        paths = [*arguments, "**", "**"].join("/")
+        Pathname.glob(paths).reject(&:directory?).map(&:to_s)
+      end
+
+      def ask_to_confirm(document)
+        UI.ask(
+          "You've an existing document with the #{document.to_s}\n" \
+          "Still want to continue, and overwrite the existing one? (yes/no):",
+        ).downcase
+      end
+
+      def file_creation_message(document, destination)
+        UI.say("Creating #{[document, destination].join("/").gsub("//", "/")}")
+      end
+    end
+  end
+end

data/lib/metanorma/cli/git_template.rb

@@ -0,0 +1,104 @@
+require "git"
+
+module Metanorma
+  module Cli
+    class GitTemplate
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+      end
+
+      def remove!
+        remove_template
+        return true
+      end
+
+      def download
+        remove!
+        clone_git_template(options[:repo])
+
+      rescue Git::GitExecuteError
+        UI.say("Invalid template reoository!")
+        return nil
+      end
+
+      def find_or_download
+        find_template || download_template
+      end
+
+      # Find or Download
+      #
+      # This interface expects a name / type, and then it will
+      # find that template, or if non exist then it will download
+      # and return the downloaded path.
+      #
+      def self.find_or_download_by(name)
+        new(name).find_or_download
+      end
+
+      # Download a template
+      #
+      # This interface expects a name, and remote repository link
+      # for a template, then it will download that template and it
+      # will return the downloaded path.
+      #
+      # By default, downloaded tempaltes will be stored in a sub
+      # directoy inside metanorma's tempaltes directory, but if
+      # you don't want then you can set the `remote` to false.
+      #
+      def self.download(name, repo:, remote: true)
+        new(name, repo: repo, remote: remote).download
+      end
+
+      private
+
+      attr_reader :name, :options
+
+      def find_template
+        if template_path.exist?
+          template_path
+        end
+      end
+
+      def download_template
+        template_repo = git_repos[name.to_sym]
+
+        if template_repo
+          clone_git_template(template_repo)
+        end
+      end
+
+      def remove_template
+        if template_path.exist?
+          template_path.rmtree
+        end
+      end
+
+      def clone_git_template(repo)
+        clone = Git.clone(repo, name, path: templates_path)
+        template_path unless clone.nil?
+      end
+
+      def git_repos
+        @git_repos ||= {
+          csd: "https://github.com/metanorma/mn-templates-csd",
+          ogc: "https://github.com/metanorma/mn-templates-ogc",
+          iso: "https://github.com/metanorma/mn-templates-iso",
+        }
+      end
+
+      def templates_path
+        @templates_path ||= build_templates_path
+      end
+
+      def build_templates_path
+        sub_directory = options[:remote] == true ? "git" : nil
+        Metanorma::Cli.templates_path.join(sub_directory.to_s)
+      end
+
+      def template_path
+        @template_path ||= templates_path.join(name.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/metanorma/cli/ui.rb

@@ -0,0 +1,20 @@
+require "thor"
+
+module Metanorma
+  module Cli
+    class UI < Thor
+      def self.ask(message)
+        new.ask(message)
+      end
+
+      def self.say(message)
+        new.say(message)
+      end
+
+      def self.run(command)
+        require "open3"
+        Open3.capture3(command)
+      end
+    end
+  end
+end

data/lib/metanorma/cli/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   module Cli
-    VERSION = "1.1.6"
+    VERSION = "1.1.7"
   end
 end

data/metanorma-cli.gemspec

@@ -30,10 +30,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "byebug", "~> 10.0"
   spec.add_development_dependency "rspec-command", "~> 1.0.3"
   spec.add_development_dependency "equivalent-xml", "~> 0.6"
-  spec.add_development_dependency 'rspec-core', "~> 3.4"
+  spec.add_development_dependency "rspec-core", "~> 3.4"
 
-
-  spec.add_runtime_dependency 'metanorma-iso', "~> 1.1.0"
+  spec.add_runtime_dependency "thor", "~> 0.20.3"
+  spec.add_runtime_dependency "metanorma-iso", "~> 1.1.0"
   spec.add_runtime_dependency 'metanorma-ietf', "~> 1.0.1"
   spec.add_runtime_dependency 'metanorma-gb', "~> 1.1.0"
   spec.add_runtime_dependency 'metanorma-csd', "~> 1.1.0"
@@ -49,4 +49,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'isodoc', "~> 0.9.0"
   spec.add_runtime_dependency 'metanorma', "~> 0.3.9"
   spec.add_runtime_dependency 'nokogiri', ">= 1"
+  spec.add_runtime_dependency "git", "~> 1.5"
 end

data/templates/base/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "metanorma-cli"
+gem "relaton-cli"

data/templates/base/Makefile

@@ -0,0 +1,126 @@
+#!make
+SHELL := /bin/bash
+
+FORMAT_MARKER := mn-output-
+FORMATS := $(shell grep "$(FORMAT_MARKER)" *.adoc | cut -f 2 -d ' ' | tr ',' '\n' | sort | uniq | tr '\n' ' ')
+
+SRC  := $(filter-out README.adoc, $(wildcard *.adoc))
+XML  := $(patsubst %.adoc,%.xml,$(SRC))
+HTML := $(patsubst %.adoc,%.html,$(SRC))
+DOC  := $(patsubst %.adoc,%.doc,$(SRC))
+PDF  := $(patsubst %.adoc,%.pdf,$(SRC))
+WSD  := $(wildcard models/*.wsd)
+XMI	 := $(patsubst models/%,xmi/%,$(patsubst %.wsd,%.xmi,$(WSD)))
+PNG	 := $(patsubst models/%,images/%,$(patsubst %.wsd,%.png,$(WSD)))
+
+COMPILE_CMD_LOCAL := bundle exec metanorma $$FILENAME
+COMPILE_CMD_DOCKER := docker run -v "$$(pwd)":/metanorma/ ribose/metanorma "metanorma $$FILENAME"
+
+ifdef METANORMA_DOCKER
+  COMPILE_CMD := echo "Compiling via docker..."; $(COMPILE_CMD_DOCKER)
+else
+  COMPILE_CMD := echo "Compiling locally..."; $(COMPILE_CMD_LOCAL)
+endif
+
+_OUT_FILES := $(foreach FORMAT,$(FORMATS),$(shell echo $(FORMAT) | tr '[:lower:]' '[:upper:]'))
+OUT_FILES  := $(foreach F,$(_OUT_FILES),$($F))
+
+all: images $(OUT_FILES)
+
+%.xml %.html %.doc %.pdf:	%.adoc | bundle
+	FILENAME=$^; \
+	${COMPILE_CMD}
+
+images: $(PNG)
+
+images/%.png: models/%.wsd
+	plantuml -tpng -o ../images/ $<
+
+xmi: $(XMI)
+
+xmi/%.xmi: models/%.wsd
+	plantuml -xmi:star -o ../xmi/ $<
+
+define FORMAT_TASKS
+OUT_FILES-$(FORMAT) := $($(shell echo $(FORMAT) | tr '[:lower:]' '[:upper:]'))
+
+open-$(FORMAT):
+	open $$(OUT_FILES-$(FORMAT))
+
+clean-$(FORMAT):
+	rm -f $$(OUT_FILES-$(FORMAT))
+
+$(FORMAT): clean-$(FORMAT) $$(OUT_FILES-$(FORMAT))
+
+.PHONY: clean-$(FORMAT)
+
+endef
+
+$(foreach FORMAT,$(FORMATS),$(eval $(FORMAT_TASKS)))
+
+open: open-html
+
+clean:
+	rm -f $(OUT_FILES)
+
+bundle:
+	if [ "x" == "${METANORMA_DOCKER}x" ]; then bundle; fi
+
+.PHONY: bundle all open clean
+
+#
+# Watch-related jobs
+#
+
+.PHONY: watch serve watch-serve
+
+NODE_BINS          := onchange live-serve run-p
+NODE_BIN_DIR       := node_modules/.bin
+NODE_PACKAGE_PATHS := $(foreach PACKAGE_NAME,$(NODE_BINS),$(NODE_BIN_DIR)/$(PACKAGE_NAME))
+
+$(NODE_PACKAGE_PATHS): package.json
+	npm i
+
+watch: $(NODE_BIN_DIR)/onchange
+	make all
+	$< $(ALL_SRC) -- make all
+
+define WATCH_TASKS
+watch-$(FORMAT): $(NODE_BIN_DIR)/onchange
+	make $(FORMAT)
+	$$< $$(SRC_$(FORMAT)) -- make $(FORMAT)
+
+.PHONY: watch-$(FORMAT)
+endef
+
+$(foreach FORMAT,$(FORMATS),$(eval $(WATCH_TASKS)))
+
+serve: $(NODE_BIN_DIR)/live-server revealjs-css reveal.js images
+	export PORT=$${PORT:-8123} ; \
+	port=$${PORT} ; \
+	for html in $(HTML); do \
+		$< --entry-file=$$html --port=$${port} --ignore="*.html,*.xml,Makefile,Gemfile.*,package.*.json" --wait=1000 & \
+		port=$$(( port++ )) ;\
+	done
+
+watch-serve: $(NODE_BIN_DIR)/run-p
+	$< watch serve
+
+#
+# Deploy jobs
+#
+
+publish:
+	mkdir -p published  && \
+	cp -a $(basename $(SRC)).* published/ && \
+	cp $(firstword $(HTML)) published/index.html; \
+	if [ -d "images" ]; then cp -a images published; fi
+
+deploy_key:
+	openssl aes-256-cbc -K $(encrypted_$(ENCRYPTION_LABEL)_key) \
+		-iv $(encrypted_$(ENCRYPTION_LABEL)_iv) -in $@.enc -out $@ -d && \
+	chmod 600 $@
+
+deploy: deploy_key
+	export COMMIT_AUTHOR_EMAIL=$(COMMIT_AUTHOR_EMAIL); \
+	./deploy.sh