nominet-epp 0.0.8 → 0.0.10

data/History.md

@@ -1,3 +1,15 @@
+
+0.0.10 / 2011-05-04 
+===================
+
+  * Fix syntax error in helpers.rb
+
+0.0.9 / 2011-05-04 
+==================
+
+  * Correct implementation of Update Operation for domain, account and contact to send
+    the correct sequence of XML elements
+
 0.0.8 / 2011-05-03
 ==================
 

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.10

data/lib/nominet-epp/helpers.rb

@@ -34,14 +34,14 @@ module NominetEPP
       when Hash
         host << XML::Node.new('hostName', nameserver[:name], ns)
         if nameserver[:v4]
-          n = XML::Node.new('hostAddr', nameserver[:v4], ns)
-          n['ip'] = 'v4'
-          host << n
+          host << XML::Node.new('hostAddr', nameserver[:v4], ns).tap do |n|
+            n['ip'] = 'v4'
+          end
         end
         if nameserver[:v6]
-          n = XML::Node.new('hostAddr', nameserver[:v6], ns)
-          n['ip'] = 'v6'
-          host << n
+          host << XML::Node.new('hostAddr', nameserver[:v6], ns).tap do |n|
+            n['ip'] = 'v6'
+          end
         end
       end
 
@@ -54,28 +54,130 @@ module NominetEPP
     # @param [XML::Node] node XML Node to add the attributes to
     # @param [XML::Namespace] ns XML Namespace to create the elements under
     def account_fields_xml(fields, node, ns)
-      fields.each do |k,v|
+      [:trad_name, :type, :co_no, :opt_out, :addr, :contacts].each do |k|
+        next if fields[k].nil?
         case k
         when :contacts
-          v.each do |c|
-            node << (c_node = XML::Node.new('contact', nil, ns))
-            c_node['order'] = c.delete(:order)
-            c_node['type'] = 'admin'
-
-            c_node << contact(c.delete(:action) || 'create') do |cn, cns|
-              c.each do |l,w|
-                cn << XML::Node.new(l, w, cns)
-              end
-            end
+          account_contacts_to_xml(fields[k], ns) do |n|
+            node << n
           end
         when :addr  # Limitation, can only handle one addr at a time
-          node << (a_node = XML::Node.new('addr', nil, ns))
-          a_node['type'] = 'admin'
-          v.each do |l,w|
-            a_node << XML::Node.new(l, w, ns)
-          end
+          node << addr_to_xml(fields[k], ns)
         else
-          node << XML::Node.new(k.to_s.gsub('_', '-'), v, ns)
+          node << generic_field_to_xml(k, fields[k], ns) unless fields[k] == ''
+        end
+      end
+    end
+
+    # Creates an XML node with the dashed form of the +name+.
+    #
+    # @param [String] name Element name, underscores will be converted to hyphens
+    # @param [String] value Element value
+    # @param [XML::Namespace] ns XML Namespace to create the element under
+    # @return [XML::Node]
+    def generic_field_to_xml(name, value, ns)
+      XML::Node.new(name.to_s.gsub('_', '-'), value, ns)
+    end
+
+    # Massage the contacts to ensure they have an :order parameter
+    #
+    # @param [Array<Hash>] contacts Array of contact attributes
+    # @return [Array<Hash>] Fixed array of contact attributes
+    def fixup_account_contacts(contacts)
+      if contacts.all? { |c| c.has_key? :order }
+        return contacts.sort { |a,b| a[:order].to_i <=> b[:order].to_i }
+      elsif contacts.any? { |c| c.has_key? :order }
+        unordered = contacts.map {|c| c if c[:order].nil? }.compact
+        ordered = Array.new
+        contacts.each do |c|
+          next if c[:order].nil?
+          ordered[c[:order].to_i - 1] = c
+        end
+
+        contacts = ordered.map do |i|
+          unless i.nil? then i
+          else unordered.shift
+          end
+        end + unordered
+      end
+
+      contacts.each_with_index { |c,i| c[:order] = (i+1).to_s }
+    end
+
+    # Creates and array of XML::Node objects for each contact passed.
+    #
+    # @param [Array] contacts Array of contacts
+    # @param [XML::Namespace] ns XML Namespace to create the elements under
+    # @yield [node]
+    # @yieldparam [XML::Node] node XML contact element
+    # @return [Array] array of XML contact nodes
+    def account_contacts_to_xml(contacts, ns)
+      raise ArgumentError, "contacts must be an Array" unless contacts.is_a?(Array)
+      raise ArgumentError, "ns must be an xml namespace" unless ns.is_a?(XML::Namespace)
+
+      contacts = fixup_account_contacts(contacts)
+
+      contacts[0,3].map do |contact|
+        account_contact_to_xml(contact, ns).tap do |n|
+          yield n if block_given?
+        end
+      end
+    end
+
+    # Creates an XML contact element
+    #
+    # @param [Hash] contact Contact attributes
+    # @param [XML::Namespace] ns XML Namespace to create the elements under
+    # @return [XML::Node] XML contact element
+    def account_contact_to_xml(contact, ns)
+      raise ArgumentError, "contact must be a hash" unless contact.is_a?(Hash)
+      raise ArgumentError, "ns must be an xml namespace" unless ns.is_a?(XML::Namespace)
+
+      XML::Node.new('contact', nil, ns).tap do |node|
+        node['order'] = contact.delete(:order).to_s if contact.has_key?(:order)
+        node['type'] = 'admin'
+
+        node << contact_to_xml(contact)
+      end
+    end
+
+    # Creates an XML +contact:create+ or +contact:update+ element.
+    #
+    # The choice to create a +create+ or +update+ element is determined by the presence of
+    # a +:roid+ key in the list of attributes.
+    #
+    # @param [Hash] contact Contact attributes
+    # @return [XML::Node] XML contact:+action+ element with the attributes
+    def contact_to_xml(contact)
+      keys = [:roid, :name, :phone, :mobile, :email]
+      raise ArgumentError, "contact must be a hash" unless contact.is_a?(Hash)
+      raise ArgumentError, "Contact allowed keys are #{keys.join(', ')}" unless (contact.keys - keys).empty?
+      raise ArgumentError, "Contact requires name and email keys" unless contact.has_key?(:name) && contact.has_key?(:email)
+
+      action = contact[:roid].nil? || contact[:roid] == '' ? 'create' : 'update'
+      contact(action) do |node, ns|
+        keys.each do |key|
+          next if contact[key].nil? || contact[key] == ''
+          node << XML::Node.new(key, contact[key], ns)
+        end
+      end
+    end
+
+    # Creates an XML addr element
+    #
+    # @param [Hash] addr Address attributes
+    # @param [XML::Namespace] ns XML Namespace to create the elements in
+    # @return [XML::Node] XML addr element
+    def addr_to_xml(addr, ns)
+      keys = [:street, :locality, :city, :county, :postcode, :country]
+      raise ArgumentError, "addr must be a hash" unless addr.is_a?(Hash)
+      raise ArgumentError, "ns must be an xml namespace" unless ns.is_a?(XML::Namespace)
+      raise ArgumentError, "Address allowed keys are #{keys.join(', ')}" unless (addr.keys - keys).empty?
+
+      XML::Node.new('addr', nil, ns).tap do |a|
+        keys.each do |key|
+          next if addr[key].nil? || addr[key] == ''
+          a << XML::Node.new(key, addr[key], ns)
         end
       end
     end

data/lib/nominet-epp/operations/create.rb

@@ -90,62 +90,13 @@ module NominetEPP
           elsif acct.kind_of?(Hash)
             account('create') do |node, ns|
               node << XML::Node.new('name', acct[:name], ns)
-              node << XML::Node.new('trad-name', acct[:trad_name], ns) unless acct[:trad_name].nil? || acct[:trad_name] == ''
-              node << XML::Node.new('type', acct[:type], ns)
-              node << XML::Node.new('co-no', acct[:co_no], ns) unless acct[:co_no].nil? || acct[:co_no] == ''
-              node << XML::Node.new('opt-out', acct[:opt_out], ns)
-
-              node << create_account_address(acct[:addr], ns) unless acct[:addr].nil?
-
-              acct[:contacts][0,3].each_with_index do |cont, i|
-                c = XML::Node.new('contact', nil, ns)
-                c['order'] = (i + 1).to_s # Enforce order 1-3
-                node << (c << create_account_contact(cont))
-              end
+              account_fields_xml(acct, node, ns)
             end
           else
             raise ArgumentError, "acct must be String or Hash"
           end
         end
 
-        # Create account contact payload
-        #
-        # @param [Hash] cont Contact fields
-        # @raise [ArgumentError] invalid contact fields
-        # @raise [ArgumentError] name or email key is missing
-        # @return [XML::Node]
-        def create_account_contact(cont)
-          raise ArgumentError, "cont must be a hash" unless cont.is_a?(Hash)
-          raise ArgumentError, "Contact allowed keys are name, email, phone and mobile" unless (cont.keys - [:name, :email, :phone, :mobile]).empty?
-          raise ArgumentError, "Contact requires name and email keys" unless cont.has_key?(:name) && cont.has_key?(:email)
-
-          contact('create') do |node, ns|
-            [:name, :phone, :mobile, :email].each do |key|
-              next if cont[key].nil? || cont[key] == ''
-              node << XML::Node.new(key, cont[key], ns)
-            end
-          end
-        end
-
-        # Create contact address
-        #
-        # @param [Hash] addr Address fields
-        # @param [XML::Namespace] ns XML Namespace
-        # @raise [ArgumentError] invalid keys in addr
-        # @return [XML::Node]
-        def create_account_address(addr, ns)
-          raise ArgumentError, "addr must be a hash" unless addr.is_a?(Hash)
-          raise ArgumentError, "ns must be an xml namespace" unless ns.is_a?(XML::Namespace)
-          raise ArgumentError, "Address allowed keys are street, locality, city, county, postcode, country" unless (addr.keys - [:street, :locality, :city, :county, :postcode, :country]).empty?
-
-          XML::Node.new('addr', nil, ns).tap do |a|
-            [:street, :locality, :city, :county, :postcode, :country].each do |key|
-              next if addr[key].nil? || addr[key] == ''
-              a << XML::Node.new(key, addr[key], ns)
-            end
-          end
-        end
-
         # Collects created account information
         #
         # @param [XML::Node] creData XML

data/lib/nominet-epp/operations/update.rb

@@ -74,19 +74,23 @@ module NominetEPP
         # @param [Hash] fields Fields to update on the domain
         # @return [XML::Node] +domain:update+ payload
         def update_domain(name, fields)
+          keys = [:auto_period, :account, :ns, :first_bill, :recur_bill,
+            :auto_bill, :next_bill, :renew_not_required, :notes, :reseller]
+
           domain('update') do |node, ns|
             node << XML::Node.new('name', name, ns)
-            fields.each do |k,v|
+            keys.each do |k|
+              next if fields[k].nil?
               case k
               when :account
                 node << (d_acct = XML::Node.new('account', nil, ns))
                 d_acct << account('update') do |acct, a_ns|
-                  account_update_xml(v, acct, a_ns)
+                  account_update_xml(fields[k], acct, a_ns)
                 end
               when :ns
-                node << domain_ns_xml(v, ns)
+                node << domain_ns_xml(fields[k], ns)
               else
-                node << XML::Node.new(k.gsub('_', '-'), v, ns)
+                node << generic_field_to_xml(k, fields[k], ns) unless fields[k] == ''
               end
             end
           end
@@ -107,16 +111,9 @@ module NominetEPP
         # @param [String] roid Contact ID
         # @param [Hash] fields Fields to update on the contact
         # @raise [ArgumentError] invalid keys
-        # @return [XML::Node] +contact:update+ payload
+        # @return [XML::Node] XML +contact:update+ element
         def update_contact(roid, fields = {})
-          raise ArgumentError, "fields allowed keys name, email, phone, mobile" unless (fields.keys - [:name, :email, :phone, :mobile]).empty?
-
-          contact('update') do |node, ns|
-            node << XML::Node.new('roid', roid, ns)
-            fields.each do |k,v|
-              node << XML::Node.new(k, v, ns)
-            end
-          end
+          contact_to_xml(fields.merge(:roid => roid))
         end
 
         # Generate +host:update+ payload to modify a nameserver entry

data/nominet-epp.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{nominet-epp}
-  s.version = "0.0.8"
+  s.version = "0.0.10"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Geoff Garside"]
-  s.date = %q{2011-05-03}
+  s.date = %q{2011-05-04}
   s.description = %q{Client for communicating with the Nominet EPP}
   s.email = %q{geoff@geoffgarside.co.uk}
   s.extra_rdoc_files = [

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: nominet-epp
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  - 10
+  version: 0.0.10
 platform: ruby
 authors: 
 - Geoff Garside
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-03 00:00:00 Z
+date: 2011-05-04 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: shoulda