jpie 0.4.4 → 1.0.0

data/lib/jpie/resource.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'resource/attributable'
-require_relative 'resource/inferrable'
-require_relative 'resource/sortable'
-require_relative 'errors'
-
-module JPie
-  class Resource
-    include ActiveSupport::Configurable
-    include Attributable
-    include Inferrable
-    include Sortable
-
-    class << self
-      def inherited(subclass)
-        super
-        subclass._attributes = _attributes.dup
-        subclass._relationships = _relationships.dup
-        subclass._meta_attributes = _meta_attributes.dup
-        subclass._sortable_fields = _sortable_fields.dup
-      end
-
-      # Default scope method that returns all records
-      # Override this in your resource classes to provide authorization scoping
-      # Example:
-      #   def self.scope(context)
-      #     current_user = context[:current_user]
-      #     return model.none unless current_user
-      #
-      #     if current_user.admin?
-      #       model.all
-      #     else
-      #       model.where(user: current_user)
-      #     end
-      #   end
-      def scope(_context = {})
-        model.all
-      end
-
-      # Return supported include paths for validation
-      # Override this method to customize supported includes
-      def supported_includes
-        # Return relationship names as supported includes by default
-        _relationships.keys.map(&:to_s)
-
-        # Convert to nested hash format for complex includes
-        # For simple includes, return array format
-      end
-
-      # Return supported sort fields for validation
-      # Override this method to customize supported sort fields
-      def supported_sort_fields
-        base_fields = extract_base_sort_fields
-        timestamp_fields = extract_timestamp_fields
-        (base_fields + timestamp_fields).uniq
-      end
-
-      private
-
-      def extract_base_sort_fields
-        (_attributes + _sortable_fields.keys).uniq.map(&:to_s)
-      end
-
-      def extract_timestamp_fields
-        return [] unless model.respond_to?(:column_names)
-
-        timestamp_fields = []
-        add_timestamp_field(timestamp_fields, 'created_at')
-        add_timestamp_field(timestamp_fields, 'updated_at')
-        timestamp_fields
-      end
-
-      def add_timestamp_field(fields, field_name)
-        return unless model.column_names.include?(field_name)
-        return if fields.include?(field_name)
-
-        fields << field_name
-      end
-    end
-
-    attr_reader :object, :context
-
-    def initialize(object, context = {})
-      @object = object
-      @context = context
-    end
-
-    delegate :id, to: :@object
-
-    delegate :type, to: :class
-
-    def attributes_hash
-      self.class._attributes.index_with do
-        send(it)
-      end
-    end
-
-    def meta_hash
-      # Start with meta attributes from the macro
-      base_meta = self.class._meta_attributes.index_with do
-        send(it)
-      end
-
-      # Check if the resource defines a custom meta method
-      if respond_to?(:meta, true) && method(:meta).owner != JPie::Resource
-        custom_meta = meta
-
-        # Validate that meta method returns a hash
-        unless custom_meta.is_a?(Hash)
-          raise JPie::Errors::ResourceError.new(
-            detail: "meta method must return a Hash, got #{custom_meta.class}"
-          )
-        end
-
-        # Merge custom meta with base meta (custom meta takes precedence)
-        base_meta.merge(custom_meta)
-      else
-        base_meta
-      end
-    end
-
-    protected
-
-    # Default meta method that returns the meta attributes
-    # This can be overridden in subclasses
-    def meta
-      self.class._meta_attributes.index_with do
-        send(it)
-      end
-    end
-
-    private
-
-    def method_missing(method_name, *, &)
-      if @object.respond_to?(method_name)
-        @object.public_send(method_name, *, &)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      @object.respond_to?(method_name, include_private) || super
-    end
-  end
-end

data/lib/jpie/routing.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  module Routing
-    # Add jpie_resources method to Rails routing DSL that creates JSON:API compliant routes
-    def jpie_resources(*resources)
-      options = resources.extract_options!
-      merged_options = build_merged_options(options)
-
-      # Create standard RESTful routes for the resource
-      resources(*resources, merged_options) do
-        yield if block_given?
-        add_jsonapi_relationship_routes(merged_options) if relationship_routes_allowed?(merged_options)
-      end
-    end
-
-    private
-
-    def build_merged_options(options)
-      default_options = {
-        defaults: { format: :json },
-        constraints: { format: :json }
-      }
-      default_options.merge(options)
-    end
-
-    def relationship_routes_allowed?(merged_options)
-      only_actions = merged_options[:only]
-      except_actions = merged_options[:except]
-
-      if only_actions
-        # If only specific actions are allowed, don't add relationship routes
-        # unless multiple member actions (show, update, destroy) are included
-        (only_actions & %i[show update destroy]).size >= 2
-      elsif except_actions
-        # If actions are excluded, only add if member actions aren't excluded
-        !except_actions.intersect?(%i[show update destroy])
-      else
-        true
-      end
-    end
-
-    def add_jsonapi_relationship_routes(_merged_options)
-      # These routes handle relationship management as per JSON:API spec
-      member do
-        # Routes for fetching and updating relationships
-        # Pattern: /resources/:id/relationships/:relationship_name
-        get 'relationships/*relationship_name', action: :show_relationship, as: :relationship
-        patch 'relationships/*relationship_name', action: :update_relationship
-        post 'relationships/*relationship_name', action: :create_relationship
-        delete 'relationships/*relationship_name', action: :destroy_relationship
-
-        # Routes for fetching related resources
-        # Pattern: /resources/:id/:relationship_name
-        get '*relationship_name', action: :show_related, as: :related
-      end
-    end
-  end
-end

data/lib/jpie/rspec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec/expectations'
-
-module JPie
-  # RSpec matchers and helpers for testing JPie resources
-  module RSpec
-    # Configure RSpec with JPie helpers and matchers
-    def self.configure!
-      ::RSpec.configure do |config|
-        config.include JPie::RSpec::Matchers
-        config.include JPie::RSpec::Helpers
-      end
-    end
-
-    # Custom matchers for JPie resources
-    module Matchers
-      extend ::RSpec::Matchers::DSL
-
-      matcher :have_attribute do |attribute_name|
-        match do |actual|
-          actual.respond_to?(attribute_name) &&
-            actual.attributes.key?(attribute_name.to_s)
-        end
-
-        failure_message do |actual|
-          "expected #{actual.inspect} to have attribute '#{attribute_name}'"
-        end
-      end
-
-      matcher :have_relationship do |relationship_name|
-        match do |actual|
-          actual.respond_to?(relationship_name) &&
-            actual.relationships.key?(relationship_name.to_s)
-        end
-
-        failure_message do |actual|
-          "expected #{actual.inspect} to have relationship '#{relationship_name}'"
-        end
-      end
-    end
-
-    # Helper methods for testing JPie resources
-    module Helpers
-      # Build a JPie resource without saving it
-      def build_jpie_resource(type, attributes = {}, relationships = {})
-        JPie::Resource.new(
-          type: type,
-          attributes: attributes,
-          relationships: relationships
-        )
-      end
-
-      # Create a JPie resource and save it
-      def create_jpie_resource(type, attributes = {}, relationships = {})
-        resource = build_jpie_resource(type, attributes, relationships)
-        resource.save
-        resource
-      end
-
-      # Clean up test data after specs
-      def cleanup_jpie_resources(resources)
-        Array(resources).each do |resource|
-          resource.destroy if resource.persisted?
-        rescue StandardError => e
-          warn "Failed to cleanup resource #{resource.inspect}: #{e.message}"
-        end
-      end
-    end
-  end
-end

data/lib/jpie/serializer.rb

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-module JPie
-  class Serializer
-    attr_reader :resource_class, :options
-
-    def initialize(resource_class, options = {})
-      @resource_class = resource_class
-      @options = options
-    end
-
-    def serialize(objects, context = {}, includes: [])
-      return { data: nil } if objects.nil?
-
-      resources = build_resources(objects, context)
-      result = serialize_data(objects, resources)
-      add_included_data(result, resources, includes, context) if should_include_data?(includes, result)
-      result
-    end
-
-    private
-
-    def build_resources(objects, context)
-      Array(objects).filter_map { |obj| obj ? resource_class.new(obj, context) : nil }
-    end
-
-    def serialize_data(objects, resources)
-      if objects.is_a?(Array) || objects.respond_to?(:each)
-        serialize_collection(resources)
-      else
-        resources.first ? serialize_single(resources.first) : { data: nil }
-      end
-    end
-
-    def should_include_data?(includes, result)
-      includes.any? && result[:data]
-    end
-
-    def add_included_data(result, resources, includes, context)
-      included_data = collect_included_data(resources, includes, context)
-      result[:included] = included_data
-    end
-
-    def serialize_single(resource)
-      {
-        data: serialize_resource_data(resource)
-      }
-    end
-
-    def serialize_collection(resources)
-      {
-        data: resources.map { serialize_resource_data(it) }
-      }
-    end
-
-    def serialize_resource_data(resource)
-      data = {
-        id: resource.id.to_s,
-        type: resource.type,
-        attributes: serialize_attributes(resource)
-      }
-
-      meta_data = serialize_meta(resource)
-      data[:meta] = meta_data if meta_data.any?
-
-      data.compact
-    end
-
-    def serialize_attributes(resource)
-      attributes = resource.attributes_hash
-      return {} if attributes.empty?
-
-      attributes.transform_keys { it.to_s.underscore }
-                .transform_values { serialize_value(it) }
-    end
-
-    def serialize_meta(resource)
-      meta_attributes = resource.meta_hash
-      return {} if meta_attributes.empty?
-
-      meta_attributes.transform_keys { it.to_s.underscore }
-                     .transform_values { serialize_value(it) }
-    end
-
-    def serialize_value(value)
-      value.respond_to?(:iso8601) ? value.iso8601 : value
-    end
-
-    def collect_included_data(resources, includes, context)
-      processor = IncludeProcessor.new(self, context)
-      processor.process(resources, includes)
-    end
-
-    def parse_nested_includes(includes)
-      result = {}
-
-      includes.each do |include_path|
-        parts = include_path.split('.')
-        top_level = parts.first
-        nested_path = parts[1..].join('.') if parts.length > 1
-
-        result[top_level] ||= []
-        result[top_level] << nested_path if nested_path.present?
-      end
-
-      result
-    end
-
-    # Helper class to manage include processing state and reduce parameter passing
-    class IncludeProcessor
-      attr_reader :serializer, :context, :included, :processed_includes
-
-      def initialize(serializer, context)
-        @serializer = serializer
-        @context = context
-        @included = []
-        @processed_includes = {}
-      end
-
-      def process(resources, includes)
-        parsed_includes = serializer.send(:parse_nested_includes, includes)
-        parsed_includes.each do |include_name, nested_includes|
-          process_single_include(include_name, nested_includes, resources)
-        end
-        included
-      end
-
-      private
-
-      def process_single_include(include_name, nested_includes, resources)
-        include_sym = include_name.to_sym
-        relationship_options = serializer.resource_class._relationships[include_sym]
-        return unless relationship_options
-
-        resources.each do |resource|
-          process_resource_relationships(resource, include_sym, relationship_options, nested_includes)
-        end
-      end
-
-      def process_resource_relationships(resource, include_sym, relationship_options, nested_includes)
-        related_objects = resource.public_send(include_sym)
-        return unless related_objects
-
-        Array(related_objects).each do |related_object|
-          process_related_object(related_object, relationship_options, nested_includes)
-        end
-      end
-
-      def process_related_object(related_object, relationship_options, nested_includes)
-        related_resource_class = serializer.send(:determine_resource_class, related_object, relationship_options)
-        return unless related_resource_class
-
-        related_resource = related_resource_class.new(related_object, context)
-        resource_data = serializer.send(:serialize_resource_data, related_resource)
-
-        add_to_included_if_unique(resource_data)
-        process_nested_includes_for_resource(related_resource_class, related_resource, nested_includes)
-      end
-
-      def add_to_included_if_unique(resource_data)
-        key = [resource_data[:type], resource_data[:id]]
-        return if processed_includes[key]
-
-        processed_includes[key] = true
-        included << resource_data
-      end
-
-      def process_nested_includes_for_resource(related_resource_class, related_resource, nested_includes)
-        return unless nested_includes.any?
-
-        nested_serializer = JPie::Serializer.new(related_resource_class)
-        nested_included = nested_serializer.send(:collect_included_data, [related_resource], nested_includes, context)
-
-        nested_included.each do |nested_item|
-          add_to_included_if_unique(nested_item)
-        end
-      end
-    end
-
-    def determine_resource_class(object, relationship_options)
-      # First try the explicitly specified resource class
-      if relationship_options[:resource]
-        begin
-          return relationship_options[:resource].constantize
-        rescue NameError
-          # If the resource class doesn't exist, it might be a polymorphic relationship
-          # Fall through to polymorphic detection
-        end
-      end
-
-      # For polymorphic relationships, determine resource class from object class
-      if object&.class
-        resource_class_name = "#{object.class.name}Resource"
-        begin
-          return resource_class_name.constantize
-        rescue NameError
-          # Resource class doesn't exist for this object type
-          return nil
-        end
-      end
-
-      nil
-    end
-  end
-end