kaiseki 0.0.3 → 1.0.1

data/lib/grammar/parslet_combining.rb

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

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

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

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

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

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

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

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

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

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

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

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

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