shogun 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: caae485be3f9b7816128451965ff1acbe5d0ff37
+  data.tar.gz: ef5108915c2044a505a1f57f1bb3d8f965d22d28
+SHA512:
+  metadata.gz: 42da9e33491a23787326a5c8ec8ce174b4430a7a7c9ebfa60d2b0d610d0cd4b2338e4f6b44416cf5053a3f35b266e990a8f3fd1a5ece4fda0a06058b526b0c73
+  data.tar.gz: 0a55db9e31daef5f4056f522f6ead270ce1b854fa83d76f7bbc487032603ddcaee5f99527d6237a86308cd714e6c1bb9887447bbddc8d0e6f66e7aa2b23a3cfd

data/bin/shogun

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require "shogun"
+require "pry"
+require Dir["./lib/*.rb"].first
+
+case ARGV.shift
+when "database" then
+  case ARGV.shift
+  when "reset" then
+    Shogun::Database.setup!(logger: Logger.new(STDOUT))
+  when "console" then
+    Shogun::Database.new(logger: Logger.new(STDOUT))
+    binding.pry
+  end
+when "console" then
+  binding.pry
+end

data/lib/shogun.rb

@@ -0,0 +1,29 @@
+require "adamantium"
+require "rack-protection"
+require "rack-commonlogger"
+require "rack-body_serializer"
+require "rack-authentication_bearer"
+require "rack-body_deserializer"
+require "rack-accept_setter"
+require "rack-chunker"
+require "rack-content_length_setter"
+require "rack-runtime"
+require "rack-log"
+require "scrawl"
+require "active_record"
+
+module Shogun
+  require_relative "shogun/authorizer"
+  require_relative "shogun/control"
+  require_relative "shogun/database"
+  require_relative "shogun/denormalizer"
+  require_relative "shogun/dispatch"
+  require_relative "shogun/endpoint"
+  require_relative "shogun/normalizer"
+  require_relative "shogun/presenter"
+  require_relative "shogun/presenters"
+  require_relative "shogun/server"
+  require_relative "shogun/validator"
+  require_relative "shogun/verifier"
+  require_relative "shogun/version"
+end

data/lib/shogun/authorizer.rb

@@ -0,0 +1,7 @@
+module Shogun
+  module Authorizer
+    def denied?
+      !allowed?
+    end
+  end
+end

data/lib/shogun/control.rb

@@ -0,0 +1,82 @@
+module Shogun
+  module Control
+    CONTINUE = 100
+    SWITCHING_PROTOCOLS = 101
+    PROCESSING = 102
+    OK = 200
+    CREATED = 201
+    ACCEPTED = 202
+    NONAUTHORITATIVE_INFORMATION = 203
+    NO_CONTENT = 204
+    RESET_CONTENT = 205
+    PARTIAL_CONTENT = 206
+    MULTISTATUS = 207
+    ALREADY_REPORTED = 208
+    IM_USED = 226
+    MULTIPLE_CHOICES = 300
+    MOVED_PERMANENTLY = 301
+    FOUND = 302
+    SEE_OTHER = 303
+    NOT_MODIFIED = 304
+    USE_PROXY = 305
+    RESERVED = 306
+    TEMPORARY_REDIRECT = 307
+    PERMANENT_REDIRECT = 308
+    BAD_REQUEST = 400
+    UNAUTHORIZED = 401
+    PAYMENT_REQUIRED = 402
+    FORBIDDEN = 403
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    NOT_ACCEPTABLE = 406
+    PROXY_AUTHENTICATION_REQUIRED = 407
+    REQUEST_TIMEOUT = 408
+    CONFLICT = 409
+    GONE = 410
+    LENGTH_REQUIRED = 411
+    PRECONDITION_FAILED = 412
+    REQUEST_ENTITY_TOO_LARGE = 413
+    REQUEST_URI_TOO_LONG = 414
+    UNSUPPORTED_MEDIA_TYPE = 415
+    REQUESTED_RANGE_NOT_SATISFIABLE = 416
+    EXPECTATION_FAILED = 417
+    IM_A_TEAPOT = 418
+    UNPROCESSABLE_ENTITY = 422
+    LOCKED = 423
+    FAILED_DEPENDENCY = 424
+    UPGRADE_REQUIRED = 426
+    PRECONDITION_REQUIRED = 428
+    TOO_MANY_REQUESTS = 429
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431
+    INTERNAL_SERVER_ERROR = 500
+    NOT_IMPLEMENTED = 501
+    BAD_GATEWAY = 502
+    SERVICE_UNAVAILABLE = 503
+    GATEWAY_TIMEOUT = 504
+    HTTP_VERSION_NOT_SUPPORTED = 505
+    VARIANT_ALSO_NEGOTIATES = 506
+    INSUFFICIENT_STORAGE = 507
+    LOOP_DETECTED = 508
+    NOT_EXTENDED = 510
+    NETWORK_AUTHENTICATION_REQUIRED = 511
+
+    require_relative "control/null"
+
+
+    def to_a
+      [status, headers, body]
+    end
+
+    private def status
+      @status || INTERNAL_SERVER_ERROR
+    end
+
+    private def headers
+      @headers || {}
+    end
+
+    private def body
+      if @denormalizer then @denormalizer.as_document else "" end
+    end
+  end
+end

data/lib/shogun/control/null.rb

@@ -0,0 +1,15 @@
+module Shogun
+  module Control
+    class Null
+      include Shogun::Control
+
+      def initialize(payload:)
+        # Don't bother with anything here
+      end
+
+      def to_a
+        [NOT_FOUND, {}, ""]
+      end
+    end
+  end
+end

data/lib/shogun/database.rb

@@ -0,0 +1,44 @@
+module Shogun
+  class Database
+    URL_NAME = "DATABASE_URL"
+    TIMEZONE_NAME = "DATABASE_TIMEZONE"
+    REAP_FREQUENCY_NAME = "DATABASE_REAP_FREQUENCY"
+    POOL_NAME = "DATABASE_POOL"
+    TIMEOUT_NAME = "DATABASE_TIMEOUT"
+    URL = ENV[URL_NAME]
+    TIMEZONE = ENV[TIMEZONE_NAME]
+    REAP_FREQUENCY = ENV[REAP_FREQUENCY_NAME]
+    POOL = ENV[POOL_NAME]
+    TIMEOUT = ENV[TIMEOUT_NAME]
+    DEFAULT_TIMEOUT = 20
+    DEFAULT_REAP_FREQUENCY = 15
+    DEFAULT_POOL = 10
+    DEFAULT_TIMEZONE = "utc"
+    CONFIGURATION = {
+      "reaping_frequency" => Integer(REAP_FREQUENCY || DEFAULT_REAP_FREQUENCY),
+      "pool" => Integer(POOL || DEFAULT_POOL),
+      "connect_timeout" => Integer(TIMEOUT || DEFAULT_TIMEOUT)
+    }
+
+    def self.connection
+      ActiveRecord::Base.connection
+    end
+
+    def self.setup!(logger:)
+      new(logger: logger).tap do
+        connection.enable_extension("uuid-ossp")
+        ActiveRecord::Base.descendants.each(&:setup!)
+      end
+    end
+
+    def initialize(logger:)
+      @logger = logger
+      ActiveRecord::LogSubscriber.logger = @logger
+      ActiveRecord::LogSubscriber.colorize_logging = false
+      ActiveRecord::Base.time_zone_aware_attributes = true
+      ActiveRecord::Base.default_timezone = (self.class.const_get("TIMEZONE") || self.class.const_get("DEFAULT_TIMEZONE")).to_sym
+      ActiveRecord::Base.logger = @logger
+      ActiveRecord::Base.establish_connection("#{self.class.const_get("URL")}?#{self.class.const_get("CONFIGURATION").to_query}")
+    end
+  end
+end

data/lib/shogun/denormalizer.rb

@@ -0,0 +1,54 @@
+module Shogun
+  module Denormalizer
+    META_KEY = "meta"
+    LINKS_KEY = "links"
+    LINKED_KEY = "linked"
+
+    def initialize(object:, fields:)
+      @object = object
+      @fields = fields
+      @meta = object.meta
+      @links = object.links
+      @linked = object.linked
+    end
+
+    def as_document
+      {
+        document_key => document,
+        meta_key => @meta,
+        links_key => @links,
+        linked_key => @linked
+      }
+    end
+
+    private def document
+      if @fields.one?
+        @object.public_send(@fields.first)
+      else
+        @fields.inject({}) do |hash, field|
+          hash.merge(field => @object.public_send(mapping[field]))
+        end
+      end
+    end
+
+    private def document_key
+      self.class.const_get("DOCUMENT_KEY")
+    end
+
+    private def meta_key
+      self.class.const_get("META_KEY")
+    end
+
+    private def links_key
+      self.class.const_get("LINKS_KEY")
+    end
+
+    private def linked_key
+      self.class.const_get("LINKED_KEY")
+    end
+
+    private def mapping
+      self.class.const_get("MAPPING")
+    end
+  end
+end

data/lib/shogun/dispatch.rb

@@ -0,0 +1,67 @@
+module Shogun
+  class Dispatch
+    PATH_KEY = "REQUEST_PATH"
+    METHOD_KEY = "REQUEST_METHOD"
+    NO_MATCH = -> { // }
+
+    require_relative "dispatch/route"
+    require_relative "dispatch/payload"
+    require_relative "dispatch/lookup"
+
+    attr_reader :routes
+    private :routes
+
+    attr_reader :payload
+    private :payload
+
+    attr_reader :lookup
+    private :lookup
+
+    attr_reader :route
+    private :route
+
+    def initialize(logger:)
+      @routes = {}
+      @logger = logger
+      yield(self)
+    end
+
+    def call(state)
+      @state = state
+
+      lookup = Lookup.new(routes: routes, verb: state[METHOD_KEY], path: state[PATH_KEY])
+
+      payload = Payload.new(state: state, lookup: lookup)
+
+      route = lookup.to_route
+
+      control = route.control.new(payload: payload)
+
+      control.to_a
+    end
+
+    def push(route:)
+      routes[route.as_key] = route
+    end
+
+    private def stack
+      @stack
+    end
+
+    private def state
+      @state
+    end
+
+    private def headers
+      @headers
+    end
+
+    private def status
+      @status
+    end
+
+    private def body
+      @body
+    end
+  end
+end

data/lib/shogun/dispatch/lookup.rb

@@ -0,0 +1,57 @@
+module Shogun
+  class Dispatch
+    class Lookup
+      include Adamantium
+
+      attr_reader :routes
+      private :routes
+
+      def initialize(routes:, verb:, path:)
+        @routes = routes
+        @verb = verb
+        @path = path
+      end
+
+      def request
+        "#{@verb} #{@path}"
+      end
+      memoize :request
+
+      def payload
+        if match.captures.any?
+          match.names.zip(match.captures).to_h
+        else
+          {}
+        end
+      end
+      memoize :payload
+
+      def to_route
+        regular || regexp || Route::Null.new
+      end
+      memoize :to_route
+
+      private def regexp
+        routes[pattern]
+      end
+      memoize :regexp
+
+      private def regular
+        routes[request]
+      end
+      memoize :regular
+
+      private def match
+        request.match(pattern)
+      end
+      memoize :match
+
+      private def pattern
+        routes.keys.detect(NO_MATCH) do |key|
+          if key.is_a?(Regexp) then request =~ key else next end
+        end
+      end
+      memoize :pattern
+    end
+  end
+end

data/lib/shogun/dispatch/payload.rb

@@ -0,0 +1,18 @@
+module Shogun
+  class Dispatch
+    class Payload
+      QUERY_KEY = "rack.request.query_hash"
+
+      def initialize(state:, lookup:)
+        @body = state[Rack::BodyDeserializer::RACK_KEY] || {}
+        @query = state[QUERY_KEY] || {}
+        @uri = lookup.payload
+        @sections = [state, @uri, @query, @body]
+      end
+
+      def to_hash
+        @sections.inject(:merge)
+      end
+    end
+  end
+end

data/lib/shogun/dispatch/route.rb

@@ -0,0 +1,34 @@
+module Shogun
+  class Dispatch
+    class Route
+      require_relative "route/null"
+
+      attr_reader :control
+
+      def initialize(namespace:, verb:, matcher:, control:)
+        @namespace = namespace
+        @verb = verb
+        @matcher = matcher
+        @control = control
+      end
+
+      def as_key
+        if expression? then Regexp.new("^#{verb} /#{path}$") else "#{verb} /#{path}" end
+      end
+
+      private def path
+        @path ||= [@namespace, @matcher].compact.join("/")
+      end
+
+      private def verb
+        @verb.to_s.upcase
+      end
+
+      private def expression?
+        [@namespace, @matcher].any? do |item|
+          item.is_a?(Regexp)
+        end
+      end
+    end
+  end
+end