gfa 0.1.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8388ee28f1d71339d701b32e2a4fa1538b0f391f
-  data.tar.gz: 520590efdc7170cf805db8427574e6e6fb5a8ac1
+SHA256:
+  metadata.gz: 0e8e61ff97b34654b7a660b011826ad5549f66933a91a09658facf58c3fd56b1
+  data.tar.gz: 8f85f07955e71cd38a9dfa28011c70433473ad6a1137ed3e6e217d63eeba20a8
 SHA512:
-  metadata.gz: c8e8366d01006fbffc22ae49f3b4d619d8e8fbf25ef2c6173b427f05382a28c8a9efd7798f791d05c890e3057d3115ca8d3a6bc6d330551bf0915569c89ecc5c
-  data.tar.gz: c6bcd711d7841585e6452cca87564b5d2e41a673e1bc4869df632db6193b928bbc6374ca370d8033db8df70e377234f3aa0a5f3a9ae96c56f053b771dff78060
+  metadata.gz: 5b9f8fd92cd30d9e4e5c0263e938169141749c7be43011b574f937c9645608d8e72189bfe9072d7321e3acdf7e8288cecf42c90abe3ceef2bf001780bdb3e472
+  data.tar.gz: ee33c0b9c0dc9adb2df96d95b792b060b248e2f991ed5a0e4b4c136d66f04b9be6cf5ca58462bce046c6cfd9e7fed6c4c6949cb5e8923eb71e3d5f53f0da2703

data/Gemfile

@@ -1,3 +1,9 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 gemspec
-gem "codeclimate-test-reporter", group: :test, require: nil
+
+group :test do
+  gem "simplecov"
+  gem "codeclimate-test-reporter", "~> 1.0.0"
+end
+
+gem 'rake', '~> 13.0'

data/LICENSE

@@ -1,6 +1,6 @@
-               The Artistic License 2.0
+                    The Artistic License 2.0
 
-           Copyright (c) 2016 Luis M Rodriguez-R
+           Copyright (c) 2016-2023 Luis M Rodriguez-R
 
      Everyone is permitted to copy and distribute verbatim copies
       of this license document, but changing it is not allowed.

data/README.md

@@ -13,20 +13,20 @@ This implementation follows the specifications of [GFA-spec][].
 To parse a file in GFA format:
 
 ```ruby
-require "gfa"
+require 'gfa'
 
-my_gfa = GFA.load("assembly.gfa")
+my_gfa = GFA.load('assembly.gfa')
 ```
 
 To load GFA strings line-by-line:
 
 ```ruby
-require "gfa"
+require 'gfa'
 
 my_gfa = GFA.new
-fh = File.open("assembly.gfa", "r")
+fh = File.open('assembly.gfa', 'r')
 fh.each do |ln|
-   my_gfa << ln
+  my_gfa << ln
 end
 fh.close
 ```
@@ -37,15 +37,15 @@ fh.close
 After altering a GFA object, you can simply save it in a file as:
 
 ```ruby
-my_gfa.save("alt-assembly.gfa")
+my_gfa.save('alt-assembly.gfa')
 ```
 
 Or line-by-line as:
 
 ```ruby
-fh = File.open("alt-assembly.gfa", "w")
+fh = File.open('alt-assembly.gfa', 'w')
 my_gfa.each_line do |ln|
-   fh.puts ln
+  fh.puts ln
 end
 fh.close
 ```
@@ -58,12 +58,12 @@ Any `GFA` object can be exported as an [`RGL`][rgl] graph using the methods
 [tiny.gfa](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.gfa):
 
 ```ruby
-require "gfa"
-require "rgl/dot"
+require 'gfa'
+require 'rgl/dot'
 
-my_gfa = GFA.load("data/tiny.gfa")
+my_gfa = GFA.load('data/tiny.gfa')
 dg = my_gfa.implicit_graph
-dg.write_to_graphic_file("jpg")
+dg.write_to_graphic_file('jpg')
 ```
 
 ![tiny_dg](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.jpg)
@@ -72,8 +72,8 @@ If you don't care about orientation, you can also build an undirected graph
 without orientation:
 
 ```ruby
-ug = my_gfa.implicit_graph(orient:false)
-ug.write_to_graphic_file("jpg")
+ug = my_gfa.implicit_graph(orient: false)
+ug.write_to_graphic_file('jpg')
 ```
 
 ![tiny_ug](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny_undirected.jpg)
@@ -85,6 +85,14 @@ ug.write_to_graphic_file("jpg")
 gem install gfa
 ```
 
+Or add the following line to your Gemfile:
+
+```ruby
+gem 'gfa'
+```
+
+and run `bundle install` from your shell.
+
 
 # Author
 
@@ -96,5 +104,5 @@ gem install gfa
 [Artistic License 2.0](LICENSE).
 
 [GFA-spec]: https://github.com/pmelsted/GFA-spec
-[lrr]: http://lmrodriguezr.github.io/
+[lrr]: https://rodriguez-r.com/
 [rgl]: https://github.com/monora/rgl

data/Rakefile

@@ -1,16 +1,17 @@
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-$:.unshift File.join(File.dirname(__FILE__), "lib")
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
 
-require "gfa/version"
+require 'gfa/version'
 
-SOURCES = FileList["lib/**/*.rb"]
+SOURCES = FileList['lib/**/*.rb']
 
-desc "Default Task"
+desc 'Default Task'
 task :default => :test
 
 Rake::TestTask.new do |t|
-   t.libs << "test"
-   t.pattern = "test/*_test.rb"
-   t.verbose = true
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
 end

data/lib/gfa/common.rb

@@ -1,45 +1,42 @@
-require "gfa/version"
-require "gfa/record"
-require "gfa/field"
+require 'gfa/version'
+require 'gfa/record_set'
+require 'gfa/field'
 
 class GFA
-   
-   # Class-level
-   def self.assert_format(value, regex, message)
-      unless value =~ regex
-         raise "#{message}: #{value}."
-      end
-   end
-
-   # Instance-level
-   attr :gfa_version, :records
-   GFA::Record.TYPES.each do |r_type|
-      plural = "#{r_type.downcase}s"
-      singular = "#{r_type.downcase}"
-      define_method(plural) do
-         records[r_type]
-      end
-      define_method(singular) do |k|
-         records[r_type][k]
-      end
-      define_method("add_#{singular}") do |v|
-         @records[r_type] << v
-      end
-   end
-
-   def initialize
-      @records = {}
-      GFA::Record.TYPES.each { |t| @records[t] = [] }
-   end
-   
-   def empty?
-      records.values.all? { |r| r.empty? }
-   end
-
-   def eql?(gfa)
-      records == gfa.records
-   end
-
-   alias == eql?
-   
+  # Class-level
+  def self.assert_format(value, regex, message)
+    unless value =~ /^(?:#{regex})$/
+      raise "#{message}: #{value}"
+    end
+  end
+
+  # Instance-level
+  attr :gfa_version, :records, :opts
+
+  GFA::Record.TYPES.each do |r_type|
+    plural = "#{r_type.downcase}s"
+    singular = "#{r_type.downcase}"
+
+    define_method(plural) { records[r_type] }
+    define_method(singular) { |k| records[r_type][k] }
+    define_method("add_#{singular}") { |v| @records[r_type] << v }
+  end
+
+  def initialize(opts = {})
+    @records = {}
+    @opts = { index: true, comments: false }.merge(opts)
+    GFA::Record.TYPES.each do |t|
+      @records[t] = GFA::RecordSet.name_class(t).new(self)
+    end
+  end
+
+  def empty?
+    records.empty? || records.values.all?(&:empty?)
+  end
+
+  def eql?(gfa)
+    records == gfa.records
+  end
+
+  alias == eql?
 end

data/lib/gfa/field/char.rb

@@ -1,10 +1,10 @@
 class GFA::Field::Char < GFA::Field
   CODE = :A
-  REGEX = /^[!-~]$/
+  REGEX = /[!-~]/
+  NATIVE_FUN = :to_s
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
-
 end

data/lib/gfa/field/float.rb

@@ -1,10 +1,26 @@
 class GFA::Field::Float < GFA::Field
   CODE = :f
-  REGEX = /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/
+  REGEX = /[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/
+  NATIVE_FUN = :to_f
+
+  def to_f
+    value
+  end
+
+  def to_i
+    value.to_i
+  end
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_f
   end
 
+  def equivalent?(field)
+    if field.is_a?(GFA::Field::NumArray)
+      return field.size == 1 && field.first.to_f == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/hex.rb

@@ -1,10 +1,26 @@
 class GFA::Field::Hex < GFA::Field
   CODE = :H
-  REGEX = /^[0-9A-F]+$/
+  REGEX = /[0-9A-F]+/
+  NATIVE_FUN = :to_i
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
 
+  def to_i
+    value.to_i(16)
+  end
+
+  def to_f
+    to_i.to_f
+  end
+
+  def equivalent?(field)
+    if field.is_a? GFA::Field::NumArray
+      return field.size == 1 && field.first.to_i == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/json.rb

@@ -0,0 +1,18 @@
+class GFA::Field::Json < GFA::Field
+  CODE = :J
+  REGEX = /[ !-~]+/
+  NATIVE_FUN = :to_s
+
+  def initialize(f)
+    GFA.assert_format(f, regex, "Bad #{type}")
+    @value = f
+  end
+
+  def equivalent?(field)
+    # TODO
+    # We should parse the contents when comparing two GFA::Field::Json to
+    # evaluate equivalencies such as 'J:{ "a" : 1 }' ~ 'J:{"a":1}' (spaces)
+    # or 'J:{"a":1,"b":2}' ~ 'J:{"b":2,"a":1}' (element order)
+    super
+  end
+end

data/lib/gfa/field/numarray.rb

@@ -1,16 +1,49 @@
 class GFA::Field::NumArray < GFA::Field
   CODE = :B
-  REGEX = /^[cCsSiIf](,[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+$/
+  REGEX = /[cCsSiIf](,[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+/
+  NATIVE_FUN = :to_a
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
 
-  def modifier ; value[0] ; end
+  def modifier
+    value[0]
+  end
+
+  def modifier_fun
+    modifier == 'f' ? :to_f : :to_i
+  end
 
-  def array ; value[2..-1].split(/,/) ; end
-  
-  alias as_a array
+  def array
+    @array ||= value[2..-1].split(',').map(&modifier_fun)
+  end
+
+  alias to_a array
 
+  %i[empty? size count length first last].each do |i|
+    define_method(i) { array.send(i) }
+  end
+
+  def number_type
+    {
+      c: 'int8_t',   C: 'uint8_t',
+      s: 'int16_t',  S: 'uint16_t',
+      i: 'int32_t',  I: 'uint32_t',
+      f: 'float'
+    }[modifier.to_sym]
+  end
+
+  def equivalent?(field)
+    return true if eql?(field)
+
+    if field.respond_to?(:to_a)
+      field.to_a.map(&modifier_fun) == array
+    elsif size == 1 && field.respond_to?(modifier_fun)
+      field.send(modifier_fun) == first
+    else
+      false
+    end
+  end
 end

data/lib/gfa/field/sigint.rb

@@ -1,10 +1,22 @@
 class GFA::Field::SigInt < GFA::Field
   CODE = :i
-  REGEX = /^[-+]?[0-9]+$/
-   
+  REGEX = /[-+]?[0-9]+/
+  NATIVE_FUN = :to_i
+
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_i
   end
 
+  def to_i
+    value
+  end
+
+  def equivalent?(field)
+    if field.is_a?(GFA::Field::NumArray)
+      return field.size == 1 && field.first.to_i == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/string.rb

@@ -1,10 +1,18 @@
 class GFA::Field::String < GFA::Field
   CODE = :Z
-  REGEX = /^[ !-~]+$/
-   
+  REGEX = /[ !-~]+/
+  NATIVE_FUN = :to_s
+
+  def to_f
+    value.to_f
+  end
+
+  def to_i(base = 10)
+    value.to_i(base)
+  end
+
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
-
 end

data/lib/gfa/field.rb

@@ -1,20 +1,18 @@
 class GFA::Field
-  
   # Class-level
-
   CODES = {
-    :A => :Char,
-    :i => :SigInt,
-    :f => :Float,
-    :Z => :String,
-    :H => :Hex,
-    :B => :NumArray
+    A: :Char,
+    i: :SigInt,
+    f: :Float,
+    Z: :String,
+    J: :Json, # Excluding new-line and tab characters
+    H: :Hex,
+    B: :NumArray
   }
   TYPES = CODES.values
-
   TYPES.each { |t| require "gfa/field/#{t.downcase}" }
 
-  [:CODES, :TYPES].each do |x|
+  %i[CODES TYPES].each do |x|
     define_singleton_method(x) { const_get(x) }
   end
   
@@ -27,23 +25,95 @@ class GFA::Field
   def self.name_class(name)
     const_get(name)
   end
-   
+
+  def self.[](string)
+    code, value = string.split(':', 2)
+    code_class(code).new(value)
+  end
+
   # Instance-level
 
   attr :value
 
-  def type ; CODES[code] ; end
-   
-  def code ; self.class::CODE ; end
-   
-  def regex ; self.class::REGEX ; end
-   
-  def to_s(with_type=true)
+  def type
+    CODES[code]
+  end
+
+  def code
+    self.class::CODE
+  end
+
+  def regex
+    self.class::REGEX
+  end
+
+  def native_fun
+    self.class::NATIVE_FUN
+  end
+
+  def to_native
+    native_fun == :to_s ? to_s(false) : send(native_fun)
+  end
+
+  def to_s(with_type = true)
     "#{"#{code}:" if with_type}#{value}"
   end
-   
+
   def hash
     value.hash
   end
 
+  ##
+  # Evaluate equivalency of contents. All the following fields are distinct but
+  # contain the same information, and are therefore considered equivalent:
+  # Z:123, i:123, f:123.0, B:i,123, H:7b
+  #
+  # Note that the information content is determined by the class of the first
+  # operator. For example:
+  # - 'i:123' ~ 'f:123.4' is true because values are compared as integers
+  # - 'f:123.4' ~ 'i:123' if false because values are compared as floats
+  def equivalent?(field)
+    return true if eql?(field) # Might be faster, so testing this first
+
+    if field.respond_to?(native_fun)
+      if field.is_a?(GFA::Field) && native_fun == :to_s
+        field.to_s(false) == to_native
+      else
+        field.send(native_fun) == to_native
+      end
+    else
+      field == value
+    end
+  end
+
+  ##
+  # Non-equivalent to +field+, same as +!equivalent?+
+  def !~(field)
+    !self.~(field)
+  end
+
+  ##
+  # Same as +equivalent?+
+  def ~(field)
+    equivalent?(field)
+  end
+
+  ##
+  # Evaluate equality. Note that fields with equivalent values evaluate as
+  # different. For example, the following fields have equivalent information,
+  # but they all evaluate as different: Z:123, i:123, f:123.0, B:i,123, H:7b.
+  # To test equivalency of contents instead, use +equivalent?+
+  def eql?(field)
+    if field.is_a?(GFA::Field)
+      type == field.type && value == field.value
+    else
+      field.is_a?(value.class) && value == field
+    end
+  end
+
+  ##
+  # Same as +eql?+
+  def ==(field)
+    eql?(field)
+  end
 end

data/lib/gfa/generator.rb

@@ -1,31 +1,35 @@
 class GFA
-   def save(file)
-      fh = File.open(file, "w")
-      each_line do |ln|
-	 fh.puts ln
+  def save(file)
+    fh = File.open(file, 'w')
+    each_line do |ln|
+      fh.puts ln
+    end
+    fh.close
+  end
+
+  def each_line(&blk)
+    set_version_header('1.1') if gfa_version.nil?
+    GFA::Record.TYPES.each do |r_type|
+      records[r_type].each do |record|
+        blk[record.to_s]
       end
-      fh.close
-   end
-   def each_line(&blk)
-      set_version_header("1.0") if gfa_version.nil?
-      GFA::Record.TYPES.each do |r_type|
-	 records[r_type].each do |record|
-	    blk[record.to_s]
-	 end
-      end
-   end
-   def set_version_header(v)
-      unset_version
-      @records[:Header] << GFA::Record::Header.new("VN:Z:#{v}")
-      @gfa_version = v
-   end
-   def unset_version
-      @records[:Header].delete_if { |o| not o.fields[:VN].nil? }
-      @gfa_version = nil
-   end
-   def to_s
-      o = ""
-      each_line{ |ln| o += ln + "\n" }
-      o
-   end
+    end
+  end
+
+  def set_version_header(v)
+    unset_version
+    @records[:Header] << GFA::Record::Header.new("VN:Z:#{v}")
+    @gfa_version = v
+  end
+
+  def unset_version
+    @records[:Header].delete_if { |o| !o.fields[:VN].nil? }
+    @gfa_version = nil
+  end
+
+  def to_s
+    o = ''
+    each_line { |ln| o += ln + "\n" }
+    o
+  end
 end