# REXML::Functions (Module)

In: | rexml/functions.rb

If you add a method, keep in mind two things: (1) the first argument will always be a list of nodes from which to filter. In the case of context methods (such as position), the function should return an array with a value for each child in the array. (2) all method calls from XML will have "-" replaced with "_". Therefore, in XML, "local-name()" is identical (and actually becomes) "local_name()"

## Methods

boolean ceiling compare_language concat contains count false floor get_namespace id index index= lang last local_name method_missing name namespace_context namespace_context= namespace_uri node node= normalize_space not number position round size size= starts_with string string_length substring substring_after substring_before sum text translate true variables variables=

## Public Class methods

node=(value)

[Source]

    # File rexml/functions.rb, line 16
                    def Functions::node=(value); @@node = value; end

index=(value)

[Source]

    # File rexml/functions.rb, line 17
                    def Functions::index=(value); @@index = value; end

size=(value)

[Source]

    # File rexml/functions.rb, line 18
                    def Functions::size=(value); @@size = value; end

variables=(value)

[Source]

    # File rexml/functions.rb, line 19
                    def Functions::variables=(value); @@variables = value; end

namespace_context=(value)

[Source]

    # File rexml/functions.rb, line 20
                    def Functions::namespace_context=(value)
                            @@namespace_context = value
                    end

node()

[Source]

    # File rexml/functions.rb, line 23
                    def Functions::node; @@node; end

index()

[Source]

    # File rexml/functions.rb, line 24
                    def Functions::index; @@index; end

size()

[Source]

    # File rexml/functions.rb, line 25
                    def Functions::size; @@size; end

variables()

[Source]

    # File rexml/functions.rb, line 26
                    def Functions::variables; @@variables; end

namespace_context()

[Source]

    # File rexml/functions.rb, line 27
                    def Functions::namespace_context; @@namespace_context; end

text( )

[Source]

    # File rexml/functions.rb, line 29
                    def Functions::text( )
                            if @@node.node_type == :element
                                    return @@node.text
                            elsif @@node.node_type == :text
                                    return @@node.value
                            else
                                    return false
                            end
                    end

last( )

[Source]

    # File rexml/functions.rb, line 39
                    def Functions::last( )
                            @@size
                    end

position( )

[Source]

    # File rexml/functions.rb, line 43
                    def Functions::position( )
                            @@index
                    end

count( node_set )

[Source]

    # File rexml/functions.rb, line 47
                    def Functions::count( node_set )
                            node_set.size
                    end

id( object )

Since REXML is non-validating, this method is not implemented as it requires a DTD

[Source]

    # File rexml/functions.rb, line 53
                    def Functions::id( object )
                    end

local_name( node_set=nil )

UNTESTED

[Source]

    # File rexml/functions.rb, line 57
                    def Functions::local_name( node_set=nil )
                            get_namespace( node_set ) do |node|
                                    return node.local_name
                            end
                    end

namespace_uri( node_set=nil )

[Source]

    # File rexml/functions.rb, line 63
                    def Functions::namespace_uri( node_set=nil )
                            get_namespace( node_set ) {|node| node.namespace}
                    end

name( node_set=nil )

[Source]

    # File rexml/functions.rb, line 67
                    def Functions::name( node_set=nil )
                            get_namespace( node_set ) do |node|
                                    node.expanded_name
                            end
                    end

get_namespace( node_set = nil ) {|@@node if defined? @@node.namespace| ...}

Helper method.

[Source]

    # File rexml/functions.rb, line 74
                    def Functions::get_namespace( node_set = nil )
                            if node_set == nil
                                    yield @@node if defined? @@node.namespace
                            else
                                    if node_set.namespace
                                            yield node_set
                                    else
                                            return unless node_set.kind_of? Enumerable
                                            node_set.each { |node| yield node if defined? node.namespace }
                                    end
                            end
                    end

string( object=nil )

A node-set is converted to a string by returning the string-value of the node in the node-set that is first in document order. If the node-set is empty, an empty string is returned.

A number is converted to a string as follows

NaN is converted to the string NaN

positive zero is converted to the string 0

negative zero is converted to the string 0

positive infinity is converted to the string Infinity

negative infinity is converted to the string -Infinity

if the number is an integer, the number is represented in decimal form as a Number with no decimal point and no leading zeros, preceded by a minus sign (-) if the number is negative

otherwise, the number is represented in decimal form as a Number including a decimal point with at least one digit before the decimal point and at least one digit after the decimal point, preceded by a minus sign (-) if the number is negative; there must be no leading zeros before the decimal point apart possibly from the one required digit immediately before the decimal point; beyond the one required digit after the decimal point there must be as many, but only as many, more digits as are needed to uniquely distinguish the number from all other IEEE 754 numeric values.

The boolean false value is converted to the string false. The boolean true value is converted to the string true.

An object of a type other than the four basic types is converted to a string in a way that is dependent on that type.

[Source]

    # File rexml/functions.rb, line 122
                    def Functions::string( object=nil )
                            #object = @context unless object

                            if object.instance_of? Array
                                    string( object[0] )
                            elsif defined? object.node_type
                                    if object.node_type == :attribute
                                            object.value
                                    elsif object.node_type == :element
                                            object.text
                                    else
                                            object.to_s
                                    end
                            else
                                    object.to_s
                            end
                    end

concat( *objects )

UNTESTED

[Source]

    # File rexml/functions.rb, line 140
                    def Functions::concat( *objects )
                            objects.join
                    end

starts_with( string, test )

Fixed by Mike Stok

[Source]

    # File rexml/functions.rb, line 145
                    def Functions::starts_with( string, test )
                            string(string).index(string(test)) == 0
                    end

contains( string, test )

Fixed by Mike Stok

[Source]

    # File rexml/functions.rb, line 150
                    def Functions::contains( string, test )
                            string(string).include? string(test)
                    end

substring_before( string, test )

Kouhei fixed this

[Source]

    # File rexml/functions.rb, line 155
                    def Functions::substring_before( string, test )
                            ruby_string = string(string)
                            ruby_index = ruby_string.index(string(test))
                            if ruby_index.nil?
                                    ""
                            else
                                    ruby_string[ 0...ruby_index ]
                            end
                    end

substring_after( string, test )

Kouhei fixed this too

[Source]

    # File rexml/functions.rb, line 166
                    def Functions::substring_after( string, test )
                            ruby_string = string(string)
                            ruby_index = ruby_string.index(string(test))
                            if ruby_index.nil?
                                    ""
                            else
                                    ruby_string[ ruby_index+1..-1 ]
                            end
                    end

substring( string, start, length=nil )

Take equal portions of Mike Stok and Sean Russell; mix vigorously, and pour into a tall, chilled glass. Serves 10,000.

[Source]

    # File rexml/functions.rb, line 178
                    def Functions::substring( string, start, length=nil )
                            ruby_string = string(string)
                            ruby_length = if length.nil?
                                                                                            ruby_string.length.to_f
                                                                                    else
                                                                                            number(length)
                                                                                    end
                            ruby_start = number(start)

                            # Handle the special cases

                            return '' if (
                                    ruby_length.nan? or
                                    ruby_start.nan? or
                                    ruby_start.infinite?
                            )

                            infinite_length = ruby_length.infinite? == 1
                            ruby_length = ruby_string.length if infinite_length

                            # Now, get the bounds.  The XPath bounds are 1..length; the ruby bounds

                            # are 0..length.  Therefore, we have to offset the bounds by one.

                            ruby_start = ruby_start.round - 1
                            ruby_length = ruby_length.round

                            if ruby_start < 0
                             ruby_length += ruby_start unless infinite_length
                             ruby_start = 0
                            end
                            return '' if ruby_length <= 0
                            ruby_string[ruby_start,ruby_length]
                    end

string_length( string )

UNTESTED

[Source]

    # File rexml/functions.rb, line 211
                    def Functions::string_length( string )
                            string(string).length
                    end

normalize_space( string=nil )

UNTESTED

[Source]

    # File rexml/functions.rb, line 216
                    def Functions::normalize_space( string=nil )
                            string = string(@@node) if string.nil?
                            if string.kind_of? Array
                                    string.collect{|x| string.to_s.strip.gsub(/\s+/um, ' ') if string}
                            else
                                    string.to_s.strip.gsub(/\s+/um, ' ')
                            end
                    end

translate( string, tr1, tr2 )

This is entirely Mike Stok’s beast

[Source]

    # File rexml/functions.rb, line 226
                    def Functions::translate( string, tr1, tr2 )
                            from = string(tr1)
                            to = string(tr2)

                            # the map is our translation table.

                            #

                            # if a character occurs more than once in the

                            # from string then we ignore the second &

                            # subsequent mappings

                            #

                            # if a charactcer maps to nil then we delete it

                            # in the output.  This happens if the from

                            # string is longer than the to string

                            #

                            # there's nothing about - or ^ being special in

                            # http://www.w3.org/TR/xpath#function-translate

                            # so we don't build ranges or negated classes

                            map = Hash.new
                            0.upto(from.length - 1) { |pos|
                                    from_char = from[pos]
                                    unless map.has_key? from_char
                                            map[from_char] =
                                            if pos < to.length
                                                    to[pos]
                                            else
                                                    nil
                                            end
                                    end
                            }

                            string(string).unpack('U*').collect { |c|
                                    if map.has_key? c then map[c] else c end
                            }.compact.pack('U*')
                    end

boolean( object=nil )

UNTESTED

[Source]

    # File rexml/functions.rb, line 263
                    def Functions::boolean( object=nil )
                            if object.kind_of? String
                                    if object =~ /\d+/u
                                            return object.to_f != 0
                                    else
                                            return object.size > 0
                                    end
                            elsif object.kind_of? Array
                                    object = object.find{|x| x and true}
                            end
                            return object ? true : false
                    end

not( object )

UNTESTED

[Source]

    # File rexml/functions.rb, line 277
                    def Functions::not( object )
                            not boolean( object )
                    end

true( )

UNTESTED

[Source]

    # File rexml/functions.rb, line 282
                    def Functions::true( )
                            true
                    end

false( )

UNTESTED

[Source]

    # File rexml/functions.rb, line 287
                    def Functions::false(  )
                            false
                    end

lang( language )

UNTESTED

[Source]

    # File rexml/functions.rb, line 292
                    def Functions::lang( language )
                            lang = false
                            node = @@node
                            attr = nil
                            until node.nil?
                                    if node.node_type == :element
                                            attr = node.attributes["xml:lang"]
                                            unless attr.nil?
                                                    lang = compare_language(string(language), attr)
                                                    break
                                            else
                                            end
                                    end
                                    node = node.parent
                            end
                            lang
                    end

compare_language(lang1, lang2)

[Source]

    # File rexml/functions.rb, line 310
                    def Functions::compare_language lang1, lang2
                            lang2.downcase.index(lang1.downcase) == 0
                    end

number( object=nil )

a string that consists of optional whitespace followed by an optional minus sign followed by a Number followed by whitespace is converted to the IEEE 754 number that is nearest (according to the IEEE 754 round-to-nearest rule) to the mathematical value represented by the string; any other string is converted to NaN

boolean true is converted to 1; boolean false is converted to 0

a node-set is first converted to a string as if by a call to the string function and then converted in the same way as a string argument

an object of a type other than the four basic types is converted to a number in a way that is dependent on that type

[Source]

    # File rexml/functions.rb, line 327
                    def Functions::number( object=nil )
                            object = @@node unless object
                            if object == true
                                    Float(1)
                            elsif object == false
                                    Float(0)
                            elsif object.kind_of? Array
                                    string( object ).to_f
                            elsif object.kind_of? Float
                                    object
                            else
                                    object.to_s.to_f
                            end
                    end

sum( nodes )

[Source]

    # File rexml/functions.rb, line 342
                    def Functions::sum( nodes )
                    end

floor( number )

[Source]

    # File rexml/functions.rb, line 345
                    def Functions::floor( number )
                            number(number).floor
                    end

ceiling( number )

[Source]

    # File rexml/functions.rb, line 349
                    def Functions::ceiling( number )
                            number(number).ceil
                    end

round( number )

[Source]

    # File rexml/functions.rb, line 353
                    def Functions::round( number )
                            begin
                                    number(number).round
                            rescue FloatDomainError
                                    number(number)
                            end
                    end

method_missing( id )

[Source]

    # File rexml/functions.rb, line 361
                    def Functions::method_missing( id )
                            puts "METHOD MISSING #{id.id2name}"
                            XPath.match( @@node, id.id2name )
                    end

[Validate]