exalted_math 0.1.1

data/lib/exalted_math/math.treetop

@@ -0,0 +1,133 @@
+module Exalted
+grammar Maths
+
+  rule additive
+    multitive space* '+' space* additive {
+      def ast
+        Ast.add(multitive.ast, additive.ast )
+      end
+   }
+  / multitive space* '-' space* additive {
+    def ast
+      Ast.sub( multitive.ast, additive.ast )
+    end
+  }
+  / multitive
+  end
+
+  rule multitive
+    primary space* '*' space* multitive {
+       def ast
+         Ast.mul(primary.ast, multitive.ast )
+       end
+    }
+    /
+    primary space* '/' space* multitive {
+       def ast
+         Ast.div( primary.ast, multitive.ast )
+       end
+    }
+    / primary
+  end
+
+  rule primary
+    '(' space* additive space* ')' {
+        def ast
+          additive.ast
+        end
+    }
+    / number / spec / max / min / stat
+  end
+
+  rule spec
+    [Ss] 'pec' 'iality'? ':"' speciality:[^"]+ '"' {
+      def value
+        speciality.text_value
+      end
+
+      def ast
+        Ast.spec(value)
+      end
+    }
+  end
+
+  rule max
+    ( 'max' / 'highest' ) num:(  '[' number ']' )?  '(' space* list space*  ')' {
+       def count
+         if num.elements
+           num.elements.detect { |e| e.respond_to?(:value) }.value
+         else
+           1
+         end
+       end
+
+       def ast
+         Ast.max( count, list.asts )
+       end
+    }
+  end
+
+  rule min
+    ( 'min' / 'lowest' ) num:(  '[' number ']' )?  '(' space* list space*  ')' {
+       def count
+         if num.elements
+           num.elements.detect { |e| e.respond_to?(:value) }.value
+         else
+           1
+         end
+       end
+       def ast
+         Ast.min( count, list.asts )
+       end
+    }
+  end
+
+  rule list
+    ( ( number / stat ) space* ',' space* )* space* ( number / stat ) {
+        def dig(values, elements)
+          elements.each do |elem|
+            values << elem if elem.respond_to?(:value)
+            dig(values, elem.elements) if elem.elements
+          end
+          values
+        end
+
+        def asts
+          elem_list = []
+          dig(elem_list, elements)
+          elem_list.map! { |e| e.ast }
+        end
+    }
+  end
+
+  rule space
+    ( " " / "\t" )+
+  end
+
+  rule number
+    negative:('-')? [1-9] [0-9]* {
+        def value
+          text_value.to_i*neg
+        end
+
+        def neg
+          (negative.elements) ? -1 : 1
+        end
+        def ast
+          Ast.num(value)
+        end
+    }
+  end
+
+  rule stat
+    [A-Za-z]+ {
+        def value
+          text_value.downcase
+        end
+        def ast
+          Ast.stat(value)
+        end
+    }
+  end
+end
+end

data/lib/exalted_math.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+require 'treetop'
+require 'exalted_math/math'
+require 'exalted_math/ast'
+
+module Exalted
+  class MathsParser
+    def ast(text)
+      result = parse(text)
+      if result
+        [true, result.ast]
+      else
+        [false, failure_reason]
+      end
+    end
+  end
+end

data/spec/ast_spec.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/ruby
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+require 'spec_helper'
+require 'exalted_math/ast'
+
+include Exalted
+
+
+describe "Exalted::Ast" do
+  before do
+    @three    = Exalted::Ast.new('num', 3 )
+    @seven    = Exalted::Ast.new('num', 7 )
+    @foo      = Exalted::Ast.new('stat', 'foo')
+    @bar      = Exalted::Ast.new('spec', 'bar')
+    @invalid  = Exalted::Ast.new('stat', 'invalid')
+    @add      = Exalted::Ast.new('add', @three, @seven)
+    @sub      = Exalted::Ast.new('sub', @three, @seven)
+    @mul      = Exalted::Ast.new('mul', @three, @seven)
+    @div      = Exalted::Ast.new('div', @seven, @three)
+    @add_foo  = Exalted::Ast.new('add', @three, @foo)
+    @sub_foo  = Exalted::Ast.new('sub', @three, @foo)
+    @mul_foo  = Exalted::Ast.new('mul', @three, @foo)
+    @div_foo  = Exalted::Ast.new('div', @three, @foo)
+    @nested   = Exalted::Ast.new('mul', @add, @sub_foo)
+    @context  = { 'foo' => 3, 'bar' => 4 }
+  end
+
+  it ".num makes a number" do
+    @three.should == Ast.num(3)
+  end
+
+  it ".stat makes a stat" do
+    @foo.should == Ast.stat('foo')
+  end
+
+  it ".spec makes a spec" do
+    @bar.should == Ast.spec('bar')
+  end
+
+  it ".add makes an add" do
+    @add.should == Ast.add(@three, @seven)
+  end
+
+  it ".sub makes an sub" do
+    @sub.should == Ast.sub(@three, @seven)
+  end
+
+  it ".mul makes an mul" do
+    @mul.should == Ast.mul(@three, @seven)
+  end
+
+  it ".div makes an div" do
+    @div.should == Ast.div(@seven, @three)
+  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 "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
+    Exalted::Ast.valid?(@three, @context.keys).should.be.true
+  end
+
+  it "A stat is valid if it is in the array of valid keys" do
+    Exalted::Ast.valid?(@foo, @context.keys).should.be.true
+  end
+
+  it "A stat is not valid if it is not in the array of valid keys" do
+    Exalted::Ast.valid?(@invalid, @context.keys).should.not.be.true
+  end
+
+  it "An add is valid if both its keys are valid" do
+    Exalted::Ast.valid?(@add, @context.keys).should.be.true
+  end
+  it "An sub is valid if both its keys are valid" do
+    Exalted::Ast.valid?(@sub, @context.keys).should.be.true
+  end
+  it "An mul is valid if both its keys are valid" do
+    Exalted::Ast.valid?(@mul, @context.keys).should.be.true
+  end
+  it "An div is valid if both its keys are valid" do
+    Exalted::Ast.valid?(@div, @context.keys).should.be.true
+  end
+  it "An add is invalid if one key is invalid" do
+    @add = Exalted::Ast.new('add', @three, @invalid)
+    Exalted::Ast.valid?(@add, @context.keys).should.not.be.true
+  end
+  it "An sub is invalid if one key is invalid" do
+    @sub = Exalted::Ast.new('sub', @three, @invalid)
+    Exalted::Ast.valid?(@sub, @context.keys).should.not.be.true
+  end
+  it "An mul is invalid if one key is invalid" do
+    @mul = Exalted::Ast.new('mul', @three, @invalid)
+    Exalted::Ast.valid?(@mul, @context.keys).should.not.be.true
+  end
+  it "An div is invalid if one key is invalid" do
+    @div = Exalted::Ast.new('div', @three, @invalid)
+    Exalted::Ast.valid?(@div, @context.keys).should.not.be.true
+  end
+
+  it "the value of a number is the number" do
+    Exalted::Ast.value(@three, @context).should == 3
+    Exalted::Ast.value(@seven, @context).should == 7
+  end
+
+  it "the value of a stat is looked up in the context" do
+    Exalted::Ast.value(@foo, @context).should == @context['foo']
+    Exalted::Ast.value(@bar, @context).should == @context['bar']
+  end
+
+  it "the value of an add is the sum of the two children" do
+     Exalted::Ast.value(@add, @context).should == 10
+  end
+
+  it "the value of an sub is first child minus the second" do
+    Exalted::Ast.value(@sub, @context).should == -4
+  end
+
+  it "the value of an mul is the two children multiplied together" do
+    Exalted::Ast.value(@mul, @context).should == 21
+  end
+
+  it "the value of a div is the first child divided by the second" do
+    Exalted::Ast.value(@div, @context).should == 2
+  end
+
+  it "it walks the whole tree to compute a value" do
+     Exalted::Ast.value(@nested, @context).should == 0
+  end
+
+  it "has sane equality behaviour" do
+    @three.should == Exalted::Ast.new('num', 3)
+  end
+
+  it "can simplify a constant add" do
+    Exalted::Ast.simplify(@add).should == Exalted::Ast.new('num', 10)
+  end
+
+  it "A number is simple" do
+    Exalted::Ast.simplify(@three).should == Exalted::Ast.new('num', 3)
+  end
+
+  it "A stat is simple" do
+    Exalted::Ast.simplify(@foo).should == Exalted::Ast.new('stat', 'foo')
+  end
+
+  it "A non-constant add isn't simplified" do
+    Exalted::Ast.simplify(@add_foo).should == Exalted::Ast.new('add', @three, @foo)
+  end
+  it "A constant branches are simplified" do
+    Exalted::Ast.simplify(@nested).should == Exalted::Ast.new('mul', Exalted::Ast.new('num', 10), @sub_foo)
+  end
+end
+

data/spec/parser_spec.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+require 'spec_helper'
+require 'exalted_math'
+
+include Exalted
+describe "Exalted::MathParser" do
+  before do
+    @parser = Exalted::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) )],
+    ['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'))]
+  ].each do |string, ast|
+    it "parses '#{string}'" do
+      success, result = @parser.ast(string)
+      success.should.be.true
+      result.should == ast
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+require 'bacon'
+
+Bacon.summary_on_exit

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: exalted_math
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jonathan Stott
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-06 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 4
+        version: "1.4"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        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.
+email: jonathan.stott@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- 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
+- 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: 
+- lib
+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 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+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