equation 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f4f1469e22a3d098dfcb0c2ca974a2d081c0c7be90afddb20fea36f65bdc0804
+  data.tar.gz: 5925da1a74a22bfe8e1cc1b7f4dd43a61cf02b05a61ca2a15821f184ff45e5a7
+SHA512:
+  metadata.gz: 5ef71408034ed55d48efadd5b99c6e3c41ae49680b673f658b5fa0689731834a0260e4810c3a189f670b97c6451845b3c082ef9ad82ff65c813de5b13a6dee27
+  data.tar.gz: 595552e82f8f4412b0a379025883669b0f05e1199948de2ed1221c14092a17cd2b296f396ad2e3e0091e1095307b392904866457222d21895c0c7b66978dda87

data/README.md

@@ -0,0 +1,31 @@
+# Equation [WIP]
+
+A rules engine for your Ruby app! Use a constrained and relatively safe language to express logic for your Ruby app, without having to write Ruby. This allows you to use text (e.g. in a configuration file or database) to store logic in a way that can be updated independently from your code faster than it takes for a deploy without opening extra security vulnerabilities. 
+
+Use cases include:
+
+* writing rules to describe HTTP traffic that then gets dropped, like a WAF
+* writing policies to express authorization logic
+* etc
+
+Modeled loosely after [Symfony Expression Language](https://symfony.com/doc/current/components/expression_language.html).
+
+## Example
+
+In this example, we'll use a rule to determine whether a request should be dropped or not. While the rule here is hardcoded into the program, it could just as easily be pulled from a database, some redis cache, etc instead. Rules can also be cached, saving you an extra parsing step.
+
+```ruby
+require 'equation'
+
+# set up the execution environment and give it access to the rails request object
+engine = EquationEngine.new(default: {
+  age: 12,
+  username: "OMAR",
+  request: request
+})
+
+suspicious_request = engine.eval(rule: '$request.path == "/api/login" && $request.remote_ip == "1.2.3.4" && $username == "OMAR"')
+if suspicious_request
+  # log some things, notify some people
+end
+```

data/lib/equation.rb

@@ -0,0 +1,68 @@
+require 'treetop'
+require_relative 'equation_node_classes'
+require_relative 'equation_grammar'
+
+class Context
+  def initialize(default: {}, methods: {})
+    @symbol_table = default
+    @methods = methods
+  end
+
+  def set(identifier:, value:)
+    @symbol_table[identifier.to_sym] = value
+  end
+
+  def get(identifier:, path: {})
+    assert_defined!(identifier: identifier)
+    @symbol_table[identifier.to_sym]
+    root = @symbol_table[identifier.to_sym]
+    child = root
+    path.each{|segment|
+      segment_name = segment.elements[1].text_value.to_sym
+      if child.respond_to?(segment_name)
+        child = child.send(segment_name)
+      elsif child.include?(segment_name)
+        child = child[segment_name]
+      else
+        raise "no"
+      end
+    }
+
+    child
+  end
+
+  def call(method:, args:)
+    assert_method_exists!(method: method)
+    @methods[method.to_sym].call(*args)
+  end
+
+  private
+  def assert_defined!(identifier:)
+    raise "Undefined variable: #{identifier}" unless @symbol_table.has_key?(identifier.to_sym)
+  end
+
+  def assert_method_exists!(method:)
+    raise "Undefined method: #{method}" unless @methods.has_key?(method.to_sym)
+  end
+end
+
+class EquationEngine
+  def initialize(default: {}, methods: {})
+    @parser = EquationParser.new
+    @context = Context.new(default: default, methods: methods)
+  end
+
+  def parse(rule:)
+    parsed_rule = @parser.parse(rule)
+    raise "Parse Error: #{@parser.failure_reason}" unless parsed_rule
+
+    parsed_rule
+  end
+
+  def eval(rule:)
+    parsed_rule = @parser.parse(rule)
+    raise "Parse Error: #{rule}" unless parsed_rule
+
+    parsed_rule.value(ctx: @context)
+  end
+end