Your message dated Sun, 01 Mar 2026 11:35:01 -0600
with message-id <[email protected]>
and subject line Fixed in 1.49.0-1
has caused the Debian Bug report #1129159,
regarding ruby-rubocop-ast: FTBFS: Failure/Error: 
expect(RuboCop::AST::Traversal::MISSING).to eq []
to be marked as done.

This means that you claim that the problem has been dealt with.
If this is not the case it is now your responsibility to reopen the
Bug report if necessary, and/or fix the problem forthwith.

(NB: If you are a system administrator and have no idea what this
message is talking about, this may indicate a serious mail system
misconfiguration somewhere. Please contact [email protected]
immediately.)


-- 
1129159: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=1129159
Debian Bug Tracking System
Contact [email protected] with problems
--- Begin Message ---
Package: src:ruby-rubocop-ast
Version: 1.24.0-2
Severity: serious
Tags: ftbfs forky sid

Dear maintainer:

During a rebuild of all packages in unstable, this package failed to build.

Below you will find the last part of the build log (probably the most
relevant part, but not necessarily). If required, the full build log
is available here:

https://people.debian.org/~sanvila/build-logs/202602/

About the archive rebuild: The build was made on virtual machines from AWS,
using sbuild and a reduced chroot with only build-essential packages.

If you cannot reproduce the bug please contact me privately, as I
am willing to provide ssh access to a virtual machine where the bug is
fully reproducible.

If this is really a bug in one of the build-depends, please use
reassign and add an affects on src:ruby-rubocop-ast, so that this is still
visible in the BTS web page for this package.

Thanks.

--------------------------------------------------------------------------------
[...]
 debian/rules clean
dh clean --buildsystem=ruby --with ruby
   dh_auto_clean -O--buildsystem=ruby
        dh_ruby --clean
W: XS-Ruby-Versions is deprecated, and will be ignored
   dh_autoreconf_clean -O--buildsystem=ruby
   dh_clean -O--buildsystem=ruby
 debian/rules binary
dh binary --buildsystem=ruby --with ruby
   dh_update_autotools_config -O--buildsystem=ruby
   dh_autoreconf -O--buildsystem=ruby
   dh_auto_configure -O--buildsystem=ruby
        dh_ruby --configure
   debian/rules override_dh_auto_build
make[1]: Entering directory '/<<PKGBUILDDIR>>'

[... snipped ...]

    parses function calls
    parses unions of literals as a set
    parses simple sequences properly

RuboCop::AST::Node
  #recursive_basic_literal?
    behaves like non literal
      returns false for `(x == false)`
    behaves like literal
      returns true for `/./`
    behaves like literal
      returns true for `[1, 2, 3]`
    behaves like non literal
      returns false for `{ some_method_call => :sym }`
    behaves like non literal
      returns false for `some_method_call(x, y)`
    behaves like literal
      returns true for `false`
    behaves like literal
      returns true for `"#{2}"`
    behaves like non literal
      returns false for `[some_method_call]`
    behaves like literal
      returns true for `(false <=> true)`
    behaves like literal
      returns true for `%r{abx}ixo`
    behaves like literal
      returns true for `(1)`
    behaves like literal
      returns true for `!true`
    behaves like non literal
      returns false for `%r{abx#{foo}}ixo`
    behaves like literal
      returns true for `(false && true)`
    behaves like literal
      returns true for `nil`
    behaves like literal
      returns true for `{ :a => 1, :b => 2 }`
    behaves like literal
      returns true for `'str'`
    behaves like non literal
      returns false for `/.#{some_method_call}/`
    behaves like literal
      returns true for `1.0`
    behaves like literal
      returns true for `{ a: 1, b: 2 }`
    behaves like literal
      returns true for `1`
    behaves like literal
      returns true for `(false or true)`
    behaves like non literal
      returns false for `(x or false)`
    behaves like non literal
      returns false for `{ :sym => some_method_call }`
    behaves like non literal
      returns false for `some_method_call`
    behaves like non literal
      returns false for `(x && false)`
  #class_constructor?
    class definition with a block
      matches
    class definition on outer scope
      matches
    module definition with a block
      matches
    class definition
      does not match
  #numeric_type?
    when rational literal
      is true
    when complex literal whose imaginary part is a rational
      is true
    when integer literal
      is true
    when complex literal
      is true
    when float literal
      is true
    when string literal
      is true
  #module_definition?
    namespaced modules
      matches
    included module definition
      matches
    with ::ModuleName
      matches
    nested modules
      matches
    prepend Module.new
      matches
    with Module.new
      matches
      when using numbered parameter
        matches
    using module keyword
      matches
  #struct_constructor?
    struct definition with a block
      matches
    ::Struct
      matches
    struct definition without block
      does not match
  #class_definition?
    namespaced class
      matches
    with inheritance
      matches
    constant defined as Struct without block
      does not match
    with Struct
      matches
      when using numbered parameter
        matches
    with Class.new
      matches
      when using numbered parameter
        matches
    with ::ClassName
      matches
    without inheritance
      matches
    with object singleton class
      matches
    with self singleton class
      matches
  #parent_module_name
    when node on module
      is expected to eq "Foo"
    when node nested in a class << exp
      is expected to be nil
    when node on class in singleton class
      is expected to eq "Foo::#<Class:Foo>::Bar"
    when node nested in an unknown block
      is expected to be nil
    when node on top level
      is expected to eq "Object"
    when node on singleton class
      is expected to eq "Foo::#<Class:Foo>"
  #argument_type?
    method arguments
      returns true for all argument types
    block arguments
      returns true for all argument types
  #pure?
    for a class definition
      returns false
    for a cvar assignment
      returns false
    for a regexp
      with options
        returns true
      with no interpolation
        returns true
      with interpolated segments
        returns false
    for a module definition
      returns false
    for an integer literal
      returns true
    for an array literal
      which contains a method call
        returns false
      with only literal children
        returns true
    for an lvar assignment
      returns false
    for a nested if
      where one branch contains an assignment statement
        returns false
      where the innermost descendants are local vars and literals
        returns true
      where one branch contains a method call
        returns false
    for a hash literal
      with only literal children
        returns true
      which contains a method call
        returns false
    for an ivar assignment
      returns false
    for a method call
      returns false
    for a gvar assignment
      returns false
  #conditional?
    when `if` node
      is true
    when `while` node
      is true
    when `case` node
      is true
    when `until` node
      is true
    when `case_match` node
      is true
    when post condition loop node
      is false
  sibling_access
    returns trivial values for a root node
    for a node with siblings
      returns the expected values
    for a single child
      returns the expected values
  #value_used?
    at the top level
      is false
    at the end of a block
      is always true
    within an if...else..end node
      at the top level
        is true only for the condition
      nested in a method call
        is always true
    within an array literal
      at the top level
        is always false
      assigned to an ivar
        is always true
    within a module definition node
      is always true
    within a class definition node
      is always true
    within a method call node
      is always true
    within a singleton class node
      is always true
    within a while node
      is true only for the condition

Changelog
  merges correctly
  parses correctly
  Changelog::Entry
    generates correct content

Failures:

  1) RuboCop::AST::Traversal knows all current node types
     Failure/Error: expect(RuboCop::AST::Traversal::MISSING).to eq []

       expected: []
            got: [:itarg, :itblock]

       (compared using ==)

       Diff:
       @@ -1 +1 @@
       -[]
       +[:itarg, :itblock]
     # ./spec/rubocop/ast/traversal_spec.rb:97:in `block (2 levels) in <top 
(required)>'

Finished in 1.61 seconds (files took 0.59643 seconds to load)
2392 examples, 1 failure

Failed examples:

rspec ./spec/rubocop/ast/traversal_spec.rb:96 # RuboCop::AST::Traversal knows 
all current node types

Randomized with seed 12829

/usr/bin/ruby3.3 -ruri 
-I/usr/share/rubygems-integration/all/gems/rspec-support-3.13.1/lib:/usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/lib
 /usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/exe/rspec --pattern 
./spec/\*\*/\*_spec.rb --format documentation failed
/usr/lib/ruby/vendor_ruby/gem2deb.rb:52:in `run': /usr/bin/ruby3.3 
/usr/bin/gem2deb-test-runner (Gem2Deb::CommandFailed)
        from /usr/lib/ruby/vendor_ruby/gem2deb.rb:64:in `block in run_ruby'
        from /usr/lib/ruby/vendor_ruby/gem2deb.rb:87:in `maybe_crossbuild'
        from /usr/lib/ruby/vendor_ruby/gem2deb.rb:63:in `run_ruby'
        from /usr/lib/ruby/vendor_ruby/gem2deb/dh_ruby.rb:189:in 
`run_tests_for_version'
        from /usr/lib/ruby/vendor_ruby/gem2deb/dh_ruby.rb:176:in `block in 
run_tests'
        from /usr/lib/ruby/vendor_ruby/gem2deb/dh_ruby.rb:175:in `each'
        from /usr/lib/ruby/vendor_ruby/gem2deb/dh_ruby.rb:175:in `run_tests'
        from /usr/lib/ruby/vendor_ruby/gem2deb/dh_ruby.rb:71:in `run_tests'
        from /usr/lib/ruby/vendor_ruby/gem2deb/dh_ruby.rb:57:in `install'
        from /usr/lib/ruby/vendor_ruby/gem2deb/dh_ruby.rb:163:in `install'
        from /usr/bin/dh_ruby:89:in `<main>'
dh_auto_install: error: dh_ruby --install 
/<<PKGBUILDDIR>>/debian/ruby-rubocop-ast returned exit code 1
make: *** [debian/rules:7: binary] Error 25
dpkg-buildpackage: error: debian/rules binary subprocess failed with exit 
status 2
--------------------------------------------------------------------------------

--- End Message ---
--- Begin Message ---
Hello,

This bug is fixed in 1.49.0-1. If you can still reproduce the failure, please 
provide a build log.

Thanks,
Simon Quigley
[email protected]

--- End Message ---

Reply via email to