coradoc 1.1.8 → 2.0.12

data/lib/coradoc/element/revision.rb

@@ -1,27 +0,0 @@
-module Coradoc
-  module Element
-    class Revision < Base
-      attr_accessor :number, :date, :remark
-
-      declare_children :number, :date, :remark
-
-      def initialize(number, options = {})
-        @number = number
-        @date = options.fetch(:date, nil)
-        @remark = options.fetch(:remark, nil)
-      end
-
-      def to_adoc
-        if @date.nil? && @remark.nil?
-          "v#{@number}\n"
-        elsif @remark.nil?
-          "#{@number}, #{@date}\n"
-        elsif @date.nil?
-          "#{@number}: #{@remark}\n"
-        else
-          "#{@number}, #{@date}: #{@remark}\n"
-        end
-      end
-    end
-  end
-end

data/lib/coradoc/element/section.rb

@@ -1,62 +0,0 @@
-module Coradoc
-  module Element
-    class Section < Base
-      attr_accessor :id, :title, :attrs, :contents, :sections, :anchor
-
-      declare_children :id, :title, :contents, :sections
-
-      def initialize(title, options = {})
-        @title = title
-        @id = options.fetch(:id, nil)
-        @id = nil if @id == ""
-        @anchor = @id.nil? ? nil : Inline::Anchor.new(@id)
-        @attrs = options.fetch(:attribute_list, "")
-        @contents = options.fetch(:contents, [])
-        @sections = options.fetch(:sections, [])
-      end
-
-      def glossaries
-        @glossaries ||= extract_glossaries
-      end
-
-      def content
-        if contents.count == 1 && contents.first.is_a?(Coradoc::Element::Paragraph)
-          contents.first
-        end
-      end
-
-      def to_adoc
-        anchor = @anchor.nil? ? "" : "#{@anchor.to_adoc}\n"
-        title = Coradoc::Generator.gen_adoc(@title)
-        attrs = @attrs.to_s.empty? ? "" : "#{@attrs.to_adoc}\n"
-        content = Coradoc::Generator.gen_adoc(@contents)
-        sections = Coradoc::Generator.gen_adoc(@sections)
-
-        # A block of " +\n"s isn't parsed correctly. It needs to start
-        # with something.
-        content = "&nbsp;#{content}" if content.start_with?(" +\n")
-
-        # Only try to postprocess elements that are text,
-        # otherwise we could strip markup.
-        if Coradoc.a_single?(@contents, Coradoc::Element::TextElement)
-          content = Coradoc.strip_unicode(content)
-        end
-
-        "\n#{anchor}" << attrs << title << content << sections << "\n"
-      end
-
-      # Check for cases when Section is simply an equivalent of an empty <DIV>
-      # HTML element and if it happens inside some other block element, can be
-      # safely collapsed.
-      def safe_to_collapse?
-        @title.nil? && @sections.empty?
-      end
-
-      private
-
-      def extract_glossaries
-        contents.grep(Coradoc::Element::Glossaries).first
-      end
-    end
-  end
-end

data/lib/coradoc/element/table.rb

@@ -1,91 +0,0 @@
-module Coradoc
-  module Element
-    class Table < Base
-      attr_accessor :title, :rows, :content, :id
-
-      declare_children :title, :rows, :id
-
-      def initialize(title, rows, options = {})
-        @rows = rows
-        @title = title
-        @id = options.fetch(:id, nil)
-        @anchor = @id.nil? ? nil : Inline::Anchor.new(@id)
-        @attrs = options.fetch(:attributes, nil)
-      end
-
-      def to_adoc
-        anchor = @anchor.nil? ? "" : "#{@anchor.to_adoc}\n"
-        attrs = @attrs.to_s.empty? ? "" : "#{@attrs.to_adoc}\n"
-        title = Coradoc::Generator.gen_adoc(@title)
-        title = title.empty? ? "" : ".#{title}\n"
-        content = @rows.map(&:to_adoc).join
-        "\n\n#{anchor}#{attrs}#{title}|===\n" << content << "\n|===\n"
-      end
-
-      class Row < Base
-        attr_accessor :columns, :header
-
-        declare_children :columns
-
-        def initialize(columns, header = false)
-          @columns = columns
-          @header = header
-        end
-
-        def table_header_row?
-          @header
-        end
-
-        def asciidoc?
-          @columns.any? { |c| c.respond_to?(:asciidoc?) && c.asciidoc? }
-        end
-
-        def to_adoc
-          delim = asciidoc? ? "\n" : " "
-          content = @columns.map do |col|
-            Coradoc::Generator.gen_adoc(col)
-          end.join(delim)
-          result  = "#{content}\n"
-          result << "\n" if asciidoc?
-          table_header_row? ? result + underline_for : result
-        end
-
-        def underline_for
-          "\n"
-        end
-      end
-
-      class Cell < Base
-        attr_accessor :content, :anchor, :id, :colrowattr, :alignattr, :style
-
-        declare_children :content, :anchor, :id
-
-        def initialize(options = {})
-          super()
-          @id = options.fetch(:id, nil)
-          @anchor = @id.nil? ? nil : Inline::Anchor.new(@id)
-          @colrowattr = options.fetch(:colrowattr, "")
-          @alignattr = options.fetch(:alignattr, "")
-          @style = options.fetch(:style, "")
-          @content = options.fetch(:content, "")
-        end
-
-        def asciidoc?
-          @style.include?("a")
-        end
-
-        def to_adoc
-          anchor = @anchor.nil? ? "" : @anchor.to_adoc.to_s
-          content = simplify_block_content(@content)
-          content = Coradoc::Generator.gen_adoc(content)
-          # Only try to postprocess elements that are text,
-          # otherwise we could strip markup.
-          if Coradoc.a_single?(@content, Coradoc::Element::TextElement)
-            content = Coradoc.strip_unicode(content)
-          end
-          "#{@colrowattr}#{@alignattr}#{@style}| #{anchor}#{content}"
-        end
-      end
-    end
-  end
-end

data/lib/coradoc/element/tag.rb

@@ -1,19 +0,0 @@
-module Coradoc
-  module Element
-    class Tag < Base
-      attr_accessor :name, :prefix, :attrs, :line_break
-
-      def initialize(name, options = {})
-        @name = name
-        @prefix = options.fetch(:prefix, "tag")
-        @attrs = options.fetch(:attribute_list, AttributeList.new)
-        @line_break = options.fetch(:line_break, "\n")
-      end
-
-      def to_adoc
-        attrs = @attrs.to_adoc
-        "// #{@prefix}::#{@name}#{attrs}#{@line_break}"
-      end
-    end
-  end
-end

data/lib/coradoc/element/term.rb

@@ -1,22 +0,0 @@
-module Coradoc
-  module Element
-    class Term < Base
-      attr_accessor :term, :options
-
-      declare_children :term, :options
-
-      def initialize(term, options = {})
-        @term = term
-        @type = options.fetch(:type, nil)
-        @lang = options.fetch(:lang, :en)
-        @line_break = options.fetch(:line_break, "")
-      end
-
-      def to_adoc
-        return "#{@type}:[#{@term}]#{@line_break}" if @lang == :en
-
-        "[#{@type}]##{@term}##{@line_break}"
-      end
-    end
-  end
-end

data/lib/coradoc/element/text_element.rb

@@ -1,92 +0,0 @@
-module Coradoc
-  module Element
-    class TextElement < Base
-      attr_accessor :id, :content, :line_break
-
-      declare_children :content
-
-      def initialize(content, options = {})
-        @content = content # .to_s
-        @id = options.fetch(:id, nil)
-        @line_break = options.fetch(:line_break, "")
-        @html_cleanup = options.fetch(:html_cleanup, false)
-        if @html_cleanup
-          @content = treat_text_to_adoc(@content)
-        end
-      end
-
-      def inspect
-        str = "TextElement"
-        str += "(#{@id})" if @id
-        str += ": "
-        str += @content.inspect
-        str += " + #{@line_break.inspect}" unless line_break.to_s.empty?
-        str
-      end
-
-      def to_adoc
-        str = ""
-        str += "[[#{@id}]] " if @id
-        str += Coradoc::Generator.gen_adoc(@content) + @line_break.to_s
-        str
-      end
-
-      def treat_text_to_adoc(text)
-        text = preserve_nbsp(text)
-        text = remove_border_newlines(text)
-        text = remove_inner_newlines(text)
-        text = self.class.escape_keychars(text)
-
-        text = preserve_keychars_within_backticks(text)
-        escape_links(text)
-      end
-
-      def preserve_nbsp(text)
-        text.gsub(/\u00A0/, "&nbsp;")
-      end
-
-      def escape_links(text)
-        text.gsub(/<<([^ ][^>]*)>>/, "\\<<\\1>>")
-      end
-
-      def remove_border_newlines(text)
-        text.gsub(/\A\n+/, "").gsub(/\n+\z/, "")
-      end
-
-      def remove_inner_newlines(text)
-        text.tr("\n\t", " ").squeeze(" ")
-      end
-
-      def preserve_keychars_within_backticks(text)
-        text.gsub(/`.*?`/) do |match|
-          match.gsub('\_', "_").gsub('\*', "*")
-        end
-      end
-
-      def self.escape_keychars(string)
-        subs = { "*" => '\*', "_" => '\_' }
-        string
-          .gsub(/((?<=\s)[\*_]+)|[\*_]+(?=\s)/) do |n|
-          n.chars.map do |char|
-            subs[char]
-          end.join
-        end
-      end
-    end
-
-    class LineBreak < Base
-      attr_reader :line_break
-
-      def initialize(line_break)
-        @line_break = line_break
-      end
-
-      def to_adoc
-        @line_break
-      end
-    end
-
-    class Highlight < Element::TextElement
-    end
-  end
-end

data/lib/coradoc/element/title.rb

@@ -1,62 +0,0 @@
-module Coradoc
-  module Element
-    class Title < Base
-      attr_accessor :id, :content, :line_break, :style, :level_int
-
-      declare_children :id, :content
-
-      def initialize(content, level, options = {})
-        @level_int = level
-        # @level_int = level.length - 1 if level.is_a?(String)
-        @content = content
-        @id = options.fetch(:id, nil)
-        @anchor = @id.nil? ? nil : Inline::Anchor.new(@id)
-        @line_break = options.fetch(:line_break, "")
-        @style = options.fetch(:style, nil)
-      end
-
-      def level
-        @level ||= level_from_string
-      end
-
-      def to_adoc
-        anchor = @anchor.nil? ? "" : "#{@anchor.to_adoc}\n"
-        content = Coradoc.strip_unicode(Coradoc::Generator.gen_adoc(@content))
-        <<~HERE
-
-          #{anchor}#{style_str}#{level_str} #{content}
-        HERE
-      end
-
-      def level_str
-        if @level_int <= 5
-          "=" * (@level_int + 1)
-        else
-          "======"
-        end
-      end
-
-      def style_str
-        style = [@style]
-        style << "level=#{@level_int}" if @level_int > 5
-        style = style.compact.join(",")
-
-        "[#{style}]\n" unless style.empty?
-      end
-
-      alias :text :content
-
-      private
-
-      def level_from_string
-        case @level_int
-        when 2 then :heading_two
-        when 3 then :heading_three
-        when 4 then :heading_four
-        when 5 then :heading_five
-        else :unknown
-        end
-      end
-    end
-  end
-end

data/lib/coradoc/element/video.rb

@@ -1,50 +0,0 @@
-module Coradoc
-  module Element
-    class Video < Base
-      attr_accessor :id, :title, :src, :options
-
-      declare_children :id, :anchor, :attributes
-
-      def initialize(title, options = {})
-        @title = title
-        @id = options.fetch(:id, nil)
-        @anchor = @id.nil? ? nil : Inline::Anchor.new(@id)
-        @src = options.fetch(:src, "")
-        @attributes = options.fetch(:attributes, AttributeList.new)
-        if @attributes.any?
-          @attributes.validate_positional(VALIDATORS_POSITIONAL)
-          @attributes.validate_named(VALIDATORS_NAMED)
-        end
-      end
-
-      def to_adoc
-        anchor = @anchor.nil? ? "" : "#{@anchor.to_adoc}\n"
-        title = ".#{@title}\n" unless @title.empty?
-        attrs = @attributes.to_adoc
-        [anchor, title, "video::", @src, attrs].join("")
-      end
-
-      extend AttributeList::Matchers
-      VALIDATORS_POSITIONAL = [
-        [:alt, String],
-        [:width, Integer],
-        [:height, Integer],
-      ].freeze
-
-      VALIDATORS_NAMED = {
-        title: String,
-        poster: String,
-        width: Integer,
-        height: Integer,
-        start: Integer,
-        end: Integer,
-        theme: one("dark", "light"),
-        lang: /[a-z]{2,3}(?:-[A-Z]{2})?/,
-        list: String,
-        playlist: String,
-        options: many("autoplay", "loop", "modest",
-                      "nocontrols", "nofullscreen", "muted"),
-      }.freeze
-    end
-  end
-end

data/lib/coradoc/generator.rb

@@ -1,19 +0,0 @@
-module Coradoc
-  class Generator
-    def self.gen_adoc(content)
-      if content.is_a?(Array)
-        content.map do |elem|
-          Coradoc::Generator.gen_adoc(elem)
-        end.join("")
-      elsif content.respond_to? :to_adoc
-        content.to_adoc
-      elsif content.is_a?(String)
-        content
-      elsif content.nil?
-        ""
-      elsif content.is_a?(Parslet::Slice)
-        content.to_s
-      end
-    end
-  end
-end

data/lib/coradoc/input/adoc.rb

@@ -1,30 +0,0 @@
-require "coradoc/input"
-
-module Coradoc
-  module Input
-    module Adoc
-      def self.processor_id
-        :adoc
-      end
-
-      def self.processor_match?(filename)
-        %w[.adoc].any? { |i| filename.downcase.end_with?(i) }
-      end
-
-      def self.processor_execute(input, _options = {})
-        ast = Coradoc::Parser::Base.new.parse(input)
-        Coradoc::Transformer.transform(ast[:document])
-      end
-
-      def self.processor_postprocess(input, options)
-        if options[:output_processor] == :adoc
-          Coradoc::Input::Html::Cleaner.new.tidy(input)
-        else
-          input
-        end
-      end
-
-      Coradoc::Input.define(self)
-    end
-  end
-end

data/lib/coradoc/input/docx.rb

@@ -1,64 +0,0 @@
-require "coradoc/input/html"
-require "fileutils"
-
-module Coradoc
-  module Input
-    module Docx
-      WORD_TO_MARKDOWN_MISSING_MSG =
-        "DOCX input requires the 'word-to-markdown' gem, " \
-        "which is unavailable on this platform. " \
-        "See https://github.com/metanorma/coradoc/issues/192".freeze
-
-      def self.windows_ruby4?
-        Gem.win_platform? &&
-          Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("4.0")
-      end
-
-      WORD_TO_MARKDOWN_AVAILABLE = if windows_ruby4?
-                                     false
-                                   else
-                                     begin
-                                       require "word-to-markdown"
-                                       true
-                                     rescue LoadError
-                                       false
-                                     end
-                                   end
-
-      def self.processor_id
-        :docx
-      end
-
-      def self.processor_match?(filename)
-        %w[.docx .doc].any? { |i| filename.downcase.end_with?(i) }
-      end
-
-      def self.assert_word_to_markdown!
-        return if WORD_TO_MARKDOWN_AVAILABLE
-
-        raise LoadError, WORD_TO_MARKDOWN_MISSING_MSG
-      end
-
-      def self.processor_execute(input, options = {})
-        assert_word_to_markdown!
-        image_dir = Dir.mktmpdir
-        options = options.merge(sourcedir: image_dir)
-        doc = WordToMarkdown.new(input, image_dir)
-        doc = Coradoc::Input::Html.cleaner.preprocess_word_html(doc.document.html)
-        options = WordToMarkdown::REVERSE_MARKDOWN_OPTIONS.merge(options)
-        Coradoc::Input::Html.to_coradoc(doc, options)
-      ensure
-        FileUtils.rm_rf(image_dir)
-      end
-
-      def self.processor_postprocess(data, options)
-        Coradoc::Input::Html.processor_postprocess(data, options)
-      end
-
-      # This processor prefers to work on original files.
-      def self.processor_wants_filenames; true; end
-
-      Coradoc::Input.define(self)
-    end
-  end
-end

data/lib/coradoc/input/html/LICENSE.txt

@@ -1,25 +0,0 @@
-BSD 2-Clause License
-
-Copyright (c) 2018, Ribose
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.