vcdom 0.3.0 → 0.3.1

data/lib/vcdom/xpath/xpath_exception.rb

@@ -0,0 +1,23 @@
+# coding : utf-8
+
+module VCDOM::XPath
+  
+  class XPathException < Exception
+    
+    # If the expression has a syntax error or otherwise is not a legal expression 
+    # according to the rules of the specific XPathEvaluator or contains specialized 
+    # extension functions or variables not supported by this implementation.
+    INVALID_EXPRESSION_ERR = :invalid_expression_err
+    # If the expression cannot be converted to return the specified type.
+    TYPE_ERR               = :type_err
+    
+    attr_reader :type
+    
+    def initialize( type, msg )
+      super msg
+      @type = type
+    end
+    
+  end
+  
+end

data/lib/vcdom/xpath/xpath_expression.rb

@@ -0,0 +1,79 @@
+# coding : utf-8
+
+module VCDOM::XPath
+  
+  # This class implements {the interface XPathExpression of W3C DOM XPath}[http://www.w3.org/TR/DOM-Level-3-XPath/xpath.html#XPathExpression]. 
+  # 
+  # == Way to create a XPathExpression object
+  # When you want a XPathExpression object, please use XPathEvaluatorMod#create_expression method.
+  # The class Document implements the module XPathEvaluatorMod when you required "vcdom/xpath", so you can use this method as the following:
+  # 
+  #   require "vcdom"
+  #   require "vcdom/xpath"
+  #   # doc is a Document object
+  #   expr = doc.create_expression( "/test/abc", nil )
+  # 
+  class XPathExpression
+    
+    #require "vcdom/xpath/internal/tokenizer"
+    #require "vcdom/xpath/internal/parser"
+    require "vcdom/xpath/xpath_result"
+    require "vcdom/xpath/internal/evaluator"
+    
+    def initialize( expr ) # :nodoc:
+      @expr = expr
+    end
+    
+    # Evaluates the XPath expression.
+    # 
+    # Usage:
+    # 
+    #   # expr is a XPathExpression object, and elem is an Element object.
+    #   result   = expr.evaluate( elem, :first_ordered_node_type )
+    #   res_node = result.single_node_value
+    def evaluate( context_node, type, result = nil )
+      res = Internal::Evaluator.new( context_node ).evaluate_expr( @expr )
+      case type
+      when :any_type
+        case res.value_type
+        when :number
+          type = :number_type
+        when :string
+          type = :string_type
+        when :boolean
+          type = :boolean_type
+        when :node_set
+          type = :unordered_node_iterator_type
+        else
+          raise "INTERNAL ERROR"
+        end
+      when :number_type
+        res = res.to_number_value if res.value_type != :number
+        xpath_result = XPathResult::ResultNumber.new( res.value )
+      when :string_type
+        res = res.to_string_value if res.value_type != :string
+        xpath_result = XPathResult::ResultString.new( res.value )
+      when :boolean_type
+        res = res.to_boolean_value if res.value_type != :boolean
+        xpath_result = XPathResult::ResultBoolean.new( res.value )
+      when :first_ordered_node_type
+        res.sort
+        xpath_result = XPathResult::ResultSingleNode.new( res.value[0], :first_ordered_node_type )
+      when :any_unordered_node_type
+        xpath_result = XPathResult::ResultSingleNode.new( res.value[0], :any_unordered_node_type )
+      when :ordered_node_snapshot_type
+        res.sort
+        xpath_result = XPathResult::ResultNodesSnapshot.new( res.value, :ordered_node_snapshot_type )
+      when :unordered_node_snapshot_type
+        xpath_result = XPathResult::ResultNodesSnapshot.new( res.value, :unordered_node_snapshot_type )
+      when :ordered_node_iterator_type, :unordered_node_iterator_type
+        raise "not still be supported" # TODO
+      else
+        raise "USER ERROR"
+      end
+      return xpath_result
+    end
+    
+  end
+  
+end

data/lib/vcdom/xpath/xpath_ns_resolver.rb

@@ -0,0 +1,36 @@
+# coding : utf-8
+
+module VCDOM::XPath # :nodoc:
+  
+  # A XPathNSResolver object permit prefix strings in the expression 
+  # to be properly bound to namespaceURI strings. XPathEvaluator can 
+  # construct an implementation of XPathNSResolver from a node, or 
+  # the interface may be implemented by any application. 
+  # 
+  # == Way to create a XPathNSResolver object
+  # 
+  # If you want a XPathNSResolver object, please use XPathEvaluatorMod#create_expression.
+  # The class Document includes the module XPathEvaluatorMod when you required "vcdom/xpath", so you can use this method as the following:
+  # 
+  #   require "vcdom"
+  #   require "vcdom/xpath"
+  #   # doc is a Document object
+  #   resolver = doc.create_ns_resolver( node )
+  # 
+  class XPathNSResolver
+    
+    def initialize( ns_resolver ) # :nodoc:
+      @ns_resolver = ns_resolver
+    end
+    
+    # Look up the namespace URI associated to the given namespace prefix. 
+    # The XPath evaluator must never call this with a null or empty argument, 
+    # because the result of doing this is undefined.
+    def lookup_namespace_uri( prefix )
+      # TODO
+      nil
+    end
+    
+  end
+  
+end

data/lib/vcdom/xpath/xpath_result.rb

@@ -0,0 +1,104 @@
+# coding : utf-8
+
+require "vcdom/xpath/xpath_exception"
+
+module VCDOM::XPath
+  
+  class XPathResult
+    
+    ANY_TYPE                       = :any_type
+    NUMBER_TYPE                    = :number_type
+    STRING_TYPE                    = :string_type
+    BOOLEAN_TYPE                   = :boolean_type
+    UNORDERED_NODE_ITERATOR_TYPE   = :unordered_node_iterator_type
+    ORDERED_NODE_ITERATOR_TYPE     = :ordered_node_iterator_type
+    UNORDERED_NODE_SNAPSHOT_TYPE   = :unordered_node_snapshot_type
+    ORDERED_NODE_SNAPSHOT_TYPE     = :ordered_node_snapshot_type
+    ANY_UNORDERED_NODE_TYPE        = :any_unordered_node_type
+    FIRST_ORDERED_NODE_TYPE        = :first_ordered_node_type
+    
+    def result_type
+      raise "INTERNAL ERROR"
+    end
+    # Signifies that the iterator has become invalid. True if resultType is UNORDERED_NODE_ITERATOR_TYPE 
+    # or ORDERED_NODE_ITERATOR_TYPE and the document has been modified since this result was returned.
+    def invalid_iterator_state
+      false
+    end
+    def snapshot_length
+      raise XPathException.new( XPathException::TYPE_ERR, 
+            "result type is not UNORDERED_NODE_SNAPSHOT_TYPE or ORDERED_NODE_SNAPSHOT_TYPE" )
+    end
+    
+    # raises(XPathException) on retrieval
+    def number_value
+      raise XPathException.new( XPathException::TYPE_ERR, "result type is not NUMBER_TYPE" )
+    end
+    def string_value
+      raise XPathException.new( XPathException::TYPE_ERR, "result type is not STRING_TYPE" )
+    end
+    def boolean_value
+      raise XPathException.new( XPathException::TYPE_ERR, "result type is not STRING_TYPE" )
+    end
+    def single_node_value
+      raise XPathException.new( XPathException::TYPE_ERR, 
+            "result type is not ANY_UNORDERED_NODE_TYPE or FIRST_ORDERED_NODE_TYPE" )
+    end
+    def snapshot_item( index )
+      raise XPathException.new( XPathException::TYPE_ERR,
+            "result type is not UNORDERED_NODE_SNAPSHOT_TYPE or ORDERED_NODE_SNAPSHOT_TYPE" )
+    end
+    def iterate_next()
+      raise XPathException.new( XPathException::TYPE_ERR,
+            "result type is not UNORDERED_NODE_ITERATOR_TYPE or ORDERED_NODE_ITERATOR_TYPE" )
+    end
+    def initialize( value ) # :nodoc:
+      @value = value
+    end
+    
+  end
+  
+end
+
+class VCDOM::XPath::XPathResult
+  
+  # This class is subclass of XPathResult.
+  # This exists to represent a number type result of XPath expression.
+  class ResultNumber < self
+    def result_type;  NUMBER_TYPE end
+    def number_value; @value      end
+  end
+  class ResultString < self
+    def result_type;  STRING_TYPE end
+    def string_value; @value      end
+  end
+  class ResultBoolean < self
+    def result_type;  BOOLEAN_TYPE end
+    def boolean_value; @value      end
+    TRUE  = self.new( true )
+    FALSE = self.new( false )
+  end
+  class ResultSingleNode < self
+    def initialize( node, type ) # :nodoc:
+      super( node )
+      @type = type
+    end
+    def result_type; @type end
+    def single_node_value; @value end
+  end
+  class ResultNodesSnapshot < self
+    def initialize( nodes, type ) # :nodoc:
+      super( nodes )
+      @type = type
+    end
+    def result_type; @type end
+    def snapshot_length
+      @value.length
+    end
+    def snapshot_item( index )
+      @value[index]
+    end
+    alias :[] :snapshot_item
+  end
+  
+end

data/lib/vcdom/xpath.rb

@@ -0,0 +1,15 @@
+# coding : utf-8
+
+require "vcdom/node"
+require "vcdom/document"
+require "vcdom/xpath/xpath_evaluator_mod"
+
+module VCDOM
+  module XPath
+    
+    class ::VCDOM::Document < ::VCDOM::Node
+      include XPathEvaluatorMod
+    end
+    
+  end
+end

data/test/main_test_1.8.rb.old

@@ -0,0 +1 @@
+require "test/unit"

data/test/main_test_1.9.rb.old

@@ -0,0 +1,25 @@
+# coding: UTF-8
+
+require "test/unit"
+
+require "vcdom/xml_ls"
+#require "vcdom/xml_parser"
+#require "vcdom/xml_serializer"
+
+class TestParsing < Test::Unit::TestCase
+  
+  @@ls_impl = VCDOM::XMLLS
+  
+  def test_of_one_element_doc_parsing
+    parser = @@ls_impl.create_ls_parser( :mode_asynchronous, nil )
+    input  = @@ls_impl.create_ls_input()
+    input.string_data = "<empty-element/>"
+    doc = parser.parse( input )
+    root_elem = doc.first_child
+    assert_equal( "empty-element", root_elem.node_name )
+    assert( root_elem.equal? doc.document_element )
+    assert( root_elem.equal? doc.last_child )
+    assert( root_elem.parent_node.equal? doc )
+  end
+  
+end

data/test/test_main.rb

@@ -0,0 +1,6 @@
+#$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift File.dirname(__FILE__)
+$LOAD_PATH.unshift File.join( File.dirname(__FILE__), "..", "lib" )
+
+require "test_parsing"
+require "test_xpath"

data/test/test_parsing.rb

@@ -0,0 +1,41 @@
+# coding: UTF-8
+
+require "test/unit"
+
+require "vcdom/xml_ls"
+
+class TestParsing < Test::Unit::TestCase
+  
+  @@ls_impl = VCDOM::XMLLS
+  
+  def test_of_parsing_one_element_xml_string()
+    parser = @@ls_impl.create_ls_parser( :mode_asynchronous, nil )
+    input  = @@ls_impl.create_ls_input()
+    input.string_data = "<empty-element/>"
+    doc = parser.parse( input )
+    root_elem = doc.document_element
+    assert_equal( "empty-element", root_elem.node_name )
+    assert( root_elem.equal? doc.first_child )
+    assert( root_elem.equal? doc.last_child  )
+    assert( root_elem.parent_node.equal? doc )
+  end
+  
+  def test_of_parsing_text_node()
+    parser = @@ls_impl.create_ls_parser( :mode_asynchronous, nil )
+    input  = @@ls_impl.create_ls_input()
+    input.string_data = "<element>テキストノードです\n改行</element>"
+    doc = parser.parse( input )
+    root_elem = doc.document_element
+    assert_equal( "テキストノードです\n改行", root_elem.first_child.node_value )
+  end
+  
+  def test_of_parsing_text_node_within_predefined_char_ref()
+    parser = @@ls_impl.create_ls_parser( :mode_asynchronous, nil )
+    input  = @@ls_impl.create_ls_input()
+    input.string_data = "<element>テキストノードです&lt;うん&gt;私&amp;あなた&quot;&apos;&amp;</element>"
+    doc = parser.parse( input )
+    root_elem = doc.document_element
+    assert_equal( "テキストノードです<うん>私&あなた\"'&", root_elem.first_child.node_value )
+  end
+  
+end

data/test/test_xpath.rb

@@ -0,0 +1,266 @@
+# coding: UTF-8
+
+require "test/unit"
+
+require "vcdom/xpath"
+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"
+
+class TestXPath < Test::Unit::TestCase
+  
+  @@ls_impl = VCDOM::XMLLS
+  
+  require "vcdom/document"
+  @@doc = VCDOM::Document._new()
+  elem = @@doc.append_child @@doc.create_element( "test" )
+  elem << @@doc.create_element( "test-child1" )
+  elem << @@doc.create_element( "test-child2" )
+  elem << @@doc.create_element( "test-child3" )
+  #doc.create_expression(nil,nil)
+  
+  def test_creating_xpath_expression()
+    xpath_expr = @@doc.create_expression( "//test-child1/.././test-child1", nil )
+    res = xpath_expr.evaluate( @@doc, :any_unordered_node_type )
+    assert_equal @@doc.document_element.first_child, res.single_node_value
+  end
+  
+  def test_creating_xpath_expression_snapshot()
+    res = @@doc.evaluate( "/*/child::*[2]", @@doc, nil, :unordered_node_snapshot_type )
+    assert_equal :unordered_node_snapshot_type, res.result_type
+    assert_equal 1, res.snapshot_length
+    assert_equal @@doc.first_child.first_child.next_sibling, res.snapshot_item( 0 )
+  end
+  
+  ##
+  # 関数呼び出しのテスト
+  def test_of_evaluating_function_call()
+    res_type = :number_type
+    res = evaluate_equality_expr( res_type, res_type, 1.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::FunctionCallCommand.new( :position, nil )
+    end
+  end
+  
+  ##
+  # 数値, リテラル, 真偽値単体を返す式のチェック
+  # 結果は数値として受け取る
+  def test_of_evaluating_expr_having_only_one_value_number()
+    res_type = :number_type
+    res = evaluate_equality_expr( res_type, res_type, 10.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 10 )
+    end
+  end
+  
+  ##
+  # 数値, リテラル, 真偽値単体を返す式のチェック
+  # 結果は文字列として受け取る
+  def test_of_evaluating_expr_having_only_one_value_string()
+    res_type = :string_type
+    res = evaluate_equality_expr( res_type, res_type, "10" ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 10 )
+    end
+    res = evaluate_equality_expr( res_type, res_type, "100.5" ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 100.5 )
+    end
+    res = evaluate_equality_expr( res_type, res_type, "てすと" ) do |expr|
+      expr << VCDOM::XPath::Internal::StringValue.new( "てすと" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, "true" ) do |expr|
+      expr << VCDOM::XPath::Internal::FunctionCallCommand.new( :true, nil )
+    end
+    res = evaluate_equality_expr( res_type, res_type, "false" ) do |expr|
+      expr << VCDOM::XPath::Internal::FunctionCallCommand.new( :false, nil )
+    end
+  end
+  
+  ##
+  # 数値, リテラル, 真偽値単体を返す式のチェック
+  # 結果は真偽値として受け取る
+  def test_of_evaluating_expr_having_only_one_value_boolean()
+    res_type = :boolean_type
+    res = evaluate_equality_expr( res_type, res_type, true ) do |expr|
+      expr << VCDOM::XPath::Internal::FunctionCallCommand.new( :true, nil )
+    end
+  end
+  
+  ##
+  # 算術演算のテスト
+  def test_operation_of_numbers()
+    res_type = :number_type
+    res = evaluate_equality_expr( res_type, res_type, 5.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 5 )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 5 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"+" )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 10 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"-@" )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"+" )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 1 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"-" )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 2 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"div" )
+      expr << VCDOM::XPath::Internal::NumberValue.new( -10 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"*" )
+    end
+  end
+  def test_operation_of_numbers_mod()
+    res_type = :number_type
+    res = evaluate_equality_expr( res_type, res_type, 1.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 5 )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 2 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"mod" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, 1.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 5 )
+      expr << VCDOM::XPath::Internal::NumberValue.new( -2 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"mod" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, -1.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( -5 )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 2 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"mod" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, -1.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( -5 )
+      expr << VCDOM::XPath::Internal::NumberValue.new( -2 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"mod" )
+    end
+  end
+  
+  ##
+  # 文字列を数値に変換するテスト
+  def test_conversion_str_to_num()
+    res_type = :number_type
+    res = evaluate_equality_expr( res_type, res_type, 105.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::StringValue.new( "105.0" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, 12.0 ) do |expr|
+      expr << VCDOM::XPath::Internal::StringValue.new( "12." )
+    end
+    res = evaluate_equality_expr( res_type, res_type, -0.5 ) do |expr|
+      expr << VCDOM::XPath::Internal::StringValue.new( "-.500000" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, lambda { |v| v.nan? } ) do |expr|
+      expr << VCDOM::XPath::Internal::StringValue.new( "45aa" )
+    end
+  end
+  
+  ##
+  # Boolean に変換するテスト
+  def test_conversion_num_to_bool()
+    res_type = :boolean_type
+    res = evaluate_equality_expr( res_type, res_type, true ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 105.0 )
+    end
+    res = evaluate_equality_expr( res_type, res_type, false ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 0.0 )
+    end
+  end
+  def test_conversion_str_to_bool()
+    res_type = :boolean_type
+    res = evaluate_equality_expr( res_type, res_type, true ) do |expr|
+      expr << VCDOM::XPath::Internal::StringValue.new( "aaaa" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, false ) do |expr|
+      expr << VCDOM::XPath::Internal::StringValue.new( "" )
+    end
+  end
+  
+  ##
+  # 比較演算テスト
+  def test_operation_of_relation()
+    res_type = :boolean_type
+    res = evaluate_equality_expr( res_type, res_type, false ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( 5 )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 5 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :">" )
+    end
+    res = evaluate_equality_expr( res_type, res_type, true ) do |expr|
+      expr << VCDOM::XPath::Internal::NumberValue.new( "5" )
+      expr << VCDOM::XPath::Internal::NumberValue.new( 100 )
+      expr << VCDOM::XPath::Internal.get_operation_command( :"<" )
+    end
+  end
+  
+  ##
+  # Node を取得するテスト
+  def test_root_node()
+    res_type = :any_unordered_node_type
+    res = evaluate_equality_expr( res_type, res_type, @@doc ) do |expr|
+      expr << VCDOM::XPath::Internal::RootNodeCommand.new()
+    end
+  end
+  
+  ##
+  # Node を選択するテスト
+  def test_node_selection()
+    res_type = :any_unordered_node_type
+    res = evaluate_equality_expr( res_type, res_type, @@doc.document_element ) do |expr|
+      expr << VCDOM::XPath::Internal::RootNodeCommand.new()
+      expr << VCDOM::XPath::Internal::NodeSelectionCommand.new( :child, :named_node, nil, nil, nil )
+    end
+  end
+  
+  ##
+  # union 演算子のテスト
+  def test_operator_union()
+    res_type = :any_unordered_node_type
+    res = evaluate_equality_expr( res_type, res_type, @@doc ) do |expr|
+      expr << VCDOM::XPath::Internal::RootNodeCommand.new()
+      expr << VCDOM::XPath::Internal::RootNodeCommand.new()
+      expr << VCDOM::XPath::Internal.get_operation_command( :"|" )
+    end
+  end
+  
+  ##
+  # Predicate テスト
+  def test_predicate()
+    res_type = :any_unordered_node_type
+    res = evaluate_equality_expr( res_type, res_type, @@doc ) do |expr|
+      expr << VCDOM::XPath::Internal::RootNodeCommand.new()
+      expr << VCDOM::XPath::Internal::PredsEvalCommand.new( [
+        VCDOM::XPath::Internal::EqualityExpr.new(
+          VCDOM::XPath::Internal::NumberValue.new( 1.0 )
+        )
+      ] )
+    end
+    res_type = :any_unordered_node_type
+    res = evaluate_equality_expr( res_type, res_type, nil ) do |expr|
+      expr << VCDOM::XPath::Internal::RootNodeCommand.new()
+      expr << VCDOM::XPath::Internal::PredsEvalCommand.new( [
+        VCDOM::XPath::Internal::EqualityExpr.new(
+          VCDOM::XPath::Internal::NumberValue.new( 2.0 )
+        )
+      ] )
+    end
+  end
+  
+  ##
+  # equality expr のテストを補助するための関数
+  def evaluate_equality_expr( res_type, expected_type, expected_val )
+    internal_expr = VCDOM::XPath::Internal::EqualityExpr.new()
+    yield( internal_expr )
+    expr = VCDOM::XPath::XPathExpression.new( internal_expr )
+    res = expr.evaluate( @@doc, res_type, nil )
+    assert_equal( expected_type, res.result_type )
+    case expected_type
+    when :number_type
+      val = res.number_value
+    when :string_type
+      val = res.string_value
+    when :boolean_type
+      val = res.boolean_value
+    when :any_unordered_node_type, :first_ordered_node_type
+      val = res.single_node_value
+    else
+      raise "ERROR"
+    end
+    if expected_val.is_a? Proc then
+      assert expected_val.call( val )
+    else
+      assert_equal( expected_val, val )
+    end
+  end
+  
+end