jat 0.0.3 → 0.0.8

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

@@ -1,65 +1,125 @@
 # frozen_string_literal: true
 
+require_relative "./lib/fields_param_parser"
 require_relative "./lib/map"
 require_relative "./lib/response"
+require_relative "./lib/response_piece"
 
-# Serializes to JSON-API format
 class Jat
   module Plugins
     module SimpleApi
-      DEFAULT_META_KEY = :meta
+      def self.plugin_name
+        :simple_api
+      end
+
+      def self.before_load(jat_class, **_opts)
+        response_plugin = jat_class.config[:response_plugin_loaded]
+        return unless response_plugin
+
+        raise Error, "Response plugin `#{response_plugin}` was already loaded before"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+        jat_class.extend(ClassMethods)
+      end
+
+      def self.after_load(jat_class, **_opts)
+        jat_class.config[:response_plugin_loaded] = plugin_name
+
+        jat_class.meta_key(:meta)
+
+        fields_parser_class = Class.new(FieldsParamParser)
+        fields_parser_class.jat_class = jat_class
+        jat_class.const_set(:FieldsParamParser, fields_parser_class)
+
+        map_class = Class.new(Map)
+        map_class.jat_class = jat_class
+        jat_class.const_set(:Map, map_class)
+
+        response_class = Class.new(Response)
+        response_class.jat_class = jat_class
+        jat_class.const_set(:Response, response_class)
 
-      def self.after_load(jat_class, **opts)
-        jat_class.plugin(:_json_api_activerecord, **opts) if opts[:activerecord]
+        response_piece_class = Class.new(ResponsePiece)
+        response_piece_class.jat_class = jat_class
+        jat_class.const_set(:ResponsePiece, response_piece_class)
       end
 
       module InstanceMethods
-        def to_h
-          Response.new(self).response
+        def to_h(object)
+          self.class::Response.call(object, context)
         end
 
-        def traversal_map
-          @traversal_map ||= Map.call(self)
+        def map
+          @map ||= self.class.map(context)
         end
       end
 
       module ClassMethods
         def inherited(subclass)
-          subclass.root(@root) if defined?(@root)
-
           super
+
+          fields_parser_class = Class.new(self::FieldsParamParser)
+          fields_parser_class.jat_class = subclass
+          subclass.const_set(:FieldsParamParser, fields_parser_class)
+
+          map_class = Class.new(self::Map)
+          map_class.jat_class = subclass
+          subclass.const_set(:Map, map_class)
+
+          response_class = Class.new(self::Response)
+          response_class.jat_class = subclass
+          subclass.const_set(:Response, response_class)
+
+          response_piece_class = Class.new(self::ResponsePiece)
+          response_piece_class.jat_class = subclass
+          subclass.const_set(:ResponsePiece, response_piece_class)
+
+          # Assign same meta
+          added_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.meta(params[:name], **params[:opts], &params[:block])
+          end
         end
 
-        def root(new_root = nil)
-          return (defined?(@root) && @root) unless new_root
+        def root(default = nil, one: nil, many: nil)
+          root_one = one || default
+          root_many = many || default
+
+          config[:root_one] = root_one ? root_one.to_sym : nil
+          config[:root_many] = root_many ? root_many.to_sym : nil
 
-          new_root = new_root.to_sym
-          @root = new_root
+          {root_one: root_one, root_many: root_many}
         end
 
-        def root_for_one(new_root_for_one = nil)
-          return (defined?(@root_for_one) && @root_for_one) unless new_root_for_one
+        def meta_key(new_meta_key)
+          config[:meta_key] = new_meta_key.to_sym
+        end
 
-          new_root_for_one = new_root_for_one.to_sym
-          @root_for_one = new_root_for_one
+        def added_meta
+          @added_meta ||= {}
         end
 
-        def root_for_many(new_root_for_many = nil)
-          return (defined?(@root_for_many) && @root_for_many) unless new_root_for_many
+        def meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_meta[new_attr.name] = new_attr
+        end
 
-          new_root_for_many = new_root_for_many.to_sym
-          @root_for_many = new_root_for_many
+        def map(context)
+          self::Map.call(context)
         end
 
-        def meta_key(new_meta_key = nil)
-          return ((defined?(@meta_key) && @meta_key) || DEFAULT_META_KEY) unless new_meta_key
+        def map_full
+          @map_full ||= self::Map.call(exposed: :all)
+        end
 
-          new_meta_key = new_meta_key.to_sym
-          @meta_key = new_meta_key
+        def map_exposed
+          @map_exposed ||= self::Map.call(exposed: :default)
         end
       end
     end
 
-    register_plugin(:simple_api, SimpleApi)
+    register_plugin(SimpleApi.plugin_name, SimpleApi)
   end
 end

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

@@ -3,19 +3,29 @@
 class Jat
   module Plugins
     module ToStr
+      def self.plugin_name
+        :to_str
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+        jat_class.extend(ClassMethods)
+      end
+
       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
+        def to_str(object, context = nil)
+          new(context || FROZEN_EMPTY_HASH).to_str(object)
         end
       end
 
       module InstanceMethods
-        def to_str
-          config[:to_str].call(to_h)
+        def to_str(object)
+          hash = to_h(object)
+          config[:to_str].call(hash)
         end
       end
 
@@ -39,6 +49,6 @@ class Jat
       end
     end
 
-    register_plugin(:to_str, ToStr)
+    register_plugin(ToStr.plugin_name, ToStr)
   end
 end

data/lib/jat/plugins/types/types.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module Types
+      def self.plugin_name
+        :types
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Attribute.include(InstanceMethods)
+      end
+
+      def self.after_load(jat_class, **_opts)
+        jat_class.config[:types] = {
+          array: ->(value) { Array(value) },
+          bool: ->(value) { !!value },
+          float: ->(value) { Float(value) },
+          hash: ->(value) { Hash(value) },
+          int: ->(value) { Integer(value) },
+          str: ->(value) { String(value) }
+        }
+      end
+
+      module InstanceMethods
+        def block
+          return @block if instance_variable_defined?(:@block)
+
+          original_block = super
+          type = opts[:type]
+          return original_block unless type
+
+          @block = typed_block(type, original_block)
+        end
+
+        private
+
+        def typed_block(type, original_block)
+          proc do |object, context|
+            value = original_block.call(object, context)
+
+            # Type conversion
+            case type
+            when Symbol then self.class.jat_class.config.fetch(:types).fetch(type).call(value)
+            else type.call(value)
+            end
+          end
+        end
+      end
+    end
+
+    register_plugin(Types.plugin_name, Types)
+  end
+end

data/lib/jat/plugins/validate_params/validate_params.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module ValidateParams
+      def self.plugin_name
+        :validate_params
+      end
+
+      def self.load(jat_class, **opts)
+        if jat_class.plugin_used?(:json_api)
+          jat_class.plugin :json_api_validate_params, **opts
+        elsif jat_class.plugin_used?(:simple_api)
+          jat_class.plugin :simple_api_validate_params, **opts
+        else
+          raise Error, "Please load :json_api or :simple_api plugin first"
+        end
+      end
+    end
+
+    register_plugin(ValidateParams.plugin_name, ValidateParams)
+  end
+end

data/lib/jat/plugins.rb

@@ -1,39 +1,51 @@
 # frozen_string_literal: true
 
 class Jat
+  class PluginLoadError < Error; end
+
   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)
+    class << self
+      # Registers given plugin to be able to load it using symbol name.
+      #
+      # Example: Jat::Plugins.register_plugin(:plugin_name, PluginModule)
+      def register_plugin(name, mod)
+        @plugins[name] = mod
+      end
+
+      # If the registered plugin already exists, use it. Otherwise, require
+      # 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 find_plugin(name)
+        return name if name.is_a?(Module)
+        return @plugins[name] if @plugins.key?(name)
+
+        begin
+          require_plugin(name)
+        rescue PluginLoadError
+          if name.start_with?("json_api")
+            require_plugin(name, "/json_api/plugins")
+          elsif name.start_with?("simple_api")
+            require_plugin(name, "/simple_api/plugins")
+          elsif name.start_with?("base")
+            require_plugin(name, "/base")
+          else
+            raise
+          end
+        end
+
+        @plugins[name] || raise(PluginLoadError, "Plugin '#{name}' did not register itself correctly")
+      end
+
+      private
+
+      def require_plugin(name, prefix = nil)
+        require "jat/plugins#{prefix}/#{name}/#{name}"
+      rescue LoadError
+        raise PluginLoadError, "Plugin '#{name}' does not exist"
+      end
     end
   end
 end

data/lib/jat.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
-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
+  FROZEN_EMPTY_HASH = {}.freeze
+  FROZEN_EMPTY_ARRAY = [].freeze
+end
+
+require_relative "jat/attribute"
+require_relative "jat/config"
+require_relative "jat/plugins"
+
+class Jat
+  @config = Config.new({plugins: []})
 
   module ClassMethods
     attr_reader :config
@@ -27,11 +31,6 @@ class Jat
       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
@@ -41,29 +40,34 @@ class Jat
       super
     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 plugin(name, **opts)
+      return if plugin_used?(name)
 
-      plugin = Plugins.load_plugin(plugin) if plugin.is_a?(Symbol)
+      plugin = Plugins.find_plugin(name)
 
-      Plugins.before_load(plugin, self, **opts)
+      # We split loading of plugin to three methods - before_load, load, after_load:
+      #
+      # - **before_load** usually used to check requirements and to load additional plugins
+      # - **load** usually used to include plugin modules
+      # - **after_load** usually used to add config options
+      plugin.before_load(self, **opts) if plugin.respond_to?(:before_load)
+      plugin.load(self, **opts) if plugin.respond_to?(:load)
+      plugin.after_load(self, **opts) if plugin.respond_to?(:after_load)
 
-      include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
-      extend(plugin::ClassMethods) if defined?(plugin::ClassMethods)
+      # Store attached plugins, so we can check it is loaded later
+      config[:plugins] << (plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin)
 
-      self::Attribute.include plugin::AttributeMethods if defined?(plugin::AttributeMethods)
-      self::Attribute.extend plugin::AttributeClassMethods if defined?(plugin::AttributeClassMethods)
-
-      self::Config.include plugin::ConfigMethods if defined?(plugin::ConfigMethods)
-      self::Config.extend plugin::ConfigClassMethods if defined?(plugin::ConfigClassMethods)
+      plugin
+    end
 
-      self::Presenter.include plugin::PresenterMethods if defined?(plugin::PresenterMethods)
-      self::Presenter.extend plugin::PresenterClassMethods if defined?(plugin::PresenterClassMethods)
+    def plugin_used?(plugin)
+      plugin_name =
+        case plugin
+        when Module then plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin
+        else plugin
+        end
 
-      Plugins.after_load(plugin, self, **opts)
-      plugin
+      config[:plugins].include?(plugin_name)
     end
 
     def call
@@ -71,7 +75,7 @@ class Jat
     end
 
     def to_h(object, context = nil)
-      new(object, context || {}).to_h
+      new(context || {}).to_h(object)
     end
 
     def attributes
@@ -81,20 +85,21 @@ class Jat
     def attribute(name, **opts, &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
+
+    def relationship(name, serializer:, **opts, &block)
+      attribute(name, serializer: serializer, **opts, &block)
     end
   end
 
   module InstanceMethods
-    attr_reader :object, :context
+    attr_reader :context
 
-    def initialize(object, context)
-      @object = object
+    def initialize(context = {})
       @context = context
     end
 
-    def to_h
+    def to_h(_object)
       raise Error, "Method #to_h must be implemented by plugin"
     end
 

data/test/lib/jat/attribute_test.rb

@@ -127,16 +127,34 @@ describe Jat::Attribute do
 
   describe "#block" do
     it "returns provided block" do
-      block = -> {}
+      block = proc { |object, context| [object, context] }
       attribute = attribute_class.new(name: "foo", block: block)
-      assert_equal block, attribute.block
+      assert_equal ["OBJECT", "CONTEXT"], attribute.value("OBJECT", "CONTEXT")
+    end
+
+    it "returns provided block when block was without params" do
+      block = proc { "RESULT" }
+      attribute = attribute_class.new(name: "foo", block: block)
+      assert_equal "RESULT", attribute.value("OBJECT", "CONTEXT")
+    end
+
+    it "returns provided block when block was with one param" do
+      block = proc { |object| object }
+      attribute = attribute_class.new(name: "foo", block: block)
+      assert_equal "OBJECT", attribute.value("OBJECT", "CONTEXT")
     end
 
     it "constructs block that calls current key method on object" do
       attribute = attribute_class.new(name: "foo", opts: {key: :length})
-      presenter = jat_class::Presenter.new([1, 2, 3], {})
+      assert_equal 3, attribute.value([1, 2, 3], nil)
+    end
 
-      assert_equal 3, presenter.instance_exec(&attribute.block)
+    it "raises error if provide block with more than 2 params" do
+      jat_class.attribute(:foo) {}
+      jat_class.attribute(:foo) { |_| }
+      jat_class.attribute(:foo) { |_, _| }
+      err = assert_raises(Jat::Error) { jat_class.attribute(:foo) { |_, _, _| } }
+      assert_equal "Block can have 0-2 parameters", err.message
     end
   end
 end

data/test/lib/jat/plugins/activerecord/activerecord_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Activerecord" do
+  it "raises error if no response plugin is loaded" do
+    new_class = Class.new(Jat)
+    err = assert_raises(Jat::Error) { new_class.plugin :activerecord }
+    assert_equal "Please load :json_api or :simple_api plugin first", err.message
+  end
+
+  it "loads simple_api compatible plugin" do
+    new_class = Class.new(Jat)
+    new_class.plugin :simple_api
+    new_class.plugin :activerecord
+
+    assert new_class.plugin_used?(:simple_api_activerecord)
+  end
+
+  it "loads json_api compatible plugin" do
+    new_class = Class.new(Jat)
+    new_class.plugin :json_api
+    new_class.plugin :activerecord
+
+    assert new_class.plugin_used?(:json_api_activerecord)
+  end
+end

data/test/lib/jat/plugins/base_activerecord_preloads/base_activerecord_preloads_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::BaseActiverecordPreloads" do
+  let(:jat_class) do
+    api_test = api_test()
+
+    Class.new(Jat) do
+      include api_test
+      plugin(:base_activerecord_preloads)
+    end
+  end
+
+  let(:api_test) do
+    Module.new do
+      def to_h(object)
+        object
+      end
+    end
+  end
+
+  describe "InstanceMethods" do
+    it "adds preloads to object when calling to_h" do
+      object = "OBJ"
+      preloads = "PRELOADS"
+      jat = jat_class.new
+      jat.expects(:preloads).returns(preloads)
+
+      Jat::Plugins::BaseActiverecordPreloads::Preloader
+        .expects(:preload)
+        .with(object, preloads).returns("OBJ_WITH_PRELOADS")
+
+      assert_equal("OBJ_WITH_PRELOADS", jat.to_h(object))
+    end
+
+    it "skips preloadings for nil" do
+      object = nil
+      jat = jat_class.new
+
+      assert_same object, jat.to_h(object)
+    end
+
+    it "skips preloadings for empty array" do
+      object = []
+      jat = jat_class.new
+
+      assert_same object, jat.to_h(object)
+    end
+
+    it "skips preloadings when nothing to preload" do
+      object = "OBJECT"
+      jat = jat_class.new
+      jat.expects(:preloads).returns({})
+
+      assert_same object, jat.to_h(object)
+    end
+  end
+end

data/test/lib/jat/plugins/{_activerecord_preloads → base_activerecord_preloads}/lib/preloader_test.rb

@@ -4,11 +4,11 @@ require "test_helper"
 require "support/activerecord"
 
 describe "Jat::Plugins::ActiverecordPreloads" do
-  before { Jat::Plugins.load_plugin(:_activerecord_preloads) }
+  before { Jat::Plugins.find_plugin(:base_activerecord_preloads) }
 
   describe "Preloader" do
     let(:described_class) { plugin::Preloader }
-    let(:plugin) { Jat::Plugins::ActiverecordPreloads }
+    let(:plugin) { Jat::Plugins::BaseActiverecordPreloads }
 
     describe ".handlers" do
       it "returns memorized array of handlers" do
@@ -52,18 +52,17 @@ describe "Jat::Plugins::ActiverecordPreloads" do
         assert_equal true, user.association(:comments).loaded?
       end
 
-      it "resets activerecord object preloaded relations" do
+      it "preloads data to activerecord array" do
         user = AR::User.create!
-        comment = user.comments.create!
-        user.comments.to_a && comment.delete # preload comments manually and delete comment
 
-        described_class.preload(user, {comments: {}})
+        users = [user]
+        result = described_class.preload(users, {comments: {}})
 
-        assert_equal true, user.association(:comments).loaded?
-        assert_equal [], user.comments
+        assert_same result, users
+        assert_equal true, result[0].association(:comments).loaded?
       end
 
-      it "preloads data to activerecord relation object" do
+      it "preloads data to activerecord relation" do
         user = AR::User.create!
 
         result = described_class.preload(AR::User.where(id: user.id), {comments: {}})
@@ -72,26 +71,13 @@ describe "Jat::Plugins::ActiverecordPreloads" do
         assert_equal true, result[0].association(:comments).loaded?
       end
 
-      it "preloads data to activerecord array" do
+      it "preloads data to loaded activerecord relation" do
         user = AR::User.create!
 
-        users = [user]
-        result = described_class.preload(users, {comments: {}})
-
-        assert_same result, users
-        assert_equal true, result[0].association(:comments).loaded?
-      end
-
-      it "resets activerecord array preloaded relations" do
-        user = AR::User.create!
-        comment = user.comments.create!
-        user.comments.to_a && comment.delete # preload comments manually and delete comment
-
-        users = [user]
-        result = described_class.preload(users, {comments: {}})
+        result = described_class.preload(AR::User.where(id: user.id).load, {comments: {}})
 
+        assert_equal result, [user]
         assert_equal true, result[0].association(:comments).loaded?
-        assert_equal [], result[0].comments
       end
     end
   end