eqn 1.6.2 → 1.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a298576c822eca16cdaf7281ec1344ea37f19a4
-  data.tar.gz: 3408ed487ad7cae4ff268559d1e71bf769221d90
+  metadata.gz: fce3040108d20ba8a47b915c6878c541f0c845c3
+  data.tar.gz: b612f8b6d206e04a545c1577f8032ace2c6f4b43
 SHA512:
-  metadata.gz: 2898eec4da5863b38c44460eb4d4fd980f4e71b9f481a92f5f09d14581399c313525dc324b3a5e2bf55768073e5b300c97687be4e8355132301d8ac1e4d9f1b0
-  data.tar.gz: 372020127e6141058da57c09fdccde57d8332a930dc0a59d9b76621b8f033d7b4b2f602d495af541dc8a1d311081d2e6610753fb95173bd52cea84efcf39dfff
+  metadata.gz: c9fdd51eb3ffd6b8acee105627279a70c886da6cce6bc1d4813ef78de5143aa81b8748d974230cfb74bba279f0b7e8e460ede46f00b4ce8e8acb8a43c98f5162
+  data.tar.gz: 8e862df9a84a75763e52cebeca227c7bd5221fbd8daaff4b70c5f5b607db663958cd883ff60ac0775f7cffbd7dfec076e184966608f7d84e2a493a7e3844a6ad

data/README.md

@@ -128,7 +128,7 @@ Rounds the number down (i.e. floor function). Optionally, pass a number of decim
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
 
-The gem uses rspec for testing; run `rspec` from the application root to execute the tests.
+The gem uses rspec for testing and appraisal to test against multiple versions of treetop (the only runtime dependency). From the command line, run `bundle exec appraisal install` to install gems and `bundle exec appraisal rspec` to run the complete test suite. (You can still run `bundle exec rspec` to only test against the latest version of treetop while developing.)
 
 ## Authorship
 
@@ -136,7 +136,7 @@ Written by Zach Schneider for [Aha!, the world's #1 product roadmap software](ht
 
 ## Contributing
 
-1. Fork it ( https://github.com/schneidmaster/eqn/fork )
+1. Fork it ([https://github.com/schneidmaster/eqn/fork](https://github.com/schneidmaster/eqn/fork))
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/eqn.gemspec

@@ -4,7 +4,7 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'eqn/version'
 
-config_files = %w[.rspec .rubocop.yml .ruby-version Appraisals circle.yml]
+config_files = %w(.rspec .rubocop.yml .ruby-version Appraisals circle.yml)
 
 Gem::Specification.new do |spec|
   spec.name          = 'eqn'

data/lib/eqn.rb

@@ -3,5 +3,8 @@ require 'treetop'
 # Load the parser from the Treetop grammar.
 Treetop.load(File.join(__dir__, 'eqn.treetop'))
 
-# Load eqn classes.
+# Load custom eqn syntax node.
+require File.join(__dir__, 'eqn', 'eqn_node')
+
+# Load other eqn classes.
 Dir.glob File.join(__dir__, 'eqn', '**', '*.rb'), &method(:require)

data/lib/eqn/calculator.rb

@@ -1,4 +1,5 @@
 module Eqn
+  # Primary calculator class used for performing calculations or creating eqn instances.
   class Calculator
     def initialize(eqn, vars = {})
       @eqn = eqn
@@ -9,16 +10,16 @@ module Eqn
       if key_or_hash.is_a?(Hash)
         @vars.merge!(key_or_hash)
       else
-        @vars[key_or_hash.intern] = value
+        @vars[key_or_hash.to_sym] = value
       end
     end
 
-    def method_missing(method, *args)
-      if %i[calculate calc valid?].include?(method)
+    def method_missing(method, *args) # rubocop:disable AbcSize
+      if %i(calculate calc valid?).include?(method)
         self.class.send(method, @eqn, @vars)
       elsif (match = method.to_s.match(/^[A-Za-z]+=$/))
-        @vars[match.to_s.delete('=').intern] = args.first
-      elsif (var = method.to_s.match(/^[A-Za-z]+$/).to_s.intern) && @vars.key?(var)
+        @vars[match.to_s.delete('=').to_sym] = args.first
+      elsif (var = method.to_s.match(/^[A-Za-z]+$/).to_s.to_sym) && @vars.key?(var)
         @vars[var]
       else
         super
@@ -26,7 +27,9 @@ module Eqn
     end
 
     def respond_to_missing?(method, _p2 = false)
-      %i[calculate calc valid?].include?(method) || method.to_s.match(/^[A-Za-z]+=$/) || (var = method.to_s.match(/^[A-Za-z]+$/).to_s.intern) && @vars.key?(var)
+      %i(calculate calc valid?).include?(method) ||
+        method.to_s.match(/^[A-Za-z]+=$/) ||
+        (var = method.to_s.match(/^[A-Za-z]+$/).to_s.to_sym) && @vars.key?(var)
     end
 
     class << self

data/lib/eqn/comparation.rb

@@ -1,15 +1,17 @@
 module Eqn
-  class Comparation < Treetop::Runtime::SyntaxNode
+  # Node class for a comparison between expressions.
+  class Comparation < EqnNode
     def value(vars = {})
       val_one = elements.shift.value(vars)
-      if elements.empty?
+      if term?
         val_one
       else
         val_one.send(*elements.shift.value(vars))
       end
     end
 
-    class CompGroup < Treetop::Runtime::SyntaxNode
+    # Node class for the operator and expression being compared.
+    class CompGroup < EqnNode
       def value(vars = {})
         [elements.shift.value(vars), elements.shift.value(vars)]
       end

data/lib/eqn/eqn_node.rb

@@ -0,0 +1,19 @@
+module Eqn
+  # Eqn parser node with helper methods for cleaning.
+  class EqnNode < Treetop::Runtime::SyntaxNode
+    def term?
+      elements.nil? || elements.empty?
+    end
+
+    def clean_tree!
+      # Return if node is a terminal.
+      return if term?
+
+      # Delete any cruft syntax nodes.
+      elements.delete_if { |node| !node.is_a?(EqnNode) }
+
+      # Recurse over any elements with their own children.
+      elements.each(&:clean_tree!)
+    end
+  end
+end

data/lib/eqn/expression.rb

@@ -1,38 +1,47 @@
 module Eqn
-  class Expression < Treetop::Runtime::SyntaxNode
+  # Node class for an expression.
+  class Expression < EqnNode
     def left_associative?
       elements.any? && elements.last.left_associative?
     end
 
-    def term?
-      elements.empty?
+    def value(vars = {})
+      base = elements.shift.value(vars)
+
+      # Aggressively consume left associative operators to maintain associativity.
+      base = consume_while_left_associative(base, vars)
+
+      # Apply next right-associative operator (if any) or return.
+      apply_next_operator(base, vars)
     end
 
-    def value(vars = {})
-      if elements.count == 1
-        elements.shift.value(vars)
+    private
+
+    def consume_while_left_associative(base, vars)
+      return base unless left_associative?
+      base = apply_next_operator(base, vars)
+      consume_while_left_associative(base, vars)
+    end
+
+    def apply_next_operator(base, vars)
+      return base if term?
+      left_associative = elements.last.left_associative?
+      op, num_expr = elements.shift.value(vars)
+      if left_associative
+        apply_left_associative(base, vars, op, num_expr)
       else
-        base = elements.shift.value(vars)
-
-        # Aggressively consume left associative operators to maintain associativity.
-        while left_associative?
-          op, num_expr = elements.shift.value(vars)
-          num_expr_operand = num_expr.elements.shift
-          base = base.send(op, num_expr_operand.value(vars))
-          elements.push num_expr.elements.shift unless num_expr.term?
-        end
-
-        # Apply next right-associative operator (if any) or return.
-        if term?
-          base
-        else
-          op, num_expr = elements.shift.value(vars)
-          base.send(op, num_expr.value(vars))
-        end
+        base.send(op, num_expr.value(vars))
       end
     end
 
-    class ExprGroup < Treetop::Runtime::SyntaxNode
+    def apply_left_associative(base, vars, op, num_expr)
+      num_expr_operand = num_expr.elements.shift
+      elements.push(num_expr.elements.shift) unless num_expr.term?
+      base.send(op, num_expr_operand.value(vars))
+    end
+
+    # Node class for the operator and latter component of an expression.
+    class ExprGroup < EqnNode
       def left_associative?
         elements.first.left_associative?
       end

data/lib/eqn/function.rb

@@ -1,6 +1,7 @@
 module Eqn
   module Function
-    class If < Treetop::Runtime::SyntaxNode
+    # Node class for the if function.
+    class If < EqnNode
       def value(vars = {})
         comp_val = elements.shift.value(vars)
         ls = elements.shift.value(vars)
@@ -10,35 +11,39 @@ module Eqn
       end
     end
 
-    class RoundBase < Treetop::Runtime::SyntaxNode
-      def value(fn, vars)
+    # Base node class for round functions.
+    class RoundBase < EqnNode
+      def value(vars)
         value = elements.shift.value(vars)
         raise ZeroDivisionError if value.is_a?(Float) && (value.abs == Float::INFINITY || value.nan?)
-        if elements.empty?
-          value.send(fn)
+        if term?
+          value.send(self.class::ROUND_METHOD)
         else
-          decimals = elements.shift.value(vars)
-          (value * 10**decimals).send(fn).to_f / 10**decimals
+          round_to_precision(vars, value)
         end
       end
+
+      private
+
+      def round_to_precision(vars, value)
+        decimals = elements.shift.value(vars)
+        (value * 10**decimals).send(self.class::ROUND_METHOD).to_f / 10**decimals
+      end
     end
 
+    # Node class for the round function.
     class Round < RoundBase
-      def value(vars = {})
-        super(:round, vars)
-      end
+      ROUND_METHOD = :round
     end
 
+    # Node class for the roundup function.
     class RoundUp < RoundBase
-      def value(vars = {})
-        super(:ceil, vars)
-      end
+      ROUND_METHOD = :ceil
     end
 
+    # Node class for the rounddown function.
     class RoundDown < RoundBase
-      def value(vars = {})
-        super(:floor, vars)
-      end
+      ROUND_METHOD = :floor
     end
   end
 end

data/lib/eqn/number.rb

@@ -1,16 +1,27 @@
 module Eqn
-  class Number < Treetop::Runtime::SyntaxNode
+  # Node class for a simple number.
+  class Number < EqnNode
     def value(vars = {})
       base = elements.shift.value(vars)
-      # Apply any exponent.
-      base *= elements.shift.value(vars) unless elements.empty?
-      base
+
+      return base if term?
+
+      if instance_of?(Float)
+        # Apply any decimal if a float.
+        base + elements.shift.value(vars)
+      else
+        # Apply any exponent if a simple number.
+        base * elements.shift.value(vars)
+      end
     end
 
-    class SignedNumber < Treetop::Runtime::SyntaxNode
+    class Float < Number; end
+
+    # Node class for a signed number.
+    class SignedNumber < EqnNode
       def value(vars = {})
         # Store sign if any.
-        sign_negative = elements.shift.negative? if elements.first.is_a? Terminal::Sign
+        sign_negative = elements.shift.negative? if elements.first.is_a?(Terminal::Sign)
 
         # Evaluate float.
         value = elements.shift.value(vars)
@@ -20,24 +31,15 @@ module Eqn
       end
     end
 
-    class Float < Treetop::Runtime::SyntaxNode
-      def value(vars = {})
-        base = elements.shift.value(vars)
-
-        # Add any decimal.
-        base += elements.shift.value(vars) unless elements.empty?
-
-        base
-      end
-    end
-
-    class Decimal < Treetop::Runtime::SyntaxNode
+    # Node class for the decimal part of a non-integer.
+    class Decimal < EqnNode
       def value(_vars = {})
         elements.shift.dec_value
       end
     end
 
-    class Exponent < Treetop::Runtime::SyntaxNode
+    # Node class for the exponent part of a number.
+    class Exponent < EqnNode
       def value(vars = {})
         10**elements.shift.value(vars)
       end

data/lib/eqn/parser.rb

@@ -1,25 +1,19 @@
 module Eqn
+  # Primary parser class to convert a string equation to a tree of nodes.
   class Parser
     class << self
-      def parse(data)
+      def parse(equation)
         parser = EqnParser.new
 
-        # Pass the data over to the parser instance.
-        tree = parser.parse(data)
+        # Pass the equation over to the parser instance.
+        root_node = parser.parse(equation)
 
         # Raise any errors.
-        raise ParseError, "Parse error at offset: #{parser.index} -- #{parser.failure_reason}" if tree.nil?
+        raise ParseError, "Parse error at offset: #{parser.index} -- #{parser.failure_reason}" if root_node.nil?
 
         # Remove extraneous nodes and return tree.
-        clean_tree(tree)
-      end
-
-      private
+        root_node.clean_tree!
 
-      def clean_tree(root_node)
-        return if root_node.elements.nil?
-        root_node.elements.delete_if { |node| node.class == Treetop::Runtime::SyntaxNode }
-        root_node.elements.each(&method(:clean_tree))
         root_node
       end
     end

data/lib/eqn/terminal.rb

@@ -1,15 +1,17 @@
 module Eqn
   module Terminal
-    class Variable < Treetop::Runtime::SyntaxNode
+    # Node class for a variable.
+    class Variable < EqnNode
       def value(vars = {})
-        val = vars[text_value.intern]
+        val = vars[text_value.to_sym]
         raise NoVariableValueError, "No value given for: #{text_value}" unless val
-        raise NonNumericVariableError, "Variable #{text_value} value is nonnumeric: #{val}" unless val.is_a? Numeric
+        raise NonNumericVariableError, "Variable #{text_value} value is nonnumeric: #{val}" unless val.is_a?(Numeric)
         val
       end
     end
 
-    class Digits < Treetop::Runtime::SyntaxNode
+    # Node class for a group of numbers.
+    class Digits < EqnNode
       def dec_value
         ".#{text_value}".to_f
       end
@@ -19,28 +21,31 @@ module Eqn
       end
     end
 
-    class Sign < Treetop::Runtime::SyntaxNode
+    # Node class for a number sign.
+    class Sign < EqnNode
       def negative?
         text_value == '-'
       end
     end
 
-    class Op < Treetop::Runtime::SyntaxNode
+    # Node class for an operator.
+    class Op < EqnNode
       def left_associative?
-        is_a? LeftAssociativeOp
+        is_a?(LeftAssociativeOp)
       end
 
       def value(_vars = {})
-        text_value == '^' ? :** : text_value.intern
+        text_value == '^' ? :** : text_value.to_sym
       end
 
       class LeftAssociativeOp < Op; end
       class RightAssociativeOp < Op; end
     end
 
-    class CompOp < Treetop::Runtime::SyntaxNode
+    # Node class for a comparation operator.
+    class CompOp < EqnNode
       def value(_vars = {})
-        text_value == '=' ? :== : text_value.intern
+        text_value == '=' ? :== : text_value.to_sym
       end
     end
   end

data/lib/eqn/version.rb

@@ -1,3 +1,3 @@
 module Eqn
-  VERSION = '1.6.2'.freeze
+  VERSION = '1.6.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eqn
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.6.3
 platform: ruby
 authors:
 - Zach Schneider
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-04 00:00:00.000000000 Z
+date: 2017-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -142,7 +142,7 @@ files:
 - lib/eqn.treetop
 - lib/eqn/calculator.rb
 - lib/eqn/comparation.rb
-- lib/eqn/engine.rb
+- lib/eqn/eqn_node.rb
 - lib/eqn/errors.rb
 - lib/eqn/expression.rb
 - lib/eqn/function.rb

data/lib/eqn/engine.rb

@@ -1,9 +0,0 @@
-module Eqn
-  if defined? Rails
-    class Engine < ::Rails::Engine
-      initializer 'eqn' do
-        config.autoload_paths += Dir["#{config.root}/lib/**/"]
-      end
-    end
-  end
-end