Module: REXML::Functions

UNTESTED

# 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

ceiling( number )

[Source]

# File rexml/functions.rb, line 355
    def Functions::ceiling( number )
      number(number).ceil
    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

concat( *objects )

UNTESTED

[Source]

# File rexml/functions.rb, line 140
    def Functions::concat( *objects )
      objects.join
    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

count( node_set )

[Source]

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

false( )

UNTESTED

[Source]

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

floor( number )

[Source]

# File rexml/functions.rb, line 351
    def Functions::floor( number )
      number(number).floor
    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

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

index()

[Source]

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

index=(value)

[Source]

# File rexml/functions.rb, line 17
    def Functions::index=(value); @@index = value; 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

last( )

[Source]

# File rexml/functions.rb, line 39
    def Functions::last( )
      @@size
    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

method_missing( id )

[Source]

# File rexml/functions.rb, line 367
    def Functions::method_missing( id )
      puts "METHOD MISSING #{id.id2name}"
      XPath.match( @@node, id.id2name )
    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

namespace_context()

[Source]

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

namespace_context=(value)

[Source]

# File rexml/functions.rb, line 20
    def Functions::namespace_context=(value)
      @@namespace_context = value
    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

node()

[Source]

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

node=(value)

[Source]

# File rexml/functions.rb, line 16
    def Functions::node=(value); @@node = value; 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

not( object )

UNTESTED

[Source]

# File rexml/functions.rb, line 277
    def Functions::not( object )
      not boolean( object )
    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
        number(string( object ))
      elsif object.kind_of? Float
        object
      else
        str = string( object )
        #puts "STRING OF #{object.inspect} = #{str}"

        if str =~ /^\d+/
          object.to_s.to_f
        else
          (0.0 / 0.0)
        end
      end
    end

position( )

[Source]

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

round( number )

[Source]

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

size()

[Source]

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

size=(value)

[Source]

# File rexml/functions.rb, line 18
    def Functions::size=(value); @@size = value; 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

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

string_length( string )

UNTESTED

[Source]

# File rexml/functions.rb, line 211
    def Functions::string_length( string )
      string(string).length
    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

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_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

sum( nodes )

[Source]

# File rexml/functions.rb, line 348
    def Functions::sum( nodes )
    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

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

true( )

UNTESTED

[Source]

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

variables()

[Source]

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

variables=(value)

[Source]

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

Methods

Public Class methods