kaiseki 0.0.3

data/lib/additions/proc.rb

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

data/lib/additions/regexp.rb

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

data/lib/additions/string.rb

@@ -0,0 +1,7 @@
+class String
+	include Kaiseki::ParsletCombining
+	
+	def to_parseable
+		Kaiseki::StringParslet.new self
+	end
+end

data/lib/additions/symbol.rb

@@ -0,0 +1,19 @@
+class Symbol
+	include Kaiseki::ParsletCombining
+	
+	def to_parseable
+		self == :EOF ? Kaiseki::EOFParslet.new : Kaiseki::SymbolParslet.new(self)
+	end
+	
+	def to_instance_variable_name
+		self[0] == '@' ? self : :"@#{self}"
+	end
+	
+	def to_class_variable_name
+		self[0..1] == '@@' ? self : :"@@#{self}"
+	end
+	
+	def to_class_name
+		self.to_s.split('_').collect {|n| n.capitalize }.join.to_sym
+	end
+end

data/lib/grammar/and_predicate.rb

@@ -0,0 +1,22 @@
+module Kaiseki
+	class AndPredicate < Predicate
+		def initialize parseable
+			super parseable
+			@prefix = 'and'
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			pos = stream.pos
+			begin
+				@parseable.parse stream, options
+			rescue ParseError
+				stream.rewind pos
+				raise ParseError.new "Predicate not satisfied (expecting `#{@parseable}')",
+						options.merge(:line_end => stream.line, :column_end => stream.column)
+			end
+			stream.rewind pos
+			throw :PredicateSuccess
+		end
+	end
+end

data/lib/grammar/array_result.rb

@@ -0,0 +1,16 @@
+module Kaiseki
+	class ArrayResult < Array
+		include LocationTracking
+		
+		attr_reader :info
+		
+		def initialize arg1 = 0, arg2 = nil, info = {}
+			super arg1, arg2
+			self.line_start = info[:line_start] if info.key? :line_start
+			self.column_start = info[:column_start] if info.key? :column_start
+			self.line_end = info[:line_end] if info.key? :line_end
+			self.column_end = info[:column_end] if info.key? :column_end
+			@info = info
+		end
+	end
+end

data/lib/grammar/eof_parslet.rb

@@ -0,0 +1,32 @@
+module Kaiseki
+	class EOFParslet
+		include ParsletCombining
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			pos = stream.pos
+			char = stream.getc
+			if char
+				stream.rewind pos
+				raise ParseError.new "unexpected character `#{char}' (expected EOF)",
+						options.merge(:line_end => stream.line, :column_end => stream.column)
+			else
+				throw :PredicateSuccess
+			end
+		end
+		
+		def to_s
+			'EOF'
+		end
+		
+		def to_parseable
+			self
+		end
+		
+		def eql? other
+			other.is_a? EOFParslet
+		end
+		
+		alias :== :eql?
+	end
+end

data/lib/grammar/grammar.rb

@@ -0,0 +1,113 @@
+module Kaiseki
+	class Grammar
+		attr_reader :starting_rule, :skipping_rule, :rules, :overrides, :nodes, :actions
+		
+		def initialize &block
+			@starting_rule = nil
+			@skipping_rule = nil
+			
+			@rules = Hash.new {|hash, key| raise NameError, "rule `#{key}' is not defined" }
+			@overrides = Hash.new {|hash, key| raise NameError, "override `#{key}' is not defined" }
+			@nodes = Hash.new {|hash, key| raise NameError, "node `#{key}' is not defined" }
+			@actions = Hash.new {|hash, key| raise NameError, "action `#{key}' is not defined" }
+			
+			@simplify = false
+			
+			instance_eval &block if block_given?
+		end
+		
+		def starting parseable
+			raise StandardError, "starting rule already defined" if @starting_rule
+			@starting_rule = parseable.to_parseable
+		end
+		
+		def skipping parseable
+			raise StandardError, "skipping rule already defined" if @skipping_rule
+			@skipping_rule = parseable.to_parseable
+		end
+		
+		def rule symbol, &block
+			raise TypeError, "can't convert #{symbol.class} into Symbol" unless symbol.is_a? Symbol
+			raise StandardError, "rule `#{symbol}' already defined" if @rules.key? symbol
+			GrammarNode.new(symbol, self).instance_eval(&block) if block_given?
+			@rules[symbol] = ProcParslet.new { raise NotImplementedError, "rule `#{symbol}' not yet implemented" } unless @rules.key? symbol
+		end
+		
+		def simplify
+			@simplify = true
+		end
+		
+		def parse! source, options = {}
+			raise StandardError, "starting rule not defined" unless @starting_rule
+			stream = source.is_a?(Stream) ? source : Stream.new(source)
+			options[:grammar] = self
+			options[:file] = stream.file
+			options[:rule] = @starting_rule.is_a?(SymbolParslet) ? @starting_rule.expected : :root
+			options[:skipping] = @skipping_rule
+			options[:simplify] = @simplify
+			@starting_rule.parse stream, options
+		end
+		
+		def parse source, options = {}
+			stream = source.is_a?(Stream) ? source : Stream.new(source)
+			result = ParseResult.new self, stream, options
+			begin
+				result.result = parse! stream, options.merge(:logger => result.logger)
+			rescue ParseError => e
+				result.error = e
+			end
+			result
+		end
+		
+		def wrap stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			raise ArgumentError, "wrapping requires a rule" unless options.key? :rule
+			rule = options[:rule]
+			options.merge! @overrides[rule] if @overrides.key? rule
+			result = @rules[rule].parse stream, options
+			if @nodes.key?(rule) and @actions.key?(rule)
+				node_class = @nodes[rule]
+				if node_class.arity == 1
+					node = node_class.new result
+				else
+					node = node_class.new *result
+				end
+				node.instance_eval &@actions[rule]
+			else
+				result
+			end
+		end
+	end
+	
+	class << Grammar
+		def subclass &block
+			if block_given?
+				subclass = Class.new self
+				subclass.bind &block
+				subclass
+			else
+				Class.new self
+			end
+		end
+		
+		def bind &block
+			if self == Grammar
+				raise StandardError, "Grammar rootclass can't be bound"
+			elsif bound?
+				raise StandardError, "Grammar can't be bound multiple times"
+			else
+				self.send :define_method, :initialize do
+					super &block
+				end
+				self.define_singleton_method :bound? do
+					true
+				end
+			end
+			true
+		end
+		
+		def bound?
+			false
+		end
+	end
+end

data/lib/grammar/grammar_node.rb

@@ -0,0 +1,31 @@
+module Kaiseki
+	class GrammarNode < Node
+		def parse parseable
+			raise StandardError, "rule `#{@name}' already defined" if @grammar.rules.key? @name
+			@grammar.rules[@name] = parseable.to_parseable
+		end
+		
+		def override options
+			raise StandardError, "rule `#{@name}' not defined" unless @grammar.rules.key? @name
+			raise StandardError, "override already deinfed for rule `#{@name}'" if @grammar.overrides.key? @name
+			@grammar.overrides[@name] = options
+		end
+		
+		def node options = {:params => [:results]}
+			superclass = options.key?(:superclass) ? options[:superclass] : Node
+			raise TypeError, "can't convert #{superclass.class} into Class" unless superclass.is_a? Class
+			raise StandardError, "rule `#{@name}' not defined" unless @grammar.rules.key? @name
+			raise StandardError, "node already defined for rule `#{@name}'" if @grammar.nodes.key? @name
+			node = @grammar.nodes[@name] = superclass.subclass(*options[:params])
+		end
+		
+		def action &block
+			raise StandardError, "rule `#{@name}' not defined" unless @grammar.rules.key? @name
+			raise StandardError, "action already defined for rule `#{@name}'" if @grammar.actions.key? @name
+			@grammar.nodes[@name] = node unless @grammar.nodes.key? @name
+			@grammar.actions[@name] = block
+		end
+	end
+
+	GrammarNode.bind :name, :grammar
+end

data/lib/grammar/location_tracking.rb

@@ -0,0 +1,57 @@
+module Kaiseki
+	module LocationTracking
+		def line_start
+			@line_start || 0
+		end
+		
+		def line_start= number
+			@line_start = number.to_i
+		end
+		
+		def column_start
+			@column_start || 0
+		end
+		
+		def column_start= number
+			@column_start = number.to_i
+		end
+		
+		def start
+			[line_start, column_start]
+		end
+		
+		def start= array
+			raise TypeError, "can't convert #{array.class} into Array" unless array.is_a? Array
+			raise ArgumentError, "array must have length 2" unless array.length == 2
+			@line_start = array[0]
+			@column_start = array[1]
+		end
+		
+		def line_end
+			@line_end || 0
+		end
+		
+		def line_end= number
+			@line_end = number.to_i
+		end
+		
+		def column_end
+			@column_end || 0
+		end
+		
+		def column_end= number
+			@column_end = number.to_i
+		end
+		
+		def end
+			[line_end, column_end]
+		end
+		
+		def end= array
+			raise TypeError, "can't convert #{array.class} into Array" unless array.is_a? Array
+			raise ArgumentError, "array must have length 2" unless array.length == 2
+			@line_end = array[0]
+			@column_end = array[1]
+		end
+	end
+end

data/lib/grammar/log_node.rb

@@ -0,0 +1,21 @@
+module Kaiseki
+	class LogNode
+		attr_accessor :result
+		attr_reader :parslet, :children
+		
+		def initialize parslet
+			@parslet = parslet
+			@children = []
+			@result = nil
+		end
+		
+		def add node
+			@children << node
+		end
+		
+		def print indent = 0
+			puts " " * indent + "in #{@parslet} got #{@result}"
+			@children.each {|n| n.print indent + 2 }
+		end
+	end
+end

data/lib/grammar/node.rb

@@ -0,0 +1,59 @@
+module Kaiseki
+	class Node
+		
+	end
+	
+	class << Node
+		def subclass *parameters
+			if parameters.empty?
+				Class.new self
+			else
+				subclass = Class.new self
+				subclass.bind *parameters
+				subclass
+			end
+		end
+		
+		def bind *parameters
+			if self == Node
+				raise StandardError, "Node rootclass can't be bound"
+			elsif bound?
+				raise StandardError, "Node can't be bound multiple times"
+			else
+				self.send :define_method, :initialize do |*arguments|
+					raise ArgumentError, "wrong number of arguments (#{arguments.length} for #{parameters.length})" unless arguments.length == parameters.length
+					arguments.length.times do |i|
+						instance_variable_set parameters[i].to_instance_variable_name, arguments[i]
+					end
+				end
+				parameters.each do |parameter|
+					self.send :define_method, parameter do
+						instance_variable_get parameter.to_instance_variable_name
+					end
+				end
+				self.define_singleton_method :arity do
+					parameters.length
+				end
+				self.define_singleton_method :parameters do
+					parameters.dup
+				end
+				self.define_singleton_method :bound? do
+					true
+				end
+			end
+			true
+		end
+		
+		def arity
+			0
+		end
+		
+		def parameters
+			[]
+		end
+		
+		def bound?
+			false
+		end
+	end
+end

data/lib/grammar/not_predicate.rb

@@ -0,0 +1,22 @@
+module Kaiseki
+	class NotPredicate < Predicate
+		def initialize parseable
+			super parseable
+			@prefix = 'not'
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			pos = stream.pos
+			begin
+				@parseable.parse stream, options
+			rescue ParseError
+				stream.rewind pos
+				throw :PredicateSuccess
+			end
+			stream.rewind pos
+			raise ParseError.new "predicate not satisfied (`#{@parseable}' not allowed)",
+					options.merge(:line_end => stream.line, :column_end => stream.column)
+		end
+	end
+end

data/lib/grammar/parse_error.rb

@@ -0,0 +1,21 @@
+module Kaiseki
+	class ParseError < Exception
+		include LocationTracking
+		
+		attr_reader :file, :rule
+		
+		def initialize message, info = {}
+			super message
+			self.line_start = info[:line_start] if info.key? :line_start
+			self.column_start = info[:column_start] if info.key? :column_start
+			self.line_end = info[:line_end] if info.key? :line_end
+			self.column_end = info[:column_end] if info.key? :column_end
+			@file = info[:file]
+			@rule = info[:rule]
+		end
+		
+		def location
+			"from #{@file || 'unknown'}:#{line_end + 1}:#{column_end + 1} in #{@rule || 'unknown'}"
+		end
+	end
+end

data/lib/grammar/parse_logger.rb

@@ -0,0 +1,27 @@
+module Kaiseki
+	class ParseLogger
+		attr_accessor :root
+		attr_reader :stack
+		
+		def initialize
+			@root = nil
+			@stack = []
+		end
+		
+		def push item
+			@stack.push item
+		end
+		
+		def pop
+			@stack.pop
+		end
+		
+		def add item
+			@stack.last.add item
+		end
+		
+		def backtrace
+			@root.print
+		end
+	end
+end

data/lib/grammar/parse_result.rb

@@ -0,0 +1,33 @@
+module Kaiseki
+	class ParseResult
+		attr_accessor :grammar, :stream, :options, :result, :error, :logger
+		
+		def initialize grammar, stream, options
+			@grammar = grammar
+			@stream = stream
+			@options = options
+			@result = nil
+			@error = nil
+			@logger = ParseLogger.new
+		end
+		
+		def parsed?
+			!@error
+		end
+		
+		def error_message
+			"#{@error}\n\t#{@error.location}"
+		end
+		
+		alias :msg :error_message
+		
+		def reparse options = {}
+			@stream.rewind
+			@grammar.parse @stream, @options.merge(options)
+		end
+		
+		def backtrace
+			@logger.backtrace
+		end
+	end
+end

data/lib/grammar/parslet.rb

@@ -0,0 +1,29 @@
+module Kaiseki
+	class Parslet
+		include ParsletCombining
+		
+		attr_reader :expected
+		
+		def initialize expected
+			@expected = expected
+		end
+		
+		def parse *args
+			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?
+	end
+end

data/lib/grammar/parslet_choice.rb

@@ -0,0 +1,25 @@
+module Kaiseki
+	class ParsletChoice < ParsletCombination
+		def initialize *components
+			super *components
+			@delimiter = '|'
+		end
+		
+		alias :| :append
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			parsed = ArrayResult.new
+			error = nil
+			@components.each do |parseable|
+				begin
+					return parseable.parse stream, options
+				rescue ParseError => e
+					error = e
+				end
+			end
+			raise ParseError.new "no valid alternatives (#{error})",
+					options.merge(:line_end => stream.line, :column_end => stream.column)
+		end
+	end
+end

data/lib/grammar/parslet_combination.rb

@@ -0,0 +1,35 @@
+module Kaiseki
+	class ParsletCombination
+		include ParsletCombining
+		
+		attr_reader :components
+		
+		def initialize *components
+			@components = components
+			@delimiter = '--'
+		end
+		
+		def append object
+			@components << object.to_parseable
+			self
+		end
+		
+		def parse *args
+			raise NotImplementedError
+		end
+		
+		def to_s
+			"<#{@components.join " #{@delimiter} "}>"
+		end
+		
+		def to_parseable
+			self
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.components == @components
+		end
+		
+		alias :== :eql?
+	end
+end

data/lib/grammar/parslet_combining.rb

@@ -0,0 +1,57 @@
+module Kaiseki
+	module ParsletCombining
+		def sequence other
+			ParsletSequence.new self.to_parseable, other.to_parseable
+		end
+		
+		alias :& :sequence
+		
+		def merge other
+			ParsletMerger.new self.to_parseable, other.to_parseable
+		end
+		
+		alias :>> :merge
+		
+		def choose other
+			ParsletChoice.new self.to_parseable, other.to_parseable
+		end
+		
+		alias :| :choose
+		
+		def repeat min, max = nil
+			ParsletRepetition.new self.to_parseable, min, max
+		end
+		
+		def optional
+			repeat 0, 1
+		end
+		
+		alias :zero_or_one :optional
+		
+		def zero_or_more
+			repeat 0
+		end
+		
+		def one_or_more
+			repeat 1
+		end
+		
+		def and_predicate
+			AndPredicate.new self.to_parseable
+		end
+		
+		alias :and? :and_predicate
+		
+		def not_predicate
+			NotPredicate.new self.to_parseable
+		end
+		
+		alias :not! :not_predicate
+		
+		def omission
+			ParsletOmission.new self.to_parseable
+		end
+		
+		alias :skip :omission
+	end
+end

data/lib/grammar/parslet_logging.rb

@@ -0,0 +1,22 @@
+module Kaiseki
+	module ParsletLogging
+		def log parse_logger = nil, &block
+			if parse_logger
+				node = LogNode.new self
+				parse_logger.root ? parse_logger.add(node) : parse_logger.root = node
+				parse_logger.push node
+				begin
+					node.result = block.call
+					parse_logger.pop
+					node.result
+				rescue ParseError => e
+					node.result = e
+					parse_logger.pop
+					raise e
+				end
+			else
+				block.call
+			end
+		end
+	end
+end

data/lib/grammar/parslet_merger.rb

@@ -0,0 +1,50 @@
+module Kaiseki
+	class ParsletMerger < ParsletCombination
+		def initialize *components
+			super *components
+			@delimiter = '&'
+		end
+		
+		alias :>> :append
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			parsed = ArrayResult.new
+			pos = stream.pos
+			@components.each do |parseable|
+				catch :PredicateSuccess do
+					begin
+						result = parseable.parse stream, options
+						if result.respond_to? :each
+							result.each {|n| parsed << n }
+						else
+							parsed << result
+						end
+					rescue ParseError => e
+						if options[:skipping]
+							begin
+								options[:skipping].parse stream, options.merge(:skipping => nil, :logger => nil)
+								redo
+							rescue ParseError
+								stream.rewind pos
+								raise e
+							end
+						else
+							stream.rewind pos
+							raise e
+						end
+					end
+				end
+			end
+			if options[:simplify]
+				if parsed.length == 1
+					parsed.first
+				else
+					parsed
+				end
+			else
+				parsed
+			end
+		end
+	end
+end

data/lib/grammar/parslet_omission.rb

@@ -0,0 +1,20 @@
+module Kaiseki
+	class ParsletOmission < Predicate
+		def initialize parseable
+			super parseable
+			@prefix = 'skip'
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			pos = stream.pos
+			begin
+				@parseable.parse stream, options
+			rescue ParseError => e
+				stream.rewind pos
+				raise e
+			end
+			throw :PredicateSuccess
+		end
+	end
+end

data/lib/grammar/parslet_repetition.rb

@@ -0,0 +1,65 @@
+module Kaiseki
+	class ParsletRepetition
+		include ParsletCombining
+		
+		attr_reader :parseable, :min, :max
+		
+		def initialize parseable, min, max = nil
+			@parseable = parseable
+			@min = min
+			@max = max
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			parsed = ArrayResult.new
+			pos = stream.pos
+			while @max.nil? or parsed.length < @max
+				begin
+					parsed << @parseable.parse(stream, options)
+				rescue ParseError
+					if options[:skipping]
+						begin
+							options[:skipping].parse stream, options.merge(:skipping => nil, :logger => nil)
+							redo
+						rescue ParseError
+							break
+						end
+					else
+						break
+					end
+				end
+			end
+			
+			if parsed.length < @min
+				stream.rewind pos
+				raise ParseError.new "required #{@min} match#{'es' unless @min == 1} but obtained #{parsed.length} (expected `#{@parseable}')",
+						options.merge(:line_end => stream.line, :column_end => stream.column)
+			else
+				if options[:simplify]
+					if @min == 0 and @max == 1
+						parsed.length == 0 ? nil : parsed.first
+					else
+						parsed
+					end
+				else
+					parsed
+				end
+			end
+		end
+		
+		def to_s
+			"repeat(#{@min}, #{@max}): #{@parseable}"
+		end
+		
+		def to_parseable
+			self
+		end
+		
+		def eql? other
+			other.is_a?(ParsletRepetition) and other.parseable == @parseable and other.min == @min and other.max == @max
+		end
+		
+		alias :== :eql?
+	end
+end

data/lib/grammar/parslet_sequence.rb

@@ -0,0 +1,45 @@
+module Kaiseki
+	class ParsletSequence < ParsletCombination
+		def initialize *components
+			super *components
+			@delimiter = '&'
+		end
+		
+		alias :& :append
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			parsed = ArrayResult.new
+			pos = stream.pos
+			@components.each do |parseable|
+				catch :PredicateSuccess do
+					begin
+						parsed << parseable.parse(stream, options)
+					rescue ParseError => e
+						if options[:skipping]
+							begin
+								options[:skipping].parse stream, options.merge(:skipping => nil, :logger => nil)
+								redo
+							rescue ParseError
+								stream.rewind pos
+								raise e
+							end
+						else
+							stream.rewind pos
+							raise e
+						end
+					end
+				end
+			end
+			if options[:simplify]
+				if parsed.length == 1
+					parsed.first
+				else
+					parsed
+				end
+			else
+				parsed
+			end
+		end
+	end
+end

data/lib/grammar/predicate.rb

@@ -0,0 +1,30 @@
+module Kaiseki
+	class Predicate
+		include ParsletCombining
+		
+		attr_reader :parseable
+		
+		def initialize parseable
+			@parseable = parseable
+			@prefix = 'predicate'
+		end
+		
+		def parse *args
+			raise NotImplementedError
+		end
+		
+		def to_s
+			"<#{@prefix}:#{@parseable}>"
+		end
+		
+		def to_parseable
+			self
+		end
+		
+		def eql? other
+			other.is_a?(self.class) and other.parseable == @parseable
+		end
+		
+		alias :== :eql?
+	end
+end

data/lib/grammar/proc_parslet.rb

@@ -0,0 +1,18 @@
+module Kaiseki
+	class ProcParslet < Parslet
+		def initialize procedure = nil, &block
+			raise ArgumentError, "can't have both an argument and a block" if block_given? and procedure
+			if block_given?
+				super block
+			else
+				raise TypeError, "can't convert #{procedure.class} into Proc" unless procedure.is_a? Proc
+				super procedure
+			end
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			@expected.call stream, options
+		end
+	end
+end

data/lib/grammar/regexp_parslet.rb

@@ -0,0 +1,25 @@
+module Kaiseki
+	class RegexpParslet < Parslet
+		def initialize regexp
+			raise TypeError, "can't convert #{regexp.class} into Regexp" unless regexp.is_a? Regexp
+			super regexp
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			parsed = StringResult.new
+			pos = stream.pos
+			match = stream.getc(-1).match /\A#{@expected}/
+			if match
+				stream.rewind pos + match.to_s.length
+				parsed << match.to_s
+				parsed.info[:captures] = match.captures
+				parsed
+			else
+				stream.rewind pos
+				raise ParseError.new "non-matching characters while parsing `#{@expected}'",
+						options.merge(:line_end => stream.line, :column_end => stream.column)
+			end
+		end
+	end
+end

data/lib/grammar/stream.rb

@@ -0,0 +1,90 @@
+module Kaiseki
+	class Stream
+		attr_reader :file
+		
+		def initialize source
+			if source.is_a? String
+				@file = nil
+				@string = source.dup
+			elsif source.is_a? File
+				@file = source.path
+				@string = ''
+				source.each_char {|c| @string << c }
+			else
+				raise TypeError, "can't convert #{source.class} into Stream"
+			end
+			@pos = 0
+			@newlines = []
+			start = 0
+			@string.length.times do |i|
+				if @string[i] == "\n"
+					@newlines << [start, i]
+					start = i + 1
+				end
+			end
+			@newlines << [start, @string.length]
+		end
+		
+		def to_s
+			@string.dup
+		end
+		
+		def length
+			@string.length
+		end
+		
+		def pos
+			@pos
+		end
+		
+		def line
+			bsearch @pos, 0, @newlines.length
+		end
+		
+		def column
+			@pos - @newlines[self.line].first
+		end
+		
+		def getc num = 0
+			if num == 0
+				char = @string[@pos]
+				if char
+					@pos += 1
+					char
+				end
+			elsif num > 0
+				string = @string[@pos..(@pos + num - 1)]
+				@pos += string.length
+				string
+			else
+				string = @string[@pos..num]
+				@pos += string.length
+				string
+			end
+		end
+		
+		def rewind pos = 0
+			if pos < 0
+				pos = @string.length + pos + 1
+				@pos = pos < 0 ? 0 : pos
+			elsif pos > @string.length
+				@pos = @string.length
+			else
+				@pos = pos
+			end
+		end
+		
+		private
+		def bsearch value, low, high
+			return nil if high < low
+			mid = low + (high - low) / 2
+			if value < @newlines[mid].first
+				bsearch value, low, mid - 1
+			elsif value > @newlines[mid].last
+				bsearch value, mid + 1, high
+			else
+				mid
+			end
+		end
+	end
+end

data/lib/grammar/string_parslet.rb

@@ -0,0 +1,29 @@
+module Kaiseki
+	class StringParslet < Parslet
+		def initialize string
+			raise TypeError, "can't convert #{string.class} into String" unless string.is_a? String
+			super string
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			parsed = StringResult.new
+			pos = stream.pos
+			@expected.each_char do |char|
+				actual = stream.getc
+				if actual.nil?
+					stream.rewind pos
+					raise ParseError.new "unexpected end-of-string (expected `#{char}') while parsing `#{@expected}'",
+							options.merge(:line_end => stream.line, :column_end => stream.column)
+				elsif actual != char
+					stream.rewind pos
+					raise ParseError.new "unexpected character `#{actual}' (expected `#{char}') while parsing `#{@expected}'",
+							options.merge(:line_end => stream.line, :column_end => stream.column)
+				else
+					parsed << actual
+				end
+			end
+			parsed
+		end
+	end
+end

data/lib/grammar/string_result.rb

@@ -0,0 +1,16 @@
+module Kaiseki
+	class StringResult < String
+		include LocationTracking
+		
+		attr_reader :info
+		
+		def initialize string = '', info = {}
+			super string
+			self.line_start = info[:line_start] if info.key? :line_start
+			self.column_start = info[:column_start] if info.key? :column_start
+			self.line_end = info[:line_end] if info.key? :line_end
+			self.column_end = info[:column_end] if info.key? :column_end
+			@info = info
+		end
+	end
+end

data/lib/grammar/symbol_parslet.rb

@@ -0,0 +1,22 @@
+module Kaiseki
+	class SymbolParslet < Parslet
+		include ParsletLogging
+		
+		def initialize symbol
+			raise TypeError, "can't convert #{symbol.class} into Symbol" unless symbol.is_a? Symbol
+			super symbol
+		end
+		
+		def parse stream, options = {}
+			raise TypeError, "can't convert #{stream.class} into Stream" unless stream.is_a? Stream
+			raise ArgumentError, "parsing requires a grammar" unless options.key? :grammar
+			log options[:logger] do
+				options[:grammar].wrap stream, options.merge(:rule => @expected)
+			end
+		end
+		
+		def to_s
+			":#{@expected}"
+		end
+	end
+end

data/lib/kaiseki.rb

@@ -0,0 +1,49 @@
+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

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: kaiseki
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- William Hamilton-Levi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-23 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: A parsing expression grammar generator written in Ruby.
+email: whamilt1@swarthmore.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/kaiseki.rb
+- lib/additions/symbol.rb
+- lib/additions/string.rb
+- lib/additions/regexp.rb
+- lib/additions/proc.rb
+- lib/grammar/array_result.rb
+- lib/grammar/symbol_parslet.rb
+- lib/grammar/string_parslet.rb
+- lib/grammar/eof_parslet.rb
+- lib/grammar/string_result.rb
+- lib/grammar/grammar_node.rb
+- lib/grammar/node.rb
+- lib/grammar/parslet_omission.rb
+- lib/grammar/parslet.rb
+- lib/grammar/regexp_parslet.rb
+- lib/grammar/predicate.rb
+- lib/grammar/stream.rb
+- lib/grammar/parslet_sequence.rb
+- lib/grammar/parslet_merger.rb
+- lib/grammar/not_predicate.rb
+- lib/grammar/parslet_combination.rb
+- lib/grammar/parslet_repetition.rb
+- lib/grammar/parse_result.rb
+- lib/grammar/parslet_logging.rb
+- lib/grammar/parse_logger.rb
+- lib/grammar/grammar.rb
+- lib/grammar/log_node.rb
+- lib/grammar/and_predicate.rb
+- lib/grammar/parslet_choice.rb
+- lib/grammar/parslet_combining.rb
+- lib/grammar/location_tracking.rb
+- lib/grammar/proc_parslet.rb
+- lib/grammar/parse_error.rb
+has_rdoc: true
+homepage: http://github.com/phi2dao/Kaiseki
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A parsing expression grammar generator written in Ruby.
+test_files: []
+