123456789_123456789_123456789_123456789_123456789_

Module: REXML::Functions

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Included In:
QuickPath, XPath
Defined in: lib/rexml/functions.rb

Overview

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()”

Constant Summary

Class Attribute Summary

Class Method Summary

Class Attribute Details

.context=(value) (writeonly)

[ GitHub ] 

  


# File 'lib/rexml/functions.rb', line 38



def Functions::context=(value); @@context = value; end


  








  

    .namespace_context   (rw)
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 35



def Functions::namespace_context ; @@namespace_context ; end


  








  

    .namespace_context=(x)   (rw)
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 33



def Functions::namespace_context=(x) ; @@namespace_context=x ; end


  








  

    .variables   (rw)
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 36



def Functions::variables ; @@variables ; end


  








  

    .variables=(x)   (rw)
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 34



def Functions::variables=(x) ; @@variables=x ; end


  







Class Method Details



  

    .boolean(object = nil)  
  



  

    

UNTESTED


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 322



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)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 418



def Functions::ceiling( number )
  number(number).ceil
end


  








  

    .compare_language(lang1, lang2)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 369



def Functions::compare_language lang1, lang2
  lang2.downcase.index(lang1.downcase) == 0
end


  








  

    .concat(*objects)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 193



def Functions::concat( *objects )
  concatenated = ""
  objects.each do |object|
    concatenated << string(object)
  end
  concatenated
end


  








  

    .contains(string, test)  
  



  

    

Fixed by Mike Stok


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 207



def Functions::contains( string, test )
  string(string).include?(string(test))
end


  








  

    .count(node_set)  
  



  

    

Returns the size of the given list of nodes.


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 60



def Functions::count( node_set )
  node_set.size
end


  








  

    .false  
  



  

    

UNTESTED


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 346



def Functions::false(  )
  false
end


  








  

    .floor(number)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 414



def Functions::floor( number )
  number(number).floor
end


  








  

    .get_namespace(node_set = nil)  
  



  

    

Helper method.


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 87



def Functions::get_namespace( node_set = nil )
  if node_set == nil
    yield @@context[:node] if @@context[:node].respond_to?(:namespace)
  else
    if node_set.respond_to? :each
      result = []
      node_set.each do |node|
        result << yield(node) if node.respond_to?(:namespace)
      end
      result
    elsif node_set.respond_to? :namespace
      yield node_set
    end
  end
end


  








  

    .id(object)  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 66



def Functions::id( object )
end


  








  

    .lang(language)  
  



  

    

UNTESTED


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 351



def Functions::lang( language )
  lang = false
  node = @@context[: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  
  



  

    

Returns the last node of the given list of nodes.


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 51



def Functions::last( )
  @@context[:size]
end


  








  

    .local_name(node_set = nil)  
  



  

    

UNTESTED


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 70



def Functions::local_name( node_set=nil )
  get_namespace( node_set ) do |node|
    return node.local_name
  end
end


  








  

    .name(node_set = nil)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 80



def Functions::name( node_set=nil )
  get_namespace( node_set ) do |node|
    node.expanded_name
  end
end


  








  

    .namespace_uri(node_set = nil)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 76



def Functions::namespace_uri( node_set=nil )
  get_namespace( node_set ) {|node| node.namespace}
end


  








  

    .normalize_space(string = nil)  
  



  

    

UNTESTED


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 269



def Functions::normalize_space( string=nil )
  string = string(@@context[: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


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 336



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


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 386



def Functions::number( object=nil )
  object = @@context[:node] unless object
  case object
  when true
    Float(1)
  when false
    Float(0)
  when Array
    number(string( object ))
  when Numeric
    object.to_f
  else
    str = string( object )
    # If XPath ever gets scientific notation...
    #if str =~ /^\s*-?(\d*\.?\d|\d\.)([Ee]\d*)?\s*$/
    if str =~ /^\s*-?(\d*\.?\d|\d\.)\s*$/
      str.to_f
    else
      (0.0 / 0.0)
    end
  end
end


  








  

    .position  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 55



def Functions::position( )
  @@context[:index]
end


  








  

    .processing_instruction(node)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 433



def Functions::processing_instruction( node )
  node.node_type == :processing_instruction
end


  








  

    .round(number)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 422



def Functions::round( number )
  number = number(number)
  begin
    neg = number.negative?
    number = number.abs.round
    neg ? -number : number
  rescue FloatDomainError
    number
  end
end


  








  

    .send(name, *args)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 437



def Functions::send(name, *args)
  if @@available_functions[name.to_sym]
    super
  else
    # TODO: Maybe, this is not XPath spec behavior.
    # This behavior must be reconsidered.
    XPath.match(@@context[:node], name.to_s)
  end
end


  








  

    .singleton_method_added(name)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 26



def singleton_method_added(name)
  unless INTERNAL_METHODS.include?(name)
    @@available_functions[name] = true
  end
end


  








  

    .starts_with(string, test)  
  



  

    

Fixed by Mike Stok


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 202



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.


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 138



def Functions::string( object=nil )
  object = @@context[:node] if object.nil?
  if object.respond_to?(:node_type)
    case object.node_type
    when :attribute
      object.value
    when :element
      string_value(object)
    when :document
      string_value(object.root)
    when :processing_instruction
      object.content
    else
      object.to_s
    end
  else
    case object
    when Array
      string(object[0])
    when Float
      if object.nan?
        "NaN"
      else
        integer = object.to_i
        if object == integer
          "%d" % integer
        else
          object.to_s
        end
      end
    when nil
      ""
    else
      object.to_s
    end
  end
end


  








  

    .string_length(string)  
  



  

    

UNTESTED


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 264



def Functions::string_length( string )
  string(string).length
end


  








  

    .string_value(o)  
  



  

    

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


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 181



def Functions::string_value( o )
  rv = ""
  o.children.each { |e|
    if e.node_type == :text
      rv << e.to_s
    elsif e.node_type == :element
      rv << string_value( e )
    end
  }
  rv
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.


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 231



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 = round(ruby_start) - 1
  ruby_length = round(ruby_length)

  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


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 223



def Functions::substring_after( string, test )
  ruby_string = string(string)
  return $1 if ruby_string =~ /#{test}(.*)/
  ""
end


  








  

    .substring_before(string, test)  
  



  

    

Kouhei fixed this


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 212



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)  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 409



def Functions::sum( nodes )
  nodes = [nodes] unless nodes.kind_of? Array
  nodes.inject(0) { |r,n| r + number(string(n)) }
end


  








  

    .text  
  

  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 40



def Functions::text( )
  if @@context[:node].node_type == :element
    return @@context[:node].find_all{|n| n.node_type == :text}.collect{|n| n.value}
  elsif @@context[:node].node_type == :text
    return @@context[:node].value
  else
    return false
  end
end


  








  

    .translate(string, tr1, tr2)  
  



  

    

This is entirely Mike Stok’s beast


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 279



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 character 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
  }

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


  








  

    .true  
  



  

    

UNTESTED


  



  [ GitHub ]


  

  


# File 'lib/rexml/functions.rb', line 341



def Functions::true( )
  true
end