jat 0.0.6 → 0.0.10

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

@@ -5,16 +5,6 @@ class Jat
     module SimpleApi
       class Map
         module ClassMethods
-          # Returns the Jat class that this Map class is namespaced under.
-          attr_accessor :jat_class
-
-          # Since Map 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}::Map"
-          end
-
           # Returns structure like
           # {
           #   key1 => { key11 => {}, key12 => { ... } },
@@ -74,11 +64,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)
@@ -91,6 +80,7 @@ class Jat
           end
         end
 
+        extend Jat::JatClass
         extend ClassMethods
         include InstanceMethods
       end

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

@@ -6,16 +6,6 @@ class Jat
     module SimpleApi
       class Response
         module ClassMethods
-          # Returns the Jat class that this Response class is namespaced under.
-          attr_accessor :jat_class
-
-          # Since Response 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}::Response"
-          end
-
           def call(object, context)
             new(object, context).to_h
           end
@@ -95,7 +85,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,12 +99,9 @@ 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 Jat::JatClass
         extend ClassMethods
         include InstanceMethods
       end

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

@@ -6,16 +6,6 @@ class Jat
     module SimpleApi
       class ResponsePiece
         module ClassMethods
-          # Returns the Jat class that this ResponsePiece class is namespaced under.
-          attr_accessor :jat_class
-
-          # Since ResponsePiece 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}::ResponsePiece"
-          end
-
           def to_h(object, context, map)
             new(object, context).piece(map)
           end
@@ -37,7 +27,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 +46,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)
@@ -76,6 +62,7 @@ class Jat
           end
         end
 
+        extend Jat::JatClass
         extend ClassMethods
         include InstanceMethods
       end

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

@@ -14,7 +14,7 @@ class Jat
 
       def self.load(jat_class, **opts)
         jat_class.plugin :simple_api_preloads, **opts
-        jat_class.plugin :_activerecord_preloads, **opts
+        jat_class.plugin :base_activerecord_preloads, **opts
       end
     end
 

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

@@ -10,7 +10,7 @@ class Jat
       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)

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

@@ -12,7 +12,7 @@ class Jat
       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 :_preloads, **opts
+        jat_class.plugin :base_preloads, **opts
       end
 
       def self.load(jat_class, **_opts)

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

@@ -38,7 +38,7 @@ class Jat
       end
 
       module FieldsParamParserMethods
-        def parse
+        def parse(*)
           super.tap { |result| ValidateFieldsParam.call(self.class.jat_class, result) }
         end
       end

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

@@ -79,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
 

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

@@ -1,39 +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 self.find_plugin(name)
-      return name if name.is_a?(Module)
+      # 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 "jat/plugins/#{name}/#{name}"
-      rescue LoadError
-        if name.start_with?("json_api")
-          require "jat/plugins/json_api/plugins/#{name}/#{name}"
-        elsif name.start_with?("simple_api")
-          require "jat/plugins/simple_api/plugins/#{name}/#{name}"
-        elsif name.start_with?("_")
-          require "jat/plugins/common/#{name}/#{name}"
-        else
-          raise
+        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
 
-      @plugins[name] || raise(Error, "plugin #{name} did not register itself correctly in Jat::Plugins")
+      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/utils/jat_class.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Jat
+  module JatClass
+    # Returns the Jat class that this class is namespaced under.
+    attr_accessor :jat_class
+
+    # Since class that uses current module 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
+      return super unless jat_class
+
+      path = superclass.inspect
+      index = path.rindex("::") + 2
+      class_name = path[index, path.length - index]
+
+      "#{jat_class.inspect}::#{class_name}"
+    end
+  end
+end

data/lib/jat.rb

@@ -1,17 +1,20 @@
 # 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/utils/jat_class"
+require_relative "jat/attribute"
+require_relative "jat/config"
+require_relative "jat/plugins"
 
+class Jat
   @config = Config.new({plugins: []})
 
   module ClassMethods

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

data/test/lib/jat/plugins/{_camel_lower/_camel_lower_test.rb → base_lower_camel_case/base_lower_camel_case_test.rb}

@@ -2,10 +2,10 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::LowerCamelCase" do
+describe "Jat::Plugins::BaseLowerCamelCase" do
   let(:jat_class) do
     new_class = Class.new(Jat)
-    new_class.plugin(:_lower_camel_case)
+    new_class.plugin(:base_lower_camel_case)
     new_class
   end
 

data/test/lib/jat/plugins/{_preloads/_preloads_test.rb → base_preloads/base_preloads_test.rb}

@@ -2,9 +2,9 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::Preloads" do
+describe "Jat::Plugins::BasePreloads" do
   let(:jat_class) do
-    Class.new(Jat) { plugin(:_preloads) }
+    Class.new(Jat) { plugin(:base_preloads) }
   end
 
   def attribute(name, opts)

data/test/lib/jat/plugins/{_preloads → base_preloads}/lib/format_user_preloads_test.rb

@@ -2,10 +2,10 @@
 
 require "test_helper"
 
-describe "Jat::Plugins::Preloads::FormatUserPreloads" do
-  before { Jat::Plugins.find_plugin(:_preloads) }
+describe "Jat::Plugins::BasePreloads::FormatUserPreloads" do
+  before { Jat::Plugins.find_plugin(:base_preloads) }
 
-  let(:format) { Jat::Plugins::Preloads::FormatUserPreloads }
+  let(:format) { Jat::Plugins::BasePreloads::FormatUserPreloads }
 
   it "transforms nil to empty hash" do
     preloads = nil

data/test/lib/jat/plugins/{_preloads → base_preloads}/lib/preloads_with_path_test.rb

@@ -3,9 +3,9 @@
 require "test_helper"
 
 describe "Jat::Plugins::Preloads::PreloadsWithPath" do
-  before { Jat::Plugins.find_plugin(:_preloads) }
+  before { Jat::Plugins.find_plugin(:base_preloads) }
 
-  let(:described_class) { Jat::Plugins::Preloads::PreloadsWithPath }
+  let(:described_class) { Jat::Plugins::BasePreloads::PreloadsWithPath }
 
   it "returns provided preloads and path to last value" do
     preloads = {a: {b: {c: {}}, d: {}}, e: {}}

data/test/lib/jat/plugins/json_api/json_api_test.rb

@@ -46,7 +46,7 @@ describe "Jat::Plugins::JsonApi" do
     describe "#map" do
       it "returns map for provided context" do
         jat_class::Map.expects(:call).with("CONTEXT").returns "MAP"
-        assert_equal "MAP", jat_class.map("CONTEXT")
+        assert_equal "MAP", jat_class.new("CONTEXT").map
       end
     end
 

data/test/lib/jat/plugins/json_api/lib/fields_param_parser_test.rb

@@ -18,21 +18,29 @@ describe "Jat::Plugins::JsonApi::FieldsParamParser" do
 
   let(:described_class) { jat_class::FieldsParamParser }
 
-  it "returns empty hash when parameters not provided" do
-    result = described_class.parse(nil)
-
-    assert_equal({}, result)
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::FieldsParamParser", described_class.inspect
+    end
   end
 
-  it "returns parsed attributes" do
-    result = described_class.parse(a: "a1,a2")
+  describe ".parse" do
+    it "returns empty hash when parameters not provided" do
+      result = described_class.parse(nil)
 
-    assert_equal({a: %i[a1 a2]}, result)
-  end
+      assert_equal({}, result)
+    end
 
-  it "validates provided attributes" do
-    jat_class.plugin :json_api_validate_params
-    error = assert_raises(Jat::Error) { described_class.parse(a: "a1,a2,a3,a4") }
-    assert_match(/a4/, error.message)
+    it "returns parsed attributes" do
+      result = described_class.parse(a: "a1,a2")
+
+      assert_equal({a: %i[a1 a2]}, result)
+    end
+
+    it "validates provided attributes" do
+      jat_class.plugin :json_api_validate_params
+      error = assert_raises(Jat::Error) { described_class.parse(a: "a1,a2,a3,a4") }
+      assert_match(/a4/, error.message)
+    end
   end
 end

data/test/lib/jat/plugins/json_api/lib/include_param_parser_test.rb

@@ -3,11 +3,10 @@
 require "test_helper"
 
 describe "Jat::Plugins::JsonApi::Params::Include" do
-  before { Jat::Plugins.find_plugin(:json_api) }
-
   let(:base_class) { Class.new(Jat) { plugin :json_api } }
   let(:a_serializer) { Class.new(base_class) }
   let(:b_serializer) { Class.new(base_class) }
+  let(:c_serializer) { Class.new(base_class) }
 
   before do
     ser = a_serializer
@@ -22,20 +21,35 @@ describe "Jat::Plugins::JsonApi::Params::Include" do
     ser = b_serializer
     ser.type :b
     ser.attribute :b1
-    ser.relationship :b2, serializer: a_serializer
-    ser.relationship :b3, serializer: a_serializer
-    ser.relationship :b4, serializer: a_serializer
+    ser.relationship :b2, serializer: c_serializer
+    ser.relationship :b3, serializer: c_serializer
+    ser.relationship :b4, serializer: c_serializer
+
+    ser = c_serializer
+    ser.type :c
+    ser.attribute :c1
+    ser.relationship :c2, serializer: a_serializer
+    ser.relationship :c3, serializer: a_serializer
+    ser.relationship :c4, serializer: a_serializer
   end
 
   let(:described_class) { a_serializer::IncludeParamParser }
 
-  it "returns empty hash when param not provided" do
-    result = described_class.parse(nil)
-    assert_equal({}, result)
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{a_serializer}::IncludeParamParser", described_class.inspect
+    end
   end
 
-  it "returns typed keys" do
-    result = described_class.parse("a2.b2,a2.b3,a3.b2.a5,a4")
-    assert_equal({a: %i[a2 a3 a5 a4], b: %i[b2 b3]}, result)
+  describe ".parse" do
+    it "returns empty hash when param not provided" do
+      result = described_class.parse(nil)
+      assert_equal({}, result)
+    end
+
+    it "returns typed keys" do
+      result = described_class.parse("a2.b2.c2,a2.b2.c3,a3.b2.c4.a5,a4")
+      assert_equal({a: %i[a2 a3 a5 a4], b: %i[b2], c: %i[c2 c3 c4]}, result)
+    end
   end
 end