coradoc 1.1.8 → 2.0.12

data/flake.nix

@@ -1,135 +0,0 @@
-{
-  description = "Ruby Dev Env";
-  inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/master";
-    flake-utils.url = "github:numtide/flake-utils";
-    devshell.url = "github:numtide/devshell/main";
-    flake-compat = {
-      url = "github:edolstra/flake-compat";
-      flake = false;
-    };
-  };
-  outputs =
-    { self
-    , nixpkgs
-    , flake-utils
-    , devshell
-    , flake-compat
-    , ...
-    }:
-    flake-utils.lib.eachDefaultSystem (system:
-    let
-      cwd = builtins.toString ./.;
-      overlays = map (x: x.overlays.default) [
-        devshell
-      ];
-      pkgs = import nixpkgs { inherit system overlays; };
-      runtimeDependencies = with pkgs; [
-        graphviz
-        inkscape
-        jre
-        plantuml
-        xml2rfc
-      ];
-    in
-    rec {
-
-      # nix develop
-      devShell = pkgs.devshell.mkShell {
-
-        env = [
-        ];
-        commands = [
-          {
-            name = "soffice-test";
-            # name = "soffice"; # This for some reason will stall the shell.
-            command = "${pkgs.libreoffice-bin}/Applications/LibreOffice.app/Contents/MacOS/soffice \"$@\"";
-            help = "Run libreoffice CLI";
-            category = "App";
-          }
-          {
-            name = "reverse_adoc";
-            command = "exe/reverse_adoc \"$@\"";
-            help = "Run reverse_adoc CLI";
-            category = "App";
-          }
-          {
-            name = "coradoc";
-            command = "exe/coradoc \"$@\"";
-            help = "Run coradoc CLI";
-            category = "App";
-          }
-          {
-            name = "release";
-            command = "bundle exec rake release \"$@\"";
-            help = "Run rake release, which adds a tag and pushes to RubyGems";
-            category = "Ruby";
-          }
-          {
-            name = "lint";
-            command = "bundle exec rubocop \"$@\"";
-            help = "Run rubocop";
-            category = "Ruby";
-          }
-          {
-            name = "update-flakes";
-            command = "make update-flakes \"$@\"";
-            help = "Update all flakes";
-            category = "Nix";
-          }
-        ] ++
-        # Only append these if there is no .tool-verions file
-        # to avoid conflicts:
-        (if ! builtins.pathExists ./.tool-versions then
-          [{
-
-            name = "irb";
-            command = "bundle exec irb \"$@\"";
-            help = "Run console IRB (has completion menu)";
-            category = "Ruby";
-          }
-            {
-              name = "console";
-              command = "bundle exec irb \"$@\"";
-              help = "Run console IRB (has completion menu)";
-              category = "Ruby";
-            }
-            {
-              name = "pry";
-              command = "bundle exec pry \"$@\"";
-              help = "Run pry";
-              category = "Ruby";
-            }
-            {
-              name = "rspec";
-              command = "bundle exec rspec \"$@\"";
-              help = "Run test suite";
-              category = "Ruby";
-            }]
-        else [ ]);
-
-        packages = with pkgs; [
-          # rubocop                  # Install with your Gemfile / gemspec
-          # ruby                     # Install with your favourite Ruby version manager, etc.
-          # rubyPackages.solargraph  # Bring your own
-          # rubyfmt                  # Broken
-          bash
-          curl
-          fd
-          gnused
-          jq
-          ripgrep
-          rubyPackages.ruby-lsp
-          rubyPackages.sorbet-runtime
-          wget
-          # libreoffice-still # unsupported in darwin
-          # libreoffice-unwrapped # unsupported in darwin
-          # libreoffice # unsupported in darwin
-          # libreoffice-bin # soffice returns nothing. Wrapper to call LibreOffice.App/Contents/MacOS/soffice implemented in devShell's command
-          pkg-config # for building native extensions
-        ] ++
-        runtimeDependencies;
-
-      };
-    });
-}

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

data/lib/coradoc/element/base.rb

@@ -1,92 +0,0 @@
-module Coradoc
-  module Element
-    class Base
-      # The idea here, is that HTML content generators may often introduce
-      # a lot of unnecessary markup, that only makes sense in the HTML+CSS
-      # context. The idea is that certain cases can be simplified, making it
-      # so that the result is equivalent, but much simpler, allowing us to
-      # generate a nicer AsciiDoc syntax for those cases.
-      def simplify_block_content(content)
-        content = Array(content)
-        collected_content = []
-        content.each do |i|
-          case i
-          when Coradoc::Element::Section
-            return content unless i.safe_to_collapse?
-
-            collected_content << i.anchor if i.anchor
-
-            simplified = simplify_block_content(i.contents)
-
-            if simplified && !simplified.empty?
-              collected_content << simplified
-            end
-          else
-            collected_content << i
-          end
-        end
-
-        collected_content = collected_content.compact
-
-        # We can safely do this optimization only if there's just one other
-        # element inside this structure.
-        if collected_content.length <= 1
-          collected_content
-        else
-          content
-        end
-      end
-
-      def self.declare_children(*children)
-        @children = (@children || []).dup + children
-        access_children
-      end
-
-      # Make each child available for access
-      def self.access_children
-        @children.each do |child|
-          attr_accessor child
-        end
-      end
-
-      def self.visit(element, &block)
-        return element if element.nil?
-
-        element = yield element, :pre
-        element = if element.respond_to? :visit
-                    element.visit(&block)
-                  elsif element.is_a? Array
-                    element.map { |child| visit(child, &block) }.flatten.compact
-                  elsif element.is_a? Hash
-                    result = {}
-                    element.each do |k, v|
-                      result[k] = visit(v, &block)
-                    end
-                    result
-                  else
-                    element
-                  end
-        yield element, :post
-      end
-
-      def self.children_accessors
-        @children || []
-      end
-
-      def children_accessors
-        self.class.children_accessors
-      end
-
-      def visit(&block)
-        children_accessors.each do |accessor|
-          child = public_send(accessor)
-          result = self.class.visit(child, &block)
-          if result != child
-            public_send(:"#{accessor}=", result)
-          end
-        end
-        self
-      end
-    end
-  end
-end