copycats 0.0.1 → 0.5.0

data/lib/copycats/data.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+
+## load all *.file in data folder
+
+
+
+def find_datafiles( root='.' )
+  files = []
+  ## todo/check: include all subfolders - why? why not?
+  Dir.glob( root + '/**/*.csv' ).each do |file|
+    files << file
+  end
+  files
+end
+
+
+def connect( config={} )
+  if config.empty?
+    puts "ENV['DATBASE_URL'] - >#{ENV['DATABASE_URL']}<"
+
+    ### change default to ./copycats.db ?? why? why not?
+    db = URI.parse( ENV['DATABASE_URL'] || 'sqlite3:///kitties.db' )
+
+    if db.scheme == 'postgres'
+        config = {
+          adapter: 'postgresql',
+          host: db.host,
+          port: db.port,
+          username: db.user,
+          password: db.password,
+          database: db.path[1..-1],
+          encoding: 'utf8'
+        }
+      else # assume sqlite3
+       config = {
+         adapter: db.scheme, # sqlite3
+         database: db.path[1..-1] # world.db (NB: cut off leading /, thus 1..-1)
+      }
+      end
+    end
+
+    puts "Connecting to db using settings: "
+    pp config
+    ActiveRecord::Base.establish_connection( config )
+    # ActiveRecord::Base.logger = Logger.new( STDOUT )
+  end
+
+
+def setup_in_memory_db
+  # Database Setup & Config
+
+  ## ActiveRecord::Base.logger = Logger.new( STDOUT )
+  ## ActiveRecord::Base.colorize_logging = false  - no longer exists - check new api/config setting?
+
+  connect( adapter:  'sqlite3',
+           database: ':memory:' )
+
+  ## build schema
+  CreateDb.new.up
+end # setup_in_memory_db (using SQLite :memory:)
+
+
+
+def setup( data_dir: './data' )
+  files = find_datafiles( data_dir )
+  pp files
+
+  ## check if files found
+
+  ## setup sqlite in-memory db
+  setup_in_memory_db()
+
+
+  ## add / read / load all datafiles
+  files.each_with_index do |file,i|
+
+    puts "== #{i+1}/#{files.size} reading datafile '#{file}'..."
+
+    kitties = CSV.read( file, headers:true )
+    pp kitties.headers
+
+    ## note: for now use first 5 rows for testing
+    ## kitties[0..4].each do |row|
+    kitties.each do |row|
+      ## puts row['id'] + '|' + row['gen'] + '|' + row['genes_kai']
+      k = Copycats::Model::Kitty.new
+      k.id    = row['id'].to_i
+      k.gen   = row['gen'].to_i
+      k.genes = row['genes_kai']
+      ## pp k
+
+      ## print ids for progress report - why? why not?
+      print "#{k.id}."
+      k.save!
+    end
+    print "\n"
+  end
+end

data/lib/copycats/gene.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+class Gene
+
+  attr_reader :d, :r1, :r2, :r3
+  # d  (dominant gene)    -- todo/check: rename to just d instead of d0 - why? why not?
+  # r1 (1st order recessive gene)
+  # r2 (2nd order recessive gene)
+  # r3 (3rd order recessive gene)
+
+  def initialize( arg )
+     ## (always) assume String in base32/kai for now
+     kai = arg
+     ## puts "Gene.initialize #{kai}"
+     kai = kai.reverse
+     @d   = kai[0]
+     @r1  = kai[1]
+     @r2  = kai[2]
+     @r3  = kai[3]
+  end
+
+  def to_kai()  @r3 + @r2 + @r1 + @d; end   ## return a string in kai/base32 notation
+
+  def swap
+    puts "Gene#swap"
+    kai = to_kai.reverse      # note: use reverse kai string (kai[0] is first char/digit/letter)
+
+    3.downto(1) do |i|
+      if Lottery.rand(100) < 25
+        puts " bingo! swap #{i}<>#{i-1}"
+        kai[i-1], kai[i] = kai[i], kai[i-1]
+      end
+    end
+    Gene.new( kai.reverse )  ## note: do NOT forget to pass in kai (unreversed)
+  end
+
+
+  def mutate( other )
+    puts "Gene#mutate"
+
+    gene1 = KAI_TO_INT[d]          ## dominant gene1
+    gene2 = KAI_TO_INT[other.d]    ## dominant gene2
+    if gene1 > gene2
+      gene1, gene2 = gene2, gene1     ## make sure gene2 is always bigger
+    end
+    if (gene2 - gene1) == 1 && gene1.even?
+      probability = 25
+      probability /= 2   if gene1 > 23
+      if Lottery.rand(100) < probability
+        genex = (gene1 / 2) + 16       ## 16=2^4
+        puts " bingo! mutation #{gene2}+#{gene1} => #{genex}"
+        puts "                 #{Kai::ALPHABET[gene2]}+#{Kai::ALPHABET[gene1]} => #{Kai::ALPHABET[genex]}"
+        return Kai::ALPHABET[genex]
+      end
+    end
+    nil   # no mutation
+  end
+
+  def mix_inner( other )
+    puts "Gene#mix_inner"
+
+    new_d = mutate( other )
+    if new_d.nil?    ## no mutation of gene.d - use "regular" formula
+      new_d = Lottery.rand(100) < 50 ? d : other.d
+    end
+
+    new_r1 = Lottery.rand(100) < 50 ? r1 : other.r1
+    new_r2 = Lottery.rand(100) < 50 ? r2 : other.r2
+    new_r3 = Lottery.rand(100) < 50 ? r3 : other.r3
+
+    gene = Gene.new( new_r3 + new_r2 + new_r1 + new_d )
+    pp gene
+    gene
+  end
+
+
+  def mix( other )
+    puts "Gene#mix"
+    self_swapped  = swap
+    other_swapped = other.swap
+
+    gene = self_swapped.mix_inner( other_swapped )
+    pp gene
+    gene
+  end
+
+end  # class Gene

data/lib/copycats/genome.rb

@@ -0,0 +1,177 @@
+# encoding: utf-8
+
+
+class Genome
+  attr_reader :genes   ## hash of genes (key is gene type)
+
+  def initialize( arg )
+    if arg.is_a? Hash
+      hash = arg       ## assumes (pre-built) hash with genes
+      @genes = hash
+    else
+      if arg.is_a? Integer   ## use Integer (Fixnum+Bignum??) - why? why not?
+        num = arg
+        kai = Kai.encode( num )
+      else              # else assume string in kai/base32 format
+        kai = arg.dup  # just in case; make a clean (fresh) copy
+        kai = kai.gsub( ' ', '' )   ## allow spaces (strip/remove)
+      end
+      ## puts "Genome.initialize #{kai}"
+      build_genes( kai )
+    end
+  end
+
+  def build_genes( kai )
+    kai = kai.reverse    ## note: reserve for easy left-to-right access
+    @genes = {}   ## hash of genes (key is gene type)
+    ## fix/todo: use as_json for "official" api order
+    ## note: use insert order from "official" api
+    @genes[:body]      = Gene.new( kai[0,4].reverse )
+    @genes[:pattern]   = Gene.new( kai[4,4].reverse )
+    @genes[:coloreyes] = Gene.new( kai[8,4].reverse )
+    @genes[:eyes]      = Gene.new( kai[12,4].reverse )
+    @genes[:color1]    = Gene.new( kai[16,4].reverse )  ## colorprimary / body color / base color
+    @genes[:color2]    = Gene.new( kai[20,4].reverse )  ## colorsecondary / sec color / pattern color /  hi(light) color
+    @genes[:color3]    = Gene.new( kai[24,4].reverse )  ## colortertiary / acc(ent) color
+    @genes[:wild]      = Gene.new( kai[28,4].reverse )
+    @genes[:mouth]     = Gene.new( kai[32,4].reverse )
+  end
+
+  def body()      TRAITS[:body][:kai][ @genes[:body].d ]; end
+  def coloreyes() TRAITS[:coloreyes][:kai][ @genes[:coloreyes].d ]; end
+  def eyes()      TRAITS[:eyes][:kai][ @genes[:eyes].d ]; end
+  def pattern()   TRAITS[:pattern][:kai][ @genes[:pattern].d ]; end
+  def mouth()     TRAITS[:mouth][:kai][ @genes[:mouth].d ]; end
+  def color1()    TRAITS[:color1][:kai][ @genes[:color1].d ]; end
+  def color2()    TRAITS[:color2][:kai][ @genes[:color2].d ]; end
+  def color3()    TRAITS[:color3][:kai][ @genes[:color3].d ]; end
+
+
+
+  def genes_color1() @genes[:color1]; end   ## rename to color1_genes instead - why? why not?
+  def genes_eyes()   @genes[:eyes];   end
+  ## ....
+
+  ## add cattributes  ?? why? why not?
+
+
+  def mix( other )
+    mgenes = genes          ## matron genes
+    sgenes = other.genes    ## sire genes
+    new_genes  = {}
+
+    ## todo/fix: use insertion order from "official" api - why? why not?
+    ##   -- preinitialize with empty hash and than use byte order ??
+    TRAIT_KEYS.each do |key|
+      mgene = mgenes[key]
+      sgene = sgenes[key]
+
+      new_gene = mgene.mix( sgene )
+      new_genes[key] = new_gene
+    end
+
+    Genome.new( new_genes )   ## return new genome from (pre-built) hash (with genes)
+  end
+
+
+  def build_tables()   GenomeTables.new( self ).build;  end
+
+  def build_mix_tables( other )  GenomeMixTables.new( self, other ).build; end
+
+end # class Genome
+
+
+
+class GenomeTables
+  def initialize( genome )
+    @genome = genome
+  end
+
+  def build
+    pos = 0
+    buf = ""
+
+    genes = @genome.genes
+
+    TRAITS.each do |key, trait|
+      gene       = genes[key]
+      next  if gene.nil?   ## skip future_1, future_2, etc.
+
+      buf << "#{trait[:name]} (Genes #{trait[:genes]})\n\n"
+
+###
+##   fix/todo: add stars for purity?
+##     ****   - all traits the same
+##     ***    - two same pairs of traits
+##     **     - one pair of same traits
+
+      buf << "|Gene  |Binary   |Kai  |Trait    |   |\n"
+      buf << "|------|---------|-----|---------|---|\n"
+      buf << "| #{pos} | #{Kai::BINARY[gene.d]} | #{gene.d} | **#{fmt_trait(trait[:kai][gene.d])}** | d |\n"; pos+=1
+      buf << "| #{pos} | #{Kai::BINARY[gene.r1]} | #{gene.r1} | #{fmt_trait(trait[:kai][gene.r1])} | r1 |\n"; pos+=1
+      buf << "| #{pos} | #{Kai::BINARY[gene.r2]} | #{gene.r2} | #{fmt_trait(trait[:kai][gene.r2])} | r2 |\n"; pos+=1
+      buf << "| #{pos} | #{Kai::BINARY[gene.r3]} | #{gene.r3} | #{fmt_trait(trait[:kai][gene.r3])} | r3 |\n"; pos+=1
+      buf << "\n"
+
+      if key == :body    ## add legend for first entry
+        buf << "d = dominant, r1 = 1st order recessive, r2 = 2nd order recessive, r3 = 3rd order recessive\n\n"
+      end
+    end
+
+    buf
+  end
+
+####################
+## helpers
+
+  def fmt_trait( trait )
+    (trait.nil? || trait.empty?) ? '?' : trait
+  end
+end  # class GenomeTables
+
+
+
+
+class GenomeMixTables
+  def initialize( matron, sire )
+    @matron = matron
+    @sire   = sire
+  end
+
+  def build
+    pos = 0
+    buf = ""
+
+    mgenes = @matron.genes
+    sgenes = @sire.genes
+
+    TRAITS.each do |key, trait|
+      mgene  = mgenes[key]
+      sgene  = sgenes[key]
+      next  if mgene.nil?   ## skip future_1, future_2, etc.
+
+      buf << "#{trait[:name]} (Genes #{trait[:genes]})\n\n"
+
+      buf << "|Gene  |Kai  |Trait (Matron)|Kai|Trait (Sire)|   |\n"
+      buf << "|------|-----|---------|-----|---------|---|\n"
+      buf << "| #{pos} | #{mgene.d} | **#{fmt_trait(trait[:kai][mgene.d])}** | #{sgene.d} | **#{fmt_trait(trait[:kai][sgene.d])}** | d |\n"; pos+=1
+      buf << "| #{pos} | #{mgene.r1} | #{fmt_trait(trait[:kai][mgene.r1])} | #{sgene.r1} | #{fmt_trait(trait[:kai][sgene.r1])} | r1 |\n"; pos+=1
+      buf << "| #{pos} | #{mgene.r2} | #{fmt_trait(trait[:kai][mgene.r2])} | #{sgene.r2} | #{fmt_trait(trait[:kai][sgene.r2])} | r2 |\n"; pos+=1
+      buf << "| #{pos} | #{mgene.r3} | #{fmt_trait(trait[:kai][mgene.r3])} | #{sgene.r3} | #{fmt_trait(trait[:kai][sgene.r3])} | r3 |\n"; pos+=1
+      buf << "\n"
+
+      if key == :body    ## add legend for first entry
+        buf << "d = dominant, r1 = 1st order recessive, r2 = 2nd order recessive, r3 = 3rd order recessive\n\n"
+      end
+    end
+
+    buf
+  end
+
+####################
+## helpers
+
+  def fmt_trait( trait )
+    (trait.nil? || trait.empty?) ? '?' : trait
+  end
+end  # class GenomeMixTables

data/lib/copycats/models/kitty.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Copycats
+  module Model
+
+class Kitty < ActiveRecord::Base
+  self.table_name = 'kitties'
+
+end  # class Kitty
+
+
+  end # module Model
+end # module Copycats

data/lib/copycats/reports/genes.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+
+class GenesReport
+
+def build
+  buf = ""
+  buf << "# Genes (#{TRAITS.keys.size} x 4)\n\n"
+
+  headings = []
+  TRAITS.values.each do |trait|
+    headings << "#{trait[:name]} (#{trait[:genes]})"
+  end
+
+  buf << headings.join( " • " )
+  buf << "\n\n"
+
+
+  ## pp TRAITS
+  TRAITS.values.each do |trait|
+
+    puts "Kai	 Cattribute"
+    items = []
+    Kai::ALPHABET.each_char do |kai|
+      value = trait[:kai][kai]
+      value = '?'  if value.nil? || value.empty?
+      items << [kai, value]
+    end
+
+    items.each do |item|
+      puts "#{item[0]} #{item[1]}"
+    end
+
+    buf << "## #{trait[:name]} (Genes #{trait[:genes]})\n\n"
+    buf << make_table( items )
+    buf << "\n\n"
+  end
+
+  puts buf
+
+  buf
+end ## method build
+
+def make_table( items )
+  rows = make_rows( items, columns: 4 )
+  pp rows
+
+  buf = ""
+  buf << "|Kai|Cattribute   |Kai|Cattribute  |Kai|Cattribute  |Kai|Cattribute  |\n"
+  buf << "|---|-------------|---|------------|---|------------|---|------------|\n"
+
+  rows.each do |row|
+    buf << "| "
+    buf <<  row.map {|item| "#{item[0]} | #{item[1]}" }.join( " | " )
+    buf << " |\n"
+  end
+
+  buf
+end
+
+
+## helpers
+def make_rows( items, columns: 4 )
+  offset = items.size / columns
+  pp offset
+
+  rows = []
+  offset.times.with_index do |row|
+    ## note: construct [items[row],items[offset+row],items[offset*2+row], ...]
+    rows << columns.times.with_index.map { |col| items[offset*col+row] }
+  end
+  rows
+end
+
+
+  def save( path )
+    File.open( path, "w" ) do |f|
+      f.write build
+    end
+  end
+
+end # class GenesReport