wml_action 0.0.2 → 0.0.3

data/lib/wml_action/parser.tab.rb

@@ -16,81 +16,110 @@ require 'wml_action/log'
 module WMLAction
   class Parser < Racc::Parser
 
-module_eval(<<'...end parser.y/module_eval...', 'parser.y', 49)
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 62)
 include Log
 
 ...end parser.y/module_eval...
 ##### State transition tables begin ###
 
 racc_action_table = [
-     4,     8,    14,    16,    17,    18,    22,    24,    25,    26,
-    27,    29,    19,     4,    18,    21,     4,     7,     5,    30,
-    31,    32 ]
+     4,     8,    14,    22,    33,     4,    45,    21,    31,    34,
+    47,    35,    36,    37,    39,    16,    17,    18,    23,    25,
+    26,    28,    29,    18,    19,    33,    41,    42,    43,    44,
+    34,    33,    35,    36,    37,    38,    34,    33,    35,    36,
+    37,     7,    34,    33,    35,    36,    37,     5,    34,    33,
+    35,    36,    37,     4,    34,   nil,    35,    36,    37,    41,
+    42,    43,    44,   nil,   nil,   nil,    52,    40,    41,    42,
+    43,    44,    41,    42,    43,    44,    41,    42,    43,    44,
+    41,    42,    43,    44 ]
 
 racc_action_check = [
-     6,     6,     6,     6,     6,     6,    18,    18,    18,    18,
-    18,    19,     6,    15,    19,    15,     0,     5,     1,    23,
-    27,    30 ]
+     6,     6,     6,    18,    42,    15,    33,    15,    19,    42,
+    38,    42,    42,    42,    29,     6,     6,     6,    18,    18,
+    18,    18,    18,    19,     6,    34,    48,    48,    48,    48,
+    34,    43,    34,    34,    34,    24,    43,    41,    43,    43,
+    43,     5,    41,    44,    41,    41,    41,     1,    44,    22,
+    44,    44,    44,     0,    22,   nil,    22,    22,    22,    46,
+    46,    46,    46,   nil,   nil,   nil,    46,    32,    32,    32,
+    32,    32,    51,    51,    51,    51,    49,    49,    49,    49,
+    50,    50,    50,    50 ]
 
 racc_action_pointer = [
-    14,    18,   nil,   nil,   nil,    17,    -2,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    11,   nil,   nil,    -2,     7,
-   nil,   nil,   nil,     6,   nil,   nil,   nil,     9,   nil,   nil,
-    12,   nil,   nil ]
+    51,    47,   nil,   nil,   nil,    41,    -2,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,     3,   nil,   nil,    -2,     4,
+   nil,   nil,    42,   nil,    10,   nil,   nil,   nil,   nil,    -9,
+   nil,   nil,    62,    -4,    18,   nil,   nil,   nil,   -11,   nil,
+   nil,    30,    -3,    24,    36,   nil,    53,   nil,    20,    70,
+    74,    66,   nil ]
 
 racc_action_default = [
-    -1,   -26,    -2,    -3,    -5,   -26,   -26,    33,    -4,    -6,
-    -7,    -8,    -9,   -10,   -11,   -26,   -14,   -15,   -16,   -26,
-   -12,   -13,   -17,   -18,   -19,   -20,   -21,   -26,   -24,   -25,
-   -26,   -22,   -23 ]
+    -1,   -37,    -2,    -3,    -5,   -37,   -37,    53,    -4,    -6,
+    -7,    -8,    -9,   -10,   -11,   -37,   -24,   -25,   -26,   -37,
+   -22,   -23,   -37,   -27,   -28,   -29,   -30,   -31,   -32,   -37,
+   -35,   -36,   -37,   -37,   -37,   -19,   -20,   -21,   -37,   -33,
+   -12,   -37,   -37,   -37,   -37,   -17,   -37,   -34,   -13,   -14,
+   -15,   -16,   -18 ]
 
 racc_goto_table = [
-     3,    12,    10,     6,     9,     1,    11,     2,    13,    15,
-    23,   nil,   nil,   nil,    28,    20 ]
+    32,     3,    12,     1,     9,    10,     6,    11,    13,    27,
+     2,    15,    46,    24,   nil,    30,    20,   nil,   nil,    48,
+    49,    50,    51 ]
 
 racc_goto_check = [
-     3,     7,     6,     4,     5,     1,     3,     2,     8,     9,
-    10,   nil,   nil,   nil,     7,     3 ]
+    10,     3,     7,     1,     5,     6,     4,     3,     8,     9,
+     2,    11,    10,    12,   nil,     7,     3,   nil,   nil,    10,
+    10,    10,    10 ]
 
 racc_goto_pointer = [
-   nil,     5,     7,     0,    -1,    -2,    -4,    -5,     2,     3,
-    -8 ]
+   nil,     3,    10,     1,     2,    -2,    -1,    -4,     2,    -9,
+   -22,     5,    -5 ]
 
 racc_goto_default = [
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil ]
+   nil,   nil,   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
-  0, 16, :_reduce_none,
-  1, 16, :_reduce_2,
-  1, 17, :_reduce_3,
-  3, 18, :_reduce_4,
-  0, 19, :_reduce_5,
-  2, 19, :_reduce_6,
-  1, 20, :_reduce_none,
-  1, 20, :_reduce_8,
-  1, 20, :_reduce_none,
-  1, 20, :_reduce_none,
-  1, 20, :_reduce_11,
-  2, 21, :_reduce_12,
-  2, 21, :_reduce_13,
-  1, 24, :_reduce_none,
-  1, 24, :_reduce_none,
-  1, 22, :_reduce_16,
-  2, 22, :_reduce_17,
-  2, 22, :_reduce_18,
-  2, 22, :_reduce_19,
-  2, 22, :_reduce_20,
-  1, 25, :_reduce_21,
-  2, 25, :_reduce_22,
-  3, 25, :_reduce_23,
-  2, 23, :_reduce_24,
-  2, 23, :_reduce_25 ]
-
-racc_reduce_n = 26
-
-racc_shift_n = 33
+  0, 28, :_reduce_none,
+  1, 28, :_reduce_2,
+  1, 29, :_reduce_3,
+  3, 30, :_reduce_4,
+  0, 31, :_reduce_5,
+  2, 31, :_reduce_6,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_8,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_11,
+  3, 36, :_reduce_12,
+  3, 37, :_reduce_13,
+  3, 37, :_reduce_14,
+  3, 37, :_reduce_15,
+  3, 37, :_reduce_16,
+  2, 37, :_reduce_17,
+  3, 37, :_reduce_18,
+  1, 37, :_reduce_19,
+  1, 37, :_reduce_20,
+  1, 37, :_reduce_21,
+  2, 33, :_reduce_22,
+  2, 33, :_reduce_23,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_none,
+  1, 34, :_reduce_26,
+  2, 34, :_reduce_27,
+  2, 34, :_reduce_28,
+  2, 34, :_reduce_29,
+  2, 34, :_reduce_30,
+  2, 34, :_reduce_31,
+  1, 39, :_reduce_32,
+  2, 39, :_reduce_33,
+  3, 39, :_reduce_34,
+  2, 35, :_reduce_35,
+  2, 35, :_reduce_36 ]
+
+racc_reduce_n = 37
+
+racc_shift_n = 53
 
 racc_token_table = {
   false => 0,
@@ -98,18 +127,30 @@ racc_token_table = {
   :OTAG => 2,
   :CTAG => 3,
   :MACRO => 4,
-  "+" => 5,
-  "-" => 6,
-  :ATTR => 7,
-  :APLAIN => 8,
-  :AMACRO => 9,
-  :ANUMBER => 10,
-  :ASTR => 11,
-  :UNDERSC => 12,
-  :APLUS => 13,
-  :SLASH => 14 }
-
-racc_nt_base = 15
+  :BACKQ => 5,
+  :EPLUS => 6,
+  :EMINUS => 7,
+  :EMUL => 8,
+  :EDIV => 9,
+  :ENUMBER => 10,
+  :EUMIN => 11,
+  "(" => 12,
+  ")" => 13,
+  :ESTR => 14,
+  :ENUM => 15,
+  :EVAR => 16,
+  "+" => 17,
+  "-" => 18,
+  :ATTR => 19,
+  :APLAIN => 20,
+  :AMACRO => 21,
+  :ANUMBER => 22,
+  :ASTR => 23,
+  :UNDERSC => 24,
+  :APLUS => 25,
+  :SLASH => 26 }
+
+racc_nt_base = 27
 
 racc_use_result_var = true
 
@@ -135,6 +176,18 @@ Racc_token_to_s_table = [
   "OTAG",
   "CTAG",
   "MACRO",
+  "BACKQ",
+  "EPLUS",
+  "EMINUS",
+  "EMUL",
+  "EDIV",
+  "ENUMBER",
+  "EUMIN",
+  "\"(\"",
+  "\")\"",
+  "ESTR",
+  "ENUM",
+  "EVAR",
   "\"+\"",
   "\"-\"",
   "ATTR",
@@ -154,6 +207,8 @@ Racc_token_to_s_table = [
   "action",
   "attribute",
   "filter",
+  "expression",
+  "expr",
   "aop",
   "string_val" ]
 
@@ -222,87 +277,164 @@ module_eval(<<'.,.,', 'parser.y', 16)
 
 module_eval(<<'.,.,', 'parser.y', 18)
   def _reduce_12(val, _values, result)
-     log.debug "Found a action tag #{val[0]}:#{val[1]}"; return Tag::Action[val[1],val[0]] 
+     return val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 19)
+module_eval(<<'.,.,', 'parser.y', 20)
   def _reduce_13(val, _values, result)
-     log.debug "Found a action mac #{val[0]}:#{val[1]}"; return Tag::Action[Tag::Macro[val[1]],val[0]] 
+     log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] 
     result
   end
 .,.,
 
-# reduce 14 omitted
+module_eval(<<'.,.,', 'parser.y', 21)
+  def _reduce_14(val, _values, result)
+     log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] 
+    result
+  end
+.,.,
 
-# reduce 15 omitted
+module_eval(<<'.,.,', 'parser.y', 22)
+  def _reduce_15(val, _values, result)
+     log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] 
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'parser.y', 24)
+module_eval(<<'.,.,', 'parser.y', 23)
   def _reduce_16(val, _values, result)
-     log.debug "Found empty attribute: #{val[0]}"; return Tag::Attribute[val[0],''] 
+     log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 25)
+module_eval(<<'.,.,', 'parser.y', 24)
   def _reduce_17(val, _values, result)
-     log.debug "Found plain attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] 
+     return Tag:Expr[-val[1]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 26)
+module_eval(<<'.,.,', 'parser.y', 25)
   def _reduce_18(val, _values, result)
-     log.debug "Found string attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] 
+     return val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 27)
+module_eval(<<'.,.,', 'parser.y', 26)
   def _reduce_19(val, _values, result)
-     log.debug "Found macro attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] 
+     log.debug "Found a string #{val[0]}"; return Tag::Expr[val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 28)
+module_eval(<<'.,.,', 'parser.y', 27)
   def _reduce_20(val, _values, result)
-     log.debug "Found numeric attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]]  
+     log.debug "Found a number #{val[0]}"; return Tag::Expr[val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 30)
+module_eval(<<'.,.,', 'parser.y', 28)
   def _reduce_21(val, _values, result)
-     return " #{val[0]}" 
+     log.debug "Found a variable #{val[0]}"; return Tag::Expr[Tag::Expr::Var[val[0]]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 31)
+module_eval(<<'.,.,', 'parser.y', 30)
   def _reduce_22(val, _values, result)
-     return ' '+val[0]+' '+val[1] 
+     log.debug "Found a action tag #{val[0]}:#{val[1]}"; return Tag::Action[val[1],val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 32)
+module_eval(<<'.,.,', 'parser.y', 31)
   def _reduce_23(val, _values, result)
+     log.debug "Found a action mac #{val[0]}:#{val[1]}"; return Tag::Action[Tag::Macro[val[1]],val[0]] 
+    result
+  end
+.,.,
+
+# reduce 24 omitted
+
+# reduce 25 omitted
+
+module_eval(<<'.,.,', 'parser.y', 36)
+  def _reduce_26(val, _values, result)
+     log.debug "Found empty attribute: #{val[0]}"; return Tag::Attribute[val[0],''] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 37)
+  def _reduce_27(val, _values, result)
+     log.debug "Found plain attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 38)
+  def _reduce_28(val, _values, result)
+     log.debug "Found string attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 39)
+  def _reduce_29(val, _values, result)
+     log.debug "Found macro attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 40)
+  def _reduce_30(val, _values, result)
+     log.debug "Found numeric attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]]  
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 41)
+  def _reduce_31(val, _values, result)
+     log.debug "Found expression attribute: #{val[0]}"; return Tag::Attribute[val[0],val[1]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 43)
+  def _reduce_32(val, _values, result)
+     return " #{val[0]}" 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 44)
+  def _reduce_33(val, _values, result)
+     return ' '+val[0]+' '+val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 45)
+  def _reduce_34(val, _values, result)
      return val[0] + '+' + val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 34)
-  def _reduce_24(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 47)
+  def _reduce_35(val, _values, result)
      log.debug "Found an attribute filter #{val[1]}"; return Tag::Filter[val[1]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 35)
-  def _reduce_25(val, _values, result)
+module_eval(<<'.,.,', 'parser.y', 48)
+  def _reduce_36(val, _values, result)
      log.debug "Found a macro filter #{val[1]}"; return Tag::Filter[Tag::Macro[val[1]]] 
     result
   end

data/lib/wml_action/parser.y

@@ -15,6 +15,18 @@ rule
                 | attribute
                 | filter
                 | MACRO    { log.debug "Found a macro #{val[0]}"; return Tag::Macro[val[0]] }
+    
+    expression  : BACKQ expr BACKQ { return val[1] }
+
+    expr        : expr EPLUS expr { log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] }
+                | expr EMINUS expr { log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] } 
+                | expr EMUL expr { log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] }
+                | expr EDIV expr { log.debug "Found a #{val[0]} #{val[1]} #{val[2]} expression"; return val[0] << val[2] << Tag::Expr[Tag::Expr::Op[val[1]]] }
+                | EMINUS ENUMBER =EUMIN { return Tag:Expr[-val[1]] }
+                | '(' expr ')' { return val[1] }
+                | ESTR { log.debug "Found a string #{val[0]}"; return Tag::Expr[val[0]] }
+                | ENUM { log.debug "Found a number #{val[0]}"; return Tag::Expr[val[0]] }
+                | EVAR { log.debug "Found a variable #{val[0]}"; return Tag::Expr[Tag::Expr::Var[val[0]]] }
 
     action      : aop tag { log.debug "Found a action tag #{val[0]}:#{val[1]}"; return Tag::Action[val[1],val[0]] }
                 | aop MACRO { log.debug "Found a action mac #{val[0]}:#{val[1]}"; return Tag::Action[Tag::Macro[val[1]],val[0]] }
@@ -27,6 +39,7 @@ rule
                 | ATTR string_val     { log.debug "Found string attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] }
                 | ATTR AMACRO   { log.debug "Found macro attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]] }
                 | ATTR ANUMBER  { log.debug "Found numeric attribute: #{val[0]}:#{val[1]}"; return Tag::Attribute[val[0],val[1]]  }
+                | ATTR expression { log.debug "Found expression attribute: #{val[0]}"; return Tag::Attribute[val[0],val[1]] }
 
     string_val  : ASTR { return " #{val[0]}" }
                 | UNDERSC ASTR { return ' '+val[0]+' '+val[1] }

data/lib/wml_action/tag.rb

@@ -76,10 +76,22 @@ module WMLAction
       return self unless @name == other.name
       return self unless match?( other.filter )
       log.info "Merging [#{@name}] section with [#{other.name}] with filter: #{other.filter}"
+      delayed_attrs={}
       other.attrs.each_pair do |key,value|
         log.debug "Processing key: #{key}=#{value}"
+        if value.class==Expr
+            delayed_attrs.store(key,value)
+            next
+        end
         @attrs.store(key,value)
       end
+      saved_attrs=@attrs.clone unless delayed_attrs.empty?
+      delayed_attrs.each_pair do |key,value|
+        log.debug "Calculating attr expression: #{key}=#{value}"
+        result = value.result(@attrs)
+        @attrs.store(key,result)
+      end
+      saved_attrs=[]
       other.macros.each do |macro|
         log.debug "Adding macro: #{macro}"
         @macros<<(macro)
@@ -139,6 +151,10 @@ module WMLAction
       @actions.include?(action)
     end
 
+    def attr(name)
+        @attrs[name]
+    end
+
   end
 
 end

data/lib/wml_action/version.rb

@@ -1,3 +1,3 @@
 module WMLAction
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/wml_action.rb

@@ -1,5 +1,6 @@
 require "wml_action/version"
 require "wml_action/tag"
+require "wml_action/expr"
 require "wml_action/cli"
 require "wml_action/document"
 require "wml_action/parser.tab"

data/spec/document_spec.rb

@@ -75,5 +75,12 @@ module WMLAction
       expect(s.actions[3].object.name).to eq "resists"
     end
 
+    it 'reads expressions' do
+      d = Document.from_file('spec/fixtures/expr.cfg')
+      s = d.root
+      expect(s.attr('hp')).to eq Tag::Expr[Tag::Expr::Var['hp'],3.0,Tag::Expr::Op['+']]
+      expect(s.attr('damage')).to eq Tag::Expr[Tag::Expr::Var['damage'],1.0,Tag::Expr::Op['-'],2.0,Tag::Expr::Op['*']]
+    end
+
   end
 end

data/spec/expr_spec.rb

@@ -0,0 +1,89 @@
+require 'wml_action'
+require 'debugger'
+
+module WMLAction
+
+  describe Tag::Expr do
+
+    before(:all) do
+        Expr=Tag::Expr unless WMLAction.const_defined? 'Expr'
+        Var=Tag::Expr::Var unless WMLAction.const_defined? 'Var'
+        Op=Tag::Expr::Op unless WMLAction.const_defined? 'Op'
+    end
+
+    describe '#result' do
+
+        it 'sums numbers' do
+            e=Expr[1,2,Op['+']]
+            expect(e.result).to eq 3
+        end
+
+        it 'substract numbers' do
+            e=Expr[2,1,Op['-']]
+            expect(e.result).to eq 1
+        end
+
+        it 'multiply numbers' do
+            e=Expr[2,3,Op['*']]
+            expect(e.result).to eq 6
+        end
+
+        it 'multiply numbers' do
+            e=Expr[6,3,Op['/']]
+            expect(e.result).to eq 2
+        end
+
+        it 'more than one operation' do
+            e=Expr[2,3,Op['*'],3,Op['-']]
+            expect(e.result).to eq 3
+        end
+
+        it 'results in integers' do
+            e=Expr[6,4,Op['/']]
+            expect(e.result).to be_integer
+        end
+
+        it 'concatenates strings' do
+            e=Expr['Hello',' World!',Op['+']]
+            expect(e.result).to eq 'Hello World!'
+        end
+
+        it 'substitute variables' do
+            e=Expr[Var[:a],Var[:b],Op['+']]
+            expect(e.result({a: 1, b: 3})).to eq 4
+        end
+
+        it 'returns empty string on empty expr' do
+            e=Expr[]
+            expect(e.result).to eq ''
+        end
+
+        it 'raises syntax error on error with binary op' do
+            e=Expr[1,Op['+']]
+            expect { e.result }.to raise_error
+        end
+
+        it 'raises syntax error on error with lack of op' do
+            e=Expr[1,2]
+            expect { e.result }.to raise_error
+        end
+
+    end
+
+    describe '#dump' do
+        it 'dumps' do
+            e=Expr[Var['hp'],1,Op['+'],2,Op['*']]
+            expect(e.dump).to eq 'hp 1 + 2 *'
+        end
+    end
+
+    describe '#to_s' do
+        it 'pretty prints for wml file output' do
+            pending('Do not think I need this feature')
+            e=Expr[Var['hp'],1,Op['+'],2,Op['*']]
+            expect(e.to_s).to eq '(hp+1)*2'
+        end
+    end
+
+  end
+end

data/spec/fixtures/expr.cfg

@@ -0,0 +1,4 @@
+[unit]
+  hp=`hp+3`
+  damage=`(damage-1)*2`
+[/unit]