jat 0.0.3 → 0.0.5

data/lib/jat/plugins/simple_api_maps_cache/simple_api_maps_cache.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiMapsCache
+      def self.before_load(jat_class, **_opts)
+        return if jat_class.plugin_used?(:simple_api)
+
+        raise Error, "Please load :simple_api plugin first"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Map.extend(MapsCacheClassMethods)
+      end
+
+      def self.after_load(jat_class, **opts)
+        jat_class.config[:cached_maps_count] = opts[:cached_maps_count] || 100
+      end
+
+      module MapsCacheClassMethods
+        # Caches up to `:cached_maps_count` maps for each serializer.
+        # Removes earliest value if new value exceeds limit.
+        def maps_cache
+          @maps_cache ||= Hash.new do |cache, cache_key|
+            cache.shift if cache.length >= jat_class.config[:cached_maps_count] # protect from memory leak
+            cache[cache_key] = EnumDeepFreeze.call(yield)
+          end
+        end
+
+        private
+
+        def construct_map(exposed, fields)
+          cache = maps_cache { super }
+          cache_key = cache_key(exposed, fields)
+          cache[cache_key]
+        end
+
+        def cache_key(exposed, fields)
+          key = "exposed:#{exposed}:"
+          key += "fields:#{fields}:" if fields
+          key
+        end
+      end
+    end
+
+    register_plugin(:simple_api_maps_cache, SimpleApiMapsCache)
+  end
+end

data/lib/jat/plugins/simple_api_validate_params/lib/fields_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Jat
+  class SimpleApiFieldsError < Error
+  end
+end

data/lib/jat/plugins/simple_api_validate_params/lib/validate_fields_param.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiValidateParams
+      class ValidateFieldsParam
+        class << self
+          def call(jat_class, fields, prev_names = [])
+            fields.each do |name, nested_fields|
+              attribute = jat_class.attributes[name]
+
+              raise_error(name, prev_names) unless attribute
+              next if nested_fields.empty?
+
+              raise_nested_error(name, prev_names, nested_fields) unless attribute.relation?
+              nested_serializer = attribute.serializer.call
+              call(nested_serializer, nested_fields, prev_names + [name])
+            end
+          end
+
+          private
+
+          def raise_error(name, prev_names)
+            field_name = field_name(name, prev_names)
+
+            raise SimpleApiFieldsError, "Field #{field_name} not exists"
+          end
+
+          def raise_nested_error(name, prev_names, nested_fields)
+            field_name = field_name(name, prev_names)
+            first_nested = nested_fields.keys.first
+
+            raise SimpleApiFieldsError, "Field #{field_name} is not a relationship to add '#{first_nested}' attribute"
+          end
+
+          def field_name(name, prev_names)
+            res = "'#{name}'"
+            res += " ('#{prev_names.join(".")}.#{name}')" if prev_names.any?
+            res
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/simple_api_validate_params/simple_api_validate_params.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "./lib/fields_error"
+require_relative "./lib/validate_fields_param"
+
+class Jat
+  module Plugins
+    module SimpleApiValidateParams
+      def self.before_load(jat_class, **_opts)
+        return if jat_class.plugin_used?(:simple_api)
+        raise Error, "Please load :simple_api plugin first"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.extend(ClassMethods)
+        jat_class.include(InstanceMethods)
+
+        jat_class::FieldsParamParser.include(FieldsParamParserMethods)
+      end
+
+      module InstanceMethods
+        def validate
+          @validate ||= self.class.validate(context)
+        end
+      end
+
+      module ClassMethods
+        def validate(context)
+          # Generate map for current context.
+          # Params are valid if no errors were raised
+          map(context)
+          true
+        end
+      end
+
+      module FieldsParamParserMethods
+        def parse
+          super.tap { |result| ValidateFieldsParam.call(self.class.jat_class, result) }
+        end
+      end
+    end
+
+    register_plugin(:simple_api_validate_params, SimpleApiValidateParams)
+  end
+end

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

@@ -3,19 +3,25 @@
 class Jat
   module Plugins
     module ToStr
+      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
 

data/lib/jat/plugins.rb

@@ -12,28 +12,15 @@ class Jat
       @plugins[name] = mod
     end
 
-    # If the registered plugin already exists, use it. Otherwise, require it
+    # 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 self.load_plugin(name)
+    def self.find_plugin(name)
+      return name if name.is_a?(Module)
       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.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
 require_relative "jat/attribute"
-require_relative "jat/presenter"
 require_relative "jat/config"
 require_relative "jat/plugins"
 
 # Main namespace
 class Jat
+  FROZEN_EMPTY_HASH = {}.freeze
+  FROZEN_EMPTY_ARRAY = [].freeze
+
   # A generic exception used by Jat.
   class Error < StandardError; end
 
-  @config = Config.new
+  @config = Config.new({plugins: []})
 
   module ClassMethods
     attr_reader :config
@@ -27,11 +29,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,37 +38,37 @@ 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
-
-      plugin = Plugins.load_plugin(plugin) if plugin.is_a?(Symbol)
+    def plugin(name, **opts)
+      return if plugin_used?(name)
 
-      Plugins.before_load(plugin, self, **opts)
+      plugin = Plugins.find_plugin(name)
 
-      include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
-      extend(plugin::ClassMethods) if defined?(plugin::ClassMethods)
+      # Before load usually used to check plugin can be attached or to load additional plugins
+      plugin.before_load(self, **opts) if plugin.respond_to?(:before_load)
 
-      self::Attribute.include plugin::AttributeMethods if defined?(plugin::AttributeMethods)
-      self::Attribute.extend plugin::AttributeClassMethods if defined?(plugin::AttributeClassMethods)
+      # Usually used to include/extend plugin modules
+      plugin.load(self, **opts) if plugin.respond_to?(:load)
 
-      self::Config.include plugin::ConfigMethods if defined?(plugin::ConfigMethods)
-      self::Config.extend plugin::ConfigClassMethods if defined?(plugin::ConfigClassMethods)
+      # Store attached plugins, so we can check them later
+      config[:plugins] << plugin
 
-      self::Presenter.include plugin::PresenterMethods if defined?(plugin::PresenterMethods)
-      self::Presenter.extend plugin::PresenterClassMethods if defined?(plugin::PresenterClassMethods)
+      # Set some config options for current plugin or load additional plugins
+      plugin.after_load(self, **opts) if plugin.respond_to?(:after_load)
 
-      Plugins.after_load(plugin, self, **opts)
       plugin
     end
 
+    def plugin_used?(name)
+      plugin = Plugins.find_plugin(name)
+      config[:plugins].include?(plugin)
+    end
+
     def call
       self
     end
 
     def to_h(object, context = nil)
-      new(object, context || {}).to_h
+      new(context || {}).to_h(object)
     end
 
     def attributes
@@ -81,20 +78,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,26 @@ 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, presenter.instance_exec(&attribute.block)
+      assert_equal 3, attribute.value([1, 2, 3], nil)
     end
   end
 end

data/test/lib/jat/plugins/_activerecord_preloads/_activerecord_preloads_test.rb

@@ -3,38 +3,57 @@
 require "test_helper"
 
 describe "Jat::Plugins::ActiverecordPreloads" do
-  let(:jat_class) { Class.new(Jat) { plugin(:_activerecord_preloads) } }
-  let(:preloader) { Jat::Plugins::ActiverecordPreloads::Preloader }
+  let(:jat_class) do
+    api_test = api_test()
+
+    Class.new(Jat) do
+      include api_test
+      plugin(:_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 in initialize call" do
-      obj = "OBJ"
+    it "adds preloads to object when calling to_h" do
+      object = "OBJ"
       preloads = "PRELOADS"
-      jat_class.expects(:jat_preloads).with(kind_of(jat_class)).returns(preloads)
-      preloader.expects(:preload).with(obj, preloads).returns("OBJ_WITH_PRELOADS")
+      jat = jat_class.new
+      jat.expects(:preloads).returns(preloads)
+
+      Jat::Plugins::ActiverecordPreloads::Preloader
+        .expects(:preload)
+        .with(object, preloads).returns("OBJ_WITH_PRELOADS")
 
-      jat = jat_class.new(obj, {})
-      assert_equal("OBJ_WITH_PRELOADS", jat.object)
+      assert_equal("OBJ_WITH_PRELOADS", jat.to_h(object))
     end
 
     it "skips preloadings for nil" do
       object = nil
-      jat = jat_class.new(object, {})
-      assert_same object, jat.object
+      jat = jat_class.new
+
+      assert_same object, jat.to_h(object)
     end
 
     it "skips preloadings for empty array" do
       object = []
-      jat = jat_class.new(object, {})
-      assert_same object, jat.object
+      jat = jat_class.new
+
+      assert_same object, jat.to_h(object)
     end
 
     it "skips preloadings when nothing to preload" do
       object = "OBJECT"
-      jat_class.expects(:jat_preloads).with(kind_of(jat_class)).returns({})
+      jat = jat_class.new
+      jat.expects(:preloads).returns({})
 
-      jat = jat_class.new(object, {})
-      assert_same object, jat.object
+      assert_same object, jat.to_h(object)
     end
   end
 end

data/test/lib/jat/plugins/_activerecord_preloads/lib/preloader_test.rb

@@ -4,7 +4,7 @@ require "test_helper"
 require "support/activerecord"
 
 describe "Jat::Plugins::ActiverecordPreloads" do
-  before { Jat::Plugins.load_plugin(:_activerecord_preloads) }
+  before { Jat::Plugins.find_plugin(:_activerecord_preloads) }
 
   describe "Preloader" do
     let(:described_class) { plugin::Preloader }
@@ -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

data/test/lib/jat/plugins/_camel_lower/_camel_lower_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::LowerCamelCase" do
+  let(:jat_class) do
+    new_class = Class.new(Jat)
+    new_class.plugin(:_lower_camel_case)
+    new_class
+  end
+
+  describe "Attribute" do
+    describe "#name" do
+      it "returns name in lower_camel_case case" do
+        attribute = jat_class.attribute(:foo)
+        assert :foo, attribute.name
+
+        attribute = jat_class.attribute(:foo_bar)
+        assert :fooBar, attribute.name
+
+        attribute = jat_class.attribute(:foo_bar_bazz)
+        assert :fooBarBazz, attribute.name
+      end
+    end
+  end
+end

data/test/lib/jat/plugins/_preloads/lib/format_user_preloads_test.rb

@@ -3,7 +3,7 @@
 require "test_helper"
 
 describe "Jat::Plugins::Preloads::FormatUserPreloads" do
-  before { Jat::Plugins.load_plugin(:_preloads) }
+  before { Jat::Plugins.find_plugin(:_preloads) }
 
   let(:format) { Jat::Plugins::Preloads::FormatUserPreloads }
 

data/test/lib/jat/plugins/_preloads/lib/preloads_with_path_test.rb

@@ -3,7 +3,7 @@
 require "test_helper"
 
 describe "Jat::Plugins::Preloads::PreloadsWithPath" do
-  before { Jat::Plugins.load_plugin(:_preloads) }
+  before { Jat::Plugins.find_plugin(:_preloads) }
 
   let(:described_class) { Jat::Plugins::Preloads::PreloadsWithPath }
 

data/test/lib/jat/plugins/cache/cache_test.rb

@@ -6,7 +6,7 @@ describe "Jat::Plugins::Cache" do
   let(:jat_class) do
     new_class = Class.new(Jat)
     to_h_mod = Module.new do
-      def to_h
+      def to_h(object)
         "RES_#{object}"
       end
     end
@@ -28,8 +28,8 @@ describe "Jat::Plugins::Cache" do
   describe "InstanceMethods" do
     describe "#to_h" do
       it "takes result from cache" do
-        result1 = jat_class.new("OBJECT", context).to_h
-        result2 = jat_class.new("OBJECT", context).to_h
+        result1 = jat_class.new(context).to_h("OBJECT")
+        result2 = jat_class.new(context).to_h("OBJECT")
 
         assert_equal "RES_OBJECT", result1
         assert_equal "RES_OBJECT", result2
@@ -37,8 +37,8 @@ describe "Jat::Plugins::Cache" do
       end
 
       it "does not take cached result when cache keys are different" do
-        result1 = jat_class.new("OBJECT", context).to_h
-        result2 = jat_class.new("OBJECT", context.merge(foo: :bazz)).to_h
+        result1 = jat_class.new(context).to_h("OBJECT")
+        result2 = jat_class.new(context.merge(foo: :bazz)).to_h("OBJECT")
 
         assert_equal "RES_OBJECT", result1
         assert_equal "RES_OBJECT", result2
@@ -46,7 +46,7 @@ describe "Jat::Plugins::Cache" do
       end
 
       it "does not saves cache when no context[:cache] provided" do
-        jat_class.new("OBJECT", {}).to_str
+        jat_class.new({}).to_str("OBJECT")
 
         assert_equal [], hash_storage.keys
       end
@@ -54,8 +54,8 @@ describe "Jat::Plugins::Cache" do
 
     describe "#to_str" do
       it "takes result from cache" do
-        result1 = jat_class.new("OBJECT", context).to_str
-        result2 = jat_class.new("OBJECT", context).to_str
+        result1 = jat_class.new(context).to_str("OBJECT")
+        result2 = jat_class.new(context).to_str("OBJECT")
 
         assert_equal '"RES_OBJECT"', result1
         assert_equal '"RES_OBJECT"', result2
@@ -63,8 +63,8 @@ describe "Jat::Plugins::Cache" do
       end
 
       it "does not take cached result when cache keys are different" do
-        result1 = jat_class.new("OBJECT", context).to_str
-        result2 = jat_class.new("OBJECT", context.merge(foo: :bazz)).to_str
+        result1 = jat_class.new(context).to_str("OBJECT")
+        result2 = jat_class.new(context.merge(foo: :bazz)).to_str("OBJECT")
 
         assert_equal '"RES_OBJECT"', result1
         assert_equal '"RES_OBJECT"', result2
@@ -73,7 +73,7 @@ describe "Jat::Plugins::Cache" do
 
       it "does not saves cache for #to_h" do
         context[:foo] = :bar
-        jat_class.new("OBJECT", context).to_str
+        jat_class.new(context).to_str("OBJECT")
 
         assert_equal ["OBJECT.bar.to_str"], hash_storage.keys
       end