msfl 1.1.5 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 177a30d02e7d96f90d3a86fd31804f7dcfacae54
-  data.tar.gz: 5e6ddff54fcc8f8380e51967a81b6a8b48931ec8
+  metadata.gz: 9034a3e616954189429dc66d76be624f065b5f9b
+  data.tar.gz: 8ef828b22da3158dc126e3d8ae8a148bdf82f9b9
 SHA512:
-  metadata.gz: 69c76fe997453a7ad780a7ebeb6f91558777075b5f2085c6aa2c2b0a4282d10c91eec1e18fa7267c0c058ddb9eeb6f129b446352bacaf55565aa60ea4e46af76
-  data.tar.gz: 1329571a071f77f574acd92223f79d7fad3dfbf94a63a4d88eca1acc782a354a336ae20120f73a8dc68b92a54721aa4529d180e9e0ce51d63583e9fb9083d79a
+  metadata.gz: fe03bb90fc8cd612c5914217600a02dfb3a8fd4a5e08e6f701b5e80cdb704f8128e8335c245300d7a2ed6ad2d45b051ac804b496b7386f7350f3484aecf0975d
+  data.tar.gz: 920a0e38dbf3256d45695c60dced75252ddff4d8cf7babaa63825da13b72fb36c220dc13f08ccf364474b0478eb888c7854d01479b39c5e5562865b71ec24fc5

data/README.md

@@ -1,5 +1,83 @@
-[![Circle CI](https://circleci.com/gh/caldwecr/msfl.svg?style=svg)](https://circleci.com/gh/caldwecr/msfl)
+[![Circle CI](https://circleci.com/gh/Referly/msfl.svg?style=svg)](https://circleci.com/gh/Referly/msfl)
 
 # Ruby Gem for the Mattermark Semantic Filter Language
 
-Contains serializers and validators (and perhaps other) MSFL goodies
+Contains serializers and validators (and perhaps other) MSFL goodies
+
+## EBNF
+
+MSFL is a context-free language. The context-free grammar is defined below.
+
+I'm not actually sure this is correct, it is definitely not comprehensive as it skips over the shortcut functionality.
+
+```
+filter = range_op | binary_op | set_op
+set_op = and | or
+and = "{" "\"and\"" ":" list "}"
+or = "{" "\"or\"" ":" list "}"
+list = "[" filter? | (filter ("," filter)*) "]";
+range_op = between;
+between = "{" field ":" between_body | "{" "\"between\"" ":" between_body "}";
+between_body = "{" "\"start\"" ":" between_start "," "\"end\"" ":" between_end "}";
+between_start = integer | double | date | datetime | time;
+between_end = integer | double | date | datetime | time;
+binary_op = comparison | containment;
+comparison = "{" field ":" "{" comparison_op ":" atom "}" "}";
+field = "\"" ALPHANUMERIC+ "\"";
+comparison_op = "lt" | "gt" | "lte" | "gte" | "eq";
+containment = "{" field ":" "{" "\"in\"" ":" atom_list "}" "}";
+atom = string | integer | double | boolean | date | datetime | time;
+atom_list = "[" atom? | (atom ("," atom)*) "]";
+```
+
+## Configuration
+
+All configuration options should be set in a block passed to `MSFL.configure { |c| c.datasets = [] }`
+
+Naturally you should provide an appropriate array of the datasets you are supporting.
+
+As additional configuration settings are added they will be set similarly.
+
+## Converters
+
+The MSFL converters provide convenience methods for transforming a parsed MSFL tree to a different structure that is
+logically equivalent. The intent is to enable consumers of MSFL to easily manipulate parsed MSFL filters into the form
+that most easily or efficiently allows adaptation to the storage mechanism upon which the filtering is being effected.
+
+Note that the order in which converters are run is controlled by the constant MSFL::Converters::CONVERSIONS and cannot
+be manipulated through configuration. This behavior is currently necessary for ease of implementation but is unlikely
+to continue to be status quo.
+
+## Datasets
+
+The consumer of the MSFL gem defines one or more datasets. The dataset definition enumerates the supported fields and
+their types.
+
+## Parsers
+
+Currently there is only a parser for the JSON encoding of MSFL filters. Any additional parsers will also be placed
+under this directory.
+
+## Types
+
+Because of the behavioral limitations imposed on certain types (currently Sets are the only example) there is a folder
+for types to be defined.
+
+## Validators
+
+After parsing a MSFL filter it can be validated. Currently the validation is primitive. The intent is to enable
+semantic validation on a per dataset basis. This will allow per attribute validations to be setup by the consumer
+of this gem, which will be run automatically during validation.
+
+## Frameworks
+
+### Sinatra
+
+There are several helper methods for using this gem with Sinatra. You can register the helpers in your Sinatra app
+by adding the following inside of your application's class.
+
+```
+# This should actually be Sinatra::MSFL but there are some namespacing issues with MSFL currently that prevented
+# this from being the v0 implementation. This will change in the near future.
+register MSFL::Sinatra
+```

data/lib/msfl/converters/operator.rb

@@ -116,8 +116,9 @@ module MSFL
               if obj[first_key].is_a?(Hash)
                 result = implicit_and_to_explicit_recursively obj[first_key], first_key
               elsif obj[first_key].is_a? MSFL::Types::Set
-                # This situation occurs when there are nested logical operators
-                # obj is a hash, with one key that is not a binary operator which has a value that is a MSFL::Types::Set
+                # When an implicit and occurs under an MSFL::Types::Set when the key for the value which is the set
+                # is not a binary or logical operator. This doesn't happen in known current cases.
+                # ex. => { foo: [ { bar: { gte: 1, lte: 5 } } ] }
                 result = Hash.new
                 result[first_key] = recurse_through_set :implicit_and_to_explicit_recursively, obj[first_key]
               elsif obj[first_key].is_a? Array

data/msfl.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl'
-  s.version     = '1.1.5'
+  s.version     = '1.1.6'
   s.date        = '2015-04-01'
   s.summary     = "MSFL in Ruby"
   s.description = "Serializers, validators, and other tasty goodness for the Mattermark Semantic Filter Language in Ruby."

data/spec/msfl/converters/operator_spec.rb

@@ -140,6 +140,24 @@ describe "MSFL::Converters::Operator" do
 
     let(:expected) { raise ArgumentError, "You are expected to define the expected value" }
 
+    context "when the argument is an Array" do
+
+      let(:arg) { ["foo", "bar"] }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
+    context "when the argument is a Hash containing an Array" do
+
+      let(:arg) { { and: [ { foo: 1 }, { bar: 2 } ] } }
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
     context "when there is not an implicit BETWEEN" do
 
       ["foo", { foo: "bar" }, 123, 56.12, :aaaah].each do |arg|
@@ -255,9 +273,9 @@ describe "MSFL::Converters::Operator" do
     end
   end
 
-  describe "#implicit_and_to_explicit" do
+  describe "#implicit_and_to_explicit_recursively" do
 
-    subject(:mut) { test_instance.implicit_and_to_explicit_recursively arg }
+    subject { test_instance.implicit_and_to_explicit_recursively arg }
 
     let(:test_instance) { MSFL::Converters::Operator.new }
 
@@ -274,7 +292,7 @@ describe "MSFL::Converters::Operator" do
         let(:arg) { 50 }
 
         it "is the arg unchanged" do
-          expect(mut).to eq expected
+          expect(subject).to eq expected
         end
       end
 
@@ -283,7 +301,7 @@ describe "MSFL::Converters::Operator" do
         let(:arg) { { gte: 1000 }  }
 
         it "is the arg unchanged" do
-          expect(mut).to eq expected
+          expect(subject).to eq expected
         end
       end
 
@@ -292,7 +310,7 @@ describe "MSFL::Converters::Operator" do
         let(:arg) { { value: { gte: 1000 } } }
 
         it "is the arg unchanged" do
-          expect(mut).to eq expected
+          expect(subject).to eq expected
         end
       end
 
@@ -310,7 +328,7 @@ describe "MSFL::Converters::Operator" do
                                                    ])}}
 
       it "converts the implicit AND to an explicit AND" do
-        expect(mut).to eq expected
+        expect(subject).to eq expected
       end
     end
 
@@ -325,7 +343,7 @@ describe "MSFL::Converters::Operator" do
                                                    ])}}
 
       it "converts the implicit AND to an explicit AND" do
-        expect(mut).to eq expected
+        expect(subject).to eq expected
       end
     end
 
@@ -347,7 +365,7 @@ describe "MSFL::Converters::Operator" do
         end
 
         it "converts both of the implicit ANDs to explicit ANDs" do
-          expect(mut).to eq expected
+          expect(subject).to eq expected
         end
       end
     end
@@ -375,14 +393,65 @@ describe "MSFL::Converters::Operator" do
       end
 
       it "converts all of the implicit ANDs" do
-        expect(mut).to eq expected
+        expect(subject).to eq expected
+      end
+    end
+
+    context "when the implicit AND is under an MSFL::Types::Set" do
+
+      let(:arg) do
+        {
+            foo: MSFL::Types::Set.new([
+                                          { bar: { gte: 1, lte: 5 } }
+                                      ])
+        }
+      end
+
+      let(:expected) do
+        {
+            foo: MSFL::Types::Set.new([
+                                          { and: MSFL::Types::Set.new([
+                                                                          { bar: { gte: 1 } },
+                                                                          { bar: { lte: 5 } }
+                                                                      ])}
+                                      ])
+        }
+      end
+
+      it "converts the implicit AND" do
+        expect(subject).to eq expected
+      end
+    end
+
+    context "when the implict AND is inside of an Array" do
+
+      let(:arg) do
+        { and: [ { foo: 1 }, { bar: 2 } ] }
+      end
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
+    context "when the implict AND is inside of an Array that is inside of an MSFL::Types::Set" do
+
+      let(:arg) do
+        { foo: MSFL::Types::Set.new([
+                                        { bar: [{ score: { gte: 1, lte: 5 } }, "efg"] }
+                                    ])
+        }
+      end
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
       end
     end
   end
 
   describe "#between_to_gte_lte_recursively" do
 
-    subject(:mut) { test_instance.between_to_gte_lte_recursively arg }
+    subject { test_instance.between_to_gte_lte_recursively arg }
 
     let(:test_instance) { MSFL::Converters::Operator.new }
 
@@ -404,7 +473,7 @@ describe "MSFL::Converters::Operator" do
           let(:arg) { item }
 
           it "is equal to the argument" do
-            expect(mut).to eq arg
+            expect(subject).to eq arg
           end
         end
       end
@@ -417,7 +486,7 @@ describe "MSFL::Converters::Operator" do
       let(:expected) { { foo: { gte: "2015-01-01", lte: "2015-04-01" } } }
 
       it "converts between clauses into anded gte / lte clauses" do
-        expect(mut).to eq expected
+        expect(subject).to eq expected
       end
 
       context "when the between clause is below the second level" do
@@ -441,7 +510,7 @@ describe "MSFL::Converters::Operator" do
         end
 
         it "recursively converts between clauses into anded gte / lte clauses" do
-          expect(mut).to eq expected
+          expect(subject).to eq expected
         end
       end
     end
@@ -453,7 +522,7 @@ describe "MSFL::Converters::Operator" do
       let(:expected) { MSFL::Types::Set.new([ { foo: { gte: 1, lte: 5 } } ]) }
 
       it "recursively converts between clauses into anded gte / lte clauses" do
-        expect(mut).to eq expected
+        expect(subject).to eq expected
       end
 
       context "when the between clause is below the second level" do
@@ -463,7 +532,7 @@ describe "MSFL::Converters::Operator" do
         let(:expected) { MSFL::Types::Set.new([ { and: MSFL::Types::Set.new([{ foo: { gte: 1, lte: 5} }, { bar: 123} ]) }]) }
 
         it "recursively converts between clauses into anded gte / lte clauses" do
-          expect(mut).to eq expected
+          expect(subject).to eq expected
         end
       end
     end
@@ -473,7 +542,7 @@ describe "MSFL::Converters::Operator" do
       let(:arg) { [ { foo: { between: { start: 1, end: 5 } } } ] }
 
       it "raises an ArgumentError" do
-        expect { mut }.to raise_error ArgumentError
+        expect { subject }.to raise_error ArgumentError
       end
     end
 
@@ -500,7 +569,7 @@ describe "MSFL::Converters::Operator" do
       end
 
       it "recursively converts between clauses into anded gte / lte clauses" do
-        expect(mut).to eq expected
+        expect(subject).to eq expected
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.1.6
 platform: ruby
 authors:
 - Courtland Caldwell