bfa 1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae42ae351e604214e30e6871459e0d01c0f6198e
+  data.tar.gz: 8c13cb054ffcae83d12529eef8942f1ece28dddd
+SHA512:
+  metadata.gz: ddff1aa18d8d7d1ebc5b803e98d7e6081a1291b1ecb9e55453a6e029a3ef979c27eecc8d9536c1d39904ee9d3a8fa644a6aa155966e93da2ee25eaa75e8af1ea
+  data.tar.gz: 6dc29d2d65144f0489e28b7ebca03a05180178d7b7c7c3c69dffb20880ffffd467f335d01ce5142e9b86c433f896d8d29d076cd2b94eb19d8f2f7da7dc702914

data/lib/bfa.rb

@@ -0,0 +1,47 @@
+BFA = Module.new
+
+require "rgfa"
+
+require_relative "bfa/constants"
+require_relative "bfa/reader"
+require_relative "bfa/writer"
+
+class RGFA
+
+  def to_bfa(filename, compressed=true)
+    BFA::Writer.encode(filename, self, compressed)
+    return nil
+  end
+
+  class << self
+
+    alias_method :from_gfa, :from_file
+
+    def from_file(filename)
+      f = File.open(filename)
+      is_gzip = (f.read(2).bytes == [31,139])
+      if is_gzip
+        # currently only gzipped bfa are supported
+        f.close
+        from_bfa(filename)
+      end
+      is_bfa = (f.read(4) == BFA::Constants::MAGIC_STRING)
+      f.close
+      if is_bfa
+        from_bfa(filename)
+      else
+        from_gfa(filename)
+      end
+    end
+
+    def from_bfa(filename)
+      BFA::Reader.parse(filename)
+    end
+
+  end
+
+end
+
+class RGFA::Line
+  attr_accessor :line_id
+end

data/lib/bfa/binary_cigar.rb

@@ -0,0 +1,11 @@
+module BFA::BinaryCigar
+
+  OPCODE_TO_NUM = {
+    :"M" => 0, :"I" => 1, :"D" => 2, :"N" => 3,
+    :"S" => 4, :"H" => 5, :"P" => 6, :"=" => 7,
+    :"X" => 8
+  }
+
+  NUM_TO_OPCODE = OPCODE_TO_NUM.invert
+
+end

data/lib/bfa/binary_cigar/decode.rb

@@ -0,0 +1,14 @@
+require_relative "../binary_cigar"
+
+module BFA::BinaryCigar::Decode
+
+  def parse_binary_cigar
+    RGFA::CIGAR::Operation.new(self >> 4,
+                               BFA::BinaryCigar::NUM_TO_OPCODE[self & 15])
+  end
+
+end
+
+class Integer
+  include BFA::BinaryCigar::Decode
+end

data/lib/bfa/binary_cigar/encode.rb

@@ -0,0 +1,14 @@
+require_relative "../binary_cigar"
+
+module BFA::BinaryCigar::Encode
+
+    def to_binary
+      (len << 4) |
+        BFA::BinaryCigar::OPCODE_TO_NUM[code]
+    end
+
+end
+
+class RGFA::CIGAR::Operation
+  include BFA::BinaryCigar::Encode
+end

data/lib/bfa/constants.rb

@@ -0,0 +1,25 @@
+module BFA::Constants
+
+  MAGIC_STRING = "BFA\1"
+
+  SIZEOF_TEMPLATE_CODE = "L<"
+
+  SIZEOF_SIZE = 4
+
+  INTEGER_DATATYPES = [:i, :I, :c, :C, :s, :S]
+
+  NUMERIC_TEMPLATE_CODE = {
+    :c => "c", :C => "C",
+    :s => "s<", :S => "S<",
+    :i => "l<", :I => "L<",
+    :f => "E"
+  }
+
+  NUMERIC_SIZE = {
+    :c => 1, :C => 1,
+    :s => 2, :S => 2,
+    :i => 4, :I => 4,
+    :f => 8
+  }
+
+end

data/lib/bfa/error.rb

@@ -0,0 +1,2 @@
+# Parent class for errors raised by the RGFATools library
+class BFA::Error < StandardError; end

data/lib/bfa/four_bit_sequence.rb

@@ -0,0 +1,12 @@
+module BFA::FourBitSequence
+
+  LETTER_TO_CODE = {
+    "=" => 0, "A" => 1, "C" => 2, "M" => 3,
+    "G" => 4, "R" => 5, "S" => 6, "V" => 7,
+    "T" => 8, "W" => 9, "Y" => 10, "H" => 11,
+    "K" => 12, "D" => 13, "B" => 14, "N" => 15,
+  }
+
+  CODE_TO_LETTER = LETTER_TO_CODE.invert
+
+end

data/lib/bfa/four_bit_sequence/decode.rb

@@ -0,0 +1,18 @@
+require_relative "../four_bit_sequence"
+
+module BFA::FourBitSequence::Decode
+
+  def parse_4bits(strsize)
+    retval = ""
+    each do |code|
+      retval << BFA::FourBitSequence::CODE_TO_LETTER[code >> 4]
+      retval << BFA::FourBitSequence::CODE_TO_LETTER[code & 15]
+    end
+    return retval[0..strsize-1]
+  end
+
+end
+
+class RGFA::ByteArray
+  include BFA::FourBitSequence::Decode
+end

data/lib/bfa/four_bit_sequence/encode.rb

@@ -0,0 +1,26 @@
+require_relative "../four_bit_sequence"
+
+module BFA::FourBitSequence::Encode
+
+  def to_4bits
+    retval = RGFA::ByteArray.new()
+    byte = nil
+    each_char do |char|
+      code = BFA::FourBitSequence::LETTER_TO_CODE[char.upcase]
+      code ||= 15
+      if byte.nil?
+        byte = (code << 4)
+      else
+        retval << (byte + code)
+        byte = nil
+      end
+    end
+    retval << byte if !byte.nil?
+    return retval
+  end
+
+end
+
+class String
+  include BFA::FourBitSequence::Encode
+end

data/lib/bfa/reader.rb

@@ -0,0 +1,289 @@
+require "rgfa"
+require "zlib"
+require_relative "constants"
+require_relative "binary_cigar/decode"
+require_relative "four_bit_sequence/decode"
+
+class BFA::Reader
+
+  include BFA::Constants
+
+  # @see BFA::Writer to write BFA files.
+  def initialize(filename)
+    file = File.new(filename)
+    magic = file.read(2)
+    file.rewind
+    if magic.bytes == [31, 139]
+      @io = Zlib::GzipReader.new(file)
+    else
+      @io = file
+    end
+  end
+
+  def close
+    @io.close
+  end
+
+  # @return [RGFA]
+  def parse
+    rgfa = RGFA.new
+    validate_magic_string!
+    parse_headers(rgfa)
+    parse_segments(rgfa)
+    parse_links(rgfa)
+    parse_containments(rgfa)
+    parse_paths(rgfa)
+    return rgfa
+  end
+
+  def self.parse(filename)
+    br = self.new(filename)
+    rgfa = br.parse
+    br.close
+    return rgfa
+  end
+
+  private
+
+  def validate_magic_string!
+    ms = @io.read(MAGIC_STRING.size)
+    unless ms == MAGIC_STRING
+      raise BFA::Reader::FormatError,
+        "Magic string not recognized (#{ms.inspect})"
+    end
+  end
+
+  def parse_headers(rgfa)
+    n_optfields = parse_size
+    n_optfields.times do
+      n, t, v = parse_optfield
+      rgfa.header.add(n, v, t)
+    end
+    # <debug> "Headers data: #{rgfa.header}"
+  end
+
+  def parse_segments(rgfa)
+    n_segments = parse_size
+    # <debug> "N.segments: #{n_segments}"
+    n_segments.times do
+      parse_segment(rgfa)
+    end
+  end
+
+  def parse_optfields(line_data)
+    n_optfields = parse_size
+    # <debug> "N.optfields: #{n_optfields}"
+    n_optfields.times do
+      n, t, v = parse_optfield
+      line_data[n] = [v, t]
+    end
+  end
+
+  def parse_segment(rgfa)
+    line_data = {}
+    line_data[:name] = parse_varlenstr.to_sym
+    line_data[:sequence] = parse_sequence
+    parse_optfields(line_data)
+    # <debug> "Segment data: #{line_data}"
+    segment = RGFA::Line::Segment.new(line_data)
+    rgfa << segment
+  end
+
+  def parse_links(rgfa)
+    n_links = parse_size
+    # <debug> "N.links: #{n_links}"
+    n_links.times do
+      parse_edge(rgfa)
+    end
+  end
+
+  def parse_containments(rgfa)
+    n_containments = parse_size
+    # <debug> "N.containments: #{n_containments}"
+    n_containments.times do
+      parse_edge(rgfa, true)
+    end
+  end
+
+  def parse_edge(rgfa, containment=false)
+    line_data = {}
+    [:from, :to].each do |dir|
+      line_id = parse_numeric_value(:i)
+      line_data[:"#{dir}_orient"] = line_id > 0 ? :+ : :-
+      line_data[dir] = rgfa.segment_names[(line_id.abs)-1].to_sym
+    end
+    line_data[:overlap] = parse_cigar
+    if containment
+      line_data[:pos] = parse_numeric_value(:I)
+    end
+    parse_optfields(line_data)
+    # <debug> "Edge data: #{line_data}"
+    edge = containment ?
+             RGFA::Line::Containment.new(line_data) :
+             RGFA::Line::Link.new(line_data)
+    rgfa << edge
+  end
+
+  def parse_paths(rgfa)
+    n_paths = parse_size
+    # <debug> "N.paths: #{n_paths}"
+    n_paths.times do
+      parse_path(rgfa)
+    end
+  end
+
+  def parse_path(rgfa)
+    line_data = {}
+    line_data[:path_name] = parse_varlenstr.to_sym
+    n_links = parse_size
+    circular = false
+    if n_links < 0
+      n_links = -n_links
+      circular = true
+    end
+    line_data[:segment_names] = []
+    line_data[:cigars] = []
+    n_links.times do |i|
+      line_id = parse_numeric_value(:i)
+      reverse_link = line_id < 0
+      link = rgfa.links[line_id.abs-1]
+      link = link.reverse if reverse_link
+      if line_data[:segment_names].empty?
+        line_data[:segment_names] <<
+          [link.from, link.from_orient].to_oriented_segment
+      end
+      if !circular or i < (n_links-1)
+        line_data[:segment_names] <<
+          [link.to, link.to_orient].to_oriented_segment
+      end
+      line_data[:cigars] << link.overlap
+    end
+    parse_optfields(line_data)
+    # <debug> "Path data: #{line_data}"
+    rgfa << RGFA::Line::Path.new(line_data)
+  end
+
+  def parse_optfield
+    fieldname = parse_fixlenstr(2).to_sym
+    datatype = parse_fixlenstr(1).to_sym
+    value = parse_data_item(datatype.to_sym)
+    datatype = :i if INTEGER_DATATYPES.include?(datatype)
+    # <debug> "Optfield #{fieldname}:#{datatype}:#{value.inspect}"
+    return fieldname, datatype, value
+  end
+
+  def parse_data_item(datatype)
+    # <assert> datatype.kind_of?(Symbol)
+    case datatype
+    when :A
+      parse_fixlenstr(1)
+    when :Z
+      parse_cstr
+    when :J
+      parse_cstr
+    when :i, :I, :c, :C, :s, :S, :f
+      parse_numeric_value(datatype)
+    when :B
+      parse_numeric_array
+    when :H
+      parse_byte_array
+    else
+      # <assert> false # this should be impossible
+    end
+  end
+
+  def parse_sequence
+    seqsize = parse_size
+    if seqsize == 0
+      return "*"
+    else
+      n_values = (seqsize.to_f/2).ceil
+      parse_values(NUMERIC_SIZE[:C], NUMERIC_TEMPLATE_CODE[:C],
+                   n_values).to_byte_array.parse_4bits(seqsize)
+    end
+  end
+
+  def parse_cigar
+    cigar = parse_numeric_values(:I)
+    if cigar.empty?
+      return "*"
+    else
+      return cigar.map(&:parse_binary_cigar)
+    end
+  end
+
+  def parse_numeric_array
+    st = parse_fixlenstr(1).to_sym
+    parse_numeric_values(st).to_numeric_array
+  end
+
+  def parse_byte_array
+    parse_numeric_values(:C).to_byte_array
+  end
+
+  def parse_numeric_value(val_type)
+    # <assert> NUMERIC_SIZE.has_key?(val_type)
+    # <assert> NUMERIC_TEMPLATE_CODE.has_key?(val_type)
+    parse_value(NUMERIC_SIZE[val_type],
+                NUMERIC_TEMPLATE_CODE[val_type])
+  end
+
+  def parse_numeric_values(val_type)
+    # <assert> NUMERIC_SIZE.has_key?(val_type)
+    # <assert> NUMERIC_TEMPLATE_CODE.has_key?(val_type)
+    asize = parse_size
+    if asize == 0
+      return []
+    else
+      parse_values(NUMERIC_SIZE[val_type],
+                   NUMERIC_TEMPLATE_CODE[val_type], asize)
+    end
+  end
+
+  def parse_varlenstr
+    strsize = parse_size
+    parse_fixlenstr(strsize)
+  end
+
+  def parse_size
+    s = parse_value(SIZEOF_SIZE, SIZEOF_TEMPLATE_CODE)
+    return s
+  end
+
+  def parse_fixlenstr(len)
+    read!(len)
+  end
+
+  def parse_cstr
+    str = ""
+    loop do
+      c = @io.getc
+      if c.nil?
+        raise BFA::Reader::FormatError
+      elsif c == "\0"
+        return str
+      else
+        str << c
+      end
+    end
+  end
+
+  def parse_value(val_size, val_template_code)
+    read!(val_size).unpack(val_template_code)[0]
+  end
+
+  def parse_values(val_size, val_template_code, numfields)
+    read!(val_size*numfields).unpack(val_template_code+numfields.to_s)
+  end
+
+  def read!(val_size)
+    str = @io.read(val_size)
+    if str.nil? or str.size < val_size
+      raise BFA::Reader::FormatError
+    end
+    return str
+  end
+
+end
+
+require_relative "reader/format_error"

data/lib/bfa/reader/format_error.rb

@@ -0,0 +1,4 @@
+require_relative "../error"
+
+# Exception raised if file parsing fails
+class BFA::Reader::FormatError < BFA::Error; end

data/lib/bfa/writer.rb

@@ -0,0 +1,273 @@
+require "rgfa"
+require "zlib"
+require_relative "constants"
+require_relative "binary_cigar/encode"
+require_relative "four_bit_sequence/encode"
+
+class BFA::Writer
+
+  include BFA::Constants
+
+  # @return [RGFATools::BFAWriter]
+  def initialize(filename, compressed=true)
+    @template = ""
+    @data = []
+    file = File.new(filename, "w")
+    @io = compressed ? Zlib::GzipWriter.new(file) : file
+    @io.print BFA::Constants::MAGIC_STRING
+  end
+
+  def encode(rgfa)
+    add_headers(rgfa)
+    add_segments(rgfa)
+    add_links(rgfa)
+    add_containments(rgfa)
+    add_paths(rgfa)
+  end
+
+  def close
+    @io.close
+  end
+
+  def self.encode(filename, rgfa, compressed=true)
+    bw = self.new(filename, compressed)
+    bw.encode(rgfa)
+    bw.close
+    return nil
+  end
+
+  private
+
+  def add_headers(rgfa)
+    headers_array = rgfa.header.tags
+    add_size_of(headers_array)
+    headers_array.each do |fieldname, val_type, value|
+      add_optfield(fieldname, value, val_type)
+    end
+    write_data
+  end
+
+  def add_optfields(rgfa_line)
+    add_size_of(rgfa_line.optional_fieldnames)
+    rgfa_line.optional_fieldnames.each do |of|
+      add_optfield(of, rgfa_line.get(of), rgfa_line.get_datatype(of))
+    end
+  end
+
+  def add_segments(rgfa)
+    add_size_of(rgfa.segment_names)
+    rgfa.segment_names.each_with_index do |segment_name, i|
+      s = rgfa.segment!(segment_name)
+      add_varlenstr(segment_name)
+      add_sequence(s.sequence)
+      add_optfields(s)
+      write_data
+      s.line_id = i
+    end
+  end
+
+  def add_containments(rgfa)
+    add_edges(rgfa, true)
+  end
+
+  def add_links(rgfa)
+    add_edges(rgfa, false)
+  end
+
+  def add_edges(rgfa, containments=false)
+    add_size_of(containments ? rgfa.containments : rgfa.links)
+    sn = rgfa.segment_names
+    link_id = 0
+    sn.each_with_index do |segment_name, segment_id|
+      if containments
+        edges = rgfa.contained_in(segment_name)
+      else
+        edges = [:+, :-].map do |orientation|
+          rgfa.links_from([segment_name, orientation], false)
+        end.flatten
+      end
+      edges.each do |edge|
+        dir_id = {:from => segment_id,
+                  :to => rgfa.segment(edge.to).line_id}
+        [:from, :to].each do |dir|
+          dir_id[dir] += 1
+          dir_id[dir] = -dir_id[dir] if edge.get(:"#{dir}_orient") == :-
+          add_numeric_value(:i, dir_id[dir])
+        end
+        add_cigar(edge.overlap)
+        add_numeric_value(:I, edge.pos) if containments
+        add_optfields(edge)
+        write_data
+        if not containments
+          edge.line_id = link_id
+          link_id += 1
+        end
+      end
+    end
+  end
+
+  def add_paths(rgfa)
+    add_size_of(rgfa.paths)
+    rgfa.paths.each do |path|
+      add_varlenstr(path.path_name)
+      links = path.links
+      # <debug> "Path links: #{links.inspect}"
+      n_links = links.size
+      n_links = -n_links if path.circular?
+      add_numeric_value(:i, n_links)
+      link_ids = links.map do |link, link_or|
+        line_id = link.line_id + 1
+        # <debug> "line_id: #{line_id.inspect}"
+        # <debug> "link_or: #{link_or.inspect}"
+        link_or ? line_id : -line_id
+      end
+      # <debug> "link ids: #{link_ids.inspect}"
+      add_numeric_values(:i, link_ids, false)
+      add_optfields(path)
+      write_data
+    end
+  end
+
+  # Add an optional field to the record
+  def add_optfield(fieldname, value, val_type)
+    val_type ||= value.gfa_datatype
+    add_fixlenstr(fieldname)
+    add_fixlenstr(val_type)
+    add_data_item(val_type, value)
+  end
+
+  def write_data
+    @io.print(@data.pack(@template))
+    @template = ""
+    @data = []
+  end
+
+  # Add a value to the record
+  # @param value [Object|String] a ruby object or its rgfa datastring
+  #   representation
+  # @param datatype [RGFA::Line::FIELD_DATATYPE] the datatype of the data
+  # @return [void]
+  def add_data_item(datatype, value)
+    # <assert> RGFA::Line::FIELD_DATATYPE.include?(datatype)
+    case datatype
+    when :A
+      add_fixlenstr(value)
+    when :Z
+      add_cstr(value)
+    when :J
+      value = value.to_gfa_datastring(:J) if value.kind_of?(String)
+      add_cstr(value)
+    when :i
+      add_int(value)
+    when :f
+      add_double(value)
+    when :B
+      add_numeric_array(value)
+    when :H
+      add_byte_array(value)
+    end
+    return nil
+  end
+
+  def add_sequence(seq)
+    if seq == "*"
+      add_numeric_value(:I, 0)
+    else
+      add_size_of(seq)
+      add_values(NUMERIC_TEMPLATE_CODE[:C], seq.to_4bits)
+    end
+  end
+
+  def add_cigar(cigar)
+    cigar = cigar.to_cigar
+    if cigar.empty?
+      add_numeric_value(:I, 0)
+    else
+      add_numeric_values(:I, cigar.map(&:to_binary))
+    end
+  end
+
+  def add_int(int)
+    int = Integer(int)
+    int_type = RGFA::NumericArray.integer_type(int..int)
+    replace_fixlenstr(int_type)
+    add_numeric_value(RGFA::NumericArray.integer_type(int..int).to_sym, int)
+  end
+
+  def add_double(float)
+    add_numeric_value(:f, Float(float))
+  end
+
+  def add_numeric_array(array)
+    array = array.parse_datastring(:B) if array.kind_of?(String)
+    array = array.to_numeric_array
+    st = array.compute_subtype
+    add_fixlenstr(st)
+    add_numeric_values(st.to_sym, array)
+  end
+
+  def add_byte_array(array)
+    array = array.parse_datastring(:H) if array.kind_of?(String)
+    array = array.to_byte_array
+    add_numeric_values(:C, array)
+  end
+
+  def add_fixlenstr(string)
+    add_string(string)
+  end
+
+  def replace_fixlenstr(string)
+    # <assert> @data.last.size == string.size
+    @data.last.replace(string)
+  end
+
+  def add_cstr(string)
+    # <assert> string.kind_of?(String) or string.kind_of?(Symbol)
+    add_string(string.to_s + "\0")
+  end
+
+  def add_varlenstr(string)
+    # <assert> string.kind_of?(String) or string.kind_of?(Symbol)
+    add_size_of(string.to_s)
+    add_string(string)
+  end
+
+  def add_string(string)
+    # <assert> string.kind_of?(String) or string.kind_of?(Symbol)
+    # <assert> string.size > 0
+    string = string.to_s
+    add_value("Z#{string.size}", string)
+  end
+
+  def add_numeric_value(val_type, number)
+    # <assert> NUMERIC_TEMPLATE_CODE.has_key?(val_type)
+    # <assert> number.kind_of?(Numeric)
+    add_value(NUMERIC_TEMPLATE_CODE[val_type], number)
+  end
+
+  def add_numeric_values(val_type, array, with_size = true)
+    # <assert> NUMERIC_TEMPLATE_CODE.has_key?(val_type)
+    # <assert> array.kind_of?(Array)
+    # <assert> array.each? {|e| e.kind_of?(Numeric)}
+    add_size_of(array) if with_size
+    add_values(NUMERIC_TEMPLATE_CODE[val_type], array)
+  end
+
+  def add_size_of(object)
+    # <assert> object.kind_of?(Array) or object.kind_of?(String)
+    add_value(SIZEOF_TEMPLATE_CODE, object.size)
+  end
+
+  def add_value(template, value)
+    # <assert> value.kind_of?(String) or value.kind_of?(Numeric)
+    @template << template
+    @data << value
+  end
+
+  def add_values(template, array)
+    # <assert> array.kind_of?(Array)
+    @template += (template + array.size.to_s)
+    @data += array
+  end
+
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: bfa
+version: !ruby/object:Gem::Version
+  version: '1.1'
+platform: ruby
+authors:
+- Giorgio Gonnella
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-22 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      The Graphical Fragment Assembly (GFA) is a proposed format which allow
+      to describe the product of sequence assembly and is implemented in the
+      RGFA class defined in the rgfa gem.
+
+      The GFA format is a text format. This gem defines a complementary binary
+      format, BFA. The methods in this class allow to write a BFA file from a
+      RGFA object, and to parse a BFA file into a RGFA object. This also allows
+      the conversion from/to GFA format.
+
+      This gem depends on the "rgfa" gem.
+email: gonnella@zbh.uni-hamburg.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bfa.rb
+- lib/bfa/binary_cigar.rb
+- lib/bfa/binary_cigar/decode.rb
+- lib/bfa/binary_cigar/encode.rb
+- lib/bfa/constants.rb
+- lib/bfa/reader.rb
+- lib/bfa/reader/format_error.rb
+- lib/bfa/error.rb
+- lib/bfa/four_bit_sequence.rb
+- lib/bfa/four_bit_sequence/decode.rb
+- lib/bfa/four_bit_sequence/encode.rb
+- lib/bfa/writer.rb
+homepage: http://github.com/ggonnella/bfa
+licenses:
+- CC-BY-SA
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Write and parse the BFA format in Ruby
+test_files: []
+has_rdoc: