clj 0.0.4.5 → 0.0.5

data/lib/clj/parser.rb

@@ -8,155 +8,260 @@
 #  0. You just DO WHAT THE FUCK YOU WANT TO.
 #++
 
-require 'strscan'
+require 'stringio'
 
 class Clojure
 
-class Parser < StringScanner
-	UNPARSED = Object.new
+class Parser
+	IGNORE    = [" ", ",", "\n", "\r", "\t"]
+	SEPARATOR = ['"', '{', '}', '(', ')', '[', ']', '#']
+	BOTH      = IGNORE + SEPARATOR
+	KEYWORD   = ["'", '^', '@', '`', '~', '\\', ';'] + BOTH
 
-	IGNORE = %r(
-		(?:
-			//[^\n\r]*[\n\r]| # line comments
-			/\* # c-style comments
-			(?:
-				[^*/]| # normal chars
-				/[^*]| # slashes that do not start a nested comment
-				\*[^/]| # asterisks that do not end this comment
-				/(?=\*/) # single slash before this comment's end
-			)*
-			\*/ # the End of this comment
-			|[ \t\r\n,]+ # whitespaces: space, horicontal tab, lf, cr, and comma
-		)
-	)mx
+	# Unescape characters in strings.
+	UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+	UNESCAPE_MAP.update({
+		?"  => '"',
+		?\\ => '\\',
+		?/  => '/',
+		?b  => "\b",
+		?f  => "\f",
+		?n  => "\n",
+		?r  => "\r",
+		?t  => "\t",
+		?u  => nil,
+	})
 
-	STRING = /" ((?:[^\x0-\x1f"\\] |
-		# escaped special characters:
-		\\["\\\/bfnrt] |
-		\\u[0-9a-fA-F]{4} |
-		# match all but escaped special characters:
-		\\[\x20-\x21\x23-\x2e\x30-\x5b\x5d-\x61\x63-\x65\x67-\x6d\x6f-\x71\x73\x75-\xff])*)
-	"/nx
+	EMPTY_8BIT_STRING = ''
 
-	KEYWORD = /:([^(\[{'^@`~\"\\,\s;)\]}]+)/
+	if EMPTY_8BIT_STRING.respond_to? :force_encoding
+		EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
+	end
 
-	INTEGER = /(-?0|-?[1-9]\d*)/
+	def initialize (source, options = {})
+		@source  = source.is_a?(String) ? StringIO.new(source) : source
+		@options = options
 
-	BIGNUM = /#{INTEGER}N/
+		@map_class    = options[:map_class]    || Hash
+		@vector_class = options[:vector_class] || Array
+		@list_class   = options[:list_class]   || Array
+		@set_class    = options[:set_class]    || Array
+	end
 
-	FLOAT = /(-?
-		(?:0|[1-9]\d*)
-		(?:
-			\.\d+(?i:e[+-]?\d+) |
-			\.\d+ |
-			(?i:e[+-]?\d+)
-		)
-	)/x
+	def parse
+		read_next
+	end
 
-	BIGDECIMAL = /#{FLOAT}M/
+private
+	def next_type (ch)
+		case ch
+		when '0'..'9', '-', '+' then :number
+		when 't', 'f'           then :boolean
+		when 'n'                then :nil
+		when '\\'               then :char
+		when ':'                then :keyword
+		when '"'                then :string
+		when '{'                then :map
+		when '('                then :list
+		when '['                then :vector
+		when '#'
+			case read(1)
+			when 'i' then :instant
+			when '{' then :set
+			when '"' then :regexp
+			end
+		end or raise SyntaxError, 'unknown type'
+	end
 
-	RATIONAL = /(#{INTEGER}\/#{INTEGER})/
+	def read_next
+		ch = ignore(false)
 
-	REGEXP = /#"((\\.|[^"])+)"/
+		raise SyntaxError, 'unexpected EOF' unless ch
 
-	INSTANT = /#inst#{IGNORE}*"(.*?)"/
+		__send__ "read_#{next_type ch}", ch
+	end
 
-	VECTOR_OPEN  = /\[/
-	VECTOR_CLOSE = /\]/
+	def read_nil (ch)
+		unless read(2).bytesize == 2
+			raise SyntaxError, 'unexpected EOF'
+		end
 
-	LIST_OPEN  = /\(/
-	LIST_CLOSE = /\)/
+		nil
+	end
 
-	SET_OPEN  = /\#\{/
-	SET_CLOSE = /\}/
+	def read_boolean (ch)
+		if ch == 't'
+			unless read(3).bytesize == 3
+				raise SyntaxError, 'unexpected EOF'
+			end
+			
+			true
+		else
+			unless read(4).bytesize == 4
+				raise SyntaxError, 'unexpected EOF'
+			end
 
-	HASH_OPEN  = /\{/
-	HASH_CLOSE = /\}/
+			false
+		end
+	end
 
-	TRUE  = /true/
-	FALSE = /false/
-	NIL   = /nil/
+	def read_number (ch)
+		piece = ch
 
-	def initialize (source, options = {})
-		super(source)
+		while (ch = read(1)) && !BOTH.include?(ch)
+			piece << ch
+		end
 
-		@hash_class   = options[:hash_class]   || Hash
-		@vector_class = options[:vector_class] || Array
-		@list_class   = options[:list_class]   || Array
-		@set_class    = options[:set_class]    || Array
+		revert(ch)
+
+		if piece.include? '/'
+			Rational(piece)
+		elsif piece.include? '.' or piece.end_with? 'M'
+			if piece.end_with? 'M'
+				piece[-1] = ''
+
+				BigDecimal(piece)
+			else
+				Float(piece)
+			end
+		else
+			if piece.end_with? 'N'
+				piece[-1] = ''
+			end
+
+			Integer(piece)
+		end
+	end
+
+	def read_char (ch)
+		ch = read(1)
+
+		unescape(if ch == 'u' && lookahead(1) =~ /[0-9a-fA-F]/
+			"\\u#{read(4)}"
+		else
+			ch
+		end)
+	end
+
+	def read_keyword (ch)
+		result = ''
+
+		while (ch = read(1)) && !KEYWORD.include?(ch)
+			result << ch
+		end
+
+		revert(ch)
+
+		result.to_sym
 	end
 
-	alias source string
+	def read_string (ch)
+		result = ''
+
+		while (ch = read(1)) != '"'
+			raise SyntaxError, 'unexpected EOF' unless ch
 
-	def parsable? (what)
-		!!case what
-			when :vector then scan(VECTOR_OPEN)
-			when :list   then scan(LIST_OPEN)
-			when :set    then scan(SET_OPEN)
-			when :hash   then scan(HASH_OPEN)
+			result << ch
+
+			if ch == '\\'
+				result << read(1)
+			end
 		end
+
+		unescape(result)
+	end
+
+	def read_instant (ch)
+		read(3)
+
+		DateTime.rfc3339(read_string(ignore(false)))
 	end
 
-	def parse (check = true)
-		reset if check
+	def read_regexp (ch)
+		result = ''
 
-		result = case
-			when parsable?(:vector) then parse_vector
-			when parsable?(:list)   then parse_list
-			when parsable?(:set)    then parse_set
-			when parsable?(:hash)   then parse_hash
-			else                         parse_value
+		while (ch = read(1)) != '"'
+			raise SyntaxError, 'unexpected EOF' unless ch
+
+			result << ch
+
+			if ch == '\\'
+				result << read(1)
+			end
 		end
 
-		if check && result == UNPARSED
-			raise SyntaxError, 'the string does not contain proper clojure'
+		/#{result}/
+	end
+
+	def read_list (ch)
+		result = @list_class.new
+
+		ignore
+
+		while lookahead(1) != ')'
+			result << read_next
+			ignore
 		end
 
+		read(1)
+
 		result
 	end
 
-	def parse_value
-		case
-			when scan(RATIONAL)   then Rational(self[1])
-			when scan(BIGDECIMAL) then require 'bigdecimal'; BigDecimal(self[1])
-			when scan(FLOAT)      then Float(self[1])
-			when scan(BIGNUM)     then Integer(self[1])
-			when scan(INTEGER)    then Integer(self[1])
-			when scan(REGEXP)     then /#{self[1]}/
-			when scan(INSTANT)    then DateTime.rfc3339(self[1])
-			when scan(STRING)     then parse_string
-			when scan(KEYWORD)    then self[1].to_sym
-			when scan(TRUE)       then true
-			when scan(FALSE)      then false
-			when scan(NIL)        then nil
-			else                  UNPARSED
+	def read_vector (ch)
+		result = @vector_class.new
+
+		ignore
+
+		while lookahead(1) != ']'
+			result << read_next
+			ignore
 		end
+
+		read(1)
+
+		result
 	end
 
-	# Unescape characters in strings.
-	UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
-	UNESCAPE_MAP.update({
-		?"  => '"',
-		?\\ => '\\',
-		?/  => '/',
-		?b  => "\b",
-		?f  => "\f",
-		?n  => "\n",
-		?r  => "\r",
-		?t  => "\t",
-		?u  => nil,
-	})
+	def read_set (ch)
+		result = @set_class.new
 
-	EMPTY_8BIT_STRING = ''
+		ignore
 
-	if EMPTY_8BIT_STRING.respond_to? :force_encoding
-		EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
+		while lookahead(1) != '}'
+			result << read_next
+			ignore
+		end
+
+		read(1)
+
+		if result.uniq!
+			raise SyntaxError, 'the set contains non unique values'
+		end
+
+		result
 	end
 
-	def parse_string
-		return '' if self[1].empty?
+	def read_map (ch)
+		result = @map_class.new
+
+		ignore
+
+		while lookahead(1) != '}'
+			key = read_next
+			ignore
+			value = read_next
 
-		self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) {|escape|
+			result[key] = value
+		end
+
+		read(1)
+
+		result
+	end
+
+	def unescape (string)
+		string.gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) {|escape|
 			if u = UNESCAPE_MAP[$&[1]]
 				next u
 			end
@@ -179,90 +284,29 @@ class Parser < StringScanner
 		}
 	end
 
-	def parse_vector
-		result = @vector_class.new
-
-		until eos?
-			case
-			when (value = parse(false)) != UNPARSED
-				result << value
-			when scan(VECTOR_CLOSE)
-				break
-			when skip(/#{IGNORE}+/)
-				;
-			else
-				raise SyntaxError, 'wat do'
-			end
-		end
-
-		result
+	def read (length)
+		@source.read(length)
 	end
 
-	def parse_list
-		result = @list_class.new
+	def lookahead (length = nil)
+		original = @source.tell
+		result   = @source.read(length)
 
-		until eos?
-			case
-			when (value = parse(false)) != UNPARSED
-				result << value
-			when scan(LIST_CLOSE)
-				break
-			when skip(/#{IGNORE}+/)
-				;
-			else
-				raise SyntaxError, 'wat do'
-			end
-		end
+		@source.seek(original)
 
 		result
 	end
 
-	def parse_set
-		result = @set_class.new
+	def ignore (ungetc = true)
+		while IGNORE.include?(ch = read(1)); end
 
-		until eos?
-			case
-			when (value = parse(false)) != UNPARSED
-				result << value
-			when scan(SET_CLOSE)
-				break
-			when skip(/#{IGNORE}+/)
-				;
-			else
-				raise SyntaxError, 'wat do'
-			end
-		end
+		return false unless ch
 
-		if result.uniq!
-			raise SyntaxError, 'the set contains non unique values'
-		end
-
-		result
+		ungetc ? revert(ch) : ch
 	end
 
-	def parse_hash
-		result = @hash_class.new
-
-		until eos?
-			case
-			when (key = parse(false)) != UNPARSED
-				skip(/#{IGNORE}*/)
-
-				if (value = parse(false)) == UNPARSED
-					raise SyntaxError, 'no value for the hash'
-				end
-
-				result[key] = value
-			when scan(HASH_CLOSE)
-				break
-			when skip(/#{IGNORE}+/)
-				;
-			else
-				raise SyntaxError, 'wat do'
-			end
-		end
-
-		result
+	def revert (ch)
+		@source.ungetc(ch)
 	end
 end
 

data/lib/clj/types.rb

@@ -9,6 +9,7 @@
 #++
 
 require 'date'
+require 'bigdecimal'
 
 [Numeric, TrueClass, FalseClass, NilClass].each {|klass|
 	klass.instance_eval {
@@ -22,7 +23,7 @@ class Symbol
 	def to_clj (options = {})
 		result = inspect
 
-		unless Clojure::Parser::KEYWORD === result
+		if Clojure::Parser::KEYWORD.any? { |c| result.include? c }
 			raise ArgumentError, "#{result} cannot be transformed into clojure"
 		end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clj
 version: !ruby/object:Gem::Version
-  version: 0.0.4.5
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-07 00:00:00.000000000 Z
+date: 2012-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &9143400 !ruby/object:Gem::Requirement
+  requirement: &10309060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9143400
+  version_requirements: *10309060
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &9142780 !ruby/object:Gem::Requirement
+  requirement: &10307740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9142780
+  version_requirements: *10307740
 description: 
 email: meh@paranoici.org
 executables: []
@@ -67,3 +67,4 @@ signing_key:
 specification_version: 3
 summary: Like json, but with clojure sexps.
 test_files: []
+has_rdoc: