defmastership 1.0.4 → 1.0.9

data/lib/defmastership/constants.rb

@@ -19,8 +19,11 @@ module DefMastership
       \s*
       (,\s*\[\s*(?<labels>.*?)\s*\])?\s*\]
     AFT
+
+    DEF_VERSION_AND_CHECKSUM = '(\((?<explicit_version>[^~]+)?(?<explicit_checksum>~[[:alnum:]]+)?\))?'
+
     DEFINITION = Regexp.new(
-      "#{DEF_BEFORE_REF}(?<reference>[\\w:_-]+)#{DEF_AFTER_REF}",
+      "#{DEF_BEFORE_REF}(?<reference>[\\w:_-]+)#{DEF_VERSION_AND_CHECKSUM}#{DEF_AFTER_REF}",
       Regexp::EXTENDED
     )
 
@@ -56,6 +59,16 @@ module DefMastership
 
     WHATEVER = //.freeze
 
+    INCLUDE_KEYWORD  = '\binclude::'
+    INCLUDE_PATH     = '(?<path>.*/)?'
+    INCLUDE_FILENAME = '(?<filename>[^\\/]+)'
+    INCLUDE_OPTIONS  = '\[(?<options>[\]]*)\]'
+
+    INCLUDE = Regexp.new(
+      INCLUDE_KEYWORD + INCLUDE_PATH + INCLUDE_FILENAME + INCLUDE_OPTIONS,
+      Regexp::EXTENDED
+    )
+
     public_constant :SINGLE_LINE_COMMENT,
                     :MULTI_LINE_COMMENT_DELIM,
                     :DEF_BEFORE_REF,

data/lib/defmastership/csv_formatter.rb

@@ -8,36 +8,42 @@ require('defmastership/csv_formatter_body')
 module DefMastership
   # to export a CSV file
   class CSVFormatter
-    COLUMN_LIST = %w[fixed labels eref iref attributes].freeze
-    private_constant :COLUMN_LIST
-
-    def initialize(doc)
+    def initialize(doc, sep = ',')
       @doc = doc
-      @header_formatter = CSVFormatterHeader.new(@doc)
-      @body_formatter = CSVFormatterBody.new(@doc)
+      @sep = sep
     end
 
     def export_to(output_file)
-      CSV.open(output_file, 'w:ISO-8859-1') do |csv|
-        csv << header
-        @doc.definitions.each { |definition| csv << body(definition) }
+      column_list = build_column_list
+      CSV.open(output_file, 'w:ISO-8859-1', { col_sep: @sep }) do |csv|
+        csv << header(column_list)
+        @doc.definitions.each { |definition| csv << body(definition, column_list) }
       end
     end
 
-    def header
-      header_line =
-        COLUMN_LIST.map do |part|
-          @header_formatter.public_send("#{part}_header".to_sym)
-        end
+    private
+
+    def header(column_list)
+      header_formatter = CSVFormatterHeader.new(@doc)
+      header_line = column_list.map { |part| header_formatter.public_send(part) }
       header_line.reduce(:+)
     end
 
-    def body(definition)
-      body_line =
-        COLUMN_LIST.map do |part|
-          @body_formatter.public_send("#{part}_body".to_sym, definition)
-        end
+    def body(definition, column_list)
+      body_formatter = CSVFormatterBody.new(@doc)
+      body_line = column_list.map { |part| body_formatter.public_send(part, definition) }
       body_line.reduce(:+)
     end
+
+    def build_column_list
+      column_list = [:fixed]
+      column_list += [:wrong_explicit_checksum] if @doc.wrong_explicit_checksum?
+      column_list += [:explicit_version] if @doc.explicit_version?
+      column_list += [:labels] unless @doc.labels.empty?
+      column_list += [:eref] unless @doc.eref.empty?
+      column_list += [:iref] if @doc.iref
+      column_list += [:attributes] unless @doc.attributes.empty?
+      column_list
+    end
   end
 end

data/lib/defmastership/csv_formatter_body.rb

@@ -10,26 +10,34 @@ module DefMastership
       @doc = doc
     end
 
-    def fixed_body(definition)
-      [definition.type, definition.reference, definition.value]
+    def fixed(definition)
+      [definition.type, definition.reference, definition.value, definition.sha256]
     end
 
-    def labels_body(definition)
-      @doc.labels.empty? ? [] : [definition.labels.to_a.join("\n")]
+    def wrong_explicit_checksum(definition)
+      wrong_explicit_checksum = definition.wrong_explicit_checksum
+      wrong_explicit_checksum ? [wrong_explicit_checksum] : ['']
     end
 
-    def eref_body(definition)
+    def explicit_version(definition)
+      explicit_version = definition.explicit_version
+      explicit_version ? [explicit_version] : ['']
+    end
+
+    def labels(definition)
+      [definition.labels.to_a.join("\n")]
+    end
+
+    def eref(definition)
       @doc.eref.map { |key, _| definition.eref[key].join("\n") }
     end
 
-    def iref_body(definition)
-      @doc.iref ? [definition.iref.join("\n")] : []
+    def iref(definition)
+      [definition.iref.join("\n")]
     end
 
-    def attributes_body(definition)
-      @doc.attributes.map do |key, _|
-        definition.attributes[key]
-      end
+    def attributes(definition)
+      @doc.attributes.map { |key, _| definition.attributes[key] }
     end
   end
 end

data/lib/defmastership/csv_formatter_header.rb

@@ -10,26 +10,31 @@ module DefMastership
       @doc = doc
     end
 
-    def fixed_header
-      %w[Type Reference Value]
+    def fixed
+      %w[Type Reference Value Checksum]
     end
 
-    def labels_header
+    def wrong_explicit_checksum
+      @doc.wrong_explicit_checksum? ? ['Wrong explicit checksum'] : []
+    end
+
+    def explicit_version
+      @doc.explicit_version? ? ['Version'] : []
+    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,21 +1,24 @@
 # Copyright (c) 2020 Jerome Arbez-Gindre
 # frozen_string_literal: true
 
+require 'digest'
+
 module DefMastership
   # DefMastership definition: contains all data of a definition
   class Definition
-    attr_reader :type, :reference, :lines, :labels, :eref, :iref, :attributes
+    attr_reader :type, :reference, :lines, :labels, :eref, :iref, :attributes, :explicit_version
 
     def initialize(match)
       @type = match[:type]
       @reference = match[:reference]
       @lines = []
       @labels = Set.new
-      labels = match[:labels]
-      @labels.merge(labels.split(/\s*,\s*/).to_set) if labels
+      @labels.merge(match[:labels].split(/\s*,\s*/).to_set) if match[:labels]
       @eref = Hash.new([])
       @iref = []
       @attributes = {}
+      @explicit_checksum = match[:explicit_checksum]
+      @explicit_version = match[:explicit_version]
     end
 
     def <<(new_line)
@@ -27,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,41 +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
@@ -45,110 +17,112 @@ 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
+
+    def parse_file_with_preprocessor(adoc_file)
+      parse(Asciidoctor.load_file(adoc_file, safe: :unsafe, parse: false).reader.read_lines)
+    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
+    def wrong_explicit_checksum?
+      @definitions.reduce(false) do |res, definition|
+        res || !definition.wrong_explicit_checksum.nil?
       end
+    end
 
-      event :empty_line do
-        transitions from: %i[wait_content single_para idle], to: :idle
-        transitions from: :in_block, to: :in_block
+    def explicit_version?
+      @definitions.reduce(false) do |res, definition|
+        res || !definition.explicit_version.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 ref_to_def(ref)
+      @definitions.find { |definition| definition.reference == ref }
     end
 
-    def new_eref_setup(match)
-      @eref[match[:refname].to_sym] ||= {}
+    def add_line(_match, line)
+      @definitions.last << line
+      line
+    end
 
-      @eref[match[:refname].to_sym][match[:symb].to_sym] =
-        match[:value]
+    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)
-      @definitions.last.add_eref(
-        match[:refname].to_sym,
-        match[:extrefs]
-      )
+    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)
-      @definitions.last.set_attribute(
-        match[:attr].to_sym,
-        match[:value]
-      )
+    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)
+      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]
-        )
+        line = line.gsub("{#{varname}}", @variables[varname.to_sym])
       end
+      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