kaiseki 0.0.3 → 1.0.1

data/lib/action.rb

@@ -0,0 +1,8 @@
+module Kaiseki
+	class Action < BasicParser
+		def parse! stream, options = {}
+			Node.new([], options[:global]).eval options[:global], &@expected
+			throw :SkipSuccess
+		end
+	end
+end

data/lib/grammar.rb

@@ -0,0 +1,88 @@
+module Kaiseki
+	class Grammar
+		attr_reader :rules, :nodes
+		attr_accessor :starting_rule, :skipping_rule, :simplify
+		
+		def initialize &block
+			@rules = Hash.new {|hash, key| raise "rule #{key.inspect} undefined" }
+			@nodes = Hash.new {|hash, key| raise "node #{key.inspect} undefined" }
+			@starting_rule = nil
+			@skipping_rule = nil
+			@simplify = true
+			
+			instance_eval &block if block_given?
+		end
+		
+		def parse stream, options = {}
+			ParseResult.new do
+				parse! stream.to_stream, options
+			end
+		end
+		
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				default_options = {
+					:grammar => self,
+					:rule => 'main',
+					:skipping => @skipping_rule,
+					:simplify => @simplify,
+					:global => {},
+				}
+				if @starting_rule
+					@starting_rule.parse stream, default_options.merge(options)
+				else
+					raise "starting rule undefined"
+				end
+			end
+		end
+		
+		def starting parseable
+			raise "starting rule already defined" if @starting_rule
+			@starting_rule = parseable
+		end
+		
+		def skipping parseable
+			raise "skipping rule already defined" if @skipping_rule
+			@skipping_rule = parseable
+		end
+		
+		def simplify bool = true
+			@simplify = bool
+		end
+		
+		def rule name, parseable = nil, &block
+			if @rules.key? name
+				raise "rule #{name.inspect} already defined"
+			else
+				if parseable and block_given?
+					raise ArgumentError, "wrong number of arguments; the second argument is mutually exclusive with a block"
+				elsif parseable
+					@rules[name] = parseable.to_parseable
+				elsif block_given?
+					@rules[name] = Rule.new(name, self, &block).parseable
+				else
+					@rules[name] = nil
+				end
+			end
+		end
+		
+		def action name, &block
+			if @rules.key? name
+				raise "rule #{name.inspect} already defined"
+			else
+				@rules[name] = block.to_parseable
+			end
+		end
+		
+		def node name, args, options = {}
+			args.must_be Array
+			if @nodes.key? name
+				raise "node #{name.inspect} already defined"
+			else
+				parent = options[:class] || Node
+				@nodes[name] = parent.subclass args, options
+			end
+		end
+	end
+end

data/lib/kaiseki.rb

@@ -1,49 +1,55 @@
-require 'pathname'
-
 module Kaiseki
-	VERSION = '0.0.3'
-end
-
-dir_path = Pathname.new(__FILE__).realpath.dirname
-
-[
-	'grammar/parslet_combining',
-	'grammar/parslet_logging',
-	'grammar/location_tracking',
-	'grammar/parse_error',
-	'grammar/parse_result',
-	'grammar/string_result',
-	'grammar/array_result',
-	
-	'grammar/stream',
-	'grammar/parslet',
-	'grammar/proc_parslet',
-	'grammar/regexp_parslet',
-	'grammar/string_parslet',
-	'grammar/symbol_parslet',
-	'grammar/eof_parslet',
-	
-	'grammar/parslet_combination',
-	'grammar/parslet_sequence',
-	'grammar/parslet_merger',
-	'grammar/parslet_choice',
-	'grammar/parslet_repetition',
-	
-	'grammar/predicate',
-	'grammar/and_predicate',
-	'grammar/not_predicate',
-	'grammar/parslet_omission',
-	
-	'grammar/grammar',
-	'grammar/parse_logger',
-	'grammar/node',
-	'grammar/grammar_node',
-	'grammar/log_node',
-	
-	'additions/proc',
-	'additions/regexp',
-	'additions/string',
-	'additions/symbol',
-	].each do |path|
-	require dir_path + path
-end
+	VERSION = '1.0.1'
+	file_path = File.dirname __FILE__
+	
+	#load basic kaiseki classes
+	require file_path + '/stream'
+	require file_path + '/parseable'
+	require file_path + '/parse_error'
+	require file_path + '/parse_result'
+	
+	#load standard class modifiers
+	require file_path + '/mod_object'
+	require file_path + '/mod_string'
+	require file_path + '/mod_regexp'
+	require file_path + '/mod_symbol'
+	require file_path + '/mod_proc'
+	require file_path + '/mod_file'
+	require file_path + '/mod_kernel'
+	
+	#load parsers
+	require file_path + '/parser_basic'
+	require file_path + '/parser_string'
+	require file_path + '/parser_regexp'
+	require file_path + '/parser_symbol'
+	require file_path + '/parser_eof'
+	
+	require file_path + '/parser_multi'
+	require file_path + '/parser_sequence'
+	require file_path + '/parser_choice'
+	require file_path + '/parser_repeat'
+	
+	require file_path + '/parser_package'
+	
+	#load predicates
+	require file_path + '/predicate_and'
+	require file_path + '/predicate_not'
+	require file_path + '/predicate_skip'
+	
+	#load result modifiers
+	require file_path + '/result_override'
+	require file_path + '/result_merge'
+	require file_path + '/result_cast'
+	require file_path + '/result_filter'
+	require file_path + '/node'
+	
+	#load grammar classes
+	require file_path + '/grammar'
+	require file_path + '/rule'
+	require file_path + '/action'
+	
+	#load varible manipulators
+	require file_path + '/var_set'
+	require file_path + '/var_get'
+	require file_path + '/var_insert'
+end

data/lib/mod_file.rb

@@ -0,0 +1,5 @@
+class File
+	def to_stream
+		Kaiseki::Stream.new self
+	end
+end

data/lib/mod_kernel.rb

@@ -0,0 +1,11 @@
+module Kernel
+	private
+	
+	def get var, parser
+		Kaiseki::GetVar.new var, parser
+	end
+	
+	def insert var
+		Kaiseki::InsertVar.new var
+	end
+end

data/lib/mod_object.rb

@@ -0,0 +1,11 @@
+class Object
+	def must_be item
+		raise TypeError, "can't convert #{self.class} into #{item}" unless self.is_a? item
+		true
+	end
+	
+	def must_have property, value
+		raise StandardError, "##{property} must be #{value} (#{self.send(property)})" unless self.send(property) == value
+		true
+	end
+end

data/lib/mod_proc.rb

@@ -0,0 +1,7 @@
+class Proc
+	include Kaiseki::Parseable
+	
+	def to_parseable
+		Kaiseki::Action.new self
+	end
+end

data/lib/mod_regexp.rb

@@ -0,0 +1,7 @@
+class Regexp
+	include Kaiseki::Parseable
+	
+	def to_parseable
+		Kaiseki::RegexpParser.new self
+	end
+end

data/lib/mod_string.rb

@@ -0,0 +1,11 @@
+class String
+	include Kaiseki::Parseable
+	
+	def to_parseable
+		Kaiseki::StringParser.new self
+	end
+	
+	def to_stream
+		Kaiseki::Stream.new self
+	end
+end

data/lib/mod_symbol.rb

@@ -0,0 +1,27 @@
+class Symbol
+	include Kaiseki::Parseable
+	
+	def to_parseable
+		if self == :EOF
+			Kaiseki::EOFParser.new
+		else
+			Kaiseki::SymbolParser.new self
+		end
+	end
+	
+	def to_instance_variable
+		if self[0] == '@'
+			self
+		else
+			:"@#{self}"
+		end
+	end
+	
+	def from_instance_variable
+		if self[0] == '@'
+			self[1..-1].to_sym
+		else
+			self
+		end
+	end
+end

data/lib/node.rb

@@ -0,0 +1,78 @@
+module Kaiseki
+	class Node
+		def initialize args = [], global = nil
+			args.must_be Array
+			if global
+				global.each_pair do |key, value|
+					instance_variable_set key.to_instance_variable, value
+				end
+			end
+			list = args.reverse
+			self.class.arg_names.each do |name|
+				value = []
+				while 0 >= self.class.arity[name] or value.length < self.class.arity[name]
+					if !list.empty?
+						value << list.pop
+					elsif value.empty? and self.class.defaults.key?(name)
+						value << self.class.defaults[name]
+						break
+					else
+						if self.class.arity[name] <= 0
+							break
+						else
+							raise ArgumentError, "wrong number of arguments (#{value.length} for #{self.class.arity[name]})"
+						end
+					end
+				end
+				if self.class.arity[name] == 1
+					value = value[0]
+				elsif self.class.arity[name] == 0
+					if value.length < 1
+						value = nil
+					elsif value.length == 1
+						value = value[0]
+					end
+				end
+				instance_variable_set name.to_instance_variable, value
+			end
+		end
+		
+		def eval global = nil, &block
+			value = instance_eval &block
+			if global
+				(instance_variables.collect {|n| n.from_instance_variable } - self.class.arg_names).each do |n|
+					global[n] = instance_variable_get n.to_instance_variable
+				end
+			end
+			value
+		end
+	end
+	
+	class << Node
+		def subclass args, options = {}
+			args.must_be Array
+			Class.new(self).bind args, options
+		end
+		
+		def bind args, options = {}
+			args.must_be Array
+			raise "can't bind parent NodeClass" if self == Node
+			define_singleton_method(:arg_names) { args }
+			define_singleton_method(:arity) { Hash.new {|hash, key| 1 }.merge(options[:arity] || {}) }
+			define_singleton_method(:defaults) { options[:defaults] || {} }
+			self
+		end
+		
+		def arg_names
+			[]
+		end
+		
+		def arity
+			{}
+		end
+		
+		def defaults
+			{}
+		end
+	end
+end

data/lib/parse_error.rb

@@ -0,0 +1,16 @@
+module Kaiseki
+	class ParseError < StandardError
+		attr_accessor :rule, :line, :column
+		
+		def initialize string, options
+			super string
+			@rule = options[:rule]
+			@line = nil
+			@column = nil
+		end
+		
+		def verbose
+			to_s
+		end
+	end
+end

data/lib/parse_result.rb

@@ -0,0 +1,21 @@
+module Kaiseki
+	class ParseResult
+		attr_reader :result, :error
+		
+		def initialize &block
+			begin
+				catch :SkipSuccess do
+					@result = block.call
+					return
+				end
+				@result = '(skipped)'
+			rescue ParseError => e
+				@error = e
+			end
+		end
+		
+		def has_errors?
+			!!@error
+		end
+	end
+end

data/lib/parseable.rb

@@ -0,0 +1,67 @@
+module Kaiseki
+	module Parseable
+		def to_parseable
+			self
+		end
+		
+		def parse stream, options = {}
+			self.to_parseable.parse! stream.to_stream, options
+		end
+		
+		def & other
+			SequenceParser.new self, other
+		end
+		
+		def | other
+			ChoiceParser.new self, other
+		end
+		
+		def repeat min, max = nil
+			RepeatParser.new self, min, max
+		end
+		
+		def optional
+			repeat 0, 1
+		end
+		
+		def zero_or_more
+			repeat 0
+		end
+		
+		def one_or_more
+			repeat 1
+		end
+		
+		def and?
+			AndPredicate.new self
+		end
+		
+		def not!
+			NotPredicate.new self
+		end
+		
+		def skip
+			SkipPredicate.new self
+		end
+		
+		def override options
+			OverrideResult.new self, options
+		end
+		
+		def merge
+			MergeResult.new self
+		end
+		
+		def cast to_class
+			CastResult.new self, to_class
+		end
+		
+		def filter node = Node.subclass([:result], :arity => {:result => 0}), &block
+			FilterResult.new self, node, &block
+		end
+		
+		def set *vars
+			SetVar.new self, *vars
+		end
+	end
+end

data/lib/{grammar/parslet.rb → parser_basic.rb}

@@ -1,29 +1,24 @@
 module Kaiseki
-	class Parslet
-		include ParsletCombining
-		
+	class BasicParser
+		include Parseable
 		attr_reader :expected
 		
 		def initialize expected
 			@expected = expected
 		end
 		
-		def parse *args
+		def parse! stream, options = {}
 			raise NotImplementedError
 		end
 		
-		def to_s
-			"#{@expected}"
-		end
-		
-		def to_parseable
-			self
-		end
-		
 		def eql? other
 			other.is_a?(self.class) and other.expected == @expected
 		end
 		
 		alias :== :eql?
+		
+		def to_s
+			@expected.inspect
+		end
 	end
 end

data/lib/parser_choice.rb

@@ -0,0 +1,24 @@
+module Kaiseki
+	class ChoiceParser < MultiParser
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				error = true
+				@expected.each do |n|
+					begin
+						return n.parse stream, options
+					rescue ParseError
+						next
+					end
+				end
+				raise ParseError.new "no valid alternatives when parsing #{self}", options
+			end
+		end
+		
+		alias :| :append
+		
+		def delimiter
+			'|'
+		end
+	end
+end

data/lib/parser_eof.rb

@@ -0,0 +1,27 @@
+module Kaiseki
+	class EOFParser
+		include Parseable
+		
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				actual = stream.getc
+				if actual
+					raise ParseError.new "unexpected character \"#{actual}\" (expected end-of-string) when parsing #{self}", options
+				else
+					throw :SkipSuccess
+				end
+			end
+		end
+		
+		def eql? other
+			other.is_a? self.class
+		end
+		
+		alias :== :eql?
+		
+		def to_s
+			'EOF'
+		end
+	end
+end

data/lib/parser_multi.rb

@@ -0,0 +1,27 @@
+module Kaiseki
+	class MultiParser < BasicParser
+		def initialize *parsers
+			@expected = []
+			parsers.each do |n|
+				append n
+			end
+		end
+		
+		def append parseable
+			@expected << parseable.to_parseable
+			self
+		end
+		
+		def delimiter
+			'--'
+		end
+		
+		def to_s
+			if @expected.empty?
+				'(empty)'
+			else
+				@expected.join ' ' + delimiter + ' '
+			end
+		end
+	end
+end

data/lib/parser_package.rb

@@ -0,0 +1,11 @@
+module Kaiseki
+	class PackageParser < BasicParser
+		def initialize expected
+			super expected.to_parseable
+		end
+		
+		def to_s
+			@expected.to_s
+		end
+	end
+end

data/lib/parser_regexp.rb

@@ -0,0 +1,19 @@
+module Kaiseki
+	class RegexpParser < BasicParser
+		def parse! stream, options = {}
+			stream.must_be Stream
+			stream.lock do
+				match = stream.match @expected
+				if match
+					if options[:simplify]
+						match.to_s
+					else
+						match
+					end
+				else
+					raise ParseError.new "non-matching characters when parsing #{self}", options
+				end
+			end
+		end
+	end
+end