jat 0.0.1 → 0.0.3

data/lib/jat/plugins/simple_api/lib/response.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module SimpleApi
+      class Response
+        attr_reader :jat, :jat_class, :object, :context
+
+        def initialize(jat)
+          @jat = jat
+          @jat_class = jat.class
+          @object = jat.object
+          @context = jat.context
+        end
+
+        def response
+          # Add main response
+          result = many? ? many(object) : one(object)
+          result = {root_key => result} if root_key
+          result ||= {}
+
+          # Add metadata to response
+          # We can add metadata to empty response, or to top-level namespace
+          # We should not mix metadata with object attributes
+          metadata.tap do |meta|
+            next if meta.empty?
+            raise Error, "Response must have a root key to add metadata" if !result.empty? && !root_key
+            result[meta_key] = meta
+          end
+
+          result
+        end
+
+        private
+
+        def metadata
+          result = context[:meta] || {}
+
+          config_meta = jat_class.config[:meta]
+          return result unless config_meta
+
+          config_meta.each_with_object(result) do |(key, value), res|
+            next if res.key?(key) # do not overwrite manually added meta
+
+            value = value.call(object, context) if value.respond_to?(:call)
+            res[key] = value unless value.nil?
+          end
+        end
+
+        def many(objects)
+          objects.map { |obj| one(obj) }
+        end
+
+        def one(obj)
+          ResponseData.new(jat_class, obj, context, jat.traversal_map).data
+        end
+
+        def many?
+          @is_many ||= begin
+            many = context[:many]
+            many.nil? ? object.is_a?(Enumerable) : many
+          end
+        end
+
+        # We can provide nil or false to remove root
+        def root_key
+          @root_key ||=
+            if context.key?(:root)
+              context[:root]
+            else
+              (many? ? jat_class.root_for_many : jat_class.root_for_one) || jat_class.root
+            end
+        end
+
+        def meta_key
+          context[:meta_key] || jat_class.meta_key
+        end
+      end
+
+      class ResponseData
+        attr_reader :jat_class, :object, :context, :map, :presenter
+
+        def initialize(jat_class, object, context, map)
+          @jat_class = jat_class
+          @object = object
+          @context = context
+          @map = map
+          @presenter = jat_class::Presenter.new(object, context)
+        end
+
+        def data
+          return unless object
+
+          result = {}
+
+          map.each do |key, inner_keys|
+            attribute = jat_class.attributes.fetch(key)
+            value = presenter.public_send(attribute.original_name)
+
+            result[key] =
+              if attribute.relation?
+                if many?(attribute, value)
+                  value.map { |obj| response_data(attribute, obj, inner_keys) }
+                else
+                  response_data(attribute, value, inner_keys)
+                end
+              else
+                value
+              end
+          end
+
+          result
+        end
+
+        private
+
+        def response_data(attribute, value, map)
+          ResponseData.new(attribute.serializer.call, value, context, map).data
+        end
+
+        def many?(attribute, object)
+          is_many = attribute.many?
+
+          # handle boolean
+          return is_many if (is_many == true) || (is_many == false)
+
+          # handle nil
+          object.is_a?(Enumerable)
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/simple_api/simple_api.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "./lib/map"
+require_relative "./lib/response"
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module SimpleApi
+      DEFAULT_META_KEY = :meta
+
+      def self.after_load(jat_class, **opts)
+        jat_class.plugin(:_json_api_activerecord, **opts) if opts[:activerecord]
+      end
+
+      module InstanceMethods
+        def to_h
+          Response.new(self).response
+        end
+
+        def traversal_map
+          @traversal_map ||= Map.call(self)
+        end
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          subclass.root(@root) if defined?(@root)
+
+          super
+        end
+
+        def root(new_root = nil)
+          return (defined?(@root) && @root) unless new_root
+
+          new_root = new_root.to_sym
+          @root = new_root
+        end
+
+        def root_for_one(new_root_for_one = nil)
+          return (defined?(@root_for_one) && @root_for_one) unless new_root_for_one
+
+          new_root_for_one = new_root_for_one.to_sym
+          @root_for_one = new_root_for_one
+        end
+
+        def root_for_many(new_root_for_many = nil)
+          return (defined?(@root_for_many) && @root_for_many) unless new_root_for_many
+
+          new_root_for_many = new_root_for_many.to_sym
+          @root_for_many = new_root_for_many
+        end
+
+        def meta_key(new_meta_key = nil)
+          return ((defined?(@meta_key) && @meta_key) || DEFAULT_META_KEY) unless new_meta_key
+
+          new_meta_key = new_meta_key.to_sym
+          @meta_key = new_meta_key
+        end
+      end
+    end
+
+    register_plugin(:simple_api, SimpleApi)
+  end
+end

data/lib/jat/plugins/to_str/to_str.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module ToStr
+      def self.after_load(jat_class, **opts)
+        jat_class.config[:to_str] = opts[:to_str] || ->(data) { ToStrJSON.dump(data) }
+      end
+
+      module ClassMethods
+        def to_str(object, context = {})
+          new(object, context).to_str
+        end
+      end
+
+      module InstanceMethods
+        def to_str
+          config[:to_str].call(to_h)
+        end
+      end
+
+      class ToStrJSON
+        module ClassMethods
+          def dump(response)
+            json_adapter.dump(response)
+          end
+
+          private
+
+          def json_adapter
+            @json_adapter ||= begin
+              require "json"
+              ::JSON
+            end
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+
+    register_plugin(:to_str, ToStr)
+  end
+end

data/lib/jat/plugins.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    @plugins = {}
+
+    # Register the given plugin with Jat, so that it can be loaded using
+    # `Jat.plugin` with a symbol. Should be used by plugin files. Example:
+    #
+    #     Jat::Plugins.register_plugin(:plugin_name, PluginModule)
+    def self.register_plugin(name, mod)
+      @plugins[name] = mod
+    end
+
+    # If the registered plugin already exists, use it. Otherwise, require it
+    # and return it. This raises a LoadError if such a plugin doesn't exist,
+    # or a Jat::Error if it exists but it does not register itself
+    # correctly.
+    def self.load_plugin(name)
+      require "jat/plugins/#{name}/#{name}" unless @plugins.key?(name)
+
+      @plugins[name] || raise(Error, "plugin #{name} did not register itself correctly in Jat::Plugins")
+    end
+
+    # Delegate call to the plugin in a way that works across Ruby versions.
+    def self.before_load(plugin, jat_class, **opts)
+      return unless plugin.respond_to?(:before_load)
+
+      plugin.before_load(jat_class, **opts)
+    end
+
+    # Delegate call to the plugin in a way that works across Ruby versions.
+    def self.after_load(plugin, jat_class, **opts)
+      return unless plugin.respond_to?(:after_load)
+
+      plugin.after_load(jat_class, **opts)
+    end
+  end
+end

data/lib/jat/presenter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Jat
+  # Core class that encapsulates attributes presentation logic
+  class Presenter
+    module InstanceMethods
+      # Presented object
+      attr_reader :object
+
+      # Presented context
+      attr_reader :context
+
+      def initialize(object, context)
+        @object = object
+        @context = context
+      end
+    end
+
+    module ClassMethods
+      # Returns the Jat class that this presenter class is namespaced under.
+      attr_accessor :jat_class
+
+      # Since Presenter is anonymously subclassed when Jat is subclassed,
+      # and then assigned to a constant of the Jat subclass, make inspect
+      # reflect the likely name for the class.
+      def inspect
+        "#{jat_class.inspect}::Presenter"
+      end
+
+      def add_method(name, block)
+        # Warning-free method redefinition
+        remove_method(name) if method_defined?(name, false)
+        define_method(name, &block_without_args(block))
+      end
+
+      private
+
+      def block_without_args(block)
+        case block.parameters.count
+        when 0 then block
+        when 1 then -> { instance_exec(object, &block) }
+        when 2 then -> { instance_exec(object, context, &block) }
+        else raise Error, "Invalid block arguments count"
+        end
+      end
+    end
+
+    extend ClassMethods
+    include InstanceMethods
+  end
+end

data/lib/jat/utils/enum_deep_dup.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Jat
+  # Duplicates nested enumerable data
+  class EnumDeepDup
+    DUP = {
+      Hash => ->(data) { dup_hash_values(data) },
+      Array => ->(data) { dup_array_values(data) }
+    }.freeze
+
+    def self.call(data)
+      duplicate_data = data.dup
+      DUP.fetch(duplicate_data.class).call(duplicate_data)
+      duplicate_data
+    end
+
+    def self.dup_hash_values(duplicate_data)
+      duplicate_data.each do |key, value|
+        duplicate_data[key] = call(value) if value.is_a?(Enumerable)
+      end
+    end
+
+    def self.dup_array_values(duplicate_data)
+      duplicate_data.each_with_index do |value, index|
+        duplicate_data[index] = call(value) if value.is_a?(Enumerable)
+      end
+    end
+  end
+end

data/lib/jat/utils/enum_deep_freeze.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Jat
+  # Freezes nested enumerable data
+  class EnumDeepFreeze
+    FREEZES = {
+      Hash => ->(data) { data.each_value(&FREEZE_ENUMS) },
+      Array => ->(data) { data.each(&FREEZE_ENUMS) }
+    }.freeze
+
+    FREEZE_ENUMS = ->(value) { call(value) if value.is_a?(Enumerable) }
+
+    def self.call(data)
+      data.freeze
+      FREEZES.fetch(data.class).call(data)
+      data
+    end
+  end
+end

data/lib/jat.rb

@@ -1,186 +1,108 @@
 # frozen_string_literal: true
 
-require 'jat/attributes'
-require 'jat/config'
-require 'jat/error'
-require 'jat/map'
-require 'jat/map/construct'
-require 'jat/opts'
-require 'jat/preloads'
-require 'jat/preload_handler'
-require 'jat/response'
-require 'jat/utils/preloads_to_hash'
+require_relative "jat/attribute"
+require_relative "jat/presenter"
+require_relative "jat/config"
+require_relative "jat/plugins"
 
 # Main namespace
 class Jat
+  # A generic exception used by Jat.
+  class Error < StandardError; end
+
+  @config = Config.new
+
   module ClassMethods
+    attr_reader :config
+
     def inherited(subclass)
-      subclass.extend DSLClassMethods
-      subclass.include DSLInstanceMethods
-      copy_to(subclass)
+      # Initialize config
+      config_class = Class.new(self::Config)
+      config_class.jat_class = subclass
+      subclass.const_set(:Config, config_class)
+      subclass.instance_variable_set(:@config, subclass::Config.new(config.opts))
+
+      # Initialize attribute class
+      attribute_class = Class.new(self::Attribute)
+      attribute_class.jat_class = subclass
+      subclass.const_set(:Attribute, attribute_class)
+
+      # Initialize object presenter
+      presenter_class = Class.new(self::Presenter)
+      presenter_class.jat_class = subclass
+      subclass.const_set(:Presenter, presenter_class)
+
+      # Assign same attributes
+      attributes.each_value do |attribute|
+        params = attribute.params
+        subclass.attribute(params[:name], **params[:opts], &params[:block])
+      end
 
       super
     end
 
-    def config
-      @config ||= Config.new(self)
-    end
+    def plugin(plugin, **opts)
+      if !plugin.is_a?(Symbol) && !plugin.is_a?(Module)
+        raise Error, "Plugin class must be a Symbol or a Module, #{plugin.inspect} given"
+      end
 
-    def config=(config)
-      @config = config
-    end
+      plugin = Plugins.load_plugin(plugin) if plugin.is_a?(Symbol)
 
-    def attributes
-      @attributes ||= Attributes.new
-    end
+      Plugins.before_load(plugin, self, **opts)
 
-    # Used to validate provided params (fields, include)
-    def full_map
-      @full_map ||= Map::Construct.new(self, :all).to_h
-    end
+      include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
+      extend(plugin::ClassMethods) if defined?(plugin::ClassMethods)
 
-    def exposed_map
-      @exposed_map ||= Map::Construct.new(self, :exposed).to_h
-    end
+      self::Attribute.include plugin::AttributeMethods if defined?(plugin::AttributeMethods)
+      self::Attribute.extend plugin::AttributeClassMethods if defined?(plugin::AttributeClassMethods)
 
-    def clear
-      @full_map = nil
-      @exposed_map = nil
-    end
+      self::Config.include plugin::ConfigMethods if defined?(plugin::ConfigMethods)
+      self::Config.extend plugin::ConfigClassMethods if defined?(plugin::ConfigClassMethods)
 
-    def refresh
-      attributes.refresh
-      clear
-    end
+      self::Presenter.include plugin::PresenterMethods if defined?(plugin::PresenterMethods)
+      self::Presenter.extend plugin::PresenterClassMethods if defined?(plugin::PresenterClassMethods)
 
-    def copy_to(subclass)
-      subclass.type(@type) if defined?(@type)
-      config.copy_to(subclass)
-      attributes.copy_to(subclass)
+      Plugins.after_load(plugin, self, **opts)
+      plugin
     end
-  end
 
-  module DSLClassMethods
     def call
       self
     end
 
-    def to_h(object, context = {})
-      new.to_h(object, context)
-    end
-
-    def to_str(object, context = {})
-      new.to_str(object, context)
-    end
-
-    def type(new_type = nil)
-      return @type || raise(Error, "#{self} has no defined type") unless new_type
-
-      new_type = new_type.to_sym
-      define_method(:type) { new_type }
-      @type = new_type
+    def to_h(object, context = nil)
+      new(object, context || {}).to_h
     end
 
-    def id(key: nil, &block)
-      raise Error, "Key and block can't be provided together" if key && block
-      raise Error, 'Key or block must be provided' if !key && !block
-
-      block ||= proc { |obj| obj.public_send(key) }
-      define_method(:id, &block)
+    def attributes
+      @attributes ||= {}
     end
 
     def attribute(name, **opts, &block)
-      add_attribute(name: name, opts: opts, block: block)
-    end
-
-    def relationship(name, serializer:, **opts, &block)
-      opts[:serializer] = serializer
-      add_attribute(name: name, opts: opts, block: block)
-    end
-
-    private
-
-    def add_attribute(params)
-      opts = Opts.new(self, params)
-
-      Attribute.new(opts).tap do |attribute|
-        attributes << attribute
-        add_method(attribute)
-        clear
-      end
-    end
-
-    def add_method(attribute)
-      block = attribute.block
-      return unless block
-
-      name = attribute.original_name
-      # Warning-free method redefinition
-      remove_method(name) if method_defined?(name)
-      define_method(name, &block)
+      new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+      attributes[new_attr.name] = new_attr
+      self::Presenter.add_method(new_attr.original_name, new_attr.block)
+      new_attr
     end
   end
 
-  # :reek:ModuleInitialize
-  module DSLInstanceMethods
-    attr_reader :_context
-
-    def initialize(context = {}, full_map = nil)
-      @_context = context.dup
-      @_full_map = full_map
-    end
-
-    def to_h(object, context = {})
-      _reinitialize(context)
-
-      Response.new(self, object).to_h
-    end
-
-    def to_str(object, context = {})
-      _reinitialize(context)
-      Response.new(self, object).to_str
-    end
+  module InstanceMethods
+    attr_reader :object, :context
 
-    def id(object)
-      object.id
+    def initialize(object, context)
+      @object = object
+      @context = context
     end
 
-    def _preloads
-      Preloads.new(_full_map).for(self.class)
+    def to_h
+      raise Error, "Method #to_h must be implemented by plugin"
     end
 
-    def _copy_to(nested_serializer)
-      nested_serializer.().new(_context, _full_map)
-    end
-
-    def _full_map
-      @_full_map ||= begin
-        params = _context[:params]
-        fields = params && (params[:fields] || params['fields'])
-        includes = params && (params[:include] || params['include'])
-        Map.(self.class, fields, includes)
-      end
-    end
-
-    def _map
-      @_map ||= _full_map.fetch(type)
-    end
-
-    private
-
-    def _reinitialize(context)
-      new_params = context[:params]
-      old_params = _context[:params]
-
-      # maps depend on params, so we should clear them when params changed
-      if new_params != old_params
-        @_full_map = nil
-        @_map = nil
-      end
-
-      @_context = _context.merge!(context)
+    def config
+      self.class.config
     end
   end
 
   extend ClassMethods
+  include InstanceMethods
 end