gfa 0.1.2 → 0.3.1

data/lib/gfa/graph.rb

@@ -1,8 +1,7 @@
-require "rgl/adjacency"
-require "rgl/implicit"
+require 'rgl/adjacency'
+require 'rgl/implicit'
 
 class GFA
-   
   ##
   # Generates a RGL::ImplicitGraph object describing the links in the GFA.
   # The +opts+ argument is a hash with any of the following key-value pairs:
@@ -11,7 +10,7 @@ class GFA
   #   true.
   # * :directed => bool. If false, ignores direction of the links. By defaut
   #   the same value as :orient.
-  def implicit_graph(opts={})
+  def implicit_graph(opts = {})
     rgl_implicit_graph(opts)
   end
 
@@ -19,7 +18,7 @@ class GFA
   # Generates a RGL::DirectedAdjacencyGraph or RGL::AdjacencyGraph object.
   # The +opts+ argument is a hash with the same supported key-value pairs as
   # in #implicit_graph.
-  def adjacency_graph(opts={})
+  def adjacency_graph(opts = {})
     implicit_graph(opts).to_adjacency
   end
    
@@ -27,7 +26,7 @@ class GFA
    
     def segment_names_with_orient
       segments.flat_map do |s|
-        %w[+ -].map{ |orient| GFA::GraphVertex.idx(s, orient) }
+        %w[+ -].map { |orient| GFA::GraphVertex.idx(s, orient) }
       end.to_set
     end
 
@@ -44,8 +43,8 @@ class GFA
           (opts[:orient] ? segment_names_with_orient :
                   segment_names).each(&b)
         end
-        g.adjacent_iterator do |x,b|
-          rgl_implicit_adjacent_iterator(x,b,opts)
+        g.adjacent_iterator do |x, b|
+          rgl_implicit_adjacent_iterator(x, b, opts)
         end
         g.directed = opts[:directed]
       end
@@ -57,25 +56,25 @@ class GFA
       opts
     end
 
-    def rgl_implicit_adjacent_iterator(x,b,opts)
+    def rgl_implicit_adjacent_iterator(x, b, opts)
       links.each do |l|
         if l.from?(x.segment, x.orient)
           orient = opts[:orient] ? l.to_orient : nil
           b.call(GFA::GraphVertex.idx(l.to, orient))
-        elsif opts[:orient] and l.to?(x.segment, orient_rc(x.orient))
+        elsif opts[:orient] && l.to?(x.segment, orient_rc(x.orient))
           orient = orient_rc(l.from_orient.value)
           b.call(GFA::GraphVertex.idx(l.from, orient))
         end
       end
     end
 
-    def orient_rc(o) o=="+" ? "-" : "+" ; end
-
+    def orient_rc(o)
+      o == '+' ? '-' : '+'
+    end
 end
 
 
 class GFA::GraphVertex # :nodoc:
-   
   # Class-level
   @@idx = {}
   def self.idx(segment, orient)
@@ -83,10 +82,10 @@ class GFA::GraphVertex # :nodoc:
     @@idx[n.to_s] ||= n
     @@idx[n.to_s]
   end
-   
+
   # Instance-level
   attr :segment, :orient
-   
+
   def initialize(segment, orient)
     @segment = segment.is_a?(GFA::Record::Segment) ? segment.name.value :
 		segment.is_a?(GFA::Field) ? segment.value : segment
@@ -96,5 +95,4 @@ class GFA::GraphVertex # :nodoc:
   def to_s
     "#{segment}#{orient}"
   end
-
 end

data/lib/gfa/parser.rb

@@ -1,18 +1,23 @@
-require "gfa/record"
+require 'gfa/record'
 
 class GFA
   # Class-level
-  MIN_VERSION = "1.0"
-  MAX_VERSION = "1.0"
-   
-  def self.load(file)
-    gfa = GFA.new
-    fh = File.open(file, "r")
+  MIN_VERSION = '1.0'
+  MAX_VERSION = '1.2'
+
+  ##
+  # Load a GFA object from a +gfa+ file with options +opts+:
+  # - index: If the records should be indexed as loaded (default: true)
+  # - comments: If the comment records should be saved (default: false)
+  def self.load(file, opts = {})
+    gfa = GFA.new(opts)
+    fh = File.open(file, 'r')
     fh.each { |ln| gfa << ln }
-    fh.close
     gfa
+  ensure
+    fh&.close
   end
-   
+
   def self.supported_version?(v)
     v.to_f >= MIN_VERSION.to_f and v.to_f <= MAX_VERSION.to_f
   end
@@ -20,26 +25,30 @@ class GFA
   # Instance-level
   def <<(obj)
     obj = parse_line(obj) unless obj.is_a? GFA::Record
-    return if obj.nil? or obj.empty?
+    return if obj.nil? || obj.empty?
     @records[obj.type] << obj
-    if obj.type==:Header and not obj.fields[:VN].nil?
-      set_gfa_version(obj.fields[:VN].value)
+
+    if obj.type == :Header && !obj.VN.nil?
+      set_gfa_version(obj.VN.value)
     end
   end
 
   def set_gfa_version(v)
+    v = v.value if v.is_a? GFA::Field
+    unless GFA::supported_version? v
+      raise "GFA version currently unsupported: #{v}"
+    end
+
     @gfa_version = v
-    raise "GFA version currently unsupported: #{v}." unless
-      GFA::supported_version? gfa_version
   end
-   
+
   private
-      
-    def parse_line(ln)
-      ln.chomp!
-      return nil if ln =~ /^\s*$/
-      cols = ln.split("\t")
-      GFA::Record.code_class(cols.shift).new(*cols)
-    end
 
+    def parse_line(string)
+      string = string.chomp
+      return nil if string =~ /^\s*$/
+      return nil if !opts[:comments] && string[0] == '#'
+
+      GFA::Record[string]
+    end
 end

data/lib/gfa/record/comment.rb

@@ -0,0 +1,15 @@
+class GFA::Record::Comment < GFA::Record
+  CODE = :'#'
+  REQ_FIELDS = %i[comment]
+  OPT_FIELDS = {}
+
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
+   
+  def initialize(comment, *opt_fields)
+    @fields = {}
+    add_field(2, :Z, comment, /.*/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
+end

data/lib/gfa/record/containment.rb

@@ -1,24 +1,30 @@
 class GFA::Record::Containment < GFA::Record
   CODE = :C
-  REQ_FIELDS = [:from, :from_orient, :to, :to_orient, :pos, :overlap]
+  REQ_FIELDS = %i[from from_orient to to_orient pos overlap]
   OPT_FIELDS = {
-    :RC => :i,
-    :NM => :i
+    RC: :i, # Read coverage
+    NM: :i, # Number of mismatches/gaps
+    ID: :Z  # Edge identifier
   }
 
   REQ_FIELDS.each_index do |i|
-    define_method(REQ_FIELDS[i]) { fields[i+2] }
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
-   
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
+
+  alias container from
+  alias container_orient from_orient
+  alias contained to
+  alias contained_orient to_orient
+
   def initialize(from, from_orient, to, to_orient, pos, overlap, *opt_fields)
     @fields = {}
-    add_field(2, :Z, from, /^[!-)+-<>-~][!-~]*$/)
-    add_field(3, :Z, from_orient, /^+|-$/)
-    add_field(4, :Z, to, /^[!-)+-<>-~][!-~]*$/)
-    add_field(5, :Z, to_orient, /^+|-$/)
-    add_field(6, :i, pos, /^[0-9]*$/)
-    add_field(7, :Z, overlap, /^\*|([0-9]+[MIDNSHPX=])+$/)
-    opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
+    add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, from_orient, /[+-]/)
+    add_field(4, :Z, to,          /[!-)+-<>-~][!-~]*/)
+    add_field(5, :Z, to_orient,   /[+-]/)
+    add_field(6, :i, pos,         /[0-9]*/)
+    add_field(7, :Z, overlap,     /\*|([0-9]+[MIDNSHPX=])+/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
-
 end

data/lib/gfa/record/header.rb

@@ -1,13 +1,14 @@
 class GFA::Record::Header < GFA::Record
-   CODE = :H
-   REQ_FIELDS = []
-   OPT_FIELDS = {
-      :VN => :Z
-   }
-   
-   def initialize(*opt_fields)
-      @fields = {}
-      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
-   end
+  CODE = :H
+  REQ_FIELDS = []
+  OPT_FIELDS = {
+    VN: :Z # Version number
+  }
 
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
+   
+  def initialize(*opt_fields)
+    @fields = {}
+    opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
+  end
 end

data/lib/gfa/record/jump.rb

@@ -0,0 +1,45 @@
+class GFA::Record::Jump < GFA::Record
+  CODE = :J
+  REQ_FIELDS = %i[from from_orient to to_orient distance]
+  OPT_FIELDS = {
+    SC: :i  # 1 indicates indirect shortcut connections. Only 0/1 allowed.
+  }
+
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
+
+  def initialize(from, from_orient, to, to_orient, distance, *opt_fields)
+    @fields = {}
+    add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, from_orient, /[+-]/)
+    add_field(4, :Z, to,          /[!-)+-<>-~][!-~]*/)
+    add_field(5, :Z, to_orient,   /[+-]/)
+    add_field(6, :Z, distance,    /\*|[-+]?[0-9]+/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
+
+  def from?(segment, orient = nil)
+    links_from_to?(segment, orient, true)
+  end
+
+  def to?(segment, orient = nil)
+    links_from_to?(segment, orient, false)
+  end
+
+  private
+
+    def links_from_to?(segment, orient, from)
+      segment = segment_name(segment)
+      orient  = orient.value if orient.is_a? GFA::Field
+      base_k  = from ? 2 : 4
+      segment==fields[base_k].value &&
+        (orient.nil? || orient==fields[base_k + 1].value)
+    end
+
+    def segment_name(segment)
+      segment.is_a?(GFA::Record::Segment) ? segment.name.value :
+        segment.is_a?(GFA::Field) ? segment.value : segment
+    end
+end

data/lib/gfa/record/link.rb

@@ -1,50 +1,50 @@
 class GFA::Record::Link < GFA::Record
-   CODE = :L
-   REQ_FIELDS = [:from, :from_orient, :to, :to_orient, :overlap]
-   OPT_FIELDS = {
-      :MQ => :i,
-      :NM => :i,
-      :EC => :i,
-      :FC => :i,
-      :KC => :i
-   }
-   
-   REQ_FIELDS.each_index do |i|
-      define_method(REQ_FIELDS[i]) { fields[i+2] }
-   end
+  CODE = :L
+  REQ_FIELDS = %i[from from_orient to to_orient overlap]
+  OPT_FIELDS = {
+    MQ: :i, # Mapping quality
+    NM: :i, # Number of mismatches/gaps
+    EC: :i, # Read count
+    FC: :i, # Fragment count
+    KC: :i, # k-mer count
+    ID: :Z  # Edge identifier
+  }
 
-   def initialize(from, from_orient, to, to_orient, overlap, *opt_fields)
-      @fields = {}
-      add_field(2, :Z, from, /^[!-)+-<>-~][!-~]*$/)
-      add_field(3, :Z, from_orient, /^+|-$/)
-      add_field(4, :Z, to, /^[!-)+-<>-~][!-~]*$/)
-      add_field(5, :Z, to_orient, /^+|-$/)
-      add_field(6, :Z, overlap, /^\*|([0-9]+[MIDNSHPX=])+$/)
-      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
-   end
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
 
-   
-   def from?(segment, orient=nil)
-      links_from_to?(segment, orient, true)
-   end
-   
-   def to?(segment, orient=nil)
-      links_from_to?(segment, orient, false)
-   end
+  def initialize(from, from_orient, to, to_orient, overlap, *opt_fields)
+    @fields = {}
+    add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, from_orient, /[+-]/)
+    add_field(4, :Z, to,          /[!-)+-<>-~][!-~]*/)
+    add_field(5, :Z, to_orient,   /[+-]/)
+    add_field(6, :Z, overlap,     /\*|([0-9]+[MIDNSHPX=])+/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
 
-   private
+  def from?(segment, orient = nil)
+    links_from_to?(segment, orient, true)
+  end
 
-      def links_from_to?(segment, orient, from)
-         segment = segment_name(segment)
-         orient  = orient.value if orient.is_a? GFA::Field
-         base_k  = from ? 2 : 4
-         segment==fields[base_k].value and
-            (orient.nil? or orient==fields[base_k + 1].value)
-      end
+  def to?(segment, orient = nil)
+    links_from_to?(segment, orient, false)
+  end
 
-      def segment_name(segment)
-         segment.is_a?(GFA::Record::Segment) ? segment.name.value :
-            segment.is_a?(GFA::Field) ? segment.value : segment
-      end
+  private
 
+    def links_from_to?(segment, orient, from)
+      segment = segment_name(segment)
+      orient  = orient.value if orient.is_a? GFA::Field
+      base_k  = from ? 2 : 4
+      segment==fields[base_k].value &&
+        (orient.nil? || orient==fields[base_k + 1].value)
+    end
+
+    def segment_name(segment)
+      segment.is_a?(GFA::Record::Segment) ? segment.name.value :
+        segment.is_a?(GFA::Field) ? segment.value : segment
+    end
 end

data/lib/gfa/record/path.rb

@@ -1,18 +1,19 @@
 class GFA::Record::Path < GFA::Record
-   CODE = :P
-   REQ_FIELDS = [:path_name, :segment_name, :cigar]
-   OPT_FIELDS = {}
+  CODE = :P
+  REQ_FIELDS = %i[path_name segment_name overlaps]
+  OPT_FIELDS = {}
 
-   REQ_FIELDS.each_index do |i|
-      define_method(REQ_FIELDS[i]) { fields[i+2] }
-   end
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
 
-   def initialize(path_name, segment_name, cigar, *opt_fields)
-      @fields = {}
-      add_field(2, :Z, path_name, /^[!-)+-<>-~][!-~]*$/)
-      add_field(3, :Z, segment_name, /^[!-)+-<>-~][!-~]*$/)
-      add_field(4, :Z, cigar, /^\*|([0-9]+[MIDNSHPX=])+$/)
-      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
-   end
+  alias cigar overlaps
 
+  def initialize(path_name, segment_name, overlaps, *opt_fields)
+    @fields = {}
+    add_field(2, :Z, path_name,    /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, segment_name, /[!-)+-<>-~][!-~]*/)
+    add_field(4, :Z, overlaps,     /\*|([0-9]+[MIDNSHPX=]|[-+]?[0-9]+J|.)+/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
 end

data/lib/gfa/record/segment.rb

@@ -1,22 +1,26 @@
 class GFA::Record::Segment < GFA::Record
-   CODE = :S
-   REQ_FIELDS = [:name, :sequence]
-   OPT_FIELDS = {
-      :LN => :i,
-      :RC => :i,
-      :FC => :i,
-      :KC => :i
-   }
+  CODE = :S
+  REQ_FIELDS = %i[name sequence]
+  OPT_FIELDS = {
+    LN: :i, # Segment length
+    RC: :i, # Read count
+    FC: :i, # Fragment count
+    KC: :i, # k-mer count
+    SH: :H, # SHA-256 checksum of the sequence
+    UR: :Z, # URI or local file-system path of the sequence
+    # Non-cannonical
+    DP: :f  # (From SAM)
+  }
 
-   REQ_FIELDS.each_index do |i|
-      define_method(REQ_FIELDS[i]) { fields[i+2] }
-   end
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
    
-   def initialize(name, sequence, *opt_fields)
-      @fields = {}
-      add_field(2, :Z, name, /^[!-)+-<>-~][!-~]*$/)
-      add_field(3, :Z, sequence, /^\*|[A-Za-z=.]+$/)
-      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
-   end
-
+  def initialize(name, sequence, *opt_fields)
+    @fields = {}
+    add_field(2, :Z, name,     /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, sequence, /\*|[A-Za-z=.]+/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
 end

data/lib/gfa/record/walk.rb

@@ -0,0 +1,20 @@
+class GFA::Record::Walk < GFA::Record
+  CODE = :W
+  REQ_FIELDS = %i[sample_id hap_index seq_id seq_start seq_end walk]
+  OPT_FIELDS = {}
+
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
+
+  def initialize(sample_id, hap_index, seq_id, seq_start, seq_end, walk, *opt_fields)
+    @fields = {}
+    add_field(2, :Z, sample_id, /[!-)+-<>-~][!-~]*/)
+    add_field(3, :i, hap_index, /[0-9]+/)
+    add_field(4, :Z, seq_id,    /[!-)+-<>-~][!-~]*/)
+    add_field(5, :i, seq_start, /\*|[0-9]+/)
+    add_field(6, :i, seq_end,   /\*|[0-9]+/)
+    add_field(7, :Z, walk,      /([><][!-;=?-~]+)+/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
+end

data/lib/gfa/record.rb

@@ -1,21 +1,21 @@
 class GFA::Record
-  
   # Class-level
-
   CODES = {
-    :H => :Header,
-    :S => :Segment,
-    :L => :Link,
-    :C => :Containment,
-    :P => :Path
+    :'#' => :Comment,
+    H: :Header,
+    S: :Segment,
+    L: :Link,
+    J: :Jump, # Since 1.2
+    C: :Containment,
+    P: :Path,
+    W: :Walk # Since 1.1
   }
   REQ_FIELDS = []
   OPT_FIELDS = {}
   TYPES = CODES.values
-
   TYPES.each { |t| require "gfa/record/#{t.downcase}" }
 
-  [:CODES, :REQ_FIELDS, :OPT_FIELDS, :TYPES].each do |x|
+  %i[CODES REQ_FIELDS OPT_FIELDS TYPES].each do |x|
     define_singleton_method(x) { const_get(x) }
   end
 
@@ -29,32 +29,46 @@ class GFA::Record
     const_get(name)
   end
 
+  def self.[](string)
+    split = string[0] == '#' ? ['', 2] : ["\t", 0]
+    code, *values = string.chomp.split(*split)
+    code_class(code).new(*values)
+  end
+
   # Instance-level
 
   attr :fields
 
-  def [](k) fields[k] ; end
-   
-  def type ; CODES[code] ; end
-   
-  def code ; self.class.const_get(:CODE) ; end
-   
-  def empty? ; fields.empty? ; end
-   
+  def [](k)
+    fields[k]
+  end
+
+  def type
+    CODES[code]
+  end
+
+  def code
+    self.class.const_get(:CODE)
+  end
+
+  def empty?
+    fields.empty?
+  end
+
   def to_s
     o = [code.to_s]
     self.class.REQ_FIELDS.each_index do |i|
-      o << fields[i+2].to_s(false)
+      o << fields[i + 2].to_s(false)
     end
-    fields.each do |k,v|
+    fields.each do |k, v|
       next if k.is_a? Integer
       o << "#{k}:#{v}"
     end
     o.join("\t")
   end
-   
+
   def hash
-    {code => fields}.hash
+    { code => fields }.hash
   end
 
   def eql?(rec)
@@ -64,27 +78,33 @@ class GFA::Record
   alias == eql?
 
   private
-      
-    def add_field(f_tag, f_type, f_value, format=nil)
+
+    def add_field(f_tag, f_type, f_value, format = nil)
       unless format.nil?
         msg = (f_tag.is_a?(Integer) ? "column #{f_tag}" : "#{f_tag} field")
         GFA.assert_format(f_value, format, "Bad #{type} #{msg}")
       end
-      @fields[ f_tag ] = GFA::Field.code_class(f_type).new(f_value)
+
+      @fields[f_tag] = GFA::Field.code_class(f_type).new(f_value)
     end
-      
+
     def add_opt_field(f, known)
-      m = /^([A-Za-z]+):([A-Za-z]+):(.*)$/.match(f) or
-        raise "Cannot parse field: '#{f}'."
+      m = /^([A-Za-z]+):([A-Za-z]+):(.*)$/.match(f)
+      raise "Cannot parse field: '#{f}'" unless m
+
       f_tag = m[1].to_sym
       f_type = m[2].to_sym
       f_value = m[3]
-      raise "Unknown reserved tag #{f_tag} for a #{type} record." if
-        known[f_tag].nil? and f_tag =~ /^[A-Z]+$/
-      raise "Wrong field type #{f_type} for a #{f_tag} tag," +
-        " expected #{known[f_tag]}" unless
-        known[f_tag].nil? or known[f_tag] == f_type
+
+      if known[f_tag].nil? && f_tag =~ /^[A-Z]+$/
+        raise "Unknown reserved tag #{f_tag} for a #{type} record."
+      end
+
+      unless known[f_tag].nil? || known[f_tag] == f_type
+        raise "Wrong field type #{f_type} for a #{f_tag} tag," \
+          " expected #{known[f_tag]}"
+      end
+
       add_field(f_tag, f_type, f_value)
     end
-
 end

data/lib/gfa/record_set/comment_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::CommentSet < GFA::RecordSet
+  CODE = :'#'
+end

data/lib/gfa/record_set/containment_set.rb

@@ -0,0 +1,4 @@
+class GFA::RecordSet::ContainmentSet < GFA::RecordSet
+  CODE = :C
+  INDEX_FIELD = 2 # Container: Name of container segment
+end

data/lib/gfa/record_set/header_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::HeaderSet < GFA::RecordSet
+  CODE = :H
+end

data/lib/gfa/record_set/jump_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::JumpSet < GFA::RecordSet
+  CODE = :J
+end

data/lib/gfa/record_set/link_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::LinkSet < GFA::RecordSet
+  CODE = :L
+end

data/lib/gfa/record_set/path_set.rb

@@ -0,0 +1,4 @@
+class GFA::RecordSet::PathSet < GFA::RecordSet
+  CODE = :P
+  INDEX_FIELD = 2 # PathName: Path name
+end

data/lib/gfa/record_set/segment_set.rb

@@ -0,0 +1,4 @@
+class GFA::RecordSet::SegmentSet < GFA::RecordSet
+  CODE = :S
+  INDEX_FIELD = 2 # Name: Segment name
+end