json_logic 0.1 → 0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d703a82274651845fd543ed444107612bbc93cf5
-  data.tar.gz: 434db11c0888e5680d00a2b90fb5171a2ad10927
+  metadata.gz: 00b8f19def918cb66b14892b45d3dff9c4c84045
+  data.tar.gz: f8fd51f4eb17fe1c1b6dec4dda24857c63b319a3
 SHA512:
-  metadata.gz: 51b5633809a496a26546fe5407b4fa919e591dd66ee153ffcfe9989ff39e2732f4eb0c508c497575203a4a7e2f1809cb672cde0943e91713d2f3e5aab21ddfa4
-  data.tar.gz: be43a7e24f84fb74226d401ccd33bd27a4fee29e6414906d11ab286801da5d2dec5c3ad333e3a281185d8a5ae19d5c0084c56b161ebd2e581abdcfb828a275cf
+  metadata.gz: 2e07d04d720757f412526c6b76611c6cbf9d68cd63406b8e26aff0f17159eefe7b957b9e86fd737d7962ee9b3e69b1ff522640096c17d9ded8b033462ff6a04a
+  data.tar.gz: fca9ad53de483794014db293c762eca8b246ba812a930fb2d2295e69b419ddf4959f5d4be3552f6e2af08775c8c3ecd6e58079f90a25d6a7f85189302dd96b64

data/README.md

@@ -1,5 +1,102 @@
-# json-logic-ruby [![Build Status](https://travis-ci.org/kennethgeerts/json-logic-ruby.svg?branch=master)](https://travis-ci.org/kennethgeerts/json-logic-ruby)
+# json-logic-ruby [![Build Status](https://travis-ci.org/bhgames/json-logic-ruby.svg?branch=master)](https://travis-ci.org/bhgames/json-logic-ruby)
 
 Build complex rules, serialize them as JSON, and execute them in ruby.
 
-**json-logic-ruby** is a ruby parser for [JsonLogic](http://jsonlogic.com).
+**json-logic-ruby** is a ruby parser for [JsonLogic](http://jsonlogic.com). Other libraries are available for parsing this logic for Python and JavaScript at that link!
+
+## Why use JsonLogic?
+
+If you're looking for a way to share logic between front-end and back-end code, and even store it in a database, JsonLogic might be a fit for you.
+
+JsonLogic isn't a full programming language. It's a small, safe way to delegate one decision. You could store a rule in a database to decide later. You could send that rule from back-end to front-end so the decision is made immediately from user input. Because the rule is data, you can even build it dynamically from user actions or GUI input.
+
+JsonLogic has no setters, no loops, no functions or gotos. One rule leads to one decision, with no side effects and deterministic computation time.
+
+## Virtues
+1. Terse.
+2. Consistent. {"operator" : ["values" ... ]} Always.
+3. Secure. We never eval(). Rules only have read access to data you provide, and no write access to anything.
+4. Flexible. Easy to add new operators, easy to build complex structures.
+
+## Examples
+
+### simple
+
+```ruby
+JSONLogic.apply({ "==" => [1, 1] }, {})
+# => true
+```
+
+This is a simple rule, equivalent to 1 == 1. A few things about the format:
+
+1. The operator is always in the 「key」 position. There is only one key per JsonLogic rule.
+2. The values are typically an array.
+3. Each value can be a string, number, boolean, array (non-associative), or null
+
+### Compound
+
+Here we're beginning to nest rules.
+
+```ruby
+JSONLogic.apply(
+{ "and" => [
+  { ">" => [3,1] },
+  { "<" => [1,3] }]
+}, {})
+
+# => true
+```
+
+In an infix language (like JavaScript) this could be written as:
+
+```
+( (3 > 1) && (1 < 3) )
+```
+
+### Data-Driven
+
+Obviously these rules aren't very interesting if they can only take static literal data. Typically jsonLogic will be called with a rule object and a data object. You can use the var operator to get attributes of the data object:
+
+```ruby
+ JSONLogic.apply(
+  { "var" => ["a"] }, # Rule
+  { "a" => 1, "b" => 2 }  # Data
+ )
+ # => 1
+```
+
+If you like, we support syntactic sugar on unary operators to skip the array around values:
+
+
+```ruby
+JSONLogic.apply(
+  { "var" => "a" },
+  { "a" => 1, "b" => 2 }
+ )
+# => 1
+```
+
+You can also use the `var` operator to access an array by numeric index:
+
+```ruby
+JSONLogic.apply(
+  { "var" => 1 },
+  ["apple", "banana", "carrot"]
+)
+# => "banana"
+```
+
+Here's a complex rule that mixes literals and data. The pie isn't ready to eat unless it's cooler than 110 degrees, and filled with apples.
+
+```ruby
+rules = JSON.parse(%Q|{ "and" : [
+  {"<" : [ { "var" : "temp" }, 110 ]},
+  {"==" : [ { "var" : "pie.filling" }, "apple" ] }
+] }|)
+
+data = JSON.parse(%Q|{ "temp" : 100, "pie" : { "filling" : "apple" } }|)
+
+JSONLogic.apply(rules, data)
+
+# => true
+```

data/json_logic.gemspec

@@ -6,8 +6,8 @@ require 'json_logic/version'
 Gem::Specification.new do |spec|
   spec.name          = 'json_logic'
   spec.version       = JSONLogic::VERSION
-  spec.authors       = ['Kenneth Geerts']
-  spec.email         = ['Kenneth.Geerts@gmail.com']
+  spec.authors       = ['Kenneth Geerts', "Jordan Prince"]
+  spec.email         = ['Kenneth.Geerts@gmail.com', "jordanmprince@gmail.com"]
   spec.homepage      = 'http://jsonlogic.com'
   spec.summary       = 'Build complex rules, serialize them as JSON, and execute them in ruby'
   spec.description   = 'Build complex rules, serialize them as JSON, and execute them in ruby. See http://jsonlogic.com'

data/lib/core_ext/stringify_keys.rb

@@ -0,0 +1,21 @@
+class Hash
+  # Stolen from ActiveSupport
+  def transform_keys
+    return enum_for(:transform_keys) { size } unless block_given?
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys(&:to_s)
+  end
+end

data/lib/json_logic.rb

@@ -1,20 +1,25 @@
 require 'core_ext/deep_fetch'
+require 'core_ext/stringify_keys'
 require 'json_logic/truthy'
 require 'json_logic/operation'
-
 module JSONLogic
   def self.apply(logic, data)
-    return logic unless logic.is_a?(Hash)                # pass-thru
-    operator, values = logic.first                       # unwrap single-key hash
-    values = [values] unless values.is_a?(Array)         # syntactic sugar
-    new_vals = values.map { |value| apply(value, data) } # recursion step
-    new_vals.flatten!(1) if new_vals.size == 1           # [['A']] => ['A']
-    Operation.perform(operator, new_vals, data || {})    # perform operation
+    return logic unless logic.is_a?(Hash)                  # pass-thru
+    data = data.stringify_keys if data.is_a?(Hash)         # Stringify keys to keep out problems with symbol/string mismatch
+    operator, values = logic.first                         # unwrap single-key hash
+    values = [values] unless values.is_a?(Array)           # syntactic sugar
+    Operation.perform(operator, values, data || {})
   end
 
   def self.filter(logic, data)
     data.select { |d| apply(logic, d) }
   end
+
+  def self.add_operation(operator, function)
+    Operation.class.send(:define_method, operator) do |v, d|
+      function.call(v, d)
+    end
+  end
 end
 
 require 'json_logic/version'

data/lib/json_logic/operation.rb

@@ -1,12 +1,66 @@
 module JSONLogic
   class Operation
     LAMBDAS = {
-      'var' => ->(v, d) { d.deep_fetch(*v) },
+      'var' => ->(v, d) do
+        return d unless d.is_a?(Hash) or d.is_a?(Array)
+        return v == [""] ? (d.is_a?(Array) ? d : d[""]) : d.deep_fetch(*v)
+      end,
       'missing' => ->(v, d) { v.select { |val| d.deep_fetch(val).nil? } },
       'missing_some' => ->(v, d) {
         present = v[1] & d.keys
         present.size >= v[0] ? [] : LAMBDAS['missing'].call(v[1], d)
       },
+      'some' => -> (v,d) do
+        v[0].any? do |val|
+          interpolated_block(v[1], val).truthy?
+        end
+      end,
+      'filter' => -> (v,d) do
+        v[0].select do |val|
+          interpolated_block(v[1], val).truthy?
+        end
+      end,
+      'substr' => -> (v,d) do
+        limit = -1
+        if v[2]
+          if v[2] < 0
+            limit = v[2] - 1
+          else
+            limit = v[1] + v[2] - 1
+          end
+        end
+
+         v[0][v[1]..limit]
+      end,
+      'none' => -> (v,d) do
+
+        v[0].each do |val|
+          this_val_satisfies_condition = interpolated_block(v[1], val)
+          if this_val_satisfies_condition
+            return false
+          end
+        end
+
+        return true
+      end,
+      'all' => -> (v,d) do
+        # Difference between Ruby and JSONLogic spec ruby all? with empty array is true
+        return false if v[0].empty?
+
+        v[0].all? do |val|
+          interpolated_block(v[1], val)
+        end
+      end,
+      'reduce' => -> (v,d) do
+        return v[2] unless v[0].is_a?(Array)
+        v[0].inject(v[2]) { |acc, val| interpolated_block(v[1], { "current": val, "accumulator": acc })}
+      end,
+      'map' => -> (v,d) do
+        return [] unless v[0].is_a?(Array)
+        v[0].map do |val|
+          interpolated_block(v[1], val)
+        end
+      end,
       'if' => ->(v, d) {
         v.each_slice(2) do |condition, value|
           return condition if value.nil?
@@ -42,8 +96,41 @@ module JSONLogic
       'log'   => ->(v, d) { puts v }
     }
 
+    def self.interpolated_block(block, data)
+      # Make sure the empty var is there to be used in iterator
+      JSONLogic.apply(block, data.is_a?(Hash) ? data.merge({"": data}) : { "": data })
+    end
+
     def self.perform(operator, values, data)
-      LAMBDAS[operator].call(values, data)
+      # If iterable, we can only pre-fill the first element, the second one must be evaluated per element.
+      # If not, we can prefill all.
+
+      if is_iterable?(operator)
+        interpolated = [JSONLogic.apply(values[0], data), *values[1..-1]]
+      else
+        interpolated = values.map { |val| JSONLogic.apply(val, data) }
+      end
+
+      interpolated.flatten!(1) if interpolated.size == 1           # [['A']] => ['A']
+
+      return LAMBDAS[operator.to_s].call(interpolated, data) if is_standard?(operator)
+      send(operator, interpolated, data)
+    end
+
+    def self.is_standard?(operator)
+      LAMBDAS.keys.include?(operator)
+    end
+
+    # Determine if values associated with operator need to be re-interpreted for each iteration(ie some kind of iterator)
+    # or if values can just be evaluated before passing in.
+    def self.is_iterable?(operator)
+      ['filter', 'some', 'all', 'none', 'in', 'map', 'reduce'].any? { |o| o == operator }
+    end
+
+    def self.add_operation(operator, function)
+      self.class.send(:define_method, operator) do |v, d|
+        function.call(v, d)
+      end
     end
   end
 end

data/lib/json_logic/version.rb

@@ -1,3 +1,3 @@
 module JSONLogic
-  VERSION = '0.1'
+  VERSION = '0.3'
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: json_logic
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.3'
 platform: ruby
 authors:
 - Kenneth Geerts
+- Jordan Prince
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-08 00:00:00.000000000 Z
+date: 2017-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,6 +57,7 @@ description: Build complex rules, serialize them as JSON, and execute them in ru
   See http://jsonlogic.com
 email:
 - Kenneth.Geerts@gmail.com
+- jordanmprince@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -71,6 +73,7 @@ files:
 - bin/setup
 - json_logic.gemspec
 - lib/core_ext/deep_fetch.rb
+- lib/core_ext/stringify_keys.rb
 - lib/json_logic.rb
 - lib/json_logic/operation.rb
 - lib/json_logic/truthy.rb
@@ -95,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.7
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Build complex rules, serialize them as JSON, and execute them in ruby