xml_active 0.0.2 → 0.0.3

data/README.rdoc

@@ -84,7 +84,7 @@ XML Active relies on the XML documents created by ActiveRecord in that it utilis
 
 === Database Schema
 
-XML Active will detect the primary key of the tables in your schema even if is a name other than @id@.  It will use the primary key to match records for update or deletion or creation when they don't exist.  Given this it's very important that the tables that you wish to synchronise have a primary key with auto increment.  The good news is by default Rails will create a primary key field called @id@ that is auto-increment.  At this time XML Active doesn't support compound primary keys.
+XML Active will detect the primary key of the tables in your schema even if is a name other than <b>id</b>.  It will use the primary key to match records for update or deletion or creation when they don't exist.  Given this it's very important that the tables that you wish to synchronise have a primary key with auto increment.  The good news is by default Rails will create a primary key field called <b>id</b> that is auto-increment.  At this time XML Active doesn't support compound primary keys.
 
 === The Model
 
@@ -110,7 +110,7 @@ At this stage XML Active has been tested with a limited number of associations.
 
 == Examples
 
-Now to the meaty part, the examples.  XML Active currenly uses "Nokogiri":http://nokogiri.org/ to do its XML parsing so you can provide either a @Nokogiri::XML::Element@ or raw XML.
+Now to the meaty part, the examples.  XML Active currenly uses "Nokogiri"(http://nokogiri.org/) to do its XML parsing so you can provide either a <b>Nokogiri::XML::Element</b> or raw XML.
 
 === New Functions
 
@@ -154,11 +154,57 @@ Following is an example:
 
 You can combine any of the options (:create, :update or :destroy) and XML Active will only perform the actions provided in the options.  However if you use the :sync option then all other options are ignored.  Following are the current options:
 
-* @:update@ records in the database that match those in the provided XML document based on classes in the model, associations and the primary key.
+* <b>:update</b> records in the database that match those in the provided XML document based on classes in the model, associations and the primary key.
 
-* @:create@ records in the database that exist in the provided XML document but not in the database. Matching is based on classes in the model, associations and the primary key.
+* <b>:create</b> records in the database that exist in the provided XML document but not in the database. Matching is based on classes in the model, associations and the primary key.
 
-* @:destroy@ records in the database that don't exist in the provided XML document. Matching is based on classes in the model, associations and the primary key.  This respects validation by using the ActiveRecord destroy rather than delete.
+* <b>:destroy</b> records in the database that don't exist in the provided XML document. Matching is based on classes in the model, associations and the primary key.  This respects validation by using the ActiveRecord destroy rather than delete.
 
-* @:sync@ is really the combination of :create, :update and :destroy. Using this option will cause XML Active to ignore :create, :update and :destroy options and will proceed to make your database records match those in the XML document.
+* <b>:sync</b> is really the combination of :create, :update and :destroy. Using this option will cause XML Active to ignore :create, :update and :destroy options and will proceed to make your database records match those in the XML document.
 
+=== One to One Associations
+XML Active supports has_one association with all options and following arr the behaviours of XML Active with each option:
+
+<b>:update</b>
+
+* <i>Record exists in XML but not in DB</i>: No Action
+* <i>Record exists in DB but not in XML</i>: No Action
+* <i>Record exists in XML and in DB</i>: DB record is updated if identifying features (eg id) match
+
+<b>:create</b>
+
+* <i>Record exists in XML but not in DB</i>: A new record in the DB is created
+* <i>Record exists in DB but not in XML</i>: No Action
+* <i>Record exists in XML and in DB</i>: No Action
+
+<b>:destroy</b>
+
+* <i>Record exists in XML but not in DB</i>: No Action
+* <i>Record exists in DB but not in XML</i>: The DB Record is Destroyed
+* <i>Record exists in XML and in DB</i>: DB record is destroyed if identifying features (eg id) don't match
+
+<b>:sync</b>
+
+* <i>Record exists in XML but not in DB</i>: A new record in the DB is created
+* <i>Record exists in DB but not in XML</i>: The DB Record is Destroyed
+* <i>Record exists in XML and in DB</i>: DB record is replaced if identifying features (eg id) don't match but if they do then the DB record is updated
+
+=== Versions
+
+* 0.0.2 First Release
+* 0.0.3 Addition of support for One to One associations and various bug fixes
+
+=== Future Features
+
+* <b>Dry Run</b> allow xml_active to do a dry run and report potentail changes rather than making them
+* <b>Events</b> Event hooks in key locations
+* <b>Selective Upates</b> Specify a set of active record objects to effect and leave all the rest alone
+* <b>Many to Many</b> Tested support for has_and_belongs_to_many
+* <b>Polymorphic Associations</b> Tested support for these associations
+
+=== Testing
+In order to perform testing I created an application specifically for the task.  The resulting application is stored on GitHub: https://github.com/michael-harrison/xml_active_bubble
+
+At this stage xml_active has been tested with Rails 3.0.7, 3.1.0 and 3.2.2
+
+This testing will be incorporated in the primary repo in the next major release

data/lib/xml_active.rb

@@ -23,21 +23,36 @@ module XmlActive
       end
 
       records = []
-      if self.xml_node_matches_many_of_class(current_node)
+      if self.name.pluralize.underscore.eql? current_node.name.underscore
         ids = []
-        if (self.xml_node_is_association(current_node))
+
+        if current_node.attributes['type'].try(:value) == "array"
           current_node.element_children.each do |node|
             record = self.one_from_xml(node, options)
-            ids[ids.length] = record[primary_key.to_sym]
-            records[records.length] = record
+            if record
+              ids[ids.length] = record[primary_key.to_sym]
+              records[records.length] = record
+            end
           end
         else
-          records[records.length] = self.one_from_xml(current_node)
+          records[records.length] = self.one_from_xml current_node
         end
 
-        if ids.length > 0 and (options.include?(:destroy) or options.include?(:sync))
-          self.destroy_all [self.primary_key.to_s + " not in (?)", ids.collect]
+
+        if options.include?(:sync)
+          if ids.length > 0
+            self.destroy_all [self.primary_key.to_s + " not in (?)", ids.collect]
+          end
+        elsif options.include?(:destroy)
+          if ids.length > 0
+            self.destroy_all [self.primary_key.to_s + " not in (?)", ids.collect]
+          else
+            self.destroy_all
+          end
         end
+
+      elsif self.name.underscore.equ current_node.name.underscore
+        raise "The supplied XML (#{current_node.name}) is a single instance of '#{self.name}'. Please use one_from_xml"
       else
         raise "The supplied XML (#{current_node.name}) cannot be mapped to this class (#{self.name})"
       end
@@ -46,60 +61,150 @@ module XmlActive
     end
 
     def one_from_xml(xml, options = [])
-      if xml.is_a?(String)
-        doc = Nokogiri::XML(xml)
+      if xml.is_a? String
+        doc = Nokogiri::XML xml
         current_node = doc.children.first
       else
         current_node = xml
       end
 
-      if self.xml_node_matches_single_class(current_node)
+      if xml_node_matches_class(current_node)
+        # Load or create a new record
         pk_value = 0
-        pk_node = current_node.xpath(self.primary_key.to_s)
+        pk_node = current_node.xpath self.primary_key.to_s
         if pk_node
           begin
-            ar = find(pk_node.text)
+            ar = find pk_node.text
             pk_value = pk_node.text
           rescue
             # No record exists, create a new one
-            ar = self.new
+            if options.include?(:sync) or options.include?(:create)
+              ar = self.new
+            else
+              # must have only have :destroy and/or :update so exit
+              return nil
+            end
           end
         else
           # No primary key value, must be a new record
-          ar = self.new
+          if options.include?(:sync) or options.include?(:create)
+            ar = self.new
+          else
+            # must have only have :destroy and/or :update so exit
+            return nil
+          end
         end
 
-        if (ar.new_record? and options.include?(:update) and not options.include?(:sync))
-          return(nil)
-        end
+        # Check through associations and apply sync appropriately
+        self.reflect_on_all_associations.each do |association|
+          if ActiveRecord::Reflection::AssociationReflection.method_defined? :foreign_key
+            # Support for Rails 3.1 and later
+            foreign_key = association.foreign_key
+          elsif ActiveRecord::Reflection::AssociationReflection.method_defined? :primary_key_name
+            # Support for Rails earlier than 3.1
+            foreign_key = association.primary_key_name
+          else
+            raise "Unsupported version of ActiveRecord. Unable to identify the foreign key."
+          end
+          case
+            when association.macro == :has_many, association.macro == :has_and_belongs_to_many
+              # Check to see if xml contains elements for the association
+              if pk_value == 0
+                containers = current_node.xpath("//#{self.name.underscore}[#{self.primary_key}=#{pk_node.text}]/#{association.name}")
+              else
+                containers = current_node.xpath("//#{self.name.underscore}[#{self.primary_key}=#{pk_value}]/#{association.name}")
+              end
+              if containers.count > 0
+                container = containers[0]
+                klass = association.klass
+                child_ids = []
+                container.element_children.each do |single_obj|
+                  # TODO: Allow for child node that doesn't have a primary key value
+                  child_ids[child_ids.length] = single_obj.xpath(self.primary_key.to_s).text
+                  new_record = klass.one_from_xml(single_obj, options)
+                  if (new_record != nil)
+                    ar.__send__(container.name.underscore.to_sym) << new_record
+                  end
+                end
 
-        current_node.element_children.each do |node|
-          sym = node.name.underscore.to_sym
-          if self.xml_node_is_association(node)
-            # Association
-            association = self.reflect_on_association(sym)
-            if (association)
-              # association exists, lets process it
+                if pk_value != 0
+                  if options.include?(:sync)
+                    if child_ids.length > 0
+                      klass.destroy_all [klass.primary_key.to_s + " not in (?) and #{foreign_key} = ?", child_ids.collect, pk_value]
+                    end
+                  elsif options.include?(:destroy)
+                    if child_ids.length > 0
+                      klass.destroy_all [klass.primary_key.to_s + " not in (?) and #{foreign_key} = ?", child_ids.collect, pk_value]
+                    else
+                      klass.destroy_all
+                    end
+                  end
+                end
+              end
+
+            when association.macro == :has_one
+              single_objects = current_node.xpath("//#{self.name.underscore}[#{self.primary_key}=#{pk_value}]/#{association.name}")
               klass = association.klass
-              child_ids = []
-              node.element_children.each do |single_obj|
-                child_ids[child_ids.length] = single_obj.xpath(self.primary_key.to_s).text
-                new_record = klass.one_from_xml(single_obj, options)
-                if (new_record != nil)
-                  ar.__send__(sym) << new_record
+              record = klass.where(foreign_key => pk_value).all
+              if single_objects.count == 1
+                # Check to see if the already record exists
+                if record.count == 1
+                  db_pk_value = record[0][klass.primary_key]
+                  xml_pk_value = Integer(single_objects[0].element_children.xpath("//#{self.name.underscore}/#{klass.primary_key}").text)
+
+                  if db_pk_value != xml_pk_value
+                    # Different record in xml
+                    if options.include?(:sync) or options.include?(:destroy)
+                      # Delete the one in the database
+                      klass.destroy(record[0][klass.primary_key])
+                    end
+                  end
+                elsif record.count > 1
+                  raise "Too many records for one to one association in the database. Found #{record.count} records of '#{association.name}' for association with '#{self.name}'"
+                end
+
+                if options.include?(:create) or options.include?(:update) or options.include?(:sync)
+                  new_record = klass.one_from_xml(single_objects[0], options)
+                  if new_record != nil
+                    new_record[foreign_key.to_sym] = ar[self.primary_key]
+                    new_record.save!
+                  end
+                end
+              elsif single_objects.count > 1
+                # There are more than one associations
+                raise "Too many records for one to one association in the provided XML. Found #{single_objects.count} records of '#{association.name}' for association with '#{self.name}'"
+              else
+                # There are no records in the XML
+                if record.count > 0 and options.include?(:sync) or options.include?(:destroy)
+                  # Found some in the database: destroy then
+                  klass.destroy_all("#{foreign_key} = #{pk_value}")
                 end
               end
-              if (pk_value != 0 and child_ids.length > 0 and (options.include?(:destroy) or options.include?(:sync)))
-                klass.destroy_all [klass.primary_key.to_s + " not in (?) and #{association.primary_key_name} = ?", child_ids.collect, pk_value]
+
+            when association.macro == :belongs_to
+
+            else
+              raise "unsupported association #{association.macro} for #{association.name  } on #{self.name}"
+          end
+        end
+
+        if options.include? :update or options.include? :sync or options.include? :create
+          # Process the attributes
+          current_node.element_children.each do |node|
+            node_name = node.name.underscore.to_sym
+            association = self.reflect_on_association node_name
+
+            if association.nil?
+              if node.attributes['nil'].try(:value)
+                ar[node_name] = nil
+              else
+                ar[node_name] = node.text
               end
             end
-          else
-            # Attribute
-            ar[sym] = node.text
           end
         end
 
-        if options.include?(:sync)
+        if options.include? :sync
           # Doing complete synchronisation with XML
           ar.save
         elsif options.include?(:create) and ar.new_record?
@@ -114,20 +219,11 @@ module XmlActive
       end
     end
 
-    def xml_node_matches_single_class(xml_node)
-      self.name.downcase.eql?(xml_node.name.downcase)
-    end
-
-    def xml_node_matches_many_of_class(xml_node)
-      self.name.pluralize.downcase.eql?(xml_node.name.downcase)
-    end
-
-    def xml_node_is_association(xml_node)
-      attr = xml_node.attributes["type"]
-      if (attr)
-        attr.value == "array"
+    def xml_node_matches_class(xml_node)
+      if xml_node.attributes['type'].blank?
+        xml_node.name.underscore == self.name.underscore
       else
-        false
+        xml_node.attributes['type'].value.underscore == self.name.underscore
       end
     end
   end
@@ -135,4 +231,4 @@ end
 
 class ActiveRecord::Base
   include XmlActive
-end
+end

data/lib/xml_active/version.rb

@@ -1,3 +1,3 @@
 module XmlActive
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -1,61 +1,46 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: xml_active
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 2
-  version: 0.0.2
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Michael Harrison
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-09-26 00:00:00 +10:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: nokogiri
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70136090689960 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70136090689960
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70136090688920 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-description: XML Active is an extension of ActiveRecord that provides features to synchronise an ActiveRecord Model with a supplied XML document
-email: 
+  prerelease: false
+  version_requirements: *70136090688920
+description: XML Active is an extension of ActiveRecord that provides features to
+  synchronise an ActiveRecord Model with a supplied XML document
+email:
 - michael@focalpause.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - README.rdoc
@@ -63,39 +48,28 @@ files:
 - lib/xml_active.rb
 - lib/xml_active/version.rb
 - xml_active.gemspec
-has_rdoc: true
 homepage: https://github.com/michael-harrison/xml_active
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: xml_active
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: xml_active 0.0.2
+summary: xml_active 0.0.3
 test_files: []
-