msfl 0.0.1.pre.dev → 0.0.1.pre.qa

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07d5ab033f428edf6c94db6c4deabbca727102ad
-  data.tar.gz: 0c0583e4e98b61785e771c376171ffd929469ec9
+  metadata.gz: 5192c432f2b0fa92fdc52f791a6d1db94e0e7273
+  data.tar.gz: 369cf6c5d51a3b2f996b070a70894a6fd952b7f4
 SHA512:
-  metadata.gz: d58df00da55126dabffdbeca04a083fdd975f8d9d9f7e7d844ca4351149efbd3cd04ada377b9c39fe635a5b90457270dbaaf445aed99ce9a2ae4a116837f6c17
-  data.tar.gz: 889702566901c32969753a490179d194cbbc1ea35940a84e7aa4318bae8dd69dbc8f10de6a96a6b0687d5cf0290f7de2fb4591414ad849253668a42aff851928
+  metadata.gz: dadc0e105e90e00c982424d332a2cada2733a676cf9c26f0d65ab3c5a79e4ffe94c78b87903c493aa070ae0c80f813eb1bf6313cd81531593911fde0f0c3b1bf
+  data.tar.gz: 86c9aac383c3a267e9344ca3f081b4b1e9fd8c461ca5e86a5962e3811476dad04ac918c521cc9dc0011811e5029caca9ec14858bd9b83ad313a8c0a1c45d6561

data/lib/msfl.rb

@@ -1,5 +1,30 @@
-class MSFL
-  def self.hi
-    puts "Hi from the MSFL team."
+require 'msfl/parsers'
+require 'msfl/types'
+require 'msfl/validators'
+require 'msfl/configuration'
+require 'msfl/datasets'
+
+module MSFL
+  class << self
+    # Allows the user to set configuration options
+    #  by yielding the configuration block
+    #
+    # @param opts [Hash] an optional hash of options, supported options are `reset: true`
+    # @param block [Block] an optional configuration block
+    # @return [Configuration] the current configuration object
+    def configure(opts = {}, &block)
+      if opts.has_key?(:reset) && opts[:reset]
+        @configuration = nil
+      end
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    # Returns the singleton class's configuration object
+    #
+    # @return [Configuration] the current configuration object
+    def configuration
+      @configuration ||= Configuration.new
+    end
   end
 end

data/lib/msfl/configuration.rb

@@ -0,0 +1,9 @@
+module MSFL
+  class Configuration
+    attr_accessor :datasets
+
+    def initialize
+      @datasets = []
+    end
+  end
+end

data/lib/msfl/datasets.rb

@@ -0,0 +1 @@
+require_relative 'datasets/base'

data/lib/msfl/datasets/base.rb

@@ -0,0 +1,79 @@
+module MSFL
+  module Datasets
+    class Base
+
+      include Validators::Definitions::HashKey
+
+      # The descendant class MUST override this method otherwise all field validations will fail
+      #
+      # @return [Array] the fields in the dataset
+      def fields
+        raise NoMethodError, "Descendants of MSFL::Datasets::Base are required to implement the #fields method"
+      end
+
+      # 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)
+      def operators
+        hash_key_operators
+      end
+
+      # Method not implemented at this time
+      #
+      # @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
+      # @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
+      #
+      # @example:
+      #  foo.investors_validate_type_conforms("abc", :total_funding) => # there is one more error in errors
+      #    # because the type of total_funding must be an integer
+      #
+      def validate_type_conforms(obj, field, errors)
+        errors
+      end
+
+      # Method not implemented at this time
+      # Returns true if the object conforms to the types supported by the indicated field
+      #
+      # @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
+      def type_conforms?(obj, field)
+        true
+      end
+
+      # Method not implemented at this time
+      #
+      #
+      # @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
+      end
+
+      # Method not implemented at this time
+      #
+      #
+      # @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
+      #     exception will be raised
+      # @param field [Symbol] which field should the value 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
+      #
+      #
+      # @example:
+      #  foo.investors_value_conforms(-6000, :total_funding) => # there is one more error in errors
+      #    # because the funding cannot be negative
+      #
+      # @example:
+      #  foo.investors_value_conforms(12345, :total_funding) => # errors is unchanged
+      #
+      def validate_value_conforms(value, field, errors)
+        errors
+      end
+    end
+  end
+end

data/lib/msfl/datasets/movies.rb

@@ -0,0 +1,13 @@
+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 Movies < ::MSFL::Datasets::Base
+      def fields
+        [:title, :rating, :description, :earnings]
+      end
+    end
+  end
+end

data/lib/msfl/parsers.rb

@@ -0,0 +1 @@
+require_relative 'parsers/json'

data/lib/msfl/parsers/json.rb

@@ -0,0 +1,26 @@
+require 'json'
+module MSFL
+  module Parsers
+    class JSON
+      def self.parse(json)
+        obj = ::JSON.parse(json)
+        obj = arrays_to_sets obj
+        obj
+      end
+
+      def self.arrays_to_sets(obj)
+        obj = Types::Set.new obj if obj.is_a?(::Array)
+        if obj.respond_to? :each
+          if obj.is_a?(::Hash)
+            result = {}
+            obj.each { |key, val| result[key.to_sym] = arrays_to_sets val }
+          elsif obj.is_a?(Types::Set)
+            result = Types::Set.new obj.map { |value| arrays_to_sets value }
+          end
+        end
+        result ||= obj
+        result
+      end
+    end
+  end
+end

data/lib/msfl/types.rb

@@ -0,0 +1 @@
+require_relative 'types/set'

data/lib/msfl/types/set.rb

@@ -0,0 +1,7 @@
+module MSFL
+  module Types
+    class Set < ::Set
+
+    end
+  end
+end

data/lib/msfl/validators.rb

@@ -0,0 +1 @@
+require_relative 'validators/semantic'

data/lib/msfl/validators/definitions.rb

@@ -0,0 +1 @@
+require_relative 'definitions/hash_key'

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

@@ -0,0 +1,36 @@
+module MSFL
+  module Validators
+    module Definitions
+      module HashKey
+
+        def valid_hash_key?(key)
+          valid_hash_keys.include? key
+        end
+
+        def valid_hash_keys
+          hash_key_operators.concat self.dataset.fields
+        end
+
+        # Operators still needing parsing: ellipsis2, tilda
+        def hash_key_operators
+          [
+              :and,         # logical AND
+              :or,          # logical OR
+              :in,          # IN
+              :between,     # inclusive range for integers, dates, and date times
+              :start,       # a range bound inclusively to the left
+              :end,         # a range bound inclusively to the right
+              :ellipsis2,   # alias to :between
+              :tilda,       # alias to :between, :start, and :end depending on usage
+              :eq,          # ==
+              :lt,          # <
+              :lte,         # <=
+              :gt,          # >
+              :gte,         # >=
+              :neg,         # logical negation
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/msfl/validators/semantic.rb

@@ -0,0 +1,155 @@
+require_relative 'definitions'
+
+module MSFL
+  module Validators
+    class Semantic
+      # Load definitions
+      include Definitions::HashKey
+
+      attr_accessor :dataset, :errors, :current_field, :current_operator
+
+      BOOLEAN_OPERATORS = [:and, :or]
+      ENUMERATION_OPERATORS = [:in]
+
+      def initialize(attributes = nil, opts = {})
+        @dataset = MSFL.configuration.datasets.first.new unless MSFL.configuration.datasets.empty?
+        @dataset ||= Datasets::Base.new
+        @current_field = nil
+        @current_operator = nil
+      end
+
+      # Returns true if the object is valid, false if the object is invalid
+      # An array of hashes of errors is available at #errors
+      #
+      # This method is not meant to be called recursively, the private method recursive_validate is used
+      #  for this purpose
+      #
+      # @param hash [Hash] the object to be validated
+      # @param errors [Array] optionally provide an array that contains errors from previous validators in the
+      #  validation chain
+      def validate(hash, errors = [], opts = {})
+        errors << "Object to validate must be a Hash" unless hash.is_a?(Hash)
+        recursive_validate hash, errors, opts
+        @errors = errors
+        result = true if @errors.empty?
+        result ||= false
+        result
+      end
+
+      # Returns the result of merging errors with any newly encountered errors found in validating the hash
+      #
+      # @param hash [Hash] the Hash to validate
+      # @param errors [Array] an array of validation errors - empty indicates that no errors have been encountered
+      # @param opts [Hash] the options hash
+      # @return [Array] errors merged with any validation errors encountered in validating the hash
+      def validate_hash(hash, errors, opts)
+        # set current field
+        current_field = nil
+        # validate the keys and values
+        hash.each do |k, value|
+          key = k.to_sym
+          # validate the current hash key using broad hash key validation
+          errors << "Hash key encountered that is broadly invalid." unless valid_hash_key?(key)
+
+          # validate that the hash key is supported as an operator or dataset field
+
+          # if they key is an operator validate the dataset supports the operator for the current field
+          #
+          # if the key is a field of the dataset then we need to validate that the _value_ conforms to the dataset
+          #  specific validation rules for that field
+          #
+          # if they key is neither an operator nor a field we raise an ArgumentError
+          #
+          # Then make a recursive call to validate on the value so that it and its elements are validated
+          #  later I might be able to optimize this by only making the recursive call for Sets and Hashes
+          #
+          if dataset.operators.include? key
+            dataset.validate_operator_conforms key, current_field, errors
+            opts[:parent_operator] = key
+          elsif dataset.fields.include? key
+            current_field = key
+            dataset.validate_type_conforms value, current_field, errors
+            dataset.validate_value_conforms value, current_field, errors
+            opts[:parent_field] = current_field
+          else
+            errors << "Encountered hash key that is neither an operator nor a property of the dataset"
+          end
+          recursive_validate value, errors, opts
+        end
+        errors
+      end
+
+      # Acts as a helper method that forwards validation requests for sets to the right handler based on the
+      #  :parent_operator option's value
+      #
+      # @param set [MSFL::Types::Set] the set to validate
+      # @param errors [Array] the existing array of validation errors
+      # @param opts [Hash] the options hash
+      # @return [Array] the errors array argument with any additional validation errors appended
+      def validate_set(set, errors, opts)
+        error_message =
+            "Validate set requires the :parent_operator option be set and represented in either the BOOLEAN_OPERATORS
+            or ENUMERATION_OPERATORS constant"
+        errors << error_message unless opts.has_key?(:parent_operator)
+
+        if BOOLEAN_OPERATORS.include?(opts[:parent_operator])
+          validate_boolean_set set, errors, opts
+        elsif ENUMERATION_OPERATORS.include?(opts[:parent_operator])
+          validate_enumeration_set set, errors, opts
+        else
+          errors << error_message
+        end
+        errors
+      end
+
+      # Returns the result of merging errors with any newly encountered errors found in validating the set
+      #
+      # @param set [MSFL::Types::Set] the set to validate
+      # @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_boolean_set(set, errors, opts)
+        # Every member needs to be a hash
+        set.each do |value|
+          errors << "Every member of a boolean set must be a Hash" unless value.is_a?(Hash)
+          # recursively call validate on each member
+          recursive_validate value, errors, opts
+        end
+        errors
+      end
+
+      # Validates a set of enumerationd scalar values
+      def validate_enumeration_set(set, errors, opts)
+        current_field = opts[:parent_field] if opts.has_key?(:parent_field)
+        current_field ||= nil
+        errors << "Validate enumeration set requires the parent_field option to be set" if current_field.nil?
+        set.each do |value|
+          # this isn't quite right, it feels dirty to use :each
+          errors << "No members of an enumeration set may permit iteration across itself" if value.respond_to?(:each)
+          dataset.validate_type_conforms value, current_field, errors
+          dataset.validate_value_conforms value, current_field, errors
+        end
+        errors
+      end
+
+    private
+
+      def recursive_validate(obj, errors, opts)
+        # store a copy of parent_operator and parent_field to restore after recursion
+        parent_operator = opts[:parent_operator] if opts.has_key?(:parent_operator)
+        parent_operator ||= nil
+        parent_field = opts[:parent_field] if opts.has_key?(:parent_field)
+        parent_field ||= nil
+        if obj.is_a?(Hash)
+          validate_hash obj, errors, opts
+        elsif obj.is_a?(Types::Set)
+          validate_set obj, errors, opts
+        end
+        opts.delete :parent_operator
+        opts[:parent_operator] = parent_operator unless parent_operator.nil?
+        opts.delete :parent_field
+        opts[:parent_field] = parent_field unless parent_field.nil?
+        errors
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: msfl
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre.dev
+  version: 0.0.1.pre.qa
 platform: ruby
 authors:
 - Courtland Caldwell
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2015-03-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +102,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/msfl.rb
+- lib/msfl/configuration.rb
+- lib/msfl/datasets.rb
+- lib/msfl/datasets/base.rb
+- lib/msfl/datasets/movies.rb
+- lib/msfl/parsers.rb
+- lib/msfl/parsers/json.rb
+- lib/msfl/types.rb
+- lib/msfl/types/set.rb
+- lib/msfl/validators.rb
+- lib/msfl/validators/definitions.rb
+- lib/msfl/validators/definitions/hash_key.rb
+- lib/msfl/validators/semantic.rb
 homepage: https://github.com/caldwecr/msfl
 licenses:
 - MIT