jsonapionify 0.0.1.pre

data/lib/jsonapionify/inherited_attributes.rb

@@ -0,0 +1,125 @@
+module JSONAPIonify
+  module InheritedAttributes
+
+    def inherited_hash_attribute(*attrs, instance_reader: true, instance_writer: true, instance_accessor: true)
+      instance_reader, instance_writer = false, false unless instance_accessor
+      attrs.each do |attr|
+        ivar   = :"@#{attr}"
+        setter = :"#{attr}="
+        getter = :"#{attr}"
+
+        # Define First Variable
+        instance_variable_set(ivar, Hash.new)
+
+        # Define Setter
+        define_singleton_method setter do |value|
+          instance_variable_get(ivar).tap(&:clear).merge! value
+        end
+
+        # Define Getter
+        define_singleton_method getter do
+          instance_variable_get(ivar)
+        end
+
+        # Define Instance Getter
+        define_method getter do
+          if instance_variable_defined?(ivar)
+            instance_variable_get(ivar)
+          else
+            instance_variable_set(
+              ivar,
+              self.class.instance_variable_get(ivar).dup
+            )
+          end
+        end if instance_reader
+
+        # Define Instance Setter
+        define_method setter do |value|
+          instance_variable_get(ivar).tap(&:clear).merge! value
+        end if instance_writer
+
+        # Define Inheritor
+        mod = Module.new do
+          define_method :inherited do |subclass|
+            super(subclass)
+
+            # Set subclass variable
+            subclass.instance_variable_set(ivar, Hash.new)
+            parent_var   = instance_variable_get(ivar)
+            subclass_var = subclass.instance_variable_get(ivar)
+
+            # Merge changes from parent
+            subclass_var.deep_merge!(parent_var)
+
+            # Observe
+            observer = EnumerableObserver.observe(parent_var)
+            observer.added { |items| subclass_var.deep_merge! items.to_h }
+            observer.removed { |items| subclass_var.delete_if { |k, v| items.to_h[k] == v } }
+          end
+        end
+        extend mod
+      end
+    end
+
+    def inherited_array_attribute(*attrs, instance_reader: true, instance_writer: true, instance_accessor: true)
+      instance_reader, instance_writer = false, false unless instance_accessor
+      attrs.each do |attr|
+        ivar   = :"@#{attr}"
+        setter = :"#{attr}="
+        getter = :"#{attr}"
+
+        # Define First Variable
+        instance_variable_set(ivar, Array.new)
+
+        # Define Setter
+        define_singleton_method setter do |value|
+          instance_variable_get(ivar).tap(&:clear).concat(value)
+        end
+
+        # Define Getter
+        define_singleton_method getter do
+          instance_variable_get(ivar)
+        end
+
+        # Define Instance Getter
+        define_method getter do
+          if instance_variable_defined?(ivar)
+            instance_variable_get(ivar)
+          else
+            instance_variable_set(
+              ivar,
+              self.class.instance_variable_get(ivar).dup
+            )
+          end
+        end if instance_reader
+
+        # Define Instance Setter
+        define_method setter do |value|
+          instance_variable_get(ivar).tap(&:clear).concat(value)
+        end if instance_writer
+
+        # Define Inheritor
+        mod = Module.new do
+          define_method :inherited do |subclass|
+            super(subclass)
+
+            # Set subclass variable
+            subclass.instance_variable_set(ivar, Array.new)
+            parent_var   = instance_variable_get(ivar)
+            subclass_var = subclass.instance_variable_get(ivar)
+
+            # Merge changes from parent
+            subclass_var.concat(parent_var)
+
+            # Observe
+            observer = EnumerableObserver.observe(parent_var)
+            observer.added { |items| subclass_var.concat items }
+            observer.removed { |items| items.each { |item| subclass_var.delete item } }
+          end
+        end
+        extend mod
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,104 @@
+require 'active_support/core_ext/module/delegation'
+
+module JSONAPIonify::Structure
+  module Collections
+    class Base < Array
+      include JSONAPIonify::EnumerableObserver
+      include Helpers::InheritsOrigin
+      attr_reader :parent
+
+      delegate :cache_store, to: JSONAPIonify
+
+      def self.value_is(type_class)
+        define_method(:type_class) do
+          type_class
+        end
+      end
+
+      value_is Objects::Base
+
+      def initialize(array = [])
+        observe.added do |items|
+          items.each do |item|
+            item.instance_variable_set(:@parent, self) unless item.frozen?
+          end
+        end
+        array.each do |instance|
+          self << instance
+        end
+      end
+
+      def original_method(method)
+        Array.instance_method(method).bind(self)
+      end
+
+      def validate
+        each do |member|
+          member.validate if member.respond_to? :validate
+        end
+      end
+
+      def signature
+        "#{self.class.name}:#{Digest::SHA2.hexdigest map(&:signature).join}"
+      end
+
+      def collect_hashes
+        map do |member|
+          case member
+          when Objects::Base, Hash
+            member.to_hash
+          else
+            member
+          end
+        end
+      end
+
+      def compile
+        collect_hashes
+      end
+
+      def new(**attributes)
+        self << attributes
+      end
+
+      alias_method :append, :new
+
+      def <<(instance)
+        new_instance =
+          case instance
+          when Hash
+            type_class.new(**instance)
+          when type_class
+            instance
+          else
+            raise ValidationError,
+                  " Can 't initialize collection `#{self.class.name}` with a type of `#{instance.class.name}`"
+          end
+        super new_instance
+      end
+
+      def errors
+        map.each_with_index.each_with_object({}) do |(value, key), errors|
+          next unless value.respond_to? :errors
+          value.errors.each do |error_key, message|
+            errors[[key, error_key].join('/')] = message
+          end
+        end
+      end
+
+      def warnings
+        map.each_with_index.each_with_object({}) do |(value, key), warnings|
+          next unless value.respond_to? :all_warnings
+          value.all_warnings.each do |warning_key, message|
+            warnings[[key, warning_key].join('. ')] = message
+          end
+        end
+      end
+
+      alias_method :all_warnings, :warnings
+
+      private
+
+    end
+  end
+end

data/lib/jsonapionify/structure/collections/errors.rb

@@ -0,0 +1,7 @@
+module JSONAPIonify::Structure
+  module Collections
+    class Errors < Base
+      value_is Objects::Error
+    end
+  end
+end

data/lib/jsonapionify/structure/collections/included_resources.rb

@@ -0,0 +1,39 @@
+module JSONAPIonify::Structure
+  module Collections
+    class IncludedResources < Resources
+      value_is Objects::IncludedResource
+
+      def self.referenceable?(referenced, not_referenced)
+        not_referenced.any? do |unreferenced_item|
+          referenced.any? do |referenced_item|
+            referenced_item.relates_to? unreferenced_item
+          end
+        end
+      end
+
+      def referenced
+        return [] unless parent
+        top_level_referenced.tap do |referenced|
+          not_referenced = reduce([]) { |a, i| a << i }
+
+          while self.class.referenceable?(referenced, not_referenced)
+            not_referenced.each do |resource|
+              if referenced.any? { |referenced_item| referenced_item.relates_to? resource }
+                referenced << not_referenced.delete(resource)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def top_level_referenced
+        return [] unless parent
+        reduce([]) { |a, i| a << i }.select do |resource|
+          Array.wrap(parent[:data]).any? { |tlr| tlr.relates_to? resource }
+        end
+      end
+    end
+  end
+end

data/lib/jsonapionify/structure/collections/resource_identifiers.rb

@@ -0,0 +1,7 @@
+module JSONAPIonify::Structure
+  module Collections
+    class ResourceIdentifiers < Base
+      value_is Objects::ResourceIdentifier
+    end
+  end
+end

data/lib/jsonapionify/structure/collections/resources.rb

@@ -0,0 +1,7 @@
+module JSONAPIonify::Structure
+  module Collections
+    class Resources < Base
+      value_is Objects::Resource
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'active_support/core_ext/module/delegation'
+
+module JSONAPIonify::Structure
+  module Helpers
+    class Errors
+      include Enumerable
+
+      delegate :clear, :present?, :blank?, :each, to: :@hash
+
+      def initialize
+        @hash = {}
+      end
+
+      def initialize_copy(new_copy)
+        super
+        instance_variables.each do |ivar|
+          new_copy.instance_variable_set(
+            ivar, instance_variable_get(ivar).dup
+          ) rescue nil
+        end
+      end
+
+      def add(key, value)
+        (@hash[key] ||= []) << value
+      end
+
+      alias_method :[]=, :add
+
+      def [](key)
+        @hash[key]
+      end
+
+      def replace(key, messages)
+        @hash[key] = Array.wrap(messages)
+      end
+
+      def all_messages
+        @hash.each_with_object([]) do |(key, errors), messages|
+          errors.each do |error|
+            messages << [backtick_key(key), error].join(' ')
+          end
+        end
+      end
+
+      def as_collection
+        each_with_object(Collections::Errors.new) do |(pointer, messages), collection|
+          *, key = pointer.to_s.split('/')
+          entity = key.present? ? key : 'object'
+          messages.each do |message|
+            message = "#{entity} #{message}".chomp('.') << '.'
+            object = {
+              source: {
+                pointer: pointer
+              },
+              detail: message,
+              status: "422"
+            }
+            collection << object
+          end
+        end
+      end
+
+      private
+
+      def backtick_key(key)
+        "`#{key}`"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module JSONAPIonify::Structure
+  module Helpers
+    module InheritsOrigin
+      def client?
+        origin == :client
+      end
+
+      def server?
+        origin == :server
+      end
+
+      def origin
+        self.parent.try(:origin)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module JSONAPIonify::Structure
+  module Helpers
+    module MemberNames
+      extend self
+
+      def valid?(value)
+        return false if value.nil?
+        value = value.to_s if value.is_a? Symbol
+        [
+          value.present?,
+          valid_ends?(value),
+          contains_valid_characters?(value),
+          !contains_invalid_characters?(value)
+        ].reduce(:&)
+      end
+
+      private
+
+      def contains_valid_characters?(value)
+        value =~ /\A[a-zA-Z0-9\u0080-\uFFFF_\s-]+\Z/
+      end
+
+      def valid_ends?(value)
+        ['-', '_', ' '].map do |char|
+          !value.start_with?(char) & !value.end_with?(char)
+        end.reduce(:&)
+      end
+
+      def contains_invalid_characters?(value)
+        %w{+ , . [ ] ! " # $ % & ' ( ) * / : ; < = > ? @ \\ ^ ` { } | ~}.map do |char|
+          value.include? char
+        end.reduce(:|)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+class JSONAPIonify::Structure::Helpers::MetaDelegate
+  attr_reader :object
+
+  def initialize(object)
+    @object = object
+  end
+
+  def []=(k, v)
+    object[:meta]    ||= {}
+    object[:meta][k] = v
+  end
+
+  def [](k)
+    object[:meta] && object[:meta][k]
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'active_support/concern'
+
+module JSONAPIonify::Structure
+  module Helpers
+    module ObjectDefaults
+      extend ActiveSupport::Concern
+      include JSONAPIonify::EnumerableObserver
+
+      module ClassMethods
+        # Forces the setter to a type
+        def implements(key, as:, **opts)
+          type_of! key, must_be: as, allow_nil: true
+          track_implementation key, as, **opts
+        end
+
+        # Forces the setter to the collection type
+        # Allows unset types to expose collection and type_map methods
+        def collects(key, as:, **opts)
+          type_of! key, must_be: as
+          track_collection key, as, **opts
+        end
+
+        # implements_or_collects(:data, implements: A, collects: B, if: ->(obj){ obj.has_key? :attributes })
+        # implements_or_collects(:data, implements: C, collects: D, unless: ->(obj){ obj.has_key? :attributes })
+        def collects_or_implements(key, implements:, collects:, allow_nil: false, **opts)
+          allowed = [implements, collects]
+          allowed << NilClass if allow_nil
+          type_of! key, must_be: allowed
+          track_collection key, collects, **opts
+          track_implementation key, implements, **opts
+        end
+
+        alias_method :implements_or_collects, :collects_or_implements
+
+        # Defaults
+        def default(key, &block)
+          after_initialize do
+            self[key] ||= instance_eval(&block)
+          end
+        end
+
+        private
+
+        def track_implementation(key, klass, **opts)
+          (implementations[key] ||= {})[klass] = opts
+        end
+
+        def track_collection(key, klass, **opts)
+          (collections[key] ||= {})[klass] = opts
+        end
+      end
+
+      included do
+        include JSONAPIonify::InheritedAttributes
+        # Class Attributes
+        attr_reader :unset
+
+        inherited_hash_attribute :implementations, :collections
+
+        before_initialize do
+          @unset = {}
+        end
+      end
+
+      def [](k)
+        if has_key? k
+          super
+        elsif collections[k]
+          @unset[k] ||= [].tap do |ary|
+            observe(ary).added { self[k] = ary }
+          end
+        else
+          nil
+        end
+      end
+
+      def []=(k, v)
+        unset.delete_if { |unset_key, _| unset_key == k }
+        super k, coerce_value(k, v)
+      end
+
+      def object
+        super.tap do
+          newly_set = unset.select { |_, v| v.present? }
+          newly_set.each do |k, v|
+            self[k] = v
+          end
+        end
+      end
+
+      private
+
+      def coerce_value(k, v)
+        if implementations[k] && v.is_a?(Hash)
+          coerce_implementation(k, v)
+        elsif collections[k] && v.is_a?(Array)
+          coerce_collection(k, v)
+        else
+          v
+        end
+      end
+
+      def coerce_implementation(k, v)
+        klass, * = (implementations[k] || {}).find do |_, options|
+          JSONAPIonify::Continuation.new(**options).check(v) { true }
+        end
+        return v unless klass && !v.is_a?(klass)
+        klass.new(v)
+      end
+
+      def coerce_collection(k, v)
+        klass, * = (collections[k] || {}).find do |_, options|
+          v.all? do |obj|
+            JSONAPIonify::Continuation.new(**options).check(obj) { true }
+          end
+        end
+        return v unless klass && !v.is_a?(klass)
+        klass.new(v)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'active_support/concern'
+
+module JSONAPIonify::Structure
+  module Helpers
+    module ObjectSetters
+      extend ActiveSupport::Concern
+
+      # Setter
+      def []=(k, v)
+        raise TypeError, 'key must be a Symbol.' unless k.is_a? Symbol
+        object[k] = v
+      end
+
+      # Getter
+      def [](k)
+        raise TypeError, 'key must be a Symbol.' unless k.is_a? Symbol
+        object[k]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module JSONAPIonify::Structure
+  module Helpers
+    PaginationLinks = [
+      :first, # the first page of data
+      :last, # the last page of data
+      :prev, # the previous page of data
+      :next # the next page of data
+    ]
+  end
+end