defmastership 1.0.1 → 1.0.6

data/lib/defmastership/document.rb

@@ -1,40 +1,11 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
-require('aasm')
-
 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 +15,108 @@ module DefMastership
       @iref          = false
       @attributes    = {}
       @in_literal    = true
-      @current_line  = nil
       @variables     = {}
-    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: :add_new_definition
-      end
-
-      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
-      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
+      @definition_parser = DefinitionParser.new(self)
+    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 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)
 
-          public_send(filter.event, Regexp.last_match)
+          line = generate_event(filter.event, Regexp.last_match, line)
+
           break if filter.consumed_line
         end
       end
     end
+
+    private
+
+    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 = line_modifier_class.from_config(@config)
+
+      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

data/lib/defmastership/rename_included_files_modifier.rb

@@ -0,0 +1,30 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
+# frozen_string_literal: true
+
+module DefMastership
+  # Change included filenames
+  class RenameIncludedFilesModifier < ModifierBase
+    def do_modifications(adoc_texts)
+      line_modifier = line_modifier_class.from_config(@config)
+
+      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
+
+    def replacements
+      %i[replace]
+    end
+
+    def line_modifier_class
+      RenameIncludedFilesLineModifier
+    end
+  end
+end

data/lib/defmastership/version.rb

@@ -1,6 +1,7 @@
+# Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
 module DefMastership
-  VERSION = '1.0.1'
+  VERSION = '1.0.6'
   public_constant :VERSION
 end