adaptation 0.0.1

data/lib/adaptation/message.rb

@@ -0,0 +1,328 @@
+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 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. 
+#
+#A summary of the major features and their usage:
+#
+#* Automated mapping between classes and xml attributes and elements.
+#
+#   class Contact < Adaptation::Message
+#     has_one :text, :name
+#   end
+#
+#   ...is automatically mapped to a xml structure with root element named "contact", such as:
+#
+#   <contact>
+#     <name>Name</name>
+#   </contact>
+#
+#   ...which gives Contact#name
+#
+#
+#* Associations between objects controlled by simple meta-programming macros.
+#
+#   class Agenda < Adaptation::Message
+#     has_one  :attribute, :type
+#     has_one  :text, :owner
+#     has_many :contacts
+#   end
+#
+#   class Contact < Adaptation::Message
+#     belongs_to :contacts
+#     has_one :text, :name
+#   end
+#
+#   Agenda class would be mapping the following xml structure:
+#
+#   <agenda type="...">
+#     <owner>...</owner>
+#     <contacts>
+#       <contact>...</contact>
+#     </contacts>
+#   </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
+#     belongs_to :contact_list
+#     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.
+#
+#    class Agenda < Adaptation::Message
+#      has_one :attribute, :type
+#      has_one :text, :owner
+#      validates_presence_of :owner, :type
+#      validates_value :type, "indexed"
+#    end
+#
+#
+  class Message
+    
+    @@validations = {}
+    @@default_error_messages = {
+      :invalid_value => "Invalid value",
+      :must_be_present => "Must be present"
+    }
+    @@errors = []
+
+    include ROXML
+     
+    def self.belongs_to symbol
+      @belongs_to = symbol
+    end
+
+    def self.parent
+      @belongs_to
+    end
+
+    def to_hash
+      s = self.to_yaml
+      h = YAML::load s[4..s.length].downcase.gsub(/\!ruby\/object:.* /,"")
+    end
+
+    def has_son?(son)
+      search_symbol_in_hash self.to_hash, son 
+    end
+
+    def search_symbol_in_hash hash, symbol
+      found = false
+      hash.each_pair do |k,v|
+        if (k.to_sym == symbol)
+          found = true
+          break
+        end
+      end
+      
+      if !found
+        hash.each_pair do |k,v|
+          found = search_symbol_in_hash(v, symbol) if v.is_a?(Hash)
+          break if found
+        end
+      end
+
+      found
+    end
+
+    def self.highest_parent
+      parent_class = self
+      while parent_class != nil
+        begin
+          parent_class = get_class_object(parent_class.parent.to_s.capitalize)
+        rescue Exception => e
+          top_parent_class = parent_class.parent.to_s
+          parent_class = nil
+        end
+      end
+      top_parent_class
+    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]
+            begin
+              klass = get_class_object(symbols[1].to_s.capitalize)
+            rescue Exception => e
+              require "#{ADAPTOR_ROOT}/app/messages/_#{symbols[1].to_s}.rb"
+              klass = get_class_object(symbols[1].to_s.capitalize)
+            end
+            xml_object symbols[1], klass
+          end
+        when :attribute
+          @attributes = [] if @attributes.nil?
+          unless @attributes.include?(symbols[1])
+            @attributes << symbols[1]
+            s = ""
+            @attributes.each do |a|
+              s << a.to_s
+            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
+
+    def self.has_text
+      if @has_text.nil?
+        @has_text = true
+        xml_text :text, nil, ROXML::TEXT_CONTENT
+      end
+    end
+
+    def self.has_many *options
+      configuration = {}
+      configuration.update(options.pop) if options.last.is_a?(Hash)
+      @has_many = [] if @has_many.nil?
+      unless @has_many.include?(options[0])
+        @has_many << options[0]
+        begin
+          klass = get_class_object(options[0].to_s.capitalize[0..-2]) # TODO: singularize seriously
+        rescue Exception => e
+          require "#{ADAPTOR_ROOT}/app/messages/_#{options[0].to_s[0..-2]}.rb"
+          klass = get_class_object(options[0].to_s.capitalize[0..-2])
+        end
+
+        if configuration[:in]
+          xml_object configuration[:in], klass, ROXML::TAG_ARRAY, configuration[:in].to_s
+        else
+          xml_object options[0], klass, ROXML::TAG_ARRAY, options[0].to_s 
+        end
+      end
+    end
+
+    def self.get_class_object(searched_class)
+      class_object = nil
+      ObjectSpace.each_object(Class){|aClass|
+        class_object = aClass if aClass.to_s == searched_class
+      }
+      if class_object.nil?
+        raise Exception.new("Unknown class #{searched_class}.")
+      else
+        return class_object
+      end
+    end
+
+    def self.get_validations_array
+      validations_array = nil
+      if self.highest_parent.empty?
+        validations_array = self.to_s.downcase.to_sym
+      else
+        validations_array = self.highest_parent.to_sym
+      end
+
+      @@validations[validations_array] = [] if @@validations[validations_array].nil?
+      @@validations[validations_array]
+    end
+
+    def self.validates_value(*options)
+      belongs_to = @belongs_to
+      get_validations_array << Proc.new {|message|
+        configuration = {:message => @@default_error_messages[:invalid_value] }
+        if belongs_to.nil?
+          unless (message.send(options[0]) == options[1].to_s)
+            @@errors << [options[0], message.send(options[0]), configuration[:message]]
+          end
+        else
+          found = false
+          message.send(belongs_to).each do |son|
+            if son.send(options[0]) == options[1].to_s
+              found = true
+              break
+            end
+          end
+          unless found
+            @@errors << [options[0], message.send(options[0]), configuration[:message]]
+          end
+        end
+      }
+    end
+
+    def self.validates_presence_of *options
+      belongs_to = @belongs_to
+      get_validations_array << Proc.new {|message|
+        configuration = {:message => @@default_error_messages[:must_be_present]}
+        options.each do |o|
+          if belongs_to.nil?
+            if message.send(o).nil?
+              @@errors << [o, message.send(o), configuration[:message]]
+            end
+          else
+            parent = message.send(belongs_to)
+            if parent.send(o).nil? # this throws a warning if o = :id (but it works)
+              @@errors << [o, message.send(o), configuration[:message]]
+            end
+          end
+        end
+      }
+    end
+
+    def self.validates_uniqueness_of(*options)
+    end
+
+    def self.to_object xml_message
+      parse xml_message
+    end
+
+    def check
+      clear_errors
+
+      @@validations.each_key do |k|
+        if self.has_son? k.to_sym
+          @@validations[k.to_sym].each do |v|
+            v.call(self)
+          end
+        end
+      end
+      @@validations[self.class.to_s.downcase.to_sym].each do |v|
+        v.call(self)
+      end
+
+      unless @@errors.empty?
+        error = "Errors found in XML message:\n"
+        @@errors.each do |e|
+          error << "  #{e[0]}: #{e[2]}\n"
+          error << "    #{e[1]}\n" 
+        end
+        return false
+      end
+
+      return true
+    end
+
+    def get_errors
+      @@errors
+    end
+    
+    def clear_errors
+      @@errors = []
+    end
+
+  end
+
+end

data/lib/adaptation/mom.rb

@@ -0,0 +1,70 @@
+require 'drb'
+require 'yaml'
+
+module Adaptation
+
+  class Mom
+
+    def initialize mom_uri
+      @mom_uri = mom_uri
+    end
+
+    def subscribe drb_uri
+      unless get_subscribers.include?(drb_uri)
+        add_subscriber drb_uri
+        puts "Added new subscriber: #{drb_uri}"
+        oapdaemon = DRbObject.new(nil, drb_uri)
+        oapdaemon.subscription_result true
+      end
+    end
+
+    def publish message, topic
+      # Tell subscribed hosts to execute their adaptors
+      puts "-----------------------------------"
+      puts "Received message in topic: #{topic}"
+      puts "#{message}"
+      puts "-----------------------------------"
+      get_subscribers.each do |uri|
+        puts "Calling #{uri}"
+        DRb.start_service
+        oapdaemon = DRbObject.new(nil, uri)
+        oapdaemon.call_adaptor message, topic
+      end
+    end
+
+    def start
+      DRb.start_service(@mom_uri, self)
+      puts "MOM started. Listening at #{@mom_uri}"
+      DRb.thread.join # Don't exit just yet
+    end
+
+    def list
+      puts "MOM subscriptions:"
+      get_subscribers.each do |s|
+        puts "  #{s}"
+      end
+      return
+    end
+
+  private
+
+    def add_subscriber drb_uri
+      subscribers = get_subscribers
+      subscribers << drb_uri unless subscribers.include?(drb_uri)
+      sf =  File.new('subscribers.yml', 'w')
+      sf.write(YAML::dump(subscribers))
+      sf.close
+    end
+
+    def get_subscribers
+      if File.exists?('subscribers.yml')
+        subscribers = YAML::load(File.open('subscribers.yml'))
+      else
+        subscribers = Array.new
+      end
+      subscribers
+    end
+
+  end
+
+end

data/lib/adaptation/oapdaemon.rb

@@ -0,0 +1,38 @@
+require 'drb'
+require 'yaml'
+
+module Adaptation
+
+  class Oapdaemon
+
+    def initialize subscriber_uri, mom_uri, topics
+      @subscriber_uri = subscriber_uri
+      @mom_uri = mom_uri
+      @topics = topics
+    end
+
+    def call_adaptor message, topic
+      if ( (@topics.include?(topic)) or (@topics == "all") )
+        system("ruby public/dispatch.rb #{message}") 
+      end
+      puts "#{topic} => #{message}"
+    end
+
+    def subscription_result subscribed
+      if subscribed
+        puts "Subscribed to mom (#{@mom_uri}). Listening at #{@subscriber_uri}"
+      end
+    end
+
+    def start
+      DRb.start_service(@subscriber_uri, self)
+
+      mom = DRbObject.new(nil, @mom_uri)
+      mom.subscribe @subscriber_uri
+
+      DRb.thread.join # Don't exit just yet!
+    end
+
+  end
+
+end

data/lib/adaptation/test/test_help.rb

@@ -0,0 +1,282 @@
+#set environment
+$environment = "test"
+if File.exists?("config/settings.yml")
+  $config = YAML::load(File.open("config/settings.yml"))[$environment]
+end
+
+# connect to test database
+require 'active_record'
+
+if File.exists?("config/database.yml") 
+  test_configurations = YAML::load(File.open("config/database.yml"))[$environment]
+  ActiveRecord::Base.configurations.update("test" => test_configurations)
+  ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[$environment])
+end
+
+if File.exists?("log")
+  ActiveRecord::Base.logger = Logger.new("#{ADAPTOR_ROOT}/log/test.log")
+end
+
+# load messages
+Dir["#{ADAPTOR_ROOT}/app/messages/*.rb"].reject{|f| f =~ /\/_/}.each do |f|
+  require f
+end
+
+# load models
+Dir["#{ADAPTOR_ROOT}/app/models/*.rb"].each do |f|
+  require f
+end
+
+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'
+end
+
+class Test::Unit::TestCase
+
+  def assert_parsed message_symbol
+    data, message_object = load_message_fixture message_symbol
+    
+    parsed_data = REXML::Document.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
+      #message_object.to_xml.to_s == parsed_data.to_s
+      compare_xml_elements parsed_data.root, message_object.to_xml
+    end
+  end
+
+  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
+    assert_block error do
+      message_object.to_xml.to_s != parsed_data.to_s
+    end
+  end
+
+  def assert_validates message_symbol
+    data, message_object = load_message_fixture message_symbol
+    error = build_message error,
+            "invalid message ?",
+            message_symbol.to_s
+    message_object.clear_errors
+    assert_block error do
+      message_object.check
+    end
+  end
+
+  def assert_not_validates message_symbol
+    data, message_object = load_message_fixture message_symbol
+    error = build_message error,
+            "? message shouldn't validate",
+            message_symbol.to_s
+    assert_block error do
+      !message_object.check
+    end
+  end
+
+  def assert_message_published xml_message
+    # build Message object with xml_data
+    message_type = xml_message[1..(xml_message.index(/(>| )/) - 1)]
+    message_class = get_class_object(message_type.capitalize)
+    message_object = message_class.to_object(xml_message)
+
+    # check for all messages "published" in the mom (that's file /tmp/mom.txt),
+    # if any line corresponds to the message passes as a parameter.
+    message_found = false
+    File.open('/tmp/mom.txt', 'r').each{ |line|
+      mom_message = REXML::Document.new line
+      if mom_message.to_s.chomp == message_object.to_xml.to_s
+        message_found = true
+        break 
+      end
+    }
+ 
+    error = build_message error,
+            "? message not published",
+            message_type
+    assert_block error do
+      message_found
+    end
+    
+  end
+
+  def assert_database_present db_settings_hash
+    update_activerecord_test_configuration db_settings_hash
+
+    ActiveRecord::Base.remove_connection
+    
+    ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[$environment])
+
+    database_exists = true
+    begin
+      connection = ActiveRecord::Base.connection
+    rescue Exception => e
+      puts "Database error message: #{e}"
+      database_exists = false
+    end
+
+    error = build_message error,
+            "? database not found",
+            ActiveRecord::Base.configurations[$environment][:database]
+    assert_block error do
+      database_exists
+    end
+
+  end
+
+  def assert_database_not_present db_settings_hash
+    update_activerecord_test_configuration db_settings_hash
+
+    ActiveRecord::Base.remove_connection
+
+    ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[$environment])
+
+    database_exists = true
+    begin
+      connection = ActiveRecord::Base.connection
+    rescue Exception => e
+      puts "Database error message: #{e}"
+      database_exists = false
+    end
+
+    error = build_message error,
+            "? database shouldn't exist",
+            ActiveRecord::Base.configurations[$environment][:database]
+    assert_block error do
+      !database_exists
+    end
+
+  end
+
+  def update_activerecord_test_configuration db_settings_hash
+    unless db_settings_hash.nil?
+      ActiveRecord::Base.configurations.update("test" => db_settings_hash)
+    end
+  end
+
+  def assert_file_present file
+    error = build_message error,
+            "? not found",
+            file
+    assert_block error do
+      File.exists?(file)
+    end
+  end
+
+  def assert_file_not_present file
+    error = build_message error,
+            "? shouldn't exist",
+            file
+    assert_block error do
+      !File.exists?(file)
+    end
+  end
+
+  def get_message_fixture fixture_name
+    fixture_file = ADAPTOR_ROOT + '/test/fixtures/' + fixture_name + '.xml'
+    fixture_contents = ""
+    File.open(fixture_file).each { |line|
+      unless line =~ /^ {0,}#/
+        fixture_contents << line.strip.chomp
+      end
+    }
+    fixture_contents.chomp
+  end
+
+  def load_message_fixture fixture_symbol
+    data = get_message_fixture(fixture_symbol.to_s)
+    class_name = self.class.to_s.gsub("Test", "")
+    class_name = class_name.gsub("Adaptor", "")
+    message_class = get_class_object(class_name)
+    message_object = message_class.to_object(data)
+    [data, message_object]
+  end
+
+  def get_class_object(searched_class)
+    class_object = nil
+    ObjectSpace.each_object(Class){|aClass|
+      class_object = aClass if aClass.to_s == searched_class
+    }
+    if class_object.nil?
+      raise Exception.new("Unknown class #{searched_class}.")
+    else
+      return class_object
+    end
+  end
+
+  def message message_symbol
+    # build a message object from fixture
+    message_xml, message_object = load_message_fixture message_symbol
+
+    # load mock objects
+    Dir["test/mocks/test/*.rb"].each do |f|
+      require f
+    end 
+
+    # clean mom (delete mom.txt file)
+    mom_mock_file = 'test/mocks/test/mom.txt'
+    if File.exists? mom_mock_file
+      File.delete mom_mock_file
+    end
+
+    # process message
+    @adaptor.process message_object
+
+  end
+
+  def compare_xml_elements element1, element2
+    if element1.has_attributes?
+       if !elements2.has_attributes?
+         return false
+       end
+       element1.attributes.to_a.each do |a|
+         if !element2.attributes.to_a.include?(a)
+           return false
+         end
+       end
+    end
+    if element1.has_text?
+      if !element2.has_text?
+        return false
+      end
+      if element1.text != element2.text
+        return false
+      end
+    end
+    if element1.has_elements?
+      if !element2.has_elements?
+        return false
+      end
+      element1.elements.to_a.each do |e1|
+        element_exists = false
+        element2.elements.to_a.each do |e2|
+          result = compare_xml_elements e1, e2
+          if result == true
+            element_exists = true
+            break
+          end
+        end
+        if element_exists == false
+          return false
+        end
+      end
+    end
+
+    return true
+  end
+  
+end