exalted_math 0.1.3 → 0.2.0

data/lib/exalted_math/node/node.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+module ExaltedMath
+  class Node
+    def initialize(*)
+    end
+
+    def constant?
+      true
+    end
+
+    def value(context={})
+      nil
+    end
+
+    def simplify
+      self
+    end
+
+    def valid?(*)
+      false
+    end
+  end
+end

data/lib/exalted_math/node/number.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'exalted_math/node/node'
+module ExaltedMath
+  class Node
+    class Number < Node
+      def initialize(value)
+        @value = value
+      end
+
+      def constant?
+        true
+      end
+
+      def value(context={})
+        @value
+      end
+
+      def ==(o)
+        return false unless self.class === o
+        @value == o.value
+      end
+
+      def valid?(*)
+        true
+      end
+    end
+  end
+end

data/lib/exalted_math/node/operator.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'exalted_math/node/node'
+module ExaltedMath
+  class Node
+    class Operator < Node
+      attr_reader :left, :right
+
+      def initialize(left, right)
+        @left  = left
+        @right = right
+      end
+
+      def constant?
+        left.constant? and right.constant?
+      end
+
+      def value(context={})
+        raise NotImplementedError
+      end
+
+      def simplify
+        if constant?
+          Number.new(value)
+        else
+          self.class.new(left.simplify, right.simplify)
+        end
+      end
+
+      def ==(o)
+        return false unless self.class === o
+        left == o.left && right == o.right
+      end
+
+      def valid?(stats=[])
+        left.valid?(stats) && right.valid?(stats)
+      end
+    end
+  end
+end

data/lib/exalted_math/node/subtract.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'exalted_math/node/node'
+require 'exalted_math/node/operator'
+module ExaltedMath
+  class Node
+    class Subtract < Operator
+      def value(context={})
+        left.value(context) - right.value(context)
+      end
+    end
+  end
+end
+

data/script/benchmark.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+$LOAD_PATH.unshift 'lib'
+require 'exalted_math'
+
+CONTEXT = { 'essence' => 4, 'willpower' => 9, 'compassion' => 4, 'conviction' => 3, 'temperance' => 4, 'valor' => 2 }.freeze
+
+string = '(Essence * 4) + Willpower + highest[2](compassion,conviction,temperance,valor) + 11'.gsub(/\s/,'')
+times = []
+
+5.times do
+start = Time.now
+10_000.times do
+  ExaltedMath::MathsParser.new.ast(string)
+end
+end_time   = Time.now
+times << end_time - start
+end
+
+sum = times.inject(0.0) { |total, time| total += time }
+
+puts times
+puts "Average: #{sum/times.size}"

data/spec/node_spec.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/ruby
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+require 'spec_helper'
+require 'exalted_math/node'
+
+include ExaltedMath
+
+
+describe "ExaltedMath::Node" do
+  before do
+    @three    = Node::Number.new(3)
+    @seven    = Node::Number.new(7)
+    @foo      = Node::Stat.new('foo')
+    @bar      = Node::Spec.new('bar')
+    @invalid  = Node::Stat.new('invalid')
+    @add      = Node::Add.new( @three, @seven)
+    @sub      = Node::Subtract.new(@three, @seven)
+    @mul      = Node::Multiply.new(@three, @seven)
+    @div      = Node::Divide.new(@seven, @three)
+    @add_foo  = Node::Add.new(@three, @foo)
+    @sub_foo  = Node::Subtract.new(@three, @foo)
+    @mul_foo  = Node::Multiply.new(@three, @foo)
+    @div_foo  = Node::Divide.new(@three, @foo)
+    @nested   = Node::Multiply.new(@add, @sub_foo)
+    @min      = Node::Minimum.new([@three, @seven], 1)
+    @max      = Node::Maximum.new([@three, @seven], 1 )
+    @context  = { 'foo' => 3, 'bar' => 4 }
+  end
+  it "a number is constant" do
+    @three.should.be.constant
+  end
+
+  it "a stat is not constant" do
+    @foo.should.not.be.constant
+  end
+
+  it "an add of two constants is constant" do
+    @add.should.be.constant
+  end
+  it "an sub of two constants is constant" do
+    @sub.should.be.constant
+  end
+  it "an mul of two constants is constant" do
+    @mul.should.be.constant
+  end
+  it "an div of two constants is constant" do
+    @div.should.be.constant
+  end
+  it "a min of constants is constant" do
+    @min.should.be.constant
+  end
+  it "a max of constants is constant" do
+    @max.should.be.constant
+  end
+
+  it "an add of constant and not constant is not constant" do
+    @add_foo.should.not.be.constant
+  end
+  it "an sub of constant and not constant is not constant" do
+    @sub_foo.should.not.be.constant
+  end
+  it "an mul of constant and not constant is not constant" do
+    @mul_foo.should.not.be.constant
+  end
+  it "an div of constant and not constant is not constant" do
+    @div_foo.should.not.be.constant
+  end
+
+  it "A number is valid" do
+    @three.valid?(@context.keys).should.be.true
+  end
+
+  it "A stat is valid if it is in the array of valid keys" do
+    @foo.valid?(@context.keys).should.be.true
+  end
+
+  it "A stat is not valid if it is not in the array of valid keys" do
+    @invalid.valid?(@context.keys).should.not.be.true
+  end
+
+  it "An add is valid if both its keys are valid" do
+    @add.valid?(@context.keys).should.be.true
+  end
+  it "An sub is valid if both its keys are valid" do
+    @sub.valid?(@context.keys).should.be.true
+  end
+  it "An mul is valid if both its keys are valid" do
+    @mul.valid?(@context.keys).should.be.true
+  end
+  it "An div is valid if both its keys are valid" do
+    @div.valid?(@context.keys).should.be.true
+  end
+  it "An add is invalid if one key is invalid" do
+    @add = Node::Add.new(@three, @invalid)
+    @add.valid?(@context.keys).should.not.be.true
+  end
+  it "An sub is invalid if one key is invalid" do
+    @sub = Node::Subtract.new(@three, @invalid)
+    @sub.valid?(@context.keys).should.not.be.true
+  end
+  it "An mul is invalid if one key is invalid" do
+    @mul = Node::Multiply.new(@three, @invalid)
+    @mul.valid?(@context.keys).should.not.be.true
+  end
+  it "An div is invalid if one key is invalid" do
+    @div = Node::Divide.new(@three, @invalid)
+    @div.valid?(@context.keys).should.not.be.true
+  end
+
+  it "the value of a number is the number" do
+    @three.value(@context).should == 3
+    @seven.value(@context).should == 7
+  end
+
+  it "the value of a stat is looked up in the context" do
+    @foo.value(@context).should == @context['foo']
+    @bar.value(@context).should == @context['bar']
+  end
+
+  it "the value of an add is the sum of the two children" do
+     @add.value(@context).should == 10
+  end
+
+  it "the value of an sub is first child minus the second" do
+    @sub.value(@context).should == -4
+  end
+
+  it "the value of an mul is the two children multiplied together" do
+    @mul.value(@context).should == 21
+  end
+
+  it "the value of a div is the first child divided by the second" do
+    @div.value(@context).should == 2
+  end
+
+  it "the value of a min is the mininum value" do
+    @min.value(@context).should == 3
+  end
+  it "the value of a max is the maxinum value" do
+    @max.value(@context).should == 7
+  end
+
+  it "it walks the whole tree to compute a value" do
+     @nested.value(@context).should == 0
+  end
+
+  it "can simplify a constant add" do
+    @add.simplify.should == Node::Number.new(10)
+  end
+
+  it "A number is simple" do
+    @three.simplify.should == Node::Number.new(3)
+  end
+
+  it "A stat is simple" do
+    @foo.simplify.should == Node::Stat.new('foo')
+  end
+
+  it "A non-constant add isn't simplified" do
+    @add_foo.simplify.should == Node::Add.new(@three, @foo)
+  end
+  it "A constant branches are simplified" do
+    @nested.simplify.should == Node::Multiply.new(Node::Number.new(10), @sub_foo)
+  end
+
+
+  node_inequality Node::Number.new(1), Node::Number.new(2)
+  node_inequality Node::Number.new(1), Node::Spec.new('foo')
+  node_inequality Node::Number.new(1), Node::Stat.new('foo')
+  node_inequality Node::Stat.new('bar'), Node::Stat.new('foo')
+  node_inequality Node::Spec.new('foo'), Node::Stat.new('foo')
+  node_inequality Node::Minimum.new([Node::Number.new(1), Node::Stat.new('foo')], 1), Node::Minimum.new([Node::Number.new(1), Node::Stat.new('foo')], 2)
+  node_inequality Node::Maximum.new([Node::Number.new(1), Node::Stat.new('foo')], 1), Node::Maximum.new([Node::Number.new(1), Node::Stat.new('foo')], 2)
+  node_inequality Node::Minimum.new([Node::Number.new(1), Node::Spec.new('foo')], 1), Node::Minimum.new([Node::Number.new(1), Node::Stat.new('foo')], 1)
+  node_inequality Node::Minimum.new([Node::Number.new(1), Node::Spec.new('foo')], 1), Node::Maximum.new([Node::Number.new(1), Node::Spec.new('foo')], 1)
+
+  node_equality Node::Number.new(1), Node::Number.new(1)
+  node_equality Node::Spec.new('foo'), Node::Spec.new('foo')
+  node_equality Node::Stat.new('foo'), Node::Stat.new('foo')
+  node_equality Node::Minimum.new([Node::Number.new(1), Node::Stat.new('foo')], 1), Node::Minimum.new([Node::Number.new(1), Node::Stat.new('foo')], 1)
+  node_equality Node::Maximum.new([Node::Number.new(1), Node::Stat.new('foo')], 1), Node::Maximum.new([Node::Number.new(1), Node::Stat.new('foo')], 1)
+end
+

data/spec/parser_spec.rb

@@ -1,45 +1,35 @@
 #!/usr/bin/ruby
-# Jonathan D. Stott <jonathan.stott@gmail.com>
 require 'spec_helper'
 require 'exalted_math'
 
-include Exalted
+include ExaltedMath
 
-class ParserFailure < Bacon::Error
-  def initialize(failure)
-    super :failure, failure
-  end
-end
 describe "Exalted::MathParser" do
   before do
-    @parser = Exalted::MathsParser.new
+    @parser = ExaltedMath::MathsParser.new
   end
 
   [
-    [' 4 ', Ast.num(4)],
-    [' -1 ', Ast.num(-1)],
-    [' 3 * 4 ', Ast.mul(Ast.num(3), Ast.num(4) )],
-    [' 3 - 4 ', Ast.sub(Ast.num(3), Ast.num(4) )],
-    [' 3 + 4 ', Ast.add(Ast.num(3), Ast.num(4) )],
-    [' 6 / 3 ', Ast.div(Ast.num(6), Ast.num(3) )],
-    [' spec:"Beating stuff" ', Ast.spec("Beating stuff")],
-    ['Essence * 4', Ast.mul(Ast.stat('essence'), Ast.num(4) )],
-    ['(Essence * 4) + Willpower', Ast.add(Ast.mul(Ast.stat('essence'), Ast.num(4) ), Ast.stat('willpower'))],
-    ['highest[2](compassion,conviction,temperance,valor)', Ast.max(2, [Ast.stat('compassion'),Ast.stat('conviction'),Ast.stat('temperance'),Ast.stat('valor') ])],
-    ['min(compassion,conviction,temperance,valor)', Ast.min(1, [Ast.stat('compassion'),Ast.stat('conviction'),Ast.stat('temperance'),Ast.stat('valor') ])]
+    [' 4 ', Node::Number.new(4)],
+    [' -1 ', Node::Number.new(-1)],
+    [' 3 * 4 ', Node::Multiply.new(Node::Number.new(3), Node::Number.new(4) )],
+    [' 3 - 4 ', Node::Subtract.new(Node::Number.new(3), Node::Number.new(4) )],
+    [' 3 + 4 ', Node::Add.new(Node::Number.new(3), Node::Number.new(4) )],
+    [' 6 / 3 ', Node::Divide.new(Node::Number.new(6), Node::Number.new(3) )],
+    [' spec:"Beating stuff" ', Node::Spec.new("Beating stuff")],
+    ['Essence * 4', Node::Multiply.new(Node::Stat.new('essence'), Node::Number.new(4) )],
+    ['(Essence * 4) + Willpower', Node::Add.new(Node::Multiply.new(Node::Stat.new('essence'), Node::Number.new(4) ), Node::Stat.new('willpower'))],
+    ['highest[2](compassion,conviction,temperance,valor)', Node::Maximum.new([Node::Stat.new('compassion'),Node::Stat.new('conviction'),Node::Stat.new('temperance'),Node::Stat.new('valor') ], 2)],
+    ['min(compassion,conviction,temperance,valor)', Node::Minimum.new([Node::Stat.new('compassion'),Node::Stat.new('conviction'),Node::Stat.new('temperance'),Node::Stat.new('valor') ], 1)]
   ].each do |string, ast|
     it "parses '#{string}'" do
-      success, result = @parser.ast(string)
-      raise ParserFailure, result unless success
-      success.should.be.true
+      result = @parser.ast(string)
       result.should == ast
     end
   end
 
   it "Doesn't care about spaces" do
-    success, result = @parser.ast(' ( Essence    * 4 )   +    Willpower + highest[2]( compassion , conviction ) ')
-    raise ParserFailure, result unless success
-    success.should.be.true
+    proc { @parser.ast(' ( Essence    * 4 )   +    Willpower + highest[2]( compassion , conviction ) ') }.should.not.raise(ParseFailedError)
   end
 end
 

data/spec/spec_helper.rb

@@ -3,3 +3,16 @@
 require 'bacon'
 
 Bacon.summary_on_exit
+
+class Bacon::Context
+  def node_inequality(left, right)
+    it "`#{left.inspect}' != `#{right.inspect}`" do
+      left.should.not == right
+    end
+  end
+  def node_equality(left, right)
+    it "`#{left.inspect}' == `#{right.inspect}`" do
+      left.should == right
+    end
+  end
+end

metadata

@@ -1,125 +1,120 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: exalted_math
-version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 3
-  version: 0.1.3
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Jonathan Stott
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-06-09 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2012-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: treetop
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 4
-        version: "1.4"
+      - !ruby/object:Gem::Version
+        version: '1.4'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: bacon
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: bacon
+  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: *id002
-- !ruby/object:Gem::Dependency 
-  name: yard
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: *id003
-description: |-
-  Parsing and evaluation of simple maths expressions for Exalted
-  
-  This intended to aid in evaluating simple calculations which appear on character sheets, especially for Exalted.
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Parsing and evaluation of simple maths expressions for Exalted
+
+
+  This intended to aid in evaluating simple calculations which appear on character
+  sheets, especially for Exalted.'
 email: jonathan.stott@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
-- .gitignore
+files:
 - README.rdoc
 - Rakefile
 - VERSION
 - exalted_math.gemspec
 - lib/exalted_math.rb
-- lib/exalted_math/ast.rb
 - lib/exalted_math/math.rb
 - lib/exalted_math/math.treetop
-- spec/ast_spec.rb
+- lib/exalted_math/node.rb
+- lib/exalted_math/node/add.rb
+- lib/exalted_math/node/divide.rb
+- lib/exalted_math/node/list.rb
+- lib/exalted_math/node/maximum.rb
+- lib/exalted_math/node/minimum.rb
+- lib/exalted_math/node/multiply.rb
+- lib/exalted_math/node/named.rb
+- lib/exalted_math/node/node.rb
+- lib/exalted_math/node/number.rb
+- lib/exalted_math/node/operator.rb
+- lib/exalted_math/node/subtract.rb
+- script/benchmark.rb
+- spec/node_spec.rb
 - spec/parser_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/namelessjon/exalted_math
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+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: 
-      - 0
-      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 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Parsing and evaluation of simple maths expressions for Exalted
-test_files: 
-- spec/ast_spec.rb
-- spec/spec_helper.rb
-- spec/parser_spec.rb
+test_files: []