rubyang 0.1.1 → 0.1.2

data/lib/rubyang/database/data_tree.rb

@@ -5,6 +5,7 @@ require 'rexml/document'
 require 'rexml/formatters/pretty'
 require 'json'
 
+require_relative '../xpath'
 require_relative 'helper'
 require_relative 'component_manager'
 
@@ -20,13 +21,71 @@ module Rubyang
 					@schema_tree = schema_tree
 					@schema = schema
 					@children = []
+					@logger = Rubyang::Logger.instance
+				end
+				def to_s parent=true
+					head, vars, tail = "#<#{self.class.to_s}:0x#{(self.object_id << 1).to_s(16).rjust(14,'0')} ", Array.new, ">"
+					if parent
+						vars.push "@parent=#{@parent.to_s(false)}"
+						vars.push "@schema_tree=#{@schema_tree.to_s(false)}"
+						vars.push "@schema=#{@schema.to_s(true)}"
+						vars.push "@children=#{@children.to_s}"
+					end
+					head + vars.join(', ') + tail
+				end
+				def to_xml pretty: false
+					doc = REXML::Document.new
+					self.to_xml_recursive doc, ''
+					if pretty
+						pretty_formatter = REXML::Formatters::Pretty.new( 2 )
+						pretty_formatter.compact = true
+						output = ''
+						pretty_formatter.write( doc, output )
+						output
+					else
+						doc.to_s
+					end
+				end
+				def to_json pretty: false
+					hash = Hash.new
+					self.to_json_recursive hash
+					if pretty
+						JSON.pretty_generate( hash )
+					else
+						JSON.generate( hash )
+					end
+				end
+				def valid? current=true
+					result = if current
+							 self.root.valid?
+						 else
+							 case self
+							 when Rubyang::Database::DataTree::Container
+								 @children.inject(self.evaluate_musts){ |r, c|
+									 r.and c.valid?( false )
+								 }
+							 when Rubyang::Database::DataTree::LeafList, Rubyang::Database::DataTree::List
+								 tmp = Rubyang::Xpath::BasicType::Boolean.new( self.evaluate_min_elements )
+								 tmp.and Rubyang::Xpath::BasicType::Boolean.new( self.evaluate_max_elements )
+							 else
+								 Rubyang::Xpath::BasicType::Boolean.new true
+							 end
+						 end
+					@logger.debug "#{self.class}#valid?: return: #{result} #{result.value}"
+					result
 				end
 				def load_merge_xml_recursive doc_xml
 					doc_xml.each_element{ |e|
 						child = edit( e.name )
 						unless e.has_elements?
 							if e.has_text?
-								child.set e.text
+								classes_have_set = [
+									Rubyang::Database::DataTree::Leaf,
+									Rubyang::Database::DataTree::LeafList,
+								]
+								if classes_have_set.include?(child.class)
+									child.set e.text
+								end
 							end
 						end
 						child.load_merge_xml_recursive e
@@ -40,25 +99,180 @@ module Rubyang
 						@parent.root
 					end
 				end
-				def evaluate_xpath location_steps, current=self
-					location_step = location_steps.first
-					candidates_by_axis = self.evaluate_xpath_axis( location_step, current )
-					candidates_by_node_test = candidates_by_axis.inject([]){ |cs, c| cs + c.evaluate_xpath_node_test( location_step, current ) }
-					candidates_by_predicates = candidates_by_node_test.inject([]){ |cs, c| cs + c.evaluate_xpath_predicates( location_step, current ) }
-					if location_steps[1..-1].size == 0
+
+				# when start
+				def evaluate_whens
+					@schema.whens.inject( Rubyang::Xpath::BasicType::Boolean.new true ){ |r, w|
+						puts
+						puts 'evaluate whens:'
+						puts 'r:'
+						puts r.value
+						puts 'w:'
+						puts w.arg
+						_when = r.and self.evaluate_xpath( w.xpath, self )
+						puts '_when:'
+						require 'yaml'
+						puts _when.to_yaml
+						puts 'evaluate whens done'
+						puts
+						r.and self.evaluate_xpath( w.xpath, self )
+					}
+				end
+				# end
+
+				# must start
+				def evaluate_musts
+					@schema.musts.inject( Rubyang::Xpath::BasicType::Boolean.new true ){ |r, w|
+						puts
+						puts 'evaluate musts:'
+						puts 'r:'
+						puts r.value
+						puts 'w:'
+						puts w.arg
+						must = r.and self.evaluate_xpath( w.xpath, self )
+						puts 'must:'
+						require 'yaml'
+						puts must.to_yaml
+						puts 'evaluate musts done'
+						puts
+						r.and self.evaluate_xpath( w.xpath, self )
+					}
+				end
+				# end
+
+				# min-elements start
+				def evaluate_min_elements
+					if @schema.min_elements.size > 0
+						@logger.debug "#{self.class}#evaluate_min_elements: @schema.min_elements.first.arg: #{@schema.min_elements.first.arg}"
+						if @children.size >= @schema.min_elements.first.arg.to_i then true else false end
+					else
+						true
+					end
+				end
+				# end
+
+				# min-elements start
+				def evaluate_max_elements
+					if @schema.max_elements.size > 0
+						@logger.debug "#{self.class}#evaluate_max_elements: @schema.max_elements.first.arg: #{@schema.max_elements.first.arg}"
+						if @children.size <= @schema.max_elements.first.arg.to_i then true else false end
+					else
+						true
+					end
+				end
+				# end
+
+				def evaluate_xpath xpath, current=self
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'in evaluate_xpath:'
+						puts
+						puts 'xpath:'
+						puts xpath.to_yaml
+						puts
+						puts 'self:'
+						puts self.class
+						puts self.schema.arg
+						puts self.schema.value rescue ''
+						puts 'current:'
+						puts current.class
+						puts current.schema.arg
+						puts current.schema.value rescue ''
+						puts
+					end
+					evaluate_xpath_expr xpath, current
+				end
+
+				def evaluate_xpath_path location_path, current
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'in evaluate_xpath_path:'
+						puts
+						puts 'location_path:'
+						puts location_path.to_yaml
+						puts
+						puts 'self:'
+						puts self.class
+						puts self.schema.arg
+						puts self.schema.value rescue ''
+						puts 'current:'
+						puts current.class
+						puts current.schema.arg
+						puts current.schema.value rescue ''
+						puts
+					end
+					first_location_step = location_path.location_step_sequence.first
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'first_location_step:'
+						puts first_location_step.to_yaml
+					end
+					candidates_by_axis = self.evaluate_xpath_axis( first_location_step, current )
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'candidates_by_axis:'
+						puts candidates_by_axis.to_yaml
+					end
+					candidates_by_node_test = Rubyang::Xpath::BasicType::NodeSet.new candidates_by_axis.value.inject([]){ |cs, c| cs + c.evaluate_xpath_node_test( first_location_step, current ) }
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'candidates_by_node_test:'
+						puts candidates_by_node_test.to_yaml
+					end
+					candidates_by_predicates = Rubyang::Xpath::BasicType::NodeSet.new candidates_by_node_test.value.inject([]){ |cs, c| cs + c.evaluate_xpath_predicates( first_location_step, current ) }
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'candidates_by_predicates:'
+						puts candidates_by_predicates.to_yaml
+					end
+					if location_path.location_step_sequence[1..-1].size == 0
 						candidates_by_predicates
 					else
-						candidates_by_predicates.inject([]){ |cs, c| c.evaluate_xpath( location_steps[1..-1], current ) }
+						Rubyang::Xpath::BasicType::NodeSet.new candidates_by_predicates.value.inject([]){ |cs, c|
+							following_location_path = Rubyang::Xpath::LocationPath.new *(location_path.location_step_sequence[1..-1])
+							if Rubyang::Xpath::Parser::DEBUG
+								puts
+								puts 'following_location_path:'
+								puts following_location_path.to_yaml
+								puts
+							end
+							cs + c.evaluate_xpath_path( following_location_path, current ).value
+						}
 					end
 				end
+
 				def evaluate_xpath_axis location_step, current
+					if Rubyang::Xpath::Parser::DEBUG
+						require 'yaml'
+						puts
+						puts 'in evaluate_xpath_axis:'
+						puts
+						puts 'location_step:'
+						puts location_step.to_yaml
+						puts
+						puts 'self:'
+						puts self.class
+						puts self.schema.arg
+						puts self.schema.value rescue ''
+						puts 'current:'
+						puts current.class
+						puts current.schema.arg
+						puts current.schema.value rescue ''
+						puts
+					end
 					case location_step.axis.name
 					when Rubyang::Xpath::Axis::SELF
-						[self]
+						Rubyang::Xpath::BasicType::NodeSet.new [self]
 					when Rubyang::Xpath::Axis::PARENT
-						[@parent]
+						Rubyang::Xpath::BasicType::NodeSet.new [@parent]
 					when Rubyang::Xpath::Axis::CHILD
-						@children.inject([]){ |cs, c|
+						Rubyang::Xpath::BasicType::NodeSet.new @children.inject([]){ |cs, c|
 							cs + case c
 							when Rubyang::Database::DataTree::ListElement
 								c.children
@@ -70,13 +284,25 @@ module Rubyang
 						raise "location_step.axis.name: #{location_step.axis.name} NOT implemented"
 					end
 				end
+
 				def evaluate_xpath_node_test location_step, current
+					puts 
+					p 'in node_test'
+					p self.class
+					p self.schema.arg
+					p self.value rescue ''
+					puts
 					case location_step.node_test.node_test_type
 					when Rubyang::Xpath::NodeTest::NodeTestType::NAME_TEST
 						if "/" == location_step.node_test.node_test
 							[self.root]
 						elsif self.schema.model.arg == location_step.node_test.node_test
-							[self]
+							case self
+							when Rubyang::Database::DataTree::List
+								self.children
+							else
+								[self]
+							end
 						else
 							[]
 						end
@@ -97,19 +323,46 @@ module Rubyang
 						raise ""
 					end
 				end
+
 				def evaluate_xpath_predicates location_step, current
 					case location_step.predicates.size
 					when 0
 						[self]
 					else
-						location_step.predicates.inject([]){ |cs, predicate|
-							self.evaluate_xpath_predicate_expr predicate.expr, current
+						location_step.predicates.inject([self]){ |cs, predicate|
+							p 'aaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+							p self.class
+							if cs.size > 0
+								result = cs[0].evaluate_xpath_expr predicate.expr, current
+								case result
+								when Rubyang::Xpath::BasicType::NodeSet
+									raise
+								when Rubyang::Xpath::BasicType::Boolean
+									if result.value == true then cs else [] end
+								when Rubyang::Xpath::BasicType::Number
+									raise
+								when Rubyang::Xpath::BasicType::String
+									raise
+								end
+							else
+								[]
+							end
 						}
 					end
 				end
-				def evaluate_xpath_predicate_expr expr, current
+
+				def evaluate_xpath_expr expr, current=self
 					case expr
-					when Rubyang::Xpath::Predicate::OrExpr
+					when Rubyang::Xpath::Expr
+						if Rubyang::Xpath::Parser::DEBUG
+							puts
+							puts "in Expr"
+							puts "op: #{expr.op}"
+							puts
+						end
+						op = expr.op
+						op_result = self.evaluate_xpath_expr( op, current )
+					when Rubyang::Xpath::OrExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in OrExpr"
@@ -119,14 +372,22 @@ module Rubyang
 						end
 						op1 = expr.op1
 						op2 = expr.op2
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							op2_result = self.evaluate_xpath_predicate_expr( op2, current )
-							op1_result | op2_result
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							if op1_result.class == Rubyang::Xpath::BasicType::NodeSet && op2_result.class == Rubyang::Xpath::BasicType::NodeSet
+								if op1_result.empty? && op2_result.empty?
+									Rubyang::Xpath::BasicType::Boolean.new false
+								else
+									Rubyang::Xpath::BasicType::Boolean.new true
+								end
+							else
+								Rubyang::Xpath::BasicType::Boolean.new true
+							end
 						end
-					when Rubyang::Xpath::Predicate::AndExpr
+					when Rubyang::Xpath::AndExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in AndExpr"
@@ -136,14 +397,20 @@ module Rubyang
 						end
 						op1 = expr.op1
 						op2 = expr.op2
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							op2_result = self.evaluate_xpath_predicate_expr( op2, current )
-							op1_result & op2_result
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							if op1_result.class == Rubyang::Xpath::BasicType::NodeSet
+								Rubyang::Xpath::BasicType::Boolean.new false if op1_result.empty?
+							elsif op2_result.class == Rubyang::Xpath::BasicType::NodeSet
+								Rubyang::Xpath::BasicType::Boolean.new false if op2_result.empty?
+							else
+								Rubyang::Xpath::BasicType::Boolean.new true
+							end
 						end
-					when Rubyang::Xpath::Predicate::EqualityExpr
+					when Rubyang::Xpath::EqualityExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in EqualityExpr"
@@ -155,21 +422,70 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\=$/
-								op2_result = self.evaluate_xpath_predicate_expr( op2, current )
-								op1_result.select{ |a| op2_result.map{ |b| b.value }.include? a.value }.map{ |c| c.parent }
-							when /^\!\=$/
-								raise "Equality Expr: '!=' not implemented"
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							if Rubyang::Xpath::Parser::DEBUG
+								require 'yaml'
+								puts
+								puts "in EqualityExpr else:"
+								puts "op1_result: #{op1_result.to_yaml}"
+								puts "op2_result: #{op2_result.to_yaml}"
+								puts
+							end
+							if op1_result.class == Rubyang::Xpath::BasicType::NodeSet && op2_result.class == Rubyang::Xpath::BasicType::String
+								case operator
+								when /^\=$/
+									#op1_result.select{ |a| op2_result.map{ |b| b.value }.include? a.value }.map{ |c| c.parent }
+									op1_result == op2_result
+								when /^\!\=$/
+									raise "Equality Expr: '!=' not implemented"
+								else
+									raise "Equality Expr: other than '=' and '!=' not implemented"
+								end
+							elsif op1_result.class == Rubyang::Xpath::BasicType::String && op2_result.class == Rubyang::Xpath::BasicType::NodeSet
+								case operator
+								when /^\=$/
+									op2_result.select{ |a| op1_result.map{ |b| b.value }.include? a.value }.map{ |c| c.parent }
+								when /^\!\=$/
+									raise "Equality Expr: '!=' not implemented"
+								else
+									raise "Equality Expr: other than '=' and '!=' not implemented"
+								end
+							elsif op1_result.class == Rubyang::Xpath::BasicType::Number && op2_result.class == Rubyang::Xpath::BasicType::Number
+								case operator
+								when /^\=$/
+									op1_result == op2_result
+								when /^\!\=$/
+									op1_result != op2_result
+								else
+									raise "Equality Expr: other than '=' and '!=' not implemented"
+								end
+							elsif op1_result.class == Rubyang::Xpath::BasicType::String && op2_result.class == Rubyang::Xpath::BasicType::String
+								case operator
+								when /^\=$/
+									op1_result == op2_result
+								when /^\!\=$/
+									op1_result != op2_result
+								else
+									raise "Equality Expr: other than '=' and '!=' not implemented"
+								end
+							elsif op1_result.class == Rubyang::Xpath::BasicType::NodeSet && op2_result.class == Rubyang::Xpath::BasicType::NodeSet
+								case operator
+								when /^\=$/
+									op1_result == op2_result
+								when /^\!\=$/
+									op1_result != op2_result
+								else
+									raise "Equality Expr: other than '=' and '!=' not implemented"
+								end
 							else
-								raise "Equality Expr: other than '=' and '!=' not implemented"
+								Rubyang::Xpath::BasicType::Boolean.new false
 							end
 						end
-					when Rubyang::Xpath::Predicate::RelationalExpr
+					when Rubyang::Xpath::RelationalExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in RelationalExpr"
@@ -181,24 +497,29 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\>$/
-								raise "Relational Expr: '>' not implemented"
-							when /^\<$/
-								raise "Relational Expr: '<' not implemented"
-							when /^\>\=$/
-								raise "Relational Expr: '>=' not implemented"
-							when /^\<\=$/
-								raise "Relational Expr: '<=' not implemented"
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							if op1_result.class == Rubyang::Xpath::BasicType::Number && op2_result.class == Rubyang::Xpath::BasicType::Number
+								case operator
+								when /^\>$/
+									op1_result > op2_result
+								when /^\<$/
+									op1_result < op2_result
+								when /^\>\=$/
+									op1_result >= op2_result
+								when /^\<\=$/
+									op1_result <= op2_result
+								else
+									raise "Relational Expr: other than '>', '<', '>=' and '<=' not valid"
+								end
 							else
-								raise "Relational Expr: other than '>', '<', '>=' and '<=' not implemented"
+								Rubyang::Xpath::BasicType::Boolean.new false
 							end
 						end
-					when Rubyang::Xpath::Predicate::AdditiveExpr
+					when Rubyang::Xpath::AdditiveExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in AdditiveExpr"
@@ -210,20 +531,25 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\+$/
-								raise "Additive Expr: '+' not implemented"
-							when /^\-$/
-								raise "Additive Expr: '-' not implemented"
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							if op1_result.class == Rubyang::Xpath::BasicType::Number && op2_result.class == Rubyang::Xpath::BasicType::Number
+								case operator
+								when /^\+$/
+									op1_result + op2_result
+								when /^\-$/
+									op1_result - op2_result
+								else
+									raise "Additive Expr: other than '+' and '-' not valid"
+								end
 							else
-								raise "Additive Expr: other than '+' and '-' not implemented"
+								Rubyang::Xpath::BasicType::Number.new Float::NAN
 							end
 						end
-					when Rubyang::Xpath::Predicate::MultiplicativeExpr
+					when Rubyang::Xpath::MultiplicativeExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in MultiplicativeExpr"
@@ -235,20 +561,25 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							case operator
-							when /^\*$/
-								raise "Multiplicative Expr: '*' not implemented"
-							when /^\/$/
-								raise "Multiplicative Expr: '/' not implemented"
+							op2_result = self.evaluate_xpath_expr( op2, current )
+							if op1_result.class == Rubyang::Xpath::BasicType::Number && op2_result.class == Rubyang::Xpath::BasicType::Number
+								case operator
+								when /^\*$/
+									op1_result * op2_result
+								when /^\/$/
+									op1_result / op2_result
+								else
+									raise "Multiplicative Expr: other than '*' and '/' not valid"
+								end
 							else
-								raise "Multiplicative Expr: other than '*' and '/' not implemented"
+								Rubyang::Xpath::BasicType::Number.new Float::NAN
 							end
 						end
-					when Rubyang::Xpath::Predicate::UnaryExpr
+					when Rubyang::Xpath::UnaryExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in UnaryExpr"
@@ -258,16 +589,21 @@ module Rubyang
 						end
 						op1 = expr.op1
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						case operator
 						when nil
 							op1_result
 						when /^\-$/
-							raise "Unary Expr: '-' not implemented"
+							case op1_result
+							when Rubyang::Xpath::BasicType::Number
+								- op1_result
+							else
+								Rubyang::Xpath::BasicType::Number.new Float::NAN
+							end
 						else
-							raise "Unary Expr: other than '-' not implemented"
+							raise "Unary Expr: other than '-' not valid"
 						end
-					when Rubyang::Xpath::Predicate::UnionExpr
+					when Rubyang::Xpath::UnionExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in UnionExpr"
@@ -279,10 +615,11 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
+							op2_result = self.evaluate_xpath_expr( op2, current )
 							case operator
 							when /^\|$/
 								raise "Union Expr: '|' not implemented"
@@ -290,7 +627,7 @@ module Rubyang
 								raise "Union Expr: other than '|' not implemented"
 							end
 						end
-					when Rubyang::Xpath::Predicate::PathExpr
+					when Rubyang::Xpath::PathExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in PathExpr"
@@ -302,32 +639,34 @@ module Rubyang
 						op1 = expr.op1
 						op2 = expr.op2
 						operator = expr.operator
-						case op1
-						when Rubyang::Xpath::LocationSteps
-							op1_result = self.evaluate_xpath( op1, current )
-						when Rubyang::Xpath::Predicate::FilterExpr
-							op1_result = self.evaluate_xpath_predicate_expr( op1, current )
-							if op2 == nil
-								op1_result
-							else
-								case operator
-								when /^\/$/
-									case op2
-									when Rubyang::Xpath::LocationSteps
-										current.evaluate_xpath (op1_result + op2), current
-									else
-										raise "Path Expr: op1 is not LocationSteps"
-									end
-								when /^\/\/$/
-									raise "Path Expr: '//' not implemented"
+						op1_result = case op1
+							     when Rubyang::Xpath::LocationPath
+								     self.evaluate_xpath_path( op1, current )
+							     when Rubyang::Xpath::FilterExpr
+								     op1_result = self.evaluate_xpath_expr( op1, current )
+							     else
+								     raise "PathExpr: #{op1} not supported"
+							     end
+						if op2 == nil
+							op1_result
+						else
+							case operator
+							when /^\/$/
+								case op1_result
+								when Rubyang::Database::DataTree::Node
+									op1_result.evaluate_xpath_path op2, current
+								when Rubyang::Xpath::LocationPath
+									self.evaluate_xpath_path Rubyang::Xpath::LocationPath.new( *(op1_result.location_step_sequence + op2.location_step_sequence) ), current
 								else
-									raise "Path Expr: other than '/' and '//' not implemented"
+									raise
 								end
+							when /^\/\/$/
+								raise "Path Expr: '//' not implemented"
+							else
+								raise "Path Expr: other than '/' and '//' not valid"
 							end
-						else
-							raise ""
 						end
-					when Rubyang::Xpath::Predicate::FilterExpr
+					when Rubyang::Xpath::FilterExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in FilterExpr"
@@ -337,14 +676,14 @@ module Rubyang
 						end
 						op1 = expr.op1
 						op2 = expr.op2
-						op1_result = self.evaluate_xpath_predicate_expr( op1, current )
+						op1_result = self.evaluate_xpath_expr( op1, current )
 						if op2 == nil
 							op1_result
 						else
-							op2_result = self.evaluate_xpath_predicate_expr( op2.expr, current )
-							raise "Filter Expr: Filter Predicate not implemented"
+							op2_result = self.evaluate_xpath_expr( op2.expr, current )
+							Rubyang::Xpath::BasicType::NodeSet.new
 						end
-					when Rubyang::Xpath::Predicate::PrimaryExpr
+					when Rubyang::Xpath::PrimaryExpr
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in PrimaryExpr"
@@ -353,16 +692,20 @@ module Rubyang
 						end
 						op1 = expr.op1
 						case op1
-						when Rubyang::Xpath::Predicate::Expr
-							raise "Primary Expr: '( Expr )' not implemented"
-						when Rubyang::Xpath::Predicate::FunctionCall
-							op1_result = self.evaluate_xpath_predicate_expr( op1, current )
-						when /^\$.*$/
-							raise "Primary Expr: 'Variable Reference' not implemented"
+						when Rubyang::Xpath::VariableReference
+							raise "Primary Expr: '#{op1}' not implemented"
+						when Rubyang::Xpath::Expr
+							op1_result = self.evaluate_xpath_expr( op1, current )
+						when Rubyang::Xpath::Literal
+							Rubyang::Xpath::BasicType::String.new op1.value
+						when Rubyang::Xpath::Number
+							Rubyang::Xpath::BasicType::Number.new op1.value
+						when Rubyang::Xpath::FunctionCall
+							op1_result = self.evaluate_xpath_expr( op1, current )
 						else
-							raise "Primary Expr: 'Literal' and 'Number' not implemented"
+							raise "Primary Expr: '#{op1}' not valid"
 						end
-					when Rubyang::Xpath::Predicate::FunctionCall
+					when Rubyang::Xpath::FunctionCall
 						if Rubyang::Xpath::Parser::DEBUG
 							puts
 							puts "in FunctionCall"
@@ -372,41 +715,19 @@ module Rubyang
 						end
 						name = expr.name
 						case name
-						when Rubyang::Xpath::Predicate::FunctionCall::CURRENT
-							Rubyang::Xpath::LocationSteps.new
+						when Rubyang::Xpath::FunctionCall::CURRENT
+							current
 						else
 							raise "FunctionCall: #{name} not implemented"
 						end
 					else
-						raise "Unrecognized predicate: #{predicate}"
+						raise "Unrecognized Expr: #{expr}"
 					end
 				end
 			end
 
 			class InteriorNode < Node
-				def to_xml pretty: false
-					doc = REXML::Document.new
-					self.to_xml_recursive doc
-					if pretty
-						pretty_formatter = REXML::Formatters::Pretty.new( 2 )
-						pretty_formatter.compact = true
-						output = ''
-						pretty_formatter.write( doc, output )
-						output
-					else
-						doc.to_s
-					end
-				end
-				def to_json pretty: false
-					hash = Hash.new
-					self.to_json_recursive hash
-					if pretty
-						JSON.pretty_generate( hash )
-					else
-						JSON.generate( hash )
-					end
-				end
-				def to_xml_recursive _doc, current_namespace=''
+				def to_xml_recursive _doc, current_namespace
 					doc = _doc.add_element( @schema.model.arg )
 					unless @schema.namespace == current_namespace
 						current_namespace = @schema.namespace
@@ -479,8 +800,15 @@ module Rubyang
 					child_node = @children.find{ |c| c.schema == child_schema }
 					unless child_node
 						case child_schema.model
+						when Rubyang::Model::Anyxml
+							child_node = Anyxml.new( self, @schema_tree, child_schema )
 						when Rubyang::Model::Container
 							child_node = Container.new( self, @schema_tree, child_schema )
+							# when start
+							unless child_node.evaluate_whens.value
+								raise "#{arg} is not valid because of 'when' conditions"
+							end
+							# end
 						when Rubyang::Model::Leaf
 							child_node = Leaf.new( self, @schema_tree, child_schema )
 						when Rubyang::Model::List
@@ -496,12 +824,12 @@ module Rubyang
 				end
 				def edit_xpath arg
 					xpath = Rubyang::Xpath::Parser.parse arg
-					elements = self.evaluate_xpath( xpath )
-					case elements.size
+					candidates = self.evaluate_xpath( xpath )
+					case candidates.value.size
 					when 0
 						raise "no such xpath: #{arg}"
 					when 1
-						elements.first
+						candidates.value.first
 					else
 						raise "too many match to xpath: #{arg}"
 					end
@@ -515,6 +843,12 @@ module Rubyang
 			end
 
 			class Root < InteriorNode
+				def valid? current=true
+					result = @children.inject(Rubyang::Xpath::BasicType::Boolean.new true){ |r, c|
+						r.and c.valid?( false )
+					}
+					result.value
+				end
 				def commit
 					begin
 						components = self.edit( "rubyang" ).edit( "component" ).children.map{ |c|
@@ -577,6 +911,27 @@ module Rubyang
 				end
 			end
 
+			class Anyxml < Node
+				def set arg
+					@value = REXML::Document.new( arg )
+				end
+				def value
+					@value.to_s
+				end
+				def to_xml_recursive _doc, current_namespace
+					doc = _doc.add_element @value
+					unless @schema.namespace == current_namespace
+						current_namespace = @schema.namespace
+						doc.add_namespace current_namespace
+					end
+				end
+				def to_json_recursive _hash
+					raise "anyxml to json is not implemented"
+					hash = _hash
+					hash[@schema.model.arg] = @value.to_s
+				end
+			end
+
 			class Container < InteriorNode
 			end
 
@@ -733,6 +1088,15 @@ module Rubyang
 				@history = Array.new
 				@component_manager = Rubyang::Database::ComponentManager.new
 			end
+			def to_s parent=true
+				head, vars, tail = "#<#{self.class.to_s}:0x#{(self.object_id << 1).to_s(16).rjust(14,'0')} ", Array.new, ">"
+				if parent
+					vars.push "@yang=#{@root.to_s}"
+					vars.push "@history=#{@history.to_s}"
+					vars.push "@component_manager=#{@component_manager.to_s}"
+				end
+				head + vars.join(', ') + tail
+			end
 			def history
 				@history
 			end