msfl 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e429121644a1d3c1f05a4044f0e1de31857630f4
-  data.tar.gz: a232210e6ebbc43905c015d4c141c81352581e4b
+  metadata.gz: 0ce057720e95af53947418f9609ab57abcd2051c
+  data.tar.gz: 1786d887042de9117b98de5396dcb8e5087693e3
 SHA512:
-  metadata.gz: 97f84ad55020f79b9603c443cb577ccac5231e4078421edfa971fb78d721f354336b6b5e092cb15ada810144c844b98f44e3a7c572d1d4ce6290edb6acda1a15
-  data.tar.gz: 3cafe256b7d10063eb768916e08b916cfac37a3d1b112ed805479875208f8a1063f032015561e8cb7b27d7e49e637a7ad2fe890093931bf7375d953671597342
+  metadata.gz: 7f78c1b92cbcf54eed39828c10018e8fb6578ccb7ef96b48306adbef2e8fc9da3cb3aff6ad9aa995ab00ba452096a0c090e6945023c562195f12cc2c6ee71905
+  data.tar.gz: e08a7c45a8a8d70e19711333073e0632d30f0ebdf59c047e48ab26fef24c25952754405d13e5dc12e2bf0ab7abdc3a67f009a9bb4be28805fdee1a8272a7fb3e

data/lib/msfl/converters/operator.rb

@@ -102,49 +102,9 @@ module MSFL
       #
       # @param obj [Object] the Hash that is an implicit and
       # @return [Hash] the resulting explicit hash
-      # @todo clean up the if elsif train
       def implicit_and_to_explicit_recursively(obj, parent_key = nil)
         if obj.is_a? Hash
-          first_key = obj.keys.first
-          if binary_operators.include?(first_key)
-            result = i_to_e_bin_op obj, parent_key
-          elsif logical_operators.include?(first_key)
-            result = i_to_e_log_op obj, parent_key
-          elsif first_key == :partial
-            result = { partial: { given: implicit_and_to_explicit_recursively(obj[:partial][:given]),
-                                  filter: implicit_and_to_explicit_recursively(obj[:partial][:filter]) } }
-          elsif first_key == :foreign
-            result = { foreign: { dataset: implicit_and_to_explicit_recursively(obj[:foreign][:dataset]),
-                                  filter: implicit_and_to_explicit_recursively(obj[:foreign][:filter]) } }
-          else
-            # the first key is not an operator
-            # if there is only one key just assign the result of calling this method recursively on the value to the result for the key
-            if obj.keys.count == 1
-              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
-                # 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
-                raise ArgumentError, "#implicit_and_to_explicit requires that it does not contain any Arrays - its argument should preprocessed by .arrays_to_sets and .convert_keys_to_symbols"
-              end
-            else
-              raise ArgumentError, "#implicit_and_to_explicit requires that all or none of a hash's keys be operators" if any_operators?(obj.keys)
-              # none of the keys are operators
-              and_array = []
-              obj.each do |k, v|
-                if v.is_a? Hash
-                  and_array << implicit_and_to_explicit_recursively(v, k)
-                else
-                  and_array << { k => v }
-                end
-              end
-              result = { and: MSFL::Types::Set.new(and_array) }
-            end
-          end
+          result = i_to_e_rec_hash obj, parent_key
         elsif obj.is_a? MSFL::Types::Set
           result = i_to_e_set obj, parent_key
         elsif obj.is_a? Array
@@ -154,6 +114,67 @@ module MSFL
       end
 
     private
+
+      # Convert a Hash containing an implicit AND to an explicit AND
+      # This is a helper method used by #implicit_and_to_explicit_recursively
+      #
+      # @param hash [Hash] the Hash to be converted
+      # @param parent_key [Symbol] the parent key of the hash to be converted, or nil if one does not exist
+      # @return [Hash] the resulting hash with implicit ANDs converted to explicit ones
+      def i_to_e_rec_hash(hash, parent_key = nil)
+        first_key = hash.keys.first
+        if operator? first_key
+          result = i_to_e_op hash, parent_key
+        else
+          # the first key is not an operator
+          # if there is only one key just assign the result of calling this method recursively on the value to the result for the key
+          if hash.keys.count == 1
+            if hash[first_key].is_a?(Hash)
+              result = implicit_and_to_explicit_recursively hash[first_key], first_key
+            elsif hash[first_key].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, hash[first_key]
+            elsif hash[first_key].is_a? Array
+              raise ArgumentError, "#implicit_and_to_explicit requires that it does not contain any Arrays - its argument should preprocessed by .arrays_to_sets and .convert_keys_to_symbols"
+            end
+          else
+            raise ArgumentError, "#implicit_and_to_explicit requires that all or none of a hash's keys be operators" if any_operators?(hash.keys)
+            # none of the keys are operators
+            and_array = []
+            hash.each do |k, v|
+              if v.is_a? Hash
+                and_array << implicit_and_to_explicit_recursively(v, k)
+              else
+                and_array << { k => v }
+              end
+            end
+            result = { and: MSFL::Types::Set.new(and_array) }
+          end
+        end
+        result
+      end
+
+      def i_to_e_op(hash, parent_key = nil)
+        op_key = hash.keys.first
+
+        if binary_operators.include?(op_key)
+          i_to_e_bin_op hash, parent_key
+        elsif logical_operators.include?(op_key)
+          i_to_e_log_op hash, parent_key
+        elsif op_key == :partial
+          { partial: { given: implicit_and_to_explicit_recursively(hash[:partial][:given]),
+                       filter: implicit_and_to_explicit_recursively(hash[:partial][:filter]) } }
+        elsif op_key == :foreign
+          { foreign: { dataset: implicit_and_to_explicit_recursively(hash[:foreign][:dataset]),
+                       filter: implicit_and_to_explicit_recursively(hash[:foreign][:filter]) } }
+        else
+          fail ArgumentError, "Unsupported hash in private method #i_to_e_rec_hash_op_key"
+        end
+      end
+
       # Recursively handle a hash containing keys that are all logical operators
       def i_to_e_log_op(hash, parent_key = nil)
         raise ArgumentError, "#implicit_and_to_explicit requires that all or none of a hash's keys be logical operators" unless all_logical_operators?(hash.keys)

data/lib/msfl/datasets/animal.rb

@@ -0,0 +1,24 @@
+require_relative 'base'
+
+module MSFL
+  module Datasets
+    # This is a fake dataset definition that shows the structure for composing your own and is used for testing
+    #  msfl
+    # It differs from the other examples in that it overrides #operators
+    class Animal < ::MSFL::Datasets::Base
+      register_dataset
+
+      def foreigns
+        [:person]
+      end
+
+      def fields
+        [:name, :gender, :age, :type]
+      end
+
+      def operators
+        super.concat [:animal_specific_operator]
+      end
+    end
+  end
+end

data/lib/msfl/datasets/base.rb

@@ -65,7 +65,6 @@ module MSFL
       #
       # @param field_name [Symbol] the name of the field to check and see if the dataset supports it
       # @return [Bool] true if the field is supported by the dataset
-      # @todo write direct test of this
       def has_field?(field_name)
         direct_fields = self.fields
         foreigns.each do |f|
@@ -105,7 +104,6 @@ module MSFL
       #
       # @param operator [Symbol] the operator to check if the dataset supports it
       # @return [Bool] true if the dataset supports the operator
-      # @todo write test of this guy
       def has_operator?(operator)
         ops = operators
         foreigns.each do |f|

data/lib/msfl/datasets/person.rb

@@ -8,7 +8,7 @@ module MSFL
       register_dataset
 
       def foreigns
-        [:car]
+        [:car, :animal]
       end
 
       def fields

data/lib/msfl/validators/definitions/hash_key.rb

@@ -53,6 +53,14 @@ module MSFL
           [:and, :or]
         end
 
+        # Returns true if the argument is a valid operator
+        #
+        # @param symbol [Symbol] the value to check to see if it is an operator
+        # @return [Bool] true if the argument is a valid operator, false otherwise
+        def operator?(symbol)
+          hash_key_operators.include? symbol
+        end
+
         # Returns true if all elements of arr are operators, false otherwise
         #
         # @param arr [Array<Symbol>] the Array of Symbols to be checked against the operators list

data/msfl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl'
-  s.version     = '1.2.1'
-  s.date        = '2015-05-20'
+  s.version     = '1.2.2'
+  s.date        = '2015-05-27'
   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"]

data/spec/msfl/converters/operator_spec.rb

@@ -449,6 +449,20 @@ describe MSFL::Converters::Operator do
     end
   end
 
+  describe "#i_to_e_op" do
+
+    let(:hash) { { some_arbitrary_key: :foobar } }
+
+    subject { described_class.new.send(:i_to_e_op, hash) }
+
+    context "when the hash has a key that is not supported" do
+
+      it "raises an ArgumentError" do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+  end
+
   describe "#between_to_gte_lte_recursively" do
 
     subject { test_instance.between_to_gte_lte_recursively arg }

data/spec/msfl/datasets/animal_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MSFL::Datasets::Animal do
+
+  it "has a foreign: person" do
+    expect(described_class.new.foreigns).to include :person
+  end
+
+  it "has the name field" do
+    expect(described_class.new.fields).to include :name
+  end
+
+  it "has the gender field" do
+    expect(described_class.new.fields).to include :gender
+  end
+
+  it "has the age field" do
+    expect(described_class.new.fields).to include :age
+  end
+
+  it "has the type field" do
+    expect(described_class.new.fields).to include :type
+  end
+end

data/spec/msfl/datasets/base_spec.rb

@@ -26,6 +26,68 @@ describe "MSFL::Datasets::Base" do
     end
   end
 
+  describe "#has_operator?" do
+
+    let(:test_instance) { MSFL::Datasets::Person.new }
+
+    let(:operator) { :eq }
+
+    subject { test_instance.has_operator? operator }
+
+    context "when the dataset has the specified operator" do
+
+      it { is_expected.to eq true }
+    end
+
+    context "when the dataset does not have the specified operator" do
+
+      context "when the dataset has a foreign dataset that has the specified operator" do
+
+        let(:operator) { :animal_specific_operator }
+
+        it { is_expected.to eq true }
+      end
+
+      context "when the dataset does not have a foreign dataset that has the specified operator" do
+
+        let(:operator) { :not_an_operator }
+
+        it { is_expected.to eq false }
+      end
+    end
+  end
+
+  describe "#has_field?" do
+
+    let(:test_instance) { MSFL::Datasets::Car.new }
+
+    let(:field_name) { :make }
+
+    subject { test_instance.has_field? field_name }
+
+    context "when the dataset has the specified field" do
+
+      it { is_expected.to eq true }
+    end
+
+    context "when the dataset has a foreign data set that has the specified field" do
+
+      let(:field_name) { :gender }
+
+      it { is_expected.to eq true }
+    end
+
+    context "when the dataset does not have the specified field" do
+
+      context "when none of the dataset's foreign datasets have the specified field" do
+
+        let(:field_name) { :not_a_field }
+
+        it { is_expected.to eq false }
+      end
+    end
+  end
+
   describe "#type_conforms?" do
 
     context "when MSFL is configured to use Movie as the dataset" do

data/spec/msfl/validators/definitions/hash_key_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe MSFL::Validators::Definitions::HashKey do
+
+  module TestClassNamespace
+    class IncludesHashKey
+      include MSFL::Validators::Definitions::HashKey
+      attr_accessor :dataset
+    end
+  end
+
+  context "when a class includes #{described_class}" do
+
+    let(:test_instance) { TestClassNamespace::IncludesHashKey.new }
+
+    describe "#valid_hash_keys" do
+
+      before { test_instance.dataset = dataset }
+
+      let(:dataset) do
+        d = double('Dataset')
+        allow(d).to receive(:fields).and_return [:foo, :bar]
+        d
+      end
+
+      subject { test_instance.valid_hash_keys }
+
+      it "includes all of the valid operators" do
+        expect(subject).to include *(test_instance.hash_key_operators)
+      end
+
+      it "includes all of the valid fields" do
+        expect(subject).to include *(test_instance.dataset.fields)
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -5,4 +5,6 @@ require 'byebug'
 require_relative '../lib/msfl'
 require_relative 'msfl/shared_examples'
 require_relative '../lib/msfl/datasets/movie'
-require_relative '../lib/msfl/datasets/car'
+require_relative '../lib/msfl/datasets/car'
+require_relative '../lib/msfl/datasets/animal'
+require_relative '../lib/msfl/datasets/person'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Courtland Caldwell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -113,6 +113,7 @@ files:
 - lib/msfl/converters.rb
 - lib/msfl/converters/operator.rb
 - lib/msfl/datasets.rb
+- lib/msfl/datasets/animal.rb
 - lib/msfl/datasets/base.rb
 - lib/msfl/datasets/car.rb
 - lib/msfl/datasets/movie.rb
@@ -129,11 +130,13 @@ files:
 - msfl.gemspec
 - simplecov_custom_profiles.rb
 - spec/msfl/converters/operator_spec.rb
+- spec/msfl/datasets/animal_spec.rb
 - spec/msfl/datasets/base_spec.rb
 - spec/msfl/parsers/json_spec.rb
 - spec/msfl/shared_examples.rb
 - spec/msfl/sinatra/helpers_spec.rb
 - spec/msfl/sinatra_spec.rb
+- spec/msfl/validators/definitions/hash_key_spec.rb
 - spec/msfl/validators/semantic_spec.rb
 - spec/msfl_spec.rb
 - spec/spec_helper.rb
@@ -163,11 +166,13 @@ specification_version: 4
 summary: MSFL in Ruby
 test_files:
 - spec/msfl/converters/operator_spec.rb
+- spec/msfl/datasets/animal_spec.rb
 - spec/msfl/datasets/base_spec.rb
 - spec/msfl/parsers/json_spec.rb
 - spec/msfl/shared_examples.rb
 - spec/msfl/sinatra/helpers_spec.rb
 - spec/msfl/sinatra_spec.rb
+- spec/msfl/validators/definitions/hash_key_spec.rb
 - spec/msfl/validators/semantic_spec.rb
 - spec/msfl_spec.rb
 - spec/spec_helper.rb