jat 0.0.1 → 0.0.7

data/lib/jat.rb

@@ -1,186 +1,111 @@
 # 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/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({plugins: []})
+
   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)
+
+      # 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(name, **opts)
+      return if plugin_used?(name)
 
-    def config=(config)
-      @config = config
-    end
+      plugin = Plugins.find_plugin(name)
 
-    def attributes
-      @attributes ||= Attributes.new
-    end
+      # 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)
 
-    # Used to validate provided params (fields, include)
-    def full_map
-      @full_map ||= Map::Construct.new(self, :all).to_h
-    end
+      # Store attached plugins, so we can check it is loaded later
+      config[:plugins] << (plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin)
 
-    def exposed_map
-      @exposed_map ||= Map::Construct.new(self, :exposed).to_h
+      plugin
     end
 
-    def clear
-      @full_map = nil
-      @exposed_map = nil
-    end
+    def plugin_used?(plugin)
+      plugin_name =
+        case plugin
+        when Module then plugin.respond_to?(:plugin_name) ? plugin.plugin_name : plugin
+        else plugin
+        end
 
-    def refresh
-      attributes.refresh
-      clear
+      config[:plugins].include?(plugin_name)
     end
 
-    def copy_to(subclass)
-      subclass.type(@type) if defined?(@type)
-      config.copy_to(subclass)
-      attributes.copy_to(subclass)
-    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(context || {}).to_h(object)
     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)
+      new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+      attributes[new_attr.name] = new_attr
     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)
+      attribute(name, serializer: serializer, **opts, &block)
     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
-
-    def id(object)
-      object.id
-    end
-
-    def _preloads
-      Preloads.new(_full_map).for(self.class)
-    end
-
-    def _copy_to(nested_serializer)
-      nested_serializer.().new(_context, _full_map)
-    end
+  module InstanceMethods
+    attr_reader :context
 
-    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
+    def initialize(context = {})
+      @context = context
     end
 
-    def _map
-      @_map ||= _full_map.fetch(type)
+    def to_h(_object)
+      raise Error, "Method #to_h must be implemented by plugin"
     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

data/test/lib/jat/attribute_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::Attribute do
+  let(:jat_class) { Class.new(Jat) }
+  let(:attribute_class) { jat_class::Attribute }
+
+  describe ".jat_class=" do
+    it "assigns @jat_class" do
+      attribute_class.jat_class = :foo
+      assert_equal :foo, attribute_class.instance_variable_get(:@jat_class)
+    end
+  end
+
+  describe ".jat_class" do
+    it "returns self @jat_class" do
+      assert_same jat_class, attribute_class.instance_variable_get(:@jat_class)
+      assert_same jat_class, attribute_class.jat_class
+    end
+  end
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::Attribute", attribute_class.inspect
+    end
+  end
+
+  describe "#initialize" do
+    it "deeply copies provided params" do
+      params = {name: :foo, opts: {include: {foo: :bar}}, block: -> {}}
+
+      attribute = attribute_class.new(**params)
+      assert_equal attribute.params, params
+      refute_same attribute.params, params
+      refute_same attribute.opts, params[:opts]
+    end
+  end
+
+  describe "#name" do
+    it "symbolizes name" do
+      attribute = attribute_class.new(name: "foo")
+      assert_equal :foo, attribute.name
+    end
+  end
+
+  describe "#key" do
+    it "returns same as #name when key not provided" do
+      attribute = attribute_class.new(name: "foo")
+      assert_equal :foo, attribute.key
+    end
+
+    it "returns symbolized key option" do
+      attribute = attribute_class.new(name: "foo", opts: {key: "bar"})
+      assert_equal :bar, attribute.key
+    end
+  end
+
+  describe "#exposed?" do
+    it "returns provided value" do
+      attribute = attribute_class.new(name: "foo", opts: {exposed: false})
+      assert_equal false, attribute.exposed?
+    end
+
+    it "returns true when all keys are exposed by config" do
+      jat_class.config[:exposed] = :all
+      attribute = attribute_class.new(name: "foo")
+      assert_equal true, attribute.exposed?
+    end
+
+    it "returns false when no keys are exposed by config" do
+      jat_class.config[:exposed] = :none
+      attribute = attribute_class.new(name: "foo")
+      assert_equal false, attribute.exposed?
+    end
+
+    it "returns false when serializer exists and config[:exposed] is default" do
+      jat_class.config[:exposed] = :default
+      attribute = attribute_class.new(name: "foo", opts: {serializer: jat_class})
+      assert_equal false, attribute.exposed?
+    end
+
+    it "returns true when serializer not exists and config[:exposed] is default" do
+      jat_class.config[:exposed] = :default
+      attribute = attribute_class.new(name: "foo")
+      assert_equal true, attribute.exposed?
+    end
+  end
+
+  describe "#many?" do
+    it "returns nil when no key provided" do
+      attribute = attribute_class.new(name: "foo")
+      assert_nil attribute.many?
+    end
+
+    it "returns provided data" do
+      attribute = attribute_class.new(name: "foo", opts: {many: false})
+      assert_equal false, attribute.many?
+      assert_equal false, attribute.instance_variable_get(:@many)
+      assert_same attribute.instance_variable_get(:@many), attribute.many?
+    end
+  end
+
+  describe "#relation?" do
+    it "returns false when no serializer key" do
+      attribute = attribute_class.new(name: "foo")
+      assert_equal false, attribute.relation?
+    end
+
+    it "returns true with serializer key" do
+      attribute = attribute_class.new(name: "foo", opts: {serializer: jat_class})
+      assert_equal true, attribute.relation?
+    end
+  end
+
+  describe "#serializer" do
+    it "returns nil when no serializer key" do
+      attribute = attribute_class.new(name: "foo")
+      assert_nil attribute.serializer
+    end
+
+    it "returns provided serializer" do
+      attribute = attribute_class.new(name: "foo", opts: {serializer: jat_class})
+      assert_same jat_class, attribute.serializer
+    end
+  end
+
+  describe "#block" do
+    it "returns provided block" do
+      block = proc { |object, context| [object, context] }
+      attribute = attribute_class.new(name: "foo", block: 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})
+      assert_equal 3, attribute.value([1, 2, 3], nil)
+    end
+  end
+end

data/test/lib/jat/config_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe Jat::Config do
+  let(:jat_class) { Class.new(Jat) }
+  let(:config) { jat_class.config }
+
+  describe ".jat_class=" do
+    it "assigns @jat_class" do
+      config.class.jat_class = :foo
+      assert_equal :foo, config.class.instance_variable_get(:@jat_class)
+    end
+  end
+
+  describe ".jat_class" do
+    it "returns self @jat_class" do
+      assert_same jat_class, config.class.instance_variable_get(:@jat_class)
+      assert_same jat_class, config.class.jat_class
+    end
+  end
+
+  describe ".inspect" do
+    it "returns self name" do
+      assert_equal "#{jat_class}::Config", config.class.inspect
+    end
+  end
+
+  describe "#initialize" do
+    it "deeply copies provided opts" do
+      opts = {foo: {bar: {bazz: :bazz2}}}
+
+      config = Jat::Config.new(opts)
+      assert_equal config.opts, opts
+      refute_same config.opts[:foo], opts[:foo]
+      refute_same config.opts[:foo][:bar], opts[:foo][:bar]
+    end
+  end
+
+  describe "#[]=" do
+    it "adds options" do
+      config = Jat::Config.new
+      config[:foo] = :bar
+
+      assert_equal :bar, config.opts[:foo]
+    end
+  end
+
+  describe "#[]" do
+    it "reads options" do
+      config = Jat::Config.new
+      config[:foo] = :bar
+
+      assert_equal :bar, config[:foo]
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::ActiverecordPreloads" do
+  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 when calling to_h" do
+      object = "OBJ"
+      preloads = "PRELOADS"
+      jat = jat_class.new
+      jat.expects(:preloads).returns(preloads)
+
+      Jat::Plugins::ActiverecordPreloads::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/lib/preloader_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "support/activerecord"
+
+describe "Jat::Plugins::ActiverecordPreloads" do
+  before { Jat::Plugins.find_plugin(:_activerecord_preloads) }
+
+  describe "Preloader" do
+    let(:described_class) { plugin::Preloader }
+    let(:plugin) { Jat::Plugins::ActiverecordPreloads }
+
+    describe ".handlers" do
+      it "returns memorized array of handlers" do
+        assert_equal [
+          plugin::ActiverecordRelation,
+          plugin::ActiverecordObject,
+          plugin::ActiverecordArray
+        ], described_class.handlers
+
+        assert_same described_class.handlers, described_class.handlers
+      end
+    end
+
+    describe ".preload" do
+      it "raises error when can't find appropriate handler" do
+        preloads = {}
+
+        object = nil
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+
+        object = []
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+
+        object = 123
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+
+        object = [AR::User.create!, AR::Comment.create!]
+        err = assert_raises(Jat::Error) { described_class.preload(object, {}) }
+        assert_equal "Can't preload #{preloads.inspect} to #{object.inspect}", err.message
+      end
+
+      it "preloads data to activerecord object" do
+        user = AR::User.create!
+
+        result = described_class.preload(user, {comments: {}})
+
+        assert_same result, user
+        assert_equal true, user.association(:comments).loaded?
+      end
+
+      it "preloads data to activerecord array" 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 "preloads data to activerecord relation" do
+        user = AR::User.create!
+
+        result = described_class.preload(AR::User.where(id: user.id), {comments: {}})
+
+        assert_equal result, [user]
+        assert_equal true, result[0].association(:comments).loaded?
+      end
+
+      it "preloads data to loaded activerecord relation" do
+        user = AR::User.create!
+
+        result = described_class.preload(AR::User.where(id: user.id).load, {comments: {}})
+
+        assert_equal result, [user]
+        assert_equal true, result[0].association(:comments).loaded?
+      end
+    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/_preloads_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+describe "Jat::Plugins::Preloads" do
+  let(:jat_class) do
+    Class.new(Jat) { plugin(:_preloads) }
+  end
+
+  def attribute(name, opts)
+    jat_class.attribute(name, **opts)
+  end
+
+  describe "AttributeMethods" do
+    it "saves @preloads and @preloads_path after first access" do
+      attribute = attribute(:foo, preload: :bar)
+
+      assert_same attribute.preloads, attribute.preloads
+      assert_same attribute.preloads_path, attribute.preloads_path
+    end
+
+    describe "#preloads" do
+      it "returns formatted data provided by user" do
+        assert_equal({}, attribute(:foo, preload: {}).preloads)
+        assert_equal({}, attribute(:foo, preload: []).preloads)
+        assert_equal({some: {}}, attribute(:foo, preload: :some).preloads)
+        assert_equal({some: {data: {}}}, attribute(:foo, preload: {some: :data}).preloads)
+      end
+
+      it "preloads main key when serializer exists and preloads are not" do
+        assert_equal({foo: {}}, attribute(:foo, serializer: jat_class).preloads)
+        assert_equal({bar: {}}, attribute(:foo, key: :bar, serializer: jat_class).preloads)
+      end
+
+      it "returns nil when requested to preload nil or false" do
+        assert_nil attribute(:foo, serializer: jat_class, preload: nil).preloads
+        assert_nil attribute(:foo, key: :bar, serializer: jat_class, preload: false).preloads
+      end
+
+      it "removes bang (!) from preloads" do
+        assert_equal({foo: {}}, attribute(:foo, preload: :foo!).preloads)
+      end
+    end
+
+    describe "#preloads_path" do
+      it "returns path to main resource provided by user" do
+        assert_equal([], attribute(:foo, preload: nil).preloads_path)
+        assert_equal([], attribute(:foo, preload: {}).preloads_path)
+        assert_equal([], attribute(:foo, preload: []).preloads_path)
+        assert_equal([:some], attribute(:foo, preload: :some).preloads_path)
+        assert_equal(%i[some data], attribute(:foo, preload: {some: :data}).preloads_path)
+      end
+
+      it "show path to main key when serializer exists and preloads are not" do
+        assert_equal([:foo], attribute(:foo, serializer: jat_class).preloads_path)
+        assert_equal([:bar], attribute(:foo, key: :bar, serializer: jat_class).preloads_path)
+
+        # serializer with empty preloads provided
+        assert_equal([], attribute(:foo, serializer: jat_class, preload: nil).preloads_path)
+        assert_equal([], attribute(:foo, key: :bar, serializer: jat_class, preload: false).preloads_path)
+      end
+
+      it "removes bang (!) and construct path to this preload" do
+        assert_equal([:some], attribute(:foo, preload: {some!: :data}).preloads_path)
+      end
+    end
+  end
+end