fun_with_json_api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 527661f615009228dc573ed949ccd8ea04349382
+  data.tar.gz: d93b9e012c63f7fab576f9c40c54af9bc3fd8c6e
+SHA512:
+  metadata.gz: 59d7335c4ecb53d0b3b7800e6635ae52240d41750f626f443e567a7025b206245db1a362d13e6d5ee440b561c47e67b8acb7e0395ee511b9a039bf6f5177233f
+  data.tar.gz: 2daad3bbbb9ea0c93fc996bee1f0ded6dade569ef0223e60985a48b42c19aaa176ae4e4920146bb4855f0b344d19abe0508a9936ce06eccc4fa21106ef32455e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Ben Morrall
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FunWithJsonApi'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc 'Run all specs in spec directory (excluding plugin specs)'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:spec, :rubocop]

data/config/locales/fun_with_json_api.en.yml

@@ -0,0 +1,13 @@
+en:
+  fun_with_json_api:
+    exceptions:
+      invalid_document: 'Request json_api document is invalid'
+      invalid_attribute: 'Request json_api document attribute is invalid'
+      invalid_relationship: 'Request json_api document relationship is invalid'
+      missing_relationship: 'Unable to find the requested relationship'
+      invalid_boolean_attribute: "Boolean value should only be true, false, or null"
+      invalid_date_attribute: "Date value should be in the format YYYY-MM-DD"
+      invalid_datetime_attribute: "Datetime value should be a ISO 8601 datetime"
+      invalid_decimal_attribute: "Decimal value must be a decimal number (i.e. 123.45)"
+      invalid_float_attribute: "Float value must be a floating point number (i.e. 123.45)"
+      invalid_integer_attribute: "Integer value must be a integer number (i.e. 123)"

data/lib/fun_with_json_api/attribute.rb

@@ -0,0 +1,38 @@
+module FunWithJsonApi
+  class Attribute
+    attr_reader :name
+    attr_reader :as
+
+    def self.create(name, options = {})
+      format = options.fetch(:format, 'string')
+      attribute_class_name = "#{format.to_s.classify}Attribute"
+      if FunWithJsonApi::Attributes.const_defined?(attribute_class_name)
+        FunWithJsonApi::Attributes.const_get(attribute_class_name)
+      else
+        raise ArgumentError, "Unknown attribute type: #{format}"
+      end.new(name, options)
+    end
+
+    def initialize(name, options = {})
+      raise ArgumentError, 'name cannot be blank!' unless name.present?
+
+      @name = name
+      @as = options.fetch(:as, name)
+    end
+
+    def call(value)
+      value
+    end
+
+    def sanitize_attribute_method
+      :"parse_#{param_value}"
+    end
+
+    def param_value
+      as.to_sym
+    end
+  end
+end
+
+# Load pre-defined Attributes
+Dir["#{File.dirname(__FILE__)}/attributes/**/*.rb"].each { |f| require f }

data/lib/fun_with_json_api/attributes/boolean_attribute.rb

@@ -0,0 +1,24 @@
+module FunWithJsonApi
+  module Attributes
+    # Ensures a value is either Boolean.TRUE, Boolean.FALSE or nil
+    # Raises an argument error otherwise
+    class BooleanAttribute < Attribute
+      def call(value)
+        return nil if value.nil?
+        return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+        raise build_invalid_attribute_error(value)
+      end
+
+      private
+
+      def build_invalid_attribute_error(value)
+        exception_message = I18n.t('fun_with_json_api.exceptions.invalid_boolean_attribute')
+        payload = ExceptionPayload.new
+        payload.detail = exception_message
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new(exception_message + ": #{value.inspect}", payload)
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/date_attribute.rb

@@ -0,0 +1,22 @@
+module FunWithJsonApi
+  module Attributes
+    class DateAttribute < Attribute
+      DATE_FORMAT = '%Y-%m-%d'.freeze
+
+      def call(value)
+        Date.strptime(value, DATE_FORMAT) if value
+      rescue ArgumentError => exception
+        raise build_invalid_attribute_error(exception, value)
+      end
+
+      private
+
+      def build_invalid_attribute_error(exception, value)
+        payload = ExceptionPayload.new
+        payload.detail = I18n.t('fun_with_json_api.exceptions.invalid_date_attribute')
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new(exception.message + ": #{value.inspect}", payload)
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/datetime_attribute.rb

@@ -0,0 +1,20 @@
+module FunWithJsonApi
+  module Attributes
+    class DatetimeAttribute < Attribute
+      def call(value)
+        DateTime.iso8601(value) if value
+      rescue ArgumentError => exception
+        raise build_invalid_attribute_error(exception, value)
+      end
+
+      private
+
+      def build_invalid_attribute_error(exception, value)
+        payload = ExceptionPayload.new
+        payload.detail = I18n.t('fun_with_json_api.exceptions.invalid_datetime_attribute')
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new(exception.message + ": #{value.inspect}", payload)
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/decimal_attribute.rb

@@ -0,0 +1,23 @@
+module FunWithJsonApi
+  module Attributes
+    class DecimalAttribute < Attribute
+      def call(value)
+        if value
+          unless value.to_s =~ /[0-9]+(\.[0-9]+)?/
+            raise build_invalid_attribute_error(value)
+          end
+          BigDecimal.new(value.to_s)
+        end
+      end
+
+      protected
+
+      def build_invalid_attribute_error(value)
+        payload = ExceptionPayload.new
+        payload.detail = I18n.t('fun_with_json_api.exceptions.invalid_decimal_attribute')
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new("Unable to parse decimal: #{value.inspect}", payload)
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/float_attribute.rb

@@ -0,0 +1,20 @@
+module FunWithJsonApi
+  module Attributes
+    class FloatAttribute < FunWithJsonApi::Attribute
+      def call(value)
+        Float(value.to_s) if value
+      rescue ArgumentError => exception
+        raise build_invalid_attribute_error(exception, value)
+      end
+
+      private
+
+      def build_invalid_attribute_error(exception, value)
+        payload = ExceptionPayload.new
+        payload.detail = I18n.t('fun_with_json_api.exceptions.invalid_float_attribute')
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new(exception.message + ": #{value.inspect}", payload)
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/integer_attribute.rb

@@ -0,0 +1,20 @@
+module FunWithJsonApi
+  module Attributes
+    class IntegerAttribute < FunWithJsonApi::Attribute
+      def call(value)
+        Integer(value.to_s) if value
+      rescue ArgumentError => exception
+        raise build_invalid_attribute_error(exception)
+      end
+
+      private
+
+      def build_invalid_attribute_error(exception)
+        payload = ExceptionPayload.new
+        payload.detail = I18n.t('fun_with_json_api.exceptions.invalid_integer_attribute')
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new(exception.message, payload)
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/relationship.rb

@@ -0,0 +1,73 @@
+module FunWithJsonApi
+  module Attributes
+    class Relationship < FunWithJsonApi::Attribute
+      # Creates a new Relationship with name
+      # @param name [String] name of the relationship
+      # @param deserializer_class_or_callable [Class] Class of Deserializer or
+      #   a callable that returns one
+      # @param options[at] [String] alias value for the attribute
+      def self.create(name, deserializer_class_or_callable, options = {})
+        new(name, deserializer_class_or_callable, options)
+      end
+
+      delegate :id_param,
+               :type,
+               :resource_class,
+               to: :deserializer
+
+      def initialize(name, deserializer_class, options = {})
+        super(name, options)
+        @deserializer_class = deserializer_class
+      end
+
+      def deserializer
+        @deserializer ||= create_deserializer_from_deserializer_class
+      end
+
+      def call(id_value)
+        unless id_value.nil? || !id_value.is_a?(Array)
+          raise build_invalid_relationship_error(id_value)
+        end
+
+        resource_class.find_by!(id_param => id_value).try(:id) if id_value
+      rescue ActiveRecord::RecordNotFound => e
+        raise convert_record_not_found_error(e, id_value)
+      end
+
+      def param_value
+        :"#{as}_id"
+      end
+
+      private
+
+      # Creates a new Deserializer from the deserializer class
+      def create_deserializer_from_deserializer_class
+        if @deserializer_class.respond_to?(:call)
+          @deserializer_class.call
+        else
+          @deserializer_class
+        end.create(
+          attributes: [],
+          relationships: []
+        )
+      end
+
+      def build_invalid_relationship_error(id_value)
+        exception_message = "#{name} relationship should contain a single '#{type}' data hash"
+        payload = ExceptionPayload.new
+        payload.pointer = "/data/relationships/#{name}"
+        payload.detail = exception_message
+        Exceptions::InvalidRelationship.new(exception_message + ": #{id_value.inspect}", payload)
+      end
+
+      def convert_record_not_found_error(exception, id_value)
+        payload = ExceptionPayload.new
+        payload.pointer = "/data/relationships/#{name}/id"
+        payload.detail = "Unable to find '#{type}' with matching id: #{id_value.inspect}"
+        exception_message = "Couldn't find #{resource_class} where "\
+                            "#{id_param} = #{id_value.inspect}: #{exception.message}"
+        Exceptions::MissingRelationship.new(exception_message, payload)
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/relationship_collection.rb

@@ -0,0 +1,99 @@
+module FunWithJsonApi
+  module Attributes
+    class RelationshipCollection < FunWithJsonApi::Attribute
+      def self.create(name, deserializer_class_or_callable, options = {})
+        new(name, deserializer_class_or_callable, options)
+      end
+
+      delegate :id_param,
+               :type,
+               :resource_class,
+               to: :deserializer
+
+      def initialize(name, deserializer_class, options = {})
+        super(name, options.reverse_merge(as: name.to_s.singularize.to_sym))
+        @deserializer_class = deserializer_class
+
+        if as.to_s != as.to_s.singularize
+          raise ArgumentError, "Use a singular relationship as value: {as: :#{as.to_s.singularize}}"
+        end
+      end
+
+      def deserializer
+        @deserializer ||= create_deserializer_from_deserializer_class
+      end
+
+      # Expects an array of id values for a nested collection
+      def call(values)
+        unless values.nil? || values.is_a?(Array)
+          raise build_invalid_relationship_collection_error(values)
+        end
+
+        collection = resource_class.where(id_param => values)
+
+        # Ensure the collection size matches
+        expected_size = values.size
+        result_size = collection.size
+        if result_size != expected_size
+          raise build_missing_relationship_error_from_collection(collection, values)
+        end
+
+        # Call ActiceRecord#pluck if it is available
+        convert_collection_to_ids(collection)
+      end
+
+      # User the singular of `as` that is how AMS converts the value
+      def param_value
+        :"#{as}_ids"
+      end
+
+      private
+
+      def convert_collection_to_ids(collection)
+        if collection.respond_to? :pluck
+          # Well... pluck+arel doesn't work with SQLite, but select at least is safe
+          collection = collection.select(resource_class.arel_table[:id])
+        end
+        collection.map(&:id)
+      end
+
+      # Creates a new Deserializer from the deserializer class
+      def create_deserializer_from_deserializer_class
+        if @deserializer_class.respond_to?(:call)
+          @deserializer_class.call
+        else
+          @deserializer_class
+        end.create(
+          attributes: [],
+          relationships: []
+        )
+      end
+
+      def build_invalid_relationship_collection_error(values)
+        exception_message = "#{name} relationship should contain a array of '#{type}' data"
+        payload = ExceptionPayload.new
+        payload.pointer = "/data/relationships/#{name}"
+        payload.detail = exception_message
+        Exceptions::InvalidRelationship.new(exception_message + ": #{values.inspect}", payload)
+      end
+
+      def build_missing_relationship_error_from_collection(collection, values)
+        collection_values = collection.map { |resource| resource.public_send(id_param).to_s }
+        missing_values = values.reject { |value| collection_values.include?(value.to_s) }
+        payload = missing_values.map do |value|
+          build_missing_relationship_payload(value)
+        end
+        exception_message = "Couldn't find #{resource_class} items with "\
+                            "#{id_param} in #{missing_values.inspect}"
+        Exceptions::MissingRelationship.new(exception_message, payload)
+      end
+
+      def build_missing_relationship_payload(value)
+        ExceptionPayload.new.tap do |payload|
+          payload.pointer = "/data/relationships/#{name}/id"
+          payload.detail = "Unable to find '#{type}' with matching id: #{value.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attributes/string_attribute.rb

@@ -0,0 +1,9 @@
+module FunWithJsonApi
+  module Attributes
+    class StringAttribute < Attribute
+      def call(value)
+        value.to_s if value
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/controller_methods.rb

@@ -0,0 +1,12 @@
+require 'fun_with_json_api/exception_serializer'
+
+module FunWithJsonApi
+  module ControllerMethods
+    def render_fun_with_json_api_exception(exception)
+      render json: exception,
+             serializer: FunWithJsonApi::ExceptionSerializer,
+             adapter: :json,
+             status: exception.http_status
+    end
+  end
+end