msfl 0.0.1.pre.qa → 0.0.1.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5192c432f2b0fa92fdc52f791a6d1db94e0e7273
-  data.tar.gz: 369cf6c5d51a3b2f996b070a70894a6fd952b7f4
+  metadata.gz: 1433fb3fe0766b9a5a4913a5c8236bffb00e9c5e
+  data.tar.gz: 9307024455e4e75530f334e4c91d2a09f7da7090
 SHA512:
-  metadata.gz: dadc0e105e90e00c982424d332a2cada2733a676cf9c26f0d65ab3c5a79e4ffe94c78b87903c493aa070ae0c80f813eb1bf6313cd81531593911fde0f0c3b1bf
-  data.tar.gz: 86c9aac383c3a267e9344ca3f081b4b1e9fd8c461ca5e86a5962e3811476dad04ac918c521cc9dc0011811e5029caca9ec14858bd9b83ad313a8c0a1c45d6561
+  metadata.gz: 1a7ac56dec38d01c8dcec0521e27cb03f361d952d8309d72bfa6494e9b5b49c8e34a89d1f2e98c66742a885110519ecd41ea24d3aa05b2508b1eeb20155244e3
+  data.tar.gz: 8a8150eb7c2ded7f183e7f124167a2dd3de92477cdc52731ee6868599625b344308c80bb5707230e51847ba11ad6a0635129a69a77887b112d570ffc3c2df6b5

data/.gitignore

@@ -0,0 +1,20 @@
+### Ruby template
+*.gem
+*.rbc
+/coverage/
+/spec/reports/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+.idea/
+
+## Gemfile for development
+#Gemfile
+#Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gem 'simplecov', :require => false, :group => :test           # MIT https://github.com/colszowka/simplecov/blob/master/MIT-LICENSE
+gem 'yard'                                                    # MIT https://github.com/lsegal/yard/blob/master/LICENSE + Ruby license for one file from the Ruby source lib/parser/ruby/legacy/ruby_lex.rb
+gem 'rspec'                                                   # MIT https://github.com/rspec/rspec/blob/master/License.txt
+gem 'byebug'

data/Gemfile.lock

@@ -0,0 +1,40 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (3.5.1)
+      columnize (~> 0.8)
+      debugger-linecache (~> 1.2)
+      slop (~> 3.6)
+    columnize (0.8.9)
+    debugger-linecache (1.2.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    multi_json (1.10.1)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.6.0)
+    yard (0.8.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  rspec
+  simplecov
+  yard

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Mattermark, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,5 @@
+[![Circle CI](https://circleci.com/gh/caldwecr/msfl.svg?style=svg)](https://circleci.com/gh/caldwecr/msfl)
+
+# Ruby Gem for the Mattermark Semantic Filter Language
+
+Contains serializers and validators (and perhaps other) MSFL goodies

data/Rakefile

@@ -0,0 +1,10 @@
+require "rake"
+require 'rspec/core/rake_task'
+
+task default: [:spec] do
+  ENV['RACK_ENV'] = 'test'
+end
+
+task :spec do
+  RSpec::Core::RakeTask.new(:spec)
+end

data/circle.yml

@@ -0,0 +1,9 @@
+machine:
+
+  timezone:
+    America/Los_Angeles # Set the timezone
+
+  # Version of ruby to use
+  ruby:
+    version:
+      2.1.3

data/lib/msfl/datasets/base.rb

@@ -6,7 +6,9 @@ module MSFL
 
       # The descendant class MUST override this method otherwise all field validations will fail
       #
-      # @return [Array] the fields in the dataset
+      # The method defines an array of symbols, indicating what fields are supported for the Dataset
+      #
+      # @return [Array<Symbol>] the fields in the dataset
       def fields
         raise NoMethodError, "Descendants of MSFL::Datasets::Base are required to implement the #fields method"
       end
@@ -14,11 +16,14 @@ module MSFL
       # The descendant class may override this method to control the operators that are supported for the dataset
       #  - Note that this can only be used to reduce the number of supported operators (you can't add new operators
       #    here, without first adding them to MSFL::Validators::Definitions::HashKey#hash_key_operators)
+      #
+      # @return [Array<Symbol>] the operators supported in the dataset
       def operators
         hash_key_operators
       end
 
-      # Method not implemented at this time
+      # This method returns the errors argument. The errors argument is unchanged if type conformity validation passes,
+      # otherwise an error is added to errors.
       #
       # @param obj [Object] the object that should be type checked based on the field argument
       # @param field [Symbol] which field should the object be checked for conformity
@@ -30,11 +35,14 @@ module MSFL
       #    # because the type of total_funding must be an integer
       #
       def validate_type_conforms(obj, field, errors)
+        errors << "Dataset type conformity validation failed for obj: #{obj} against field: #{field}" unless type_conforms?(obj, field)
         errors
       end
 
       # Method not implemented at this time
       # Returns true if the object conforms to the types supported by the indicated field
+      # While not currently implemented the intent is that the descendant Dataset would specify a hash of supported
+      # types for each field and this method would then cross reference that list.
       #
       # @param obj [Object] the object that should be type checked based on the field argument
       # @param field [Symbol] which field should the object be checked for conformity
@@ -42,19 +50,33 @@ module MSFL
         true
       end
 
-      # Method not implemented at this time
-      #
+      # This method returns the errors argument. The errors argument is unchanged if operator conformity validation
+      # passes, otherwise an error is added to errors.
       #
       # @param operator [Symbol] the operator that we want to know if the particular field supports it
       # @param field [Symbol] which field should the operator be checked for conformity
       # @param errors [Array] an array of validation errors - empty indicates that no errors have been encountered
       # @return [Array] errors merged with any validation errors encountered in validating the set
       def validate_operator_conforms(operator, field, errors)
+        errors << "Dataset operator conformity validation failed for operator: #{operator} against field: #{field}" unless operator_conforms?(operator, field)
         errors
       end
 
       # Method not implemented at this time
       #
+      # This method returns true if the operator is supported for the specified field by the dataset. While this
+      # is not currently implemented, the intent is that a hash of fields (as keys) would map to
+      # Arrays<Symbol> (as values) and then this method would validate that the operator argument meets this contract.
+      #
+      # @param operator [Symbol] the operator that needs to be checked for conformity
+      # @param field [Symbol] which field should the operator be checked against
+      # @return [Bool] true if the operator conforms, false otherwise
+      def operator_conforms?(operator, field)
+        true
+      end
+
+      # This method returns the errors argument. The errors argument is unchanged if value conformity validation
+      # passes, otherwise an error is added to errors.
       #
       # @param value [Object] the precoerced value (the value must be correctly typed)
       #     that should be checked for validity based on the field, if the value does not conform an
@@ -72,8 +94,28 @@ module MSFL
       #  foo.investors_value_conforms(12345, :total_funding) => # errors is unchanged
       #
       def validate_value_conforms(value, field, errors)
+        errors << "Dataset value conformity validation failed for value: #{value} against field: #{field}" unless value_conforms?(value, field, errors)
         errors
       end
+
+      # Method not implemented at this time
+      #
+      # This method returns true if the value is supported for the specified field by the dataset. While this is not
+      # currently implemented, the intent is that a hash of fields (as keys) would map to an Array of validation
+      # constraints. These constraints would then be executed against the value and if all are successful the value
+      # would be considered to have passed.
+      #
+      # It is likely that the methods invoked from the Array of validation constraints would actually return an Array
+      # of errors encountered, this method would then concat that Array into the errors array. If the encountered errors
+      # array is empty the method would return true, and false otherwise.
+      #
+      # @param value [Object] the object to on which to perform validation
+      # @param field [Symbol] the field the object should be validated against
+      # @param errors [Array] the array of errors from prior validations
+      # @return [Bool] true if no new errors are encountered, false otherwise
+      def value_conforms?(value, field, errors = [])
+        true
+      end
     end
   end
 end

data/lib/msfl/parsers/json.rb

@@ -2,12 +2,21 @@ require 'json'
 module MSFL
   module Parsers
     class JSON
+
+      # Parses json encoded MSFL into Ruby encoded MSFL
+      #
+      # @param json [String] the string to parse
+      # @return [Object] the Ruby encoded MSFL, which may be a Hash, MSFL::Types::Set, or any number of scalar types
       def self.parse(json)
         obj = ::JSON.parse(json)
         obj = arrays_to_sets obj
         obj
       end
 
+      # Converts Ruby Arrays is a partially parsed Ruby MSFL filter to MSFL::Types::Set objects
+      #
+      # @param obj [Object] the object in which to convert Ruby Array objects to MSFL::Types::Set objects
+      # @return [Object] the result of converting Ruby Arrays to MSFL::Types::Set objects
       def self.arrays_to_sets(obj)
         obj = Types::Set.new obj if obj.is_a?(::Array)
         if obj.respond_to? :each

data/lib/msfl/validators/semantic.rb

@@ -11,8 +11,18 @@ module MSFL
       BOOLEAN_OPERATORS = [:and, :or]
       ENUMERATION_OPERATORS = [:in]
 
-      def initialize(attributes = nil, opts = {})
-        @dataset = MSFL.configuration.datasets.first.new unless MSFL.configuration.datasets.empty?
+      # Used for creating new semantic validator instances
+      #
+      # If the dataset argument is specified it will be used as the dataset for the validator. Otherwise
+      # the instance's dataset will default to the first value in MSFL.configuration.datasets, unless it is empty,
+      # in which case it will revert to MSFL::Datasets::Base, which will deliberately break execution when #validate
+      # is called on the validator instance, raising a NoMethodError.
+      #
+      # @param dataset [MSFL::Dataset::Base] optionally override the dataset instance that should be used by the validator
+      # @param opts [Hash] optional; currently not used, included for future additions
+      def initialize(dataset = nil, opts = {})
+        @dataset = dataset unless dataset.nil?
+        @dataset ||= MSFL.configuration.datasets.first.new unless MSFL.configuration.datasets.empty?
         @dataset ||= Datasets::Base.new
         @current_field = nil
         @current_operator = nil

data/msfl.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name        = 'msfl'
+  s.version     = '0.0.1-rc1'
+  s.date        = '2015-03-05'
+  s.summary     = "MSFL in Ruby"
+  s.description = "Serializers, validators, and other tasty goodness for the Mattermark Semantic Filter Language in Ruby."
+  s.authors     = ["Courtland Caldwell"]
+  s.email       = 'courtland@mattermark.com'
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.homepage    =
+      'https://github.com/caldwecr/msfl'
+  s.add_runtime_dependency "json", "~> 1.7"
+  s.add_development_dependency "rake", "~> 10.3"
+  s.add_development_dependency "simplecov", "~> 0.9"
+  s.add_development_dependency "yard", "~> 0.8"
+  s.add_development_dependency "rspec", "~> 3.1"
+  s.add_development_dependency "byebug", "~> 3.5"
+  s.license     = "MIT"
+end

data/simplecov_custom_profiles.rb

@@ -0,0 +1,5 @@
+require 'simplecov'
+SimpleCov.profiles.define 'msfl' do
+  add_filter '/spec'
+  add_filter '/test'
+end

data/spec/msfl/datasets/base_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe "MSFL::Datasets::Base" do
+
+  let(:test_instance) { MSFL::Datasets::Movies.new }
+
+  let(:errors) { [ ] }
+
+  let(:field) { :title }
+
+  describe "#fields" do
+
+    it "raises a NoMethodError" do
+      expect { MSFL::Datasets::Base.new.fields }.to raise_error NoMethodError
+    end
+  end
+
+  describe "#validate_type_conforms" do
+
+    subject(:mut) { test_instance.validate_type_conforms obj, field, errors }
+
+    let(:obj) { "i am a string" }
+
+    it "is currently a stubbed method that just returns the errors argument" do
+      expect(mut).to eq errors
+    end
+  end
+
+  describe "#type_conforms?" do
+
+    context "when MSFL is configured to use Movies as the dataset" do
+
+      subject(:mut) { test_instance.type_conforms? obj, field }
+
+      let(:obj) { "i am a string" }
+
+      it "is true for types that conform to the Dataset" do
+        expect(mut).to eq true
+      end
+
+      it "is false for types that do not conform to the Dataset" do
+        pending "Dataset specific semantic validation is not yet implemented."
+        expect(mut).to eq false
+      end
+    end
+  end
+
+  describe "#validate_operator_conforms" do
+
+    subject(:mut) { test_instance.validate_operator_conforms operator, field, errors }
+
+    let(:operator) { :and }
+
+    it "is currently a stubbed method that just returns the errors argument" do
+      expect(mut).to eq errors
+    end
+  end
+
+  describe "#validate_value_conforms" do
+
+    subject(:mut) { test_instance.validate_value_conforms value, field, errors }
+
+    let(:value) { 1234 }
+
+    it "is currently a stubbed method that just returns the errors argument" do
+      expect(mut).to eq errors
+    end
+  end
+end

data/spec/msfl/parsers/json_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+
+# Still need to deal with duplicates in array scenarios - is there a nested array variation with a non-obvious deduplication consequence?
+describe "MSFL::Parsers::JSON" do
+  describe ".parse" do
+
+    subject(:mut) { MSFL::Parsers::JSON.parse test_json }
+
+    let(:test_json) { '{"total_funding": 5000000}' }
+
+    context "when parsing a json hash" do
+
+      it "is an equivalent Ruby Hash" do
+        expect(mut).to eq({ :total_funding => 5000000 })
+      end
+    end
+
+    context "when parsing a json array" do
+
+      let(:test_json) { '["abc", "def"]' }
+
+      it { is_expected.to be_a MSFL::Types::Set }
+    end
+
+  end
+
+  describe ".arrays_to_sets" do
+
+    subject(:mut) { MSFL::Parsers::JSON.arrays_to_sets arg }
+
+    let(:arg) { Object.new }
+
+    [55, "five", :fourty, nil].each do |item|
+      context "when the argument is a #{item.class}" do
+
+        let(:arg) { item }
+
+        it "is equal to the argument" do
+          expect(mut).to eq arg
+        end
+      end
+    end
+
+    context "when the argument is a Hash" do
+
+      context "when the hash's values are scalars" do
+
+        let(:arg) { { foo: "bar", cat: 1337 } }
+
+        it "is equal to the argument" do
+          expect(mut).to eq arg
+        end
+      end
+
+      context "when the hash's values include at least one Hash" do
+
+        let(:arg) do
+          { foo: { bar: "bar" }, abc: 123 }
+        end
+
+        it "is equal to the argument" do
+          expect(mut).to eq arg
+        end
+      end
+
+      context "when the hash's values include at least one Array" do
+
+        let(:arg) do
+          { inner_array: array_in_arg, abc: 123 }
+        end
+
+        let(:expected) do
+          { inner_array: MSFL::Types::Set.new(array_in_arg), abc: 123 }
+        end
+
+        let(:array_in_arg) { ["bar", "baz"] }
+
+        it "is the argument with the Array converted to a MSFL::Types::Set" do
+          expect(mut).to eq expected
+        end
+
+        context "when at least one included Array has a duplicate item" do
+
+          let(:array_in_arg) { ["cat", "cat", 44, 55, "dog", 44, :marco, :polo, nil, :polo, "cat", nil] }
+
+          it "includes the duplicate item(s) exactly once" do
+            expect(mut[:inner_array]).to eq MSFL::Types::Set.new(["cat", 44, 55, "dog", :marco, :polo, nil])
+          end
+        end
+      end
+    end
+
+    context "when the argument is an Array" do
+
+      let(:arg) { [:foo, "bar", nil, 99, "bar"] }
+
+      it { is_expected.to be_a MSFL::Types::Set }
+
+      it "is unordered" do
+        expect(mut).to eq MSFL::Types::Set.new(arg.shuffle)
+      end
+
+      it "is deduplicated" do
+        expect(mut).to eq MSFL::Types::Set.new([:foo, "bar", nil, 99])
+      end
+
+      context "when the array's values are scalars" do
+
+        let(:arg) { ["bar", 1337] }
+
+        it "is equal to MSFL::Types::Set.new(argument)" do
+          expect(mut).to eq(MSFL::Types::Set.new arg)
+        end
+      end
+
+      context "when the argument includes at least one Hash" do
+
+        let(:arg) { ["bar", hash_in_arg, 84] }
+
+        let(:hash_in_arg) { { cat: 1221, dog: "fur" } }
+
+        it "includes the hash from the argument" do
+          expect(mut).to include hash_in_arg
+        end
+      end
+
+      context "when the argument includes at least one Array" do
+
+        let(:arg) { ["bar", array_in_arg, 84] }
+
+        let(:array_in_arg) { [444.3, "where'swaldo"] }
+
+        let(:expected_result) { MSFL::Types::Set.new ["bar", MSFL::Types::Set.new(array_in_arg), 84] }
+
+        it "replaces the outer Array with an equivalent MSFL::Types::Set" do
+          expect(mut).to eq expected_result
+        end
+
+        it "replaces the inner Array with an equivalent MSFL::Types::Set" do
+          expect(mut).to include MSFL::Types::Set.new(array_in_arg)
+        end
+      end
+    end
+  end
+end

data/spec/msfl/validators/semantic_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe "MSFL::Validators::Semantic" do
+
+  describe "#initialize" do
+
+    subject(:mut) { MSFL::Validators::Semantic.new dataset }
+
+    let(:dataset) { nil }
+
+    context "when the dataset argument is specified" do
+
+      let(:dataset) { Object.new }
+
+      it "has the dataset argument's value as the dataset" do
+        expect(mut.dataset).to be dataset
+      end
+    end
+
+    context "when the dataset argument is not specified" do
+
+      context "when MSFL is configured for one or more datasets" do
+
+        before { MSFL.configure(reset: true) { |configuration| configuration.datasets = [MSFL::Datasets::Movies] } }
+
+        it "has an instance of the first item in MSFL.configuration.datasets (an instance of Class) as the dataset" do
+          expect(mut.dataset).to be_a MSFL::Datasets::Movies
+        end
+      end
+
+      context "when MSFL is not configured for any datasets" do
+
+        before { MSFL.configure(reset: true) }
+
+        it "has an instance of MSFL::Datasets::Base as the dataset" do
+          expect(mut.dataset).to be_a MSFL::Datasets::Base
+        end
+      end
+    end
+
+  end
+
+  describe "#validate_set" do
+
+    subject(:mut) { test_instance.validate_set set, errors, options }
+
+    let(:test_instance) { MSFL::Validators::Semantic.new }
+
+    let(:set) { MSFL::Types::Set.new([ ]) }
+
+    let(:errors) { [ ] }
+
+    let(:options) { { } }
+
+    context "when the errors argument has items" do
+
+      let(:errors) { [error_message] }
+
+      let(:error_message) { "This is an error message" }
+
+      it "is an array containing at least all of the error messages from the original errors argument" do
+        expect(mut).to include error_message
+      end
+    end
+
+    context "when opts does not have the key :parent_operator" do
+
+      let(:error_message) do
+        "Validate set requires the :parent_operator option be set and represented in either the BOOLEAN_OPERATORS
+            or ENUMERATION_OPERATORS constant"
+      end
+
+      it "appends an error to errors" do
+        expect(mut).to include error_message
+      end
+    end
+
+    context "when opts[:parent_operator] is in BOOLEAN_OPERATORS" do
+
+      let(:options) { { parent_operator: :and } }
+
+      let(:test_instance) do
+        t_i = MSFL::Validators::Semantic.new
+        allow(t_i).to receive(:validate_boolean_set) { errors }
+        expect(t_i).to receive(:validate_boolean_set).once.with(set, errors, options)
+        t_i
+      end
+
+      it "invokes #validate_boolean_set once with the same arguments" do
+        mut
+      end
+    end
+
+    context "when opts[:parent_operator] is in ENUMERATION_OPERATORS" do
+
+      let(:options) { { parent_operator: :in } }
+
+      let(:test_instance) do
+        t_i = MSFL::Validators::Semantic.new
+        allow(t_i).to receive(:validate_enumeration_set) { errors }
+        expect(t_i).to receive(:validate_enumeration_set).once.with(set, errors, options)
+        t_i
+      end
+
+      it "invokes #validate_enumeration_set once with the same arguments" do
+        mut
+      end
+    end
+
+    context "when opts[:parent_operator] is not in neither BOOLEAN_OPERATORS nor ENUMERATION_OPERATORS" do
+
+      let(:options) { { parent_operator: :not_in_either } }
+
+      let(:error_message) do
+        "Validate set requires the :parent_operator option be set and represented in either the BOOLEAN_OPERATORS
+            or ENUMERATION_OPERATORS constant"
+      end
+
+      it "appends an error to errors" do
+        expect(mut).to include error_message
+      end
+    end
+  end
+end

data/spec/msfl_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'msfl/datasets/movies'
+describe "MSFL" do
+
+  let(:json_encoded_msfl) do
+    '{
+      "or": [
+          {
+              "and": [
+                  {
+                      "title": {
+                          "in": [
+                              "Frozen",
+                              "Big Hero 6",
+                              "Apollo 13"
+                          ]
+                      }
+                  },
+                  {
+                      "rating": {
+                          "gte": "PG"
+                      }
+                  }
+              ]
+          },
+          {
+              "earnings": {
+                  "lt": 5000000
+              }
+          }
+      ]
+    }'
+  end
+
+  let(:invalid_ruby_encoded_msfl) do
+    { not_a_field_in_dataset: "foobar" }
+  end
+
+  let(:ruby_encoded_msfl) do
+    {
+        or: MSFL::Types::Set.new([
+            {
+                and: MSFL::Types::Set.new([
+                    {
+                        title: {
+                            in: MSFL::Types::Set.new([
+                                "Frozen",
+                                "Big Hero 6",
+                                "Apollo 13"
+                            ])
+                        }
+                    },
+                    {
+                        rating: {
+                            gte: "PG"
+                        }
+                    }
+                ])
+            },
+            {
+                earnings: {
+                    lt: 5000000
+                }
+            }
+        ])
+    }
+  end
+
+  let(:parser) { MSFL::Parsers::JSON }
+
+  let(:validator) { MSFL::Validators::Semantic.new }
+
+  it "is configured using a block" do
+    MSFL.configure(reset: true) { |configuration| configuration.datasets = [MSFL::Datasets::Movies] }
+    expect(MSFL.configuration.datasets).to eq [MSFL::Datasets::Movies]
+  end
+
+  it "parses json encoded MSFL" do
+    expect(parser.parse json_encoded_msfl).to eq ruby_encoded_msfl
+  end
+
+  it "rejects invalid MSFL filters" do
+    MSFL.configure(reset: true) { |conf| conf.datasets = [MSFL::Datasets::Movies] }
+    expect(validator.validate invalid_ruby_encoded_msfl).to be false
+  end
+
+  it "accepts valid MSFL filters" do
+    MSFL.configure(reset: true) { |conf| conf.datasets = [MSFL::Datasets::Movies] }
+    expect(validator.validate ruby_encoded_msfl).to be true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require_relative '../simplecov_custom_profiles'
+SimpleCov.start 'msfl'
+require 'rspec/support/spec'
+require 'byebug'
+require_relative '../lib/msfl'
+require_relative 'msfl/shared_examples'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.qa
+  version: 0.0.1.pre.rc1
 platform: ruby
 authors:
 - Courtland Caldwell
@@ -101,6 +101,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- circle.yml
 - lib/msfl.rb
 - lib/msfl/configuration.rb
 - lib/msfl/datasets.rb
@@ -114,6 +121,14 @@ files:
 - lib/msfl/validators/definitions.rb
 - lib/msfl/validators/definitions/hash_key.rb
 - lib/msfl/validators/semantic.rb
+- msfl.gemspec
+- simplecov_custom_profiles.rb
+- spec/msfl/datasets/base_spec.rb
+- spec/msfl/parsers/json_spec.rb
+- spec/msfl/shared_examples.rb
+- spec/msfl/validators/semantic_spec.rb
+- spec/msfl_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/caldwecr/msfl
 licenses:
 - MIT
@@ -138,5 +153,11 @@ rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: MSFL in Ruby
-test_files: []
+test_files:
+- spec/msfl/datasets/base_spec.rb
+- spec/msfl/parsers/json_spec.rb
+- spec/msfl/shared_examples.rb
+- spec/msfl/validators/semantic_spec.rb
+- spec/msfl_spec.rb
+- spec/spec_helper.rb
 has_rdoc: