quiver 0.21.0

data/lib/quiver/json_parser.rb

@@ -0,0 +1,17 @@
+class JsonParser < Lotus::Routing::Parsing::Parser
+  def mime_types
+    ['application/json', 'application/vnd.api+json']
+  end
+
+  def parse(body)
+    parsed = JSON.parse(body)
+
+    if parsed.is_a?(Array)
+      { request_data: parsed }
+    else
+      parsed
+    end
+  rescue JSON::ParserError => e
+    {terrible_hack: e}
+  end
+end

data/lib/quiver/logger.rb

@@ -0,0 +1,26 @@
+require 'logger'
+
+module Quiver
+  class Logger < ::Logger
+    def initialize(logdev, shift_age = 0, shift_size = 1048576)
+      @progname = nil
+      @level = DEBUG
+      @default_formatter = Formatter.new
+      @formatter = nil
+      @logdev = nil
+
+      if logdev
+        @logdev = LogDevice.new(
+          logdev,
+          :shift_age => shift_age,
+          :shift_size => shift_size
+        )
+      end
+    end
+
+    class LogDevice < ::Logger::LogDevice
+      def add_log_header(file)
+      end
+    end
+  end
+end

data/lib/quiver/mapper.rb

@@ -0,0 +1,311 @@
+module Quiver
+  module Mapper
+    def self.included(host)
+      host.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def type_attribute(attr_name=nil)
+        if attr_name
+          @type_attribute = attr_name
+        end
+
+        @type_attribute
+      end
+
+      private
+
+      def filters(*args)
+        raise 'Mapper.filters is unused, it should be removed'
+      end
+
+      def default_filter(h=nil)
+        if h
+          h.each do |k, v|
+            v.each do |comparator, _|
+              unless %i|nil not_nil ~nil|.include?(comparator)
+                raise 'Default filter only supports the nil and ~nil comparators'
+              end
+            end
+          end
+
+          @default_filter = h
+        end
+
+        @default_filter || {}
+      end
+
+      def sorts(*args)
+        @sorts ||= []
+
+        if args.any?
+          @sorts += args.map(&:to_sym)
+        end
+
+        @sorts.dup.freeze
+      end
+
+      def maps(model_klass=nil)
+        if model_klass
+          @maps = model_klass
+        end
+
+        @maps
+      end
+
+      def hooks(hook_array=nil)
+        if hook_array
+          @hooks = hook_array
+        end
+
+        @hooks
+      end
+
+      def adapter_for(adapter_type)
+        raise ArgumentError, 'adapter_type must not be nil' if adapter_type.nil?
+        unnamespaced_name = name.split('::').last
+        adapters_namespace = self.parents[-2]::Adapters.const_get(unnamespaced_name)
+        adapters_namespace.const_get(adapter_type.to_s.camelize + 'Adapter')
+      end
+    end
+
+    def initialize(adapter_type=nil)
+      adapter_type ||= self.class.parents[-2]::Application.default_adapter_type
+      self.adapter_type = adapter_type
+      self.adapter = self.class.send(:adapter_for, adapter_type).new
+    end
+
+    def save(model)
+      self.class.parents[-2]::Mappers.transaction do |transaction|
+        hooks = self.class.send(:hooks) || []
+
+        if self.class.type_attribute
+          type_key = model.send(self.class.type_attribute)
+        end
+
+        if hooks.is_a?(Hash)
+          hooks = hooks[type_key.to_sym] || []
+        end
+
+        hooks = hooks.map(&:new)
+
+        model = hooks.inject(model) do |model, hook|
+          hook.before_save(model)
+        end
+
+        if model.persisted_by.include?(adapter_type)
+          result = update(model, transaction)
+        else
+          result = create(model, transaction)
+
+          if result.success?
+            # model.persisted_by!(adapter_type)
+          end
+        end
+
+        hooks.inject(result) do |result, hook|
+          hook.after_save(result)
+        end
+      end
+    end
+
+    def find(pk)
+      adapter.find(pk).when(
+        success: -> (attributes, result) {
+          Quiver::Mapper::MapperResult.new { |e| hydrate(attributes) }
+        },
+        failure: -> (errors, result) { result }
+      )
+    end
+
+    def all
+      query({})
+    end
+
+    def hard_delete(model)
+      self.class.parents[-2]::Mappers.transaction do |transaction|
+        attributes = dehydrate(model)
+
+        Quiver::Mapper::MapperResult.new(nil, nil, {adapter_op: :hard_delete}) do |errors|
+          adapter.hard_delete(attributes, transaction).when(
+            success: -> (attributes, result) {
+              {}
+            },
+            failure: -> (adapter_errors, result) { errors.add(adapter_errors); nil }
+          )
+        end
+      end
+    end
+
+    def soft_delete(model)
+      self.class.parents[-2]::Mappers.transaction do |transaction|
+        model.deleted_at = Time.now
+
+        attributes = dehydrate(model)
+
+        Quiver::Mapper::MapperResult.new(nil, nil, {adapter_op: :soft_delete}) do |errors|
+          adapter.update(attributes, transaction).when(
+            success: -> (attributes, result) {
+              hydrate(attributes)
+            },
+            failure: -> (adapter_errors, result) { errors.add(adapter_errors); nil }
+          )
+        end
+      end
+    end
+
+    def restore(model)
+      self.class.parents[-2]::Mappers.transaction do |transaction|
+        model.deleted_at = nil
+
+        attributes = dehydrate(model)
+
+        Quiver::Mapper::MapperResult.new(nil, nil, {adapter_op: :restore}) do |errors|
+          adapter.update(attributes, transaction).when(
+            success: -> (attributes, result) {
+              hydrate(attributes)
+            },
+            failure: -> (adapter_errors, result) { errors.add(adapter_errors); nil }
+          )
+        end
+      end
+    end
+
+    def count
+      adapter.count
+    end
+
+    def filter(params)
+      SimpleQueryBuilder.new(self).filter(params)
+    end
+
+    def sort(params)
+      SimpleQueryBuilder.new(self).sort(params)
+    end
+
+    def paginate(params)
+      SimpleQueryBuilder.new(self).paginate(params)
+    end
+
+    private
+
+    attr_accessor :adapter, :adapter_type
+
+    def when_valid(model, adapter_op)
+      raise ArgumentError, "requires block" unless block_given?
+
+      errors = model.validate(
+        tags: [adapter_op],
+        mapper: self,
+        model: model
+      )
+
+      if errors.success?
+        current_time = Time.now.utc
+        model.updated_at = current_time if model.respond_to?(:updated_at=)
+
+        if adapter_op == :create
+          model.created_at ||= current_time if model.respond_to?(:created_at)
+        end
+
+        object = yield(model, errors)
+      end
+
+      Quiver::Mapper::MapperResult.new(object, errors, adapter_op: adapter_op)
+    end
+
+    def create(model, transaction)
+      when_valid(model, :create) do |model, errors|
+        attributes = dehydrate(model)
+
+        adapter.create(attributes, transaction).when({
+          success: -> (attributes, result) {
+            model.persisted_by!(adapter_type)
+            model.send(:"#{adapter.send(:primary_key_name)}=", attributes[adapter.send(:primary_key_name)])
+            hydrate(attributes)
+          },
+          failure: -> (adapter_errors, result) { errors.add(adapter_errors) }
+        })
+      end
+    end
+
+    def update(model, transaction)
+      when_valid(model, :update) do |model, errors|
+        attributes = dehydrate(model)
+
+        adapter.update(attributes, transaction).when(
+          success: -> (attributes, result) {
+            hydrate(attributes)
+          },
+          failure: -> (adapter_errors, result) { errors.add(adapter_errors); nil }
+        )
+      end
+    end
+
+    def query(q={})
+      adapter.query(q).when(
+        success: -> (items, result) {
+          Quiver::Mapper::MapperResult.new(nil, nil, result.data) { |e|
+            items.map do |attributes|
+              hydrate(attributes)
+            end
+          }
+        },
+        failure: -> (errors, result) { result }
+      )
+      end
+
+    def hydrate(attributes)
+      attributes = attributes.dup
+
+      hooks = self.class.send(:hooks) || []
+
+      type_key = attributes.delete(self.class.type_attribute) || attributes.delete(self.class.type_attribute.to_s)
+
+      if hooks.is_a?(Hash)
+        hooks = hooks[type_key.to_sym] || []
+      end
+
+      attributes = hooks.inject(attributes) do |attrs, hook|
+        hook.new.before_hydrate(attrs)
+      end
+
+      if self.class.send(:maps).is_a?(Hash)
+        object = self.class.send(:maps)[type_key.to_sym].new(attributes)
+      else
+        object = self.class.send(:maps).new(attributes)
+      end
+
+      object.persisted_by!(adapter_type)
+
+      object
+    end
+
+    def dehydrate(model)
+      attributes = model.attributes
+
+      if self.class.type_attribute
+        attributes = attributes.merge(:__type__ => {
+          value: model.send(self.class.type_attribute),
+          name: self.class.type_attribute
+        })
+      end
+
+      hooks = self.class.send(:hooks) || []
+
+      if hooks.is_a?(Hash)
+        hooks = hooks[model.send(self.class.type_attribute)] || []
+      end
+
+      hooks.inject(attributes) do |attrs, hook|
+        hook.new.after_dehydrate(attrs)
+      end
+    end
+  end
+end
+
+require 'quiver/mapper/mapper_result'
+require 'quiver/mapper/not_found_error'
+require 'quiver/mapper/simple_query_builder'
+require 'quiver/mapper/soft_delete'
+require 'quiver/mapper/hook'

data/lib/quiver/mapper/hook.rb

@@ -0,0 +1,21 @@
+module Quiver
+  module Mapper
+    module Hook
+      def before_hydrate(attributes)
+        attributes
+      end
+
+      def after_dehydrate(attributes)
+        attributes
+      end
+
+      def before_save(model)
+        model
+      end
+
+      def after_save(result)
+        result
+      end
+    end
+  end
+end

data/lib/quiver/mapper/mapper_result.rb

@@ -0,0 +1,7 @@
+module Quiver
+  module Mapper
+    class MapperResult
+      include Quiver::Result
+    end
+  end
+end

data/lib/quiver/mapper/not_found_error.rb

@@ -0,0 +1,27 @@
+module Quiver::Mapper
+  class NotFoundError < Quiver::Error
+    def title
+      type
+    end
+
+    def detail
+      type
+    end
+
+    def path
+      "/#{subject}"
+    end
+
+    def status
+      404
+    end
+
+    def code
+      :not_found_error
+    end
+
+    def serialization_type
+      'Error'
+    end
+  end
+end

data/lib/quiver/mapper/simple_query_builder.rb

@@ -0,0 +1,70 @@
+module Quiver
+  module Mapper
+    class SimpleQueryBuilder
+      def initialize(mapper)
+        self.mapper = mapper
+
+        self._filter = {}
+        self._sort = {}
+        self._paginate = {}
+      end
+
+      def to_result
+        filter_errors = _filter.reduce(Quiver::ErrorCollection.new) do |errors, (k, v)|
+          if v
+            errors + v.errors.each_with_object(Quiver::ErrorCollection.new) do |error, collection|
+              collection << Quiver::Action::FilterError.new("#{k}: #{error.detail}")
+            end
+          else
+            errors
+          end
+        end
+
+        if filter_errors.any?
+          return Quiver::Mapper::MapperResult.new([], filter_errors)
+        end
+
+        mapper.send(:query,
+          filter: mapper.class.send(:default_filter).merge(_filter),
+          sort: _sort,
+          page: _paginate
+        )
+      end
+
+      def filter(params)
+        self._filter = params.to_h
+        self
+      end
+
+      def sort(params)
+        params ||= ''
+        self._sort = params.split(',').map do |k|
+          asc = k[0] != '-'
+          k = k[1..-1] if !asc
+
+          [k, asc]
+        end.reject do |(k, _)|
+          !allowed_sorts.include?(k.to_sym)
+        end
+        self
+      end
+
+      def paginate(params)
+        self._paginate = params.to_h.slice('limit', 'offset')
+        self
+      end
+
+      private
+
+      attr_accessor :mapper, :adapter, :_filter, :_sort, :_paginate
+
+      def allowed_filters
+        mapper.class.send(:filters)
+      end
+
+      def allowed_sorts
+        mapper.class.send(:sorts)
+      end
+    end
+  end
+end