jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiPreloads
+      class Preloads
+        module ClassMethods
+          def call(jat)
+            result = {}
+            append_many(result, jat.class, jat.map)
+            result
+          end
+
+          private
+
+          def append_many(result, jat_class, keys)
+            keys.each do |key, inner_keys|
+              attribute = jat_class.attributes.fetch(key)
+              preloads = attribute.preloads
+              next unless preloads
+
+              append_one(result, jat_class, preloads)
+              next if inner_keys.empty?
+
+              path = attribute.preloads_path
+              nested_result = nested(result, path)
+              nested_serializer = attribute.serializer.call
+
+              append_many(nested_result, nested_serializer, inner_keys)
+            end
+          end
+
+          def append_one(result, jat_class, preloads)
+            return if preloads.empty?
+
+            preloads = EnumDeepDup.call(preloads)
+            merge(result, preloads)
+          end
+
+          def merge(result, preloads)
+            result.merge!(preloads) do |_key, value_one, value_two|
+              merge(value_one, value_two)
+            end
+          end
+
+          def nested(result, path)
+            !path || path.empty? ? result : result.dig(*path)
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

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 :_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/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/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/plugins/simple_api_validate_params/simple_api_validate_params.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "./lib/fields_error"
+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"
+      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(SimpleApiValidateParams.plugin_name, SimpleApiValidateParams)
+  end
+end

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

@@ -0,0 +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"
+
+class Jat
+  module Plugins
+    module SimpleApi
+      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)
+
+        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(object)
+          self.class::Response.call(object, context)
+        end
+
+        def map
+          @map ||= self.class.map(context)
+        end
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          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.attribute(params[:name], **params[:opts], &params[:block])
+          end
+        end
+
+        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
+
+          {root_one: root_one, root_many: root_many}
+        end
+
+        def meta_key(new_meta_key)
+          config[:meta_key] = new_meta_key.to_sym
+        end
+
+        def added_meta
+          @added_meta ||= {}
+        end
+
+        def meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_meta[new_attr.name] = new_attr
+        end
+
+        def map(context)
+          self::Map.call(context)
+        end
+
+        def map_full
+          @map_full ||= self::Map.call(exposed: :all)
+        end
+
+        def map_exposed
+          @map_exposed ||= self::Map.call(exposed: :default)
+        end
+      end
+    end
+
+    register_plugin(SimpleApi.plugin_name, SimpleApi)
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+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 = nil)
+          new(context || FROZEN_EMPTY_HASH).to_str(object)
+        end
+      end
+
+      module InstanceMethods
+        def to_str(object)
+          hash = to_h(object)
+          config[:to_str].call(hash)
+        end
+      end
+
+      class ToStrJSON
+        module ClassMethods
+          def dump(response)
+            json_adapter.dump(response)
+          end
+
+          private
+
+          def json_adapter
+            @json_adapter ||= begin
+              require "json"
+              ::JSON
+            end
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+
+    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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class Jat
+  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
+    # 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)
+
+      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
+        end
+      end
+
+      @plugins[name] || raise(Error, "plugin #{name} did not register itself correctly in Jat::Plugins")
+    end
+  end
+end

data/lib/jat/utils/enum_deep_dup.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Jat
+  # Duplicates nested enumerable data
+  class EnumDeepDup
+    DUP = {
+      Hash => ->(data) { dup_hash_values(data) },
+      Array => ->(data) { dup_array_values(data) }
+    }.freeze
+
+    def self.call(data)
+      duplicate_data = data.dup
+      DUP.fetch(duplicate_data.class).call(duplicate_data)
+      duplicate_data
+    end
+
+    def self.dup_hash_values(duplicate_data)
+      duplicate_data.each do |key, value|
+        duplicate_data[key] = call(value) if value.is_a?(Enumerable)
+      end
+    end
+
+    def self.dup_array_values(duplicate_data)
+      duplicate_data.each_with_index do |value, index|
+        duplicate_data[index] = call(value) if value.is_a?(Enumerable)
+      end
+    end
+  end
+end

data/lib/jat/utils/enum_deep_freeze.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Jat
+  # Freezes nested enumerable data
+  class EnumDeepFreeze
+    FREEZES = {
+      Hash => ->(data) { data.each_value(&FREEZE_ENUMS) },
+      Array => ->(data) { data.each(&FREEZE_ENUMS) }
+    }.freeze
+
+    FREEZE_ENUMS = ->(value) { call(value) if value.is_a?(Enumerable) }
+
+    def self.call(data)
+      data.freeze
+      FREEZES.fetch(data.class).call(data)
+      data
+    end
+  end
+end