mu 5.7.8 → 5.7.9

data/lib/mu/libxml.rb

@@ -0,0 +1,21 @@
+# 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/maker.rb

@@ -0,0 +1,288 @@
+module MuSL
+# A simple DSL for making MuSL code. Invoke thusly and provided nested
+# blocks to construct the scenario:
+# MuSL::Maker.create do |scenario|
+#     scenario.hosts do |hosts|
+#         ...
+#     end
+# end
+class Maker
+    def self.create name='scenario'
+        scenario = Scenario.new
+        scenario.create(name) do
+            yield scenario
+        end
+        return scenario.musl.join
+    end
+    
+    class Scenario
+        def depth
+            @depth ||= 0
+        end
+        
+        def musl
+            @musl ||= []
+        end
+        
+        def indent amount
+            " " * (4 * amount)
+        end
+
+        def line text=''
+            musl << indent(depth) + text + "\r\n"
+        end
+
+        def comment text
+            line '# ' + text
+        end
+        
+        def literal text
+            musl << indent(depth) + text + "\r\n"
+        end
+
+        def literal_no_format text
+            musl << text
+        end
+
+        def block start, finish, opts={}
+            musl << indent(depth) + start + "\r\n"
+            @depth += 1
+            yield self
+            @depth -= 1
+            musl << indent(depth) + finish + "\r\n"
+        end
+        
+        def create name # yield |scenario|
+            block 'scenario(name: "' + name + '") {', '}' do
+                yield self
+            end
+        end
+        
+        def hosts # yield |hosts|
+            block 'hosts {', '}' do
+                yield Hosts.new(self)
+            end
+        end
+        
+        def options # yield |options|
+            block 'options {', '}' do
+                yield Options.new(self)
+            end
+        end
+        
+        def globals # yield |globals|
+            block 'variables {', '}' do
+                yield Globals.new(self)
+            end
+        end
+        
+        def steps # yield |steps|
+            block 'steps { ', '}' do
+                yield Steps.new(self)
+            end
+        end
+        
+        def escape text
+            text.gsub(/\\/, '\\\\').gsub(/\r/, '\\r').gsub(/\n/, '\\n').gsub(/"/, '\\"')
+        end
+
+        def escape_payload text
+            text.gsub(/\\/, '\\\\\\').gsub(/\r/, '\\r').gsub(/\n/, '\\n').gsub(/"/, '\\"')
+        end
+        
+        def attrs kvs = {}
+            return '' if kvs.empty?
+            
+            ary = []
+            kvs.each_pair do |key, val|
+                if ( (val.is_a? String) &&  (val.length === 0)  )
+                    #val = escape(val.to_s)
+                    val = '"' + escape(val.to_s) + '"'
+                elsif val.is_a? Symbol
+                    val = escape(val.to_s)
+                else
+                    val = escape(val.to_s)
+                end
+                ary << (key.to_s + ':' + val.to_s)
+            end
+            return '(' + ary.join(', ') + ')'
+        end
+    end
+    
+    class Block
+        attr_reader :scenario
+        
+        def initialize scenario
+            @scenario = scenario
+        end
+        
+        def comment text
+            scenario.comment text
+        end
+    end
+    
+    class Hosts < Block
+        def create name, type, role=nil
+            scenario.comment(role) if role
+            scenario.line('&' + name + ' = host(type:' + type + ')')
+        end
+    end
+    
+    class Options < Block
+        def create name, value
+            v = value.is_a?(String) ? '"' + value + '"' : value
+            scenario.line('$' + name + ' = ' + v)
+        end
+    end
+    
+    class Globals < Block
+        def create name, value
+            scenario.line('@' + name + ' = ' + value)
+        end
+    end
+    
+    class Steps < Block
+        def xport name, klass, kvs
+            scenario.line(name + ' = ' + klass + scenario.attrs(kvs));
+            scenario.line;            
+        end
+        
+        def client_send name, xport, kvs={}
+            decl = name + ' = ' + xport + '.client_send' + scenario.attrs(kvs)
+            scenario.block decl + ' {', '}' do
+                yield Send.new(scenario)
+            end            
+        end
+
+        def server_send name, xport, kvs={}
+            decl = name + ' = ' + xport + '.server_send' + scenario.attrs(kvs)
+            scenario.block decl + ' {', '}' do
+                yield Send.new(scenario)
+            end
+        end
+        
+        def client_receive name, xport, kvs={}
+            decl = name + ' = ' + xport + '.client_receive' + scenario.attrs(kvs)
+            scenario.block decl + ' {', '}' do
+                yield Receive.new(scenario)
+            end
+        end
+
+        def server_receive name, xport, kvs={}
+            decl = name + ' = ' + xport + '.server_receive' + scenario.attrs(kvs)
+            scenario.block decl + ' {', '}' do
+                yield Receive.new(scenario)
+            end
+        end
+    end
+    
+    class Send < Block
+        def base64_encode kvs={}
+            if block_given?
+                scenario.block 'base64_encode' + scenario.attrs(kvs) + ' [', ']' do
+                    yield self
+                end
+            else
+                scenario.line 'base64_encode' + scenario.attrs(kvs)
+            end
+        end
+        
+        def uri_percent_encode kvs={}
+            if block_given?
+                scenario.block 'uri_percent_encode' + scenario.attrs(kvs) + ' [', ']' do
+                    yield self
+                end
+            else
+                scenario.line 'uri_percent_encode' + scenario.attrs(kvs)
+            end
+        end
+        
+        def hex_encode kvs={}
+            if block_given?
+                scenario.block 'hex_encode' + scenario.attrs(kvs) + ' [', ']' do
+                    yield self
+                end
+            else
+                scenario.line 'hex_encode' + scenario.attrs(kvs)
+            end
+        end
+        
+        def block start, finish
+            scenario.block start, finish do
+                yield self
+            end
+        end
+        
+        def compress type
+            scenario.block type + '_compress [', ']' do
+                yield self
+            end
+        end
+        
+        def header name, kvs={}
+            kvs['header_name'] = name
+            if block_given?
+                scenario.block 'header(header_name:"' + name + '") [', ']' do
+                #scenario.block 'header' + scenario.attrs(kvs) + ' [', ']' do
+                    yield self
+                end
+            else
+                scenario.line 'header' + scenario.attrs(kvs)
+            end
+        end
+        
+        def length_string kvs={}
+            scenario.line 'length_string' + scenario.attrs(kvs)
+        end
+        
+        def line text=''
+            if block_given?
+                scenario.block 'line [', ']' do
+                    yield self
+                end
+            else
+                scenario.line('"' + scenario.escape(text) + '\r\n"')
+            end
+        end
+        
+        def string text=''
+            scenario.line('"' + scenario.escape(text) + '"')
+        end
+        
+        def literal text
+            scenario.literal text
+        end
+
+        def literal_no_format text
+            scenario.literal_no_format text
+        end
+    end
+    
+    class Receive < Block
+        def assertions
+            scenario.block 'assertions {', '}' do
+                yield Assertions.new(scenario)
+            end
+        end
+
+        def variables
+            scenario.block 'variables {', '}' do
+                yield Variables.new(scenario)
+            end
+        end
+    end
+    
+    class Assertions < Block
+        def create text
+            scenario.line(text)
+        end
+    end
+
+    class Variables < Block
+        def create text
+            scenario.line(text)
+        end
+    end
+
+end
+end

data/lib/mu/xmlizable.rb

@@ -0,0 +1,559 @@
+# 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