keisan 0.8.4 → 0.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de85515fc642eede46d24bdb2347a7f8bbe32c4d317fd305404c08367e742ecf
-  data.tar.gz: 0ce75e5555ca880e690e1cae4b76820594899706aa5608944fa5c9eedd0be9c8
+  metadata.gz: '0817ad5c7f153f93b34fd0c3861a1b4d9afcb49ad325310f2258f6ea020e444d'
+  data.tar.gz: 2d1601371bf02fdacdcbd6f29cf72ce9ec15d46a402579dc89418825fde97a5c
 SHA512:
-  metadata.gz: cd6b7cee90edee2d0ba51eb6b4d0a223305eeaf75a85ec6c2c6dbd9c3310ecd035c00d4a86d16768303f28d61996291e6e4d3ac7e5323a3a4df0c22f6343ff58
-  data.tar.gz: '05873d8324f622a818f5cba2b9ef260e61f3500154db3ab0ecb9570bf308a686f4b32eddcbfb664afab76845fe71da7c82f47dd511f845f33498045011024a8a'
+  metadata.gz: 4faa11222178814693fb58d9db1ddafa7097e49a15e5c59aa8132c26a56e8fc8f69487057ad11e2a37d6dd84d1bb7afa9af4b536ed898d9cd082f357e226098d
+  data.tar.gz: ba57a649fbaf1fec6dc29495f86921141c627ea1e652cccd884f30edf4f9e70096803f1ed36acab4b010930abb75dc01cb09cdd5f399c2bec0b03c6c27d1d449

data/.github/workflows/ruby.yml

@@ -0,0 +1,28 @@
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby-version: [2.3, 2.4, 2.5, 2.6, 2.7, 3.0]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rspec

data/README.md

@@ -178,6 +178,22 @@ calculator.evaluate("x = 11; {let x = 12}; x")
 #=> 11
 ```
 
+##### Comments
+
+When working with multi-line blocks of code, sometimes comments are useful to include.
+Comments are parts of a string from the `#` character to the end of a line (indicated by a newline character `"\n"`).
+
+```
+calculator = Keisan::Calculator.new
+calculator.evaluate("""
+  # This is a comment
+  x = 'foo'
+  x += '#bar' # Notice that `#` inside strings is not part of the comment
+  x # Should print 'foo#bar'
+""")
+#=> "foo#bar"
+```
+
 ##### Lists
 
 Just like in Ruby, lists can be defined using square brackets, and indexed using square brackets

data/lib/keisan/ast/block.rb

@@ -17,8 +17,8 @@ module Keisan
         child.unbound_functions(local)
       end
 
-      def contains_a?(klass)
-        super || child.contains_a?(klass)
+      def traverse(&block)
+        super(&block) || child.traverse(&block)
       end
 
       def deep_dup

data/lib/keisan/ast/cell.rb

@@ -15,8 +15,8 @@ module Keisan
         node.unbound_functions(context)
       end
 
-      def contains_a?(klass)
-        super || node.contains_a?(klass)
+      def traverse(&block)
+        super(&block) || node.traverse(&block)
       end
 
       def deep_dup

data/lib/keisan/ast/hash.rb

@@ -21,8 +21,16 @@ module Keisan
         end
       end
 
-      def contains_a?(klass)
-        super || @hash.any? {|k, v| k.to_node.contains_a?(klass) || v.contains_a?(klass) }
+      def traverse(&block)
+        value = super(&block)
+        return value if value
+        @hash.each do |k, v|
+          value = k.to_node.traverse(&block)
+          return value if value
+          value = v.traverse(&block)
+          return value if value
+        end
+        false
       end
 
       def evaluate(context = nil)

data/lib/keisan/ast/node.rb

@@ -37,12 +37,26 @@ module Keisan
         value(context)
       end
 
+      # Takes a block, and does a DFS down the AST, evaluating the received block
+      # at each node, passing in the node as the single argument. If the block
+      # returns a truthy value at any point, the DFS ends and the return value is
+      # percolated up the tree.
+      def traverse(&block)
+        block.call(self)
+      end
+
       def contains_a?(klass)
         case klass
         when Array
-          klass.any? {|k| is_a?(k) }
+          klass.any? do |k|
+            traverse do |node|
+              node.is_a?(k)
+            end
+          end
         else
-          is_a?(klass)
+          traverse do |node|
+            node.is_a?(klass)
+          end
         end
       end
 

data/lib/keisan/ast/number.rb

@@ -5,6 +5,11 @@ module Keisan
 
       def initialize(number)
         @number = number
+        # Reduce the number if possible
+        case @number
+        when Rational
+          @number = @number.numerator if @number.denominator == 1
+        end
       end
 
       def value(context = nil)

data/lib/keisan/ast/parent.rb

@@ -25,8 +25,14 @@ module Keisan
         end
       end
 
-      def contains_a?(klass)
-        super || children.any? {|child| child.contains_a?(klass) }
+      def traverse(&block)
+        value = super(&block)
+        return value if value
+        children.each do |child|
+          value = child.traverse(&block)
+          return value if value
+        end
+        false
       end
 
       def freeze

data/lib/keisan/calculator.rb

@@ -4,11 +4,12 @@ module Keisan
 
     # Note, allow_recursive would be more appropriately named:
     # allow_unbound_functions_in_function_definitions, but it is too late for that.
-    def initialize(context: nil, allow_recursive: false, allow_blocks: true, allow_multiline: true)
+    def initialize(context: nil, allow_recursive: false, allow_blocks: true, allow_multiline: true, allow_random: true)
       @context = context || Context.new(
         allow_recursive: allow_recursive,
         allow_blocks: allow_blocks,
-        allow_multiline: allow_multiline
+        allow_multiline: allow_multiline,
+        allow_random: allow_random
       )
     end
 
@@ -28,6 +29,10 @@ module Keisan
       context.allow_multiline
     end
 
+    def allow_random
+      context.allow_random
+    end
+
     def evaluate(expression, definitions = {})
       Evaluator.new(self).evaluate(expression, definitions)
     end

data/lib/keisan/context.rb

@@ -4,13 +4,15 @@ module Keisan
       :variable_registry,
       :allow_recursive,
       :allow_multiline,
-      :allow_blocks
+      :allow_blocks,
+      :allow_random
 
     def initialize(parent: nil,
                    random: nil,
                    allow_recursive: false,
                    allow_multiline: true,
                    allow_blocks: true,
+                   allow_random: true,
                    shadowed: [])
       @parent = parent
       @function_registry = Functions::Registry.new(parent: @parent&.function_registry)
@@ -19,6 +21,7 @@ module Keisan
       @allow_recursive   = allow_recursive
       @allow_multiline   = allow_multiline
       @allow_blocks      = allow_blocks
+      @allow_random      = allow_random
     end
 
     def allow_recursive!
@@ -111,7 +114,13 @@ module Keisan
     end
 
     def random
-      @random || @parent&.random || Random.new
+      raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with randomness") unless allow_random
+      @random ||= @parent&.random || Random.new
+    end
+
+    def set_random(random)
+      raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with randomness") unless allow_random
+      @random = random
     end
 
     protected

data/lib/keisan/functions/enumerable_function.rb

@@ -21,14 +21,17 @@ module Keisan
         context ||= Context.new
 
         operand, arguments, expression = operand_arguments_expression_for(ast_function, context)
+        
+        # Extract underlying operand for cells
+        real_operand = operand.is_a?(AST::Cell) ? operand.node : operand
 
-        case operand
+        case real_operand
         when AST::List
-          evaluate_list(operand, arguments, expression, context).evaluate(context)
+          evaluate_list(real_operand, arguments, expression, context).evaluate(context)
         when AST::Hash
-          evaluate_hash(operand, arguments, expression, context).evaluate(context)
+          evaluate_hash(real_operand, arguments, expression, context).evaluate(context)
         else
-          raise Exceptions::InvalidFunctionError.new("Unhandled first argument to #{name}: #{operand}")
+          raise Exceptions::InvalidFunctionError.new("Unhandled first argument to #{name}: #{real_operand}")
         end
       end
 

data/lib/keisan/string_and_group_parser.rb

@@ -9,24 +9,26 @@ module Keisan
     end
 
     class StringPortion < Portion
-      attr_reader :string
+      attr_reader :string, :escaped_string
 
       def initialize(expression, start_index)
         super(start_index)
 
         @string = expression[start_index]
+        @escaped_string = expression[start_index]
         @end_index = start_index + 1
 
         while @end_index < expression.size
           if expression[@end_index] == quote_type
             @string << quote_type
+            @escaped_string << quote_type
             @end_index += 1
             # Successfully parsed the string
             return
           end
 
-          n, c = process_next_character(expression, @end_index)
-          @string << c
+          n, c = get_potentially_escaped_next_character(expression, @end_index)
+          @escaped_string << c
           @end_index += n
         end
 
@@ -44,9 +46,13 @@ module Keisan
       private
 
       # Returns number of processed input characters, and the output character
-      def process_next_character(expression, index)
-        # escape character
-        if expression[index] == "\\"
+      # If a sequence like '\"' is encountered, the first backslash escapes the
+      # second double-quote, and the two characters will act as a one double-quote
+      # character.
+      def get_potentially_escaped_next_character(expression, index)
+        @string << expression[index]
+        if expression[index] == "\\" && index + 1 < expression.size
+          @string << expression[index + 1]
           return [2, escaped_character(expression[index + 1])]
         else
           return [1, expression[index]]

data/lib/keisan/tokenizer.rb

@@ -33,7 +33,7 @@ module Keisan
       @tokens = portions.inject([]) do |tokens, portion|
         case portion
         when StringAndGroupParser::StringPortion
-          tokens << Tokens::String.new(portion.to_s)
+          tokens << Tokens::String.new(portion.escaped_string)
         when StringAndGroupParser::GroupPortion
           tokens << Tokens::Group.new(portion.to_s)
         when StringAndGroupParser::OtherPortion

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.8.4"
+  VERSION = "0.8.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.9
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-16 00:00:00.000000000 Z
+date: 2021-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmath
@@ -115,9 +115,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -328,7 +328,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: An equation parser and evaluator

data/.travis.yml

@@ -1,9 +0,0 @@
-sudo: false
-language: ruby
-before_install:
-  - gem install bundler
-rvm:
-  - 2.4.9
-  - 2.5.7
-  - 2.6.5
-  - 2.7.0