class XTemplate::XPath::Action

# File lib/xtemplate/xpath.rb, line 31
def _alt(name)
  @alts ||= {}
  @alts[name] = true
end

# File lib/xtemplate/xpath.rb, line 26
def _alt_exist?(name)
  @alts ||= {}
  @alts.key?(name)
end

# File lib/xtemplate/xpath.rb, line 36
def _unalt(name)
  @alts.delete(name)
end

# File lib/xtemplate/xpath.rb, line 40
def alt(val, *args)
  args.each{|arg|
    if( _alt_exist?(arg) )
      val = nil
    else
      _alt(arg)
    end
  }
  val
end

# File lib/xtemplate/xpath.rb, line 243
def array(val)
  if( val.is_a?(Enumerable) )
    newval = val.to_a
  else
    newval = val
  end
  newval
end

# File lib/xtemplate/xpath.rb, line 58
def attr(val, *args)
  case val
  when Hash
    newval = val.dup
    args.each{|a|
      a.strip!
      if( v = newval[a] )
        newval.delete(a)
        newval['@'+a] = v
      end
    }
    newval
  when Array
    val.collect{|v| attr(v, *args)}
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 427
def clear(val)
  []
end

# File lib/xtemplate/xpath.rb, line 421
def clear_stack(val, name)
  stack = ((Thread.current[:xtemplate] ||= [])[name.intern] ||= [])
  stack.clear
  val
end

# File lib/xtemplate/xpath.rb, line 119
def copy(val, x, y)
  case val
  when Hash
    newval = val.dup
    if( v = newval[x] )
      newval[y] = v
    end
    newval
  when Array
    val.collect{|v| copy(v, x, y)}
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 377
def delete(val, *args)
  case val
  when Hash
    newval = val.dup
    args.each{|s|
      s.strip!
      if( newval[s] )
        newval.delete(s)
      end
    }
    newval
  when Array
    val.collect{|v| delete(v, *args)}
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 347
def dump(val, name=nil)
  if( name )
    parent = XNode.new(name)
  else
    parent = XNode.new()
  end
  value_to_xml(val, parent)
  parent.to_s
end

# File lib/xtemplate/xpath.rb, line 321
def flatten(val)
  warn("The action 'flatten' and 'hash' will be obsoleted.")
  case val
  when Array
    newval = {}
    text   = ""
    val.each{|elem|
      case elem
      when Hash
        elem.each{|k,v|
          newval[k] = v
        }
      else
        text.concat(elem.to_s)
      end
    }
    if( text.size > 0 )
      newval[TextNode] = text
    end
  else
    newval = val
  end
  newval
end

# File lib/xtemplate/xpath.rb, line 222
def float(val)
  if( val[TextNode] )
    newval = val.dup
    newval[TextNode] = newval[TextNode].to_i
  else
    newval = val.to_f
  end
  newval
end

# File lib/xtemplate/xpath.rb, line 431
def import(val, *args)
  case args[0]
  when /^xml:\/\/(.+)/
    fn = $1
    doc = File.open(fn){|f|f.read}
    parser = XMLParser.new()
    node = parser.parse(doc)
    node.prepare()
    XMLDocument.new(node).to_hash
  when /^data:\/\/(.+)/
    fn = $1
    eval(File.open(fn){|f|f.read})
  when /^var:(.+)/
    eval($1)
  when /^yaml:\/\/(.+)/
    require 'xtemplate/yaml'
    fn = $1
    File.open(fn){|f|YAMLDocument.new(f)}
  when /^soap:\/\/(.+)/
    require 'soap/driver'
    args.shift
    endpoint  = $1
    namespace = args.shift
    if( namespace =~ /^\s*$/ )
      namespace = nil
    end
    obj = SOAP::Driver.new(nil, nil, namespace, "http://#{endpoint}")
    m = args.shift
    argv = args.collect{|s| eval_expr(s,val,nil) }
    i = -1
    obj.addMethod(m, *(argv.collect{ i+=1; "arg" + i.to_s }))
    obj.call(m, *argv)
  when /^xmlrpc:\/\/(.+)/
    require 'xmlrpc/client'
    m = args[1]
    argv = args[2..-1].collect{|s| eval_expr(s,val,nil) }
    client = XMLRPC::Client.new2("http://#{$1}")
    client.call(m, *argv)
  when /^dbi:(.+)/
    require 'dbi'
    h = DBI.connect("dbi:#{$1}")
    query = args[1..-1].collect{|s|s.gsub(/\#\{(.+)\}/){eval_expr($1,val,nil).to_s }}.join(',')
    newval = []
    h.execute(query){|sth|
      while( r = sth.fetch_hash )
        newval.push(r)
      end
    }
    newval
  else
    eval(args[0])
  end
end

# File lib/xtemplate/xpath.rb, line 290
def index(val, tag, ini=0)
  if( ini )
    if( ini =~ /^([1-9]\d*)$/ )
      ini = $1.to_i
    end
  end
  case val
  when Hash
    newval = val.dup
    newval[tag] = ini
  when Array
    newval = []
    idx = ini
    val.each{|v|
      case v
      when Hash
        v = v.dup
        v[tag] = idx
        newval.push(v)
      else
        v = {TextNode => v, tag => idx}
        newval.push(v)
      end
      idx = idx.succ
    }
  else
    newval = {tag => ini, TextNode => val}
  end
  newval
end

# File lib/xtemplate/xpath.rb, line 212
def int(val)
  if( val[TextNode] )
    newval = val.dup
    newval[TextNode] = newval[TextNode].to_i
  else
    newval = val.to_i
  end
  newval
end

# File lib/xtemplate/xpath.rb, line 97
def node(val)
  case val
  when Hash
    val.reject{|k,v| (k[0] == ?@ || k == TextNode)}
  when Array
    val.collect{|v| node(v)}
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 514
def p(val, out=nil)
  case out
  when "stdout"
    f = $stdout
  when "stderr"
    f = $stderr
  else
    f = $stdout
  end
  f.print(value_inspect(val),"\n")
  val
end

# File lib/xtemplate/xpath.rb, line 408
def pop(val, name)
  stack = ((Thread.current[:xtemplate] ||= [])[name.intern] ||= [])
  v = stack.pop
  [val, v].flatten
end

# File lib/xtemplate/xpath.rb, line 414
def pop_all(val, name)
  stack = ((Thread.current[:xtemplate] ||= [])[name.intern] ||= [])
  newval = [val, stack.dup].flatten
  stack.clear
  newval
end

# File lib/xtemplate/xpath.rb, line 395
def push(val, name)
  stack = ((Thread.current[:xtemplate] ||= {})[name.intern] ||= [])
  stack.push(val)
  case val
  when Hash
    {}
  when Array
    []
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 134
def rename(val, x, y)
  case val
  when Hash
    newval = val.dup
    if( v = newval[x] )
      newval[y] = v
      newval.delete(x)
    end
    newval
  when Array
    val.collect{|v| rename(v, x, y)}
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 369
def reverse(val)
  if( val.is_a?(Array) )
    val.reverse
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 358
def sanitize(val)
  s = String.new(val.to_s)
  __sanitize__(s)
end

# File lib/xtemplate/xpath.rb, line 279
def size(val)
  case val
  when Array
    val.size
  when nil
    0
  else
    1
  end
end

# File lib/xtemplate/xpath.rb, line 182
def sort(val, path=nil)
  if( val.is_a?(Array) )
    if( path )
      newval = val.sort{|x,y|
        path.split("/").each{|key|
          key.strip!
          if( x.is_a?(Hash) && y.is_a?(Hash) )
            x,y = x[key], y[key]
          end
        }
        if( x.is_a?(Comparable) && y.is_a?(Comparable) )
          x <=> y
        else
          0
        end
      }
    else
      newval = val.sort{|x,y|
        if( x && y )
          x <=> y
        else
          0
        end
      }
    end
  else
    val
  end
end

# File lib/xtemplate/xpath.rb, line 233
def string(val)
  if( val[TextNode] )
    newval = val.dup
    newval[TextNode] = newval[TextNode].to_i
  else
    newval = val.to_s
  end
  newval
end

# File lib/xtemplate/xpath.rb, line 252
def strip(val)
  case val
  when Hash
    if( val[TextNode] )
      newval = val.dup()
      newval[TextNode] = newval[TextNode].strip()
    else
      newval = val
    end
  when Array
    newval = val.reject{|v|
      case v
      when Hash, Array
        false
      else
        v.to_s() =~ /\A\s*\z/
      end
    }
  else
    newval = val.to_s().strip()
    if( newval.size == 0 )
      newval = nil
    end
  end
  newval
end

# File lib/xtemplate/xpath.rb, line 150
def tag(val, tag)
  case val
  when Hash
    newval = val.dup
    if( v = newval[TextNode] )
      newval[tag] = v
      newval.delete(TextNode)
    end
    newval
  when Array
    val.collect{|v| tag(v, tag)}
  else
    {tag => val}
  end
end

# File lib/xtemplate/xpath.rb, line 108
def text(val)
  case val
  when Hash
    val[TextNode]
  when Array
    val.collect{|v| text(v)}
  else
    val
  end
end

# File lib/xtemplate/xpath.rb, line 485
def time(val, fmt, tag=nil)
  if( tag )
    case val
    when Array
      val.collect{|v| time(v, fmt, tag)}
    when Hash
      str = Time.now.strftime(fmt)
      newval = val.dup
      tag ||= TextNode
      newval[tag] = str
      newval
    else
      if( val )
        str = Time.now.strftime(fmt)
        newval = {
          tag => str,
          TextNode => val,
        }
        newval
      else
        nil
      end
    end
  else
    Time.now.strftime(fmt)
  end
end

# File lib/xtemplate/xpath.rb, line 51
def unalt(val, *args)
  args.each{|arg|
    _unalt(arg)
  }
  val
end

# File lib/xtemplate/xpath.rb, line 77
def unattr(val, *args)
  case val
  when Hash
    newval = val.dup
    args.each{|a|
      a.strip!
      k = '@'+a
      if( v = newval[k] )
        newval.delete(k)
        newval[a] = v
      end
    }
    newval
  when Array
    val.collect{|v| unattr(v, *args)}
  else
    nil
  end
end

# File lib/xtemplate/xpath.rb, line 364
def unsanitize(val)
  s = SanitizedString[val.to_s]
  SanitizedString[__unsanitize__(s)]
end

# File lib/xtemplate/xpath.rb, line 166
def untag(val, tag)
  case val
  when Hash
    newval = val.dup
    if( v = newval[tag] )
      newval[TextNode] = v
      newval.delete(tag)
    end
    newval
  when Array
    val.collect{|v| untag(v,tag)}
  else
    nil
  end
end