genealogy 0.3.0 → 0.3.9

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2E0ZWFjOGVkNjE5NmI2NGYwOTFkNTBkOThhMWNkN2NiZGI5MGIyYw==
+    YzJjYzM4NzU0NWU4OWI3N2I1OWUzZWU5OGI3M2VlOTc3NTU5MGU1Yg==
   data.tar.gz: !binary |-
-    YTYwYTBlMDFlNTQxOTg4MDhjYTlmOTRmNGNhMGRlOWE2Zjg5NjViMA==
+    ZWRhODI1YjMxMjA1NDA3MTQ3ZGNhN2NhNDgyOTEyMDQ2ZGY5MmIyZA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MjcxZmY0MmZiNmYwNWE3YWYxYzFhMTA0NjdkYjViYjhkZTMyMTBiOTdlMTgz
-    NDY2YmM2NWExMWE4OTZkN2Q3YmRjN2E4ZjYzYTRhOTBiYmFlYzQwODljNTZl
-    MGIzMzI5YzViNzU4MTEzNDdhNTAzNDQwM2U1NzY4ZTZlMjg1NWE=
+    ZmNiN2MwOTJkN2E2NmExNmMyY2MzYWI5ZWJkMTkwNjE2YTJkNzJlMzM4MDll
+    MTE3MTM0YmI1NWM0N2U3YzA0NDAxYzg1ZDMxNTllMzZkYzJmMTMzMTc1NTc3
+    MTgyNTMyM2FkZTlkMGY1MGFhZDllM2Q2OWU0MzNlNTc1ZjJhMDQ=
   data.tar.gz: !binary |-
-    MDYwMzcwNWFkNWE0M2Q5MmFmZDgzNjFhY2FiZWJmM2UyZjFjNTlhN2EwYWI3
-    ZjhiNDMyNjcwZDJlZDA4NzFmNzY3NDc5YjU1MThmZjNiM2YyODRjZjA3ZTQx
-    M2RiZjc3NDc5MmU0YjQ2M2Q3MzU4NzJjZjgxNGZmYTA2Y2I2NDg=
+    MmY0Yzc1M2FjY2ZjYjJhZWFlZTcyMDMwYmFjOWIxNmQwYzAyMjAxM2E1N2Nl
+    ZTFiYjQzYzBmMzRlNzBkMmI4NWQxY2JkMDg2OGYzZjg4MTdmOWY4ZDBkZTRm
+    N2QyNDM5OWY2Y2RhYWNlNjdkZjBjNTljNWEyMDJhMjdkMzExNzU=

data/lib/genealogy/alter_methods.rb

@@ -8,7 +8,7 @@ module Genealogy
       # add method
       define_method "add_#{parent}" do |relative|
         unless relative.nil?
-          raise IncompatibleObjectException, "Linked objects must be instances of the same class: got #{relative.class} for #{self.class}" unless relative.is_a? self.class
+          raise IncompatibleObjectException, "Both linked objects must be instances of class with genealogy enabled. Got classes #{relative.class} and #{self.genealogy_class}" unless relative.class.respond_to?(:genealogy_enabled)
           incompatible_parents = self.offspring | self.siblings.to_a | [self] 
           raise IncompatibleRelationshipException, "#{relative} can't be #{parent} of #{self}" if incompatible_parents.include? relative
           raise WrongSexException, "Can't add a #{relative.sex} #{parent}" unless (parent == :father and relative.is_male?) or (parent == :mother and relative.is_female?)
@@ -45,13 +45,13 @@ module Genealogy
     [:father, :mother].each do |parent|
       [:father, :mother].each do |grandparent|
         # add one 
-        define_method "add_#{Genealogy::LINEAGE_NAME[parent]}_grand#{grandparent}" do |relative|
+        define_method "add_#{Genealogy::PARENT2LINEAGE[parent]}_grand#{grandparent}" do |relative|
           raise IncompatibleRelationshipException, "#{self} can't be grand#{grandparent} of itself" if relative == self
           raise_if_gap_on(parent)
           send(parent).send("add_#{grandparent}",relative)
         end
         # remove one
-        define_method "remove_#{Genealogy::LINEAGE_NAME[parent]}_grand#{grandparent}" do
+        define_method "remove_#{Genealogy::PARENT2LINEAGE[parent]}_grand#{grandparent}" do
           raise_if_gap_on(parent)
           send(parent).send("remove_#{grandparent}")
         end
@@ -60,12 +60,12 @@ module Genealogy
 
     [:father, :mother].each do |parent|
       # add two by lineage
-      define_method "add_#{Genealogy::LINEAGE_NAME[parent]}_grandparents" do |grandfather,grandmother|
+      define_method "add_#{Genealogy::PARENT2LINEAGE[parent]}_grandparents" do |grandfather,grandmother|
         raise_if_gap_on(parent)
         send(parent).send("add_parents",grandfather,grandmother)
       end
       # remove two by lineage
-      define_method "remove_#{Genealogy::LINEAGE_NAME[parent]}_grandparents" do
+      define_method "remove_#{Genealogy::PARENT2LINEAGE[parent]}_grandparents" do
         raise_if_gap_on(parent)
         send(parent).send("remove_parents")
       end
@@ -91,18 +91,20 @@ module Genealogy
     ## siblings
     def add_siblings(*args)
       options = args.extract_options!
-      raise LineageGapException, "Can't add siblings if both parents are nil" unless father and mother
       raise IncompatibleRelationshipException, "Can't add an ancestor as sibling" unless (ancestors.to_a & args).empty?
       transaction do
         args.each do |sib|
           case options[:half]
           when :father
+            raise LineageGapException, "Can't add paternal halfsiblings without a father" unless father
             sib.add_father(self.father)
             sib.add_mother(options[:spouse]) if options[:spouse]
           when :mother
+            raise LineageGapException, "Can't add maternal halfsiblings without a mother" unless mother
             sib.add_father(options[:spouse]) if options[:spouse]
             sib.add_mother(self.mother)
           when nil
+            raise LineageGapException, "Can't add siblings without parents" unless father and mother
             sib.add_father(self.father)
             sib.add_mother(self.mother)
           else
@@ -112,10 +114,20 @@ module Genealogy
       end
     end
 
-    def remove_siblings(options = {})
-      options.delete_if{ |key,value| key == :half and ![:father,:mother].include?(value) }
+    def add_sibling(sib,options={})
+      add_siblings(sib,options)
+    end
+
+    def remove_siblings(*args)
+      options = args.extract_options!
+      
+      raise WrongOptionException.new("Unknown option value: :half => #{options[:half]}.") if (options[:half] and ![:father,:mother].include?(options[:half]))
 
-      resulting_indivs = siblings(options)
+      resulting_indivs = if args.blank?
+        siblings(options)
+      else
+        args & siblings(options)
+      end
 
       transaction do
 
@@ -130,12 +142,50 @@ module Genealogy
           when nil
             sib.remove_parents
           end  
-
         end
+
       end
 
+      !resulting_indivs.empty? #returned value must be true if self has at least a siblings to affect
+
     end
 
+    def remove_sibling(sib,options={})
+      remove_siblings(sib,options)
+    end
+
+    [:father, :mother].each do |parent|
+      
+      # add paternal/maternal half_siblings
+      define_method "add_#{Genealogy::PARENT2LINEAGE[parent]}_half_siblings" do | *args |
+        options = args.extract_options!
+        options[:half] = parent
+        args << options
+        send("add_siblings",*args)
+      end
+      
+      # add paternal/maternal half_sibling
+      define_method "add_#{Genealogy::PARENT2LINEAGE[parent]}_half_sibling" do | sib,options={} |
+        options[:half] = parent
+        send("add_sibling",sib,options)
+      end
+
+      # remove paternal/maternal half_siblings
+      define_method "remove_#{Genealogy::PARENT2LINEAGE[parent]}_half_siblings" do | *args |
+        options = args.extract_options!
+        options[:half] = parent
+        args << options
+        send("remove_siblings",*args)
+      end
+
+      # remove paternal/maternal half_sibling
+      define_method "remove_#{Genealogy::PARENT2LINEAGE[parent]}_half_sibling" do | sib,options={} |
+        options[:half] = parent
+        send("remove_sibling",sib,options)
+      end
+    end
+
+
     # offspring
     def add_offspring(*args)
       options = args.extract_options!
@@ -156,11 +206,21 @@ module Genealogy
       end
     end
 
-    def remove_offspring(options = {})
+    def add_child(child,options={})
+      add_offspring(child,options)
+    end
+
+    def remove_offspring(*args)
+      options = args.extract_options!
       
       raise_if_sex_undefined
 
-      resulting_indivs = offspring(options)
+      resulting_indivs = if args.blank?
+        offspring(options)
+      else
+        args & offspring(options)
+      end
+
       transaction do
         resulting_indivs.each do |child|
           if options[:affect_spouse] == true
@@ -175,7 +235,11 @@ module Genealogy
           end
         end
       end
-      resulting_indivs.empty? ? false : true
+      !resulting_indivs.empty? #returned value must be true if self has at least a siblings to affect
+    end
+
+    def remove_child(child,options={})
+      remove_offspring(child,options)
     end
 
     private

data/lib/genealogy/constants.rb

@@ -1,3 +1,24 @@
 module Genealogy
-  LINEAGE_NAME = { :father => :paternal, :mother => :maternal }
+  PARENT2LINEAGE = { :father => :paternal, :mother => :maternal }
+  LINEAGE2PARENT = PARENT2LINEAGE.invert
+  PARENT2SEX = { :father => :male, :mother => :female }
+  SEX2PARENT = PARENT2SEX.invert
+  OPPOSITESEX = {:male => :female, :female => :male}
+
+  AKA = {
+    :father => "F",
+    :mother => "M",
+    :paternal_grandfather => "PGF", 
+    :paternal_grandmother => "PGM", 
+    :maternal_grandfather => "MGF", 
+    :maternal_grandmother => "MGM", 
+    :children => "C",
+    :siblings => "S", 
+    :half_siblings => "HS",
+    :paternal_half_siblings => "PHS",
+    :maternal_half_siblings => "MHS", 
+    :grandchildren => "GC", 
+    :uncles_and_aunts => "U&A", 
+    :nieces_and_nephews => "N&N"
+  }
 end

data/lib/genealogy/genealogy.rb

@@ -19,17 +19,20 @@ module Genealogy
 
   def has_parents options = {}
 
-    admitted_keys = [:sex_column, :sex_values, :father_column, :mother_column, :spouse_column, :spouse]
+    admitted_keys = [:sex_column, :sex_values, :father_column, :mother_column, :current_spouse_column, :current_spouse]
     check_options(options, admitted_keys) do |key, value|
       if key == :sex_values
         raise WrongOptionException, ":sex_values option must be an array with two char: first for male sex symbol an last for female" unless value.is_a?(Array) and value.size == 2 and value.first.to_s.size == 1 and value.last.to_s.size == 1
       end
     end
     
-    class_attribute :spouse_enabled
-    self.spouse_enabled = options[:spouse].try(:==,true) || false
-    tracked_parents = [:father, :mother]
-    tracked_parents << :spouse if spouse_enabled
+    class_attribute :genealogy_enabled, :current_spouse_enabled, :genealogy_class
+    self.genealogy_enabled = true
+    self.current_spouse_enabled = options[:current_spouse].try(:==,true) || false
+    self.genealogy_class = self #keep track of the original extend class to prevent wrong scopes in query method in case of STI
+    
+    tracked_relatives = [:father, :mother]
+    tracked_relatives << :current_spouse if current_spouse_enabled
 
     ## sex
     # class attributes
@@ -45,7 +48,7 @@ module Genealogy
     validates_format_of sex_column, :with => /[#{sex_values.join}]/ 
 
     ## relatives associations
-    tracked_parents.each do |key|
+    tracked_relatives.each do |key|
       # class attribute where is stored the correspondig foreign_key column name
       class_attribute_name = "#{key}_column"
       foreign_key = "#{key}_id"
@@ -61,7 +64,7 @@ module Genealogy
     # Include instance methods and class methods
     include Genealogy::QueryMethods
     include Genealogy::AlterMethods
-    include Genealogy::SpouseMethods if spouse_enabled
+    include Genealogy::SpouseMethods if current_spouse_enabled
 
   end
   

data/lib/genealogy/query_methods.rb

@@ -4,10 +4,17 @@ module Genealogy
 
     # parents
     def parents
-      if father or mother
-        [father,mother]
-      else
-        []
+      [father,mother]
+    end
+
+    # eligible
+    [:father, :mother].each do |parent|
+      define_method "eligible_#{parent}s" do
+        if send(parent)
+          []
+        else
+          self.genealogy_class.send("#{Genealogy::PARENT2SEX[parent]}s") - descendants - [self]
+        end
       end
     end
 
@@ -16,52 +23,89 @@ module Genealogy
       [:father, :mother].each do |grandparent|
 
         # get one
-        define_method "#{Genealogy::LINEAGE_NAME[parent]}_grand#{grandparent}" do
+        define_method "#{Genealogy::PARENT2LINEAGE[parent]}_grand#{grandparent}" do
           send(parent) && send(parent).send(grandparent)
         end
 
+        # eligible
+        define_method "eligible_#{Genealogy::PARENT2LINEAGE[parent]}_grand#{grandparent}s" do 
+          if send(parent) and send("#{Genealogy::PARENT2LINEAGE[parent]}_grand#{grandparent}").nil?
+            send(parent).send("eligible_#{grandparent}s") - [self]
+          else
+            []
+          end
+        end
+
       end
 
       # get two by lineage
-      define_method "#{Genealogy::LINEAGE_NAME[parent]}_grandparents" do
-        (send(parent) && send(parent).parents) || []
+      define_method "#{Genealogy::PARENT2LINEAGE[parent]}_grandparents" do
+        (send(parent) && send(parent).parents) || [nil,nil]
       end
 
     end
 
-    # get all
     def grandparents
       result = []
       [:father, :mother].each do |parent|
         [:father, :mother].each do |grandparent|
-          result << send("#{Genealogy::LINEAGE_NAME[parent]}_grand#{grandparent}")
+          result << send("#{Genealogy::PARENT2LINEAGE[parent]}_grand#{grandparent}")
         end
       end
-      result.compact! if result.all?{|gp| gp.nil? }
+      # result.compact! if result.all?{|gp| gp.nil? }
       result
     end
 
+    # offspring
     def offspring(options = {})
-
       if spouse = options[:spouse]
         raise WrongSexException, "Something wrong with spouse #{spouse} gender." if spouse.sex == sex 
       end
       case sex
       when sex_male_value
-        self.class.find_all_by_father_id(id, :conditions => (["mother_id == ?", spouse.id] if spouse) )
+        if options.keys.include?(:spouse)
+          self.genealogy_class.find_all_by_father_id_and_mother_id(id,spouse.try(:id))
+        else
+          self.genealogy_class.find_all_by_father_id(id)
+        end
       when sex_female_value
-        self.class.find_all_by_mother_id(id, :conditions => (["father_id == ?", spouse.id] if spouse) )
+        if options.keys.include?(:spouse)
+          self.genealogy_class.find_all_by_mother_id_and_father_id(id,spouse.try(:id))
+        else
+          self.genealogy_class.find_all_by_mother_id(id)
+        end
       end
     end
+    alias_method :children, :offspring
+
+    def eligible_offspring
+      self.genealogy_class.all - ancestors - offspring - siblings - [self]
+    end
+    alias_method :eligible_children, :eligible_offspring
+
+    # spouses
+    def spouses
+      parent_method = Genealogy::SEX2PARENT[Genealogy::OPPOSITESEX[sex_to_s.to_sym]]
+      offspring.collect{|child| child.send(parent_method)}.uniq
+    end
 
+    def eligible_spouses
+      self.genealogy_class.send("#{Genealogy::OPPOSITESEX[sex_to_s.to_sym]}s") - spouses
+    end
+
+    # siblings
     def siblings(options = {})
       result = case options[:half]
-      when nil # exluding half siblings
-        father.try(:offspring, :spouse => mother ).to_a
+      when nil # only full siblings
+        unless parents.include?(nil)
+          father.try(:offspring, :spouse => mother ).to_a
+        else
+          []
+        end
       when :father # common father
-        father.try(:offspring, :spouse => options[:spouse]).to_a - mother.try(:offspring).to_a
+        father.try(:offspring, options.keys.include?(:spouse) ? {:spouse => options[:spouse]} : {}).to_a - mother.try(:offspring).to_a
       when :mother # common mother
-        mother.try(:offspring, :spouse => options[:spouse]).to_a - father.try(:offspring).to_a
+        mother.try(:offspring, options.keys.include?(:spouse) ? {:spouse => options[:spouse]} : {}).to_a - father.try(:offspring).to_a
       when :only # only half siblings
         siblings(:half => :include) - siblings
       when :include # including half siblings
@@ -72,6 +116,10 @@ module Genealogy
       result.uniq - [self]
     end
 
+    def eligible_siblings
+      self.genealogy_class.all - ancestors - siblings(:half => :include) - [self]
+    end
+
     def half_siblings
       siblings(:half => :only)
       # todo: inprove with option :father and :mother 
@@ -85,6 +133,11 @@ module Genealogy
       siblings(:half => :mother)
     end
 
+    alias_method :eligible_half_siblings, :eligible_siblings
+    alias_method :eligible_paternal_half_siblings, :eligible_siblings
+    alias_method :eligible_maternal_half_siblings, :eligible_siblings
+
+    # ancestors
     def ancestors
       result = []
       remaining = parents.to_a.compact
@@ -95,16 +148,86 @@ module Genealogy
       result.uniq
     end
 
+    # descendants
     def descendants
       result = []
       remaining = offspring.to_a.compact
       until remaining.empty?
         result << remaining.shift
         remaining += result.last.offspring.to_a.compact
+        # break if (remaining - result).empty? can be necessary in case of loop. Idem for ancestors method
       end
       result.uniq
     end
 
+    def grandchildren
+      offspring.inject([]){|memo,child| memo |= child.offspring}
+    end
+
+    def uncles_and_aunts
+      parents.compact.inject([]){|memo,parent| memo |= parent.siblings}
+    end
+
+    def nieces_and_nephews
+      siblings.inject([]){|memo,sib| memo |= sib.offspring}
+    end
+
+    def family(options = {}) 
+      res = [self] | siblings | parents | offspring
+      res |= case options[:half]
+        when nil
+          []
+        when :include
+          half_siblings
+        when :father
+          paternal_half_siblings
+        when :mother
+          maternal_half_siblings
+        else
+          raise WrongOptionValueException, "Admitted values for :half options are: :father, :mother, :include, nil"
+      end
+      offspring.inject(res){|memo,child| memo |= child.parents}.compact
+    end
+
+    def family_hash(options = {}) 
+      roles = [:father, :mother, :children, :siblings]
+      roles += case options[:half]
+        when nil
+          []
+        when :include
+          [:half_siblings]
+        when :father
+          [:paternal_half_siblings]
+        when :mother
+          [:maternal_half_siblings]
+        else
+          raise WrongOptionValueException, "Admitted values for :half options are: :father, :mother, :include, nil"
+      end
+      h = {}
+      roles.each{|role| h[role] = self.send(role)}
+      h
+    end
+
+    def extended_family(options = {}) 
+      (family(options) + grandparents + grandchildren + uncles_and_aunts + nieces_and_nephews).compact
+    end
+
+    def extended_family_hash(options = {}) 
+      h = family_hash(options)
+      [:paternal_grandfather, :paternal_grandmother, :maternal_grandfather, :maternal_grandmother, :grandchildren, :uncles_and_aunts, :nieces_and_nephews].each{|role| h[role] = self.send(role)}
+      h
+    end
+
+    def sex_to_s
+      case sex
+      when sex_male_value
+        'male'
+      when sex_female_value
+        'female'
+      else 
+        raise "undefined sex for #{self}"
+      end
+    end
 
     def is_female?
       sex == sex_female_value
@@ -115,6 +238,12 @@ module Genealogy
     end
 
     module ClassMethods
+      def males
+        where(sex_column => sex_male_value)
+      end
+      def females
+        where(sex_column => sex_female_value)
+      end
     end
 
   end

data/lib/genealogy/spouse_methods.rb

@@ -3,11 +3,11 @@ module Genealogy
     extend ActiveSupport::Concern
 
     # add method
-    def add_spouse(obj)
-      raise IncompatibleObjectException, "Linked objects must be instances of the same class" unless obj.is_a? self.class
-      raise WrongSexException, "Can't add spouse with same sex" if self.sex == obj.sex
-      self.spouse = obj
-      obj.spouse = self
+    def add_current_spouse(obj)
+      raise IncompatibleObjectException, "Linked objects must be instances of the same class" unless obj.is_a? self.genealogy_class
+      raise WrongSexException, "Can't add current_spouse with same sex" if self.sex == obj.sex
+      self.current_spouse = obj
+      obj.current_spouse = self
       transaction do
         obj.save!
         save!
@@ -15,16 +15,21 @@ module Genealogy
     end
 
     # remove method
-    def remove_spouse
+    def remove_current_spouse
       transaction do
-        ex_spouse = spouse
-        spouse.spouse = nil
-        self.spouse = nil
-        ex_spouse.save!
+        ex_current_spouse = current_spouse
+        current_spouse.current_spouse = nil
+        self.current_spouse = nil
+        ex_current_spouse.save!
         save!
       end
     end
 
+    # query methods
+    def eligible_current_spouses
+      self.genealogy_class.send("#{Genealogy::OPPOSITESEX[sex_to_s.to_sym]}s") - spouses
+    end
+
     module ClassMethods
     end
 

data/lib/genealogy/version.rb

@@ -1,3 +1,3 @@
 module Genealogy
-  VERSION = "0.3.0"
+  VERSION = "0.3.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: genealogy
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.9
 platform: ruby
 authors:
 - masciugo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-22 00:00:00.000000000 Z
+date: 2013-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -94,6 +94,20 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Genealogy is a ruby gem library which extend ActiveRecord::Base class
   with familiar relationships capabilities in order to build and query genealogies
 email:
@@ -110,7 +124,7 @@ files:
 - lib/genealogy/query_methods.rb
 - lib/genealogy/spouse_methods.rb
 - lib/genealogy/version.rb
-homepage: https://github.com//genealogy
+homepage: https://github.com/masciugo/genealogy
 licenses:
 - MIT
 metadata: {}