mu 5.7.9 → 5.7.10

data/lib/mu/libxml.rb

@@ -1,21 +0,0 @@
-# Copyright (C) 2008 Mu Dynamics, Inc
-#
-# This program is confidential and proprietary to Mu Dynamics, Inc and
-# may not be reproduced, published or disclosed to others without its
-# authorization.
-
-module LibXML
-module XML
-class Node
-    # Get first element, optionally with name.
-    def first_element name=nil
-        each_element do |element|
-            if not name or name == element.name
-                return element
-            end
-        end
-        return nil
-    end
-end
-end
-end

data/lib/mu/xmlizable.rb

@@ -1,559 +0,0 @@
-# Copyright (C) 2008 Mu Dynamics, Inc
-#
-# This program is confidential and proprietary to Mu Dynamics, Inc and
-# may not be reproduced, published or disclosed to others without its
-# authorization.
-
-require 'libxml'
-require 'mu/libxml'
-
-# Helper mixin for XML serialization.
-#
-# Example:
-#   class MyObject
-#      include XMLizable
-#      xmlizable 'my-object' do
-#          xml_element :a, Integer
-#          xml_attribute :b, String, :required => true
-#      end
-#   ...
-module XMLizable
-    class XMLParseError < StandardError ; end
-
-    def self.included klass
-        super
-        klass.extend XMLizableClassMethods
-    end
-
-    module XMLizableClassMethods
-        # Declare object to be XML serializable.  If name is not given, the
-        # object itself cannot be serialized and only XMLizable subclasses can.
-        def xmlizable name=nil #block
-            if defined? @xmlizable_called
-                raise ArgumentError, "Only call xmlizable once"
-            end
-            @xmlizable_called = true
-            @xmlizable_name = name
-            @xmlizable_classes = {}
-            if name
-                # Add this class to ancestor's XMLizable class map.
-                classes = ancestors.select { |ancestor| ancestor < XMLizable }
-                classes.each do |ancestor|
-                    if ancestor.instance_variable_defined? :@xmlizable_classes
-                        classes = 
-                            ancestor.instance_variable_get :@xmlizable_classes
-                        classes[name] = self
-                    end
-                end
-            end
-            
-            # Set xmlizable elements and attributes in block
-            @xmlizable_elements = []
-            @xmlizable_attributes = []
-            if block_given?
-                yield
-            end
-
-            # Re-init to merge in ancestor elements and attributes 
-            init_elements_and_attrs
-        end
-
-        # Initialize @xmlizable_elements and @xmlizable_attributes
-        def init_elements_and_attrs
-            # Get non-duplicate elements/attibutes from ancestors (including
-            # current class)
-            elems = []
-            attrs = []
-            attr_names = Set.new
-            elem_names = Set.new
-            ancestors.each do |klass|
-                next unless klass < XMLizable
-                if klass.instance_variable_defined? :@xmlizable_elements
-                    klass.xmlizable_elements.reverse_each do |e|
-                        elems.unshift e unless elem_names.include? e.name
-                        elem_names << e.name
-                    end
-                end
-                if klass.instance_variable_defined? :@xmlizable_attributes
-                    klass.xmlizable_attributes.reverse_each do |a|
-                        attrs.unshift a unless attr_names.include? a.name
-                        attr_names << a.name
-                    end
-                end
-            end
-            @xmlizable_attributes = attrs.freeze
-            @xmlizable_elements = elems.freeze
-        end
-        
-        # There may be subclasses that indirectly include XMLizable or that never
-        # call xmlizable. Use inherited hook to make sure they are initialized
-        def inherited(klass)
-            klass.init_elements_and_attrs
-        end
-
-        # Declare variable to be serialized as an XML element of type.
-        def xml_element name, klass, *opts
-            element = xml_object name, klass, *opts
-            @xmlizable_elements << element
-        end
-
-        # Declare variable to be serialized as an array of XML element with
-        # of type.  The type must support to/from_libxml.
-        def xml_elements name, klass, *opts
-            element = xml_object name, klass, *opts
-            element.array = true
-            @xmlizable_elements << element
-        end
-
-        # Declare variable to be serialized as an XML attribute of type.
-        def xml_attribute name, klass, *opts
-            attribute = xml_object name, klass, *opts
-            @xmlizable_attributes << attribute
-        end
-
-        def xmlizable_name
-            @xmlizable_name
-        end
-
-        # Get list of elements.
-        def xmlizable_elements
-            @xmlizable_elements 
-        end
-
-        # Get list of attributes.
-        def xmlizable_attributes
-            @xmlizable_attributes 
-        end
-
-        # Create object to XML::Node.  The object must be creatable by
-        # calling a constructor with no arguments.
-        def from_libxml node
-            if node.name != @xmlizable_name
-                xmlizable_classes = @xmlizable_classes
-                klass = xmlizable_classes[node.name]
-                if klass and klass != self
-                    return klass.from_libxml(node)
-                else
-                    raise XMLParseError, "Unknown element: #{node.name}"
-                end
-            end
-
-            object = self.new
-            @xmlizable_attributes.each do |attribute|
-                value = node[attribute.xml_name]
-                if value
-                    attribute_klass = attribute.klass
-                    if attribute_klass == String
-                        # Common case with no special treatment
-                    elsif attribute_klass <= Integer
-                        value = value.to_i
-                    elsif attribute_klass <= Float
-                        value = value.to_f
-                    elsif attribute_klass <= TrueClass
-                        if value == 'true'
-                            value = true
-                        elsif value == 'false'
-                            value = false
-                        else
-                            raise XMLParseError, 'Invalid boolean value: ' +
-                                value.inspect
-                        end
-                    elsif attribute_klass <= Symbol
-                        begin
-                            value = value.to_sym
-                        rescue ArgumentError
-                            raise XMLParseError, "Invalid value: #{value.inspect} in #{node.name}" 
-                        end
-                        if attribute.enum and not attribute.enum.member? value
-                            raise XMLParseError, "Invalid value: #{value.inspect} in #{node.name}" 
-                        end
-                    end
-                    object.send :"#{attribute.name}=", value
-                elsif attribute.required
-                    raise XMLParseError, "Required attribute missing: " + 
-                        attribute.xml_name + ' in ' + node.name
-                else
-                    object.send "#{attribute.name}=", attribute.default
-                end
-            end
-            @xmlizable_elements.each do |element|
-                element_node = node.first_element element.xml_name
-                if element_node
-                    element_klass = element.klass
-                    if element_klass == String or element_klass == Mu::Scenario::Field::Reference
-                        content = element_node.content
-                        case element.escape
-                        when :default
-                            content.delete! TAB_CR_LF
-                            value = XMLizable.unescape content
-                        when :no_newline
-                            content.delete! TAB_CR
-                            value = XMLizable.unescape content
-                        when :regexp
-                            value = content
-                        else
-                            raise XMLParseError, "Unknown escape type: #{element.escape}"
-                        end
-                    elsif element_klass == Integer
-                        value = element_node.content.to_i(0)
-                    elsif element.array
-                        value = []
-                        element_node.each_element do |value_node|
-                            value << element.klass.from_libxml(value_node)
-                        end
-                    elsif element_klass == Float
-                        value = element_node.content.to_f
-                    elsif element_klass == Symbol
-                        value = element_node.content
-                        begin
-                            value = value.to_sym
-                        rescue ArgumentError
-                            raise XMLParseError, "Invalid value: #{value.inspect} in #{node.name}" 
-                        end
-                        if element.enum and not element.enum.member? value
-                            raise XMLParseError, "Invalid value: #{value.inspect} in #{node.name}" 
-                        end
-                    elsif element_klass == TrueClass
-                        value = element_node.content
-                        if value == 'true'
-                            value = true
-                        elsif value == 'false'
-                            value = false
-                        else
-                            raise XMLParseError, 'Invalid boolean value: ' +
-                                value.inspect
-                        end
-                    else
-                        value_node = element_node.first_element
-                        if not value_node
-                            raise XMLParseError, 'Element missing value: ' +
-                                element.xml_name + ' in ' + node.name
-                        end
-                        value = element_klass.from_libxml value_node
-                    end
-                    object.send :"#{element.name}=", value
-                elsif element.required
-                    raise XMLParseError, 'Required element missing: ' + 
-                        element.xml_name + ' in ' + node.name
-                else
-                    object.send :"#{element.name}=", element.default
-                end
-            end
-            object.post_from_libxml node
-            return object
-        end
-
-        private
-
-        # Create new XML serializable object.  Internal helper method.
-        XMLObject = ::Struct.new :name, :klass, :default, :required, :internal,
-            :array, :enum, :xml_name, :label, :doc, :escape
-        def xml_object name, klass, *opts
-            # Get default value
-            if not opts[0].is_a? Hash
-                default = opts.shift
-            else
-                default = nil
-            end
-            array = false
-            if opts[-1]
-                required = opts[-1].fetch :required, false
-                internal = opts[-1].fetch :internal, false
-                enum     = opts[-1][:enum]
-                xml_name = opts[-1].fetch :xml_name, name.to_s
-                label    = opts[-1][:label]
-                doc      = opts[-1][:doc]
-                escape = opts[-1].fetch :escape, :default
-            else
-                required = false
-                internal = false
-                enum     = nil
-                xml_name = name.to_s
-                label    = nil
-                doc      = nil
-                escape   = :default
-            end
-            return XMLObject.new(name, klass, default, required, internal,
-                                 array, enum, xml_name, label, doc, escape)
-        end
-    end
-
-    # Traverses the XMLizable tree rooted at the current node, passing 
-    # each child node to the associated block. If the block returns a 
-    # value other than nil or false the child is replaced with that 
-    # value. 
-    def xmlizable_replace_nodes &block
-        self.class.xmlizable_attributes.each do |attribute|
-            obj = self.send attribute.name
-            if nobj = block.call(obj)
-                self.send :"#{attribute.name}=", nobj
-            end
-        end
-
-        self.class.xmlizable_elements.each do |element|
-            obj = self.send element.name
-            recurse = element.klass <= XMLizable
-            if element.array
-                obj.each_with_index do |sub_obj,i|
-                    if nsub_obj = block.call(sub_obj) 
-                        obj[i] = nsub_obj
-                    elsif sub_obj and recurse
-                        sub_obj.xmlizable_replace_nodes(&block)
-                    end
-                end
-            else
-                if nobj = block.call(obj)
-                    self.send :"#{element.name}=", nobj
-                elsif obj and recurse
-                    obj.xmlizable_replace_nodes(&block)
-                end
-            end
-        end
-    end
-
-    def xmlizable_map! &block
-        self.class.xmlizable_attributes.each do |attribute|
-            obj = self.send attribute.name
-            if nobj = block.call(obj) and not nobj.equal?(obj)
-                self.send :"#{attribute.name}=", nobj
-            end
-        end
-
-        self.class.xmlizable_elements.each do |element|
-            obj = self.send element.name
-            if element.array
-                obj.each_with_index do |sub_obj,i|
-                    if nsub_obj = block.call(sub_obj) and not nsub_obj.equal?(sub_obj)
-                        obj[i] = nsub_obj
-                    end
-                end
-            else
-                if nobj = block.call(obj) and not nobj.equal?(obj)
-                    self.send :"#{element.name}=", nobj
-                end
-            end
-        end
-    end
-
-    def xmlizable_each &block
-        self.class.xmlizable_attributes.each do |attribute|
-            obj = self.send attribute.name
-            block.call(obj)
-        end
-
-        self.class.xmlizable_elements.each do |element|
-            obj = self.send element.name
-            if element.array
-                obj.each do |sub_obj|
-                    block.call(sub_obj) 
-                end
-            else
-                block.call(obj)
-            end
-        end
-    end
-
-    # Recuses through xmlizable tree, yielding each element and attribute
-    # to the supplied block. You can stop recursion at a given node
-    # with "throw :prune" (like Find.find from stdlib)
-    def xmlizable_find &block
-        catch :prune do
-            block.call(self)
-
-            self.class.xmlizable_attributes.each do |attribute|
-                catch :prune do
-                    obj = self.send attribute.name
-                    block.call(obj)
-                end
-            end
-
-            self.class.xmlizable_elements.each do |element|
-                obj = self.send element.name
-                next if not obj
-
-                recurse = element.klass <= XMLizable
-                if element.array
-                    obj.each do |sub_obj|
-                        next unless sub_obj
-                        if recurse
-                            sub_obj.xmlizable_find(&block)
-                        end
-                    end
-                else
-                    if recurse
-                        obj.xmlizable_find(&block)
-                    end
-                end
-            end
-        end
-    end
-
-    # Same as xmlizable_find but only yields elements. 
-    def xmlizable_find_elements &block
-        catch :prune do
-            block.call(self)
-
-            self.class.xmlizable_elements.each do |element|
-                obj = self.send element.name
-                next if not obj
-
-                recurse = element.klass <= XMLizable
-                if element.array
-                    obj.each do |sub_obj|
-                        next unless sub_obj
-                        if recurse
-                            sub_obj.xmlizable_find_elements(&block)
-                        end
-                    end
-                else
-                    if recurse
-                        obj.xmlizable_find_elements(&block)
-                    end
-                end
-            end
-        end
-    end
-
-    # Convert object to XML::Node
-    def xmlizable_to_libxml
-        name = self.class.instance_variable_get :@xmlizable_name
-        if not name
-            raise ArgumentError, 'Cannot convert nameless class to XML: ' +
-                self.class.name
-        end
-        node = LibXML::XML::Node.new name
-        self.class.xmlizable_attributes.each do |attribute|
-            value = self.send attribute.name
-            if value == attribute.default and not attribute.required
-                next
-            end
-            node[attribute.xml_name] = value.to_s
-        end
-        self.class.xmlizable_elements.each do |element|
-            value = self.send element.name
-            element_klass = element.klass
-            if value == element.default and not element.required
-                next
-            end
-            element_node = LibXML::XML::Node.new element.xml_name
-            node << element_node
-            if element.array
-                value.each do |sub_value|
-                    element_node << sub_value.to_libxml
-                end
-            elsif element_klass <= Integer or element_klass <= Float
-                element_node.content = value.to_s
-            elsif element_klass <= Symbol or element_klass <= TrueClass
-                element_node.content = value.to_s
-            elsif element_klass <= String
-                value = value.to_s.dup
-                case element.escape
-                when :default
-                    element_node << XMLizable.escape(value, ESCAPES)
-                when :no_newline
-                    element_node << XMLizable.escape(value, ESCAPES_NO_NEWLINE)
-                when :regexp
-                     element_node << XMLizable.escape(value, ESCAPES_RE)
-                else
-                    raise ArgumentError, "Unknown escape type: #{escape_table}"
-                end
-            else
-                element_node << value.to_libxml
-            end
-        end
-        return node
-    end
-
-    alias :to_libxml :xmlizable_to_libxml
-
-    # Hook for logic after de-serializing an object.
-    def post_from_libxml node
-    end
-
-
-    # Default map used for unescaping.
-    # Backslash escapes are not substituted unless they are defined here 
-    # (or in a map explicitly passed to XMLizable.unescape). The exception 
-    # to this is "\x" sequences like "\x0a"  which are always substituted.
-    UNESCAPE_MAP = {
-        'n' => "\n",
-        't' => "\t",
-        'r' => "\r",
-        '\\' => "\\"
-    }
-    
-    #              1                    2                   3
-    RE_ESCAPE = /\A([^\\]+)?(?:\\(?:(?:x([0-9a-fA-F]{1,2}))|(.)))?/
-    # 1: optional text in front with no escapes
-    # then we parse optional escape sequence:
-    # 2: hex from  \x escape 
-    # 3: char from other escapes 
-
-    # Returns an unescaped copy of string s.
-    def self.unescape s, unescape_map=nil
-        unescape_map ||= UNESCAPE_MAP
-
-        input = s.dup
-        output = []
-        until input.empty?
-            input.slice! RE_ESCAPE
-            # leading text with no escape sequences
-            output << $1 if $1
-            if $2
-                # We have an \x escape code. Interpret hex and get character.
-                output << $2.hex.chr
-            elsif $3
-                # We have something like \t. Interpet it if we can, otherwise preserve both characters
-                output << unescape_map.fetch($3,"\\#$3")
-            end
-        end
-        output.join
-    end
-
-    # Default table used for converting ascii code to escaped representation
-    ESCAPES = Array.new 256 do |i| 
-        case i 
-        when 9;        "\\t".freeze
-        when 13;       "\\r".freeze
-        when 92;       "\\\\".freeze
-        when 10;       "\\n".freeze
-        when 32..126;  i.chr.freeze
-        else ;         ('\x%02x' % i).freeze
-        end
-    end
-    ESCAPES.freeze
-    # Text escaped with ESCAPES should not have any of these characters in it.
-    TAB_CR_LF = "\t\r\n".freeze
-
-    ESCAPES_NONE = Array.new(256) { |i| i.chr.freeze }
-    ESCAPES_NONE.freeze
-
-    # Regular expressions are escaped when writing to xml but not when
-    # reading from XML. This is necessary because XML doesn't allow
-    # some (all?) binary characters. Escaping doesn't change the meaning
-    # of the regex and does not need to be reversed when deserealizing.
-    ESCAPES_RE = Array.new 256 do |i| 
-        case i 
-        when 32..126;  i.chr.freeze
-        else ;         ('\x%02x' % i).freeze
-        end
-    end
-    ESCAPES_RE.freeze
-
-    # Alternate escape table that doesn't escape newline characters
-    ESCAPES_NO_NEWLINE = ESCAPES.dup
-    ESCAPES_NO_NEWLINE[10] = "\n".freeze
-    ESCAPES_NO_NEWLINE.freeze
-    # Text escaped with ESCAPES_NO_NEWLINE should not have any of these characters in it.
-    TAB_CR = "\t\r".freeze
-
-    # Takes input and a table that maps ascii codes to their representation
-    def self.escape input, escapes=nil
-        escapes ||= ESCAPES
-        output = []
-        input.each_byte do |i|
-            output << escapes[i]
-        end
-        output.join 
-    end
-end