quiver 0.21.0

data/lib/quiver/mapper/soft_delete.rb

@@ -0,0 +1,15 @@
+module Quiver
+  module Mapper
+    module SoftDelete
+      def soft_delete(model)
+        model.deleted_at = Time.now
+        save(model)
+      end
+
+      def restore(model)
+        model.deleted_at = nil
+        save(model)
+      end
+    end
+  end
+end

data/lib/quiver/mappers.rb

@@ -0,0 +1,75 @@
+module Quiver
+  module Mappers
+    def self.transaction(&block)
+      raise ArgumentError, "#transaction requires a block" unless block_given?
+
+      root_module = self.parent
+      adapter_type = root_module::Application.default_adapter_type
+
+      transaction_klass = self.const_get("#{adapter_type.to_s.camelize}Transaction")
+      transaction_klass.transaction(root_module, &block)
+    end
+
+    class Transaction
+      def initialize
+        self.rollback = false
+      end
+
+      def rollback!
+        self.rollback = true
+      end
+
+      def rollback?
+        rollback
+      end
+
+      def good?
+        !rollback
+      end
+
+      private
+
+      attr_accessor :rollback
+    end
+
+    class RollbackTransaction < StandardError; end
+
+    module MemoryTransaction
+      def self.transaction(root_module, &block)
+        raise ArgumentError, "#transaction requires a block" unless block_given?
+
+        transaction = Transaction.new
+
+        root_module::Application.memory_adapter_store.transaction do
+          ret = block.call(transaction)
+
+          raise RollbackTransaction if transaction.rollback?
+
+          ret
+        end
+      end
+    end
+
+    module ActiveRecordTransaction
+      def self.transaction(root_module, &block)
+        raise ArgumentError, "#transaction requires a block" unless block_given?
+
+        transaction = Transaction.new
+
+        ret = nil
+
+        ActiveRecord::Base.transaction do
+          begin
+            ret = block.call(transaction)
+          rescue ::ActiveRecord::ActiveRecordError, RollbackTransaction
+            transaction.rollback!
+          end
+
+          raise ActiveRecord::Rollback if transaction.rollback?
+        end
+
+        ret
+      end
+    end
+  end
+end

data/lib/quiver/middleware_stack.rb

@@ -0,0 +1,35 @@
+module Quiver
+  class MiddlewareStack
+    attr_reader :middlewares
+
+    def initialize
+      self.middlewares = []
+    end
+
+    def <<(middleware)
+      middlewares << middleware
+      @middleware_stack = nil
+      middlewares
+    end
+
+    def unshift(*middleware)
+      middlewares.unshift(*middleware)
+      @middleware_stack = nil
+      middlewares
+    end
+
+    def stack(app)
+      @stack ||= rebuild_stack!(app)
+    end
+
+    private
+
+    attr_writer :middlewares
+
+    def rebuild_stack!(app)
+      middlewares.reverse.inject(app) do |app, middleware|
+        middleware.new(app)
+      end
+    end
+  end
+end

data/lib/quiver/model.rb

@@ -0,0 +1,63 @@
+require 'extant'
+
+module Quiver
+  module Model
+    module ExtantAttributeOverrides
+      def with(attrs={}, metadata={})
+        super.tap do |new_instance|
+          persisted_by.each do |pb|
+            new_instance.persisted_by!(pb)
+          end
+        end
+      end
+
+      def dirty?(attr=nil)
+        return true unless persisted?
+
+        super
+      end
+    end
+
+    require 'quiver/model/validations'
+
+    def self.included(host)
+      host.send(:include, Extant::Attributes)
+      host.send(:include, Validations)
+      host.send(:include, ExtantAttributeOverrides)
+    end
+
+    def coerced?(attr)
+      extant_attributes[attr].set? && extant_attributes[attr].coerced? ||
+        extant_attributes[attr].unset? && !extant_attributes[attr].coerced?
+    end
+
+    def coerced_all?
+      extant_attributes.all? { |(_, attr_object)| attr_object.coerced? }
+    end
+
+    def persisted?
+      persisted_by.any?
+    end
+
+    def persisted_by
+      @persisted_by ||= []
+    end
+
+    def persisted_by!(adapter_type)
+      persisted_by << adapter_type
+    end
+
+    def serialization_type
+      @serialization_type ||= self.class.name.split('::').last
+    end
+
+    def original_attributes
+      original_extant_attributes.each_with_object({}) do |(k, v), attrs|
+        attrs[k] = v.value
+      end
+    end
+  end
+end
+
+require 'quiver/model/validation_error'
+require 'quiver/model/soft_delete'

data/lib/quiver/model/soft_delete.rb

@@ -0,0 +1,14 @@
+module Quiver
+  module Model
+    module SoftDelete
+
+      def self.included(host)
+        host.send(:attribute, :deleted_at, Time)
+      end
+
+      def deleted?
+        !!deleted_at
+      end
+    end
+  end
+end

data/lib/quiver/model/validation_error.rb

@@ -0,0 +1,27 @@
+module Quiver::Model
+  class ValidationError < Quiver::Error
+    def title
+      type
+    end
+
+    def detail
+      type
+    end
+
+    def path
+      "/#{subject}"
+    end
+
+    def status
+      422
+    end
+
+    def code
+      :model_validation_error
+    end
+
+    def serialization_type
+      'Error'
+    end
+  end
+end

data/lib/quiver/model/validations.rb

@@ -0,0 +1,45 @@
+module Quiver
+  module Model
+    module Validations
+      def self.included(host)
+        host.send(:extend, ClassMethods)
+      end
+
+      module ClassMethods
+        def validate(attr_or_proc, options={})
+          validation_definitions << {
+            attr_or_proc: attr_or_proc,
+            options: options
+          }
+        end
+
+        def validator
+          @validator ||= Quiver::Validator.new(validation_definitions)
+        end
+
+        private
+
+        def validation_definitions
+          @validation_definitions ||= []
+        end
+      end
+
+      def validate(options={})
+        result = self.class.validator.validate(self, options)
+
+        if respond_to?(:extant_attributes, true)
+          extant_attributes.each do |(key, attr_object)|
+            unless coerced?(attr_object.name)
+              result << Quiver::Model::ValidationError.new(
+                attr_object.name,
+                "could_not_be_coerced_to_expected_type.#{attr_object.coercer_name}"
+              )
+            end
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/quiver/patcher.rb

@@ -0,0 +1,94 @@
+module Quiver
+  module Patcher
+    def self.included(host)
+      host.send(:include, AbstractAction)
+      host.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def values(&block)
+        warn '`values` is no longer supported.'
+      end
+
+      def params(&block)
+        klass = Class.new do
+          include Lotus::Validations
+
+          def self.param(name, options={}, &block)
+            attribute(name, options, &block)
+            nil
+          end
+
+          def self.build_validation_class(&block)
+            kls = Class.new(self)
+            kls.class_eval(&block)
+            kls
+          end
+
+          def initialize(attributes)
+            @raw_attributes = attributes
+            super
+          end
+
+          def [](key)
+            @attributes.get(key)
+          end
+
+          def to_h
+            super.select do |key, _|
+              @raw_attributes.to_h.has_key?(key.to_s) || @raw_attributes.to_h.has_key?(key.to_sym)
+            end
+          end
+        end
+        klass.instance_exec(&block)
+
+        instance_variable_set('@params_attributes', klass)
+      end
+
+      def get_params_attributes_klass
+        instance_variable_get('@params_attributes')
+      end
+    end
+
+    attr_accessor :operation, :current_user
+
+    def initialize(operation, extra_params)
+      self.extra_params = extra_params || {}
+      self.operation = operation
+    end
+
+    def run
+      internal_call(nil)
+    end
+
+    def internal_call(_)
+      serialize_with(action)
+    end
+
+    def params
+      @params ||= begin
+        if operation['value'].respond_to?(:to_h) && self.class.get_params_attributes_klass
+          self.class.get_params_attributes_klass.new(extra_params.merge({data: operation['value'].to_h}))
+        else
+          extra_params.merge({data: operation['value']})
+        end
+      end
+    end
+
+    def serialize_with(data)
+      self.class.serializer.new({collections: data}).serialize(context: self)
+    end
+
+    def request_path
+      @request_path ||= operation['path']
+    end
+
+    def request_path_with_query
+      request_path
+    end
+
+    private
+
+    attr_accessor :extra_params
+  end
+end

data/lib/quiver/result.rb

@@ -0,0 +1,44 @@
+module Quiver
+  module Result
+    attr_reader :object, :errors, :data
+
+    def initialize(object=nil, errors=nil, data={})
+      errors ||= Quiver::ErrorCollection.new
+
+      if block_given?
+        object = yield errors
+      end
+
+      self.object = object
+      self.errors = errors
+      self.data = data
+    end
+
+    def success?
+      errors.success?
+    end
+
+    def when(success: nil, failure: nil)
+      # one day if we ever have Ruby 2.1 we can delete this
+      raise ArgumentError, 'missing keyword: success' if success == nil
+      raise ArgumentError, 'missing keyword: failure' if failure == nil
+
+      if success?
+        success.call(object, self)
+      else
+        failure.call(errors, self)
+      end
+    end
+
+    def ==(other)
+      other.is_a?(Result) &&
+      object == other.object &&
+        errors == other.errors &&
+        data == other.data
+    end
+
+    private
+
+    attr_writer :object, :errors, :data
+  end
+end

data/lib/quiver/route_helper.rb

@@ -0,0 +1,16 @@
+module Quiver
+  class RouteHelper
+    def initialize(router)
+      self.router = router
+    end
+
+    def path(*args)
+      route = router.path(*args)
+      route.gsub(/%7B(.*?)%7D/, '{\1}')
+    end
+
+    private
+
+    attr_accessor :router
+  end
+end

data/lib/quiver/router.rb

@@ -0,0 +1,37 @@
+module Quiver
+  module Router
+    def self.included(host)
+      host.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def routes(&block)
+        @routes_block = block
+      end
+
+      def routes_block
+        @routes_block || Proc.new {}
+      end
+    end
+
+    def initialize
+      resolver = Lotus::Routing::EndpointResolver.new(pattern: %Q|#{root_module}::Endpoints::%{controller}::%{action}|)
+      self.router = Lotus::Router.new(resolver: resolver, parsers: [JsonParser.new], &self.class.routes_block)
+      router.get('/', to: ->(env) { [200, {}, ["#{root_module} is now flying out of the Quiver!"]] })
+    end
+
+    def call(env)
+      router.call(env)
+    end
+
+    private
+
+    attr_accessor :router
+
+    def root_module
+      self.class.parents[1].name
+    end
+  end
+end
+
+require 'quiver/route_helper'