defmastership 1.0.1

data/features/step_definitions/defmastership_steps.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+When(/^I get help for "([^"]*)"$/) do |app_name|
+  @app_name = app_name
+  step %(I run `#{app_name} help`)
+end
+
+# Add more step definitions here

data/features/support/env.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require('aruba/cucumber')
+
+# ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}"\
+#               "#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+# LIB_DIR = File.join(__dir__, '..', '..', 'lib')
+
+# Before do
+#   # Using "announce" causes massive warnings on 1.9.2
+#   @puts = true
+#   @original_rubylib = ENV['RUBYLIB']
+#   ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+# end
+
+# After do
+#   ENV['RUBYLIB'] = @original_rubylib
+# end

data/lib/defmastership.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require('defmastership/version')
+
+# Add requires for other files you add to your project here, so
+# you just need to require this one file in your bin file
+require('defmastership/constants')
+require('defmastership/definition')
+require('defmastership/document')
+require('defmastership/comment_filter')
+require('defmastership/csv_formatter')
+
+require('defmastership/ref_changer')
+require('defmastership/batch_changer')
+require('defmastership/project_ref_changer')

data/lib/defmastership/batch_changer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DefMastership
+  # Change references from temporary to definitive with multiple RefChangers
+  class BatchChanger
+    attr_reader :refchangers
+
+    def initialize
+      @refchangers = {}
+    end
+
+    def self.from_h(hash)
+      new.from_h(hash)
+    end
+
+    def from_h(hash)
+      @refchangers =
+        hash.transform_values do |value|
+          DefMastership::RefChanger.from_h(value)
+        end
+      self
+    end
+
+    def to_h
+      @refchangers.transform_values(&:to_h)
+    end
+
+    def replace(symb, line)
+      @refchangers.reduce(line) do |res_line, (_, refchanger)|
+        refchanger.public_send("replace_#{symb}".to_sym, res_line)
+      end
+    end
+
+    def changes
+      @refchangers.reduce([]) do |all_changes, (_, refchanger)|
+        all_changes + refchanger.changes
+      end
+    end
+  end
+end

data/lib/defmastership/comment_filter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Add a class to handled asciidoctor comments
+module DefMastership
+  attr_reader :comment_filter
+
+  # Kind of proxy that Filters comments fome Asciidoctor document
+  class CommentFilter
+    def initialize
+      @in_multiline_comment = false
+    end
+
+    def accept?(line)
+      case line
+      when DMRegexp::SINGLE_LINE_COMMENT then false
+      when DMRegexp::MULTI_LINE_COMMENT_DELIM
+        @in_multiline_comment ^= true
+        false
+      else !@in_multiline_comment
+      end
+    end
+  end
+
+  @comment_filter = CommentFilter.new
+
+  def self.reset_comments
+    @comment_filter = CommentFilter.new
+    nil
+  end
+
+  def self.comment_filter
+    @comment_filter
+  end
+end
+
+# adding a method to string to figure out if a string is commented or
+# not.
+class String
+  def commented?
+    !DefMastership.comment_filter.accept?(self)
+  end
+end

data/lib/defmastership/constants.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module DefMastership
+  # set of regexp of added asciidoctor constructions
+  module DMRegexp
+    SINGLE_LINE_COMMENT = %r{^//[^/]}.freeze
+
+    MULTI_LINE_COMMENT_DELIM = %r{^////\s*$}.freeze
+
+    DEF_BEFORE_REF = <<~'BEF'
+      ^\s*
+      \[\s*define\s*,
+      \s*(?<type>[\w:_-]+)\s*,
+      \s*
+    BEF
+
+    DEF_AFTER_REF = <<~'AFT'
+      \s*
+      (,\s*\[\s*(?<labels>.*?)\s*\])?\s*\]
+    AFT
+    DEFINITION = Regexp.new(
+      "#{DEF_BEFORE_REF}(?<reference>[\\w:_-]+)#{DEF_AFTER_REF}",
+      Regexp::EXTENDED
+    )
+
+    VARIABLE_DEF = /^\s*:(?<varname>[\w:_-]+):\s*
+                   \s*(?<value>\S.*\S)\s*$/x.freeze
+
+    VARIABLE_USE = /{(?<varname>[\w:_-]+)}/x.freeze
+
+    EREF_CONFIG = /^\s*:eref-(?<refname>[\w:_-]+)-(?<symb>prefix|url):\s*
+                   \s*(?<value>\S.*\S)\s*/x.freeze
+    EREF_DEF = /^\s*
+               defs:eref\[
+               \s*(?<refname>[\w:_-]+)\s*,
+               \s*\[(?<extrefs>[^\]]+)\]\s*\]/x.freeze
+    BLOCK = /^--\s*$/.freeze
+    LITERAL_BLOCK = /^\.\.\.\.\s*$/.freeze
+
+    IREF_DEF_BEF = 'defs:iref\[\s*'
+    IREF_DEF_AFT = '\s*\]'
+    IREF_DEF = Regexp.new(
+      "#{IREF_DEF_BEF}(?<intref>[\\w:_-]+)#{IREF_DEF_AFT}",
+      Regexp::EXTENDED
+    )
+
+    ATTR_CONFIG = /\s*:attr-(?<attr>[\w:_-]+)-prefix:
+                      \s+(?<prefix>.+?)\s*$/x.freeze
+    ATTR_SET = /\s*
+                defs:attribute\[
+                \s*(?<attr>[\w:_-]+)\s*,
+                \s*(?<value>.+?)\s*\]/x.freeze
+
+    EMPTY_LINE = /^\s*$/.freeze
+
+    WHATEVER = //.freeze
+
+    public_constant :SINGLE_LINE_COMMENT,
+                    :MULTI_LINE_COMMENT_DELIM,
+                    :DEF_BEFORE_REF,
+                    :DEF_AFTER_REF,
+                    :DEFINITION,
+                    :VARIABLE_DEF,
+                    :VARIABLE_USE,
+                    :EREF_CONFIG,
+                    :EREF_DEF,
+                    :BLOCK,
+                    :LITERAL_BLOCK,
+                    :IREF_DEF_BEF,
+                    :IREF_DEF_AFT,
+                    :IREF_DEF,
+                    :ATTR_CONFIG,
+                    :ATTR_SET,
+                    :EMPTY_LINE,
+                    :WHATEVER
+  end
+end

data/lib/defmastership/csv_formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require('csv')
+require('defmastership/csv_formatter_header')
+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)
+      @doc = doc
+      @header_formatter = CSVFormatterHeader.new(@doc)
+      @body_formatter = CSVFormatterBody.new(@doc)
+    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) }
+      end
+    end
+
+    def header
+      header_line =
+        COLUMN_LIST.map do |part|
+          @header_formatter.public_send("#{part}_header".to_sym)
+        end
+      header_line.reduce(:+)
+    end
+
+    def body(definition)
+      body_line =
+        COLUMN_LIST.map do |part|
+          @body_formatter.public_send("#{part}_body".to_sym, definition)
+        end
+      body_line.reduce(:+)
+    end
+  end
+end

data/lib/defmastership/csv_formatter_body.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require('csv')
+
+module DefMastership
+  # format lines per definition
+  class CSVFormatterBody
+    def initialize(doc)
+      @doc = doc
+    end
+
+    def fixed_body(definition)
+      [definition.type, definition.reference, definition.value]
+    end
+
+    def labels_body(definition)
+      @doc.labels.empty? ? [] : [definition.labels.to_a.join("\n")]
+    end
+
+    def eref_body(definition)
+      @doc.eref.map { |key, _| definition.eref[key].join("\n") }
+    end
+
+    def iref_body(definition)
+      @doc.iref ? [definition.iref.join("\n")] : []
+    end
+
+    def attributes_body(definition)
+      @doc.attributes.map do |key, _|
+        definition.attributes[key]
+      end
+    end
+  end
+end

data/lib/defmastership/csv_formatter_header.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require('csv')
+
+module DefMastership
+  # format header for one document
+  class CSVFormatterHeader
+    def initialize(doc)
+      @doc = doc
+    end
+
+    def fixed_header
+      %w[Type Reference Value]
+    end
+
+    def labels_header
+      @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
+    end
+
+    def iref_header
+      @doc.iref ? ['Internal links'] : []
+    end
+
+    def attributes_header
+      @doc.attributes.map { |_, value| value }
+    end
+  end
+end

data/lib/defmastership/definition.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module DefMastership
+  # DefMastership definition: contains all data of a definition
+  class Definition
+    attr_reader :type, :reference, :lines, :labels, :eref, :iref, :attributes
+
+    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
+      @eref = Hash.new([])
+      @iref = []
+      @attributes = {}
+    end
+
+    def <<(new_line)
+      @lines << new_line
+      self
+    end
+
+    def value
+      @lines.join("\n")
+    end
+
+    def add_eref(refname, extrefs)
+      @eref[refname] = extrefs.strip.split(/\s*,\s*/)
+    end
+
+    def add_iref(ref)
+      @iref << ref
+    end
+
+    def set_attribute(key, value)
+      @attributes[key] = value
+    end
+  end
+end

data/lib/defmastership/document.rb

@@ -0,0 +1,153 @@
+# 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
+      @definitions   = []
+      @labels        = Set.new
+      @eref          = {}
+      @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
+
+      event :empty_line do
+        transitions from: %i[wait_content single_para idle], to: :idle
+        transitions from: :in_block, to: :in_block
+      end
+    end
+
+    def code_block_delimiter(_match)
+      @in_literal ^= true
+    end
+
+    def add_new_definition(match)
+      definition = Definition.new(match)
+      @labels.merge(definition.labels)
+      @definitions << definition
+    end
+
+    def add_line(_match)
+      @definitions.last << @current_line
+    end
+
+    def new_eref_setup(match)
+      @eref[match[:refname].to_sym] ||= {}
+
+      @eref[match[:refname].to_sym][match[:symb].to_sym] =
+        match[:value]
+    end
+
+    def new_eref_def(match)
+      @definitions.last.add_eref(
+        match[:refname].to_sym,
+        match[:extrefs]
+      )
+    end
+
+    def new_iref_def(_match)
+      @iref = true
+      @current_line.scan(DMRegexp::IREF_DEF) do |_|
+        @definitions.last.add_iref(Regexp.last_match[:intref])
+      end
+    end
+
+    def new_attribute_conf(match)
+      @attributes[match[:attr].to_sym] = match[:prefix]
+    end
+
+    def new_attribute_value(match)
+      @definitions.last.set_attribute(
+        match[:attr].to_sym,
+        match[:value]
+      )
+    end
+
+    def new_variable_def(match)
+      @variables[match[:varname].to_sym] = match[:value]
+    end
+
+    def new_variable_use(_match)
+      @current_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]
+        )
+      end
+    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)
+          break if filter.consumed_line
+        end
+      end
+    end
+  end
+end