quiver 0.21.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7a72a172701aa86d29e34e207afa3b9c366a6e6
+  data.tar.gz: 44c395d87a9a5c24674c9485df4612d765fba9ca
+SHA512:
+  metadata.gz: cc3433511ef6ee74cf5a13cdc1cdcb76720de132b9806ede1f5f3888c8af6d9b5cdd615f6b8d5edfc35e583e4bf7df94c318bf1edea3f5dca40330cd8cc47da8
+  data.tar.gz: d2b8c3d2763cee663cc2544cee1a5dc3d694fb2c1632718d87560b3f65ab5beed6187a5d06823dd8c61fd281b5ce67746d9e28b967be73e4116629014b65cb51

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/bin/stubs/
+/spec/tmp
+/spec/dummy/log/*
+/log/*
+/.idea

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'extant', '~> 0.3.0'
+gem 'pry-byebug'

data/README.md

@@ -0,0 +1,22 @@
+# Quiver
+_Sponsored by NCC Group Domain Services_
+
+## Installation
+
+    $ gem install quiver
+
+## Usage
+
+`quiver new app_name`
+
+## Todo
+
+Actually document things.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/quiver/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :environment do
+end
+
+desc 'Drop, create and migrate the dummy app database'
+task :generate_dummy_schema do
+  ENV['BUNDLE_GEMFILE'] = File.absolute_path(ENV['BUNDLE_GEMFILE']) if ENV['BUNDLE_GEMFILE']
+  cd 'spec/dummy' do
+    sh 'rake db:drop db:create db:migrate'
+  end
+end

data/bin/quiver

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'quiver/version'
+require 'pry'
+require 'active_support/all'
+require 'quiver/cli/app'
+
+Quiver::CLI::App.start

data/lib/quiver.rb

@@ -0,0 +1,46 @@
+ENV['RACK_ENV'] ||= 'development'
+
+require 'quiver/version'
+require 'pry'
+require 'active_support/all'
+
+require 'lotus/router'
+require 'lotus/controller'
+
+Lotus::Controller.configure do
+  format json_api: 'application/vnd.api+json'
+  handle_exceptions false
+end
+
+require 'quiver/logger'
+
+module Quiver
+  def self.controller(s)
+    Lotus::Controller.duplicate(s)
+  end
+end
+
+require 'quiver/tasks'
+require 'quiver/json_parser'
+require 'quiver/router'
+require 'quiver/adapter/memory_adapter_store'
+require 'quiver/application'
+require 'quiver/error'
+require 'quiver/error_collection'
+require 'quiver/validator'
+require 'quiver/model'
+require 'quiver/result'
+require 'quiver/mapper'
+require 'quiver/mappers'
+require 'quiver/adapter'
+require 'quiver/duty'
+require 'quiver/duty_master'
+require 'quiver/duty_test_helper'
+require 'quiver/middleware_stack'
+
+require 'quiver/abstract_action'
+require 'quiver/action'
+require 'quiver/patcher'
+require 'quiver/serialization'
+
+require 'quiver/cli/app'

data/lib/quiver/abstract_action.rb

@@ -0,0 +1,31 @@
+module Quiver
+  module AbstractAction
+    def self.included(host)
+      host.send(:include, Lotus::Action)
+      host.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def serializer(val = nil)
+        if val
+          @serializer = val
+        else
+          @serializer || raise("#{self.name} serializer not set")
+        end
+      end
+    end
+
+    def call(params)
+      # because ruby < 2.2.0, pry, and Module.prepend aren't friends
+      internal_call(params)
+    end
+
+    def arrayify(arg)
+      if arg.is_a?(Array)
+        arg
+      else
+        [arg]
+      end
+    end
+  end
+end

data/lib/quiver/action.rb

@@ -0,0 +1,208 @@
+module Quiver
+  module Action
+    def self.included(host)
+      host.send(:include, AbstractAction)
+      host.send(:extend, ClassMethods)
+
+      # prepend over Lotus's prepends
+      host.send(:prepend, DurationTracking)
+      host.send(:prepend, Logging)
+    end
+
+    module DurationTracking
+      def call(params)
+        start_duration_tracking
+        super(params)
+      ensure
+        finish_duration_tracking
+      end
+    end
+
+    module Logging
+      def call(params)
+        super(params)
+      ensure
+        if params == nil
+          raise '#params is nil inside of a Quiver::Action. Something probably went wrong internally.'
+        end
+
+        logging_fields = default_logging_fields
+
+        self.class.send(:extra_logging_blocks).reverse.each do |block|
+          logging_fields.merge!(instance_exec(&block))
+        end
+
+        logger.info(logging_fields.merge(extra_logging_fields))
+      end
+    end
+
+    module ClassMethods
+      def extra_logging(&block)
+        extra_logging_blocks << block
+      end
+
+      private
+
+      def extra_logging_blocks
+        @extra_logging_blocks ||= []
+      end
+    end
+
+    def internal_call(params)
+      self.params = params
+
+      if params.raw[:terrible_hack].is_a?(JSON::ParserError)
+        return serialize_with(errors: [Quiver::Action::InvalidRequestBodyError.new])
+      end
+
+      serialize_with(run_action)
+    rescue Quiver::Error => e
+      serialize_with(errors: [e])
+    end
+
+    private
+
+    attr_accessor :duration_ms, :db_duration_ms, :duration_start_time, :params
+
+    # for hooking in without prepend
+    def run_action
+      action
+    end
+
+    def start_duration_tracking
+      self.duration_start_time = Time.now
+
+      if defined?(ActiveRecord)
+        ActiveRecord::LogSubscriber.reset_runtime
+      end
+    end
+
+    def finish_duration_tracking
+      if defined?(ActiveRecord) && ActiveRecord::Base.connected?
+        self.db_duration_ms = ActiveRecord::LogSubscriber.reset_runtime
+      else
+        self.db_duration_ms = 0
+      end
+
+      self.duration_ms = (Time.now - duration_start_time) * 1000 - db_duration_ms
+    end
+
+    def extra_logging_fields
+      {}
+    end
+
+    def default_logging_fields
+      {
+        method: params.env['REQUEST_METHOD'],
+        path: request_path_with_query,
+        controller: self.class.to_s.split('::').first.underscore,
+        action: self.class.to_s.split('::').last.underscore,
+        status: @_status || self.class::DEFAULT_RESPONSE_CODE,
+        ip: request.ip,
+        route: "#{self.class.to_s.split('::').first.underscore}##{self.class.to_s.split('::').last.underscore}",
+        request_id: request_id,
+        tags: [:request],
+        duration: duration_ms.round(1),
+        db: db_duration_ms.round(1) || 0,
+        '@timestamp' => Time.now.utc,
+        '@version' => '1'
+      }
+    end
+
+    def route_helper
+      RouteHelper.new(self.class.parents[-2]::Config::Router.new.send(:router))
+    end
+
+    def logger
+      @logger ||= self.class.parents[-2]::Application.logger
+    end
+
+    def patch_serialize_with(data)
+      if data[:patch_data]
+        self.status = 200
+        self.format = :json_api
+        self.body = data[:patch_data].to_json
+      else
+        data[:patch_errors] = data[:patch_errors].map do |datum|
+          datum.select { |k, _| k == :errors }
+        end
+
+        self.status = 400
+        self.format = :json_api
+        self.body = data[:patch_errors].to_json
+      end
+    end
+
+    def serialize_with(data)
+      if data.is_a?(Quiver::Result)
+        mapper_result = data
+        data = if data.success?
+          {
+            data: arrayify(data.object)
+          }.tap do |h|
+            h[:pagination_offset] = data.data[:pagination_offset] if data.data.key?(:pagination_offset)
+            h[:pagination_limit] = data.data[:pagination_limit] if data.data.key?(:pagination_limit)
+            h[:total_count] = data.data[:total_count] if data.data.key?(:total_count)
+          end
+        else
+          {errors: data.errors}
+        end
+      end
+
+      return patch_serialize_with(data) if data.keys.include?(:patch_data) || data.keys.include?(:patch_errors)
+
+      errors = data[:errors] || []
+
+      if errors.count > 0
+        self.status = errors.first.status
+      else
+        if data.keys.count == 0
+          self.status = 204
+        else
+          if mapper_result && data[:data].count == 1 && mapper_result.data[:adapter_op] == :create
+            self.status = 201
+          else
+            self.status = 200
+          end
+        end
+      end
+
+      self.format = :json_api
+      hash_body = self.class.serializer.new({collections: data}).serialize(context: self)
+
+      hash_body.merge!(
+        links: PaginationLinkBuilder.new(
+          request_path_with_query, data[:pagination_offset], data[:pagination_limit], data[:total_count]
+        ).pagination_links
+      ) if data.key?(:pagination_offset)
+
+      meta = {}
+
+      if data.key?(:pagination_offset)
+        meta[:page] ||= {}
+
+        meta[:page][:offset] = data[:pagination_offset] if data.key?(:pagination_offset)
+        meta[:page][:limit] = data[:pagination_limit] if data.key?(:pagination_limit) && data[:pagination_limit] != -1
+        meta[:page][:total] = data[:total_count] if data.key?(:total_count)
+      end
+
+      hash_body.merge!(
+        meta: meta
+      )
+
+      self.body = hash_body.to_json
+    end
+
+    def request_path
+      @request_path ||= request.path || ''
+    end
+
+    def request_path_with_query
+      @request_path_with_query ||= request.fullpath || ''
+    end
+  end
+end
+
+require 'quiver/action/filter_value'
+require 'quiver/action/pagination_link_builder'
+require 'quiver/action/invalid_request_body_error'

data/lib/quiver/action/filter_error.rb

@@ -0,0 +1,33 @@
+module Quiver::Action
+  class FilterError < Quiver::Error
+    attr_reader :detail
+
+    def initialize(detail)
+      self.detail = detail
+    end
+
+    def title
+      'filter_error'
+    end
+
+    def path
+      "/"
+    end
+
+    def status
+      422
+    end
+
+    def code
+      :filter_error
+    end
+
+    def serialization_type
+      'Error'
+    end
+
+    private
+
+    attr_writer :detail
+  end
+end

data/lib/quiver/action/filter_value.rb

@@ -0,0 +1,152 @@
+module Quiver
+  module Action
+    module FilterValue
+      PRESENCE = %w|nil not_nil|.freeze
+      EQUALITIES = %w|eq not_eq|.freeze
+      INCLUSIONS = %w|in not_in|.freeze
+      INEQUALITIES = %w|gt lt gte lte not_gt not_lt not_gte not_lte|.freeze
+
+      def self.with(type, *args, extras:[])
+        set = Set.new(args + extras)
+        klasses[[set, type]] ||= Class.new do
+          include Extant::Attributes
+          include FilterValue
+
+          def self.supported_comparisons
+            @supported_comparisons
+          end
+
+          def self.extra_supported_comparisons
+            @extra_supported_comparisons
+          end
+        end.tap do |klass|
+          klass.instance_variable_set(
+            '@supported_comparisons',
+            set
+          )
+
+          klass.instance_variable_set(
+            '@extra_supported_comparisons',
+            extras
+          )
+
+          extras.each do |extra|
+            klass.send(:attribute, extra, type)
+          end
+
+          if set.include?(:presence)
+            klass.send(:attribute, :nil, String)
+            klass.send(:attribute, :not_nil, String)
+          end
+
+          if set.include?(:equalities)
+            klass.send(:attribute, :eq, type)
+            klass.send(:attribute, :not_eq, type)
+          end
+
+          if set.include?(:inclusions)
+            klass.send(:attribute, :in, Array[type])
+            klass.send(:attribute, :not_in, Array[type])
+          end
+
+          if set.include?(:inequalities)
+            klass.send(:attribute, :gt, type)
+            klass.send(:attribute, :not_gt, type)
+            klass.send(:attribute, :gte, type)
+            klass.send(:attribute, :not_gte, type)
+            klass.send(:attribute, :lt, type)
+            klass.send(:attribute, :not_lt, type)
+            klass.send(:attribute, :lte, type)
+            klass.send(:attribute, :not_lte, type)
+          end
+        end
+      end
+
+      def self.with_all(type, extras:[])
+        with(type, :presence, :equalities, :inequalities, :inclusions)
+      end
+
+      def self.klasses
+        @klasses ||= {}
+      end
+
+      attr_reader :errors
+
+      def initialize(filter)
+        self.errors = Quiver::ErrorCollection.new
+
+        filter = filter.to_h if filter.is_a?(Lotus::Utils::Hash)
+        self.filter = filter
+
+        if filter.is_a?(Hash)
+          keys = filter.keys
+          keys.each do |key|
+            filter[key.sub('~', 'not_')] = filter.delete(key)
+          end
+
+          keys.each do |key|
+            if INCLUSIONS.include?(key) && !filter[key].is_a?(Array)
+              errors << FilterError.new("'#{key}' must map to an Array")
+              filter[key] = []
+            end
+          end
+
+          (filter.keys - supported_comparisons).each do |key|
+            errors << FilterError.new("'#{key}' is not supported")
+            filter.delete(key)
+          end
+
+          filter
+        else
+          filter = {}
+          errors << FilterError.new('filters must be a Hash')
+        end
+
+        super
+
+        validate
+      end
+
+      def filter_attributes
+        attributes.slice(*filter.keys.map(&:to_sym))
+      end
+
+      def valid?
+        !errors.any?
+      end
+
+      private
+
+      attr_writer :errors
+      attr_accessor :filter
+
+      def validate
+        extant_attributes.each do |key, attr_object|
+          if attr_object.set? && !attr_object.coerced?
+            case
+            when EQUALITIES.include?(attr_object.name.to_s) || INEQUALITIES.include?(attr_object.name.to_s) || PRESENCE.include?(attr_object.name.to_s)
+              errors << FilterError.new("'#{attr_object.name}' must not map to Hashes or Arrays")
+            when INCLUSIONS.include?(attr_object.name.to_s)
+              errors << FilterError.new("'#{attr_object.name}' must map to an Array")
+            end
+          end
+        end
+      end
+
+      def supported_comparisons
+        unless @supported_comparisons
+          @supported_comparisons = []
+          @supported_comparisons += PRESENCE if self.class.supported_comparisons.include?(:presence)
+          @supported_comparisons += EQUALITIES if self.class.supported_comparisons.include?(:equalities)
+          @supported_comparisons += INEQUALITIES if self.class.supported_comparisons.include?(:inequalities)
+          @supported_comparisons += INCLUSIONS if self.class.supported_comparisons.include?(:inclusions)
+          @supported_comparisons += self.class.extra_supported_comparisons.map(&:to_s)
+        end
+
+        @supported_comparisons
+      end
+    end
+  end
+end
+
+require 'quiver/action/filter_error'