quiver 0.21.0

data/lib/quiver/serialization.rb

@@ -0,0 +1,6 @@
+module Quiver
+  module Serialization
+  end
+end
+
+require 'quiver/serialization/json_api'

data/lib/quiver/serialization/json_api.rb

@@ -0,0 +1,7 @@
+module Quiver::Serialization
+  module JsonApi
+  end
+end
+
+require 'quiver/serialization/json_api/item_type_handler'
+require 'quiver/serialization/json_api/serializer'

data/lib/quiver/serialization/json_api/item_type_handler.rb

@@ -0,0 +1,96 @@
+module Quiver::Serialization::JsonApi
+  class NoIdError < StandardError
+  end
+
+  class ItemTypeHandler
+    attr_accessor :type
+
+    def initialize(type, config_block, no_id=false)
+
+      self.attributes_storage = {}
+      self.links = {}
+      self.type = type
+
+      instance_exec(&config_block)
+
+      raise NoIdError, "no :id in handler for type #{type}" unless no_id || attributes_storage[:id]
+    end
+
+    def link(name, opts={})
+      links[name] = opts
+    end
+
+    def attribute(name, opts={})
+      attributes_storage[name] = opts
+    end
+
+    def attributes(*names)
+      names.each do |name|
+        attribute(name)
+      end
+    end
+
+    def calculated_attribute(name, &block)
+      attributes_storage[name] = {
+        proc: block
+      }
+    end
+
+    def serialize(item, opts={})
+      context = opts[:context]
+
+      serialized_links = links.each_with_object({}) do |(name, opts), h|
+        h[name] = {}
+
+        if href_proc = opts[:resource]
+          h[name][:resource] = context.instance_exec(item, &href_proc)
+        end
+
+        if self_proc = opts[:self]
+          h[name][:self] = context.instance_exec(item, &self_proc)
+        end
+
+        if value_proc = opts[:value]
+          value = value_from_proc(value_proc, item)
+          key = value.is_a?(Array) ? :ids : :id
+
+          h[name][key] = value
+        end
+
+        if type = opts[:type]
+          h[name][:type] = type
+        end
+
+        h[name].merge!(scope: context.instance_exec(item, &opts[:scope])) if opts[:scope]
+      end
+
+      serialized_attributes = attributes_storage.each_with_object({}) do |(name, opts), h|
+        if proc = opts[:proc]
+          h[name] = context.instance_exec(item, &proc)
+        elsif attr_alias = opts[:alias]
+          h[name] = item.send(attr_alias)
+        else
+          h[name] = item.send(name)
+        end
+      end
+
+      if serialized_links.count > 0
+        serialized_attributes.merge(links: serialized_links)
+      else
+        serialized_attributes
+      end
+    end
+
+    private
+
+    attr_accessor :attributes_storage, :links
+
+    def value_from_proc(potential_proc, item)
+      if potential_proc.respond_to?(:call)
+        potential_proc.call(item)
+      else
+        potential_proc
+      end
+    end
+  end
+end

data/lib/quiver/serialization/json_api/serializer.rb

@@ -0,0 +1,77 @@
+module Quiver::Serialization
+  module JsonApi
+    module Serializer
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+      end
+
+      attr_accessor :collection_info
+
+      def initialize(collection_info)
+        self.collection_info = collection_info
+      end
+
+      def serialize(opts={})
+        output = {}
+
+        [:data, :linked, :errors].each do |type|
+          if collection = fetch_collection(type)
+            output[type] = serialize_items(collection, opts)
+          end
+        end
+
+        output
+      end
+
+      private
+
+      def fetch_collection(key)
+        collection_info[:collections][key]
+      end
+
+      def serialize_items(items, opts)
+        items.map do |item|
+          serialization_type = if item.respond_to?(:serialization_type)
+            item.serialization_type
+          else
+            item.class.name
+          end
+
+          if handler = self.class.type_handlers[serialization_type]
+            handler.serialize(item, opts).merge(
+              type: serialization_type.underscore.pluralize
+            )
+          end
+        end.compact
+      end
+
+      module ClassMethods
+        def self.extended(base)
+          base.instance_variable_set('@type_handlers', {})
+
+          begin
+            base.for_type 'Error', JsonApi::ItemTypeHandler.new('Error', -> {
+              attributes :title, :detail, :path, :code
+              calculated_attribute(:status) { |item| item.status.to_s }
+            }, true)
+          rescue JsonApi::NoIdError
+          end
+        end
+
+        attr_accessor :type_handlers
+
+        def for_type(type, handler=nil, &block)
+          if handler
+            type_handlers[type] = handler
+          else
+            type_handlers[type] = JsonApi::ItemTypeHandler.new(type, block)
+          end
+        end
+
+        def type_handlers
+          instance_variable_get('@type_handlers')
+        end
+      end
+    end
+  end
+end

data/lib/quiver/tasks.rb

@@ -0,0 +1,31 @@
+module Quiver
+  module Tasks
+    def self.load_tasks
+      if parent::Application.using_active_record
+        include(::ActiveRecord::Tasks)
+        load_active_record_tasks
+      end
+    end
+
+    private
+
+    def self.load_active_record_tasks
+      load 'active_record/railties/databases.rake'
+
+      database_tasks_constant = parent::Tasks::DatabaseTasks
+
+      ::ActiveRecord::Base.schema_format = :ruby #configuration.schema_format
+      database_tasks_constant.env = ENV['RACK_ENV'] #configuration.environment
+      database_tasks_constant.seed_loader = "Later" #configuration.seed_loader
+
+      database_configuration = YAML.load(ERB.new(File.read(File.join(parent::Application.app_root, 'config', 'database.yml'))).result)
+
+      ::ActiveRecord::Base.configurations = database_tasks_constant.database_configuration = database_configuration
+
+      database_tasks_constant.current_config = database_configuration[ENV['RACK_ENV']]
+      database_tasks_constant.db_dir = File.join(parent::Application.app_root, 'db')
+      database_tasks_constant.migrations_paths = File.join(parent::Application.app_root, 'db', 'migrate')
+      database_tasks_constant.root = parent::Application.app_root
+    end
+  end
+end

data/lib/quiver/validator.rb

@@ -0,0 +1,83 @@
+module Quiver
+  module Validators; end
+
+  require 'quiver/validators/base'
+  require 'quiver/validators/presence'
+  require 'quiver/validators/unique'
+
+  class Validator
+    VALIDATORS = {
+      presence: Quiver::Validators::Presence,
+      unique: Quiver::Validators::Unique
+    }.freeze
+
+    def initialize(definitions)
+      self.definitions = definitions
+    end
+
+    def validate(object, options={})
+      tags = options[:tags] || []
+
+      error_collections = definitions.map do |definition|
+        next unless tags_match?(tags, definition)
+
+        if definition[:options][:if]
+          next if !definition[:options][:if].call(object)
+        end
+
+        if definition[:options][:unless]
+          next if definition[:options][:unless].call(object)
+        end
+
+        attr_or_proc = definition[:attr_or_proc]
+
+        validator_options = definition[:options].select do |k, v|
+          !%i|except only if unless|.include?(k)
+        end
+
+        if attr_or_proc.is_a?(Proc)
+          result = attr_or_proc.call(object)
+
+          unless result.is_a?(Quiver::ErrorCollection)
+            raise TypeError, 'proc validators must return a Quiver::ErrorCollection'
+          end
+
+          result
+        else
+          value = object.public_send(attr_or_proc)
+
+          results = validator_options.map do |k, v|
+            validator_klass = VALIDATORS[k] || next
+            validator = validator_klass.new(
+              value, v, attr_or_proc, options[:mapper], options[:model]
+            )
+
+            validator.validate
+          end
+
+          results.compact.reduce(:+)
+        end
+      end
+
+      error_collections.compact.reduce(:+) || Quiver::ErrorCollection.new
+    end
+
+    private
+
+    attr_accessor :definitions
+
+    def tags_match?(tags, definition)
+      definition_options = definition[:options]
+
+      if definition_options.key?(:except)
+        return false if (definition_options[:except] & tags).any?
+      end
+
+      if definition_options.key?(:only)
+        return false unless definition_options[:only].any? { |t| tags.include?(t) }
+      end
+
+      return true
+    end
+  end
+end

data/lib/quiver/validators/base.rb

@@ -0,0 +1,21 @@
+module Quiver
+  module Validators
+    class Base
+      def initialize(value, options, name, mapper=nil, model=nil)
+        self.value = value
+        self.options = options
+        self.name = name
+        self.mapper = mapper
+        self.model = model
+      end
+
+      private
+
+      attr_accessor :value, :options, :name, :mapper, :model
+
+      def adapter
+        mapper.send(:adapter)
+      end
+    end
+  end
+end

data/lib/quiver/validators/presence.rb

@@ -0,0 +1,34 @@
+module Quiver
+  module Validators
+    class Presence < Base
+      def validate
+        error_collection = Quiver::ErrorCollection.new
+
+        # if options is true
+        # then the value must be non-nil
+        # otherwise it must be nil
+        if options
+          if value == nil
+            error_collection << Quiver::Model::ValidationError.new(name, failed_presence_type)
+          end
+        else
+          if value != nil
+            error_collection << Quiver::Model::ValidationError.new(name, failed_non_presence_type)
+          end
+        end
+
+        error_collection
+      end
+
+      private
+
+      def failed_presence_type
+        "should_be_present"
+      end
+
+      def failed_non_presence_type
+        "should_not_be_present"
+      end
+    end
+  end
+end

data/lib/quiver/validators/unique.rb

@@ -0,0 +1,33 @@
+require 'quiver/action/filter_value'
+
+module Quiver
+  module Validators
+    class Unique < Base
+      def validate
+        errors = Quiver::ErrorCollection.new
+
+        result = mapper.send(:query,
+          filter: {
+            name => {'eq' => value}
+          }
+        )
+
+        if result.object.any?
+          unless result.object.size == 1 &&
+            result.object.first.send(adapter.class.primary_key_name) == model.send(adapter.class.primary_key_name)
+
+            errors << Quiver::Model::ValidationError.new(name, must_be_unique)
+          end
+        end
+
+        errors
+      end
+
+      private
+
+      def must_be_unique
+        'must_be_unique'
+      end
+    end
+  end
+end

data/lib/quiver/version.rb

@@ -0,0 +1,3 @@
+module Quiver
+  VERSION = "0.21.0"
+end

data/quiver.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'quiver/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "quiver"
+  spec.version       = Quiver::VERSION
+  spec.authors       = ["NCC Group Domain Services"]
+  spec.email         = ["brady.love@nccgroup.trust", "emily.dobervich@nccgroup.trust"]
+  spec.licenses      = ['MIT']
+
+  spec.summary       = %q{Quiver is web API framework}
+  spec.description   = %q{Quiver is a framework for writing web APIs}
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.executables << "quiver"
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "shotgun", "~> 0.9"
+  spec.add_dependency "thor", "~> 0.19"
+  spec.add_dependency "rack", "~> 1.5"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "lotus-router", "0.3.0"
+  spec.add_dependency "lotus-controller", "0.4.0"
+  spec.add_dependency "pry"
+  spec.add_dependency "extant", "~> 0.3"
+  spec.add_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "delayed_job_active_record"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "factory_girl"
+  spec.add_development_dependency "ffaker"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "timecop"
+end