defmastership 1.0.19 → 1.1.1

data/lib/defmastership/update_def_version_modifier.rb

@@ -1,91 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require 'defmastership/constants'
-require 'defmastership/update_def_modifier'
-require 'git'
-require 'tmpdir'
-
-module DefMastership
-  # modify one line after another
-  class UpdateDefVersionModifier < UpdateDefModifier
-    def self.default_config
-      {
-        def_type: '',
-        ref_document: [],
-        ref_tag: '',
-        ref_repo: '.',
-        first_version: ''
-      }
-    end
-
-    def initialize(config)
-      @ref_document = Document.new
-
-      Helper.normalilize_config(config) if config.key?(:ref_document)
-
-      super
-    end
-
-    def do_modifications(adoc_sources)
-      if ref_tag == ''
-        ref_document.each { |ref_doc| @ref_document.parse_file_with_preprocessor(ref_doc) }
-      else
-        Dir.mktmpdir('defmastership') do |tmpdir|
-          parse_ref_files_from_git(adoc_sources, tmpdir)
-        end
-      end
-
-      super
-    end
-
-    private
-
-    def parse_ref_files_from_git(adoc_sources, tmpdir)
-      Git.clone(ref_repo, tmpdir, branch: ref_tag)
-      ref_sources = ref_document.empty? ? adoc_sources.keys : ref_document
-      ref_sources.each do |adoc_file|
-        @ref_document.parse_file_with_preprocessor("#{tmpdir}/#{adoc_file}")
-      end
-    end
-
-    def reference_replacement(reference, match)
-      "#{reference}#{version_and_checksum_str(match)}"
-    end
-
-    def version_and_checksum_str(match)
-      explicit_checksum = match[:explicit_checksum]
-      version = version_string(match)
-      return unless explicit_checksum || version
-
-      "(#{version}#{explicit_checksum})"
-    end
-
-    def version_string(match)
-      ref_definition = Helper.def_from_match(@ref_document, match)
-      definition = Helper.def_from_match(document, match)
-      return unless ref_definition
-
-      Helper.ref_version(ref_definition, definition, first_version)
-    end
-
-    # Helper functions
-    module Helper
-      def self.def_from_match(doc, match)
-        doc.ref_to_def(match[:reference])
-      end
-
-      def self.ref_version(ref_definition, definition, first_version)
-        new_ref_version = ref_definition.explicit_version
-        return new_ref_version if definition.sha256_short == ref_definition.sha256_short
-
-        new_ref_version ? new_ref_version.next : first_version
-      end
-
-      def self.normalilize_config(config)
-        ref_docs = config.fetch(:ref_document)
-        config[:ref_document] = [ref_docs] if ref_docs.instance_of?(String)
-      end
-    end
-  end
-end

data/spec/unit/def_mastership/modifier_factory_spec.rb

@@ -1,38 +0,0 @@
-# Copyright (c) 2023 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership/modifier_factory')
-
-module DefMastership
-  # Modifier example
-  class TotoModifier
-    include Modifier
-  end
-end
-
-RSpec.describe(DefMastership::ModifierFactory) do
-  describe('.from_config') do
-    let(:toto)        { instance_double(DefMastership::TotoModifier, 'toto') }
-    let(:toto_config) { { type: 'toto', config: { p: 'whatever' } }          }
-    let(:tutu)        { instance_double(DefMastership::TotoModifier, 'tutu') }
-    let(:tutu_config) { { type: 'tu_tu', config: { p: 'whatever' } }         }
-
-    before do
-      allow(DefMastership::TotoModifier).to(receive(:new).with(toto_config[:config]).and_return(toto))
-      allow(DefMastership::TuTuModifier).to(receive(:new).with(tutu_config[:config]).and_return(tutu))
-    end
-
-    it { expect(described_class.from_config(toto_config)).to(be(toto)) }
-    it { expect(described_class.from_config(tutu_config)).to(be(tutu)) }
-
-    it do
-      described_class.from_config(toto_config)
-      expect(DefMastership::TotoModifier).to(have_received(:new).with(toto_config[:config]))
-    end
-
-    it do
-      described_class.from_config(tutu_config)
-      expect(DefMastership::TuTuModifier).to(have_received(:new).with(tutu_config[:config]))
-    end
-  end
-end

data/spec/unit/def_mastership/parsing_state_spec.rb

@@ -1,62 +0,0 @@
-# Copyright (c) 2020 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('defmastership/parsing_state')
-
-RSpec.describe(DefMastership::ParsingState) do
-  subject(:parsing_state) do
-    described_class.new
-  end
-
-  describe '.new' do
-    it { is_expected.not_to(be_nil) }
-  end
-
-  describe '#enabled_with?' do
-    context 'when single line commment' do
-      it { expect(parsing_state.enabled?("//whatever\n")).to(be(false)) }
-    end
-
-    context 'when starting' do
-      it { expect(parsing_state.enabled?("whatever\n")).to(be(true)) }
-      it { expect(parsing_state.enabled?("----\n")).to(be(false)) }
-      it { expect(parsing_state.enabled?("....\n")).to(be(false)) }
-      it { expect(parsing_state.enabled?("////\n")).to(be(false)) }
-      it { expect(parsing_state.enabled?('....')).to(be(false)) }
-    end
-
-    context 'when disabled' do
-      before { parsing_state.enabled?("----\n") }
-
-      it { expect(parsing_state.enabled?("whatever\n")).to(be(false)) }
-      it { expect(parsing_state.enabled?("----\n")).to(be(true)) }
-      it { expect(parsing_state.enabled?("....\n")).to(be(false)) }
-      it { expect(parsing_state.enabled?("////\n")).to(be(false)) }
-    end
-
-    context 'with intricated disables starting with "...."' do
-      before do
-        ["....\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
-      end
-
-      it { expect(parsing_state.enabled?("----\n")).to(be(false)) }
-      it { expect(parsing_state.enabled?("....\n")).to(be(true)) }
-    end
-
-    context 'with intricated disables starting with "----"' do
-      before do
-        ["....\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
-      end
-
-      it { expect(parsing_state.enabled?("....\n")).to(be(true)) }
-    end
-
-    context 'with intricated disables starting with "////"' do
-      before do
-        ["////\n", "----\n", "whatever\n"].each { |line| parsing_state.enabled?(line) }
-      end
-
-      it { expect(parsing_state.enabled?("////\n")).to(be(true)) }
-    end
-  end
-end

data/tasks/package.task

@@ -1,9 +0,0 @@
-# Copyright (c) 2023 Jerome Arbez-Gindre
-# frozen_string_literal: true
-
-require('rubygems')
-require('rubygems/package_task')
-
-spec = eval(File.read('defmastership.gemspec'))
-
-Gem::PackageTask.new(spec)