kalc 0.7.0 → 0.8.0

data/README.md

@@ -13,8 +13,9 @@ typing in `ikalc`
 Syntax
 ------
 
-kalc is a tiny language, and it has very little syntax. It does support
-functions, variable assignment, and arithmetic.
+kalc is a tiny language, and it has very little syntax. It supports
+functions, variable assignment, arithmetic, and some string parsing
+functionality.
 
 Numbers
 -------
@@ -39,8 +40,32 @@ Logical operations
 Variable assignment
 -------------------
 
+The assignment operator `:=` is borrowed from Pascal.  This decision was
+made for practical reason.  Since comparison operators are both `=` and
+`==` and the language is expression-based, `=` could not be chosen. 
+
+Variables come in a lot of different flavors.
+
+You have standard variables:
+
     a := 1 b := 2 d := a + b
 
+    d := 100.0
+
+and you have quoted variables:
+
+    'a' := 1 'b' := 2 'd' := 'a' + 'b'
+
+Quoted variables can contain pretty much any character that you can
+think of:
+
+    'Hello world' := 1
+    'Hello 2 the world' := 1
+    'This \' is a \' [string]' := 1
+    '!@#$%^& !@#$%^& *&^%$%^&*' := 1
+
+The only real rule is that you need to escape a standard single quote.
+
 Functions
 ---------
 
@@ -62,13 +87,38 @@ on the Excel formula functions, so you should see some overlap.
 
 Some of them are:
 
-    IF, OR, NOT, AND, RAND, SYSTEM, ISLOGICAL, ISNONTEXT, ISNUMBER, ISTEXT, ABS,
-    DEGREES, PRODUCT, RADIANS, ROUND, SUM, TRUNC, LN, ACOS, ACOSH, ASIN, ASINH,
-    ATAN, ATANH, CBRT, COS, COSH, ERF, ERFC, EXP, GAMMA, LGAMMA, LOG, LOG2,
-    LOG10, SIN, SINH, SQRT, TAN, TANH, UPPER, LOWER, CHOMP, CHOP, CHR, CLEAR,
-    COUNT, DOWNCASE, HEX, INSPECT, INTERN, TO_SYM, LENGTH, SIZE, LSTRIP, SUCC,
-    NEXT, OCT, ORD, REVERSE, RSTRIP, STRIP, SWAPCASE, TO_C, TO_F, TO_I, TO_R,
-    UPCASE, P, PP, PUTS, PLUS_ONE, MINUS_ONE, SQUARE, CUBE, FIB, FACTORIAL,
+    # Conditional
+    IF, OR, NOT, AND
+
+    # Random number generation
+    RAND
+
+    # System level integration  
+    SYSTEM
+
+    # Boolean functions
+    ISLOGICAL, ISNONTEXT, ISNUMBER, ISTEXT
+
+    # Math functions
+    ABS, DEGREES, PRODUCT, RADIANS, ROUND, SUM, TRUNC, LN, ACOS,
+    ACOSH, ASIN, ASINH, ATAN, ATANH, CBRT, COS, COSH, ERF, ERFC, EXP, GAMMA,
+    LGAMMA, LOG, LOG2, LOG10, SIN, SINH, SQRT, TAN, TANH
+
+    # String functions
+    CHOMP, CHOP, CHR, CLEAR, COUNT, DOWNCASE, HEX, INSPECT, INTERN, TO_SYM, LENGTH, SIZE,
+    LSTRIP, SUCC, NEXT, OCT, ORD, REVERSE, RSTRIP, STRIP, SWAPCASE, TO_C,
+    TO_F, TO_I, TO_R, UPCASE, CHAR, CLEAN, CODE, CONCATENATE, DOLLAR, EXACT,
+    FIND, FIXED, LEFT, LEN, LOWER, MID, PROPER, REPLACE, REPT, RIGHT,
+    SEARCH, SUBSTITUTE, TRIM, UPPER, VALUE
+
+    # Regular expression functions
+    REGEXP_MATCH, REGEXP_REPLACE
+
+    # Debugging
+    P, PP, PUTS, 
+
+    # Other
+    PLUS_ONE, MINUS_ONE, SQUARE, CUBE, FIB, FACTORIAL,
     TOWERS_OF_HANOI
 
 Loops
@@ -77,7 +127,10 @@ Loops
 There are no looping mechanisms to speak of, but recursion works (pretty) well.  
 **Note:** *go too deep and you might blow the stack!*
 
-    DEFINE SAMPLE_LOOP(a) { PUTS(a) IF(a == 1, 1, SAMPLE_LOOP(a - 1)) }
+    DEFINE SAMPLE_LOOP(a) { 
+      PUTS(a) 
+      IF(a == 1, 1, SAMPLE_LOOP(a - 1)) 
+    }
 
 There are a few examples of loops via recursion in `lib/stdlib.kalc`
 
@@ -97,7 +150,7 @@ For example, here is how you compare 2 variables:
 
     (a == a) && (b = b) \> true
 
-'=' and '==' are both equality operators. Use ':=' for assignment.
+`=` and `==` are both equality operators. Use `:=` for assignment.
 
 More inside
 -----------

data/lib/kalc/grammar.rb

@@ -126,13 +126,22 @@ class Kalc::Grammar < Parslet::Parser
     (alpha >> (alpha | digit).repeat) >> spaces?
   }
 
+  rule(:quoted_identifier) {
+    str("'") >> 
+    (
+      str('\\') >> any  | str("'").absnt? >> any
+    ).repeat(1) >>
+    str("'") >> spaces?
+  }
+
   rule(:argument) {
     identifier.as(:argument)
   }
 
   # Should look like 'Name'
   rule(:variable) {
-    identifier | (str("'") >> spaces? >> identifier.repeat >> str("'")) >> spaces?
+    #identifier | (str("'") >> spaces? >> identifier.repeat >> str("'")) >> spaces?
+    identifier | quoted_identifier
   }
 
   # Does not self-evaluate

data/lib/kalc/interpreter.rb

@@ -115,15 +115,6 @@ module Kalc
           })
         end
 
-        # Change case of text
-        env.add_function(:UPPER, lambda { |cxt, val|  
-          val.eval(cxt).upcase
-        })
-
-        env.add_function(:LOWER, lambda { |cxt, val|  
-          val.eval(cxt).downcase
-        })
-
         # Strings
         string_funs = 
           [
@@ -145,6 +136,117 @@ module Kalc
           })
         end
 
+        env.add_function(:CHAR, lambda { |cxt, val|
+          Integer(val.eval(cxt)).chr
+        })
+
+        env.add_function(:CLEAN, lambda { |cxt, val| 
+          val.eval(cxt).gsub(/\P{ASCII}/, '')
+        })
+
+        env.add_function(:CODE, lambda { |cxt, val|
+          val.eval(cxt).ord
+        })
+
+        env.add_function(:CONCATENATE, lambda { |cxt, *args| 
+          args.map { |a| a.eval(cxt) }.join
+        })
+
+        env.add_function(:DOLLAR, lambda { |cxt, val, decimal_places|
+          "%.#{Integer(decimal_places.eval(cxt))}f" % Float(val.eval(cxt))
+        })
+
+        env.add_function(:EXACT, lambda { |cxt, string1, string2|
+          string1.eval(cxt) == string2.eval(cxt)
+        })
+
+        env.add_function(:FIND, lambda { |cxt, string1, string2, starting_pos|
+          start = Integer(starting_pos.eval(cxt)) - 1
+          string1.eval(cxt)[start..-1].index(string2.eval(cxt)) + 1
+        })
+
+        env.add_function(:FIXED, lambda { |cxt, val, decimal_places, no_commas|
+          output = "%.#{Integer(decimal_places.eval(cxt))}f" % Float(val.eval(cxt))
+          output = output.to_s.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse if no_commas.eval(cxt) == false
+          output
+        })
+
+        env.add_function(:LEFT, lambda { |cxt, val, number_of_characters| 
+          num = Integer(number_of_characters.eval(cxt)) - 1
+          val.eval(cxt)[0..num]
+        })
+
+        env.add_function(:LEN, lambda { |cxt, val|
+          val.eval(cxt).length
+        })
+
+        env.add_function(:LOWER, lambda { |cxt, val|  
+          val.eval(cxt).downcase
+        })
+
+        env.add_function(:MID, lambda { |cxt, val, start_position, number_of_characters|
+    
+          start = Integer(start_position.eval(cxt)) - 1
+          chars = Integer(number_of_characters.eval(cxt)) - 1
+
+          val.eval(cxt)[start..chars + start]
+        })
+
+        env.add_function(:PROPER, lambda { |cxt, val|
+          val.eval(cxt).split(" ").map { |c| c.capitalize }.join(" ")
+        })
+
+        env.add_function(:REPLACE, lambda { |cxt, val, start_position, number_of_chars, new_text|
+          start = Integer(start_position.eval(cxt)) - 1
+          chars = Integer(number_of_chars.eval(cxt)) - 1
+          output = val.eval(cxt)
+          output[start..chars + start] = new_text.eval(cxt)
+          output
+        })
+
+        env.add_function(:REPT, lambda { |cxt, val, number_of_times| 
+          val.eval(cxt) * Integer(number_of_times.eval(cxt))
+        })
+
+        env.add_function(:RIGHT, lambda { |cxt, val, number_of_characters|
+          num = -Integer(number_of_characters.eval(cxt))
+          val.eval(cxt)[num..-1]
+        })
+
+        env.add_function(:SEARCH, lambda { |cxt, string1, string2, start_position|
+          start = Integer(start_position.eval(cxt)) - 1
+          string2.eval(cxt).downcase[start..-1].index(string1.eval(cxt).downcase) + 1
+        })
+
+        env.add_function(:SUBSTITUTE, lambda { |cxt, val, old_text, new_text|  
+          val.eval(cxt).gsub(old_text.eval(cxt), new_text.eval(cxt))
+        })
+
+        env.add_function(:TRIM, lambda { |cxt, val|
+          val.eval(cxt).strip
+        })
+
+        env.add_function(:UPPER, lambda { |cxt, val|  
+          val.eval(cxt).upcase
+        })
+
+        env.add_function(:VALUE, lambda { |cxt, val|
+          val.eval(cxt).to_f
+        })
+
+        # Regular expressions
+        
+        env.add_function(:REGEXP_MATCH, lambda { |cxt, val, regex|
+          r = regex.eval(cxt)
+          /#{r}/.match(val.eval(cxt))
+        })
+  
+        env.add_function(:REGEXP_REPLACE, lambda { |cxt, val, regex, to_replace|
+          r = regex.eval(cxt)
+
+          val.eval(cxt).gsub(/#{r}/, to_replace.eval(cxt))
+        })
+        
         # Debug
         env.add_function(:P, lambda { |cxt, *output|  
           p output

data/lib/kalc/version.rb

@@ -1,3 +1,3 @@
 module Kalc
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/spec/interpreter_spec.rb

@@ -32,6 +32,11 @@ describe Kalc::Interpreter do
     evaluate("a := 1; b := 2; 1 + b").should == 3
   end
 
+  it "should be able to load quoted variables" do
+    evaluate("'Item (a)' := 1; 1 + 'Item (a)'").should == 2
+    evaluate("'a' := 1; 'b[a]' := 2 + 'a'; 1 + 'b[a]'").should == 4
+  end
+
   it "should be able to load single quoted variables" do
     evaluate("'a' := 1; 1 + 'a'").should == 2
     evaluate("'a' := 1; 'b' := 2; 'b' + 'a'").should == 3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kalc
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-27 00:00:00.000000000 Z
+date: 2012-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake