lexr 0.2.3 → 0.3.1

data/README.md

@@ -13,16 +13,26 @@ Install with
 
 	ExpressionLexer = Lexr.that {
 		ignores /\s+/ => :whitespace
-		matches /[-+]?[0-9]*\.?[0-9]+/ => :number, :convert_with => lambda { |v| Float(v) }
-		matches "+" => :addition
-		matches "-" => :subtraction
-		matches "*" => :multiplication
-		matches "/" => :division
+		
+		legal_place_for_binary_operator = lambda { |prev| [:addition, 
+																:subtraction, 
+																:multiplication, 
+																:division,
+																:left_parenthesis,
+																:start].include? prev.type }
+		
+		matches "+" => :addition, :unless => legal_place_for_binary_operator
+		matches "-" => :subtraction, :unless => legal_place_for_binary_operator
+		matches "*" => :multiplication, :unless => legal_place_for_binary_operator
+		matches "/" => :division, :unless => legal_place_for_binary_operator
+		
 		matches "(" => :left_parenthesis
 		matches ")" => :right_parenthesis
+		
+		matches /[-+]?[0-9]*\.?[0-9]+/ => :number, :convert_with => lambda { |v| Float(v) }
 	}
 
-	lexer = ExpressionLexer.new("1 * 12.5 / (55 + 2 - 56)")
+	lexer = ExpressionLexer.new("-1 * 12.5 / (55 + 2 - -56)")
 
 	until lexer.end?
 		puts lexer.next
@@ -30,7 +40,7 @@ Install with
 
 results in an output of
 
-	number(1.0)
+	number(-1.0)
 	multiplication(*)
 	number(12.5)
 	division(/)
@@ -39,7 +49,7 @@ results in an output of
 	addition(+)
 	number(2.0)
 	subtraction(-)
-	number(56.0)
+	number(-56.0)
 	right_parenthesis())
 	end()
 	

data/lib/lexr.rb

@@ -1,150 +1,155 @@
 class Lexr
-	def self.that(&block)
-		dsl = Lexr::Dsl.new
-		block.arity == 1 ? block[dsl] : dsl.instance_eval(&block)
-		dsl
-	end
-	
-	def initialize(text, rules)
-		@text, @rules = text, rules
-		@current = nil
-		@position = 0
-	end
+  def self.that(&block)
+    dsl = Lexr::Dsl.new
+    block.arity == 1 ? block[dsl] : dsl.instance_eval(&block)
+    dsl
+  end
+  
+  def initialize(text, rules)
+    @text, @rules = text, rules
+    @current = Lexr::Token.start
+    @position = 0
+  end
 
-	def next
-		return @current = Lexr::Token.end if @position >= @text.length
-		@rules.each do |rule|
-		  next unless result = rule.match(unprocessed_text)
-		  @position += result.characters_matched
-		  return self.next if rule.ignore?
-		  return @current = result.token
-		end
-		raise Lexr::UnmatchableTextError.new(unprocessed_text[0..0], @position)
-	end
-	
-	def peek
-	  pos = @position
-	  cur = @current
-		result = self.send :next
-		@position = pos
-		@current = cur
-		result
-	end
-	
-	def current
-		@current
-	end
-	
-	def end?
-		@current == Lexr::Token.end
-	end
-	
-	private
-	
-	def unprocessed_text
-		@text[@position..-1]
-	end
-	
-	class Token
-		attr_reader :value, :type
-	
-		def initialize(value, type = nil)
-			@value, @type = value, type
-		end
-		
-		def self.method_missing(sym, *args)
-			self.new(args.first, sym)
-		end
-		
-		def to_s
-			"#{type}(#{value})"
-		end
-		
-		def ==(other)
-			@type == other.type && @value == other.value
-		end
-	end
-	
-	class Rule
-		attr_reader :pattern, :symbol
-		
-		def converter ; @opts[:convert_with] ; end
-		def ignore? ; @opts[:ignore] ; end
-		
-		def initialize(pattern, symbol, opts = {})
-			@pattern, @symbol, @opts = pattern, symbol, opts
-		end
-	  
-	  def match(text)
-	    text_matched = self.send :"#{pattern.class.name.downcase}_matcher", text
-	    return nil unless text_matched
-	    value = converter ? converter[text_matched] : text_matched
-	    Lexr::MatchData.new(text_matched.length, Lexr::Token.new(value, symbol))
-    end
-		
-		def ==(other)
-			@pattern == other.pattern && 
-				@symbol == other.symbol && 
-				@opts[:convert_with] == other.converter && 
-				@opts[:ignore] == other.ignore?
-		end
-		
-		private
-		
-		def string_matcher(text)
-		  return nil unless text[0..pattern.length-1] == pattern
+  def next
+    return @current = Lexr::Token.end if @position >= @text.length
+    @rules.each do |rule|
+      next unless result = rule.match(unprocessed_text, @current)
+      @position += result.characters_matched
+      return self.next if rule.ignore?
+      return @current = result.token
+    end
+    raise Lexr::UnmatchableTextError.new(unprocessed_text[0..0], @position)
+  end
+  
+  def peek
+    pos = @position
+    cur = @current
+    result = self.send :next
+    @position = pos
+    @current = cur
+    result
+  end
+  
+  def current
+    @current
+  end
+  
+  def end?
+    @current == Lexr::Token.end
+  end
+  
+  private
+  
+  def unprocessed_text
+    @text[@position..-1]
+  end
+  
+  class Token
+    attr_reader :value, :type
+  
+    def initialize(value, type = nil)
+      @value, @type = value, type
+    end
+    
+    def self.method_missing(sym, *args)
+      self.new(args.first, sym)
+    end
+    
+    def to_s
+      "#{type}(#{value})"
+    end
+    
+    def ==(other)
+      @type == other.type && @value == other.value
+    end
+  end
+  
+  class Rule
+    attr_reader :pattern, :symbol
+    
+    def converter ; @opts[:convert_with] ; end
+    def ignore? ; @opts[:ignore] ; end
+    
+    def initialize(pattern, symbol, opts = {})
+      @pattern, @symbol, @opts = pattern, symbol, opts
+    end
+    
+    def match(text, previous_token = nil)
+      text_matched = self.send :"#{pattern.class.name.downcase}_matcher", text
+      return nil unless text_matched
+      return nil if predecate && !predecate[previous_token]
+      value = converter ? converter[text_matched] : text_matched
+      Lexr::MatchData.new(text_matched.length, Lexr::Token.new(value, symbol))
+    end
+    
+    def ==(other)
+      @pattern == other.pattern && 
+        @symbol == other.symbol && 
+        @opts[:convert_with] == other.converter && 
+        @opts[:ignore] == other.ignore?
+    end
+    
+    private
+    
+    def predecate
+      @opts[:if] || (@opts[:unless] ? lambda { |prev| ! @opts[:unless][prev] } : nil)
+    end
+    
+    def string_matcher(text)
+      return nil unless text[0..pattern.length-1] == pattern
       pattern
-	  end
-	  
-	  def regexp_matcher(text)
-	    return nil unless m = text.match(/\A#{pattern}/)
-		  m[0]
-    end
-	end
-	
-	class Dsl
-		def initialize
-			@rules = []
-		end
-		
-		def matches(rule_hash)
-			pattern = rule_hash.keys.reject { |k| k.class == Symbol }.first
-			symbol = rule_hash[pattern]
-			opts = rule_hash.delete_if { |k, v| k.class != Symbol }
-			@rules << Rule.new(pattern, symbol, opts)
-		end
-		
-		def ignores(rule_hash)
-			matches rule_hash.merge(:ignore => true)
-		end
-		
-		def new(str)
-			Lexr.new(str, @rules)
-		end
-	end
-	
-	class UnmatchableTextError < StandardError
-		attr_reader :character, :position
-		
-		def initialize(character, position)
-			@character, @position = character, position
-		end
-		
-		def message
-			"Unexpected character '#{character}' at position #{position + 1}"
-		end
-		
-		def inspect
-			message
-		end
-	end
-	
-	class MatchData
-	  attr_reader :characters_matched, :token
-	  
-	  def initialize(characters_matched, token)
-	    @characters_matched = characters_matched
-	    @token = token
+    end
+    
+    def regexp_matcher(text)
+      return nil unless m = text.match(/\A#{pattern}/)
+      m[0]
+    end
+  end
+  
+  class Dsl
+    def initialize
+      @rules = []
+    end
+    
+    def matches(rule_hash)
+      pattern = rule_hash.keys.reject { |k| k.class == Symbol }.first
+      symbol = rule_hash[pattern]
+      opts = rule_hash.delete_if { |k, v| k.class != Symbol }
+      @rules << Rule.new(pattern, symbol, opts)
+    end
+    
+    def ignores(rule_hash)
+      matches rule_hash.merge(:ignore => true)
+    end
+    
+    def new(str)
+      Lexr.new(str, @rules)
+    end
+  end
+  
+  class UnmatchableTextError < StandardError
+    attr_reader :character, :position
+    
+    def initialize(character, position)
+      @character, @position = character, position
+    end
+    
+    def message
+      "Unexpected character '#{character}' at position #{position + 1}"
+    end
+    
+    def inspect
+      message
+    end
+  end
+  
+  class MatchData
+    attr_reader :characters_matched, :token
+    
+    def initialize(characters_matched, token)
+      @characters_matched = characters_matched
+      @token = token
     end
   end
 end

metadata

@@ -1,82 +1,68 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: lexr
-version: !ruby/object:Gem::Version 
-  hash: 17
+version: !ruby/object:Gem::Version
+  version: 0.3.1
   prerelease: 
-  segments: 
-  - 0
-  - 2
-  - 3
-  version: 0.2.3
 platform: ruby
-authors: 
+authors:
 - Michael Baldry
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-17 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
-email: michael.baldry@uswitch.com
+email: michael@brightbits.co.uk
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.md
-files: 
+files:
 - README.md
 - lib/lexr.rb
-has_rdoc: true
-homepage: http://www.forwardtechnology.co.uk
+homepage: http://www.brightbits.co.uk
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --main
 - README.md
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: -344489456942955657
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A lightweight and pretty lexical analyser
 test_files: []
-