cytogenetics 0.0.1

data/lib/cytogenetics/aberration.rb

@@ -0,0 +1,157 @@
+require 'yaml'
+
+module Cytogenetics
+  class Aberration
+
+    attr_accessor :breakpoints
+    attr_reader :abr, :ab_objs, :fragments
+
+    class<<self
+      def instantiate_aberrations
+        aberration_obj = {}
+        ChromosomeAberrations.constants.each do |ca|
+          abr_obj = ChromosomeAberrations.const_get(ca)
+          aberration_obj[abr_obj.type.to_sym] = abr_obj
+        end
+        return aberration_obj
+      end
+    end
+
+    def self.type
+      return @kt
+    end
+
+    def self.regex
+      return @rx
+    end
+
+    def self.all_regex
+      rx = {}
+      ChromosomeAberrations.constants.each do |ca|
+        ca_obj = ChromosomeAberrations.const_get(ca)
+        rx[ca_obj.type.to_sym] = ca_obj.regex
+      end
+      return rx
+    end
+
+    # instantiate these
+    def self.aberration_objs
+      @ab_objs ||= self.instantiate_aberrations
+    end
+
+    def self.aberration_type
+      abr_breaks = Aberration.all_regex.keys
+      abr_breaks.delete_if { |c| c.to_s.match(/gain|loss/) }
+      return abr_breaks
+    end
+
+    def self.classify_aberration(abr)
+      Aberration.all_regex.each_pair do |k, regex|
+        return k if abr.match(regex)
+      end
+      return "unk".to_sym
+    end
+
+    def initialize(str)
+      config_logging()
+
+      @abr = str
+      @breakpoints = []; @fragments = []
+
+      #regex = Aberration.regex[@type.to_sym]
+      # make sure it really is an inversion first
+      #raise KaryotypeError, "#{str} does not appear to be a #{self.class}" unless str.match(self.regex)
+      get_breakpoints() #(@abr)
+      @breakpoints.flatten!
+    end
+
+    def remove_breakpoint(bp)
+      removed = @breakpoints.index(bp)
+      @breakpoints.delete_at(removed) if removed
+      return removed
+    end
+
+    def to_s
+      "#{@abr}: #{@breakpoints.join(',')}"
+    end
+
+    :private
+
+    def get_breakpoints
+      chr_i = find_chr(@abr)
+      return if chr_i.nil?
+
+      band_i = find_bands(@abr, chr_i[:end_index])
+
+      unless band_i.nil? # breakpoints aren't added if there is no band information
+        chr_i[:chr].each_with_index do |c, i|
+          fragments = find_fragments(band_i[:bands][i])
+          fragments.each { |f| @breakpoints << Breakpoint.new(c, f, self.class.type) }
+        end
+      else
+        ## No band --> TODO add this as information somewhere but not as a breakpoint
+        #@breakpoints << Breakpoint.new(c, "", @type)
+      end
+    end
+
+    # Parsing aberration strings to pull out the chromosome and band definitions
+    # These will result in breakpoint information
+    def find_chr(str)
+      chr_s = str.index(/\(/, 0)
+      chr_e = str.index(/\)/, chr_s)
+      chrs = str[chr_s+1..chr_e-1].split(/;|:/)
+      chrs.each do |chr|
+        unless chr.match(/^\d+|X|Y$/)
+          log.warn("No chromosome defined from #{str}, skipped.")
+          return
+        end
+      end
+      return {:start_index => chr_s, :end_index => chr_e, :chr => chrs}
+    end
+
+    def find_bands(str, index)
+      band_info = nil
+      #raise KaryotypeError, "No bands defined in #{str}" if str.length.eql?(index+1)
+      if str.length.eql?(index+1)
+        log.warn("No bands defined in #{str}, skipped.")
+        return
+      end
+
+      ei = str.index(/\(/, index)
+      if str.match(/(q|p)(\d+|\?)/) and str[ei-1..ei].eql?(")(") # has bands and is not a translocation
+        band_s = str.index(/\(/, index)
+        band_e = str.index(/\)/, band_s)
+        band_e = str.length-1 if band_e.nil?
+        bands = str[band_s+1..band_e-1].split(/;|:/)
+
+        if str[band_s+1..band_e-1].match(/::/)
+          log.warn("Aberration defined using different language, not currently parsed skipping: #{@abr}")
+          return band_info
+        else
+          bands.map! { |b| b.sub(/-[q|p]\d+$/, "") } # sometimes bands are given a range, for our purposes we'll take the first one (CyDas appears to do this as well)
+          bands.each do |b|
+            unless b.match(/^[p|q]\d+(\.\d)?$/)
+              log.warn("Bands incorrectly defined in #{str}")
+              return band_info
+            end
+          end
+          band_info = {:start_index => band_s, :end_index => band_e, :bands => bands}
+        end
+      end
+      return band_info
+    end
+
+    # sometimes bands are defined for a single chr as p13q22
+    def find_fragments(str)
+      return str.scan(/([p|q]\d+)/).collect { |a| a[0] }
+    end
+
+    :private
+    def config_logging
+      @log = Cytogenetics.logger
+      #@log.progname = self.class.name
+    end
+
+  end
+
+end

data/lib/cytogenetics/breakpoint.rb

@@ -0,0 +1,37 @@
+module Cytogenetics
+
+  class Breakpoint
+
+    attr_accessor :chr, :band, :type
+
+    def initialize(*args)
+      config_logging
+      c = args[0]; b = args[1]
+      @type = args[2] if args.length > 2
+
+      unless ((c.is_a? String and c.match(/\d+|X|Y/)) and (b.is_a? String and b.length > 0))
+        @log.error("#{c}#{b} is not a valid breakpoint")
+        raise ArgumentError, "#{c}#{b} is not a valid breakpoint"
+      end
+      @chr = c; @band = b
+    end
+
+    def arm
+      @band.match(/(q|p)\d+/)
+      return $1
+    end
+
+    def to_s
+      return "#{@chr}#{@band}"
+    end
+
+    :private
+
+    def config_logging
+      @log = Cytogenetics.logger
+      #@log.progname = self.class.name
+    end
+
+  end
+
+end

data/lib/cytogenetics/chromosome.rb

@@ -0,0 +1,68 @@
+require 'cytogenetics/utils/band_reader'
+
+module Cytogenetics
+
+  class Chromosome
+    include BandReader
+
+    class<<self
+      attr_accessor :normal_bands
+    end
+
+    attr_reader :name, :aberrations
+
+    def initialize(*args)
+      config_logging()
+      chr = args[0]
+      chr = chr.to_s  if chr.is_a?Fixnum
+
+      raise ArgumentError, "#{chr} is not a valid chromosome identifier." unless (chr.is_a? String and chr.match(/^\d+|X|Y$/))
+      @name = chr
+      @aberrations = []
+      @normal_bands = bands(@name, "resources/HsBands.txt") if (args.length > 1 and args[1].eql? true) ## TODO quit hardcoding
+    end
+
+    def to_s
+      "#{@name}"
+    end
+
+    def aberration(obj)
+      raise ArgumentError, "Not an Aberration object" unless obj.is_a? Aberration
+
+      #obj.breakpoints.each do |bp|
+      #  log.warn("Band #{bp.to_s} doesn't exist. Removing.") if @normal_bands.index(bp.to_s).nil?
+      #end
+
+      ## TODO Deal with bands, HOWEVER because the chromosome has aberration objects breakpoints can include
+      ## bands for which no chromosome object is created
+
+      #obj.breakpoints.reject {|bp|
+      #  @normal_bands.index(bp.to_s).nil?
+      #}
+
+      @aberrations << obj
+    end
+
+    def breakpoints
+      bps = []
+      @aberrations.each { |a| bps << a.breakpoints }
+      return bps
+    end
+
+    def fragments
+      frags = []
+      @aberrations.each do |a|
+        frags << a.fragments
+      end
+      frags
+    end
+
+    :private
+    def config_logging
+      @log = Cytogenetics.logger
+      #@log.progname = self.class.name
+    end
+
+  end
+
+end

data/lib/cytogenetics/chromosome_aberrations.rb

@@ -0,0 +1,188 @@
+require 'cytogenetics/aberration'
+
+module Cytogenetics
+
+  module ChromosomeAberrations
+
+    ## INVERSION
+    class Inversion < Aberration
+      @kt = 'inv'
+      @rx = /^inv\((\d+|X|Y)\)/
+    end
+
+    ## DUPLICATION
+    class Duplication < Aberration
+      @kt = 'dup'
+      @rx = /^dup\((\d+|X|Y)\)/
+    end
+
+    ## INSERTION
+    class Insertion < Aberration
+      @kt = 'ins'
+      @rx = /^ins\((\d+|X|Y)\)/
+    end
+
+    ## DELETION
+    class Deletion < Aberration
+      @kt = 'del'
+      @rx = /^del\((\d+|X|Y)\)/
+    end
+
+    ## ADD (addition of unknown material)
+    class Addition < Aberration
+      @kt = 'add'
+      @rx = /^add\((\d+|X|Y)\)/
+    end
+
+    ## ISOCHROMOSOME
+    class Isochromosome < Aberration
+      @kt = 'iso'
+      @rx = /^i\((\d+|X|Y)\)/
+    end
+
+    ## DICENTRIC
+    class DicentricChromosome < Aberration
+      @kt = 'dic'
+      @rx = /^dic\((\d+|X|Y)[;|:](\d+|X|Y)\)/
+
+      #def get_breakpoints
+      #  chr_i = find_chr(@abr)
+      #  band_i = find_bands(@abr, chr_i[:end_index])
+      #  chr_i[:chr].each_with_index do |c, i|
+      #    @breakpoints << Breakpoint.new(c, band_i[:bands][i], 'dic')
+      #  end
+      #  # TODO am not sure how the dic rearrangment works, see this in CyDas dic(13;13)(q14;q32)
+      #  #@fragments << Fragment.new( Breakpoint.new(@breakpoints[0].chr, "pter"), @breakpoints[0])
+      #  #@fragments << Fragment.new( @breakpoints[1], Breakpoint.new(@breakpoints[1].chr, "#{@breakpoints[1].arm}ter"))
+      #end
+
+    end
+
+    ## RING  ## TODO figure out the right regex for this
+    #class RingChromosome < Aberration
+    #  @kt = 'ring'
+    #  @rx = /^r\(/
+    #end
+
+    ## ROBERTSONIAN
+    #class Robertsonian < Aberration
+    #  @kt = 'rob'
+    #  @rx = /^rob\(/
+    #end
+
+    ## DERIVATIVE
+    class Derivative < Aberration
+      @kt = 'der'
+      @rx = /^der\((\d+|X|Y)\)/
+
+      def get_breakpoints
+        @aberrations = []
+
+        ab_objs = Aberration.aberration_objs
+
+        chr_i = find_chr(@abr)
+        derivative_abr = @abr[chr_i[:end_index]+1..@abr.length]
+
+        # separate different abnormalities within the derivative chromosome and clean it up to make it parseable
+        abnormalities = derivative_abr.scan(/([^\(\)]+\(([^\(\)]|\)\()*\))/).collect { |a| a[0] }
+
+        trans_bps = []
+        abnormalities.each do |abn|
+          abrclass = Aberration.classify_aberration(abn)
+
+          if abrclass.to_s.eql? 'unk' # not dealing with unknowns
+            log.warn("Cannot handle #{abn}, incorrect format.")
+            next
+          end
+
+          # special handling because translocations are written as a sliding window
+          # translocations should also only every have 2 breakpoints...
+          if abrclass.to_s.eql? ChromosomeAberrations::Translocation.type
+            trans = ChromosomeAberrations::Translocation.new(abn)
+            trans_bps << trans.breakpoints
+            @breakpoints << trans.breakpoints
+          else
+            ab_obj = ab_objs[abrclass].new(abn)
+            if ab_obj.breakpoints.length > 0
+              @aberrations << ab_obj
+              @breakpoints << ab_obj.breakpoints
+            end
+          end
+        end
+        trans_bps.delete_if { |c| c.empty? }
+        add_fragments(trans_bps.flatten!) if trans_bps.length > 0
+      end
+
+      :private
+      # have to reorder the array and then turn Breakpoints into fragments
+      def add_fragments(tbp_list)
+        sorted = []
+        tbp_list.each_with_index do |e, i|
+          if i <= 1
+            sorted << Breakpoint.new(e.chr, "#{e.arm}ter") if i.eql? 0
+            sorted << e
+          elsif i%2 == 0
+            sorted << tbp_list[i+1]
+            sorted << tbp_list[i]
+          end
+        end
+        sorted << Breakpoint.new(sorted[-1].chr, "#{sorted[-1].arm}ter")
+        sorted.each_slice(2).to_a.each do |pair|
+          @fragments << Fragment.new(pair[0], pair[1])
+        end
+      end
+
+    end
+
+    ## TRANSLOCATION ... this is typically a subset of Derivative chromosomes, but have seen it on it's own
+    class Translocation < Aberration
+      @kt = 'trans'
+      @rx = /^t\((\d+|X|Y)[;|:](\d+|X|Y)\)/
+
+      ## TWo ways of defining translocations:
+      ## 1)  t(1;3)(p31;p13)
+      def get_breakpoints
+        chr_i = find_chr(@abr)
+        band_i = find_bands(@abr, chr_i[:end_index])
+        unless band_i
+          log.warn("No bands defined in #{@abr}")
+        else
+          chr_i[:chr].each_with_index do |c, i|
+            @breakpoints << Breakpoint.new(c, band_i[:bands][i], 'trans')
+          end
+        end
+      end
+
+    end
+
+    ## FRAGMENT
+    class ChromosomeFragment < Aberration
+      @kt = 'frag'
+      @rx = /^frag\((\d+|X|Y)\)/
+    end
+
+    ## CHROMOSOME GAIN
+    class ChromosomeGain < Aberration
+      @kt = 'gain'
+      @rx = /^\+(\d+|X|Y)$/
+
+      def initialize
+        config_logging()
+        @abr = str.sub("+", "")
+        @breakpoints = []
+      end
+    end
+
+    ## CHROMOSOME LOSS
+    class ChromosomeLoss < Aberration
+      @kt = 'loss'
+      @rx = /^-(\d+|X|Y)$/
+
+      def initialize
+        config_logging()
+        @abr = str.sub("-", "")
+        @breakpoints = []
+      end
+    end
+  end
+end

data/lib/cytogenetics/fragment.rb

@@ -0,0 +1,45 @@
+
+module Cytogenetics
+
+  class Fragment
+    attr_reader :chr, :start, :end, :genes
+
+    def initialize(*args)
+      config_logging()
+      unless (args.length.eql? 2 and (args[0].is_a? Breakpoint and args[1].is_a? Breakpoint))
+        raise ArgumentError, "Expected arguments are missing or are not Breakpoints: #{args}"
+      end
+
+      #@genes = []
+      @start = args[0]
+      @end = args[1]
+      @chr = @start.chr
+
+      unless @start.chr.eql? @end.chr
+        raise GenomeStructureError, "Fragments must be within the same chromosome: #{args}"
+      end
+    end
+
+    def add_gene(gene)
+      @genes << gene
+    end
+
+    def to_s
+      return "#{@start.to_s} --> #{@end.to_s}"
+    end
+
+    ## TODO this will require length in basepairs of each band
+    #def length
+    #
+    #end
+
+    :private
+
+    def config_logging
+      @log = Cytogenetics.logger
+      #@log.progname = self.class.name
+    end
+
+  end
+end
+

data/lib/cytogenetics/karyotype.rb

@@ -0,0 +1,172 @@
+require 'yaml'
+
+require 'cytogenetics/utils/karyotype_reader'
+
+module Cytogenetics
+
+  class Karyotype
+
+    @@haploid = 23
+
+    attr_reader :aberrations, :karyotype, :ploidy, :sex, :abnormal_chr, :normal_chr
+
+    class<<self
+      attr_accessor :aberration_objs, :unclear_aberrations, :log
+    end
+
+    def initialize(karyotype_str)
+      config_logging()
+      raise ArgumentError, "#{karyotype_str} is not a karyotype." unless (karyotype_str.is_a? String and karyotype_str.length > 1)
+      @log.info("Reading karyotype #{karyotype_str}")
+
+      @karyotype = karyotype_str.gsub(/\s/, "")
+      @normal_chr = {}; @abnormal_chr = {}; @aberrations = {}; @unclear_aberrations = [];
+      setup_abberation_objs()
+      prep_karyotype()
+      handle_ploidy_diff()
+      analyze()
+    end
+
+    def analyze
+      Aberration.aberration_type.each do |abr_type|
+        next unless @aberrations.has_key? abr_type
+        regex = @aberration_obj[abr_type].regex
+
+        @aberrations[abr_type].each do |abr|
+#        if abr_type
+          abr.match(regex)
+          @log.warn("Aberration has two chromosomes #{abr} but only the first one is handled.") unless ($2.nil? or $1.eql? $2)
+
+          ## TODO deal with the case of 2 chromosomes defined in the aberration
+          chr = Chromosome.new($1, true)
+          chr.aberration(@aberration_obj[abr_type].new(abr))
+
+          @abnormal_chr[chr.name] = [] unless @abnormal_chr.has_key? chr.name
+          @abnormal_chr[chr.name] << chr
+        end
+      end
+    end
+
+    # get breakpoints for the karyotype
+    def report_breakpoints
+      bps = Array.new
+      @abnormal_chr.each_pair do |c, chr_list|
+        chr_list.each do |chr|
+          bps << chr.breakpoints
+        end
+      end
+      bps.delete_if { |c| c.empty? }
+      bps.flatten!
+      return bps
+    end
+
+    def report_fragments
+      frags = []
+      @abnormal_chr.each_pair do |c, chr_list|
+        chr_list.each do |chr|
+          frags << chr.fragments
+        end
+      end
+      frags.delete_if { |c| c.empty? }
+      frags.flatten!
+      return frags
+    end
+
+    def report_ploidy_change
+      pd = []
+      pd << @aberrations[:loss].map { |e| "-#{e}" } if @aberrations[:loss]
+      pd << @aberrations[:gain].map { |e| "+#{e}" } if @aberrations[:gain]
+      pd.flatten!
+      return pd
+    end
+
+    def summarize
+      summary = "NORMAL CHROMOSOMES\n"
+      @normal_chr.each_pair do |chr, count|
+        summary = "#{summary} #{chr}: #{count}\n"
+      end
+
+      summary = "#{summary}\nABNORMAL:"
+      @abnormal_chr.each_pair do |chr, list|
+        summary = "#{summary}\n#{chr}"
+        list.each do |c|
+          summary = "#{summary}\n#{c.aberrations}\n"
+          summary = "#{summary}\n#{c.breakpoints}\n"
+        end
+      end
+    end
+
+    # -------------------- # PRIVATE # -------------------- #
+    :private
+    def config_logging
+      @log = Cytogenetics.logger
+      #@log.progname = self.class.name
+    end
+
+
+    def setup_abberation_objs
+      @aberration_obj = Aberration.aberration_objs
+    end
+
+
+    def handle_ploidy_diff
+      @aberrations[:loss].each { |c| @normal_chr[c] -= 1 } if @aberrations[:loss]
+      @aberrations[:gain].each { |c| @normal_chr[c] += 1 } if @aberrations[:gain]
+    end
+
+# determine ploidy & gender, clean up each aberration and drop any "unknown"
+    def prep_karyotype
+      @karyotype.gsub!(/\s/, "")
+      clones = @karyotype.scan(/(\[\d+\])/).collect { |a| a[0] }
+      @log.warn("Karyotype is a collection of clones, analysis may be inaccurate.") if clones.length > 3
+
+      @karyotype.gsub!(/\[\d+\]/, "") # don't care about numbers of cells: [5]
+
+      (pl, sc) = @karyotype.split(",")[0..1]
+      if (pl and sc)
+        @ploidy = KaryotypeReader.calculate_ploidy(pl, @@haploid)
+        sex_chr = KaryotypeReader.determine_sex(sc)
+      else
+        raise KaryotypeError, "'#{@karyotype}' is not a valid karyotype. Ploidy and sex defnitions are absent"
+      end
+
+      st = sex_chr.values.inject { |sum, v| sum+v }
+      @sex = nil
+      karyotype_index = 1 # sometimes the sex is not indicated and there's no case information to figure it out
+      if st > 0
+        @sex = sex_chr.keys.join("")
+        karyotype_index = 2
+      end
+
+      (Array(1..23)).each { |c| @normal_chr[c.to_s] = @ploidy.to_i }
+
+      sex_chr.each_pair { |c, p| @normal_chr[c] = p.to_i }
+
+      # deal with the most common karyotype string inconsistencies
+      cleaned_karyotype = []
+
+      @karyotype.split(",")[karyotype_index..-1].each do |abr|
+        cleaned_karyotype |= [cleaned_karyotype, KaryotypeReader.cleanup(abr)].flatten
+      end
+      @karyotype = cleaned_karyotype
+
+      # classify each type of aberration in the karyotype
+      @karyotype.each do |k|
+        abrclass = Aberration.classify_aberration(k)
+        @aberrations[abrclass] = [] unless @aberrations.has_key? abrclass
+        @aberrations[abrclass] << k.sub(/^(\+|-)?/, "")
+      end
+
+      @aberrations.each_pair do |abrclass, abrlist|
+        next if (abrclass.eql? ChromosomeAberrations::ChromosomeGain.type or abrclass.eql? ChromosomeAberrations::ChromosomeLoss.type)
+        # aberrations other than chromosome gains/losses should be uniquely represented
+
+        counts = abrlist.inject(Hash.new(0)) { |h, i| h[i] += 1; h }
+        counts.each_pair { |k, v| @log.warn("#{k} was seen multiple times. Analyzed only once.") if v > 1 }
+
+        @aberrations[abrclass] = abrlist.uniq
+      end
+
+    end
+  end
+end

data/lib/cytogenetics/karyotype_error.rb

@@ -0,0 +1,4 @@
+module Cytogenetics
+  class KaryotypeError < StandardError
+  end
+end

data/lib/cytogenetics/utils/band_reader.rb

@@ -0,0 +1,30 @@
+
+module Cytogenetics
+
+  module BandReader
+
+    @bands_by_chr = {}
+
+    def bands(chr, file)
+      file = File.open(file, 'r') unless file.is_a? File
+      bands = read_file(file)
+      bds = bands[chr]
+      bds.uniq!
+      return bds
+    end
+
+    def read_file(file)
+      band_by_chr = {}
+      file.each_line do |line|
+        line.chomp!
+        line.match(/^(\d+|X|Y)([p|q].*)/)
+        c = $1; b = $2
+        band_by_chr[c] = Array.new unless band_by_chr.has_key? c
+        band_by_chr[c] << "#{c}#{b}"
+        band_by_chr[c] << "#{c}#{$1}" if b.match(/([p|q]\d+)\.\d+/)
+      end
+      return band_by_chr
+    end
+  end
+
+end

data/lib/cytogenetics/utils/karyotype_reader.rb

@@ -0,0 +1,121 @@
+require 'cytogenetics/karyotype_error'
+
+module Cytogenetics
+  class KaryotypeReader
+
+    def self.config_logging
+      @log = Cytogenetics.logger
+      #@log.progname = self.name
+    end
+
+
+    def self.cleanup(abr)
+      config_logging
+
+      new_abr = []
+
+      # +t(13;X)(q13;p12) doesn't need a +
+      abr.sub!(/^[\+|-]/, "") unless abr.match(/^[\+|-][\d|X|Y]+$/)
+
+      # not going to bother with aberrations that are unclear/unknown '?' or with '**'
+      if (abr.match(/\?|\*\*/))
+        @log.warn("Removing aberration with unknown/unclear information: #{abr}")
+        return new_abr
+      end
+
+      # 13x2 is normal, 13x3 is a duplicate and should read +13
+      if abr.match(/^([\d+|X|Y]+)x(\d+)/)
+        chr = $1; dups = $2.to_i
+        if dups.eql? 0 # managed to lose both chromosomes in a diploidy karyotype
+          (Array(1..dups)).map { new_abr.push("-#{chr}") }
+        elsif dups > 2 # sometimes you have 13x3, really just means 1 additional chr 13 since normal ploidy is 2
+          dups -= 2
+          (Array(1..dups)).map { new_abr.push("+#{chr}") }
+        elsif dups.eql?(1)
+          new_abr.push("-#{chr}")
+        end
+        # add(9)(p21)x2 or add(7)x2 should indicate that this "additional material of unk origin" happened twice
+      elsif abr.match(/(.*)x(\d+)$/)
+        a = $1; dups = $2.to_i
+        (Array(1..dups)).map { new_abr.push(a) }
+        # del(7) should be -7  but not del(7)(q12)
+      else # everything else
+        new_abr.push(abr)
+      end
+
+      return new_abr
+    end
+
+    def self.determine_sex(str)
+      config_logging
+
+      sex_chr = {}
+      ['X', 'Y'].each { |c| sex_chr[c] = 0 }
+
+      unless str.match(/^(X|Y)+$/)
+        @log.warn("Definition of gender incorrect (#{str})")
+      else
+        #raise KaryotypeError, "Definition of gender incorrect (#{str})" unless str.match(/^(X|Y)+$/)
+        # ploidy number makes no difference since this string will tell us how many or at least what the gender should be
+
+        chrs = str.match(/([X|Y]+)/).to_s.split(//)
+        chrs.each { |c| sex_chr[c] +=1 }
+
+        # assume this was an XY karyotype that may have lost the Y, have only seen this in
+        # severely affected karyotypes NOT TRUE, some karyotypes are just not defined correctly
+        # often XX -X is listed as X,...  Cannot assume it's a male missing Y
+        #sex_chr['Y'] += 1 if (chrs.length.eql?(1) and chrs[0].eql?('X'))
+      end
+
+      return sex_chr
+    end
+
+    def self.calculate_ploidy(str, haploid)
+      config_logging
+
+      str.sub!(/<.{2,}>/, "")
+      str = $1 if str.match(/\d+\((\d+-\d+)\)/)
+
+      diploid = haploid*2
+      triploid = haploid*3
+      quadraploid = haploid*4
+
+      # typically see di- tri- quad- if more than that it should be noted
+      ploidy = nil
+      min = diploid
+      max = diploid
+      #if str.match(/<\+(\d)n>/) # sometimes see this odd configuration: 46<+3n>
+      #  ploidy = $1
+      if str.match(/(\d+)[-|~](\d+)/) # num and range or just range: 46-53
+        min = $1.to_i; max = $2.to_i
+      elsif str.match(/^(\d+)/) # single num:  72
+        min = $1.to_i; max = $1.to_i
+      end
+
+      if min < haploid
+        @log.warn("Ploidy determination may be bad as the min was less than haploid (#{str}). Setting to haploid.")
+        min = haploid
+      end
+
+      if ploidy.nil?
+        case
+          when (min.eql? diploid and max.eql? diploid)
+            @log.debug("Normal ploidy: #{str}")
+            ploidy = 2
+          when ((min >= haploid and max <= diploid) or (min <= diploid and max < triploid))
+            @log.debug("Relatively normal ploidy #{str}")
+            ploidy = 2
+          when (min >= haploid and max < quadraploid)
+            @log.debug("Triploid #{str}")
+            ploidy = 3
+          when (max >= quadraploid)
+            @log.debug("Quadraploid #{str}")
+            ploidy = 4
+          else
+            raise KaryotypeError, "Failed to determine ploidy for #{str}"
+        end
+      end
+      return ploidy
+    end
+  end
+end

data/lib/cytogenetics/version.rb

@@ -0,0 +1,3 @@
+module Cytogenetics
+  VERSION = '0.0.1'
+end

data/lib/cytogenetics.rb

@@ -0,0 +1,36 @@
+require 'cytogenetics/aberration'
+require 'cytogenetics/breakpoint'
+require 'cytogenetics/chromosome'
+require 'cytogenetics/chromosome_aberrations'
+require 'cytogenetics/fragment'
+require 'cytogenetics/karyotype'
+require 'cytogenetics/karyotype_error'
+
+
+require 'cytogenetics/utils/karyotype_reader'
+require 'cytogenetics/utils/band_reader'
+
+require 'yaml'
+require 'logger'
+
+module Cytogenetics
+
+  class << self
+    def logger=(log)
+      @clog = log
+    end
+
+    def logger
+      unless @clog
+        @clog = Logger.new(STDOUT)
+        @clog.level = Logger::FATAL
+      end
+      @clog
+    end
+  end
+
+  def self.karyotype(kary_str)
+    return Karyotype.new(kary_str)
+  end
+
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: cytogenetics
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sarah Killcoyne
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-26 00:00:00.000000000 Z
+dependencies: []
+description: Karyotype parser based on ISCN specification. Note that there are still
+  many bugs. The ISCN language is poorly followed by most users so the parser is still
+  being developed.
+email: sarah.killcoyne@uni.lu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cytogenetics/aberration.rb
+- lib/cytogenetics/breakpoint.rb
+- lib/cytogenetics/chromosome.rb
+- lib/cytogenetics/chromosome_aberrations.rb
+- lib/cytogenetics/fragment.rb
+- lib/cytogenetics/karyotype.rb
+- lib/cytogenetics/karyotype_error.rb
+- lib/cytogenetics/utils/band_reader.rb
+- lib/cytogenetics/utils/karyotype_reader.rb
+- lib/cytogenetics/version.rb
+- lib/cytogenetics.rb
+homepage: 
+licenses:
+- http://www.apache.org/licenses/LICENSE-2.0.html
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Karyotype parser based on ISCN specification.
+test_files: []