[SCM] ci-tooling packaging branch, master, updated. 569b3ca0d1ab57271dae2d0f08fabbc2e43b700a

[Harald Sitter]

Gitweb-URL: http://git.debian.org/?p=pkg-kde/ci-tooling.git;a=commitdiff;h=569b3ca

The following commit has been merged in the master branch:
commit 569b3ca0d1ab57271dae2d0f08fabbc2e43b700a
Author: Harald Sitter <sitter at kde.org>
Date:   Tue Mar 24 15:20:50 2015 +0100

    add a qml ignorerule class implementing a per-package ignore rule format
    
    this is currently not wired up to the verifier
    
    ignore rules are of the format NAME\s+VERSION, where version is in fact
    optional. ignore rules are read from path via IgnoreRule.read returning
    an array. it is the class consumer's responsibility to check ignoriyness
    via rule.ignore?(qml_module). rule matching is as dynamic as possibly
    
    a) names can include wildcarding as per File.fnmatch e.g. org.kde.* matches
       all org.kde modules
    b) since version is optional in the format a nil version matches everything
       in the future this might change to support more precise matching with
       ~> >= <= = etc (no use case for it right now)
---
 lib/qml_ignore_rule.rb                   | 43 +++++++++++++++
 test/data/test_qml_ignore_rule/test_read |  4 ++
 test/test_qml_ignore_rule.rb             | 90 ++++++++++++++++++++++++++++++++
 3 files changed, 137 insertions(+)

diff --git a/lib/qml_ignore_rule.rb b/lib/qml_ignore_rule.rb
new file mode 100644
index 0000000..374168d
--- /dev/null
+++ b/lib/qml_ignore_rule.rb
@@ -0,0 +1,43 @@
+require_relative 'qml'
+
+module QML
+  # Sepcifies an ignore rule for a qml module.
+  class IgnoreRule
+    attr_reader :identifier
+    attr_reader :version
+
+    def ignore?(qml_module)
+      return false unless match_version?(qml_module)
+      match_identifier?(qml_module)
+    end
+
+    # @return [Array<IgnoreRule>] array of ignore rules read from path
+    def self.read(path)
+      rules = File.read(path).split($/)
+      rules.collect! do |line|
+        new(*line.split(/\s+/))
+      end
+      rules.compact
+    end
+
+    private
+
+    def initialize(identifier, version = nil)
+      @identifier = identifier
+      @version = version
+      unless @version.nil? || @version.is_a?(String)
+        fail 'Version must either be nil or a string'
+      end
+      return unless @identifier.nil? || @identifier.empty?
+      fail 'No valid identifier set. Needs to be a string and not empty'
+    end
+
+    def match_version?(qml_module)
+      @version.nil? || @version == qml_module.version
+    end
+
+    def match_identifier?(qml_module)
+      File.fnmatch(@identifier, qml_module.identifier)
+    end
+  end
+end
diff --git a/test/data/test_qml_ignore_rule/test_read b/test/data/test_qml_ignore_rule/test_read
new file mode 100644
index 0000000..7145e20
--- /dev/null
+++ b/test/data/test_qml_ignore_rule/test_read
@@ -0,0 +1,4 @@
+org.kde.kwin 1.0
+org.kde.plasma                                              
+org.kde.plasma.abc           2.0
+org.kde.plasma.*	1.0
diff --git a/test/test_qml_ignore_rule.rb b/test/test_qml_ignore_rule.rb
new file mode 100644
index 0000000..c52c438
--- /dev/null
+++ b/test/test_qml_ignore_rule.rb
@@ -0,0 +1,90 @@
+require_relative '../lib/qml_ignore_rule'
+require_relative 'lib/testcase'
+
+# Test qml ignore rules
+class QMLIgnoreRuleTest < TestCase
+  def new_rule(identifier, version = nil)
+    QML::IgnoreRule.send(:new, identifier, version)
+  end
+
+  def new_mod(id, version = nil)
+    QML::Module.new(id, version)
+  end
+
+  def test_init
+    assert_raise RuntimeError do
+      new_rule(nil, nil)
+    end
+    assert_raise RuntimeError do
+      new_rule('id', 1.0) # Float version
+    end
+    r = new_rule('id', 'version')
+    assert_equal('id', r.identifier)
+    assert_equal('version', r.version)
+  end
+
+  # @return [Array] used as send_array for assert_send
+  def send_identifier(id, mod)
+    [new_rule(id), :match_identifier?, mod]
+  end
+
+  def assert_identifier(id, mod, message = nil)
+    assert_send(send_identifier(id, mod), message)
+  end
+
+  def assert_not_identifier(id, mod, message = nil)
+    assert_not_send(send_identifier(id, mod), message)
+  end
+
+  def test_match_id
+    mod = QML::Module.new('org.kde.plasma.abc')
+    truthies = %w(
+      org.kde.plasma.*
+      org.kde.plasma.abc
+      org.kde.plasma.abc*
+    )
+    truthies.each { |t| assert_identifier(t, mod) }
+    falsies = %w(
+      org.kde.plasma
+      org.kde.plasma.abc.*
+    )
+    falsies.each { |f| assert_not_identifier(f, mod) }
+  end
+
+  def test_match_version
+    id = 'org.kde.plasma.abc'
+    mod = QML::Module.new(id, '1.0')
+    assert_send([new_rule(id, '1.0'), :match_version?, mod])
+    assert_send([new_rule(id, nil), :match_version?, mod])
+    assert_not_send([new_rule(id, '2.0'), :match_version?, mod])
+  end
+
+  def test_ignore
+    id = 'org.kde.plasma'
+    version = '2.0'
+    r = new_rule(id, version)
+    assert_false(r.ignore?(new_mod('org.kde', version)))
+    assert_false(r.ignore?(new_mod(id, '1.0')))
+    assert_true(r.ignore?(new_mod(id, version)))
+    r = new_rule(id, nil) # nil version should match anything
+    assert_true(r.ignore?(new_mod(id, version)))
+    assert_true(r.ignore?(new_mod(id, '1.0')))
+    assert_true(r.ignore?(new_mod(id, nil)))
+  end
+
+  def test_read
+    r = QML::IgnoreRule.read(data)
+    expected = {
+      'org.kde.kwin' => '1.0',
+      'org.kde.plasma' => nil,
+      'org.kde.plasma.abc' => '2.0',
+      'org.kde.plasma.*' => '1.0'
+    }
+    r.each do |rule|
+      next unless expected.keys.include?(rule.identifier)
+      version = expected.delete(rule.identifier)
+      assert_equal(version, rule.version, 'Versions do not match')
+    end
+    assert_empty(expected, "Did not get all expected rules")
+  end
+end

-- 
ci-tooling packaging