dentaku 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+bin/*
+pkg/*
+vendor/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dentaku.gemspec
+gemspec

data/README.md

@@ -0,0 +1,81 @@
+Dentaku
+=======
+
+http://github.com/rubysolo/dentaku
+
+DESCRIPTION
+-----------
+
+Dentaku is a parser and evaluator for a mathematical and logical formula
+language that allows run-time binding of values to variables referenced in the
+formulas.
+
+EXAMPLE
+-------
+
+This is probably simplest to illustrate in code:
+
+    calculator = Dentaku::Calculator.new
+    calculator.evaluate('10 * 2')
+    => 20
+
+Okay, not terribly exciting.  But what if you want to have a reference to a
+variable, and evaluate it at run-time?  Here's how that would look:
+
+    calculator.evaluate('kiwi + 5', :kiwi => 2)
+    => 7
+
+You can also store the variable values in the calculator's memory and then
+evaluate expressions against those stored values:
+
+    calculator.store(:peaches => 15)
+    calculator.evaluate('peaches - 5')
+    => 10
+    calculator.evaluate('peaches >= 15')
+    => true
+
+For maximum CS geekery, `bind` is an alias of `store`.
+
+If you're too lazy to be building calculator objects, there's a module-method
+shortcut just for you:
+
+    Dentaku['plums * 1.5', {:plums => 2}]
+    => 3.0
+
+
+SUPPORTED OPERATORS
+-------------------
+
+Math: `+ - * /`
+Logic: `< > <= >= <> != = AND OR`
+
+THANKS
+------
+
+Big thanks to [ElkStone Basements](http://www.elkstonebasements.com/) for
+allowing me to extract and open source this code.
+
+LICENSE
+-------
+
+(The MIT License)
+
+Copyright © 2012 Solomon White
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the ‘Software’), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+task :spec do
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = %w{--colour --format progress}
+    t.pattern = 'spec/*_spec.rb'
+  end
+end

data/dentaku.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dentaku/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dentaku"
+  s.version     = Dentaku::VERSION
+  s.authors     = ["Solomon White"]
+  s.email       = ["rubysolo@gmail.com"]
+  s.homepage    = "http://github.com/rubysolo/dentaku"
+  s.summary     = %q{A formula language parser and evaluator}
+  s.description = <<-DESC
+    Dentaku is a parser and evaluator for mathematical formulas
+  DESC
+
+  s.rubyforge_project = "dentaku"
+
+  s.add_development_dependency('rspec')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/dentaku.rb

@@ -0,0 +1,14 @@
+require "dentaku/calculator"
+require "dentaku/version"
+
+module Dentaku
+  def self.[](expression, data={})
+    calculator.evaluate(expression, data)
+  end
+
+  private
+
+  def self.calculator
+    @calculator ||= Dentaku::Calculator.new
+  end
+end

data/lib/dentaku/calculator.rb

@@ -0,0 +1,68 @@
+require 'dentaku/evaluator'
+require 'dentaku/token'
+require 'dentaku/tokenizer'
+
+module Dentaku
+  class Calculator
+    attr_reader :result
+
+    def initialize
+      clear
+    end
+
+    def evaluate(expression, data={})
+      @tokenizer ||= Tokenizer.new
+      @tokens = @tokenizer.tokenize(expression)
+
+      store(data) do
+        @evaluator ||= Evaluator.new
+        @result = @evaluator.evaluate(replace_identifiers_with_values)
+      end
+    end
+
+    def memory(key=nil)
+      key ? @memory[key.to_sym] : @memory
+    end
+
+    def store(key_or_hash, value=nil)
+      restore = @memory.dup
+
+      if value
+        @memory[key_or_hash.to_sym] = value
+      else
+        key_or_hash.each do |key, value|
+          @memory[key.to_sym] = value if value
+        end
+      end
+
+      if block_given?
+        result = yield
+        @memory = restore
+        return result
+      end
+
+      self
+    end
+    alias_method :bind, :store
+
+    def clear
+      @memory = {}
+    end
+
+    def empty?
+      @memory.empty?
+    end
+
+    private
+
+    def replace_identifiers_with_values
+      @tokens.map do |token|
+        if token.is?(:identifier)
+          Token.new(:numeric, memory(token.value))
+        else
+          token
+        end
+      end
+    end
+  end
+end

data/lib/dentaku/evaluator.rb

@@ -0,0 +1,97 @@
+require 'dentaku/token'
+require 'dentaku/token_matcher'
+
+module Dentaku
+  class Evaluator
+    T_NUMERIC    = TokenMatcher.new(:numeric)
+    T_ADDSUB     = TokenMatcher.new(:operator, [:add, :subtract])
+    T_MULDIV     = TokenMatcher.new(:operator, [:multiply, :divide])
+    T_COMPARATOR = TokenMatcher.new(:comparator)
+    T_OPEN       = TokenMatcher.new(:grouping, :open)
+    T_CLOSE      = TokenMatcher.new(:grouping, :close)
+    T_NON_GROUP  = TokenMatcher.new(:grouping).invert
+    T_LOGICAL    = TokenMatcher.new(:logical)
+    T_COMBINATOR = TokenMatcher.new(:combinator)
+
+    P_GROUP      = [T_OPEN,    T_NON_GROUP,  T_CLOSE]
+    P_MATH_ADD   = [T_NUMERIC, T_ADDSUB,     T_NUMERIC]
+    P_MATH_MUL   = [T_NUMERIC, T_MULDIV,     T_NUMERIC]
+    P_COMPARISON = [T_NUMERIC, T_COMPARATOR, T_NUMERIC]
+    P_COMBINE    = [T_LOGICAL, T_COMBINATOR, T_LOGICAL]
+
+    RULES = [
+      [P_GROUP,      :evaluate_group],
+      [P_MATH_MUL,   :apply],
+      [P_MATH_ADD,   :apply],
+      [P_COMPARISON, :apply],
+      [P_COMBINE,    :apply]
+    ]
+
+    def evaluate(tokens)
+      evaluate_token_stream(tokens).value
+    end
+
+    def evaluate_token_stream(tokens)
+      while tokens.length > 1
+        matched = false
+        RULES.each do |pattern, evaluator|
+          if pos = find_rule_match(pattern, tokens)
+            tokens = evaluate_step(tokens, pos, pattern.length, evaluator)
+            matched = true
+            break
+          end
+        end
+
+        raise "no rule matched #{ tokens.map(&:category).inspect }" unless matched
+      end
+
+      tokens << Token.new(:numeric, 0) if tokens.empty?
+
+      tokens.first
+    end
+
+    def evaluate_step(token_stream, start, length, evaluator)
+      expr = token_stream.slice!(start, length)
+      token_stream.insert start, self.send(evaluator, *expr)
+    end
+
+    def find_rule_match(pattern, token_stream)
+      position = 0
+      while position <= token_stream.length - pattern.length
+        substream = token_stream.slice(position, pattern.length)
+        return position if pattern == substream
+        position += 1
+      end
+      nil
+    end
+
+    def evaluate_group(*args)
+      evaluate_token_stream(args[1..-2])
+    end
+
+    def apply(lvalue, operator, rvalue)
+      l = lvalue.value
+      r = rvalue.value
+
+      case operator.value
+      when :add      then Token.new(:numeric, l + r)
+      when :subtract then Token.new(:numeric, l - r)
+      when :multiply then Token.new(:numeric, l * r)
+      when :divide   then Token.new(:numeric, l / r)
+
+      when :le       then Token.new(:logical, l <= r)
+      when :ge       then Token.new(:logical, l >= r)
+      when :lt       then Token.new(:logical, l <  r)
+      when :gt       then Token.new(:logical, l >  r)
+      when :ne       then Token.new(:logical, l != r)
+      when :eq       then Token.new(:logical, l == r)
+
+      when :and      then Token.new(:logical, l && r)
+      when :or       then Token.new(:logical, l || r)
+
+      else
+        raise "unknown comparator '#{ comparator }'"
+      end
+    end
+  end
+end

data/lib/dentaku/token.rb

@@ -0,0 +1,24 @@
+module Dentaku
+  class Token
+    attr_reader :category, :raw_value, :value
+
+    def initialize(category, value, raw_value=nil)
+      @category  = category
+      @value     = value
+      @raw_value = raw_value
+    end
+
+    def length
+      raw_value.to_s.length
+    end
+
+    def is?(c)
+      category == c
+    end
+
+    def ==(other)
+      (category.nil? || other.category.nil? || category == other.category) &&
+      (value.nil?    || other.value.nil?    || value    == other.value)
+    end
+  end
+end

data/lib/dentaku/token_matcher.rb

@@ -0,0 +1,31 @@
+require 'dentaku/token'
+
+module Dentaku
+  class TokenMatcher
+    def initialize(categories=nil, values=nil)
+      @categories = [categories].compact.flatten
+      @values     = [values].compact.flatten
+      @invert     = false
+    end
+
+    def invert
+      @invert = ! @invert
+      self
+    end
+
+    def ==(token)
+      (category_match(token.category) && value_match(token.value)) ^ @invert
+    end
+
+    private
+
+    def category_match(category)
+      @categories.empty? || @categories.include?(category)
+    end
+
+    def value_match(value)
+      @values.empty? || @values.include?(value)
+    end
+  end
+end
+

data/lib/dentaku/token_scanner.rb

@@ -0,0 +1,22 @@
+require 'dentaku/token'
+
+module Dentaku
+  class TokenScanner
+    def initialize(category, regexp, converter=nil)
+      @category  = category
+      @regexp    = %r{\A(#{ regexp })}
+      @converter = converter
+    end
+
+    def scan(string)
+      if m = @regexp.match(string)
+        value = raw = m.to_s
+        value = @converter.call(raw) if @converter
+
+        return Token.new(@category, value, raw)
+      end
+
+      false
+    end
+  end
+end

data/lib/dentaku/tokenizer.rb

@@ -0,0 +1,67 @@
+require 'dentaku/token'
+require 'dentaku/token_matcher'
+require 'dentaku/token_scanner'
+
+module Dentaku
+  class Tokenizer
+    SCANNERS = [
+      TokenScanner.new(:whitespace, '\s+'),
+      TokenScanner.new(:numeric,    '(\d+(\.\d+)?|\.\d+)', lambda{|raw| raw =~ /\./ ? raw.to_f : raw.to_i }),
+      TokenScanner.new(:operator,   '\+|-|\*|\/', lambda do |raw|
+        case raw
+        when '+' then :add
+        when '-' then :subtract
+        when '*' then :multiply
+        when '/' then :divide
+        end
+      end),
+      TokenScanner.new(:grouping,   '\(|\)', lambda do |raw|
+        raw == '(' ? :open : :close
+      end),
+      TokenScanner.new(:comparator, '<=|>=|!=|<>|<|>|=', lambda do |raw|
+        case raw
+        when '<=' then :le
+        when '>=' then :ge
+        when '!=' then :ne
+        when '<>' then :ne
+        when '<'  then :lt
+        when '>'  then :gt
+        when '='  then :eq
+        end
+      end),
+      TokenScanner.new(:combinator, '(and|or)\b', lambda {|raw| raw.strip.to_sym }),
+      TokenScanner.new(:identifier, '[A-Za-z_]+', lambda {|raw| raw.to_sym })
+    ]
+
+    LPAREN = TokenMatcher.new(:grouping, :open)
+    RPAREN = TokenMatcher.new(:grouping, :close)
+
+    def tokenize(string)
+      nesting = 0
+      tokens  = []
+      input   = string.dup.downcase
+
+      until input.empty?
+        raise "parse error at: '#{ input }'" unless SCANNERS.any? do |scanner|
+          if token = scanner.scan(input)
+            raise "unexpected zero-width match (:#{ token.category }) at '#{ input }'" if token.length == 0
+
+            nesting += 1 if LPAREN == token
+            nesting -= 1 if RPAREN == token
+            raise "too many closing parentheses" if nesting < 0
+
+            tokens << token unless token.is?(:whitespace)
+            input.slice!(0, token.length)
+
+            true
+          else
+            false
+          end
+        end
+      end
+
+      raise "too many opening parentheses" if nesting > 0
+      tokens
+    end
+  end
+end

data/lib/dentaku/version.rb

@@ -0,0 +1,3 @@
+module Dentaku
+  VERSION = "0.1.0"
+end

data/spec/calculator_spec.rb

@@ -0,0 +1,52 @@
+require 'dentaku/calculator'
+
+describe Dentaku::Calculator do
+  let(:calculator)  { described_class.new }
+  let(:with_memory) { described_class.new.store(:apples => 3) }
+
+  it 'evaluates an expression' do
+    calculator.evaluate('7+3').should eq(10)
+  end
+
+  describe 'memory' do
+    it { calculator.should be_empty }
+    it { with_memory.should_not be_empty   }
+    it { with_memory.clear.should be_empty }
+
+    it { with_memory.memory(:apples).should eq(3) }
+    it { with_memory.memory('apples').should eq(3) }
+
+    it { calculator.store(:apples, 3).memory('apples').should eq(3) }
+    it { calculator.store('apples', 3).memory(:apples).should eq(3) }
+
+    it 'should discard local values' do
+      calculator.evaluate('pears * 2', :pears => 5).should eq(10)
+      calculator.should be_empty
+      lambda { calculator.tokenize('pears * 2') }.should raise_error
+    end
+  end
+
+  it 'should evaluate a statement with no variables' do
+    calculator.evaluate('5+3').should eq(8)
+  end
+
+  it 'should fail to evaluate unbound statements' do
+    lambda { calculator.evaluate('foo * 1.5') }.should raise_error
+  end
+
+  it 'should evaluate unbound statements given a binding in memory' do
+    calculator.evaluate('foo * 1.5', :foo => 2).should eq(3)
+    calculator.bind(:monkeys => 3).evaluate('monkeys < 7').should be_true
+    calculator.evaluate('monkeys / 1.5').should eq(2)
+  end
+
+  it 'should rebind for each evaluation' do
+    calculator.evaluate('foo * 2', :foo => 2).should eq(4)
+    calculator.evaluate('foo * 2', :foo => 4).should eq(8)
+  end
+
+  it 'should accept strings or symbols for binding keys' do
+    calculator.evaluate('foo * 2', :foo => 2).should eq(4)
+    calculator.evaluate('foo * 2', 'foo' => 4).should eq(8)
+  end
+end

data/spec/dentaku_spec.rb

@@ -0,0 +1,11 @@
+require 'dentaku'
+
+describe Dentaku do
+  it 'should evaulate an expression' do
+    Dentaku['5+3'].should eql(8)
+  end
+
+  it 'should bind values to variables' do
+    Dentaku['oranges > 7', {:oranges => 10}].should be_true
+  end
+end

data/spec/evaluator_spec.rb

@@ -0,0 +1,96 @@
+require 'dentaku/evaluator'
+
+describe Dentaku::Evaluator do
+  let(:evaluator) { Dentaku::Evaluator.new }
+
+  describe 'rule scanning' do
+    it 'should find a matching rule' do
+      rule   = [Dentaku::Token.new(:numeric, nil)]
+      stream = [Dentaku::Token.new(:numeric, 1), Dentaku::Token.new(:operator, :add), Dentaku::Token.new(:numeric, 1)]
+      evaluator.find_rule_match(rule, stream).should eq(0)
+    end
+  end
+
+  describe 'evaluating' do
+    it 'empty expression should be truthy' do
+      evaluator.evaluate([]).should be
+    end
+
+    it 'empty expression should equal 0' do
+      evaluator.evaluate([]).should eq(0)
+    end
+
+    it 'single numeric should return value' do
+      evaluator.evaluate([Dentaku::Token.new(:numeric, 10)]).should eq(10)
+    end
+
+    it 'should evaluate one apply step' do
+      stream   = ts(1, :add, 1, :add, 1)
+      expected = ts(2, :add, 1)
+
+      evaluator.evaluate_step(stream, 0, 3, :apply).should eq(expected)
+    end
+
+    it 'should evaluate one grouping step' do
+      stream   = ts(:open, 1, :add, 1, :close, :multiply, 5)
+      expected = ts(2, :multiply, 5)
+
+      evaluator.evaluate_step(stream, 0, 5, :evaluate_group).should eq(expected)
+    end
+
+    describe 'maths' do
+      it 'should perform addition' do
+        evaluator.evaluate(ts(1, :add, 1)).should eq(2)
+      end
+
+      it 'should respect order of precedence' do
+        evaluator.evaluate(ts(1, :add, 1, :multiply, 5)).should eq(6)
+      end
+
+      it 'should respect explicit grouping' do
+        evaluator.evaluate(ts(:open, 1, :add, 1, :close, :multiply, 5)).should eq(10)
+      end
+    end
+
+    describe 'logic' do
+      it 'should evaluate conditional' do
+        evaluator.evaluate(ts(5, :gt, 1)).should be_true
+      end
+
+      it 'should evaluate combined conditionals' do
+        evaluator.evaluate(ts(5, :gt, 1, :or, :false)).should be_true
+        evaluator.evaluate(ts(5, :gt, 1, :and, :false)).should be_false
+      end
+    end
+  end
+
+  private
+
+  def ts(*args)
+    args.map do |arg|
+      category = (arg.is_a? Fixnum) ? :numeric : category_for(arg)
+      arg = (arg == :true) if category == :logical
+      Dentaku::Token.new(category, arg)
+    end
+  end
+
+  def category_for(value)
+    case value
+    when Numeric
+      :numeric
+    when :add, :subtract, :multiply, :divide
+      :operator
+    when :open, :close
+      :grouping
+    when :le, :ge, :ne, :ne, :lt, :gt, :eq
+      :comparator
+    when :and, :or
+      :combinator
+    when :true, :false
+      :logical
+    else
+      :identifier
+    end
+  end
+end
+

data/spec/token_matcher_spec.rb

@@ -0,0 +1,55 @@
+require 'dentaku/token_matcher'
+
+describe Dentaku::TokenMatcher do
+  it 'with single category should match token category' do
+    matcher = described_class.new(:numeric)
+    token   = Dentaku::Token.new(:numeric, 5)
+
+    matcher.should == token
+  end
+
+  it 'with multiple categories should match any included token category' do
+    matcher    = described_class.new([:comparator, :operator])
+    numeric    = Dentaku::Token.new(:numeric, 5)
+    comparator = Dentaku::Token.new(:comparator, :lt)
+    operator   = Dentaku::Token.new(:operator, :add)
+
+    matcher.should == comparator
+    matcher.should == operator
+    matcher.should_not == numeric
+  end
+
+  it 'with single category and value should match token category and value' do
+    matcher     = described_class.new(:operator, :add)
+    addition    = Dentaku::Token.new(:operator, :add)
+    subtraction = Dentaku::Token.new(:operator, :subtract)
+
+    matcher.should == addition
+    matcher.should_not == subtraction
+  end
+
+  it 'with multiple values should match any included token value' do
+    matcher = described_class.new(:operator, [:add, :subtract])
+    add = Dentaku::Token.new(:operator, :add)
+    sub = Dentaku::Token.new(:operator, :subtract)
+    mul = Dentaku::Token.new(:operator, :multiply)
+    div = Dentaku::Token.new(:operator, :divide)
+
+    matcher.should == add
+    matcher.should == sub
+    matcher.should_not == mul
+    matcher.should_not == div
+  end
+
+  it 'should be invertible' do
+    matcher = described_class.new(:operator, [:add, :subtract]).invert
+    add = Dentaku::Token.new(:operator, :add)
+    mul = Dentaku::Token.new(:operator, :multiply)
+    cmp = Dentaku::Token.new(:comparator, :lt)
+
+    matcher.should_not == add
+    matcher.should == mul
+    matcher.should == cmp
+  end
+end
+

data/spec/token_scanner_spec.rb

@@ -0,0 +1,23 @@
+require 'dentaku/token_scanner'
+
+describe Dentaku::TokenScanner do
+  let(:whitespace) { described_class.new(:whitespace, '\s') }
+  let(:numeric)    { described_class.new(:numeric,    '(\d+(\.\d+)?|\.\d+)', lambda{|raw| raw =~ /\./ ? raw.to_f : raw.to_i }) }
+
+  it 'should return a token for a matching string' do
+    token = whitespace.scan(' ')
+    token.category.should eq(:whitespace)
+    token.value.should eq(' ')
+  end
+
+  it 'should return falsy for a non-matching string' do
+    whitespace.scan('A').should_not be
+  end
+
+  it 'should perform raw value conversion' do
+    token = numeric.scan('5')
+    token.category.should eq(:numeric)
+    token.value.should eq(5)
+  end
+end
+

data/spec/token_spec.rb

@@ -0,0 +1,10 @@
+require 'dentaku/token'
+
+describe Dentaku::Token do
+  it 'should have a category and a value' do
+    token = Dentaku::Token.new(:numeric, 5)
+    token.category.should eq(:numeric)
+    token.value.should eq(5)
+    token.is?(:numeric).should be_true
+  end
+end

data/spec/tokenizer_spec.rb

@@ -0,0 +1,69 @@
+require 'dentaku/tokenizer'
+
+describe Dentaku::Tokenizer do
+  let(:tokenizer) { described_class.new }
+
+  it 'should handle an empty expression' do
+    tokenizer.tokenize('').should be_empty
+  end
+
+  it 'should tokenize addition' do
+    tokens = tokenizer.tokenize('1+1')
+    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
+    tokens.map(&:value).should eq([1, :add, 1])
+  end
+
+  it 'should ignore whitespace' do
+    tokens = tokenizer.tokenize('1     / 1     ')
+    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
+    tokens.map(&:value).should eq([1, :divide, 1])
+  end
+
+  it 'should handle floating point' do
+    tokens = tokenizer.tokenize('1.5 * 3.7')
+    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
+    tokens.map(&:value).should eq([1.5, :multiply, 3.7])
+  end
+
+  it 'should not require leading zero' do
+    tokens = tokenizer.tokenize('.5 * 3.7')
+    tokens.map(&:category).should eq([:numeric, :operator, :numeric])
+    tokens.map(&:value).should eq([0.5, :multiply, 3.7])
+  end
+
+  it 'should accept arbitrary identifiers' do
+    tokens = tokenizer.tokenize('monkeys > 1500')
+    tokens.map(&:category).should eq([:identifier, :comparator, :numeric])
+    tokens.map(&:value).should eq([:monkeys, :gt, 1500])
+  end
+
+  it 'should match "<=" before "<"' do
+    tokens = tokenizer.tokenize('perimeter <= 7500')
+    tokens.map(&:category).should eq([:identifier, :comparator, :numeric])
+    tokens.map(&:value).should eq([:perimeter, :le, 7500])
+  end
+
+  it 'should match "and" for logical expressions' do
+    tokens = tokenizer.tokenize('octopi <= 7500 AND sharks > 1500')
+    tokens.map(&:category).should eq([:identifier, :comparator, :numeric, :combinator, :identifier, :comparator, :numeric])
+    tokens.map(&:value).should eq([:octopi, :le, 7500, :and, :sharks, :gt, 1500])
+  end
+
+  it 'should match "or" for logical expressions' do
+    tokens = tokenizer.tokenize('size < 3 or admin = 1')
+    tokens.map(&:category).should eq([:identifier, :comparator, :numeric, :combinator, :identifier, :comparator, :numeric])
+    tokens.map(&:value).should eq([:size, :lt, 3, :or, :admin, :eq, 1])
+  end
+
+  it 'should detect unbalanced parentheses' do
+    lambda { tokenizer.tokenize('(5+3') }.should raise_error
+    lambda { tokenizer.tokenize(')')    }.should raise_error
+  end
+
+  it 'should recognize identifiers that share initial substrings with combinators' do
+    tokens = tokenizer.tokenize('andover < 10')
+    tokens.length.should eq(3)
+    tokens.map(&:category).should eq([:identifier, :comparator, :numeric])
+    tokens.map(&:value).should eq([:andover, :lt, 10])
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: dentaku
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Solomon White
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70125220014660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70125220014660
+description: ! '    Dentaku is a parser and evaluator for mathematical formulas
+
+'
+email:
+- rubysolo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- dentaku.gemspec
+- lib/dentaku.rb
+- lib/dentaku/calculator.rb
+- lib/dentaku/evaluator.rb
+- lib/dentaku/token.rb
+- lib/dentaku/token_matcher.rb
+- lib/dentaku/token_scanner.rb
+- lib/dentaku/tokenizer.rb
+- lib/dentaku/version.rb
+- spec/calculator_spec.rb
+- spec/dentaku_spec.rb
+- spec/evaluator_spec.rb
+- spec/token_matcher_spec.rb
+- spec/token_scanner_spec.rb
+- spec/token_spec.rb
+- spec/tokenizer_spec.rb
+homepage: http://github.com/rubysolo/dentaku
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: dentaku
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A formula language parser and evaluator
+test_files:
+- spec/calculator_spec.rb
+- spec/dentaku_spec.rb
+- spec/evaluator_spec.rb
+- spec/token_matcher_spec.rb
+- spec/token_scanner_spec.rb
+- spec/token_spec.rb
+- spec/tokenizer_spec.rb