jpie 0.1.0 → 0.3.0

data/lib/json_api/support/responders.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-require "rack/utils"
-
-module JSONAPI
-  module Responders
-    extend ActiveSupport::Concern
-
-    included do
-      before_action :ensure_jsonapi_content_type, if: -> { request.post? || request.patch? || request.put? }
-      before_action :ensure_jsonapi_accept_header
-    end
-
-    private
-
-    def ensure_jsonapi_content_type
-      return if request.content_type&.include?("application/vnd.api+json")
-
-      render json: {
-        errors: [
-          {
-            status: "415",
-            title: "Unsupported Media Type",
-            detail: "Content-Type must be application/vnd.api+json"
-          }
-        ]
-      }, status: :unsupported_media_type
-    end
-
-    def ensure_jsonapi_accept_header
-      # Allow requests without Accept header or with */* (browser defaults)
-      # Only validate when Accept header is explicitly set to non-JSON:API media types
-      accept_header = request.headers["Accept"]
-
-      # Allow blank Accept header (browser default)
-      return if accept_header.blank?
-
-      # Allow */* Accept header (browser default)
-      return if accept_header == "*/*"
-
-      # Check if request accepts */* (wildcard)
-      return if request.accepts.any? { |mime| mime.to_s == "*/*" }
-
-      # Check if JSON:API media type is explicitly requested
-      return if jsonapi_requested?
-
-      # If Accept header is present and doesn't include JSON:API, return 406
-      # This ensures we honor explicit Accept preferences while allowing defaults
-      render_not_acceptable_error
-    end
-
-    def jsonapi_requested?
-      request.accepts.any? { |mime| mime.to_s.include?("application/vnd.api+json") }
-    end
-
-    def render_not_acceptable_error
-      render_parameter_errors(
-        [nil],
-        title: "Not Acceptable",
-        detail_proc: ->(_) { "Accept header must include application/vnd.api+json or be omitted" },
-        status: :not_acceptable
-      )
-    end
-
-    def render_jsonapi_error(status:, title:, detail: nil, source: nil)
-      render_jsonapi_errors([{ status:, title:, detail:, source: }], status:)
-    end
-
-    def render_jsonapi_errors(errors, status:)
-      normalized_errors = Array(errors).map do |error|
-        normalized = error.compact
-        normalized_status = normalized[:status] || status
-        normalized[:status] = status_code_for(normalized_status)
-        normalized
-      end
-
-      render json: { errors: normalized_errors }, status:
-    end
-
-    def render_parameter_errors(values, title:, detail_proc:, source_proc: nil, status: :bad_request)
-      errors = Array(values).map do |value|
-        error = {
-          title:,
-          detail: detail_proc.call(value)
-        }
-        error[:source] = source_proc.call(value) if source_proc
-        error
-      end
-
-      render_jsonapi_errors(errors, status:)
-    end
-
-    def status_code_for(status)
-      return status if status.is_a?(String) && status.match?(/\A\d+\z/)
-
-      Rack::Utils::SYMBOL_TO_STATUS_CODE.fetch(status, status).to_s
-    end
-  end
-end

data/lib/json_api/support/response_helpers.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module ResponseHelpers
-    # Delegates to Serializer.jsonapi_object for backward compatibility
-    def self.jsonapi_object
-      JSONAPI::Serializer.jsonapi_object
-    end
-  end
-end

data/lib/json_api/support/sort_parsing.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module SortParsing
-    module_function
-
-    def parse_sort_field(sort_field)
-      descending = sort_field.start_with?("-")
-      field = descending ? sort_field[1..] : sort_field
-      { field:, direction: descending ? :desc : :asc }
-    end
-
-    def extract_sort_field_name(sort_field)
-      parse_sort_field(sort_field)[:field]
-    end
-
-    def extract_sort_direction(sort_field)
-      parse_sort_field(sort_field)[:direction]
-    end
-  end
-end

data/lib/json_api/support/type_conversion.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module TypeConversion
-    module_function
-
-    def type_to_class_name(type)
-      type.to_s.singularize.classify
-    end
-
-    def model_type_name(model_class)
-      model_class.name.underscore.pluralize
-    end
-
-    def resource_type_name(definition_class)
-      type_name = definition_class.name.sub(/Resource$/, "").underscore.pluralize
-      # Remove namespace prefix if present (e.g., "json_api/active_storage_blobs" -> "active_storage_blobs")
-      type_name.split("/").last
-    end
-  end
-end

data/lib/json_api/testing/test_helper.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module JSONAPI
-  module Testing
-    # Test helper for Rails integration/request tests that provides consistent
-    # `as: :jsonapi` behavior across all HTTP methods.
-    #
-    # Usage in RSpec:
-    #   RSpec.configure do |config|
-    #     config.include JSONAPI::Testing::TestHelper, type: :request
-    #   end
-    #
-    # Then use `as: :jsonapi` in your tests:
-    #   get users_path, params: { filter: { active: true } }, headers:, as: :jsonapi
-    #   post users_path, params: payload, headers:, as: :jsonapi
-    #
-    # Behavior:
-    # - GET: Sets Accept header, params go to query string (no body encoding)
-    # - POST/PATCH/PUT/DELETE: Sets Content-Type and Accept headers, JSON-encodes body
-    #
-    module TestHelper
-      JSONAPI_MIME = "application/vnd.api+json"
-
-      def get(path, **options)
-        if options[:as] == :jsonapi
-          options = apply_jsonapi_headers(options, include_content_type: false)
-          options.delete(:as)
-        end
-        super
-      end
-
-      def post(path, **options)
-        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
-        super
-      end
-
-      def patch(path, **options)
-        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
-        super
-      end
-
-      def put(path, **options)
-        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
-        super
-      end
-
-      def delete(path, **options)
-        options = apply_jsonapi_options_for_body(options) if options[:as] == :jsonapi
-        super
-      end
-
-      private
-
-      def apply_jsonapi_headers(options, include_content_type: true)
-        options = options.dup
-        headers = (options[:headers] || {}).dup
-
-        headers["Accept"] = JSONAPI_MIME
-        headers["Content-Type"] = JSONAPI_MIME if include_content_type
-
-        options[:headers] = headers
-        options
-      end
-
-      def apply_jsonapi_options_for_body(options)
-        options = apply_jsonapi_headers(options, include_content_type: true)
-        options.delete(:as)
-
-        # JSON-encode params for request body
-        options[:params] = options[:params].to_json if options[:params].is_a?(Hash)
-
-        options
-      end
-    end
-  end
-end

data/lib/json_api/testing.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "testing/test_helper"

data/lib/json_api.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "json_api/version"
-require "json_api/configuration"
-
-module JSONAPI
-  class Error < StandardError; end
-  class AuthorizationError < Error; end
-end
-
-require "json_api/errors/parameter_not_allowed"
-
-module JSONAPI
-  # Rebuild BaseController and RelationshipsController to reflect the current
-  # base_controller_class configuration. Safe to call repeatedly.
-  def self.rebuild_base_controllers!
-    remove_const(:BaseController) if const_defined?(:BaseController)
-    load "json_api/controllers/base_controller.rb"
-
-    remove_const(:RelationshipsController) if const_defined?(:RelationshipsController)
-    load "json_api/controllers/relationships_controller.rb"
-  end
-end
-
-require "json_api/resources/resource"
-require "json_api/resources/resource_loader"
-require "json_api/support/type_conversion"
-require "json_api/support/sort_parsing"
-require "json_api/support/resource_identifier"
-require "json_api/support/relationship_helpers"
-require "json_api/support/param_helpers"
-require "json_api/active_storage/detection"
-require "json_api/active_storage/serialization"
-require "json_api/active_storage/deserialization"
-require "json_api/support/active_storage_support"
-require "json_api/support/collection_query"
-require "json_api/routing"
-require "json_api/support/responders"
-require "json_api/support/instrumentation"
-require "json_api/serialization/serializer"
-require "json_api/serialization/deserializer"
-require "json_api/support/response_helpers"
-require "json_api/controllers/concerns/controller_helpers"
-require "json_api/controllers/concerns/resource_actions"
-require "json_api/controllers/base_controller"
-require "json_api/controllers/resources_controller"
-require "json_api/controllers/relationships_controller"
-require "json_api/resources/active_storage_blob_resource" if defined?(ActiveStorage)
-
-require "json_api/railtie" if defined?(Rails)

data/lib/rubocop/cop/custom/hash_value_omission.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Custom
-      # Enforces hash value omission syntax introduced in Ruby 3.1
-      # When a hash key and value have the same name, use the shorthand syntax.
-      #
-      # @example
-      #   # bad
-      #   { controller: controller }
-      #   { foo: foo, bar: bar }
-      #
-      #   # good
-      #   { controller: }
-      #   { foo:, bar: }
-      class HashValueOmission < Base
-        extend AutoCorrector
-
-        MSG = "Use hash value omission (`%<key>s:`) when the value is the same-named local variable."
-
-        def on_pair(node)
-          return unless valid_pair_for_omission?(node)
-
-          key_name = node.key.value.to_s
-          return if already_omitted?(node, key_name)
-          return unless same_name?(node, key_name)
-
-          add_offense(node, message: format(MSG, key: key_name)) do |corrector|
-            corrector.replace(node.source_range, "#{key_name}:")
-          end
-        end
-
-        def valid_pair_for_omission?(node)
-          key = node.key
-          value = node.value
-
-          key.sym_type? && value&.lvar_type?
-        end
-
-        def already_omitted?(node, key_name)
-          source = node.source.strip
-          source == "#{key_name}:"
-        end
-
-        def same_name?(node, key_name)
-          value_name = node.value.source
-          key_name == value_name
-        end
-      end
-    end
-  end
-end