coradoc 1.1.7 → 2.0.2

data/coradoc.gemspec

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/coradoc/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "coradoc"
-  spec.version = Coradoc::VERSION
-  spec.authors = ["Ribose Inc.", "Abu Nashir"]
-  spec.email = ["open.source@ribose.com", "abunashir@gmail.com"]
-
-  spec.license = "MIT"
-  spec.homepage = "https://www.metanorma.org"
-  spec.summary = "AsciiDoc parser for metanorma"
-  spec.description = "Experimental AsciiDoc parser for metanorma"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/metanorma/coradoc"
-
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 3.1.0"
-
-  spec.add_dependency "base64"
-  spec.add_dependency "marcel", "~> 1.0.0"
-  spec.add_dependency "nokogiri", "~> 1.13"
-  spec.add_dependency "oscal", "~> 0.1.1"
-  spec.add_dependency "parslet"
-  spec.add_dependency "plurimath"
-  spec.add_dependency "thor", ">= 1.3.0"
-  spec.add_dependency "unitsml"
-  spec.add_dependency "word-to-markdown"
-end

data/exe/reverse_adoc

@@ -1,81 +0,0 @@
-#!/usr/bin/env ruby
-# Usage: reverse_adoc [FILE]...
-# Usage: cat FILE | reverse_adoc
-require "rubygems"
-require "bundler/setup"
-
-require "coradoc/input/html"
-require "coradoc/converter"
-require "optparse"
-require "fileutils"
-
-config = {
-  input_options: input_options = {},
-  input_processor: :html,
-  output_options: {},
-  output_processor: :adoc,
-}
-destination = nil
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: reverse_adoc [options] <file>"
-  opts.on("-m", "--mathml2asciimath", "Convert MathML to AsciiMath") do |_v|
-    input_options[:mathml2asciimath] = true
-  end
-
-  opts.on("-oFILENAME", "--output=FILENAME", "Output file to write to") do |v|
-    destination = File.expand_path(v)
-    # puts "output goes to #{Coradoc::Input::HTML.config.destination}"
-  end
-
-  opts.on("-e", "--external-images", "Export images if data URI") do |_v|
-    input_options[:external_images] = true
-  end
-
-  opts.on("-u", "--unknown_tags [pass_through, drop, bypass, raise]",
-          "Unknown tag handling (default: pass_through)") do |v|
-    input_options[:unknown_tags] = v
-  end
-
-  opts.on("-r", "--require RUBYMODULE", "Require additional Ruby file") do |v|
-    require v
-  end
-
-  opts.on("--track-time", "Track time spent on each step") do
-    input_options[:track_time] = true
-  end
-
-  opts.on("--split-sections LEVEL", "Split sections up to LEVEL") do |i|
-    input_options[:split_sections] = i.to_i
-  end
-
-  opts.on("-v", "--version", "Version information") do |_v|
-    puts "Coradoc: v#{Coradoc::VERSION}"
-    exit
-  end
-
-  opts.on("-h", "--help", "Prints this help") do
-    puts opts
-    exit
-  end
-end.parse!
-
-if filename = ARGV.pop
-  input_content = filename
-else
-  if input_options[:external_images]
-    raise "The -e | --external-images feature cannot be used with STDIN input. Exiting."
-  end
-
-  input_content = ARGF
-end
-
-if input_options[:external_images] && destination.nil?
-  raise "The -e | --external-images feature must be used with -o | --output. Exiting."
-end
-
-if input_options[:split_sections] && destination.nil?
-  raise "The --split_sections feature must be used with -o | --output. Exiting."
-end
-
-Coradoc::Converter.(input_content, destination, **config)

data/exe/w2a

@@ -1,60 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "rubygems"
-require "bundler/setup"
-
-require "word-to-markdown"
-require "optparse"
-require "coradoc"
-
-ARGV.push("-h") if ARGV.empty?
-
-config = {
-  input_options: input_options = {},
-  input_processor: :docx,
-  output_options: {},
-  output_processor: :adoc,
-}
-destination = nil
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: w2a [options] <file>"
-  opts.on("-m", "--mathml2asciimath", "Convert MathML to AsciiMath") do |_v|
-    input_options[:mathml2asciimath] = true
-  end
-
-  opts.on("-oFILENAME", "--output=FILENAME", "Output file to write to") do |v|
-    destination = File.expand_path(v)
-    # puts "output goes to #{Coradoc::Input::HTML.config.destination}"
-  end
-
-  opts.on("-e", "--external-images", "Export images if data URI") do |_v|
-    input_options[:external_images] = true
-  end
-
-  opts.on("-v", "--version", "Version information") do |_v|
-    puts "Coradoc: v#{Coradoc::VERSION}"
-    puts "[dependency] WordToMarkdown: v#{WordToMarkdown::VERSION}"
-    if Gem.win_platform?
-      puts "[dependency] LibreOffice: version not available on Windows"
-    else
-      puts "[dependency] LibreOffice: v#{WordToMarkdown.soffice.version}"
-    end
-    exit
-  end
-
-  opts.on("-h", "--help", "Prints this help") do
-    puts opts
-    exit
-  end
-end.parse!
-
-filename = ARGV.pop
-raise "Please provide an input file to process. Exiting." unless filename
-
-if input_options[:external_images] && destination.nil?
-  raise "The -e | --external-images feature must be used with -o | --output. Exiting."
-end
-
-Coradoc::Converter.(filename, destination, **config)

data/lib/coradoc/converter.rb

@@ -1,144 +0,0 @@
-require "fileutils"
-
-module Coradoc
-  class Converter
-    attr_accessor :input, :output, :config
-
-    def initialize(input = nil, output = nil, **config)
-      @input = input || $stdin
-      @output = output || $stdout
-
-      @config = {
-        input_options: {},
-        output_options: {},
-      }.merge(config)
-
-      yield if block_given?
-    end
-
-    def self.call(...)
-      new(...).convert
-    end
-
-    def input_processor
-      if config[:input_processor]
-        Input[config[:input_processor]]
-      else
-        Input.select_processor(input)
-      end
-    end
-
-    def output_processor
-      if config[:output_processor]
-        Output[config[:output_processor]]
-      else
-        Output.select_processor(output)
-      end
-    end
-
-    def convert(data = nil)
-      input_processor.processor_id
-      output_id = output_processor.processor_id
-
-      unless data
-        input = self.input
-        input = File.open(input, "rb") if input.is_a? String
-        data = input.read
-        input_path = input.path if input.respond_to? :path
-      end
-
-      # Some input processors may prefer filenames
-      if input_processor.respond_to? :processor_wants_filenames
-        unless input.respond_to? :path
-          raise NoInputPathError,
-                "no input path given, but #{input_processor} wants that form. Ensure you don't read from standard input."
-        end
-
-        data = input.path
-      end
-
-      # We may need to configure destination path.
-      output = self.output
-      if output.is_a? String
-        FileUtils.mkdir_p(File.dirname(output))
-        output = File.open(output, "wb")
-      end
-      output_path = output.path if output.respond_to?(:path)
-
-      input_options = config[:input_options]
-      input_options = input_options.merge(destination: output_path) if output_path
-      input_options = input_options.merge(sourcedir: File.dirname(input_path)) if input_path
-
-      data = input_processor.processor_execute(data, input_options)
-
-      # Two options are possible at this point:
-      # Either we have a document we want to write to some output, or
-      # we have a Hash, that contains a list of files and their
-      # documents (where a nil key denotes the main file). Let's normalize
-      # those cases.
-      data = { nil => data } unless data.is_a? Hash
-
-      # Let's check an edge case of non-nil keys and no output path
-      if !output_path && data.keys.any? { |i| !i.nil? }
-        raise NoOutputPathError,
-              "no output path given, while wanting to write multiple files"
-      end
-
-      data = output_processor.processor_execute(data, config[:output_options])
-
-      if input_processor.respond_to?(:processor_postprocess)
-        data = input_processor.processor_postprocess(
-          data, input_options.merge(output_processor: output_id)
-        )
-      end
-
-      # Now we have all, let's write.
-      data.each do |filename, content|
-        if filename.nil?
-          file = output
-        else
-          dirname = File.dirname(output_path)
-          file = "#{dirname}/#{filename}"
-          FileUtils.mkdir_p(File.dirname(file))
-          file = File.open(file, "wb")
-        end
-
-        file.write(content)
-        file.close
-      end
-    end
-
-    class ConverterArgumentError < ArgumentError; end
-
-    class NoInputPathError < ConverterArgumentError; end
-    class NoOutputPathError < ConverterArgumentError; end
-    class NoProcessorError < ConverterArgumentError; end
-
-    module CommonInputOutputMethods
-      def define(const)
-        @processors[const.processor_id] = const
-      end
-
-      def [](id)
-        @processors[id.to_sym]
-      end
-
-      def keys
-        @processors.keys
-      end
-
-      def select_processor(filename)
-        filename = filename.path if filename.respond_to? :path
-        unless filename.is_a? String
-          raise Converter::NoProcessorError,
-                "Can't find a path for #{filename}. You must manually select the processor."
-        end
-
-        @processors.values.find do |i|
-          i.processor_match?(filename)
-        end or raise Converter::NoProcessorError,
-                     "You must manually select the processor for #{filename}"
-      end
-    end
-  end
-end

data/lib/coradoc/document.rb

@@ -1,77 +0,0 @@
-require_relative "element/base"
-require_relative "element/title"
-require_relative "element/block"
-require_relative "element/bibliography"
-require_relative "element/bibliography_entry"
-require_relative "element/comment_block"
-require_relative "element/comment_line"
-require_relative "element/include"
-require_relative "element/section"
-require_relative "element/attribute"
-require_relative "element/attribute_list"
-require_relative "element/admonition"
-require_relative "element/text_element"
-require_relative "element/author"
-require_relative "element/revision"
-require_relative "element/header"
-require_relative "element/document_attributes"
-require_relative "element/paragraph"
-require_relative "element/table"
-require_relative "element/tag"
-require_relative "element/list"
-require_relative "element/inline"
-require_relative "element/image"
-require_relative "element/audio"
-require_relative "element/video"
-require_relative "element/break"
-require_relative "element/term"
-
-module Coradoc
-  class Document
-    class << self
-      def from_adoc(filename)
-        ast = Coradoc::Parser.parse(filename)
-        Coradoc::Transformer.transform(ast)
-      end
-
-      def from_ast(elements)
-        @sections = []
-
-        elements.each do |element|
-          case element
-          when Coradoc::Element::DocumentAttributes
-            @document_attributes = element
-
-          when Coradoc::Element::Header
-            @header = element
-
-          when Coradoc::Element::Section
-            @sections << element
-          end
-        end
-
-        new(
-          document_attributes: @document_attributes,
-          header: @header,
-          sections: @sections,
-        )
-      end
-    end
-
-    attr_accessor :header, :document_attributes, :sections
-
-    def initialize(options = {})
-      @document_attributes = options.fetch(:document_attributes,
-                                           Coradoc::Element::DocumentAttributes.new)
-      @header = options.fetch(:header, Coradoc::Element::Header.new(""))
-      @sections = options.fetch(:sections, [])
-      self
-    end
-
-    def to_adoc
-      Coradoc::Generator.gen_adoc(@header) +
-        Coradoc::Generator.gen_adoc(@document_attributes) +
-        Coradoc::Generator.gen_adoc(@sections)
-    end
-  end
-end

data/lib/coradoc/element/admonition.rb

@@ -1,18 +0,0 @@
-module Coradoc
-  module Element
-    class Admonition < Base
-      attr_accessor :type, :content, :line_break
-
-      def initialize(content, type, options = {})
-        @content = content
-        @type = type.downcase.to_sym
-        @line_break = options.fetch(:line_break, "")
-      end
-
-      def to_adoc
-        content = Coradoc::Generator.gen_adoc(@content)
-        "#{type.to_s.upcase}: #{content}#{@line_break}"
-      end
-    end
-  end
-end

data/lib/coradoc/element/attribute.rb

@@ -1,36 +0,0 @@
-module Coradoc
-  module Element
-    class Attribute < Base
-      attr_accessor :key, :value
-
-      def initialize(key, value, _options = {})
-        @key = key.to_s
-        @value = if extensions_value?(value.to_s)
-                   build_values(value.to_s)
-                 else
-                   value.to_s.strip
-                 end
-      end
-
-      def extensions_value?(value)
-        v = value.split(",").map(&:strip)
-        v.intersect? %w[xml html pdf xml adoc rxl]
-      end
-
-      private
-
-      def build_values(value)
-        values = value.split(",").map(&:strip)
-        values.length > 1 ? values : values.first
-      end
-    end
-
-    class Glossaries
-      attr_reader :items
-
-      def initialize(items)
-        @items = items
-      end
-    end
-  end
-end

data/lib/coradoc/element/attribute_list.rb

@@ -1,138 +0,0 @@
-module Coradoc
-  module Element
-    class AttributeList < Base
-      attr_accessor :positional, :named, :rejected_positional, :rejected_named
-
-      declare_children :positional, :named
-
-      def initialize(*positional, **named)
-        @positional = positional || []
-        @named = named || {}
-        @rejected_positional = []
-        @rejected_named = []
-      end
-
-      def inspect
-        "AttributeList: " +
-          [
-            @positional.map(&:inspect).join(", "),
-            @named.map { |k, v| "#{k}: #{v.inspect}" }.join(", "),
-            (@rejected_positional.empty? or "rejected: #{@rejected_positional.inspect}"),
-            (@rejected_positional.empty? or "rejected: #{@rejected_named.inspect}"),
-          ].reject { |i| i == true || i.empty? }.join(", ")
-      end
-
-      def add_positional(*attr)
-        @positional += attr
-      end
-
-      def add_named(name, value)
-        @named[name] = value
-      end
-
-      def any?
-        !empty?
-      end
-
-      def empty?
-        @positional.empty? && @named.empty?
-      end
-
-      def validate_attr(attr, matcher)
-        matcher === attr
-      end
-
-      def validate_positional(validators)
-        @positional.each_with_index do |value, i|
-          # TODO: Decide what to do with this value
-          _positional_name = validators[i][0]
-
-          validator = validators[i][1]
-
-          unless validator && validate_attr(value, validator)
-            @positional[i] = nil
-            @rejected_positional << [i, value]
-          end
-        end
-
-        @positional.pop while !@positional.empty? && @positional.last.nil?
-      end
-
-      def validate_named(validators)
-        @named.each_with_index do |(name, value), _i|
-          name = name.to_sym
-          validator = validators[name]
-
-          unless validator && validate_attr(value, validator)
-            @named.delete(name)
-            @rejected_named << [name, value]
-          end
-        end
-      end
-
-      def to_adoc(show_empty = true)
-        return "[]" if [@positional, @named].all?(:empty?)
-
-        adoc = +""
-        if !@positional.empty?
-          adoc << @positional.map do |p|
-            [nil, ""].include?(p) ? '""' : p
-          end.join(",")
-        end
-        adoc << "," if @positional.any? && @named.any?
-        adoc << @named.map do |k, v|
-          if v.is_a?(String)
-            if (v[0] == '"' && v[-1] == '"') || (v[0] == "'" && v[-1] == "'")
-            elsif v.include?(",") || v.include?('"')
-              v = v.gsub("\"", "\\\"")
-              v = "\"#{v}\""
-            end
-          elsif v.is_a?(Array)
-            v = "\"#{v.join(',')}\""
-          end
-          [k.to_s, "=", v].join
-        end.join(",")
-
-        if !empty? || (empty? && show_empty)
-          "[#{adoc}]"
-        elsif empty? && !show_empty
-          adoc
-        end
-      end
-
-      module Matchers
-        def one(*args)
-          One.new(*args)
-        end
-
-        class One
-          def initialize(*possibilities)
-            @possibilities = possibilities
-          end
-
-          def ===(other)
-            @possibilities.any? { |i| i === other }
-          end
-        end
-
-        def many(*args)
-          Many.new(*args)
-        end
-
-        # TODO: Find a way to only reject some values but not all?
-        class Many
-          def initialize(*possibilities)
-            @possibilities = possibilities
-          end
-
-          def ===(other)
-            other = other.split(",") if other.is_a?(String)
-
-            other.is_a?(Array) &&
-              other.all? { |i| @possibilities.any? { |p| p === i } }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/coradoc/element/audio.rb

@@ -1,33 +0,0 @@
-module Coradoc
-  module Element
-    class Audio < Base
-      attr_accessor :id, :title, :src, :options, :anchor, :attributes
-
-      declare_children :id, :title, :anchor, :attributes
-
-      def initialize(title, options = {})
-        @title = title
-        @id = options.fetch(:id, nil)
-        @anchor = Inline::Anchor.new(@id) if @id
-        @src = options.fetch(:src, "")
-        @attributes = options.fetch(:attributes, [])
-      end
-
-      def to_adoc
-        anchor = @anchor.nil? ? "" : "#{@anchor.to_adoc}\n"
-        title = ".#{@title}\n" unless @title.empty?
-        attrs = @attributes.empty? ? "\[\]" : @attributes.to_adoc
-        [anchor, title, "audio::", @src, attrs].join("")
-      end
-
-      extend AttributeList::Matchers
-      VALIDATORS_NAMED = {
-        title: String,
-        start: Integer,
-        end: Integer,
-        options: many("nofollow", "noopener", "inline", "interactive"),
-        opts: many("nofollow", "noopener", "inline", "interactive"),
-      }.freeze
-    end
-  end
-end

data/lib/coradoc/element/author.rb

@@ -1,24 +0,0 @@
-module Coradoc
-  module Element
-    class Author < Base
-      attr_accessor :email, :last_name, :first_name
-
-      declare_children :email, :last_name, :first_name
-
-      def initialize(first_name, last_name, email, middle_name = nil)
-        @first_name = first_name
-        @last_name = last_name
-        @email = email
-        @middle_name = middle_name
-      end
-
-      def to_adoc
-        adoc = @first_name.to_s
-        adoc << " #{@middle_name}" if @middle_name
-        adoc << " #{@last_name}"
-        adoc << " <#{@email}>\n" if @email
-        adoc
-      end
-    end
-  end
-end