gedcomx-jruby 0.1.1 → 0.1.3

data/lib/gedcomx/field_value.rb

@@ -0,0 +1,32 @@
+module Gedcomx
+  class FieldValue
+
+    def self.java_class
+      Java::OrgGedcomxRecords::FieldValue
+    end
+
+    def initialize(input = nil)
+      @value = input || self.class.java_class.new
+    end
+
+    def text
+      @value.get_text
+    end
+
+    def text=(input_string)
+      @value.text= input_string
+    end
+
+    def type
+      @value.get_type.to_s
+    end
+
+    def type= (input_type)
+      @value.type = ( input_type.is_a? Gedcomx.java_uri_class ) ? input_type : Gedcomx.new_uri(input_type)
+    end
+
+    def to_java
+      @value
+    end
+  end
+end

data/lib/gedcomx/gender.rb

@@ -0,0 +1,59 @@
+module Gedcomx
+  class Gender
+
+    attr_reader :fields
+
+    def self.java_class
+      Java::OrgGedcomxConclusion::Gender
+    end
+
+    def self.create(attributes = {})
+      new_gender = self.new
+      new_gender.type = attributes[:type] if attributes[:type]
+      attributes[:fields].each { |field| new_gender.add_field(field) } if attributes[:fields].is_a? Array
+      new_gender
+    end
+
+    def self.create_male
+      new_gender = self.new
+      new_gender.type = Gedcomx::TYPES[:male]
+      field = Gedcomx::Field.create( values: [ { text: 'Male', type: Gedcomx::TYPES[:original] } ],
+                                     type: Gedcomx::TYPES[:gender] )
+      new_gender.add_field(field)
+      new_gender
+    end
+
+    def self.create_female
+      new_gender = self.new
+      new_gender.type = Gedcomx::TYPES[:female]
+      field = Gedcomx::Field.create( values: [ { text: 'Female', type: Gedcomx::TYPES[:original] } ],
+                                     type: Gedcomx::TYPES[:gender] )
+      new_gender.add_field(field)
+      new_gender
+    end
+
+    def initialize(input = nil)
+      @gender = input || self.class.java_class.new
+      @fields = []
+      @fields = @gender.fields.map { |field| Gedcomx::Field.new(field) } if @gender.fields.is_a? Array
+    end
+
+    def add_field(field)
+      return false unless field.is_a? Gedcomx::Field
+      @gender.add_field field.to_java
+      @fields << field
+    end
+
+    def type
+      @gender.get_type.to_s
+    end
+
+    def type= (input_type)
+      @gender.type = ( input_type.is_a? Gedcomx.java_uri_class ) ? input_type : Gedcomx.new_uri(input_type)
+    end
+
+    def to_java
+      @gender
+    end
+  end
+end

data/lib/gedcomx/identifier.rb

@@ -0,0 +1,39 @@
+module Gedcomx
+  class Identifier
+
+    def self.java_class
+      Java::OrgGedcomxConclusion::Identifier
+    end
+
+    def self.create(attributes = {})
+      new_identifier = self.new
+      new_identifier.type = attributes[:type] if attributes[:type]
+      new_identifier.value = attributes[:value] if attributes[:value]
+      new_identifier
+    end
+
+    def initialize(input = nil)
+      @identifier = input || self.class.java_class.new
+    end
+
+    def type
+      @identifier.get_type.to_s
+    end
+
+    def type=(input_type)
+      @identifier.type = ( input_type.is_a? Gedcomx.java_uri_class ) ? input_type : Gedcomx.new_uri(input_type)
+    end
+
+    def value
+      @identifier.get_value.to_s
+    end
+
+    def value=(input_value)
+      @identifier.value = ( input_value.is_a? Gedcomx.java_uri_class ) ? input_value : Gedcomx.new_uri(input_value)
+    end
+
+    def to_java
+      @identifier
+    end
+  end
+end

data/lib/gedcomx/iterator.rb

@@ -2,6 +2,9 @@
 module Gedcomx
   class Iterator
     def initialize(input)
+      unless File.file?(input)
+        input = Gedcomx.input_stream(input)
+      end
       @iter = org.gedcomx.util.RecordSetIterator.new(input)
     end
 
@@ -16,5 +19,9 @@ module Gedcomx
     def next
       Record.new(@iter.next)
     end
+
+    def to_java
+      @iter
+    end
   end
 end

data/lib/gedcomx/jruby/version.rb

@@ -1,5 +1,5 @@
 module Gedcomx
   module Jruby
-    VERSION = "0.1.1"
+    VERSION = "0.1.3"
   end
 end

data/lib/gedcomx/name.rb

@@ -0,0 +1,133 @@
+module Gedcomx
+  class Name
+
+    attr_reader :date, :forms
+
+    def self.java_class
+      Java::OrgGedcomxConclusion::Name
+    end
+
+    def self.build_simple(attributes = {})
+      first = attributes[:first]
+      last = attributes[:last]
+      name_form = Gedcomx::NameForm.new
+      name_form.full_text = attributes[:full] if attributes[:full]
+
+      if first
+        field = Gedcomx::Field.create( first_attributes = {
+          values: [ { text: first, type: Gedcomx::TYPES[:original] } ],
+          type: Gedcomx::TYPES[:given]
+        } )
+
+        name_part = Gedcomx::NamePart.create( first_attributes = {
+          fields: [ field ],
+          value: first,
+          type: Gedcomx::TYPES[:given]
+        })
+
+        name_form.add_part(name_part)
+      end
+
+      if last
+        field = Gedcomx::Field.create( last_attributes = {
+          values: [ { text: last, type: Gedcomx::TYPES[:original] } ],
+          type: Gedcomx::TYPES[:surname]
+        } )
+
+        name_part = Gedcomx::NamePart.create( last_attributes = {
+          fields: [ field ],
+          value: last,
+          type: Gedcomx::TYPES[:surname]
+        })
+
+        name_form.add_part(name_part)
+      end
+
+      attributes[:forms] = [name_form]
+      self.create(attributes)
+    end
+
+    def self.create(attributes = {})
+      new_name = self.new
+      new_name.confidence = attributes[:confidence] if attributes[:confidence]
+      new_name.preferred = attributes[:preferred] if attributes[:preferred]
+      new_name.language = attributes[:language] if attributes[:language]
+      new_name.type = attributes[:type] if attributes[:type]
+
+      if attributes[:type]
+        puts attributes[:type]
+      end
+
+      attributes[:forms].each { |form| new_name.add_form(form) } if attributes[:forms].is_a? Array
+      new_name
+    end
+
+    def initialize(input = nil)
+      @name = input || self.class.java_class.new
+      @date = Gedcomx::Date.new(@name.get_date) if @name.get_date
+      @forms = []
+      @forms = @name.get_name_forms.map { |form| Gedcomx::NameForm.new(form) } if @name.get_name_forms
+    end
+
+    def add_form(form)
+      return false unless form.is_a? Gedcomx::NameForm
+      @name.add_name_form form.to_java
+      @forms << form
+    end
+
+    def date=(date)
+      return false unless date.is_a? Gedcomx::Date
+      @name.date = date.to_java
+      @date = date
+    end
+
+    def confidence
+      @name.get_confidence
+    end
+
+    def confidence=(input_confidence)
+      if input_confidence.is_a? Gedcomx.java_uri_class
+       @name.confidence = input_confidence
+      else
+        @name.confidence = Gedcomx.new_uri(input_confidence)
+      end
+    end
+
+    def preferred?
+      @name.get_preferred
+    end
+
+    def preferred=(input_boolean)
+      return false unless input_boolean.is_a? Boolean
+      @name.preferred = input_boolean
+    end
+
+    def language
+      @name.get_lang
+    end
+
+    def language=(input_language)
+      return false unless input_language.is_a? String
+      @name.lang = input_language
+    end
+
+    def type
+      @name.get_type.to_s
+    end
+
+    def type=(input_type)
+      @name.type = ( input_type.is_a? Gedcomx.java_uri_class ) ? input_type : Gedcomx.new_uri(input_type)
+    end
+
+    def to_java
+      @name
+    end
+
+    # Generates accessor methods for each of the types
+    TYPES.keys.each do |type|
+      define_method type do
+        first_value(type)
+      end
+    end
+  end
+end

data/lib/gedcomx/name_form.rb

@@ -0,0 +1,41 @@
+module Gedcomx
+  class NameForm
+
+    attr_reader :parts
+
+    def self.java_class
+      Java::OrgGedcomxConclusion::NameForm
+    end
+
+    def self.create(attributes = {})
+      new_form = self.new
+      new_form.full_text = attributes[:full_text] if attributes[:full_text]
+      attributes[:fields].each { |field| new_form.add_field field } if attributes[:fields].is_a? Array
+      attributes[:parts].each { |part| new_form.add_part part } if attributes[:parts].is_a? Array
+    end
+
+    def initialize(input = nil)
+      @name_form = input || self.class.java_class.new
+      @parts = []
+      @parts = @name_form.parts.map { |part| Gedcomx::NamePart.new(part) } if @name_form.parts
+    end
+
+    def add_part(part)
+      return false unless part.is_a? Gedcomx::NamePart
+      @name_form.add_part part.to_java
+      @parts << part
+    end
+
+    def full_text
+      @name_form.get_full_text
+    end
+
+    def full_text=(full_text)
+      @name_form.full_text = full_text
+    end
+
+    def to_java
+      @name_form
+    end
+  end
+end

data/lib/gedcomx/name_part.rb

@@ -0,0 +1,50 @@
+module Gedcomx
+  class NamePart
+
+    attr_reader :fields
+
+    def self.java_class
+      Java::OrgGedcomxConclusion::NamePart
+    end
+
+    def self.create(attributes = {})
+      new_part = self.new
+      new_part.value = attributes[:value] if attributes[:value]
+      new_part.type = attributes[:type] if attributes[:type]
+      attributes[:fields].each { |field| new_part.add_field field } if attributes[:fields].is_a? Array
+      new_part
+    end
+
+    def initialize(input = nil)
+      @name_part = input || self.class.java_class.new
+      @fields = []
+      @fields = @name_part.fields.map { |field| Gedcomx::Field.new(field) } if @name_part.fields
+    end
+
+    def add_field(field)
+      return false unless field.is_a? Gedcomx::Field
+      @name_part.to_java.add_field field.to_java
+      @fields << field
+    end
+
+    def type
+      @name_part.get_type.to_s
+    end
+
+    def type=(input_type)
+      @name_part.type = ( input_type.is_a? Gedcomx.java_uri_class ) ? input_type : Gedcomx.new_uri(input_type)
+    end
+
+    def value
+      @name_part.get_value
+    end
+
+    def value=(input_value)
+      @name_part.value = input_value
+    end
+
+    def to_java
+      @name_part
+    end
+  end
+end

data/lib/gedcomx/person.rb

@@ -1,9 +1,34 @@
 module Gedcomx
-
   class Person
 
-    def initialize(input)
-      @person = input
+    attr_reader :names, :fields, :facts, :identifiers, :gender
+
+    def self.java_class
+      Java::OrgGedcomxConclusion::Person
+    end
+
+    def self.create(attributes = {})
+      new_person = self.new
+      new_person.principal = attributes[:principal] if attributes[:principal]
+      new_person.relative_id = attributes[:relative_id] if attributes[:relative_id]
+      attributes[:fields].each { |field| new_person.add_field(field) } if attributes[:fields].is_a? Array
+      attributes[:facts].each { |fact| new_person.add_fact(fact) } if attributes[:facts].is_a? Array
+      attributes[:names].each { |name| new_person.add_name(name) } if attributes[:names].is_a? Array
+      attributes[:identifiers].each { |id| new_person.add_identifier(id) } if attributes[:identifiers].is_a? Array
+      new_person
+    end
+
+    def initialize(input = nil)
+      @person = input || self.class.java_class.new
+      @gender = Gedcomx::Gender.new(@person.get_gender) if @person.get_gender
+      @identifiers = []
+      @identifiers = @person.identifiers.map { |identifier| Gedcomx::Identifier.new(identifier) } if @person.identifiers
+      @names = []
+      @names = @person.names.map { |name| Gedcomx::Name.new(name) } if @person.names
+      @facts = []
+      @facts = @person.facts.map { |fact| Gedcomx::Fact.new(fact) } if @person.facts
+      @fields = []
+      @fields = @person.fields.map { |field| Gedcomx::Field.new(field) } if @person.fields
     end
 
     def male?
@@ -16,24 +41,198 @@ module Gedcomx
       gender == TYPES[:female]
     end
 
-    def gender
-      return TYPES[:male] if self.male?
-      TYPES[:female] if self.female?
+    def gender_type
+      return TYPES[:male] if male?
+      TYPES[:female] if female?
+    end
+
+    def set_gender(gender)
+      return false unless gender.is_a? Gedcomx::Gender
+      @person.gender = gender.to_java
+      @gender = gender
+    end
+
+    def set_gender_male
+      set_gender(Gedcomx::Gender.create_male)
+    end
+
+    def set_gender_female
+      set_gender(Gedcomx::Gender.create_female)
     end
 
     # Returns a list of name hashes
-    def names
+    def names_hash
       names_list = []
       @person.names.each do |name_obj|
         name_obj.name_forms.each do |name_form_obj|
           name_hash = {}
           name_hash[:full] = name_form_obj.get_full_text
-          name_hash[:first] = name_form_obj.parts.find{|part| part.get_type.to_s == TYPES[:given] }.andand.get_value
-          name_hash[:last] = name_form_obj.parts.find{|part| part.get_type.to_s == TYPES[:surname] }.andand.get_value
+          first_name = name_form_obj.parts.find{|part| part.get_type.to_s == TYPES[:given] }
+          unless first_name.nil?
+            name_hash[:first] = first_name.get_value
+          end
+          last_name = name_form_obj.parts.find{|part| part.get_type.to_s == TYPES[:surname] }
+          unless last_name.nil?
+            name_hash[:last] = last_name.get_value
+          end
           names_list << name_hash
         end
       end
       names_list
     end
+
+    def add_fact(fact)
+      return false unless fact.is_a? Gedcomx::Fact
+      @person.add_fact(fact.to_java)
+      @facts << fact
+    end
+
+    def add_field(field)
+      return false unless field.is_a? Gedcomx::Field
+      @person.add_field(field.to_java)
+      @fields << field
+    end
+
+    def add_identifier(identifier)
+      return false unless identifier.is_a? Gedcomx::Identifier
+      @person.add_identifier identifier.to_java
+      @identifiers << identifier
+    end
+
+    def add_name(name)
+      return false unless name.is_a? Gedcomx::Name
+      @person.add_name name.to_java
+      @names << name
+    end
+
+    def add_birthday(info = {})
+      birth_date = Gedcomx::Date.create_simple(info)
+      birth_fact = Gedcomx::Fact.create(date: birth_date, type: Gedcomx::TYPES[:birth])
+      add_fact(birth_fact)
+    end
+
+    def principal?
+      @person.get_principal
+    end
+
+    def principal=(input_boolean)
+      return false unless input_boolean.is_a? Boolean
+      @person.principal = input_boolean
+    end
+
+    def event_date
+      primary_fact = self.primary_fact
+      unless primary_fact.nil?
+        primary_date = primary_fact.get_date
+        return get_date(primary_date) unless primary_date.nil?
+      end
+    end
+
+    def birth_date
+      birthday_obj = Gedcomx.get_first_fact(@person, :birth)
+      unless birthday_obj.nil?
+        birth_date_obj = birthday_obj.get_date
+        get_date(birth_date_obj)
+      end
+    end
+
+    def first_value(type)
+      field = Gedcomx.get_first_field(@person, type)
+      unless field.nil?
+        interpreted = Gedcomx.interpreted_value(field)
+        return interpreted.get_text unless interpreted.nil?
+        return nil
+      end
+      fact = Gedcomx.get_first_fact(@person, type)
+      unless fact.nil?
+        fact.get_value
+      end
+    end
+
+    def location
+      primary_fact = @person.facts.find{|fact| fact.get_primary }
+
+      location = primary_fact.get_place
+      location_params = {}
+      location_params[:name] = location.get_original
+
+      # Fill in the location level definitions
+      location_levels = {}
+      location_fields = @person.fields.select{|field| field.get_type.to_s.include? 'EVENT_PLACE_LEVEL_' }
+      location_fields.each do |field|
+        value = field.get_values[0].get_text
+        level = /EVENT_PLACE_LEVEL_\d/.match(field.get_type.to_s)[0]
+        location_levels[level] = value
+      end
+
+      # Match the location name to the appropriate level
+      location.get_fields.each do |field|
+        value = Gedcomx.interpreted_value(field)
+
+        # Store the level if it is valid
+        level = location_levels[value.label_id]
+        next if level.nil?
+        mapped_value = Gedcomx.location_mapping(level)
+        next if mapped_value.nil?
+        location_params[mapped_value] = value.get_text
+      end
+
+      location_params
+    end
+
+    def relative_id
+      @person.get_id
+    end
+
+    def relative_id=(id_string)
+      return false unless id_string.is_a? String
+      @person.id = id_string
+    end
+
+    def to_java
+      @person
+    end
+
+    # Generates accessor methods for each of the types
+    TYPES.keys.each do |type|
+      define_method type do
+        first_value(type)
+      end
+    end
+
+    def gender
+      @gender
+    end
+
+    protected
+
+    def method_missing(something)
+      @person.send(something)
+    end
+
+    def primary_fact
+      @person.facts.find{|fact| fact.get_primary }
+    end
+
+    def get_date(date_obj)
+      date_hash = {}
+      year_field = Gedcomx.interpreted_value( Gedcomx.get_first_field(date_obj, :year) )
+      unless year_field.nil?
+        year = year_field.get_text.to_i
+        date_hash[:year] = year
+      end
+      month_field = Gedcomx.interpreted_value( Gedcomx.get_first_field(date_obj, :month) )
+      unless month_field.nil?
+        month = month_field.get_text
+        month = MONTH_MAP[month.downcase.to_sym] unless month.nil?
+        date_hash[:month] = month
+      end
+      day_field = Gedcomx.interpreted_value( Gedcomx.get_first_field(date_obj, :day) )
+      unless day_field.nil?
+        day = day_field.get_text
+        date_hash[:day] = day
+      end
+      date_hash
+    end
   end
 end