quiver 0.21.0

data/lib/quiver/adapter/memory_adapter_store.rb

@@ -0,0 +1,34 @@
+module Quiver
+  module Adapter
+    class MemoryAdapterStore
+      def initialize
+        clean!
+      end
+
+      def clean!
+        self.store = {}
+      end
+
+      def get(key)
+        store[key] ||= {}
+      end
+
+      def transaction(&block)
+        pristine_store = store.deep_dup
+
+        begin
+          yield block
+        rescue Quiver::Mappers::RollbackTransaction
+          self.store = pristine_store
+        rescue => ex
+          self.store = pristine_store
+          raise ex
+        end
+      end
+
+      private
+
+      attr_accessor :store
+    end
+  end
+end

data/lib/quiver/adapter/memory_helpers.rb

@@ -0,0 +1,182 @@
+require 'quiver/adapter/memory_adapter_filter'
+
+module Quiver
+  module Adapter
+    module Memory
+      include Quiver::Adapter::HelpersHelpers
+
+      def self.included(host)
+        super
+
+        host.adapter_type(:memory)
+        host.send(:extend, ClassMethods)
+      end
+
+      module ClassMethods
+        def next_pk
+          @pk_series ||= 0
+          @pk_series += 1
+        end
+      end
+
+      def find(primary_key)
+        Quiver::Adapter::AdapterResult.new do |errors|
+          if store.key?(primary_key)
+            load_additional([store[primary_key].dup]).first
+          else
+            errors << Quiver::Mapper::NotFoundError.new('record', 'not_found')
+            nil
+          end
+        end
+      end
+
+      def count
+        count = stores.get(store_key).count
+
+        Quiver::Adapter::AdapterResult.new(count)
+      end
+
+      def create(attributes, transaction)
+        primary_key = new_primary_key
+
+        if attributes[:__type__]
+          attributes = attributes.merge(
+            primary_key_name => primary_key,
+            attributes[:__type__][:name] => attributes[:__type__][:value]
+          )
+
+          attributes.delete(:__type__)
+        else
+          attributes = attributes.merge(
+            primary_key_name => primary_key
+          )
+        end
+
+        store[primary_key] = attributes
+
+        Quiver::Adapter::AdapterResult.new(attributes.dup)
+      end
+
+      def update(attributes, transaction)
+        primary_key = attributes[primary_key_name]
+
+        if attributes[:__type__]
+          attributes = attributes.merge(
+            attributes[:__type__][:name] => attributes[:__type__][:value]
+          )
+
+          attributes.delete(:__type__)
+        end
+
+        Quiver::Adapter::AdapterResult.new do |errors|
+          if store.key?(primary_key)
+            store[primary_key] = attributes.dup
+          else
+            errors << Quiver::Mapper::NotFoundError.new('record', 'does_not_exist')
+            nil
+          end
+        end
+      end
+
+      def hard_delete(attributes, transaction)
+        store = stores.get(store_key)
+
+        Quiver::Adapter::AdapterResult.new do |errors|
+          object = store.delete(attributes[primary_key_name])
+
+          if object
+            {}
+          else
+            errors << Quiver::Mapper::NotFoundError.new('record', 'not_found')
+            nil
+          end
+        end
+      end
+
+      def query(q={})
+        store = stores.get(store_key)
+
+        filter_params = q[:filter] || {}
+        sort_params = q[:sort] || {}
+        pagination_params = q[:page] || {}
+
+        objects = filter_klass.new(
+          store.values,
+          filter_params
+        ).filter
+
+        if sort_params.any?
+          objects = objects.sort do |a, b|
+            sort_params.reduce(0) do |memo, (attr, asc)|
+              attr = attr.to_sym
+
+              # A memo of 0 means either no sorting has happened yet,
+              # or there has been a tie that might need breaking.
+              if memo == 0
+                sign = asc ? 1 : -1
+                sign * (a[attr] <=> b[attr])
+              else
+                memo
+              end
+            end
+          end
+        end
+
+        offset = pagination_params['offset'] || 0
+        limit  = pagination_params['limit'] || -1
+        total_count = objects.count
+
+        if limit == -1
+          range_end = -1
+        else
+          range_end = offset + limit - 1
+        end
+        objects = objects[offset..range_end]
+
+        objects = load_additional(objects.map do |attrs|
+          attrs.dup
+        end)
+
+        result = Quiver::Adapter::AdapterResult.new(objects)
+
+        if pagination_params.any?
+          result.data[:pagination_offset] = offset
+          result.data[:pagination_limit] = limit
+          result.data[:total_count] = total_count
+        end
+
+        result
+      end
+
+      private
+
+      def stores
+        @stores ||= self.class.parents[-2]::Application.memory_adapter_store
+      end
+
+      private
+
+      def load_additional(items)
+        items
+      end
+
+      def new_primary_key
+        self.class.next_pk
+      end
+
+      def store_key
+        mapper_name
+      end
+
+      def store
+        stores.get(store_key.to_s)
+      end
+
+      def filter_klass
+        Quiver::Adapter::MemoryAdapterFilter
+      end
+    end
+
+    MemoryHelpers = Memory
+  end
+end

data/lib/quiver/adapter/memory_uuid_primary_key.rb

@@ -0,0 +1,25 @@
+module Quiver
+  module Adapter
+    module Memory
+      module UuidPrimaryKey
+        def self.included(k)
+          k.send(:extend, ClassMethods)
+        end
+
+        module ClassMethods
+          def next_pk
+            @pk_series ||= []
+
+            new_pk = SecureRandom.uuid
+            while @pk_series.include?(new_pk)
+              new_pk = SecureRandom.uuid
+            end
+
+            @pk_series << new_pk
+            new_pk
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quiver/application.rb

@@ -0,0 +1,128 @@
+module Quiver
+  module Application
+    def self.included(host)
+      host.send(:extend, ClassMethods)
+
+      host.root_module = host.parent
+      host.root_module.const_set(:Adapters, Module.new)
+      host.root_module.const_set(:Duties, Module.new)
+      host.root_module.const_set(:Endpoints, Module.new)
+      host.root_module.const_set(:Models, Module.new)
+      host.root_module.const_set(:Mappers, Quiver::Mappers.dup)
+      host.root_module.const_set(:Serializers, Module.new)
+      host.root_module.const_set(:Tasks, Quiver::Tasks.dup)
+      host.root_module.const_set(:Logger, Quiver::Logger.dup)
+      host.root_module.const_set(:DutyMaster, Quiver::DutyMaster.dup)
+      host.root_module.const_set(:DutyTestHelper, Quiver::DutyTestHelper.dup)
+      host.memory_adapter_store = Quiver::Adapter::MemoryAdapterStore.new
+
+      application_file = caller[0].partition(':').first
+      host.app_root = File.expand_path('..', File.dirname(application_file))
+      host.lib_dir = File.join(host.app_root, 'lib', File.basename(application_file, '.rb'))
+      host.default_adapter_type = :memory
+      host.default_duty_queue_backend = :memory
+    end
+
+    module ClassMethods
+      attr_reader :app_root, :lib_dir, :root_module, :using_active_record,
+        :using_delayed_job
+
+      attr_accessor :memory_adapter_store, :default_adapter_type, :default_duty_queue_backend,
+        :middleware_stack
+
+      def app_root=(path)
+        @app_root ||= path
+      end
+
+      def lib_dir=(path)
+        @lib_dir ||= path
+      end
+
+      def root_module=(mod)
+        @root_module ||= mod
+      end
+
+      def logger
+        @logger ||= begin
+          logger = root_module::Logger.new("log/logstash_#{ENV['RACK_ENV']}.log")
+          logger.formatter = -> (severity, datetime, progname, msg) {
+            "#{msg.to_json}\n"
+          }
+          logger
+        end
+      end
+
+      def middleware_stack
+        @middleware_stack ||= Quiver::MiddlewareStack.new
+      end
+
+      def load_everything!(extra_folders = [])
+        load_env_vars!
+
+        Dir[File.join(lib_dir, 'config', 'initializers', '**', '*.rb')].each { |f| require f}
+
+        if !ENV["#{self.parents.first.to_s.underscore.upcase}_DOUBLE_MODE"]
+          Dir[File.join(app_root, 'config', 'initializers', '**', '*.rb')].each { |f| require f}
+        end
+
+        require File.join(lib_dir, 'config', 'router')
+
+        folders = ['models', 'mappers', 'adapters', 'serializers', 'endpoints', 'duties'] + extra_folders
+
+        folders.each do |folder|
+          Dir[File.join(lib_dir, folder, '*.rb')].each { |f| require f }
+          Dir[File.join(lib_dir, folder, '**', '*.rb')].each { |f| require f }
+        end
+      end
+
+      def use_active_record!(config_path = File.join(app_root, 'config', 'database.yml'))
+        self.using_active_record = true
+        require 'active_record'
+
+        ActiveRecord::Base.configurations = YAML.load(ERB.new(File.read(config_path)).result)
+        ActiveRecord::Base.establish_connection
+      end
+
+      def use_delayed_job!
+        self.using_delayed_job = true
+        require 'delayed_job_active_record'
+      end
+
+      private
+
+      attr_writer :using_active_record, :using_delayed_job
+
+      def load_env_vars!
+        file_path = File.join(lib_dir, 'config', 'environment.yml')
+
+        if File.exist?(file_path)
+          require 'yaml'
+
+          var_data = YAML.load(File.read(file_path))
+
+          var_data.fetch(ENV['RACK_ENV'], {}).each do |k, v|
+            ENV[k.upcase] ||= v.to_s unless v.is_a?(Hash)
+          end
+
+          var_data.each do |k, v|
+            ENV[k.upcase] ||= v.to_s unless v.is_a?(Hash)
+          end
+        end
+      end
+    end
+
+    attr_reader :router
+
+    def initialize
+      self.router = self.class.root_module::Config::Router.new
+    end
+
+    def call(env)
+      self.class.middleware_stack.stack(router).call(env)
+    end
+
+    private
+
+    attr_writer :router
+  end
+end

data/lib/quiver/cli/app.rb

@@ -0,0 +1,25 @@
+require 'thor'
+require 'active_support'
+require 'quiver/version'
+
+require 'quiver/cli/generators/new_application'
+require 'quiver/cli/generators/new_application_cli'
+
+module Quiver
+  module CLI
+    class App < Thor
+      package_name "Quiver"
+
+      desc "server", "run a Quiver application"
+      method_option :host, aliases: ['-h', '-b'], desc: 'host for the server to bind to (default 127.0.0.1)'
+      method_option :port, aliases: '-p', desc: 'port to listen on'
+      method_option :reloading_code, aliases: '-r', desc: 'reload code automatically', type: :boolean, default: true
+      def server
+        require 'quiver/cli/server'
+        Quiver::CLI::Server.new(options).start
+      end
+
+      register(NewApplicationCli, "new", "new APP_NAME", "generates a new Quiver application")
+    end
+  end
+end

data/lib/quiver/cli/generators/endpoint.rb

@@ -0,0 +1,17 @@
+module Quiver
+  module CLI
+    class Endpoint < Thor::Group
+      include Thor::Actions
+
+      argument :name
+
+      def self.source_root
+        File.expand_path(File.join('..', '..'), __FILE__)
+      end
+
+      def first
+        puts name
+      end
+    end
+  end
+end

data/lib/quiver/cli/generators/new_application.rb

@@ -0,0 +1,166 @@
+module Quiver
+  module CLI
+    class NewApplication
+      include Thor::Base
+      include Thor::Actions
+
+      def self.source_root
+        File.expand_path(File.join('..', '..', 'templates'), __FILE__)
+      end
+
+      def self.inherited(subclass)
+        generators_hash.each do |k, v|
+          subclass.generators_hash[k] = v
+        end
+
+        generators_array.each do |i|
+          subclass.generators_array << i
+        end
+      end
+
+      def self.generators_array
+        @generators_array ||= []
+      end
+
+      def self.generators_hash
+        @generators_hash ||= {}
+      end
+
+      def self.register_step(name, step, opts={})
+        generators_hash[name] = step
+        generators_array << name unless opts[:skip_queueing] || generators_array.include?(name)
+      end
+
+      def initialize(name, options)
+        self.name = name
+        self.options = options
+        @destination_stack ||= []
+        self.behavior = :invoke
+      end
+
+      def generate!
+        self.class.generators_array.each do |name|
+          if step = self.class.generators_hash[name]
+            instance_exec(&step)
+          end
+        end
+
+        git_init
+      end
+
+      register_step :gemfile, proc {
+        template(
+          File.join('Gemfile.tt'),
+          File.join(underscored_name, 'Gemfile')
+        )
+      }
+
+      register_step :gemspec, proc {
+        template(
+          File.join('gemspec.tt'),
+          File.join(underscored_name, "#{underscored_name}.gemspec")
+        )
+      }
+
+      register_step :rakefile, proc {
+        template(
+          File.join('Rakefile.tt'),
+          File.join(underscored_name, 'Rakefile')
+        )
+      }
+
+      register_step :config_ru, proc {
+        template(
+          File.join('config.tt'),
+          File.join(underscored_name, 'config.ru')
+        )
+      }
+
+      register_step :application, proc {
+        template(
+          File.join('lib', 'application.tt'),
+          File.join(underscored_name, 'lib', "#{underscored_name}.rb")
+        )
+      }
+
+      register_step :version, proc {
+        template(
+          File.join('lib', 'application', 'version.tt'),
+          File.join(underscored_name, 'lib', underscored_name, 'version.rb')
+        )
+      }
+
+      register_step :router, proc {
+        template(
+          File.join('lib', 'application', 'config', 'router.tt'),
+          File.join(underscored_name, 'lib', underscored_name, 'config', 'router.rb')
+        )
+      }
+
+      register_step :gitkeeps, proc {
+        create_file(File.join(underscored_name, 'config', '.gitkeep'))
+        create_file(File.join(underscored_name, 'lib', underscored_name, 'adapters', '.gitkeep'))
+        create_file(File.join(underscored_name, 'lib', underscored_name, 'endpoints', '.gitkeep'))
+        create_file(File.join(underscored_name, 'lib', underscored_name, 'mappers', '.gitkeep'))
+        create_file(File.join(underscored_name, 'lib', underscored_name, 'models', '.gitkeep'))
+        create_file(File.join(underscored_name, 'lib', underscored_name, 'serializers', '.gitkeep'))
+      }
+
+      register_step :gitignore, proc {
+        template(
+          File.join('gitignore.tt'),
+          File.join(underscored_name, '.gitignore')
+        )
+      }
+
+      register_step :spec_helper, proc {
+        if options[:rspec]
+          template(
+            File.join('spec', 'spec_helper.tt'),
+            File.join(underscored_name, 'spec', 'spec_helper.rb')
+          )
+
+          create_file(File.join(underscored_name, 'spec', 'support', '.gitkeep'))
+        end
+      }
+
+      register_step :active_record, proc {
+        if options[:active_record]
+          create_file(File.join(underscored_name, 'db', 'migrate', '.gitkeep'))
+
+          template(
+            File.join('config', 'database.tt'),
+            File.join(underscored_name, 'config', 'database.yml')
+          )
+
+          template(
+            File.join('config', 'database.tt'),
+            File.join(underscored_name, 'config', 'database.example.yml')
+          )
+        end
+      }
+
+      private
+
+      attr_accessor :name, :options
+
+      def underscored_name
+        @underscored_name ||= name.underscore
+      end
+
+      def camelized_name
+        @camelized_name ||= name.camelize
+      end
+
+      def git_init
+        inside(underscored_name) do
+          run('git init')
+          run('git add .')
+
+          output = run(%Q{git commit -m " Initial Commit\n _____________________\n|                    /--<<<\n|___________________/----<<<"}, verbose: false, capture: true)
+          puts output.sub(/Commit.*?\n/, "Commit\n")
+        end
+      end
+    end
+  end
+end