adaptation 0.1.10 → 1.0.1

data/CHANGELOG

@@ -65,3 +65,10 @@
     - bug: test environment not set properly since 0.1.7
 * 0.1.10
     - generated mock publish.rb bug corrected
+-------------------
+* 1.0.0
+    - Migrated from ROXML to XmlSimple. Messages don't need to be defined any more, so
+      has_many, has_one... and partials are deprecated.
+* 1.0.1
+    - Fixed problems with activerecord > 2.2.2
+    - Requires activerecord >= 2.3.3

data/README

@@ -40,8 +40,7 @@ Adaptation is available as a ruby gem, so the easiest way should be:
    
    This will generate a an adaptor file tree under folder _myadaptor_.
 
-2. If no message oriented middleware has been already set, change directory into _myadaptor_ 
-   and start the <b>mom</b>:
+2. If no message oriented middleware (mom) has been already set, you can start one typing:
 
      > mom
 
@@ -50,14 +49,14 @@ Adaptation is available as a ruby gem, so the easiest way should be:
 3. Subscribe your adaptor to the <b>mom</b>, so it will be executed when a message is received on
    a topic your adaptor is interested in:
 
-     > script/subscribe
+     > ruby script/subscribe
 
    By default this will try to subscribe to a *mom* listening on <em>localhost:8080</em>, using port
    <em>8081</em> to subscribe (subscribing means starting a new server that listens for 
    message publication notifications). These values can be changed editing <em>config/mom.yml</em>. In <em>mom.yml</em> 
    you can also specify wich topics your adaptor is interested in.
 
-4. Right now you should have a <b>mom</b>_ listening for messages on <em>localhost:8080</em>, and an _adaptor_
+4. Right now you should have a <b>mom</b> listening for messages on <em>localhost:8080</em>, and an _adaptor_
    subscribed to that *mom* and listening on <em>localhost:8081</em>, and interested in all topics available.
 
    This environment can be tested by executing the following from _myadaptor_ folder:
@@ -68,8 +67,8 @@ Adaptation is available as a ruby gem, so the easiest way should be:
    This message should be displayed in the subscriber terminal when delivered by the *mom*.
    Nothing would be executed, because a _Helloworld_ message[link:../rdoc/classes/Adaptation/Message.html] to 
    map this xml message and a _HelloworldAdaptor_[link:../rdoc/classes/Adaptation/Adaptor.html] to process it don't 
-   exist yet. Since these classes aren't implemented, Adaptation will pass the  message as a xml _String_ to the 
-   default _ApplicationAdaptor_ adaptor, but its _process_ method is  still empty, so nothing will happen. 
+   exist yet. Since these classes aren't implemented, Adaptation will pass the  message as an Adaptation::Message object 
+   to the default _ApplicationAdaptor_ adaptor, but its _process_ method is  still empty, so nothing will happen. 
 
    To see something happening the _process_ method in the default _ApplicationAdaptor_ could be implemented, 
    editing file <em>myadaptor/app/adaptors/application.rb</em>:
@@ -109,8 +108,7 @@ Adaptation is available as a ruby gem, so the easiest way should be:
          create  app/adaptors/helloworld_adaptor.rb
          create  test/functional/helloworld_adaptor_test.rb
 
-   and to edit <em>app/adaptors/helloworld_adaptor</em> to make something happen
-   when a message is received:
+   and to edit <em>app/adaptors/helloworld_adaptor</em> to make something happen when a message is received:
 
      class HelloworldAdaptor < ApplicationAdaptor
 
@@ -120,8 +118,8 @@ Adaptation is available as a ruby gem, so the easiest way should be:
 
      end
 
-   We can notice that _helloworld_ variable is not a _String_ now, because Adaptation
-   has been able to map it to a Adaptation::Message object, and that the _HelloworldAdaptor_
+   We can notice that _helloworld_ variable is an instance of _Helloworld_ class (because Adaptation
+   has been able to map it to a subclass of Adaptation::Message object), and that the _HelloworldAdaptor_
    inherits from _ApplicationAdaptor_, so functionality repeated in different _Adaptors_[link:../rdoc/classes/Adaptation/Adaptor.html]
    can be placed in _ApplicationAdaptor_.
    
@@ -186,7 +184,87 @@ test
 
 
 == Debugging 
-<em>TODO: ruby script/console + ruby-debug</em>
+
+Adaptation includes a console from wich we can access Adaptation::Message and ActiveRecord classes defined in
+the <em>adaptor</em> we are working on.
+
+To open the console type:
+
+     > ruby script/console [environment]
+
+From the command prompt that should appear, we can instantiate ActiveRecord objects defined in app/models and
+Adaptation::Message objects defined in app/messages.
+With the previous example, where an Adaptation::Message subclass called Helloworld was defined in app/messages,
+we could do:
+
+     > ruby script/console test
+     $ >> Loading test environment (Adaptation X.X.X)
+     $ hw = HelloWorld.new("<helloworld>hello</helloworld>")
+     $ hw.content
+     $ >> "hello"
+     $ hw.to_xml
+     $ >> "<helloworld>hello</helloworld>"
+
+We could edit app/messages/hellworld.rb to add a validation:
+     
+     class Helloworld < Adaptation::Message
+       validates_presence_of :atr
+     end
+
+and check if it works with the console:
+     
+     > ruby script/console
+     $ >> Loading test environment (Adaptation X.X.X)
+     $ hw = HelloWorld.new("<helloworld>hello</helloworld>")
+     $ hw.valid?
+     $ >> false 
+     $ hw = HelloWorld.new("<helloworld atr="something">hello</helloworld>")
+     $ hw.valid?
+     $ >> true
+
+If we define ActiveRecord::Base subclasses in app/models we can do the same mapping 
+database rows instead of xml messages, if config/database.yml is properly configured
+to access the database.
+If we had a <em>users</em> table in our database, we could generate a model to access
+it with ActiveRecord:
+
+     > ruby script/generate model user
+         exists  app/models/
+         exists  test/fixtures/
+         create  app/models/user.rb
+
+and use it from the console:
+  
+     > ruby script/console
+     $ >> Loading test environment (Adaptation X.X.X)
+     $ u = User.find(:first)
+
 
 == Testing 
-<em>TODO</em>
+
+As it can be seen when generating adaptors and messages, adaptation automatically generates empty functional 
+tests for adaptors and empty unit tests for messages.
+
+Tests can be run typing:
+
+     > ruby test.rb
+
+Tests can use fixtures stored in <em>test/fixtures</em> folder. There are two kind of fixtures:
+
+- <b>database fixtures</b>: the same database fixtures a {rails}[http://www.rubyonrails.org] application uses to fill its tables in tests. These fixtures are usually stored in <em>*.yml</em> files, and are used to reset database contents before each test, so it is important to configure the test database properly in config/database.yml. More about ActiveRecord fixtures {here}[http://api.rubyonrails.org/classes/Fixtures.html].
+ 
+- <b>xml fixtures</b>: these fixtures are plain xml strored in <em>*.xml</em>, and are used to build Adaptation::Message objects and probably process them with our adaptor in the tests. These fixtures can also be created dynamically with Erb templetes. This is an example of a xml fixture built with Erb:
+
+     <20_people>
+       <% 20.times do |c| %>
+         <person num="<%= c %>"/>
+       <% end %>
+     </20_people>
+ 
+For the _HellworldAdaptor_ in our example, we should find a functional test in <em>test/functional/helloworld_adaptor_test.rb</em>, and for the _Helloworld_ message a unit test in <em>test/unit/helloworld_test.rb</em>.
+
+Tests usually perfrom {assertions}[link:../rdoc/classes/ActiveSupport/TestCase.html]. There are a couple of methods that may be useful when testing _adaptors_, {*get_message_form_fixture*}[link:../rdoc/classes/ActiveSupport/TestCase.html#M000044] and {*message*}[link:../rdoc/classes/ActiveSupport/TestCase.html#M000043]:
+
+- *get_message_from_fixture*: Returns an Adaptation::Message object from a fixture, without processing it (or an instance of the corresponding subclass, if it's defined).
+
+- *message*: Builds a message from a xml fixture file and processes it the same way messages from the mom are processed by Adaptation, but using the test environment. Messages published with {publish}[link:../rdoc/classes/Adaptation/Adaptor.html#M000170] will be published to a mocked MOM (and can be checked with _assert_message_published_).

data/helpers/publish.rb

@@ -9,7 +9,7 @@ class Adaptation::Adaptor
       xml_message = options.first
       message_type = xml_message[1..(xml_message.index(/(>| )/) - 1)]
       message_class = Adaptation::Message.get_class_object(message_type.capitalize)
-      message_object = message_class.to_object(xml_message)
+      message_object = message_class.new(xml_message)
     end
 
     mom = File.new(ADAPTOR_ROOT + '/test/mocks/test/mom.txt', "a")

data/helpers/test_helper.rb

@@ -6,3 +6,7 @@ $:.unshift("#{ADAPTOR_ROOT}/app/adaptors")
 
 require 'rubygems'
 require "adaptation/test/test_help"
+
+class ActiveSupport::TestCase
+  fixtures :all
+end

data/lib/adaptation.rb

@@ -1,6 +1,7 @@
-require 'roxml'
+require 'xmlsimple'
 require 'yaml'
 require 'active_record'
+require 'active_record/base'
 require 'adaptation/validateable'
 require 'adaptation/message'
 require 'adaptation/adaptor'

data/lib/adaptation/adaptor.rb

@@ -10,22 +10,39 @@ module Adaptation
 # 
   class Adaptor
 
-    def process message
+    def process message #:nodoc:
     end
 
+    # Returns the logger to output results in the current environment log file.
+    # Example:
+    #   > logger.info "this is going to log/development.log"
     def logger
       Adaptation::Base.logger
     end
-    
-    def publish *options
-      message_object = nil
-      if options.first.is_a?(Message)
-        message_object = options.first
+
+    # Publishes a message to the MOM. The message can be an instance of Adaptation::Message or a String.
+    #
+    # When executed in test environment messages are not published to the MOM. They are written to a mocked MOM
+    # and their publication can be asserted in tests with assert_message_published[link:/classes/ActiveSupport/TestCase.html#M000038].
+    #
+    # By default it uses <b>script/publish</b> ito publish. This can be overwritten specifying the
+    # <b>oappublish</b> instruction in configuration file <b>config/settings.yml</b>.
+    #
+    # By default it publishes in topic <b>ADAPTATION</b>. This can be overwritten specifying the <b>application</b> setting
+    # in <b>config/settings.yml</b> file.
+    #
+    # Example settings file:
+    #    oappublish: /bin/echo
+    #    application: MY_TOPIC
+    def publish *options                                                                         
+      message_object = nil                                                                       
+      if options.first.is_a?(Message)                                                            
+        message_object = options.first                                                           
       elsif options.first.is_a?(String)
         xml_message = options.first
         message_type = xml_message[1..(xml_message.index(/(>| )/) - 1)]
         message_class = Adaptation::Message.get_class_object(message_type.capitalize)
-        message_object = message_class.to_object(xml_message)
+        message_object = message_class.new(xml_message)
       end
       
       xml = message_object.to_xml.to_s.gsub("'", "\"")
@@ -37,7 +54,7 @@ module Adaptation
 
     end
 
-    def self.get_class_object(adaptor_class) # nodoc
+    def self.get_class_object(adaptor_class) #:nodoc:
       Object.const_get(adaptor_class) rescue nil
     end
 

data/lib/adaptation/base.rb

@@ -61,19 +61,14 @@ module Adaptation
       adaptor = message = nil
  
       message_class = Adaptation::Message.get_class_object(message_type.capitalize)
-      message = message_class.nil? ? xml_message : message_class.to_object(xml_message)
-      # TODO: the xml is returned as a String if a class to map it is not found;
-      # in future versions Adaptation may build a valid Adaptation::Message even
-      # without implementation for this type of message
+      message = message_class.nil? ? Adaptation::Message.new(xml_message) : message_class.new(xml_message)
         
       adaptor_class = Adaptation::Adaptor.get_class_object("#{message_type.capitalize}Adaptor")    
       adaptor = adaptor_class.nil? ? ApplicationAdaptor.new : adaptor_class.new rescue Adaptation::Adaptor.new
 
-      unless message.is_a?(String) # TODO: remove when feature explained in line 67 implemented
-        unless message.valid?
-          @@logger.info "WARNING:Message doesn't validate!" 
-          return
-        end
+      unless message.valid?
+        @@logger.info "WARNING:Message doesn't validate!" 
+        return
       end
 
       adaptor.process message

data/lib/adaptation/message.rb

@@ -2,102 +2,44 @@ module Adaptation
 
 #= Adaptation::Message -- XML to classes mapping.
 #
-#Adaptation::Message connects ruby objects and xml data to create a model where 
-#logic and data are presented in one wrapping. It's is inspired on activerecord, and pretends
-#to solve xml data management problems in a similar way activerecord handles database data
-#management. 
+#Adaptation::Message maps xml data into a ruby object. It also provides validators
+#(inspired by ActiveRecord[http://api.rubyonrails.org/classes/ActiveRecord/Validations.html] ORM) 
+#to check xml format.
 #
-#Adaptation::Message classes describe xml structures, allowing separation of common structures as
-#standalone classes. It offers a set of macros to specify wich structures are part of a bigger one and
-#to allow validation of the different parts. 
+#Examples:
 #
-#A summary of the major features and their usage:
+#      contact = Adaptation::Message.new('<contact><name kind="surname">Name</name></contact>')
 #
-#* Automated mapping between classes and xml attributes and elements.
+#      contact.name.content        # -> "Name"
+#      contact.names.first.content # -> "Name"
+#      contact.names.length        # -> 1
+#      contact.name.kind           # -> "surname"
 #
-#     class Contact < Adaptation::Message
-#       has_one :text, :name
-#     end
+#Let's add some validations:
 #
-#  ...is automatically mapped to a xml structure with root element named "contact", such as:
+#      class Contact < Adaptation::Message
+#        validates_presence_of :name
+#      end
 #
-#     <contact>
-#       <name>Name</name>
-#     </contact>
+#      contact = Contact.new('<contact><name kind="surname">Name</name></contact>')
+#      contact.valid?              # -> true
 #
-#  ...which gives Contact#name
+#      contact = Contact.new('<contact><phone>555</phone></contact>')
+#      contact.valid?              # -> false
 #
 #
-#* Associations between objects controlled by simple meta-programming macros.
+#      class SeriousContact < Adaptation::Message
+#        maps_xml :contact # tell Adaptation that xml data like <contact>...</contact> is mapped by this class
+#        validates_value_of :kind, "surname", :in => :names 
+#      end
 #
-#     class Agenda < Adaptation::Message
-#       has_one  :attribute, :type
-#       has_one  :text, :owner
-#       has_many :contacts
-#     end
+#      contact = SeriousContact.new('<contact><name kind="surname">Name</name></contact>')
+#      contact.valid?              # -> true
 #
-#     class Contact < Adaptation::Message
-#       has_one :text, :name
-#     end
-#
-#  Agenda class would be mapping the following xml structure:
-#
-#     <agenda type="...">
-#       <owner>...</owner>
-#       <contact>...</contact>
-#       <contact>...</contact>
-#       ...
-#     </agenda>
-#
-#  while the _Contact_ class would map:
-#
-#     <contact>
-#       <name>...</name>
-#     </contact>
-#
-#  The Contact class is a partial, a structure included in a bigger structure, so its 
-#  file name starts with an underscore: _contact.rb
-#
-#  We could have wrote Agenda like this, to change the contacts container name:
-#
-#    class Agenda < Adaptation::Message
-#      has_one  :attribute, :type
-#      has_one  :text, :owner
-#      has_many :contacts, :in => :contact_list
-#    end
-#
-#  and Contact like:
-#
-#    class Contact < Adaptation::Message
-#      has_one :text, :name
-#    end
-# 
-#  Then the mapping in Agenda would be:
-#
-#    <agenda type="...">
-#      <owner>...</owner>
-#      <contact_list>
-#        <contact>...</contact>
-#      </contact_list>
-#    </agenda>
-#
-#
-#* Validation rules.
-#
-#  Adaptation::Message uses {ActiveRecord::Validations}[http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html].
-#  This means that {ActiveRecord validations}[http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html]
-#  can be used in an Adaptation::Message object and that custom validations can be easily implemented. 
+#      contact = SeriousContact.new('<contact><name kind="alias">Alias</name></contact>')
+#      contact.valid?              # -> false
 #  
-#  Adaptation::Message also defines some {custom validation methods}[link:../rdoc/classes/ActiveRecord/Validations/ClassMethods.html].
-#
-#  Validations usage example:
-#
-#    class Agenda < Adaptation::Message
-#      has_one :attribute, :type
-#      has_one :text, :owner
-#      validates_presence_of :owner, :type
-#      validates_value_of :type, "indexed"
-#    end
+#More on validations here[link:../rdoc/classes/ActiveRecord/Validations/ClassMethods.html].
 #
 #
   class Message
@@ -109,167 +51,86 @@ module Adaptation
     cattr_reader :objects
     
     include Validateable
-    include ROXML
 
+    # Constructor. Transforms xml passsed as a <em>String</em> to an object wich methods map the input xml elements and attributes.
+    def initialize xml_string 
+      @hash_with_root = XmlSimple.xml_in("<adaptation_wrapper>" + xml_string + "</adaptation_wrapper>", 'ForceArray' => false, 'AttrPrefix' => true) 
+ 
+      first_value = @hash_with_root.values.first
+      hash = first_value.is_a?(String) ? {"content" => first_value} : first_value
+      array = hash.is_a?(Array) ? hash : [hash]
 
-    # Maps an xml attribute or element.
-    # 
-    # Example 1: Mapping an attribute:
-    #   <xml attr="something"/>
-    #
-    #   class Xml < Adaptation::Message
-    #     has_one :attribute, :attr
-    #   end
-    #
-    # Example 2: Mapping an xml element that contains text.
-    #   <xml>
-    #     <element>something</element>
-    #   </xml>
-    #
-    #   class Xml < Adaptation::Message
-    #     has_one :text, :element
-    #   end
-    #
-    # Example 3: Mapping an xml element that contains xml data.
-    #   <xml>
-    #     <element>
-    #       <subelement>something</subelement>
-    #     </element>
-    #   </xml>
-    #
-    #   class Xml < Adaptation::Message
-    #     has_one :object, :element
-    #   end
-    #
-    # The element xml structure would be described in a separate partial file <em>_element.rb</em>:
-    #   class Element < Adaptation::Message
-    #     has_one :text, :subelement
-    #   end
-    #
-    def self.has_one *symbols
-      xml_tag = symbols[0]
-      case xml_tag
-        when :object
-          @objects = [] if @objects.nil?
-          unless @objects.include?(symbols[1])
-            @objects << symbols[1]
-
-            klass = get_class_object(symbols[1])
-            if klass.nil?
-              require "#{ADAPTOR_ROOT}/app/messages/_#{symbols[1].to_s}.rb"
-              klass = get_class_object(symbols[1])
+      array.each do |h|
+        if end_of_tree?(h)
+          h.each_pair do |k, v|
+            if !v.is_a?(Array)
+              is_attribute = k.include?("@") ? true : false
+              var = k.gsub("@","")
+              self.class_eval "attr_accessor :#{var}"         
+              eval "@#{var} = v"
+              var2 = pluralize(var)
+              if !is_attribute and var != var2  
+                self.class_eval "attr_accessor :#{var2}"         
+                eval "@#{var2} = []; @#{var2} << '#{var}'" 
+              end
+            else 
+              var = pluralize(k.gsub("@",""))
+              self.class_eval "attr_accessor :#{var}"         
+              eval "@#{var} = []"
+              v.each do |val|
+                if is_attribute?(val)
+                  xml_substring = XmlSimple.xml_out(val, 'NoIndent' => true, 'RootName' => k,   'AttrPrefix' => true)
+                  eval "@#{var} << Adaptation::Message.new('#{xml_substring}')"
+                else
+                  eval "@#{var} << '#{val}'"  
+                end
+              end 
             end
-
-            xml_object symbols[1], klass
-            validates_associated symbols[1]
           end
-        when :attribute
-          @attributes = [] if @attributes.nil?
-          unless @attributes.include?(symbols[1])
-            @attributes << symbols[1]
-            s = ""
-            @attributes.each do |a|
-              s << a.to_s
+        else
+          h.each_pair do |k,v|
+            if k[0..0] == "@"
+              var = k.gsub("@","")
+              self.class_eval "attr_accessor :#{var}"
+              eval "@#{var} = '#{v}'" 
+            else
+              self.class_eval "attr_accessor :#{k}"
+              xml_substring = ""
+              if !v.is_a?(Array)
+                xml_substring = XmlSimple.xml_out(v, 'NoIndent' => true, 'RootName' => k,   'AttrPrefix' => true)
+                eval "@#{k} = Adaptation::Message.new('#{xml_substring}')"
+                k2 = pluralize(k)
+                if k != k2  
+                  self.class_eval "attr_accessor :#{k2}"
+                  eval "@#{k2} = []; @#{k2} << @#{k}" 
+                end
+              else
+                k2 = pluralize(k)
+                self.class_eval "attr_accessor :#{k2}"
+                eval "@#{k2} = [];" 
+                v.each do |val|  
+                  xml_substring = XmlSimple.xml_out(val, 'NoIndent' => true, 'RootName' => k, 'AttrPrefix' => true) 
+                  eval "@#{k} = Adaptation::Message.new('#{xml_substring}')"
+                  eval "@#{k2} << @#{k}" 
+                end
+              end
             end
-            xml_attribute symbols[1]
-          end
-        when :text
-          @texts = [] if @texts.nil?
-          unless @texts.include?(symbols[1])
-            @texts << symbols[1]
-            xml_text symbols[1]
           end
+        end
       end
+
     end
 
-    # Maps an xml element text.
-    #
-    # If an element contains plain text data and has not been declared in its parent element with
-    # <em>has_one :text</em>, it must declare itself with <em>has_text</em> to be able to contain text.
-    #
-    # Example:
-    #
-    #   <xml>
-    #     <element attr="something">something more</element>
-    #   </xml>
-    #
-    #   class Xml < Adaptation::Message
-    #     has_one :object, :element
-    #   end
-    #
-    # In this case element cannot be declared just like <em>has_one :text</em>, because it also has
-    # an attribute. It must be declared like <em>has_one :object</em>. Then the element declares itself
-    # in a file called <em>_element.rb</em> like this:
-    #
-    #   class Element < Adaptation::Message
-    #     has_one :attribute, :attr
-    #     has_text
-    #   end
-    # 
-    def self.has_text
-      if @has_text.nil?
-        @has_text = true
-        xml_text :text, nil, ROXML::TEXT_CONTENT
-      end
+    def self.has_one *symbols #:nodoc:
+      logger.info "has_one is deprecated and not necessary"
+    end
+
+    def self.has_text #:nodoc:
+      logger.info "has_text is deprecated and not necessary"
     end
    
-    # Maps many xml subelements.
-    #
-    # Example 1:
-    #
-    #   <xml>
-    #     <subelement>...</subelement>
-    #     <subelement>...</subelement>
-    #     <subelement>...</subelement>
-    #   </xml>
-    #
-    #   class Xml < Adaptation::Message
-    #     has_many :subelements
-    #   end   
-    #
-    # Example 2:
-    #
-    #   <xml>
-    #     <subelement_list>
-    #       <subelement>...</subelement>
-    #       <subelement>...</subelement>
-    #       <subelement>...</subelement>
-    #     </subelement_list>
-    #   </xml>       
-    #
-    #   class Xml < Adaptation::Message
-    #     has_many :subelements, :in => :subelement_list
-    #   end
-    #
-    def self.has_many *options
-      configuration = {}
-      configuration.update(options.pop) if options.last.is_a?(Hash)
-      
-      class_with_container = nil
-      if configuration[:in]
-        class_with_container =  options[0].to_s.capitalize[0..-2] + ":#{configuration[:in].to_s}"
-      else
-        class_with_container =  options[0].to_s.capitalize[0..-2] + ":#{options[0].to_s}"  
-      end    
-      unless @@classes_with_brothers.include?(class_with_container)
-        @@classes_with_brothers << class_with_container    
-      end 
-      
-      @has_many = [] if @has_many.nil?
-      unless @has_many.include?(options[0])
-        @has_many << options[0]
-        
-        load "#{ADAPTOR_ROOT}/app/messages/_#{options[0].to_s[0..-2]}.rb"
-        klass = get_class_object(options[0].to_s.capitalize[0..-2])
-        
-        if configuration[:in]
-          xml_object configuration[:in], klass, ROXML::TAG_ARRAY, configuration[:in].to_s
-          validates_associated configuration[:in]
-        else
-          xml_object options[0], klass, ROXML::TAG_ARRAY #, options[0].to_s 
-          validates_associated options[0]
-        end
-      end
+    def self.has_many *options #:nodoc: 
+      logger.info "has_many is deprecated and not necessary"
     end
 
     # Defines the xml element that this class is mapping. This is useful to avoid class
@@ -302,7 +163,6 @@ module Adaptation
     #
     def self.maps_xml element
       @mapped_xml = element
-      xml_name element.to_s
     end
 
     # Returns the xml element this class is mapping
@@ -321,21 +181,57 @@ module Adaptation
       klass
     end
 
-    # This is the constructor. Instead of <em>Adaptation::Message#new</em>, an <em>Adaptation::Message</em> 
-    # instance is created like this:
-    #
-    #   m = Adaptation::Message.to_object("<xml>valid xml</xml>")
-    #
-    def self.to_object xml_message
-      parse xml_message
+    # <em>Deprecated</em>, use <em>new</em> instead.
+    def self.to_object xml_message #:nodoc:
+       logger.info "to_object is deprecated, use new instead"
+       self.new(xml_message)
     end
 
-    # Alias for {Adaptation::Message#valid?}[http://api.rubyonrails.org/classes/ActiveRecord/Validations.html#M002099]
     # <em>Deprecated</em>, use <em>valid?</em> instead.
-    def check
+    def check #:nodoc:
+      logger.info "check is deprecated, use valid? instead"
       valid?
     end
 
+    def self.logger#:nodoc:#
+      Adaptation::Base.logger rescue Logger.new(STDOUT)
+    end
+
+    def to_xml
+      xml_out(@hash_with_root).gsub("\"","'").gsub(/(<|<\/)content(>| *\/>)/,"")
+    end
+
+    def to_hash
+      @hash_with_root
+    end
+
+    private
+    
+    def end_of_tree?(v) #:nodoc:
+      return true if v.has_key? "content"
+      return true if v.values.length == 1 and v.values.first.is_a?(Array) and v.values.first.reject{|val| val.is_a?(String) or is_attribute?(val)}.length == 0
+      false
+    end
+
+    def xml_in(xml_string)
+      XmlSimple.xml_in(xml_string, 'ForceArray' => false, 'AttrPrefix' => true, 'KeepRoot' => true)
+    end
+
+    def xml_out(xml_hash)
+      XmlSimple.xml_out(xml_hash, 'NoIndent' => true, 'RootName' => k, 'AttrPrefix' => true)
+    end
+
+    # TODO: improve this
+    def pluralize(v) #:nodoc:
+      v[(v.length - 1)..v.length] == "s" ? v : v + "s"
+    end
+
+    def is_attribute?(h) #:nodoc:
+      return false unless h.is_a?(Hash)
+      return true if h.length == 1 and h.values.first.is_a?(String)
+      false
+    end
+
   end
   
 end

data/lib/adaptation/test/test_help.rb

@@ -5,58 +5,37 @@ require 'adaptation'
 
 Adaptation::Initializer.run
 
-if File.exists?("config/database.yml")
-  begin
-    require 'active_record/fixtures'
-  rescue Exception => e
-    puts "Problem with database fixtures: #{e}"
-  end
-  Test::Unit::TestCase.fixture_path =  'test/fixtures'
+begin
+  require 'active_record/test_case'
+  require 'active_record/fixtures'
+rescue Exception => e
+  puts "Problem with database fixtures: #{e}"
+  raise e
 end
 
 require 'erb'
 
-class Test::Unit::TestCase
+class ActiveSupport::TestCase
+
+  include ActiveRecord::TestFixtures
+  self.fixture_path = "#{ADAPTOR_ROOT}/test/fixtures/"
+  self.use_instantiated_fixtures  = false
+  self.use_transactional_fixtures = false
 
   # Asserts that a message[link:/classes/Adaptation/Message.html] in a xml
   # fixture file is converted into an Adaptation::Message that if serialized
   # again to xml is equivalent to the xml data in the initial fixture file.
-  # An Adaptation::Message object cretaed from a xml fixture, will only
-  # have the xml tags specified in its class definition (using has_one,
-  # has_many, has_text...) so this assertion can be useful to check that
-  # the class is defined correctly.
   def assert_parsed message_symbol
     data, message_object = load_message_fixture message_symbol
-    
-    parsed_data = REXML::Document.new data
+   
+    #parsed_data = Adaptation::Message.new(data)
     error = build_message error, 
             "? not parsed ok:\n initial: ?\n parsed:  ?", 
             message_symbol.to_s, 
-            parsed_data.to_s, 
-            message_object.to_xml.to_s
-    assert_block error do
-      compare_xml_elements parsed_data.root, message_object.to_xml
-    end
-  end
-
-  # Asserts that a message[link:/classes/Adaptation/Message.html] in a xml
-  # fixture file is converted into an Adaptation::Message that if serialized
-  # again to xml is not equivalent to the xml data in the initial fixture file.
-  # An Adaptation::Message object cretaed from a xml fixture, will only
-  # have the xml tags specified in its class definition (using has_one,
-  # has_many, has_text...) so this assertion can be useful to check that
-  # undesired xml tags are filtered.
-  def assert_not_parsed message_symbol
-    data, message_object = load_message_fixture message_symbol
-
-    parsed_data = REXML::Document.new data
-    error = build_message error, 
-            "? shouldn't be parsed ok:\n data: ?\n real: ?", 
-            message_symbol.to_s, 
-            parsed_data.to_s, 
-            message_object.to_xml.to_s
+            data, 
+            message_object.to_xml
     assert_block error do
-      !compare_xml_elements parsed_data.root, message_object.to_xml
+      compare_xml_elements data, message_object.to_xml
     end
   end
 
@@ -100,7 +79,7 @@ class Test::Unit::TestCase
       # build Message object with xml_data
       message_type = xml_message[1..(xml_message.index(/(>| )/) - 1)]
       message_class = Adaptation::Message.get_class_object(message_type.capitalize)
-      message_object = message_class.to_object(xml_message)
+      message_object = message_class.nil? ? Adaptation::Message.new(xml_message) : message_class.new(xml_message)
     end
 
     # check for all messages "published" in the mom (that's file /tmp/mom.txt),
@@ -108,10 +87,9 @@ class Test::Unit::TestCase
     message_found = false
     expected = published = ""
     File.open(ADAPTOR_ROOT + '/test/mocks/test/mom.txt', 'r').each{ |line|
-      mom_message = REXML::Document.new line
       published   =  line.chop
       expected    =  message_object.to_xml.to_s
-      if compare_xml_elements mom_message.root, message_object.to_xml
+      if compare_xml_elements published, message_object.to_xml
         message_found = true
         break 
       end
@@ -219,9 +197,10 @@ class Test::Unit::TestCase
   end
   
   # Builds a message[link:/classes/Adaptation/Message.html] from a xml fixture
-  # file and processes it the same way mesages from the mom are processed by
-  # adaptation, but using a test environment. Published messages will be
-  # published to a mock MOM.
+  # file and processes it the same way messages from the mom are processed by
+  # adaptation, but using a test environment. Messages published with 
+  # {publish}[link:/classes/Adaptation/Adaptor.html#M000170] will be published 
+  # to a mocked MOM (and can be checked with _assert_message_published_)
   def message message_symbol
     # build a message object from fixture
     message_xml, message_object = load_message_fixture message_symbol
@@ -241,8 +220,8 @@ class Test::Unit::TestCase
 
   end
 
-  # Retuns a message[link:/classes/Adaptation/Message.html] object
-  # from a fixture, without processing it
+  # Returns an Adaptation::Message object from a fixture, without processing it 
+  # (or an instance of the corresponding subclass, if it's defined).
   def get_message_from_fixture message_symbol
     load_message_fixture(message_symbol)[1]
   end
@@ -264,11 +243,13 @@ class Test::Unit::TestCase
     data = get_message_fixture(fixture_symbol.to_s)
     class_name =  data[1..(data.index(/(>| )/) - 1)].capitalize
     message_class = Adaptation::Message.get_class_object(class_name) 
-    message_object = message_class.nil? ? data : message_class.to_object(data)
+    message_object = message_class.nil? ? Adaptation::Message.new(data) : message_class.new(data)
     [data, message_object]
   end
   
   def compare_xml_elements element1, element2 #:nodoc:
+    element1 = REXML::Document.new(element1) if element1.is_a?(String)
+    element2 = REXML::Document.new(element2) if element2.is_a?(String)
     if element1.has_attributes?
        if !element2.has_attributes?
          return false

data/lib/adaptation/validateable.rb

@@ -21,7 +21,7 @@ module Validateable
   module ClassMethods
     # Define class methods here.
    
-    def self_and_descendents_from_active_record#nodoc:
+    def self_and_descendents_from_active_record # :nodoc:
       klass = self
       classes = [klass]
       while klass != klass.base_class
@@ -45,10 +45,97 @@ module Validateable
 
 end
 
+#= Adaptation::Message Validations
+# {ActiveRecord validations}[http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html] should work
+# the same way, except those that have been overwritten here.
+#
 module ActiveRecord
   module Validations
     module ClassMethods
 
+      # Validates whether the specified xml attribute/element is present (not nil or blank).
+      #
+      # Example 1:
+      # 
+      #   class Leftwing < Adaptation::Message
+      #     validates_presence_of :side
+      #   end
+      #
+      #   lw = Leftwing.new("<leftwing side=\"left\"/>")
+      #   lw.valid?  # -> true
+      #   lw = Leftwing.new("<leftwing noside=\"left\"/>")
+      #   lw.valid?  # -> false
+      # 
+      # Example 2:
+      #
+      #   class Bird < Adaptation::Message
+      #     validates_presence_of :side, :in => "birds.wings"
+      #   end
+      #
+      #   b = Bired.new('<birds><bird><wings><wing side="left"/><wing side="right"/></wings></bird></birds>')
+      #   b.valid?   # -> true
+      #   b = Bired.new('<birds><bird><wings><wing side="left"/><wing noside="right"/></wings></bird></birds>')
+      #   b.valid?   # -> false
+      #
+      def validates_presence_of(*attr_names)
+        configuration = {
+          :message => 'cannot be blank' 
+        }
+        configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
+
+        if configuration[:in].nil?
+          validates_each(attr_names, configuration) do |record, attr_name, value|
+            string = record.send(attr_names[0].to_sym) 
+            unless string.nil?
+              string = string.content if string.is_a?(Adaptation::Message)
+            end
+            if string.blank?
+              record.errors.add(attr_name, configuration[:message])
+            end
+          end
+        else
+          validates_each(attr_names, configuration) do |record, attr_name, value|
+            missing = false
+            configuration_in = configuration[:in].to_s
+            elements = configuration_in.to_s.split('.')
+            subelement = record
+            while elements.length > 1
+              subelement = record.send(elements[0].to_sym)
+              elements.slice!(0)
+            end
+
+            if !subelement.is_a?(Array)             
+              subelement.send(elements[0].to_sym).each do |s|
+                string = s.send(attr_names[0].to_sym) 
+                unless string.nil?
+                  string = string.content unless string.is_a?(String)
+                end
+                if string.blank?
+                  missing = true
+                  break
+                end
+              end
+            else
+              subelement.each do |sub|
+                sub.send(elements[0].to_sym).each do |s|
+                  string = s.send(attr_names[0].to_sym) 
+                  unless string.nil?
+                    string = string.content unless string.is_a?(String)
+                  end
+                  if string.blank?
+                    missing = true
+                    break
+                  end
+                end
+                break if missing
+              end
+            end
+
+            record.errors.add(attr_name, configuration[:message]) if missing
+          end
+        end
+      end
+
       # Validates whether the value of the specified xml attribute/element is the expected one.
       #
       # Example 1:
@@ -56,8 +143,6 @@ module ActiveRecord
       #   <leftwing side="left"/>
       #
       #   class Leftwing < Adaptation::Message
-      #     has_one :attribute, :side
-      #
       #     validates_value_of :side, "left"
       #   end
       # 
@@ -65,8 +150,6 @@ module ActiveRecord
       #   <bird><wings><wing side="left"/><wing side="right"/></wings></bird>
       #
       #   class Bird < Adaptation::Message
-      #     has_many :wings
-      #
       #     validates_value_of :side, "left", :in => :wings
       #   end
       #
@@ -78,15 +161,30 @@ module ActiveRecord
 
         if configuration[:in].nil?
           validates_each(attr_names, configuration) do |record, attr_name, value|
-            if (attr_names[1].to_s != record.send(attr_names[0].to_sym))
+            string = record.send(attr_names[0].to_sym) 
+            unless string.nil?
+              string = string.content unless string.is_a?(String)
+            end
+            if (attr_names[1].to_s != string)
               record.errors.add(attr_name, configuration[:message])
             end
           end
         else
           validates_each(attr_names, configuration) do |record, attr_name, value|
             found = false
-            record.send(configuration[:in]).each do |s|
-              if (attr_names[1].to_s == s.send(attr_names[0].to_sym))
+            configuration_in = configuration[:in].to_s
+            elements = configuration_in.to_s.split('.')
+            subelement = record
+            while elements.length > 1
+              subelement = record.send(elements[0].to_sym)
+              elements.slice!(0)
+            end
+            subelement.send(elements[0].to_sym).each do |s|
+              string = s.send(attr_names[0].to_sym) 
+              unless string.nil?
+                string = string.content unless string.is_a?(String)
+              end
+              if (attr_names[1].to_s == string)
                 found = true
                 break
               end
@@ -99,13 +197,15 @@ module ActiveRecord
       # Validates whether the value of the specified xml attribute/element has a valid email format.
       #
       # Example:
-      #   <contact email="mail@xample.com">...</contact>
       #
       #   class Contact < Adaptation::Message
-      #     has_one :attribute, :email
-      #
       #     validates_as_email :email
-      #   end  
+      #   end 
+      #
+      #   c = Contact.new('<contact email="mail@xample.com">...</contact>')
+      #   c.valid?  # -> true
+      #   c.email = "nomail"
+      #   c.valid?  # -> false
       #
       def validates_as_email(*attr_names)
         configuration = {

data/lib/adaptation/version.rb

@@ -1,8 +1,8 @@
 module Adaptation
   module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 1
-    TINY  = 10
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/rails_generator/generators/components/adaptor/templates/functional_test.rb

@@ -1,14 +1,13 @@
 require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
 
-class <%= class_name %>AdaptorTest < Test::Unit::TestCase
-
-  #fixtures :your_table_name_here
+class <%= class_name %>AdaptorTest < ActiveSupport::TestCase
 
   def setup
   end
 
   # Replace this with your real tests.
-  def test_truth
+  test "should be true" do
     assert true
   end
+
 end

data/lib/rails_generator/generators/components/message/templates/unit_test.rb

@@ -1,24 +1,16 @@
 require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
 
-class <%= class_name %>Test < Test::Unit::TestCase
+class <%= class_name %>Test < ActiveSupport::TestCase
 
   # Replace this with your real tests.
-  def test_truth
+  test "should be true" do
     assert true
   end
 
-  # assert the message is defined correctly comparing the initial xml
-  # from the fixture with the xml obtained from the Adaptation::Message
-  # object created with that fixture
-  #def test_not_parsed
-  #  assert_parsed :<%= file_name %>
-  #end
-
   # assert message passes our validations
   #def test_validates
   #  assert_validates :<%= file_name %>
   #  assert_not_validates :<%= file_name %>_incorrect
   #end
 
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: adaptation
 version: !ruby/object:Gem::Version 
-  version: 0.1.10
+  version: 1.0.1
 platform: ruby
 authors: 
 - Xavi Vila Morell
@@ -9,18 +9,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-18 00:00:00 +02:00
+date: 2009-07-24 00:00:00 +02:00
 default_executable: adaptation
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: roxml
+  name: xml-simple
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: "1.2"
+        version: 1.0.12
     version: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -28,9 +28,9 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.2.2
+        version: 2.3.3
     version: 
 description: Adaptation is a framework for building "adaptors" for web-applications, so they can interact with other web-applications publishing messages and being subscribed to a message queue.
 email: xavi@oaproject.net