defmastership 1.0.1

data/lib/defmastership/project_ref_changer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DefMastership
+  # Change all refs of a given project
+  class ProjectRefChanger
+    attr_reader :yaml_config, :adoc_texts, :changes
+
+    def initialize(yaml_config, adoc_texts)
+      @yaml_config = yaml_config
+      @adoc_texts = adoc_texts
+    end
+
+    def replace_all
+      batch = BatchChanger.from_h(@yaml_config)
+
+      @adoc_texts =
+        %i[refdef irefs].reduce(@adoc_texts) do |texts, method|
+          texts.transform_values do |text|
+            text.lines.map { |line| batch.replace(method, line) }.join
+          end
+        end
+
+      @yaml_config = batch.to_h.to_yaml
+      @changes = batch.changes
+    end
+  end
+end

data/lib/defmastership/ref_changer.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module DefMastership
+  # Change references from temporary to definitive
+  class RefChanger
+    attr_reader :changes
+
+    def self.from_h(hash)
+      new.from_h(hash)
+    end
+
+    REGEXP_FROM = {
+      definition: {
+        before: DMRegexp::DEF_BEFORE_REF,
+        after: DMRegexp::DEF_AFTER_REF
+      },
+      iref: {
+        before: DMRegexp::IREF_DEF_BEF,
+        after: DMRegexp::IREF_DEF_AFT
+      }
+    }.freeze
+
+    private_constant :REGEXP_FROM
+
+    def initialize
+      @h = {
+        from_regexp: '',
+        to_template: '',
+        next_ref: 0
+      }
+      @changes = []
+      @in_literal = false
+    end
+
+    def method_missing(method_name, *args, &block)
+      return @h[method_name] if @h[method_name]
+
+      super
+    end
+
+    def respond_to_missing?(method_name, *args)
+      @h[method_name] || super
+    end
+
+    def from_h(hash)
+      @h.merge!(hash)
+      self
+    end
+
+    def to_h
+      @h
+    end
+
+    def replace_refdef(line)
+      if in_literal(line)
+        line
+      else
+        do_replace_refdef(line)
+      end
+    end
+
+    def replace_irefs(line)
+      changes.reduce(line) do |res_line, (from, to)|
+        res_line.gsub(regexp_from(:iref, from)) do
+          text_with(Regexp.last_match, to)
+        end
+      end
+    end
+
+    private
+
+    def regexp_from(const, from)
+      regexp_str =
+        "(?<before>#{REGEXP_FROM[const][:before]})" \
+        "(?<from>#{from})" \
+        "(?<after>#{REGEXP_FROM[const][:after]})"
+      Regexp.new(regexp_str, Regexp::EXTENDED)
+    end
+
+    def text_with(match, replacement)
+      match[:before] + replacement + match[:after]
+    end
+
+    def hmerge(match)
+      @h.merge(Hash[match.names.map(&:to_sym).zip(match.captures)])
+    end
+
+    def in_literal(line)
+      @in_literal ^= true if line.chomp == '....'
+      @in_literal
+    end
+
+    def do_replace_refdef(line)
+      line.gsub(regexp_from(:definition, from_regexp)) do
+        replacement = to_template % hmerge(Regexp.last_match)
+        changes << [Regexp.last_match[:from], replacement]
+        @h[:next_ref] += 1
+        text_with(Regexp.last_match, replacement)
+      end
+    end
+  end
+end

data/lib/defmastership/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module DefMastership
+  VERSION = '1.0.1'
+  public_constant :VERSION
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require('bundler/setup')
+require('aruba/rspec')
+
+# formatter = [SimpleCov::Formatter::HTMLFormatter]
+# SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(formatter)
+
+require('simplecov')
+
+SimpleCov.start do
+  command_name 'spec:unit'
+
+  add_group 'Libraries', 'lib'
+  add_group 'Unit test', 'spec/unit'
+
+  add_filter 'config'
+  add_filter 'vendor'
+
+  minimum_coverage 100
+end
+
+RSpec.configure do |config|
+  config.include(Aruba::Api)
+end
+
+RSpec::Matchers.define(:matchdata_including) do |h|
+  match do |matchdata|
+    h.all? do |key, _|
+      matchdata[key] == h[key]
+    end
+  end
+end
+
+require('defmastership')

data/spec/unit/defmastership/batch_changer_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::BatchChanger) do
+  subject(:batchchanger) { described_class.new }
+
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+    it { is_expected.to(have_attributes(refchangers: {})) }
+  end
+
+  describe '.from_h' do
+    before do
+      allow(DefMastership::RefChanger).to(receive(:from_h).once
+                                           .with(:whatever_a).and_return(:toto_a))
+    end
+
+    it { expect(described_class.from_h(a: :whatever_a)).not_to(be(nil)) }
+
+    it {
+      batchchanger = described_class.from_h(a: :whatever_a)
+      expect(batchchanger).to(have_attributes(refchangers: { a: :toto_a }))
+    }
+  end
+
+  describe '#from_h' do
+    before do
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:whatever_a).and_return(:one))
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:whatever_b).and_return(:two))
+      batchchanger.from_h(a: :whatever_a, b: :whatever_b)
+    end
+
+    it { expect(DefMastership::RefChanger).to(have_received(:from_h).with(:whatever_a)) }
+
+    it { expect(DefMastership::RefChanger).to(have_received(:from_h).with(:whatever_b)) }
+
+    it { expect(batchchanger).to(have_attributes(refchangers: { a: :one, b: :two })) }
+  end
+
+  describe '#to_h' do
+    subject(:batchchanger) { described_class.from_h(a: :a, b: :b) }
+
+    let(:refchanger_a) { instance_double(DefMastership::RefChanger, 'refchanger_a') }
+    let(:refchanger_b) { instance_double(DefMastership::RefChanger, 'refchanger_b') }
+
+    before do
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:a).and_return(refchanger_a))
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:b).and_return(refchanger_b))
+      allow(refchanger_a).to(receive(:to_h).and_return(a_a: :a_a))
+      allow(refchanger_b).to(receive(:to_h).and_return(b_b: :b_b))
+      batchchanger.to_h
+    end
+
+    it { expect(refchanger_a).to(have_received(:to_h)) }
+
+    it { expect(refchanger_b).to(have_received(:to_h)) }
+
+    it do
+      expect(batchchanger.to_h).to(eq(
+                                     a: { a_a: :a_a },
+                                     b: { b_b: :b_b }
+                                   ))
+    end
+  end
+
+  describe 'replace' do
+    subject(:batchchanger) { described_class.from_h(a: :a, b: :b) }
+
+    let(:refchanger_a) { instance_double(DefMastership::RefChanger, 'refchanger_a') }
+    let(:refchanger_b) { instance_double(DefMastership::RefChanger, 'refchanger_b') }
+
+    before do
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:a).and_return(refchanger_a))
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:b).and_return(refchanger_b))
+      allow(refchanger_a).to(receive(:public_send).with(:replace_toto, 'a line').and_return('b line'))
+      allow(refchanger_b).to(receive(:public_send).with(:replace_toto, 'b line').and_return('c line'))
+      batchchanger.replace(:toto, 'a line')
+    end
+
+    it { expect(refchanger_a).to(have_received(:public_send).with(:replace_toto, 'a line')) }
+
+    it { expect(refchanger_b).to(have_received(:public_send).with(:replace_toto, 'b line')) }
+
+    it { expect(batchchanger.replace(:toto, 'a line')).to(eq('c line')) }
+  end
+
+  describe 'changes' do
+    subject(:batchchanger) { described_class.from_h(a: :a, b: :b) }
+
+    let(:refchanger_a) { instance_double(DefMastership::RefChanger, 'refchanger_a') }
+    let(:refchanger_b) { instance_double(DefMastership::RefChanger, 'refchanger_b') }
+
+    before do
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:a).and_return(refchanger_a))
+      allow(DefMastership::RefChanger).to(receive(:from_h).with(:b).and_return(refchanger_b))
+      allow(refchanger_a).to(receive(:changes).and_return([%w[a1 a2]]))
+      allow(refchanger_b).to(receive(:changes).and_return([%w[b1 b2]]))
+    end
+
+    it do
+      expect(batchchanger.changes).to(eq([
+                                           %w[a1 a2],
+                                           %w[b1 b2]
+                                         ]))
+    end
+  end
+end

data/spec/unit/defmastership/comment_filter_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::CommentFilter) do
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+  end
+
+  describe '#accept?' do
+    subject(:comment_filter) { described_class.new }
+
+    context 'when no comment' do
+      it do
+        expect(comment_filter.accept?('whatever')).to(be(true))
+      end
+    end
+
+    context 'when single line comment' do
+      it do
+        expect(comment_filter.accept?('// whatever')).to(be(false))
+      end
+    end
+
+    context 'when bat formated single line comment' do
+      it do
+        expect(comment_filter.accept?('///')).to(be(true))
+      end
+    end
+
+    context 'when starting multiline comment' do
+      it do
+        expect(comment_filter.accept?('////')).to(be(false))
+      end
+    end
+
+    context 'when multiline comment' do
+      before do
+        comment_filter.accept?('////')
+      end
+
+      it do
+        expect(comment_filter.accept?('whatever')).to(be(false))
+      end
+    end
+
+    context 'when exiting multiline comment' do
+      before do
+        comment_filter.accept?('////')
+        comment_filter.accept?('something')
+      end
+
+      it do
+        expect(comment_filter.accept?('////')).to(be(false))
+      end
+    end
+
+    context 'when end of multiline comment' do
+      before do
+        comment_filter.accept?('////')
+        comment_filter.accept?('something')
+        comment_filter.accept?('////')
+      end
+
+      it do
+        expect(comment_filter.accept?('whatever')).to(be(true))
+      end
+    end
+  end
+
+  describe 'String .commented?' do
+    let(:comment_filter) do
+      instance_double(described_class, 'comment_filter')
+    end
+
+    before do
+      allow(DefMastership).to(receive(:comment_filter)
+        .and_return(comment_filter))
+    end
+
+    context 'when not .commented?' do
+      before do
+        allow(comment_filter).to(receive(:accept?).with('blabla').and_return(true))
+        'blabla'.commented?
+      end
+
+      it { expect(DefMastership).to(have_received(:comment_filter)) }
+
+      it { expect(comment_filter).to(have_received(:accept?).with('blabla')) }
+
+      it { expect('blabla'.commented?).to(be(false)) }
+    end
+
+    context 'when .commented?' do
+      before do
+        allow(comment_filter).to(receive(:accept?)
+          .with('blabla').and_return(false))
+      end
+
+      it do
+        expect('blabla'.commented?).to(be(true))
+      end
+    end
+  end
+
+  describe '#reset_comments' do
+    before do
+      '////'.commented?
+    end
+
+    it do
+      expect('whatever'.commented?).to(be(true))
+    end
+
+    it do
+      '////'.commented?
+      DefMastership.reset_comments
+      expect('whatever'.commented?).to(be(false))
+    end
+  end
+end

data/spec/unit/defmastership/csv_formatter_body_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require('defmastership')
+
+RSpec.describe(DefMastership::CSVFormatterBody) do
+  subject(:formatter) { described_class.new(document) }
+
+  let(:document)   { instance_double(DefMastership::Document, 'document')     }
+  let(:definition) { instance_double(DefMastership::Definition, 'definition') }
+
+  describe '.new' do
+    it { is_expected.not_to(be(nil)) }
+  end
+
+  describe '#fixed_body' do
+    before do
+      allow(definition).to(receive(:type).with(no_args).and_return('a'))
+      allow(definition).to(receive(:reference).with(no_args).and_return('b'))
+      allow(definition).to(receive(:value).with(no_args).and_return('c'))
+      formatter.fixed_body(definition)
+    end
+
+    it { expect(definition).to(have_received(:type).with(no_args)) }
+
+    it { expect(definition).to(have_received(:reference).with(no_args)) }
+
+    it { expect(definition).to(have_received(:value).with(no_args)) }
+
+    it { expect(formatter.fixed_body(definition)).to(eq(%w[a b c])) }
+  end
+
+  describe '#labels_body' do
+    context 'when no labels on document' do
+      before do
+        allow(document).to(receive(:labels).with(no_args).and_return([]))
+        formatter.labels_body(definition)
+      end
+
+      it { expect(document).to(have_received(:labels).once.with(no_args)) }
+
+      it { expect(formatter.labels_body(definition)).to(eq([])) }
+    end
+
+    context 'when labels on document' do
+      before { allow(document).to(receive(:labels).with(no_args).and_return(['whatever'])) }
+
+      context 'when no labels on definition' do
+        before do
+          allow(definition).to(receive(:labels).with(no_args).and_return([]))
+          formatter.labels_body(definition)
+        end
+
+        it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+
+        it { expect(formatter.labels_body(definition)).to(eq([''])) }
+      end
+
+      context 'when labels on definition' do
+        before do
+          allow(definition).to(receive(:labels).with(no_args).and_return(%w[toto tutu]))
+          formatter.labels_body(definition)
+        end
+
+        it { expect(definition).to(have_received(:labels).once.with(no_args)) }
+
+        it { expect(formatter.labels_body(definition)).to(eq(["toto\ntutu"])) }
+      end
+    end
+  end
+
+  describe '#eref_body' do
+    context 'when no eref on the document' do
+      before do
+        allow(document).to(receive(:eref).with(no_args).and_return({}))
+        formatter.eref_body(definition)
+      end
+
+      it { expect(document).to(have_received(:eref).with(no_args)) }
+
+      it { expect(formatter.eref_body(nil)).to(eq([])) }
+    end
+
+    context 'when eref on the document' do
+      before do
+        allow(document).to(receive(:eref).with(no_args).and_return(
+                             a: 'whatever',
+                             b: 'whatever',
+                             c: 'whatever'
+                           ))
+        allow(definition).to(receive(:eref).with(no_args).and_return(a: %w[A B], b: [], c: ['C']))
+        formatter.eref_body(definition)
+      end
+
+      it { expect(definition).to(have_received(:eref).exactly(3).times.with(no_args)) }
+
+      it { expect(formatter.eref_body(definition)).to(eq(["A\nB", '', 'C'])) }
+    end
+  end
+
+  describe '#iref_body' do
+    context 'when no iref on the document' do
+      before do
+        allow(document).to(receive(:iref).with(no_args).and_return(false))
+        formatter.iref_body(definition)
+      end
+
+      it { expect(document).to(have_received(:iref).with(no_args)) }
+
+      it { expect(formatter.iref_body(definition)).to(eq([])) }
+    end
+
+    context 'when iref on the document' do
+      before { allow(document).to(receive(:iref).with(no_args).and_return(true)) }
+
+      context 'when no iref on the definition' do
+        before do
+          allow(definition).to(receive(:iref).with(no_args).and_return([]))
+          formatter.iref_body(definition)
+        end
+
+        it { expect(definition).to(have_received(:iref).with(no_args)) }
+
+        it { expect(formatter.iref_body(definition)).to(eq([''])) }
+      end
+
+      context 'when iref on the definition' do
+        before do
+          allow(definition).to(receive(:iref).with(no_args).and_return(%w[A B]))
+          formatter.iref_body(definition)
+        end
+
+        it { expect(definition).to(have_received(:iref).with(no_args)) }
+
+        it { expect(formatter.iref_body(definition)).to(eq(["A\nB"])) }
+      end
+    end
+  end
+
+  describe '#attributes_body' do
+    context 'when no attributes on the document' do
+      before do
+        allow(document).to(receive(:attributes).with(no_args).and_return({}))
+        formatter.attributes_body(definition)
+      end
+
+      it { expect(document).to(have_received(:attributes).with(no_args)) }
+
+      it { expect(formatter.attributes_body(nil)).to(eq([])) }
+    end
+
+    context 'when attributes on the document' do
+      before do
+        allow(document).to(receive(:attributes).with(no_args).and_return(
+                             a: 'whatever',
+                             b: 'whatever',
+                             c: 'whatever'
+                           ))
+        allow(definition).to(receive(:attributes).and_return(a: 'X', b: '', c: 'Y'))
+        formatter.attributes_body(definition)
+      end
+
+      it { expect(definition).to(have_received(:attributes).exactly(3).times) }
+
+      it { expect(formatter.attributes_body(definition)).to(eq(['X', '', 'Y'])) }
+    end
+  end
+end