defmastership 1.0.2 → 1.0.7

data/lib/defmastership/csv_formatter_header.rb

@@ -1,3 +1,4 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 require('csv')
@@ -9,26 +10,27 @@ module DefMastership
       @doc = doc
     end
 
-    def fixed_header
-      %w[Type Reference Value]
+    def fixed
+      %w[Type Reference Value sha256]
     end
 
-    def labels_header
+    def wrong_explicit_checksum
+      @doc.wrong_explicit_checksum? ? ['Wrong explicit checksum'] : []
+    end
+
+    def labels
       @doc.labels.empty? ? [] : %w[Labels]
     end
 
-    def eref_header
-      @doc.eref.map do |_, ref|
-        ref[:prefix] +
-          (ref[:url].nil? || ref[:url] == 'none' ? '' : " #{ref[:url]}")
-      end
+    def eref
+      @doc.eref.map { |_, ref| ref[:prefix] }
     end
 
-    def iref_header
+    def iref
       @doc.iref ? ['Internal links'] : []
     end
 
-    def attributes_header
+    def attributes
       @doc.attributes.map { |_, value| value }
     end
   end

data/lib/defmastership/definition.rb

@@ -1,5 +1,8 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'digest'
+
 module DefMastership
   # DefMastership definition: contains all data of a definition
   class Definition
@@ -15,6 +18,7 @@ module DefMastership
       @eref = Hash.new([])
       @iref = []
       @attributes = {}
+      @explicit_checksum = match[:explicit_checksum]
     end
 
     def <<(new_line)
@@ -26,6 +30,14 @@ module DefMastership
       @lines.join("\n")
     end
 
+    def sha256
+      Digest::SHA2.new(256).hexdigest(value).split(//).last(8).join
+    end
+
+    def wrong_explicit_checksum
+      @explicit_checksum if @explicit_checksum != sha256
+    end
+
     def add_eref(refname, extrefs)
       @eref[refname] = extrefs.strip.split(/\s*,\s*/)
     end

data/lib/defmastership/definition_parser.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+require('aasm')
+
+module DefMastership
+  # DefMastership definition: contains all data of a definition
+  class DefinitionParser
+    include AASM
+
+    def initialize(document)
+      @document = document
+    end
+
+    aasm do
+      state :idle, initial: true
+      state :wait_content
+      state :in_block
+      state :single_para
+
+      event :new_definition do
+        transitions from: :idle, to: :wait_content, after: ->(*args) { @document.add_new_definition(*args) }
+      end
+
+      event :block_delimiter do
+        transitions from: :wait_content,                 to: :in_block
+        transitions from: %i[in_block idle single_para], to: :idle
+      end
+
+      event :new_line do
+        transitions from: %i[wait_content single_para],
+                    to: :single_para,
+                    after: ->(*args) { @document.add_line(*args) }
+        transitions from: :in_block,
+                    to: :in_block,
+                    after: ->(*args) { @document.add_line(*args) }
+        transitions from: :idle, to: :idle
+      end
+
+      event :empty_line do
+        transitions from: %i[wait_content single_para idle], to: :idle
+        transitions from: :in_block, to: :in_block
+      end
+    end
+  end
+end

data/lib/defmastership/document.rb

@@ -1,40 +1,13 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('aasm')
+require('asciidoctor')
 
 module DefMastership
   # Contains the content of a DefMastership document: mainly definitions
-  # TODO: make this class smaller by defining a separated parser
-
-  # Contains regexp / action couples
-  Filter = Struct.new(:regexp, :event, :consumed_line)
-  private_constant :Filter
-
-  FILTERS_IN_LITERAL = [
-    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, false),
-    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
-  ].freeze
-  private_constant :FILTERS_IN_LITERAL
-
-  FILTERS = [
-    Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def,     false),
-    Filter.new(DMRegexp::VARIABLE_USE,  :new_variable_use,     false),
-    Filter.new(DMRegexp::DEFINITION,    :new_definition,       true),
-    Filter.new(DMRegexp::EREF_CONFIG,   :new_eref_setup,       true),
-    Filter.new(DMRegexp::EREF_DEF,      :new_eref_def,         false),
-    Filter.new(DMRegexp::IREF_DEF,      :new_iref_def,         false),
-    Filter.new(DMRegexp::ATTR_CONFIG,   :new_attribute_conf,   true),
-    Filter.new(DMRegexp::ATTR_SET,      :new_attribute_value,  false),
-    Filter.new(DMRegexp::BLOCK,         :block_delimiter,      true),
-    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, true),
-    Filter.new(DMRegexp::EMPTY_LINE,    :empty_line,           false),
-    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
-  ].freeze
-  private_constant :FILTERS
 
   # Reflects document structure from a definition point of view
   class Document
-    include AASM
     attr_reader :definitions, :labels, :eref, :iref, :attributes, :variables
 
     def initialize
@@ -44,110 +17,116 @@ module DefMastership
       @iref          = false
       @attributes    = {}
       @in_literal    = true
-      @current_line  = nil
       @variables     = {}
+
+      @definition_parser = DefinitionParser.new(self)
     end
 
-    aasm do
-      state :idle, initial: true
-      state :wait_content
-      state :in_block
-      state :single_para
+    def parse(lines)
+      lines.reject(&:commented?).each do |line|
+        (@in_literal ? FILTERS : FILTERS_IN_LITERAL).each do |filter|
+          next unless line.match(filter.regexp)
 
-      event :new_definition do
-        transitions from: :idle, to: :wait_content, after: :add_new_definition
-      end
+          line = generate_event(filter.event, Regexp.last_match, line)
 
-      event :block_delimiter do
-        transitions from: :wait_content,     to: :in_block
-        transitions from: %i[in_block idle], to: :idle
-        transitions from: :single_para, to: :idle
+          break if filter.consumed_line
+        end
       end
+    end
 
-      event :new_line do
-        transitions from: :wait_content, to: :single_para, after: :add_line
-        transitions from: :single_para, to: :single_para, after: :add_line
-        transitions from: :in_block, to: :in_block, after: :add_line
-        transitions from: :idle, to: :idle
-      end
+    def parse_file_with_preprocessor(adoc_file)
+      parse(Asciidoctor.load_file(adoc_file, safe: :unsafe, parse: false).reader.read_lines)
+    end
 
-      event :empty_line do
-        transitions from: %i[wait_content single_para idle], to: :idle
-        transitions from: :in_block, to: :in_block
+    def wrong_explicit_checksum?
+      @definitions.reduce(false) do |res, definition|
+        res || !definition.wrong_explicit_checksum.nil?
       end
     end
 
-    def code_block_delimiter(_match)
+    def code_block_delimiter(_match, line)
       @in_literal ^= true
+      line
     end
 
-    def add_new_definition(match)
+    def add_new_definition(match, line)
       definition = Definition.new(match)
       @labels.merge(definition.labels)
       @definitions << definition
+      line
+    end
+
+    def ref_to_def(ref)
+      @definitions.find { |definition| definition.reference == ref }
     end
 
-    def add_line(_match)
-      @definitions.last << @current_line
+    def add_line(_match, line)
+      @definitions.last << line
+      line
     end
 
-    def new_eref_setup(match)
+    def new_eref_setup(match, line)
       @eref[match[:refname].to_sym] ||= {}
 
       @eref[match[:refname].to_sym][match[:symb].to_sym] =
         match[:value]
+      line
     end
 
-    def new_eref_def(match)
+    def new_eref_def(match, line)
       @definitions.last.add_eref(
         match[:refname].to_sym,
         match[:extrefs]
       )
+      line
     end
 
-    def new_iref_def(_match)
+    def new_iref_def(_match, line)
       @iref = true
-      @current_line.scan(DMRegexp::IREF_DEF) do |_|
+      line.scan(DMRegexp::IREF_DEF) do |_|
         @definitions.last.add_iref(Regexp.last_match[:intref])
       end
+      line
     end
 
-    def new_attribute_conf(match)
+    def new_attribute_conf(match, line)
       @attributes[match[:attr].to_sym] = match[:prefix]
+      line
     end
 
-    def new_attribute_value(match)
+    def new_attribute_value(match, line)
       @definitions.last.set_attribute(
         match[:attr].to_sym,
         match[:value]
       )
+      line
     end
 
-    def new_variable_def(match)
+    def new_variable_def(match, line)
       @variables[match[:varname].to_sym] = match[:value]
+      line
     end
 
-    def new_variable_use(_match)
-      @current_line.scan(DMRegexp::VARIABLE_USE) do |_|
+    def new_variable_use(_match, line)
+      new_line = line.dup
+      line.scan(DMRegexp::VARIABLE_USE) do |_|
         varname = Regexp.last_match[:varname]
         next if @variables[varname.to_sym].nil?
 
-        @current_line = @current_line.gsub(
-          "{#{varname}}", @variables[varname.to_sym]
-        )
+        new_line.gsub!("{#{varname}}", @variables[varname.to_sym])
       end
+      new_line
     end
 
-    def parse(lines)
-      lines.reject(&:commented?).each do |line|
-        @current_line = line
-        (@in_literal ? FILTERS : FILTERS_IN_LITERAL).each do |filter|
-          next unless line.match(filter.regexp)
+    private
 
-          public_send(filter.event, Regexp.last_match)
-          break if filter.consumed_line
-        end
+    def generate_event(event, match, line)
+      if respond_to?(event)
+        line = public_send(event, match, line)
+      else
+        @definition_parser.public_send(event, match, line)
       end
+      line
     end
   end
 end

data/lib/defmastership/filters.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Contains regexp / action couples
+  Filter = Struct.new(:regexp, :event, :consumed_line)
+  private_constant :Filter
+
+  FILTERS_IN_LITERAL = [
+    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, false),
+    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+  ].freeze
+  private_constant :FILTERS_IN_LITERAL
+
+  FILTERS = [
+    Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def,     false),
+    Filter.new(DMRegexp::VARIABLE_USE,  :new_variable_use,     false),
+    Filter.new(DMRegexp::DEFINITION,    :new_definition,       true),
+    Filter.new(DMRegexp::EREF_CONFIG,   :new_eref_setup,       true),
+    Filter.new(DMRegexp::EREF_DEF,      :new_eref_def,         false),
+    Filter.new(DMRegexp::IREF_DEF,      :new_iref_def,         false),
+    Filter.new(DMRegexp::ATTR_CONFIG,   :new_attribute_conf,   true),
+    Filter.new(DMRegexp::ATTR_SET,      :new_attribute_value,  false),
+    Filter.new(DMRegexp::BLOCK,         :block_delimiter,      true),
+    Filter.new(DMRegexp::LITERAL_BLOCK, :code_block_delimiter, true),
+    Filter.new(DMRegexp::EMPTY_LINE,    :empty_line,           false),
+    Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+  ].freeze
+  private_constant :FILTERS
+end

data/lib/defmastership/line_modifier_base.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change references from temporary to definitive with multiple RefChangers
+  class LineModifierBase
+    attr_reader :changes, :config
+
+    def initialize
+      @config = {}
+      @changes = []
+    end
+
+    def method_missing(method_name, *args, &block)
+      return @config[method_name] if @config[method_name]
+
+      super
+    end
+
+    def respond_to_missing?(method_name, *args)
+      @config[method_name] || super
+    end
+
+    def from_config(config)
+      @config.merge!(config)
+      self
+    end
+  end
+end

data/lib/defmastership/modifier_base.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change references from temporary to definitive with multiple RefChangers
+  class ModifierBase
+    attr_reader :config, :changes
+
+    def initialize(config)
+      @config = config
+      @changes = []
+    end
+
+    def do_modifications(adoc_texts)
+      line_modifier = new_line_modifier(@config, adoc_texts)
+
+      adoc_texts =
+        replacements.reduce(adoc_texts) do |texts, method|
+          texts.transform_values do |text|
+            text.lines.map { |line| line_modifier.public_send(method, line) }.join
+          end
+        end
+
+      @config = line_modifier.config
+      @changes = line_modifier.changes
+      adoc_texts
+    end
+  end
+end

data/lib/defmastership/rename_included_files_line_modifier.rb

@@ -0,0 +1,126 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change included filenames on one line at a time
+  class RenameIncludedFilesLineModifier < LineModifierBase
+    LOCAL_FILTERS = [
+      Filter.new(DMRegexp::VARIABLE_DEF,  :new_variable_def,     false),
+      Filter.new(DMRegexp::DEFINITION,    :new_definition,       true),
+      Filter.new(DMRegexp::BLOCK,         :block_delimiter,      true),
+      Filter.new(DMRegexp::EMPTY_LINE,    :empty_line,           false),
+      Filter.new(DMRegexp::WHATEVER,      :new_line,             true)
+    ].freeze
+    private_constant :LOCAL_FILTERS
+
+    def self.from_config(config)
+      new.from_config(config)
+    end
+
+    def initialize
+      super
+      @config = {
+        from_regexp: '',
+        to_template: ''
+      }
+      @variables = {}
+      @definition_parser = DefinitionParser.new(self)
+    end
+
+    def replace(line)
+      match = matched?(line)
+
+      return line unless match
+
+      new_line =
+        line.gsub(complete_regexp_from(from_regexp)) do
+          text_with(match, to_template % hmerge(match))
+        end
+
+      rename_file(line, new_line)
+
+      new_line
+    end
+
+    def add_new_definition(match, _line)
+      @config[:reference] = match[:reference]
+    end
+
+    def add_line(_match, _line) end
+
+    def new_variable_def(match, line)
+      @variables[match[:varname].to_sym] = match[:value]
+      line
+    end
+
+    private
+
+    def matched?(line)
+      return if line.commented?
+
+      parse(line)
+
+      return if @definition_parser.idle?
+      return unless line =~ complete_regexp_from(from_regexp)
+
+      match = Regexp.last_match
+
+      return if @config[:cancel_if_match] && match[:filename] =~ Regexp.new(cancel_if_match)
+
+      match
+    end
+
+    def parse(line)
+      LOCAL_FILTERS.each do |filter|
+        next unless line.match(filter.regexp)
+
+        line = generate_event(filter.event, Regexp.last_match, line)
+
+        break if filter.consumed_line
+      end
+    end
+
+    def rename_file(from, to)
+      @changes << [extract_filename(from), extract_filename(to)]
+      File.rename(extract_filename(from), extract_filename(to))
+    end
+
+    def extract_filename(include_statement)
+      filename = include_statement
+                 .gsub(Regexp.new(DMRegexp::INCLUDE_KEYWORD), '')
+                 .gsub(Regexp.new(DMRegexp::INCLUDE_OPTIONS), '')
+
+      filename.dup.scan(DMRegexp::VARIABLE_USE) do |_|
+        varname = Regexp.last_match[:varname]
+        next if @variables[varname.to_sym].nil?
+
+        filename.gsub!("{#{varname}}", @variables[varname.to_sym])
+      end
+      filename
+    end
+
+    def complete_regexp_from(from)
+      Regexp.new(
+        DMRegexp::INCLUDE_KEYWORD + DMRegexp::INCLUDE_PATH +
+        "(?<filename>#{from})" + DMRegexp::INCLUDE_OPTIONS
+      )
+    end
+
+    def text_with(match, to)
+      "include::#{match[:path] || ''}#{to}[#{match[:options]}]"
+    end
+
+    def hmerge(match)
+      @config.merge(match.names.map(&:to_sym).zip(match.captures).to_h)
+    end
+
+    def generate_event(event, match, line)
+      if respond_to?(event)
+        public_send(event, match, line)
+      else
+        @definition_parser.public_send(event, match, line)
+      end
+      line
+    end
+  end
+end