vcdom 0.3.0 → 0.3.1

data/lib/vcdom/xpath/internal/parser.rb

@@ -0,0 +1,333 @@
+# coding : utf-8
+
+require "strscan"
+
+require "vcdom/xpath/xpath_expression"
+require "vcdom/xpath/xpath_result"
+require "vcdom/xpath/internal/value"
+require "vcdom/xpath/internal/expr"
+require "vcdom/xpath/internal/command"
+
+module VCDOM::XPath::Internal # :nodoc:
+  
+  class Parser # :nodoc: all
+    
+    regexp_str_creating_proc = lambda { |*args|
+      args.length == 1 ? [ args[0] ].pack( "U1" ) : [ args[0], 0x2D, args[1] ].pack( "U3" )
+    }
+    
+    xml_name_start_char = [
+      [ 0xC0, 0xD6 ],
+      [ 0xD8, 0xF6 ],
+      [ 0xF8, 0x2FF ],
+      [ 0x370, 0x37D ],
+      [ 0x37F, 0x1FFF ],
+      [ 0x200C, 0x200D ],
+      [ 0x2070, 0x218F ],
+      [ 0x2C00, 0x2FEF ],
+      [ 0x3001, 0xD7FF ],
+      [ 0xF900, 0xFDCF ],
+      [ 0xFDF0, 0xFFFD ],
+      [ 0x10000, 0xEFFFF ]
+    ].inject( String.new( "_a-zA-Z" ) ) do |s,pair|
+      s << regexp_str_creating_proc.call( *pair )
+    end
+    
+    xml_name_char = [
+      [ 0xB7 ],
+      [ 0x0300, 0x036F ],
+      [ 0x203F, 0x2040 ]
+    ].inject( String.new( xml_name_start_char + "\\-\\.\\d" ) ) do |s,pair|
+      s << regexp_str_creating_proc.call( *pair )
+    end
+    
+    xml_nc_name    = "[#{xml_name_start_char}][#{xml_name_char}]*"
+    xml_q_name     = "(?:#{xml_nc_name}:)?#{xml_nc_name}"
+    xpath_literal  = "\"[^\"]*\"|'[^']*'"
+    xpath_operator = "\\/?\\/|\\||\\+|\\-|=|\\!=|<=?|>=?"
+    xpath_sign     = "\\(|\\)|\\[|\\]|\\.\\.?|@|,|::"
+    xpath_number   = "\\d+(?:\\.\\d*)?|\\.\\d+"
+    #xpath_varref   = "\\$#{xml_q_name}"  # varref は anyname と結合
+    xpath_anyname  = "(?:#{xml_nc_name}:)?\\*|\\$?#{xml_q_name}"
+    #XML_NC_NAME_REGEXP = /#{xml_nc_name}/u
+    #XML_Q_NAME_REGEXP  = /(?:#{xml_nc_name}:)?#{xml_nc_name}/u
+    
+    xpath_token = xpath_literal + "|" + xpath_number + "|" + xpath_anyname + "|" + xpath_operator + "|" + xpath_sign
+    
+    XML_Q_NAME = /#{xml_q_name}/u
+    XPATH_TOKEN_REGEXP = /#{xpath_token}/u
+    XPATH_WHITE_SPACE_REGEXP = /[\x20\x0A\x0D\x09]+/u
+    
+    #def next_token()
+    #  @scanner.skip XPATH_WHITE_SPACE_REGEXP
+    #  if ( token = @scanner.scan XPATH_TOKEN_REGEXP ).nil? then
+    #    raise "Invalid XPath expression" unless @scanner.eos?
+    #  end
+    #  token
+    #end
+    
+    class XPathStringScanner < StringScanner
+      XPATH_WHITE_SPACE_REGEXP = /[\x20\x0A\x0D\x09]+/u
+      def scan( regexp )
+        skip XPATH_WHITE_SPACE_REGEXP
+        super( regexp )
+      end
+      def check( regexp )
+        skip XPATH_WHITE_SPACE_REGEXP
+        super( regexp )
+      end
+    end
+    
+    def initialize( xpath_str, ns_resolver )
+      @scanner = XPathStringScanner.new( xpath_str )
+      @ns_resolver = ns_resolver
+    end
+    
+    def parse()
+      expr = parse_expr()
+      raise "invalid xpath [#{@scanner.rest}]" unless @scanner.eos?
+      expr
+    end
+    
+    def parse_expr()
+      parse_or_expr()
+    end
+    
+    def parse_or_expr()
+      expr = parse_and_expr()
+      if @scanner.check( /or/u ) then
+        tmp = expr
+        expr = OrExpr.new()
+        expr << tmp
+        while @scanner.scan( /or/u ) do
+          expr << parse_and_expr()
+        end
+      end
+      expr
+    end
+    
+    def parse_and_expr()
+      expr = parse_equality_expr()
+      if token = @scanner.check( /and/u ) then
+        tmp = expr
+        expr = AndExpr.new()
+        expr << tmp
+        while @scanner.scan( /and/u ) do
+          expr << parse_equality_expr()
+        end
+      end
+      expr
+    end
+    
+    def parse_equality_expr()
+      expr = VCDOM::XPath::Internal::EqualityExpr.new()
+      parse_relational_expr( expr )
+      while token = @scanner.scan( /=|\!=/u ) do
+        parse_relational_expr( expr )
+        expr << VCDOM::XPath::Internal.get_operation_command( token.intern )
+      end
+      expr
+    end
+    
+    def parse_relational_expr( expr )
+      parse_additive_expr( expr )
+      while token = @scanner.scan( /\<=?|\>=?/u ) do
+        parse_additive_expr( expr )
+        expr << VCDOM::XPath::Internal.get_operation_command( token.intern )
+      end
+    end
+    
+    def parse_additive_expr( expr )
+      parse_multiplicative_expr( expr )
+      while token = @scanner.scan( /\+|\-/u ) do
+        parse_multiplicative_expr( expr )
+        expr << VCDOM::XPath::Internal.get_operation_command( token.intern )
+      end
+    end
+    
+    def parse_multiplicative_expr( expr )
+      parse_unary_expr( expr )
+      while token = @scanner.scan( /\*|div|mod/u ) do
+        parse_unary_expr( expr )
+        expr << VCDOM::XPath::Internal.get_operation_command( token.intern )
+      end
+    end
+    
+    def parse_unary_expr( expr )
+      num = 0
+      while @scanner.scan( /\-/u ) do
+        num += 1
+      end
+      parse_union_expr( expr )
+      num.times do
+        expr << VCDOM::XPath::Internal.get_operation_command( :"-@" )
+      end
+    end
+    
+    def parse_union_expr( expr )
+      parse_path_expr( expr )
+      while @scanner.scan( /\|/u ) do
+        parse_path_expr( expr )
+        expr << VCDOM::XPath::Internal.get_operation_command( :"|" )
+      end
+    end
+    
+    XPATH_PATH_EXPR_STARTER_REGEXP = /#{xpath_number}|#{xpath_literal}|#{xpath_anyname}|\/\/?|\.\.?|@|\(/u
+    XPATH_VARIABLE_REFERENCE_REGEXP = /\$#{xml_q_name}/u
+    XPATH_NUMBER_REGEXP  = /#{xpath_number}/u
+    XPATH_LITERAL_REGEXP = /#{xpath_literal}/u
+    XPATH_NAME_TEST = /(?:#{xml_nc_name}:)?\*|#{xml_q_name}/u
+    XPATH_STEP_STARTER_REGEXP = /\*|\.\.?|@|#{xml_q_name}/u
+    # VariableReference
+    # '(' Expr ')'
+    # Literal
+    # Number
+    # FunctionCall
+    def parse_path_expr( expr )
+      is_path = false
+      if token = @scanner.scan( XPATH_NUMBER_REGEXP ) then
+        # Number の場合
+        expr << VCDOM::XPath::Internal::NumberValue.new( token.to_f() )
+      elsif token = @scanner.scan( XPATH_LITERAL_REGEXP) then
+        # Literal の場合
+        token[0,1]  = ""
+        token[-1,1] = ""
+        expr << VCDOM::XPath::Internal::StringValue.new( token )
+      elsif token = @scanner.scan( XPATH_VARIABLE_REFERENCE_REGEXP ) then
+        # VariableReference の場合
+        raise "VariableReference is not supported"
+      elsif @scanner.scan( /\(/u ) then
+        # "(" Expr ")" の場合
+        expr << VCDOM::XPath::Internal::ExprEvalCommand.new( parse_expr() )
+        raise "invalid xpath expression" unless @scanner.scan( /\)/u )
+      else
+        # Path or FunctionCall
+        pos = @scanner.pos
+        is_path = true
+        if token = @scanner.scan( XML_Q_NAME ) then
+          # FunctionName or AxisName or NameTest or NodeType
+          if @scanner.scan( /\(/u ) then
+            # FunctionName or NodeType
+            case token
+            when "comment", "text", "processing-instruction", "node"
+              # do nothing
+            else
+              # FunctionName
+              is_path = false
+            end
+          end
+        end
+        if is_path then
+          # Path
+          @scanner.pos = pos
+          if token = @scanner.scan( /\/\/?/u ) then
+            # "/" or "//"
+            expr << VCDOM::XPath::Internal::RootNodeCommand.get_instance()
+            if token == "/" then
+              # 続く要素がなければここで終了
+              return unless @scanner.check( XPATH_STEP_STARTER_REGEXP )
+            else # "//"
+              expr << VCDOM::XPath::Internal::NodeSelectionCommand.new( :"descendant-or-self", :node, nil, nil, nil )
+            end
+          else
+            expr << VCDOM::XPath::Internal::ContextNodeCommand.get_instance()
+          end
+          expr << parse_step()
+        else
+          # FunctionCall
+          function_name = token.intern
+          arg_exprs = @scanner.check( /\)/u ) ? nil : parse_expr_list()
+          raise "invalid xpath [#{@scanner.rest}]" unless @scanner.scan( /\)/u )
+          expr << FunctionCallCommand.new( function_name, arg_exprs )
+        end
+      end
+      if not is_path then
+        if @scanner.check( /\[/u ) then
+          pred_exprs = parse_predicates()
+          expr << PredsEvalCommand.new( pred_exprs )
+        end
+      end
+      while token = @scanner.scan( /\/\/?/ ) do
+        if token == "//" then
+          expr << VCDOM::XPath::Internal::NodeSelectionCommand.new( :"descendant-or-self", :node, nil, nil, nil )
+        end
+        expr << parse_step()
+      end
+    end
+    
+    AXIS_NAME_LIST = [ :'ancestor', :'ancestor-or-self', :'attribute', :'child', :'descendant', :'descendant-or-self', 
+          :'following', :'following-sibling', :'namespace', :'parent', :'preceding', :'preceding-sibling', :'self' ]
+    NODE_TYPE_LIST = [ :'comment', :'text', :'processing-instruction', :'node' ]
+    def parse_step()
+      # "." or ".."
+      if @scanner.scan( /\.\./u ) then
+        return VCDOM::XPath::Internal::NodeSelectionCommand.new( :parent, :node, nil, nil, nil )
+      elsif token = @scanner.scan( /\./u ) then
+        return VCDOM::XPath::Internal::NodeSelectionCommand.new( :self, :node, nil, nil, nil )
+      end
+      # AxisName
+      pos = @scanner.pos
+      if @scanner.scan( /@/u ) then
+        axis_name = :attribute
+      elsif token = @scanner.scan( XML_Q_NAME ) then
+        if @scanner.scan( /::/u ) then
+          axis_name = token.intern
+          raise "invalid AxisName [#{axis_name}]" unless AXIS_NAME_LIST.include? axis_name
+        else
+          axis_name = :child
+          @scanner.pos = pos
+        end
+      else
+        axis_name = :child
+      end
+      # NameTest or NodeType
+      if token = @scanner.scan( XPATH_NAME_TEST ) then
+        if @scanner.scan( /\(/u ) then
+          # NodeType
+          node_type = token.intern
+          raise "invalid NodeType [#{node_type}]" unless NODE_TYPE_LIST.include? node_type
+          node_name = ( node_type == :"processing-instruction" and token = @scanner.scan( XPATH_LITERAL ) ) ? token.intern : nil
+          node_ns_uri = nil
+          raise "invalid xpath expression" unless @scanner.scan( /\)/u )
+        else
+          # NameTest
+          node_type = :named_node
+          name_pair = token.split( /:/u )
+          if name_pair.length == 2 then
+            node_name = ( name_pair[1] == "*" ) ? nil : name_pair[1].intern
+            node_ns_uri = @ns_resolver.lookup_namespace_uri( name_pair[0] )
+            node_ns_uri.nil? or node_ns_uri = node_ns_uri.intern
+          else
+            # length == 1
+            node_name = ( name_pair[0] == "*" ) ? nil : name_pair[0].intern
+            node_ns_uri = nil
+          end
+        end
+      else
+        raise "invalid xpath expression [#{@scanner.rest}]"
+      end
+      # Predicate
+      pred_exprs = @scanner.check( /\[/u ) ? parse_predicates() : nil
+      VCDOM::XPath::Internal::NodeSelectionCommand.new( axis_name, node_type, node_ns_uri, node_name, pred_exprs )
+    end
+    
+    def parse_expr_list()
+      exprs = Array.new()
+      exprs << parse_expr()
+      while @scanner.scan( /,/u ) do
+        exprs << parse_expr()
+      end
+      exprs
+    end
+    
+    def parse_predicates()
+      exprs = Array.new()
+      while @scanner.scan( /\[/u ) do
+        exprs << parse_expr()
+        raise "invalid xpath expression" unless @scanner.scan( /\]/u )
+      end
+      exprs
+    end
+    
+  end
+end

data/lib/vcdom/xpath/internal/value.rb

@@ -0,0 +1,342 @@
+# coding : utf-8
+
+module VCDOM::XPath::Internal # :nodoc:
+  
+  class AbstractValue # :nodoc:
+    
+    def is_value?;   true  end
+    def is_expr?;    false end
+    def is_command?; false end
+    
+    def to_s()
+      "XPathValue(#{value})"
+    end
+    
+    def -@(); - self.to_number_value end
+    def +( val ); self.to_number_value + val end
+    def -( val ); self.to_number_value - val end
+    def *( val ); self.to_number_value * val end
+    def /( val ); self.to_number_value / val end
+    def %( val ); self.to_number_value % val end
+    
+    def |( val )
+      raise "User Error : xpath operator \"|\" must operate NodeSet"
+    end
+    
+    def ==( val )
+      types = [ self.value_type, val.value_type ]
+      if types.include? :boolean then
+        return val.to_boolean_value.value == self.to_boolean_value.value ? BooleanValue.true : BooleanValue.false
+      elsif types.include? :node_set then
+        # TODO : node-set が含まれている場合
+        val == self
+      elsif types.include? :number
+        return val.to_number_value.value == self.to_number_value.value ? BooleanValue.true : BooleanValue.false
+      else
+        return val.to_string_value.value == self.to_string_value.value ? BooleanValue.true : BooleanValue.false
+      end
+    end
+    
+    def neq?( val )
+      if val.value_type == :node_set then
+        return val.neq? self
+      else
+        return ( self == val ? BooleanValue.false : BooleanValue.true )
+      end
+    end
+    
+    def <=>( val )
+      if val.value_type == :node_set then
+        return ( val <=> self ) * -1
+      else
+        return self.to_number_value.value <=> val.to_number_value.value
+      end
+    end
+    def <( val )
+      ( self <=> val ) < 0 ? BooleanValue.true : BooleanValue.false
+    end
+    def <=( val )
+      ( self <=> val ) <= 0 ? BooleanValue.true : BooleanValue.false
+    end
+    def >( val )
+      ( self <=> val ) > 0 ? BooleanValue.true : BooleanValue.false
+    end
+    def >=( val )
+      ( self <=> val ) >= 0 ? BooleanValue.true : BooleanValue.false
+    end
+    
+  end
+  
+  class NumberValue < AbstractValue # :nodoc:
+    
+    def initialize( val )
+      @value = val.to_f
+    end
+    ##
+    # NaN -> "NaN"
+    # 正ゼロ, 負ゼロ -> "0"
+    # 正の無限大 -> "Infinity"
+    # 負の無限大 -> "-Infinity"
+    # 数値が整数である場合, 数値は 10 進形式で, 小数点がなく先頭のゼロもない [0-9]+ として表現され,
+    # 数値が負である場合には負号 (-) が前につく
+    # それ以外 -> 数値は 10 進形式で [0-9]+ "." [0-9]+ として表現され, 数値が負である場合には負号 (-) が前につく
+    # 小数点の直前にある必須の数字 1 個を別として, 小数点の前に先頭のゼロがあってはならない. 
+    # 小数点の後の必須の数字1個を越えてそれ以上の数字は, その数値をその他すべての IEEE 754 数値から一意的に区別するのに
+    # 必要な数字がなければならないが, 必要なだけしかあってはならない
+    def to_string_value()
+      if @value.nan? then
+        str = StringValue.new("NaN")
+      elsif @value.infinite? == 1 then
+        str = StringValue.new("Infinity")
+      elsif @value.infinite? == -1 then
+        str = StringValue.new("-Infinity")
+      elsif @value.zero? then
+        str = StringValue.new("0")
+      elsif @value.truncate == @value then
+        str = StringValue.new(@value.to_i.to_s)
+      else
+        str = StringValue.new(@value.to_s)
+      end
+      str
+    end
+    
+    def to_number_value()
+      self
+    end
+    
+    # 数値は、正または負のゼロでなくNaNでもない場合に、かつない場合にのみ、真である。
+    def to_boolean_value()
+      ( @value.zero? || @value.nan? ) ? BooleanValue.false : BooleanValue.true
+    end
+    
+    attr_reader :value
+    def value_type; :number end
+    
+    # define operations
+    
+    def -@(); @value = - @value; self end
+    def +( val ); NumberValue.new( @value + val.to_number_value.value ) end
+    def -( val ); NumberValue.new( @value - val.to_number_value.value ) end
+    def *( val ); NumberValue.new( @value * val.to_number_value.value ) end
+    def /( val ); NumberValue.new( @value / val.to_number_value.value ) end
+    def %( val )
+      value1 = val.to_number_value.value
+      value1 < 0 && value1 = -value1
+      value2 = @value
+      if value2 < 0 then
+        value2 = - value2
+        value2 %=  value1
+        value2 = - value2
+      else
+        value2 %=  value1
+      end
+      NumberValue.new( value2 )
+    end
+    
+  end
+  
+  class StringValue < AbstractValue # :nodoc:
+    
+    def initialize( val )
+      @value = val.to_s
+    end
+    def to_string_value()
+      self
+    end
+    
+    # StringValue を NumberValue に変換する
+    # オプションの空白にオプションの負号 1 個が続き, [0-9]("." [0-9]*)? | "." [0-9]+ が続いて空白が続いたものからなる文字列は, 
+    # その文字列が表す数学的値に (IEEE 754 最近接値丸めルールに従い) 最も近い IEEE 754 数値に変換される.
+    # その他の文字列はどれも NaN に変換される.
+    def to_number_value()
+      str = @value.gsub( /[\x20\x09\x0A\x0D]/u, "" )
+      if str =~ /\A\-?(?:\d+(?:\.\d*)?|\.\d+)\Z/ then
+        # NaN
+        return NumberValue.new( str.to_f )
+      else
+        # NaN
+        return NumberValue.new( 0.0 / 0.0 )
+      end
+    end
+    
+    # 文字列は、その長さが非ゼロである場合に、かつ非ゼロである場合にのみ、真である。 
+    def to_boolean_value()
+      @value.length != 0 ? BooleanValue.true : BooleanValue.false
+    end
+    
+    attr_reader :value
+    def value_type; :string end
+    
+  end
+  
+  class BooleanValue < AbstractValue # :nodoc:
+    
+    def initialize( val )
+      @value = !! val
+    end
+    def to_string_value()
+      @value ? StringValue.new("true") : StringValue.new("false")
+    end
+    
+    # convert a BooleanValue object to a NumberValue object.
+    # オプションの空白にオプションの負号 1 個が続き, [0-9]("." [0-9]*)? | "." [0-9]+ が続いて空白が続いたものからなる文字列は, 
+    # その文字列が表す数学的値に (IEEE 754 最近接値丸めルールに従い) 最も近い IEEE 754 数値に変換される.
+    # その他の文字列はどれも NaN に変換される.
+    def to_number_value()
+      @value ? NumberValue.new( 1.0 ) : NumberValue.new( 0.0 )
+    end
+    
+    def to_boolean_value()
+      self
+    end
+    
+    attr_reader :value
+    def value_type; :boolean end
+    
+    TRUE  = self.new( true )
+    FALSE = self.new( false )
+    def self.true;  TRUE  end
+    def self.false; FALSE end
+    
+  end
+  
+  class NodeSetValue < AbstractValue # :nodoc:
+    
+    def initialize( *nodes )
+      @value = nodes
+    end
+    def to_string_value()
+      # TODO
+      raise "NOT SUPPORT"
+    end
+    
+    def to_number_value()
+      # TODO
+      raise "NOT SUPPORT"
+    end
+    
+    def to_boolean_value()
+      @value.empty? ? BooleanValue.false : BooleanValue.true
+    end
+    
+    def []( *args )
+      @value.[]( *args )
+    end
+    def <<( node )
+      @value << node
+    end
+    
+    def sort( document_order = true )
+      # TODO
+      #@value.sort! { |a,b| 
+      #  
+      #  case a. b
+      #  when :document_position_preceding, 
+      #  when :document_position_following, # a が b より後ろ
+      #}
+    end
+    
+    def each
+      # TODO : ブロックが与えられなかった場合の処理
+      @value.each do |v|
+        yield v
+      end
+    end
+    def each_with_index
+      # TODO : ブロックが与えられなかった場合の処理
+      @value.each_with_index do |v,i|
+        yield v,i
+      end
+    end
+    
+    def length
+      @value.length
+    end
+    
+    attr_reader :value
+    def value_type; :node_set end
+    
+    def |( val )
+      val.|(self) if val.value_type != :node_set
+      @value = @value + val.value
+      @value.uniq!
+      self
+    end
+    
+    # 比較されるべきオブジェクトの双方がノードセットである場合、比較は、2つのノードの文字列値について
+    # 比較を実行した結果が真であるようなノードが、1つ目のノードセットと2つ目のノードセットとにある場合に、
+    # かつある場合にのみ、真ということになる。比較されるべきオブジェクトの一方がノードセットであり、
+    # 他方が数値である場合、比較は、比較されるべき数値と、number 関数を用いてノードの文字列値を数値に変換
+    # した結果とについて比較を実行した結果が真であるようなノードが、ノードセットの中にある場合に、かつある
+    # 場合にのみ、真ということになる。比較されるべきオブジェクトの一方がノードセットであり、他方が文字列で
+    # ある場合、比較は、ノードの文字列値と他方の文字列とについて比較を実行した結果が真であるようなノードが、
+    # ノードセットの中にある場合に、かつある場合にのみ、真ということになる。比較されるべきオブジェクトの一方が
+    # ノードセットであり、他方がブール値である場合、比較は、ブール値と、boolean 関数を用いてノードセット
+    # をブール値に変換した結果とについて比較を実行した結果が真である場合に、かつ真である場合にのみ、真ということになる。 
+    def ==( val )
+      case val.value_type
+      when :node_set
+        @value.each do |node1|
+          str1 = StringValue.new( node1.text_content )
+          val.each do |node2|
+            return BooleanValue.true if ( str1 == StringValue.new( node2.text_content ) ) == BooleanValue.true
+          end
+        end
+        return BooleanValue.false
+      when :number
+        # TODO
+        raise "NOT SUPPORT"
+      when :string
+        # TODO
+        raise "NOT SUPPORT"
+      when :boolean
+        return val == self
+      end
+    end
+    
+    def neq?( val )
+      case val.value_type
+      when :node_set
+        @value.each do |node1|
+          str1 = StringValue.new( node1.text_content )
+          val.each do |node2|
+            return BooleanValue.true if ( str1.neq? StringValue.new( node2.text_content ) ) == BooleanValue.true
+          end
+        end
+        return BooleanValue.false
+      when :number
+        # TODO
+        raise "NOT SUPPORT"
+      when :string
+        # TODO
+        raise "NOT SUPPORT"
+      when :boolean
+        return val.neq? self
+      end
+    end
+    
+    def <=>( val )
+      # TODO
+      case val.value_type
+      when :node_set
+        @value.each do |node1|
+          str1 = StringValue.new( node1.text_content )
+          val.each do |node2|
+            return BooleanValue.true if ( str1 <=> StringValue.new( node2.text_content ) ) == BooleanValue.true
+          end
+        end
+        return BooleanValue.false
+      when :number
+        # TODO
+        raise "NOT SUPPORT"
+      when :string
+        # TODO
+        raise "NOT SUPPORT"
+      when :boolean
+        return self.to_boolean_value <=> val
+      end
+    end
+    
+  end
+  
+end

data/lib/vcdom/xpath/xpath_evaluator_mod.rb

@@ -0,0 +1,32 @@
+# coding : utf-8
+
+require "vcdom/xpath/xpath_expression"
+require "vcdom/xpath/xpath_ns_resolver"
+require "vcdom/xpath/xpath_result"
+require "vcdom/xpath/internal/parser"
+
+module VCDOM::XPath
+  
+  module XPathEvaluatorMod
+    
+    def create_expression( expression, resolver )
+      XPathExpression.new( Internal::Parser.new( expression, resolver ).parse() )
+    end
+    
+    # Adapts any DOM node to resolve namespaces so that an XPath expression can be easily 
+    # evaluated relative to the context of the node where it appeared within the document. 
+    # This adapter works like the DOM Level 3 method lookupNamespaceURI on nodes in resolving 
+    # the namespaceURI from a given prefix using the current information available in the 
+    # node's hierarchy at the time lookupNamespaceURI is called. also correctly resolving 
+    # the implicit xml prefix.
+    def create_ns_resolver( node_resolver )
+      XPathNSResolver.new( node_resolver )
+    end
+    
+    def evaluate( expression, context_node, resolver, type, result = nil )
+      return self.create_expression( expression, resolver ).evaluate( context_node, type, result )
+    end
+    
+  end
+  
+end