REXML::Functions

 
               # File rexml/functions.rb, line 321
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
            

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

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

 
               # File rexml/functions.rb, line 192
def Functions::concat( *objects )
  concatenated = ""
  objects.each do |object|
    concatenated << string(object)
  end
  concatenated
end
            

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

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

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

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

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

 
               # File rexml/functions.rb, line 86
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
            

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

 
               # File rexml/functions.rb, line 350
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
            

 
               # File rexml/functions.rb, line 50
def Functions::last( )
  @@context[:size]
end
            

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

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

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

 
               # File rexml/functions.rb, line 32
def Functions::namespace_context=(x) ; @@namespace_context=x ; end
            

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

 
               # File rexml/functions.rb, line 268
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
            

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

 
               # File rexml/functions.rb, line 385
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
            

 
               # File rexml/functions.rb, line 54
def Functions::position( )
  @@context[:index]
end
            

 
               # File rexml/functions.rb, line 432
def Functions::processing_instruction( node )
  node.node_type == :processing_instruction
end
            

 
               # File rexml/functions.rb, line 421
def Functions::round( number )
  number = number(number)
  begin
    neg = number.negative?
    number = number.abs.round
    neg ? -number : number
  rescue FloatDomainError
    number
  end
end
            

 
               # File rexml/functions.rb, line 436
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
            

 
               # File rexml/functions.rb, line 25
def singleton_method_added(name)
  unless INTERNAL_METHODS.include?(name)
    @@available_functions[name] = true
  end
end
            

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

 
               # File rexml/functions.rb, line 137
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
            

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

 
               # File rexml/functions.rb, line 180
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
            

 
               # File rexml/functions.rb, line 230
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
            

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

 
               # File rexml/functions.rb, line 211
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
            

 
               # File rexml/functions.rb, line 408
def Functions::sum( nodes )
  nodes = [nodes] unless nodes.kind_of? Array
  nodes.inject(0) { |r,n| r + number(string(n)) }
end
            

 
               # File rexml/functions.rb, line 39
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
            

 
               # File rexml/functions.rb, line 278
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
            

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

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

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