exalted_math 0.1.1

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+doc

data/README.rdoc

@@ -0,0 +1,51 @@
+= Exalted Math Parser
+
+This is a very simple project both to teach myself to use Treetop, and to
+implement simple (or not so simple) parsing of mathematics for Exalted character
+sheets.  Although I'm sure it could be used for other simple math situations.
+It consists of two parts; parser and abstract syntax tree.  The parser
+constructs the abstract syntax tree as it parses the input string.  The AST can
+then be used to compute the value of the expression with a given context.  The
+AST also has a simple method to simplify it if possible.  The AST is based on an
+array class, which makes it very easy to serialize.
+
+== Examples
+
+    @parser = Exalted::MathsParser.new
+
+    # simple maths
+    # The ast method results a two-tuple.
+    # The first value is the success or failure of the parse
+    # The second value is the AST, or failure message if it failed
+    @parser.ast('3 + 4')
+    #=> true, simple_ast
+
+    # symbolic values
+    @parser.ast('Essence * 4')
+    #=> true, symbolic_ast
+
+    # complex maths
+    @parser.ast('(Essence * 4) + Willpower + highest[2](Compassion,Conviction,Temperance,Valor)')
+    #=> true, complex_ast
+
+    # evaluate the Ast
+    Exalted::Ast.value(simple_ast)
+    #=> 7
+
+    # evaluate a more complex Ast
+    Exalted::Ast.value(symbolic_ast, {'essence' => 4})
+    #=> 16
+
+== Syntax
+
+The syntax supported by the parser is pretty simple.  In the examples above,
+almost all of it has been demonstrated.
+
+[[0-9]+]                        A number
+[[A-Za-z]+]                     A stat.  This is looked up from the context.
+[spec:"..."]                    A speciality. This is looked up from the context.
+[highest(stat|number,...)]      Has the value of the highest component.
+[highest[n](stat|number,...)]   Has the value of the highest n components.
+[lowest(stat|number,...)]       Has the value of the lowest component.
+[lowest[2](stat|number,...)]    Has the value of the lowest n components.
+

data/Rakefile

@@ -0,0 +1,31 @@
+# Rakefile for phedre
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+require 'rake/testtask'
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << 'lib' << 'spec' << 'app'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+task :default => :spec
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "exalted_math"
+    gem.summary = "Parsing and evaluation of simple maths expressions for Exalted"
+    gem.description = "Parsing and evaluation of simple maths expressions for Exalted\n\nThis intended to aid in evaluating simple calculations which appear on character sheets, especially for Exalted."
+    gem.email = "jonathan.stott@gmail.com"
+    gem.homepage = "http://github.com/namelessjon/exalted_math"
+    gem.authors = ["Jonathan Stott"]
+    gem.add_dependency "treetop", "~> 1.4"
+    gem.add_development_dependency "bacon"
+    gem.add_development_dependency "yard"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/exalted_math.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{exalted_math}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jonathan Stott"]
+  s.date = %q{2010-06-06}
+  s.description = %q{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.}
+  s.email = %q{jonathan.stott@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.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"
+  ]
+  s.homepage = %q{http://github.com/namelessjon/exalted_math}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Parsing and evaluation of simple maths expressions for Exalted}
+  s.test_files = [
+    "spec/ast_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/parser_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<treetop>, ["~> 1.4"])
+      s.add_development_dependency(%q<bacon>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<treetop>, ["~> 1.4"])
+      s.add_dependency(%q<bacon>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<treetop>, ["~> 1.4"])
+    s.add_dependency(%q<bacon>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end
+

data/lib/exalted_math/ast.rb

@@ -0,0 +1,226 @@
+#!/usr/bin/ruby
+# Jonathan D. Stott <jonathan.stott@gmail.com>
+module Exalted
+  # Provides a simple AST for Exalted Maths
+  class Ast < Array
+    class UnknownNodeError < ArgumentError
+      def initialize(type)
+        @message = "Unknown node type '#{type}'"
+        puts @message
+      end
+    end
+
+    def initialize(*args)
+      super(args)
+    end
+
+    # Is this AST constant?
+    #
+    # If an AST only has constant child nodes, it is constant.
+    # This allows some simplification.
+    #
+    # @return [Boolean] is the AST constant
+    def constant?
+      case self[0]
+      when 'mul', 'div', 'add', 'sub'
+        self[1].constant? and self[2].constant?
+      when 'num'
+        true
+      when 'stat', 'spec'
+        false
+      when 'max'
+        self[2].all? { |ast| ast.constant? }
+      else
+        raise UnknownNodeError, self[0]
+      end
+    end
+
+    # Is the given AST constant?
+    #
+    # If an AST only has constant child nodes, it is constant.
+    # This allows some simplification.
+    #
+    # @param ast [Ast] An Ast
+    #
+    # @return [Boolean] is the AST constant
+    def self.constant?(ast)
+      ast.constant?
+    end
+
+    # Is the given AST valid?
+    #
+    # Does the context provide all the values the AST is looking for?
+    #
+    # @param ast [Ast] The Ast to test
+    # @param valid_values [Array] Array of valid values, the keys of the context
+    # @param errors [Array] Optional array of errors
+    #
+    # @return [Boolean] True if valid, false if not.
+    def self.valid?(ast, valid_values, errors=[])
+      case ast[0]
+      when 'mul', 'div', 'add', 'sub'
+        valid?(ast[1], valid_values, errors) and valid?(ast[2], valid_values, errors)
+      when 'num'
+        true
+      when 'stat', 'spec'
+        if valid_values.include? ast[1]
+          true
+        else
+          errors << "Unknown #{ast[0]} '#{ast[1]}'"
+          false
+        end
+      when 'max', 'min'
+        ast[2].map { |ast| valid?(ast, valid_values, errors) }.all?
+      else
+        raise UnknownNodeError, ast[0]
+      end
+    end
+
+    # Calculate the value of the AST for the given context
+    #
+    # This method recursively walks the AST, calculating the final value
+    #
+    # @param ast [Ast] The AST to compute
+    # @param context [#[]] Context used to evaluate the AST
+    #
+    # @return [Integer] The value of the AST
+    def self.value(ast, context={})
+      case ast[0]
+      when 'mul'
+        value(ast[1], context) * value(ast[2], context)
+      when 'div'
+        value(ast[1], context) / value(ast[2], context)
+      when 'add'
+        value(ast[1], context) + value(ast[2], context)
+      when 'sub'
+        value(ast[1], context) - value(ast[2], context)
+      when 'num'
+        ast[1]
+      when 'stat', 'spec'
+        context[ast[1]]
+      when 'max'
+        tmp = ast[2].map { |ast| value(ast, context) }.sort[-ast[1], ast[1]]
+        (tmp.size == 1) ? tmp.first : tmp.inject(0) { |fin, val| fin += val }
+      when 'min'
+        tmp = ast[2].map { |ast| value(ast, context) }.sort[0, ast[1]]
+        (tmp.size == 1) ? tmp.first : tmp.inject(0) { |fin, val| fin += val }
+      else
+        raise UnknownNodeError, self[0]
+      end
+    end
+
+    # Simplify the AST
+    #
+    # This recusively walks the AST, replacing any constant subtrees with their
+    # value.
+    #
+    # @param ast [Ast] The AST to simplify
+    # @return [Ast] The simplified AST
+    def self.simplify(ast)
+      if ast.constant?
+        new('num', value(ast))
+      else
+        case ast[0]
+        when 'add', 'sub', 'mul', 'div'
+           new(ast[0], simplify(ast[1]), simplify(ast[2]))
+        else
+          ast
+        end
+      end
+    end
+
+    # Create a new num node
+    #
+    # @param value [Integer] The value of the new node
+    #
+    # @return [Ast] A num Ast Node
+    def self.num(value)
+      new('num', value)
+    end
+
+    # Create a new stat node
+    #
+    # @param value [String] The value of the new node
+    #
+    # @return [Ast] A stat Ast Node
+    def self.stat(value)
+      new('stat', value)
+    end
+
+    # Create a new spec node
+    #
+    # @param value [String] The value of the new node
+    #
+    # @return [Ast] A spec Ast Node
+    def self.spec(value)
+      new('spec', value)
+    end
+
+    # Create a new add node
+    #
+    # @param left [Ast] The left node of the add
+    # @param right [Ast] The right node of the add
+    # @return [Ast] An add Ast Node
+    def self.add(left, right)
+      new('add', left, right)
+    end
+
+    # Create a new sub node
+    #
+    # @param left [Ast] The left node of the sub
+    # @param right [Ast] The right node of the sub
+    # @return [Ast] An sub Ast Node
+    def self.sub(left, right)
+      new('sub', left, right)
+    end
+
+    # Create a new mul node
+    #
+    # @param left [Ast] The left node of the mul
+    # @param right [Ast] The right node of the mul
+    # @return [Ast] An mul Ast Node
+    def self.mul(left, right)
+      new('mul', left, right)
+    end
+
+    # Create a new div node
+    #
+    # @param left [Ast] The left node of the div
+    # @param right [Ast] The right node of the div
+    # @return [Ast] An div Ast Node
+    def self.div(left, right)
+      new('div', left, right)
+    end
+
+    # Create a new min node
+    #
+    # @param count [Integer] Number of values to sum for the min
+    # @param list  [Array]  Array of ASTs to calculate the min from
+    # @return [Ast] A min Ast Node
+    def self.min(count, list)
+      new('min', count, list)
+    end
+
+    # Create a new max node
+    #
+    # @param count [Integer] Number of values to sum for the max
+    # @param list  [Array]  Array of ASTs to calculate the max from
+    # @return [Ast] A max Ast Node
+    def self.max(count, list)
+      new('max', count, list)
+    end
+
+    def self.from_array(array)
+      case array[0]
+      when 'mul', 'div', 'add', 'sub'
+        new(array[0], from_array(array[1]), from_array(array[2])  )
+      when 'num', 'stat', 'spec'
+        new(array[0], array[1])
+      when 'max', 'min'
+        new(array[0], array[1], array[2].map! { |ast| new(ast) } )
+      else
+        raise UnknownNodeError, self[0]
+      end
+    end
+  end
+end