jat 0.0.5 → 0.0.9

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

@@ -18,7 +18,7 @@ class Jat
           def parse(fields)
             return FROZEN_EMPTY_HASH unless fields
 
-            new(fields).parse
+            new.parse(fields)
           end
         end
 
@@ -27,65 +27,49 @@ class Jat
           OPEN_BRACKET = "("
           CLOSE_BRACKET = ")"
 
-          def initialize(fields)
-            @fields = fields
-          end
-
           # user => { user: {} }
           # user(id) => { user: { id: {} } }
           # user(id,name) => { user: { id: {}, name: {} } }
           # user,comments => { user: {}, comments: {} }
           # user(comments(text)) => { user: { comments: { text: {} } } }
-          def parse
-            current_attr = nil
+          def parse(fields)
+            res = {}
+            attribute = +""
+            path_stack = nil
 
             fields.each_char do |char|
               case char
               when COMMA
-                next unless current_attr
-
-                add_attribute(current_attr)
-                current_attr = nil
+                add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
               when CLOSE_BRACKET
-                if current_attr
-                  add_attribute(current_attr)
-                  current_attr = nil
-                end
-
-                route.pop
+                add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
+                path_stack&.pop
               when OPEN_BRACKET
-                next unless current_attr
-
-                attribute_name = add_attribute(current_attr, {})
-                route << attribute_name
-                current_attr = nil
+                name = add_attribute(res, path_stack, attribute, {})
+                (path_stack ||= []).push(name) if name
               else
-                current_attr = current_attr ? current_attr.insert(-1, char) : char
+                attribute.insert(-1, char)
               end
             end
 
-            add_attribute(current_attr) if current_attr
+            add_attribute(res, path_stack, attribute, FROZEN_EMPTY_HASH)
 
             res
           end
 
           private
 
-          attr_reader :fields
+          def add_attribute(res, path_stack, attribute, nested_attributes = FROZEN_EMPTY_HASH)
+            attribute.strip!
+            return if attribute.empty?
 
-          def add_attribute(current_attr, nested_attrs = FROZEN_EMPTY_HASH)
-            current_resource = route.empty? ? res : res.dig(*route)
-            attribute_name = current_attr.strip.to_sym
-            current_resource[attribute_name] = nested_attrs
-            attribute_name
-          end
+            name = attribute.to_sym
+            attribute.clear
 
-          def res
-            @res ||= {}
-          end
+            current_attrs = !path_stack || path_stack.empty? ? res : res.dig(*path_stack)
+            current_attrs[name] = nested_attributes
 
-          def route
-            @route ||= []
+            name
           end
         end
 

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

@@ -74,11 +74,10 @@ class Jat
           private
 
           def expose?(attribute, fields)
-            case exposed
-            when :all then true
-            when :none then manually_exposed?(attribute, fields)
-            else attribute.exposed? || manually_exposed?(attribute, fields)
-            end
+            return true if exposed == :all
+            return manually_exposed?(attribute, fields) if exposed == :none
+
+            attribute.exposed? || manually_exposed?(attribute, fields)
           end
 
           def manually_exposed?(attribute, fields)

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

@@ -95,7 +95,7 @@ class Jat
             meta.each do |name, attribute|
               next if data.key?(name)
 
-              value = attribute_value(attribute)
+              value = attribute.value(object, context)
 
               unless value.nil?
                 data = data.dup if data.equal?(FROZEN_EMPTY_HASH)
@@ -109,10 +109,6 @@ class Jat
           def context_metadata
             context[:meta]&.transform_keys(&:to_sym) || FROZEN_EMPTY_HASH
           end
-
-          def attribute_value(attribute)
-            attribute.block.call(object, context)
-          end
         end
 
         extend ClassMethods

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

@@ -37,7 +37,7 @@ class Jat
 
             map.each do |key, inner_map|
               attribute = jat_class.attributes.fetch(key)
-              value = attribute_value(attribute)
+              value = attribute.value(object, context)
 
               result[key] =
                 if attribute.relation?
@@ -56,10 +56,6 @@ class Jat
 
           private
 
-          def attribute_value(attribute)
-            attribute.block.call(object, context)
-          end
-
           def inner_piece(attribute, value, inner_map)
             serializer = attribute.serializer.call
             serializer::ResponsePiece.to_h(value, context, inner_map)

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiActiverecord
+      def self.plugin_name
+        :simple_api_activerecord
+      end
+
+      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.plugin :simple_api_preloads, **opts
+        jat_class.plugin :base_activerecord_preloads, **opts
+      end
+    end
+
+    register_plugin(SimpleApiActiverecord.plugin_name, SimpleApiActiverecord)
+  end
+end

data/lib/jat/plugins/{simple_api_lower_camel_case → simple_api/plugins/simple_api_lower_camel_case}/simple_api_lower_camel_case.rb

@@ -3,10 +3,14 @@
 class Jat
   module Plugins
     module SimpleApiLowerCamelCase
+      def self.plugin_name
+        :simple_api_lower_camel_case
+      end
+
       def self.before_load(jat_class, **_opts)
         raise Error, "Please load :simple_api plugin first" unless jat_class.plugin_used?(:simple_api)
 
-        jat_class.plugin :_lower_camel_case
+        jat_class.plugin :base_lower_camel_case
       end
 
       def self.load(jat_class, **_opts)
@@ -25,6 +29,6 @@ class Jat
       end
     end
 
-    register_plugin(:simple_api_lower_camel_case, SimpleApiLowerCamelCase)
+    register_plugin(SimpleApiLowerCamelCase.plugin_name, SimpleApiLowerCamelCase)
   end
 end

data/lib/jat/plugins/{simple_api_maps_cache → simple_api/plugins/simple_api_maps_cache}/simple_api_maps_cache.rb

@@ -3,6 +3,10 @@
 class Jat
   module Plugins
     module SimpleApiMapsCache
+      def self.plugin_name
+        :simple_api_maps_cache
+      end
+
       def self.before_load(jat_class, **_opts)
         return if jat_class.plugin_used?(:simple_api)
 
@@ -36,13 +40,11 @@ class Jat
         end
 
         def cache_key(exposed, fields)
-          key = "exposed:#{exposed}:"
-          key += "fields:#{fields}:" if fields
-          key
+          "exposed:#{exposed}:fields:#{fields}:"
         end
       end
     end
 
-    register_plugin(:simple_api_maps_cache, SimpleApiMapsCache)
+    register_plugin(SimpleApiMapsCache.plugin_name, SimpleApiMapsCache)
   end
 end

data/lib/jat/plugins/{simple_api_activerecord → simple_api/plugins/simple_api_preloads}/lib/preloads.rb

@@ -2,7 +2,7 @@
 
 class Jat
   module Plugins
-    module SimpleApiActiverecord
+    module SimpleApiPreloads
       class Preloads
         module ClassMethods
           def call(jat)

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "./lib/preloads"
+
+class Jat
+  module Plugins
+    module SimpleApiPreloads
+      def self.plugin_name
+        :simple_api_preloads
+      end
+
+      def self.before_load(jat_class, **opts)
+        raise Error, "Please load :simple_api plugin first" unless jat_class.plugin_used?(:simple_api)
+
+        jat_class.plugin :base_preloads, **opts
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.extend(ClassMethods)
+        jat_class.include(InstanceMethods)
+      end
+
+      module ClassMethods
+        def preloads(context = {})
+          new(context).preloads
+        end
+      end
+
+      module InstanceMethods
+        def preloads
+          @preloads ||= Preloads.call(self)
+        end
+      end
+    end
+
+    register_plugin(SimpleApiPreloads.plugin_name, SimpleApiPreloads)
+  end
+end

data/lib/jat/plugins/{simple_api_validate_params → simple_api/plugins/simple_api_validate_params}/simple_api_validate_params.rb

@@ -6,6 +6,10 @@ require_relative "./lib/validate_fields_param"
 class Jat
   module Plugins
     module SimpleApiValidateParams
+      def self.plugin_name
+        :simple_api_validate_params
+      end
+
       def self.before_load(jat_class, **_opts)
         return if jat_class.plugin_used?(:simple_api)
         raise Error, "Please load :simple_api plugin first"
@@ -34,12 +38,12 @@ class Jat
       end
 
       module FieldsParamParserMethods
-        def parse
+        def parse(*)
           super.tap { |result| ValidateFieldsParam.call(self.class.jat_class, result) }
         end
       end
     end
 
-    register_plugin(:simple_api_validate_params, SimpleApiValidateParams)
+    register_plugin(SimpleApiValidateParams.plugin_name, SimpleApiValidateParams)
   end
 end

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

@@ -8,7 +8,9 @@ require_relative "./lib/response_piece"
 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]
@@ -22,11 +24,10 @@ class Jat
         jat_class.extend(ClassMethods)
       end
 
-      def self.after_load(jat_class, **opts)
-        jat_class.config[:response_plugin_loaded] = :simple_api
-        jat_class.plugin(:simple_api_activerecord, **opts) if opts[:activerecord]
+      def self.after_load(jat_class, **_opts)
+        jat_class.config[:response_plugin_loaded] = plugin_name
 
-        jat_class.meta_key(DEFAULT_META_KEY)
+        jat_class.meta_key(:meta)
 
         fields_parser_class = Class.new(FieldsParamParser)
         fields_parser_class.jat_class = jat_class
@@ -78,7 +79,7 @@ class Jat
           # Assign same meta
           added_meta.each_value do |attribute|
             params = attribute.params
-            subclass.attribute(params[:name], **params[:opts], &params[:block])
+            subclass.meta(params[:name], **params[:opts], &params[:block])
           end
         end
 
@@ -119,6 +120,6 @@ class Jat
       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,6 +3,10 @@
 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)
@@ -45,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,55 @@
+# 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
+            if type.is_a?(Symbol)
+              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,26 +1,52 @@
 # 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
+    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
+          name_str = name.to_s
+          if name_str.start_with?("json_api")
+            require_plugin(name, "/json_api/plugins")
+          elsif name_str.start_with?("simple_api")
+            require_plugin(name, "/simple_api/plugins")
+          elsif name_str.start_with?("base")
+            require_plugin(name, "/base")
+          else
+            raise
+          end
+        end
+
+        @plugins[name] || raise(PluginLoadError, "Plugin '#{name}' did not register itself correctly")
+      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 self.find_plugin(name)
-      return name if name.is_a?(Module)
-      require "jat/plugins/#{name}/#{name}" unless @plugins.key?(name)
+      private
 
-      @plugins[name] || raise(Error, "plugin #{name} did not register itself correctly in Jat::Plugins")
+      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,17 +1,19 @@
 # frozen_string_literal: true
 
-require_relative "jat/attribute"
-require_relative "jat/config"
-require_relative "jat/plugins"
-
 # Main namespace
 class Jat
+  # A generic exception used by Jat.
+  class Error < StandardError; end
+
   FROZEN_EMPTY_HASH = {}.freeze
   FROZEN_EMPTY_ARRAY = [].freeze
+end
 
-  # A generic exception used by Jat.
-  class Error < StandardError; end
+require_relative "jat/attribute"
+require_relative "jat/config"
+require_relative "jat/plugins"
 
+class Jat
   @config = Config.new({plugins: []})
 
   module ClassMethods
@@ -43,24 +45,29 @@ class Jat
 
       plugin = Plugins.find_plugin(name)
 
-      # Before load usually used to check plugin can be attached or to load additional plugins
+      # 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)
-
-      # Usually used to include/extend plugin modules
       plugin.load(self, **opts) if plugin.respond_to?(:load)
-
-      # Store attached plugins, so we can check them later
-      config[:plugins] << plugin
-
-      # Set some config options for current plugin or load additional plugins
       plugin.after_load(self, **opts) if plugin.respond_to?(:after_load)
 
+      # Store attached plugins, so we can check it is loaded later
+      config[:plugins] << (plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin)
+
       plugin
     end
 
-    def plugin_used?(name)
-      plugin = Plugins.find_plugin(name)
-      config[:plugins].include?(plugin)
+    def plugin_used?(plugin)
+      plugin_name =
+        case plugin
+        when Module then plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin
+        else plugin
+        end
+
+      config[:plugins].include?(plugin_name)
     end
 
     def call

data/test/lib/jat/attribute_test.rb

@@ -148,5 +148,13 @@ describe Jat::Attribute do
       attribute = attribute_class.new(name: "foo", opts: {key: :length})
       assert_equal 3, attribute.value([1, 2, 3], nil)
     end
+
+    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/{_activerecord_preloads/_activerecord_preloads_test.rb → base_activerecord_preloads/base_activerecord_preloads_test.rb}

@@ -2,13 +2,13 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::ActiverecordPreloads" do
+describe "Jat::Plugins::BaseActiverecordPreloads" do
   let(:jat_class) do
     api_test = api_test()
 
     Class.new(Jat) do
       include api_test
-      plugin(:_activerecord_preloads)
+      plugin(:base_activerecord_preloads)
     end
   end
 
@@ -27,7 +27,7 @@ describe "Jat::Plugins::ActiverecordPreloads" do
       jat = jat_class.new
       jat.expects(:preloads).returns(preloads)
 
-      Jat::Plugins::ActiverecordPreloads::Preloader
+      Jat::Plugins::BaseActiverecordPreloads::Preloader
         .expects(:preload)
         .with(object, preloads).returns("OBJ_WITH_PRELOADS")
 

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.find_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