ruby-dbus 0.16.0 → 0.17.0

data/lib/dbus/object.rb

@@ -7,9 +7,11 @@
 # See the file "COPYING" for the exact licensing terms.
 
 require "thread"
-require "dbus/core_ext/class/attribute"
+require_relative "core_ext/class/attribute"
 
 module DBus
+  PROPERTY_INTERFACE = "org.freedesktop.DBus.Properties".freeze
+
   # Exported object type
   # = Exportable D-Bus object class
   #
@@ -58,7 +60,7 @@ module DBus
           meth.rets.zip(retdata).each do |rsig, rdata|
             reply.add_param(rsig.type, rdata)
           end
-        rescue => ex
+        rescue StandardError => ex
           dbus_msg_exc = msg.annotate_exception(ex)
           reply = ErrorMessage.from_exception(dbus_msg_exc).reply_to(msg)
         end
@@ -85,45 +87,294 @@ module DBus
       end
     end
 
-    # Dummy undefined interface class.
-    class UndefinedInterface < ScriptError
+    # Forgetting to declare the interface for a method/signal/property
+    # is a ScriptError.
+    class UndefinedInterface < ScriptError # rubocop:disable Lint/InheritException
       def initialize(sym)
-        super "No interface specified for #{sym}"
+        super "No interface specified for #{sym}. Enclose it in dbus_interface."
+      end
+    end
+
+    # A read-write property accessing an instance variable.
+    # A combination of `attr_accessor` and {.dbus_accessor}.
+    #
+    # PropertiesChanged signal will be emitted whenever `foo_bar=` is used
+    # but not when @foo_bar is written directly.
+    #
+    # @param ruby_name [Symbol] :foo_bar is exposed as FooBar;
+    #   use dbus_name to override
+    # @param type a signature like "s" or "a(uus)" or Type::STRING
+    # @param dbus_name [String] if not given it is made
+    #   by CamelCasing the ruby_name. foo_bar becomes FooBar
+    #   to convert the Ruby convention to the DBus convention.
+    # @return [void]
+    def self.dbus_attr_accessor(ruby_name, type, dbus_name: nil)
+      attr_accessor(ruby_name)
+      dbus_accessor(ruby_name, type, dbus_name: dbus_name)
+    end
+
+    # A read-only property accessing an instance variable.
+    # A combination of `attr_reader` and {.dbus_reader}.
+    #
+    # Whenever the property value gets changed from "inside" the object,
+    # you should emit the `PropertiesChanged` signal by calling
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {dbus_name.to_s => value}, [])
+    #
+    # or, omitting the value in the signal,
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {}, [dbus_name.to_s])
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_attr_reader(ruby_name, type, dbus_name: nil)
+      attr_reader(ruby_name)
+      dbus_reader(ruby_name, type, dbus_name: dbus_name)
+    end
+
+    # A write-only property accessing an instance variable.
+    # A combination of `attr_writer` and {.dbus_writer}.
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_attr_writer(ruby_name, type, dbus_name: nil)
+      attr_writer(ruby_name)
+      dbus_writer(ruby_name, type, dbus_name: dbus_name)
+    end
+
+    # A read-write property using a pair of reader/writer methods
+    # (which must already exist).
+    # (To directly access an instance variable, use {.dbus_attr_accessor} instead)
+    #
+    # Uses {.dbus_watcher} to set up the PropertiesChanged signal.
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_accessor(ruby_name, type, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+      property = Property.new(dbus_name, type, :readwrite, ruby_name: ruby_name)
+      @@cur_intf.define(property)
+
+      dbus_watcher(ruby_name, dbus_name: dbus_name)
+    end
+
+    # A read-only property accessing a reader method (which must already exist).
+    # (To directly access an instance variable, use {.dbus_attr_reader} instead)
+    #
+    # Whenever the property value gets changed from "inside" the object,
+    # you should emit the `PropertiesChanged` signal by calling
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {dbus_name.to_s => value}, [])
+    #
+    # or, omitting the value in the signal,
+    #
+    #   object[DBus::PROPERTY_INTERFACE].PropertiesChanged(interface_name, {}, [dbus_name.to_s])
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_reader(ruby_name, type, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+      property = Property.new(dbus_name, type, :read, ruby_name: ruby_name)
+      @@cur_intf.define(property)
+    end
+
+    # A write-only property accessing a writer method (which must already exist).
+    # (To directly access an instance variable, use {.dbus_attr_writer} instead)
+    #
+    # Uses {.dbus_watcher} to set up the PropertiesChanged signal.
+    #
+    # @param  (see .dbus_attr_accessor)
+    # @return (see .dbus_attr_accessor)
+    def self.dbus_writer(ruby_name, type, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+      property = Property.new(dbus_name, type, :write, ruby_name: ruby_name)
+      @@cur_intf.define(property)
+
+      dbus_watcher(ruby_name, dbus_name: dbus_name)
+    end
+
+    # Enables automatic sending of the PropertiesChanged signal.
+    # For *ruby_name* `foo_bar`, wrap `foo_bar=` so that it sends
+    # the signal for FooBar.
+    # The original version remains as `_original_foo_bar=`.
+    #
+    # @param ruby_name [Symbol] :foo_bar and :foo_bar= both mean the same thing
+    # @param dbus_name [String] if not given it is made
+    #   by CamelCasing the ruby_name. foo_bar becomes FooBar
+    #   to convert the Ruby convention to the DBus convention.
+    # @return [void]
+    def self.dbus_watcher(ruby_name, dbus_name: nil)
+      raise UndefinedInterface, ruby_name if @@cur_intf.nil?
+      cur_intf = @@cur_intf
+
+      ruby_name = ruby_name.to_s.sub(/=$/, "").to_sym
+      ruby_name_eq = "#{ruby_name}=".to_sym
+      original_ruby_name_eq = "_original_#{ruby_name_eq}"
+
+      dbus_name = make_dbus_name(ruby_name, dbus_name: dbus_name)
+
+      # the argument order is alias_method(new_name, existing_name)
+      alias_method original_ruby_name_eq, ruby_name_eq
+      define_method ruby_name_eq do |value|
+        public_send(original_ruby_name_eq, value)
+
+        # TODO: respect EmitsChangedSignal to use invalidated_properties instead
+        # PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
+        PropertiesChanged(cur_intf.name, { dbus_name.to_s => value }, [])
       end
     end
 
     # Defines an exportable method on the object with the given name _sym_,
     # _prototype_ and the code in a block.
-    def self.dbus_method(sym, protoype = "", &block)
+    # @param prototype [Prototype]
+    def self.dbus_method(sym, prototype = "", &block)
       raise UndefinedInterface, sym if @@cur_intf.nil?
-      @@cur_intf.define(Method.new(sym.to_s).from_prototype(protoype))
-      define_method(Object.make_method_name(@@cur_intf.name, sym.to_s), &block)
+      @@cur_intf.define(Method.new(sym.to_s).from_prototype(prototype))
+
+      ruby_name = Object.make_method_name(@@cur_intf.name, sym.to_s)
+      # ::Module#define_method(name) { body }
+      define_method(ruby_name, &block)
     end
 
     # Emits a signal from the object with the given _interface_, signal
     # _sig_ and arguments _args_.
+    # @param intf [Interface]
+    # @param sig [Signal]
+    # @param args arguments for the signal
     def emit(intf, sig, *args)
       @service.bus.emit(@service, self, intf, sig, *args)
     end
 
     # Defines a signal for the object with a given name _sym_ and _prototype_.
-    def self.dbus_signal(sym, protoype = "")
+    def self.dbus_signal(sym, prototype = "")
       raise UndefinedInterface, sym if @@cur_intf.nil?
       cur_intf = @@cur_intf
-      signal = Signal.new(sym.to_s).from_prototype(protoype)
-      cur_intf.define(Signal.new(sym.to_s).from_prototype(protoype))
+      signal = Signal.new(sym.to_s).from_prototype(prototype)
+      cur_intf.define(Signal.new(sym.to_s).from_prototype(prototype))
+
+      # ::Module#define_method(name) { body }
       define_method(sym.to_s) do |*args|
         emit(cur_intf, signal, *args)
       end
     end
 
-    ####################################################################
-
     # Helper method that returns a method name generated from the interface
     # name _intfname_ and method name _methname_.
     # @api private
     def self.make_method_name(intfname, methname)
       "#{intfname}%%#{methname}"
     end
+
+    # TODO: borrow a proven implementation
+    # @param str [String]
+    # @return [String]
+    # @api private
+    def self.camelize(str)
+      str.split(/_/).map(&:capitalize).join("")
+    end
+
+    # Make a D-Bus conventional name, CamelCased.
+    # @param ruby_name [String,Symbol] eg :do_something
+    # @param dbus_name [String,Symbol,nil] use this if given
+    # @return [Symbol] eg DoSomething
+    def self.make_dbus_name(ruby_name, dbus_name: nil)
+      dbus_name ||= camelize(ruby_name.to_s)
+      dbus_name.to_sym
+    end
+
+    # @param interface_name [String]
+    # @param property_name [String]
+    # @return [Property]
+    # @raise [DBus::Error]
+    # @api private
+    def dbus_lookup_property(interface_name, property_name)
+      # what should happen for unknown properties
+      # plasma: InvalidArgs (propname), UnknownInterface (interface)
+      # systemd: UnknownProperty
+      interface = intfs[interface_name]
+      if !interface
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownProperty"),
+              "Property '#{interface_name}.#{property_name}' (on object '#{@path}') not found: no such interface"
+      end
+
+      property = interface.properties[property_name.to_sym]
+      if !property
+        raise DBus.error("org.freedesktop.DBus.Error.UnknownProperty"),
+              "Property '#{interface_name}.#{property_name}' (on object '#{@path}') not found"
+      end
+
+      property
+    end
+
+    ####################################################################
+
+    # use the above defined methods to declare the property-handling
+    # interfaces and methods
+
+    dbus_interface PROPERTY_INTERFACE do
+      dbus_method :Get, "in interface_name:s, in property_name:s, out value:v" do |interface_name, property_name|
+        property = dbus_lookup_property(interface_name, property_name)
+
+        if property.readable?
+          ruby_name = property.ruby_name
+          value = public_send(ruby_name)
+          [value]
+        else
+          raise DBus.error("org.freedesktop.DBus.Error.PropertyWriteOnly"),
+                "Property '#{interface_name}.#{property_name}' (on object '#{@path}') is not readable"
+        end
+      end
+
+      dbus_method :Set, "in interface_name:s, in property_name:s, in val:v" do |interface_name, property_name, value|
+        property = dbus_lookup_property(interface_name, property_name)
+
+        if property.writable?
+          ruby_name_eq = "#{property.ruby_name}="
+          public_send(ruby_name_eq, value)
+        else
+          raise DBus.error("org.freedesktop.DBus.Error.PropertyReadOnly"),
+                "Property '#{interface_name}.#{property_name}' (on object '#{@path}') is not writable"
+        end
+      end
+
+      dbus_method :GetAll, "in interface_name:s, out value:a{sv}" do |interface_name|
+        interface = intfs[interface_name]
+        if !interface
+          raise DBus.error("org.freedesktop.DBus.Error.UnknownProperty"),
+                "Properties '#{interface_name}.*' (on object '#{@path}') not found: no such interface"
+        end
+
+        p_hash = {}
+        interface.properties.each do |p_name, property|
+          next unless property.readable?
+
+          ruby_name = property.ruby_name
+          begin
+            # D-Bus spec says:
+            # > If GetAll is called with a valid interface name for which some
+            # > properties are not accessible to the caller (for example, due
+            # > to per-property access control implemented in the service),
+            # > those properties should be silently omitted from the result
+            # > array.
+            # so we will silently omit properties that fail to read.
+            # Get'ting them individually will send DBus.Error
+            p_hash[p_name.to_s] = public_send(ruby_name)
+          rescue StandardError
+            DBus.logger.debug "Property '#{interface_name}.#{p_name}' (on object '#{@path}')" \
+                              " has raised during GetAll, omitting it"
+          end
+        end
+
+        [p_hash]
+      end
+
+      dbus_signal :PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
+    end
   end
 end

data/lib/dbus/proxy_object.rb

@@ -44,6 +44,7 @@ module DBus
     end
 
     # Returns the interfaces of the object.
+    # @return [Array<String>] names of the interfaces
     def interfaces
       introspect unless introspected
       @interfaces.keys
@@ -129,6 +130,11 @@ module DBus
     ####################################################
     private
 
+    # rubocop:disable Style/MethodMissing
+    # but https://github.com/rubocop-hq/ruby-style-guide#no-method-missing
+    # and http://blog.marc-andre.ca/2010/11/15/methodmissing-politely/
+    # have a point to be investigated
+
     # Handles all unkown methods, mostly to route method calls to the
     # default interface.
     def method_missing(name, *args, &reply_handler)
@@ -150,5 +156,6 @@ module DBus
         raise NoMethodError, "undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
       end
     end
+    # rubocop:enable Style/MethodMissing
   end # class ProxyObject
 end

data/lib/dbus/proxy_object_interface.rb

@@ -87,6 +87,7 @@ module DBus
     end
 
     # Defines a proxied method on the interface.
+    # Better name: declare_method
     def define_method(methodname, prototype)
       m = Method.new(methodname)
       m.from_prototype(prototype)

data/lib/dbus/type.rb

@@ -9,6 +9,24 @@
 # See the file "COPYING" for the exact licensing terms.
 
 module DBus
+  # Like a {Signature} but containing only a single complete type.
+  #
+  # For documentation purposes only.
+  class SingleCompleteType < String; end
+
+  # Zero or more {SingleCompleteType}s; its own type code is "g".
+  # For example "ssv" for a method taking two Strings and a Variant/
+  #
+  # For documentation purposes only.
+  class Signature < String; end
+
+  # Similar to {Signature} but for {DBus::Object.define_method},
+  # contains names and direction of the parameters.
+  # For example "in query:s, in case_sensitive:b, out results:ao".
+  #
+  # For documentation purposes only.
+  class Prototype < String; end
+
   # = D-Bus type module
   #
   # This module containts the constants of the types specified in the D-Bus

data/ruby-dbus.gemspec

@@ -18,15 +18,17 @@ GEMSPEC = Gem::Specification.new do |s|
   ]
   s.require_path = "lib"
 
-  s.required_ruby_version = ">= 2.0.0"
+  s.required_ruby_version = ">= 2.1.0"
+
+  s.add_dependency "rexml"
 
   # This is optional
   # s.add_runtime_dependency "nokogiri"
 
-  s.add_development_dependency "coveralls"
   s.add_development_dependency "packaging_rake_tasks"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", "~> 3"
-  s.add_development_dependency "rubocop", "= 0.41.2"
+  s.add_development_dependency "rubocop", "= 0.50.0"
   s.add_development_dependency "simplecov"
+  s.add_development_dependency "simplecov-lcov"
 end

data/spec/main_loop_spec.rb

@@ -70,7 +70,7 @@ describe "MainLoopTest" do
     @obj.on_signal "LongTaskEnd"
   end
 
-  it "tests loop quit" do
+  it "tests loop quit", slow: true do
     test_loop_quit 1
   end
 

data/spec/property_spec.rb

@@ -4,8 +4,8 @@ require "dbus"
 
 describe "PropertyTest" do
   before(:each) do
-    session_bus = DBus::ASessionBus.new
-    @svc = session_bus.service("org.ruby.service")
+    @session_bus = DBus::ASessionBus.new
+    @svc = @session_bus.service("org.ruby.service")
     @obj = @svc.object("/org/ruby/MyInstance")
     @iface = @obj["org.ruby.SampleInterface"]
   end
@@ -21,6 +21,10 @@ describe "PropertyTest" do
     expect(iface["ReadMe"]).to eq("READ ME")
   end
 
+  it "gets an error when reading a property whose implementation raises" do
+    expect { @iface["Explosive"] }.to raise_error(DBus::Error, /Something failed/)
+  end
+
   it "tests property nonreading" do
     expect { @iface["WriteMe"] }.to raise_error(DBus::Error, /not readable/)
   end
@@ -31,7 +35,7 @@ describe "PropertyTest" do
   end
 
   # https://github.com/mvidner/ruby-dbus/pull/19
-  it "tests service select timeout" do
+  it "tests service select timeout", slow: true do
     @iface["ReadOrWriteMe"] = "VALUE"
     expect(@iface["ReadOrWriteMe"]).to eq("VALUE")
     # wait for the service to become idle
@@ -64,4 +68,50 @@ describe "PropertyTest" do
   it "tests unknown property writing" do
     expect { @iface["Spoon"] = "FPRK" }.to raise_error(DBus::Error, /not found/)
   end
+
+  it "errors for a property on an unknown interface" do
+    # our idiomatic way would error out on interface lookup already,
+    # so do it the low level way
+    prop_if = @obj[DBus::PROPERTY_INTERFACE]
+    expect { prop_if.Get("org.ruby.NoSuchInterface", "SomeProperty") }.to raise_error(DBus::Error) do |e|
+      expect(e.name).to match(/UnknownProperty/)
+      expect(e.message).to match(/no such interface/)
+    end
+  end
+
+  it "errors for GetAll on an unknown interface" do
+    # no idiomatic way?
+    # so do it the low level way
+    prop_if = @obj[DBus::PROPERTY_INTERFACE]
+    expect { prop_if.GetAll("org.ruby.NoSuchInterface") }.to raise_error(DBus::Error) do |e|
+      expect(e.name).to match(/UnknownProperty/)
+      expect(e.message).to match(/no such interface/)
+    end
+  end
+
+  it "receives a PropertiesChanged signal", slow: true do
+    received = {}
+
+    # TODO: for client side, provide a helper on_properties_changed,
+    # or automate it even more in ProxyObject, ProxyObjectInterface
+    prop_if = @obj[DBus::PROPERTY_INTERFACE]
+    prop_if.on_signal("PropertiesChanged") do |_interface_name, changed_props, _invalidated_props|
+      received.merge!(changed_props)
+    end
+
+    @iface["ReadOrWriteMe"] = "VALUE"
+
+    # loop to process the signal. complicated :-( see signal_spec.rb
+    loop = DBus::Main.new
+    loop << @session_bus
+    quitter = Thread.new do
+      sleep 1
+      loop.quit
+    end
+    loop.run
+    # quitter has told loop.run to quit
+    quitter.join
+
+    expect(received["ReadOrWriteMe"]).to eq("VALUE")
+  end
 end

data/spec/service_newapi.rb

@@ -59,6 +59,26 @@ class Test < DBus::Object
     dbus_method :mirror_byte_array, "in bytes:ay, out mirrored:ay" do |bytes|
       [bytes]
     end
+
+    # Properties:
+    # ReadMe:string, returns "READ ME" at first, then what WriteMe received
+    # WriteMe:string
+    # ReadOrWriteMe:string, returns "READ OR WRITE ME" at first
+    dbus_attr_accessor :read_or_write_me, "s"
+    dbus_attr_reader :read_me, "s"
+
+    def write_me=(value)
+      @read_me = value
+    end
+    dbus_writer :write_me, "s"
+
+    dbus_attr_writer :password, "s"
+
+    # a property that raises when client tries to read it
+    def explosive
+      raise "Something failed"
+    end
+    dbus_reader :explosive, "s"
   end
 
   # closing and reopening the same interface
@@ -118,72 +138,6 @@ class Test < DBus::Object
     dbus_signal :LongTaskStart
     dbus_signal :LongTaskEnd
   end
-
-  # Properties:
-  # ReadMe:string, returns "READ ME" at first, then what WriteMe received
-  # WriteMe:string
-  # ReadOrWriteMe:string, returns "READ OR WRITE ME" at first
-  dbus_interface PROPERTY_INTERFACE do
-    dbus_method :Get, "in interface:s, in propname:s, out value:v" do |interface, propname|
-      unless interface == INTERFACE
-        raise DBus.error("org.freedesktop.DBus.Error.UnknownInterface"),
-              "Interface '#{interface}' not found on object '#{@path}'"
-      end
-
-      case propname
-      when "ReadMe"
-        [@read_me]
-      when "ReadOrWriteMe"
-        [@read_or_write_me]
-      when "WriteMe"
-        raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"),
-              "Property '#{interface}.#{propname}' (on object '#{@path}') is not readable"
-      else
-        # what should happen for unknown properties
-        # plasma: InvalidArgs (propname), UnknownInterface (interface)
-        raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"),
-              "Property '#{interface}.#{propname}' not found on object '#{@path}'"
-      end
-    end
-
-    dbus_method :Set, "in interface:s, in propname:s, in  value:v" do |interface, propname, value|
-      unless interface == INTERFACE
-        raise DBus.error("org.freedesktop.DBus.Error.UnknownInterface"),
-              "Interface '#{interface}' not found on object '#{@path}'"
-      end
-
-      case propname
-      when "ReadMe"
-        raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"),
-              "Property '#{interface}.#{propname}' (on object '#{@path}') is not writable"
-      when "ReadOrWriteMe"
-        @read_or_write_me = value
-        self.PropertiesChanged(interface, { propname => value }, [])
-      when "WriteMe"
-        @read_me = value
-        self.PropertiesChanged(interface, { "ReadMe" => value }, [])
-      else
-        raise DBus.error("org.freedesktop.DBus.Error.InvalidArgs"),
-              "Property '#{interface}.#{propname}' not found on object '#{@path}'"
-      end
-    end
-
-    dbus_method :GetAll, "in interface:s, out value:a{sv}" do |interface|
-      unless interface == INTERFACE
-        raise DBus.error("org.freedesktop.DBus.Error.UnknownInterface"),
-              "Interface '#{interface}' not found on object '#{@path}'"
-      end
-
-      [
-        {
-          "ReadMe" => @read_me,
-          "ReadOrWriteMe" => @read_or_write_me
-        }
-      ]
-    end
-
-    dbus_signal :PropertiesChanged, "interface:s, changed_properties:a{sv}, invalidated_properties:as"
-  end
 end
 
 class Derived < Test

data/spec/signal_spec.rb

@@ -29,7 +29,7 @@ describe "SignalHandlerTest" do
   end
 
   # testing for commit 017c83 (kkaempf)
-  it "tests overriding a handler" do
+  it "tests overriding a handler", slow: true do
     DBus.logger.debug "Inside test_overriding_a_handler"
     counter = 0
 
@@ -52,7 +52,7 @@ describe "SignalHandlerTest" do
     expect(counter).to eq(1)
   end
 
-  it "tests on signal overload" do
+  it "tests on signal overload", slow: true do
     DBus.logger.debug "Inside test_on_signal_overload"
     counter = 0
     started = false
@@ -74,7 +74,7 @@ describe "SignalHandlerTest" do
     expect { @intf.on_signal "to", "many", "yarrrrr!" }.to raise_error(ArgumentError)
   end
 
-  it "is possible to add signal handlers from within handlers" do
+  it "is possible to add signal handlers from within handlers", slow: true do
     ended = false
     @intf.on_signal "LongTaskStart" do
       @intf.on_signal "LongTaskEnd" do

data/spec/spec_helper.rb

@@ -2,8 +2,7 @@ coverage = if ENV["COVERAGE"]
              ENV["COVERAGE"] == "true"
            else
              # heuristics: enable for interactive builds (but not in OBS)
-             # or in Travis
-             ENV["DISPLAY"] || ENV["TRAVIS"]
+             ENV["DISPLAY"]
            end
 
 if coverage
@@ -15,11 +14,24 @@ if coverage
   # do not cover the activesupport helpers
   SimpleCov.add_filter "/core_ext/"
 
-  # use coveralls for on-line code coverage reporting at Travis CI
-  if ENV["TRAVIS"]
-    require "coveralls"
-  end
   SimpleCov.start
+
+  # additionally use the LCOV format for on-line code coverage reporting at CI
+  if ENV["COVERAGE_LCOV"] == "true"
+    require "simplecov-lcov"
+
+    SimpleCov::Formatter::LcovFormatter.config do |c|
+      c.report_with_single_file = true
+      # this is the default Coveralls GitHub Action location
+      # https://github.com/marketplace/actions/coveralls-github-action
+      c.single_report_path = "coverage/lcov.info"
+    end
+
+    SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::LcovFormatter
+    ]
+  end
 end
 
 $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)

data/spec/tools/dbus-limited-session.conf

@@ -25,4 +25,8 @@
        Instead, lower some so that we can test resource leaks. -->
   <limit name="max_match_rules_per_connection">50</limit><!-- was 512 -->
 
+  <!--
+dbus-daemon[1700]: [session uid=1001 pid=1700] Unable to set up new connection: Failed to get AppArmor confinement information of socket peer: Protocol not available
+  -->
+  <apparmor mode="disabled"/>
 </busconfig>