boolean-expression 0.0.1 → 0.0.1.1

data/lib/boolean/expression.rb

@@ -22,120 +22,113 @@ unless defined?(Boolean)
 end
 
 class Boolean::Expression
-  EvaluationError = Class.new(Exception)
-
-  class << self
-    def parse (text)
-      base  = Group.new
-      name  = nil
-      stack = [base]
-      logic = nil
-
-      text.to_s.each_char.to_a.each_with_index {|char, index|
-        begin
-          if char == ')' && stack.length == 1
-            raise SyntaxError.new('Closing an unopened parenthesis')
-          end
-
-          if char.match(/\s|\(|\)/) || (!logic && ['|', '&', '!'].member?(char))
-            if logic || (name && name.match(/(and|or|not)/i))
-              stack.last << Logic.new(logic || name)
-              logic       = nil
-              name        = nil
-            elsif name
-              stack.last << Name.new(name)
-              name        = nil
-            end
-          end
-
-          if name || logic
-            name  << char if name
-            logic << char if logic
-          else
-            case char
-              when '('; stack.push Group.new
-              when ')'; stack[-2] << stack.pop
-              when '|'; logic = '|'
-              when '&'; logic = '&'
-              when '!'; stack.last << Logic.new('!')
-              else;     name = char if !char.match(/\s/)
-            end
-          end
-        rescue SyntaxError => e
-          raise "#{e.message} near `#{text[index - 4, 8]}` at character #{index}"
-        end
-      }
-
-      if stack.length != 1
-        raise SyntaxError.new('Not all parenthesis are closed')
-      end
-
-      if logic
-        raise SyntaxError.new('The expression cannot end with a logic operator')
-      end
-
-      base << Name.new(name) if name
-
-      if base.length == 1 && base.first.is_a?(Group)
-        base = base.first
-      end
-
-      self.new(base)
-    end
-
-    alias [] parse
-  end
-
-  attr_reader :base
-
-  def initialize (base=Group.new)
-    @base = base
-  end
-
-  def evaluate (*args)
-    _evaluate(@base, args.flatten.compact.map {|piece|
-      piece.to_s
-    })
-  end
-
-  alias [] evaluate
-
-  def to_s
-    @base.inspect
-  end
-
-  private
-    def _evaluate (group, pieces)
-      return false if pieces.empty?
-
-      values = []
-
-      group.each {|thing|
-        case thing
-          when Logic; values << thing
-          when Group; values << _evaluate(thing, pieces)
-          when Name;  values << pieces.member?(thing.to_s)
-        end
-      }
-
-      at = 0
-      while at < values.length
-        if values[at].is_a?(Logic) && values[at].type == :not
-          values[at] = values.delete_at(at).evaluate(values[at])
-          values[at] = !values[at]
-        end 
-
-        at += 1
-      end 
-
-      while values.length > 1
-        a, logic, b = values.shift(3)
-
-        values.unshift(logic.evaluate(a, b))
-      end
-
-      values.first
-    end
+	def self.parse (text)
+		base  = Group.new
+		name  = nil
+		stack = [base]
+		logic = nil
+
+		text.to_s.chars.each_with_index {|char, index|
+			begin
+				if char == ')' && stack.length == 1
+					raise SyntaxError, 'closing an unopened parenthesis'
+				end
+
+				if char.match(/\s|\(|\)/) || (!logic && ['|', '&', '!'].member?(char))
+					if logic || (name && name.match(/(and|or|not)/i))
+						stack.last << Logic.new(logic || name)
+						logic       = nil
+						name        = nil
+					elsif name
+						stack.last << Name.new(name)
+						name        = nil
+					end
+				end
+
+				if name || logic
+					name  << char if name
+					logic << char if logic
+				else
+					case char
+						when '(' then stack.push Group.new
+						when ')' then stack[-2] << stack.pop
+						when '|' then logic = '|'
+						when '&' then logic = '&'
+						when '!' then stack.last << Logic.new('!')
+						else name = char if !char.match(/\s/)
+					end
+				end
+			rescue SyntaxError => e
+				raise "#{e.message} near `#{text[index - 4, 8]}` at character #{index}"
+			end
+		}
+
+		raise SyntaxError, 'not all parenthesis are closed' if stack.length != 1
+		
+		raise SyntaxError, 'the expression cannot end with a logic operator' if logic
+
+		base << Name.new(name) if name
+
+		base = base.first if base.length == 1 && base.first.is_a?(Group)
+
+		new(base)
+	end
+
+	def self.[] (*args)
+		parse(*args)
+	end
+
+	attr_reader :base
+
+	def initialize (base = Group.new)
+		@base = base
+	end
+
+	def evaluate (*args)
+		_evaluate(@base, args.flatten.compact.map {|piece|
+			piece.to_s
+		})
+	end
+
+	alias [] evaluate
+
+	def to_s
+		@base.inspect
+	end
+
+private
+	def _evaluate (group, pieces)
+		return false if pieces.empty?
+
+		values = []
+
+		group.each {|thing|
+			case thing
+				when Logic then values << thing
+				when Group then values << _evaluate(thing, pieces)
+				when Name  then  values << pieces.member?(thing.to_s)
+			end
+		}
+
+		at = 0
+		while at < values.length
+			if values[at].is_a?(Logic) && values[at].type == :not
+				value = values.delete_at(at + 1)
+
+				values[at] = !(value.is_a?(Group) ? value.evaluate(values[at]) : value)
+			end
+
+			at += 1
+		end
+
+		while values.length > 1
+			a, logic, b = values.shift(3)
+
+			values.unshift(logic.evaluate(a, b))
+		end
+
+		values.first
+	end
 end
 
 require 'boolean/expression/name'

data/lib/boolean/expression/group.rb

@@ -18,7 +18,7 @@
 #++
 
 class Boolean::Expression::Group < Array
-  def inspect
-    '(' + self.map {|e| e.inspect}.join(' ') + ')'
-  end
+	def inspect
+		'(' + map { |e| e.inspect }.join(' ') + ')'
+	end
 end

data/lib/boolean/expression/logic.rb

@@ -18,27 +18,26 @@
 #++
 
 class Boolean::Expression::Logic
-  attr_reader :type
+	attr_reader :type
 
-  def initialize (what)
-    @type = case what
-      when '!',  /not/i then :not
-      when '&&', /and/i then :and
-      when '||', /or/i  then :or
-    end
+	def initialize (what)
+		@type = case what
+			when '!',  /not/i then :not
+			when '&&', /and/i then :and
+			when '||', /or/i  then :or
+			else raise SyntaxError, 'invalid logical operator, logical fallacies everywhere'
+		end
+	end
 
-    raise SyntaxError.new('Invalid logical operator, logical fallacies everywhere') unless @type
-  end
+	def evaluate (a, b=nil)
+		case @type
+			when :not then !a
+			when :and then !!(a && b)
+			when :or  then !!(a || b)
+		end
+	end
 
-  def evaluate (a, b=nil)
-    case @type
-      when :not then !a
-      when :and then !!(a && b)
-      when :or  then !!(a || b)
-    end
-  end
-
-  def inspect
-    self.type.to_s.upcase
-  end
+	def inspect
+		type.to_s.upcase
+	end
 end

data/lib/boolean/expression/name.rb

@@ -18,7 +18,7 @@
 #++
 
 class Boolean::Expression::Name < String
-  def inspect
-    self.to_s.downcase
-  end
+	def inspect
+		to_s.downcase
+	end
 end

metadata

@@ -1,57 +1,48 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: boolean-expression
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.1.1
   prerelease: 
-  version: 0.0.1
 platform: ruby
-authors: 
+authors:
 - meh.
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-22 00:00:00 Z
+date: 2012-01-28 00:00:00.000000000 Z
 dependencies: []
-
 description: 
 email: meh@paranoici.org
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - lib/boolean/expression.rb
 - lib/boolean/expression/logic.rb
 - lib/boolean/expression/name.rb
 - lib/boolean/expression/group.rb
 homepage: http://github.com/meh/boolean-expression
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-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 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.5
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A simple library to evaluate boolean expressions.
 test_files: []
-