msfl 0.0.1.pre.rc1 → 0.0.1.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1433fb3fe0766b9a5a4913a5c8236bffb00e9c5e
-  data.tar.gz: 9307024455e4e75530f334e4c91d2a09f7da7090
+  metadata.gz: daafbe97f5c20cfcd8c01f85f037d2ce541f79ea
+  data.tar.gz: 5dc889069b814f410425cd899a195affb0d5033e
 SHA512:
-  metadata.gz: 1a7ac56dec38d01c8dcec0521e27cb03f361d952d8309d72bfa6494e9b5b49c8e34a89d1f2e98c66742a885110519ecd41ea24d3aa05b2508b1eeb20155244e3
-  data.tar.gz: 8a8150eb7c2ded7f183e7f124167a2dd3de92477cdc52731ee6868599625b344308c80bb5707230e51847ba11ad6a0635129a69a77887b112d570ffc3c2df6b5
+  metadata.gz: 82a657a00b0dfa31b645d4a23bf587768510dd03dbeaa659543e11570af810688e29dad84475c4632ef1dc0c7f9f1b2c3115af9f6579f764b9d99be54268c8e5
+  data.tar.gz: be3361401722d576c5a9cb66dd1f4c4883f1d9abdf9328fe52f7dce1966deb09ffe7b16cebe4d21496847b23cf9642465c3f018196da031439c4726c1c63258d

data/lib/msfl.rb

@@ -3,6 +3,7 @@ require 'msfl/types'
 require 'msfl/validators'
 require 'msfl/configuration'
 require 'msfl/datasets'
+require 'msfl/sinatra'
 
 module MSFL
   class << self

data/lib/msfl/datasets/base.rb

@@ -4,6 +4,43 @@ module MSFL
 
       include Validators::Definitions::HashKey
 
+      # This class singleton code and the register_dataset method are a cute nicety for conveniently registering
+      #  new datasets from within the datasets themselves
+      class << self
+        def registered_datasets
+          @registered_datasets ||= {}
+        end
+
+        def registered_datasets=(registered_datasets)
+          @registered_datasets = registered_datasets
+        end
+      end
+
+      # Register a MSFL::Dataset as a registered dataset so that other code can reference the dataset using its
+      # name as a symbol, instead of having to pass around the class name.
+      #
+      # If no arguments are provided it registers the current class and sets its name to the class name downcased
+      # The dataset being registered can be overridden. The dataset name (how one refers to the dataset as a symbol)
+      #  can also be overridden.
+      #
+      # @todo add tests
+      #
+      # @meta-spinach
+      # @param dataset [Class] optionally specify a dataset to register (use this when registration occurs outside
+      #  of a dataset's class scope)
+      # @param opts [Hash] options
+      #  notable option: :name (it allows you to override the dataset name)
+      def self.register_dataset(dataset = nil, opts = {})
+        dataset ||= self
+        dataset_name = opts[:name] if opts.has_key?(:name)
+        dataset_name ||= dataset.name
+        dataset_name.slice! "MSFL::Datasets::"
+        dataset_name.downcase!
+        registered_datasets = MSFL::Datasets::Base.registered_datasets
+        registered_datasets[dataset_name.to_sym] = dataset
+        MSFL::Datasets::Base.registered_datasets = registered_datasets
+      end
+
       # The descendant class MUST override this method otherwise all field validations will fail
       #
       # The method defines an array of symbols, indicating what fields are supported for the Dataset

data/lib/msfl/datasets/cars.rb

@@ -0,0 +1,15 @@
+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
+    class Cars < ::MSFL::Datasets::Base
+      register_dataset
+
+      def fields
+        [:make, :model, :year, :value]
+      end
+    end
+  end
+end

data/lib/msfl/datasets/movies.rb

@@ -5,6 +5,8 @@ module MSFL
     # This is a fake dataset definition that shows the structure for composing your own and is used for testing
     #  msfl
     class Movies < ::MSFL::Datasets::Base
+      register_dataset
+
       def fields
         [:title, :rating, :description, :earnings]
       end

data/lib/msfl/sinatra.rb

@@ -0,0 +1,90 @@
+module MSFL
+  module Sinatra
+    class << self
+
+      attr_accessor :valid_filter
+
+      def valid_filter
+        @valid_filter ||= nil
+      end
+
+      # Extracts the filter clause from a Sinatra request params hash and parsers the filter
+      #
+      # @param params [Hash] the Sinatra request params
+      # @return [Object] the Ruby-ified MSFL filter
+      def parse_filter_from(params)
+        filter = params[:filter]
+        MSFL::Parsers::JSON.parse filter.to_json unless filter.nil?
+      end
+
+      # Extracts the dataset name from the Sinatra params. It then returns a new instance of the specified
+      # dataset.
+      #
+      # @param params [Hash] the Sinatra request params
+      # @return [MSFL::Datasets::Base, Nil] a new instance of the specified dataset, if it can be found, otherwise nil
+      def dataset_from(params)
+        dataset_name = params[:dataset].to_sym unless params[:dataset].nil?
+        dataset_name ||= nil
+        Datasets::Base.registered_datasets[dataset_name].new if Datasets::Base.registered_datasets.has_key?(dataset_name)
+      end
+
+      # Creates a semantic validator instance that is ready to validate the dataset
+      #
+      # @param params [Hash] the Sinatra request params
+      # @return [MSFL::Validators::Semantic] a validator instance ready to validate filters for the dataset
+      def validator_from(params)
+        MSFL::Validators::Semantic.new dataset_from(params)
+      end
+
+      # Validate the MSFL filter in the Sinatra request's params hash
+      #
+      # @param params [Hash] the Sinatra request params
+      # @return [Bool]
+      def validate(params)
+        validator = validator_from params
+        parsed_filter = parse_filter_from params
+        result = validator.validate parsed_filter
+        @valid_filter = parsed_filter if result
+        result
+      end
+    end
+
+    module Helpers
+      # This method extracts the dataset name and filter from the Sinatra params. It also performs semantic validation
+      # of the filter relative to the dataset.
+      #
+      # The method also has the side effect, when the filter is valid or setting the valid_filter singleton class
+      # instance variable valid_filter to the Ruby-ified parsed filter.
+      #
+      # @param params [Hash] this should be the params variable from the request context
+      # @return [Bool] returns true if the filter is valid, false otherwise.
+      def msfl_valid?(params)
+        Sinatra.validate params
+      end
+
+      # This method returns the valid MSFL filter. If the valid filter has already been extracted from the parameters
+      # it is returned, otherwise if the optional params argument is specified it will be sent to MSFL::Sinatra.validate
+      # and if the validation is successful the valid filter is returned. If the valid filter still cannot be determined
+      # then the method raises an ArgumentError.
+      #
+      # @param params [Hash] optionally pass in the Sinatra request parameters - this is intended to be used when no
+      #  previously successful call to msfl_valid? has been made, so that when you just need the filter you can skip
+      #  writing msfl_valid?(params) in your code.
+      # @return [Object] the Ruby-ified and validated MSFL filter
+      def msfl_filter(params = nil)
+        filter = Sinatra.valid_filter
+        if filter.nil?
+          Sinatra.validate params
+          filter = Sinatra.valid_filter
+        end
+        raise ArgumentError, "A valid filter could not be located in msfl_filter." if filter.nil?
+        filter
+      end
+    end
+
+    # Sinatra specific registration hook
+    def self.registered(app)
+      app.helpers Helpers if app.respond_to?(:helpers)
+    end
+  end
+end

data/msfl.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'msfl'
-  s.version     = '0.0.1-rc1'
+  s.version     = '0.0.1-rc2'
   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."

data/spec/msfl/shared_examples.rb

@@ -0,0 +1,23 @@
+shared_examples_for "an invocation of MSFL::Sinatra.validate" do
+
+  let(:params) { { dataset: dataset, filter: filter } }
+
+  context "when params[:dataset] is :movies" do
+
+    let(:dataset) { :movies }
+
+    context "when params[:filter] is a valid filter" do
+
+      let(:filter) { { title: "Gone with the wind" } }
+
+      it { is_expected.to be true }
+    end
+
+    context "when params[:filter] is an invalid filter" do
+
+      let(:filter) { { notavalidfield: "some arbitrary value" } }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/msfl/sinatra/helpers_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe "MSFL::Sinatra::Helpers" do
+
+  let(:sinatra_app_class) do
+    klass = class SinatraTestAppClass
+              # In a proper Sinatra app there would be no need to this because when the extension is registered the helpers
+              #  are automatically mixed in
+      include MSFL::Sinatra::Helpers
+    end
+    klass
+  end
+
+  let(:sinatra_app) { sinatra_app_class.new }
+
+  let(:params) { nil }
+
+  describe "#msfl_valid?" do
+
+    subject(:mut) { sinatra_app.msfl_valid? params }
+
+    it_behaves_like "an invocation of MSFL::Sinatra.validate"
+  end
+
+  describe "#msfl_filter" do
+
+    subject(:mut) { sinatra_app.msfl_filter params }
+
+    context "when Sinatra.valid_filter is a valid MSFL filter" do
+
+      let(:valid_filter) { { arbitrary: "hash" } }
+
+      before { MSFL::Sinatra.valid_filter = valid_filter }
+
+      it "is the valid MSFL filter" do
+        expect(mut).to eq valid_filter
+      end
+
+    end
+
+    context "when Sinatra.valid_filter is nil" do
+
+      before(:each) { MSFL::Sinatra.valid_filter = nil }
+
+      let(:params) { { filter: filter, dataset: dataset } }
+
+      let(:filter) { nil }
+
+      let(:dataset) { nil }
+
+      context "when params[:dataset] is nil" do
+
+        context "when params[:filter] is valid json" do
+
+          let(:filter) { { notavalidmsflkeybutokjson: ["a", "b"] } }
+
+          it "raises a NoMethodError" do
+            expect { mut }.to raise_error NoMethodError
+          end
+        end
+      end
+
+      context "when params[:filter] is not valid json" do
+
+        let(:filter) { "iamnotvalidjson" }
+
+        it "raises a JSON::ParserError" do
+          expect { mut }.to raise_error JSON::ParserError
+        end
+      end
+
+      context "when params[:filter] is nil" do
+
+        it "raises an ArgumentError" do
+          expect { mut }.to raise_error ArgumentError
+        end
+      end
+
+      context "when params[:dataset] is a valid Dataset" do
+
+        let(:dataset) { :cars }
+
+        context "when params[:filter] is a valid MSFL filter" do
+
+          let(:filter) { { make: { in: inner_array } } }
+
+          let(:inner_array) { ["Chevy", "Tesla"] }
+
+          let(:msfl_filter) { { make: { in: MSFL::Types::Set.new(inner_array) } } }
+
+          it "is the valid MSFL filter" do
+            expect(mut).to eq msfl_filter
+          end
+        end
+      end
+    end
+  end
+end

data/spec/msfl/sinatra_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+
+describe "MSFL::Sinatra" do
+
+  describe ".registered" do
+
+    let(:app) do
+      o = Object.new
+      allow(o).to receive :helpers
+      expect(o).to receive(:helpers).once
+      o
+    end
+
+    it "adds the methods in the Helpers module as helpers to a Sinatra application" do
+      MSFL::Sinatra.registered app
+    end
+  end
+
+  describe ".parse_filter_from" do
+
+    subject(:mut) { MSFL::Sinatra.parse_filter_from params }
+
+    let(:params) { { filter: filter } }
+
+    let(:filter) { nil }
+
+    context "when the params[:filter] is a hash" do
+
+      let(:filter) { { foo: inner_array } }
+
+      let(:inner_array) { ["cat", "dog"] }
+
+      let(:expected) { { foo: MSFL::Types::Set.new(inner_array) } }
+
+      it "is the MSFL parsed filter" do
+        expect(mut).to eq expected
+      end
+    end
+  end
+
+  describe ".dataset_from" do
+
+    subject(:mut) { MSFL::Sinatra.dataset_from params }
+
+    let(:params) { { dataset: dataset } }
+
+    let(:dataset) { nil }
+
+    context "when params[:dataset] is :movies" do
+
+      let(:dataset) { :movies }
+
+      it "is a new instance of MSFL::Datasets::Movies" do
+        expect(mut).to be_a MSFL::Datasets::Movies
+      end
+    end
+
+    context "when params[:dataset] is :cars" do
+
+      let(:dataset) { :cars }
+
+      it "is a new instance of MSFL::Datasets::Cars" do
+        expect(mut).to be_a MSFL::Datasets::Cars
+      end
+    end
+  end
+
+  describe ".validator_from" do
+
+    subject(:mut) { MSFL::Sinatra.validator_from params }
+
+    let(:params) { { dataset: dataset } }
+
+    let(:dataset) { nil }
+
+    context "when params[:dataset] is :movies" do
+
+      let(:dataset) { :movies }
+
+      it "is a semantic validator instance of MSFL::Datasets::Movies" do
+        validator = mut
+        expect(validator).to be_a MSFL::Validators::Semantic
+        expect(validator.dataset).to be_a MSFL::Datasets::Movies
+      end
+    end
+  end
+
+  describe ".validate" do
+
+    subject(:mut) { MSFL::Sinatra.validate params }
+
+    let(:params) { nil }
+
+    it_behaves_like "an invocation of MSFL::Sinatra.validate"
+  end
+end

data/spec/spec_helper.rb

@@ -3,4 +3,6 @@ SimpleCov.start 'msfl'
 require 'rspec/support/spec'
 require 'byebug'
 require_relative '../lib/msfl'
-require_relative 'msfl/shared_examples'
+require_relative 'msfl/shared_examples'
+require_relative '../lib/msfl/datasets/movies'
+require_relative '../lib/msfl/datasets/cars'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.rc1
+  version: 0.0.1.pre.rc2
 platform: ruby
 authors:
 - Courtland Caldwell
@@ -112,9 +112,11 @@ files:
 - lib/msfl/configuration.rb
 - lib/msfl/datasets.rb
 - lib/msfl/datasets/base.rb
+- lib/msfl/datasets/cars.rb
 - lib/msfl/datasets/movies.rb
 - lib/msfl/parsers.rb
 - lib/msfl/parsers/json.rb
+- lib/msfl/sinatra.rb
 - lib/msfl/types.rb
 - lib/msfl/types/set.rb
 - lib/msfl/validators.rb
@@ -126,6 +128,8 @@ files:
 - 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/semantic_spec.rb
 - spec/msfl_spec.rb
 - spec/spec_helper.rb
@@ -157,6 +161,8 @@ test_files:
 - 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/semantic_spec.rb
 - spec/msfl_spec.rb
 - spec/spec_helper.rb