jsonapionify 0.0.1.pre

data/lib/jsonapionify/structure/helpers/validations.rb

@@ -0,0 +1,296 @@
+require 'active_support/core_ext/class/attribute'
+
+module JSONAPIonify::Structure
+  module Helpers
+    module Validations
+      extend ActiveSupport::Concern
+      using JSONAPIonify::UnstrictProc
+
+      module ClassMethods
+
+        # Raise the validation errors
+        def validation_error(message)
+          message = "#{name}: #{message}"
+          ValidationError.new(message)
+        end
+
+        # Validations
+
+        # Fails if this key doesn't exist and the `given` does.
+        def may_not_exist!(key, without: nil, **options)
+          return may_not_exist_without! key, without if without
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              invalid_keys = self.keys.map(&:to_sym) & keys.map(&:to_sym)
+              if invalid_keys.present?
+                invalid_keys.each do |k|
+                  errors.add(k, 'is not permitted')
+                end
+              end
+            end
+          end
+        end
+
+        def may_not_exist_without!(key, without, **options)
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              if has_key?(key) && !has_key?(without)
+                errors.add(key, "may not exist without: `#{without}`")
+              end
+            end
+          end
+        end
+
+        # Warn but do not fail if keys present
+        def should_not_contain!(*keys, **options, &block)
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              keys         += self.keys.select(&block) if block_given?
+              invalid_keys = self.keys.map(&:to_sym) & keys.map(&:to_sym)
+              if invalid_keys.present?
+                invalid_keys.each do |key|
+                  warnings.add(key, 'is not permitted')
+                end
+              end
+            end
+          end
+        end
+
+        # Fails if these keys exist
+        def must_not_contain!(*keys, deep: false, **options, &block)
+          return must_not_contain_deep!(*keys, **options) if deep === true
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              keys         += self.keys.select(&block) if block_given?
+              invalid_keys = self.keys.map(&:to_sym) & keys.map(&:to_sym)
+              if invalid_keys.present?
+                invalid_keys.each do |key|
+                  errors.add(key, 'is not permitted')
+                end
+              end
+            end
+          end
+        end
+
+        # Fails if these keys exist deeply
+        def must_not_contain_deep!(*keys, **options, &block)
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              all_invalid_keys = []
+              keys             += self.keys.select(&block) if block_given?
+              is_invalid       = proc do |hash|
+                invalid_keys     = hash.keys.map(&:to_sym) & keys.map(&:to_sym)
+                all_invalid_keys += invalid_keys
+                children         = hash.values.select { |v| v.respond_to?(:to_hash) }
+                invalid_keys.present? | children.map { |c| is_invalid.call c }.reduce(:|)
+              end
+              if is_invalid.call(self)
+                errors.add('*', "cannot contain keys #{keys_to_sentence(*all_invalid_keys.uniq)}")
+              end
+            end
+          end
+        end
+
+        # Fails if one of these keys does not exist
+        def must_contain_one_of!(*keys, **options, &block)
+          self.permitted_keys = [*permitted_keys, *keys].uniq
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              keys       += self.keys.select(&block) if block_given?
+              valid_keys = keys.map(&:to_sym) & self.keys.map(&:to_sym)
+              unless valid_keys.present?
+                errors.add('*', "must contain one of: #{keys_to_sentence(*valid_keys)}")
+              end
+            end
+          end
+        end
+
+        # Fails if these keys dont exist
+        def must_contain!(*keys, **options)
+          self.permitted_keys = [*self.permitted_keys, *keys]
+          keys.each do |key|
+            required_keys[key] = options
+          end
+        end
+
+        # Fails if keys other than these exist
+        def may_contain!(*keys)
+          self.allow_only_permitted = true
+          self.permitted_keys       = [*permitted_keys, *keys].uniq
+        end
+
+        # Fails is more than one of the keys exists.
+        def must_not_coexist!(*keys, **options)
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              keys             = expand_keys(*keys)
+              conflicting_keys = keys & self.keys
+              if conflicting_keys.length > 1
+                conflicting_keys.each do |key|
+                  conflicts_with = conflicting_keys - [key]
+                  errors.add key, "conflicts with #{keys_to_sentence(*conflicts_with)}"
+                end
+              end
+            end
+          end
+        end
+
+        # Validates key using a provided method or block
+        def validate!(key, with: nil, message: 'is not valid', **options, &block)
+          before_validation do
+            if has_key? key
+              JSONAPIonify::Continuation.new(**options).check(self, key, self[key]) do
+                real_block = get_block_from_options(with, &block)
+                errors.add key, message unless real_block.call(self, key, self[key])
+              end
+            end
+          end
+        end
+
+        def validate_object!(with: nil, message: 'is not valid', **options, &block)
+          before_validation do
+            JSONAPIonify::Continuation.new(**options).check(self) do
+              real_block = get_block_from_options(with, &block)
+              errors.add '*', message unless real_block.call(self)
+            end
+          end
+        end
+
+        # Validates the object using a provided method or block
+        def validate_each!(with: nil, message: 'not valid', **options, &block)
+          before_validation do
+            real_block = get_block_from_options(with, &block)
+            keys.each do |key|
+              JSONAPIonify::Continuation.new(**options).check(self, key, self[key]) do
+                errors.add key, message unless real_block.call(self, key, self[key])
+              end
+            end
+          end
+        end
+
+        # Validates key is type
+        def type_of!(key, must_be:, allow_nil: false, **options)
+          allowed_type_map[key] ||= {}
+          types                 = Array.wrap(must_be)
+          types << NilClass if allow_nil
+          allowed_type_map[key][options] ||= []
+          allowed_type_map[key][options] += types
+        end
+      end
+
+      # Included Stuff
+
+      included do
+        extend JSONAPIonify::InheritedAttributes
+        class_attribute :allow_only_permitted, instance_writer: false
+        delegate :validation_error, to: :class
+        inherited_hash_attribute :allowed_type_map, :required_keys, instance_accessor: false
+        inherited_array_attribute :permitted_keys, instance_accessor: false
+        self.allow_only_permitted = false
+        self.permitted_keys       = []
+        self.allowed_type_map     = {}
+        self.required_keys        = {}
+
+        # Check Permitted Keys
+        before_validation do
+          self.keys.each do |key|
+            errors.add(key, "is not permitted") unless permitted_key? key
+          end
+        end
+
+        # Check Permitted Types
+        before_validation do
+          keys.each do |key|
+            next unless permitted_key?(key)
+            unless permitted_type_for?(key)
+              types   = permitted_types_for(key).map(&:name)
+              message = "must be a #{keys_to_sentence(*types)}."
+              errors.add(key, message)
+            end
+          end
+        end
+
+        # Check Required Keys
+        before_validation do
+          required_keys.each do |key|
+            unless has_key? key
+              errors.add key, 'must be provided'
+            end
+          end
+        end
+
+        validate_each!(message: 'is not a valid member name') do |_, key, _|
+          Helpers::MemberNames.valid? key
+        end
+
+      end
+
+      # Instance Methods
+
+      def permitted_key?(key)
+        !allow_only_permitted || permitted_keys.map(&:to_sym).include?(key.to_sym)
+      end
+
+      def required_key?(key)
+        required_keys.include? key
+      end
+
+      def required_keys
+        self.class.required_keys.select do |_, options|
+          JSONAPIonify::Continuation.new(**options).check(self) { true }
+        end.keys
+      end
+
+      def permitted_type_for?(key)
+        types = permitted_types_for(key)
+        types.empty? || permitted_types_for(key).any? { |type| self[key].is_a? type }
+      end
+
+      def permitted_types_for(key)
+        options_and_types = allowed_type_map[key] || {}
+        options_and_types.each_with_object([]) do |(options, types), permitted_types|
+          JSONAPIonify::Continuation.new(**options).check(self) do
+            permitted_types.concat types
+          end
+        end.uniq
+      end
+
+      def permitted_keys
+        expand_keys(*self.class.permitted_keys)
+      end
+
+      def allowed_type_map
+        self.class.allowed_type_map.dup.tap do |hash|
+          wildcard_types = hash.delete('*')
+          keys.each do |k|
+            hash[k] ||= {}
+            hash[k].deep_merge! wildcard_types
+          end if wildcard_types.present?
+        end
+      end
+
+      private
+
+      def expand_keys(*keys)
+        keys.flat_map do |key|
+          key.is_a?(Proc) ? keys.select(&key) : key
+        end
+      end
+
+      def get_block_from_options(symbol, &block)
+        raise ArgumentError, 'cannot pass symbol and block' if symbol && block
+        raise ArgumentError, 'must pass symbol or block' unless symbol || block
+        (block || method(symbol).to_proc).unstrict
+      end
+
+      def keys_to_sentence(*keys, connector: "or")
+        keys = keys.map { |key| backtick_key key }
+        keys.to_sentence(last_word_connector: ", #{connector} ", two_words_connector: " #{connector} ")
+      end
+
+      def backtick_key(key)
+        "`#{key}`"
+      end
+    end
+  end
+end

data/lib/jsonapionify/structure/maps/base.rb

@@ -0,0 +1,25 @@
+module JSONAPIonify::Structure
+  module Maps
+    class Base < Objects::Base
+
+      def self.value_is(type_class, strict: false)
+        define_method(:type_class) do
+          type_class
+        end
+        type! must_be: type_class if strict
+      end
+
+      def self.type!(**opts)
+        type_of! '*', **opts
+      end
+
+      private
+
+      def coerce_value(_, v)
+        return v unless v.is_a? Hash
+        type_class.new v
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/structure/maps/error_links.rb

@@ -0,0 +1,7 @@
+module JSONAPIonify::Structure
+  module Maps
+    class ErrorLinks < Links
+      may_contain! :about
+    end
+  end
+end

data/lib/jsonapionify/structure/maps/links.rb

@@ -0,0 +1,21 @@
+module JSONAPIonify::Structure
+  module Maps
+    class Links < Base
+
+      value_is Objects::Link
+
+      validate_each! message: 'must be url string or valid link object' do |obj, key, value|
+        case value
+        when String
+          uri = URI.parse(value)
+          uri.scheme.present?
+        when Objects::Link
+          true
+        else
+          false
+        end || !obj.permitted_key?(key)
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/structure/maps/relationship_links.rb

@@ -0,0 +1,11 @@
+module JSONAPIonify::Structure
+  module Maps
+    class RelationshipLinks < Links
+      # The RelationshipLinksObject **MAY** contain the following members:
+      must_contain_one_of! :self, # the link that generated the current response document.
+                           :related # a related resource link when the primary data represents a resource relationship.
+
+      may_contain! *Helpers::PaginationLinks
+    end
+  end
+end

data/lib/jsonapionify/structure/maps/relationships.rb

@@ -0,0 +1,23 @@
+module JSONAPIonify::Structure
+  module Maps
+    class Relationships < Base
+
+      # The value of the relationships key MUST be an object (a "relationships object"). Members of the relationships object ("relationships") represent references from the resource object in which it's defined to other resource objects.
+      # Relationships may be to-one or to-many.
+
+      # A relationship object that represents a to-many relationship MAY also contain pagination links under the links member, as described below.
+      # A resource object's AttributesObject and its RelationshipsObject are collectively called its fields.
+      # Fields for a ResourceObject **MUST** share a common namespace with each
+      # other and with `type` and `id`. In other words, a resource can not have an
+      # attribute and relationship with the same name, nor can it have an attribute
+      # or relationship named `type` or `id`.
+      must_not_contain! :type, :id
+      validate_each! message: 'conflicts with a resource_key' do |obj, key, _|
+        !obj.parent || !obj.parent.attribute_keys.include?(key)
+      end
+
+      value_is Objects::Relationship, strict: true
+
+    end
+  end
+end

data/lib/jsonapionify/structure/maps/resource_links.rb

@@ -0,0 +1,7 @@
+module JSONAPIonify::Structure
+  module Maps
+    class ResourceLinks < Links
+      may_contain! :self
+    end
+  end
+end

data/lib/jsonapionify/structure/maps/top_level_links.rb

@@ -0,0 +1,10 @@
+module JSONAPIonify::Structure
+  module Maps
+    class TopLevelLinks < Links
+      # The TopLevelLinksObject **MAY** contain the following members:
+      may_contain! :self, # the link that generated the current response document.
+                   :related, # a related resource link when the primary data represents a resource relationship.
+                   *Helpers::PaginationLinks # pagination links for the primary data.
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/attributes.rb

@@ -0,0 +1,29 @@
+module JSONAPIonify::Structure
+  module Objects
+    class Attributes < Base
+
+      # Attributes may contain any valid JSON value.
+      # Complex data structures involving JSON objects and arrays are allowed as
+      # attribute values. However, any object that constitutes or is contained in an
+      # attribute **MUST NOT** contain a `relationships` or `links` member, as those
+      # members are reserved by this specification for future use.
+      must_not_contain! :relationships, :links, deep: true
+
+      # A resource object's AttributesObject and its RelationshipsObject are collectively called its fields.
+      # Fields for a ResourceObject **MUST** share a common namespace with each
+      # other and with `type` and `id`. In other words, a resource can not have an
+      # attribute and relationship with the same name, nor can it have an attribute
+      # or relationship named `type` or `id`.
+      must_not_contain! :type, :id
+      validate_each! message: 'conflicts with a relationship key' do |obj, key, _|
+        !obj.parent || !obj.parent.relationship_keys.include?(key)
+      end
+
+      # Although has-one foreign keys (e.g. `author_id`) are often stored internally
+      # alongside other information to be represented in a resource object, these keys
+      # **SHOULD NOT** appear as attributes.
+      should_not_contain! { |key| key.to_s.end_with? '_id' }
+
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/base.rb

@@ -0,0 +1,166 @@
+require 'oj'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/hash/keys'
+
+module JSONAPIonify::Structure
+  module Objects
+    class Base
+
+      include JSONAPIonify::Callbacks
+      include Enumerable
+      include JSONAPIonify::EnumerableObserver
+      include Helpers::InheritsOrigin
+
+      define_callbacks :initialize, :validation
+
+      include Helpers::ObjectSetters
+      include Helpers::Validations
+      include Helpers::ObjectDefaults
+
+      # Attributes
+      attr_reader :object, :parent
+
+      delegate :fetch, :select, :has_key?, :keys, :values, :each, :present?, :blank?, :empty?, to: :object
+      delegate :cache_store, to: JSONAPIonify
+
+      before_initialize do
+        @object = {}
+        observe(@object).added do |items|
+          items.each do |_, value|
+            value.instance_variable_set(:@parent, self) unless value.frozen?
+          end
+        end
+      end
+
+      def self.from_hash(hash)
+        new hash.deep_symbolize_keys
+      end
+
+      def self.from_json(json)
+        from_hash Oj.load json
+      end
+
+      # Initialize the object
+      def initialize(**attributes)
+        run_callbacks :initialize do
+          attributes.each do |k, v|
+            self[k] = v
+          end
+        end
+      end
+
+      def copy
+        self.class.from_hash to_hash
+      end
+
+      def ==(other)
+        return unless other.respond_to? :[]
+        object.all? do |k, v|
+          other[k] == v
+        end
+      end
+
+      def ===(other)
+        other.class == self.class && self == other
+      end
+
+      # Compile as json
+      attr_reader :errors, :warnings
+
+      def compile
+        validate
+        to_hash
+      end
+
+      def as_json
+        compile.deep_stringify_keys
+      end
+
+      def to_json
+        Oj.dump(as_json)
+      end
+
+      def signature
+        "#{self.class.name}:#{Digest::SHA2.hexdigest to_hash.to_s}"
+      end
+
+      def to_hash
+        object.reduce({}) do |hash, (k, v)|
+          hash[k] =
+            case v
+            when Objects::Base
+              v.to_hash
+            when Hash
+              v.deep_stringify_keys
+            when Collections::Base
+              v.collect_hashes
+            else
+              v
+            end
+          hash
+        end
+      end
+
+      def compile!(*args)
+        compile(*args).tap do
+          if (wrns = warnings).present?
+            warn validation_error wrns.all_messages.to_sentence + '.'
+          end
+          if (errs = errors).present?
+            raise validation_error errs.all_messages.to_sentence + '.'
+          end
+        end
+      end
+
+      def validate
+        object.values.each { |val| val.validate if val.respond_to? :validate }
+        [errors, warnings].each(&:clear)
+        @errors, @warnings =
+          cache_store.fetch(signature) do
+            run_callbacks :validation do
+              collect_child_errors
+              collect_child_warnings
+            end
+            [errors, warnings]
+          end
+        errors.blank?
+      end
+
+      def errors
+        @errors ||= Helpers::Errors.new
+      end
+
+      def warnings
+        @warnings ||= Helpers::Errors.new
+      end
+
+      def pretty_json
+        JSON.pretty_generate as_json
+      end
+
+      private
+
+      def collect_child_errors
+        object.each do |key, value|
+          next unless value.respond_to? :errors
+          value.errors.each do |error_key, messages|
+            errors.replace [key, error_key].join('/'), messages
+          end
+        end
+      end
+
+      def collect_child_warnings
+        object.each do |key, value|
+          next unless value.respond_to? :warnings
+          value.warnings.each do |warning_key, messages|
+            warnings.replace [key, warning_key].join('/'), messages
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/error.rb

@@ -0,0 +1,16 @@
+module JSONAPIonify::Structure
+  module Objects
+    class Error < Base
+      may_contain! :id, :links, :status, :code, :title, :detail, :source, :meta
+
+      implements :links, as: Maps::ErrorLinks
+      implements :source, as: Source
+      implements :meta, as: Meta
+
+      type_of! :id, must_be: String
+      type_of! :status, must_be: String
+      type_of! :code, must_be: String
+      type_of! :title, must_be: String
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/included_resource.rb

@@ -0,0 +1,14 @@
+module JSONAPIonify::Structure
+  module Objects
+    # ResourceObjects appear in a JSON API document to represent resources.
+    class IncludedResource < Resource
+      validate_object! with: :referenced?, message: "included resource is not referenced"
+
+      def referenced?
+        return true unless parent
+        parent.referenced.include? self
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/jsonapi.rb

@@ -0,0 +1,7 @@
+module JSONAPIonify::Structure
+  module Objects
+    class Jsonapi < Base
+      may_contain! :version, :meta
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/link.rb

@@ -0,0 +1,18 @@
+module JSONAPIonify::Structure
+  module Objects
+    class Link < Base
+
+      may_contain! :href, :meta
+
+      validate! :href, message: 'must be a valid URL' do |*, value|
+        if value.is_a?(String)
+          uri = URI.parse(value)
+          uri.scheme.present?
+        else
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/meta.rb

@@ -0,0 +1,7 @@
+module JSONAPIonify::Structure
+  module Objects
+    class Meta < Base
+
+    end
+  end
+end

data/lib/jsonapionify/structure/objects/relationship.rb

@@ -0,0 +1,20 @@
+module JSONAPIonify::Structure
+  module Objects
+    class Relationship < Base
+      # A "relationship object" MUST contain at least one of the following:
+      must_contain_one_of! :links, # A links object.
+                           :data, # Resource linkage.
+                           :meta # A meta object that contains non-standard meta-information about the relationship.
+
+      implements :links, as: Maps::Links
+      implements :meta, as: Meta
+
+      collects_or_implements(
+        :data,
+        collects:   Collections::ResourceIdentifiers,
+        implements: ResourceIdentifier,
+        allow_nil:  true
+      )
+    end
+  end
+end