modern 0.4.2

data/lib/modern/dsl/scope.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'modern/struct'
+
+require 'modern/capsule'
+require 'modern/descriptor'
+
+require 'modern/dsl/scope_settings'
+
+require 'deep_dup'
+require 'docile'
+require 'ice_nine'
+
+module Modern
+  module DSL
+    class Scope
+      attr_reader :settings
+      attr_reader :descriptor
+
+      def initialize(descriptor, settings = nil)
+        @descriptor = descriptor
+        @settings = settings&.dup || ScopeSettings.new
+      end
+
+      def capsule(cap)
+        raise "Must be a Modern::Capsule." unless cap.is_a?(Modern::Capsule)
+        @descriptor = _scope({}, &cap.block)
+      end
+
+      def path(p, &block)
+        p_segs = p.split("/")
+        new_path_segments = ([@settings.path_segments] + p_segs).flatten
+        @descriptor = _scope(path_segments: new_path_segments, &block)
+      end
+
+      def default_response(&block)
+        resp = ResponseBuilder.evaluate(@settings.default_response, &block)
+        @settings = @settings.copy(default_response: resp)
+      end
+
+      def deprecate!
+        @settings = @settings.copy(deprecated: true)
+      end
+
+      def tag(t)
+        @settings = @settings.copy(tags: @settings.tags + [t.to_s])
+      end
+
+      def helper(h)
+        @settings = @settings.copy(helpers: @settings.helpers + [h])
+      end
+
+      def parameter(name, parameter_type, opts)
+        param = Modern::Descriptor::Parameters.from_inputs(name, parameter_type, opts)
+        raise "Duplicate parameter '#{name}'.'" if @settings.parameters.any? { |p| p.name == param.name }
+
+        @settings = @settings.copy(parameters: @settings.parameters + [param])
+      end
+
+      def clear_security!
+        @settings = @settings.copy(security: [])
+      end
+
+      def security(sec)
+        @settings = @settings.copy(security: @settings.security + [sec])
+      end
+
+      def input_converter(media_type_or_converter, &block)
+        if media_type_or_converter.is_a?(Modern::Descriptor::Converters::Input::Base)
+          @settings = @settings.copy(input_converters: @settings.input_converters + [media_type_or_converter])
+        elsif media_type_or_converter.is_a?(String) && !block.nil?
+          input_converter(
+            Modern::Descriptor::Converters::Input::Base.new(
+              media_type: media_type_or_converter, converter: block
+            )
+          )
+        else
+          raise "must pass a String and block or a Modern::Descriptor::Converters::Input::Base."
+        end
+      end
+
+      def clear_input_converters!
+        @settings = @settings.copy(input_converters: [])
+      end
+
+      def output_converter(media_type_or_converter, &block)
+        if media_type_or_converter.is_a?(Modern::Descriptor::Converters::Output::Base)
+          @settings = @settings.copy(output_converters: @settings.output_converters + [media_type_or_converter])
+        elsif media_type_or_converter.is_a?(String) && !block.nil?
+          output_converter(
+            Modern::Descriptor::Converters::Output::Base.new(
+              media_type: media_type_or_converter, converter: block
+            )
+          )
+        else
+          raise "must pass a String and block or a Modern::Descriptor::Converters::Output::Base."
+        end
+      end
+
+      def clear_output_converters!
+        @settings = @settings.copy(output_converters: [])
+      end
+
+      def route(id, http_method, path = nil, &block)
+        route = RouteBuilder.evaluate(id, http_method, path, @settings.dup, &block)
+        @descriptor = @descriptor.copy(routes: @descriptor.routes + [route])
+      end
+
+      def get(id, path = nil, &block)
+        route(id, :get, path, &block)
+      end
+
+      def post(id, path = nil, &block)
+        route(id, :post, path, &block)
+      end
+
+      def put(id, path = nil, &block)
+        route(id, :put, path, &block)
+      end
+
+      def delete(id, path = nil, &block)
+        route(id, :delete, path, &block)
+      end
+
+      def patch(id, path = nil, &block)
+        route(id, :patch, path, &block)
+      end
+
+      def self.evaluate(descriptor, settings, &block)
+        scope = Scope.new(descriptor, settings)
+        scope.instance_exec(&block)
+
+        scope.descriptor
+      end
+
+      private
+
+      def _scope(new_settings = {}, &block)
+        ret = Scope.evaluate(descriptor, @settings.copy(new_settings), &block)
+        ret
+      end
+    end
+  end
+end

data/lib/modern/dsl/scope_settings.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'modern/struct'
+
+require 'modern/capsule'
+require 'modern/descriptor'
+
+require 'deep_dup'
+require 'docile'
+require 'ice_nine'
+
+module Modern
+  module DSL
+    class ScopeSettings < Modern::Struct
+      attribute :path_segments, Types.array_of(
+        Types::Strict::String.constrained(
+          format: %r,[^/]+,
+        )
+      )
+
+      attribute :tags, Types.array_of(Types::Strict::String)
+
+      attribute :deprecated, Types::Strict::Bool.default(false)
+
+      attribute :parameters, Types.array_of(Modern::Descriptor::Parameters::Base)
+
+      attribute :default_response, Modern::Descriptor::Response.optional.default(
+        Modern::Descriptor::Response.new(http_code: :default)
+      )
+
+      # TODO: this code gets way less gross when we get Types.Map
+      attribute :input_converters, Types.array_of(Modern::Descriptor::Converters::Input::Base)
+      attribute :output_converters, Types.array_of(Modern::Descriptor::Converters::Output::Base)
+
+      attribute :security, Types.array_of(Modern::Descriptor::Security::Base)
+      attribute :helpers, Types.array_of(Types.Instance(Module))
+    end
+  end
+end

data/lib/modern/dsl.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'modern/descriptor'
+
+# TODO: make the DSL in general more efficient
+#       The various copies in every class in this DSL builder are probably
+#       unavoidable. Which is a bummer. But we could probably reduce the amount
+#       of code involved. I've been trying to think of a good way to make a
+#       generalized builder for Dry::Struct; anybody have a good idea?
+# TODO: Figure out why Docile (hence removed) causes settings leaks
+#       For SOME awful reason, `@settings` in sub-scopes is leaking out to
+#       parent scopes. I have only isolated this down to Docile, as when I use
+#       `instance_exec` it doesn't happen.
+Dir["#{__dir__}/dsl/**/*.rb"].each { |f| require_relative f }

data/lib/modern/errors/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Modern
+  module Errors
+    class Error < RuntimeError; end
+  end
+end

data/lib/modern/errors/setup_errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "modern/errors/error"
+
+module Modern
+  module Errors
+    class SetupError < Modern::Errors::Error; end
+
+    class RoutingError < SetupError; end
+  end
+end

data/lib/modern/errors/web_errors.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "modern/errors/error"
+
+module Modern
+  module Errors
+    class WebError < Modern::Errors::Error
+      def status
+        raise "#{self.class.name}#status must be implemented."
+      end
+    end
+
+    class BadRequestError < WebError
+      def initialize(msg = "Bad request")
+        super(msg)
+      end
+
+      def status
+        400
+      end
+    end
+
+    class UnauthorizedError < WebError
+      def initialize(msg = "Unauthorized")
+        super(msg)
+      end
+
+      def status
+        401
+      end
+    end
+
+    class ForbiddenError < WebError
+      def initialize(msg = "Forbidden")
+        super(msg)
+      end
+
+      def status
+        403
+      end
+    end
+
+    class NotFoundError < WebError
+      def initialize(msg = "Not found")
+        super(msg)
+      end
+
+      def status
+        404
+      end
+    end
+
+    class NotAcceptableError < WebError
+      def initialize(msg = "Not acceptable (no servable content types in Accept header)")
+        super(msg)
+      end
+
+      def status
+        406
+      end
+    end
+
+    class UnsupportedMediaTypeError < WebError
+      def initialize(msg = "Unrecognized request Content-Type.")
+        super(msg)
+      end
+
+      def status
+        415
+      end
+    end
+
+    class UnprocessableEntity < WebError
+      def initialize(msg = "Recognized content-type of body, but could not parse it.")
+        super(msg)
+      end
+
+      def status
+        422
+      end
+    end
+  end
+end

data/lib/modern/errors.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir["#{__dir__}/errors/*.rb"].each { |f| require_relative f }

data/lib/modern/redirect.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Modern
+  # rubocop:disable Lint/InheritException
+  class Redirect < Exception
+    attr_reader :redirect_to
+
+    def initialize(redirect_to)
+      raise "Redirects require a target." if redirect_to.nil?
+      @redirect_to = redirect_to
+    end
+
+    def status
+      raise "#{self.class.name}#status must be implemented."
+    end
+  end
+  # rubocop:enable Lint/InheritException
+
+  class PermanentRedirect < Redirect
+    def status
+      308
+    end
+  end
+
+  class TemporaryRedirect < Redirect
+    def status
+      307
+    end
+  end
+end

data/lib/modern/request.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rack'
+require 'securerandom'
+
+module Modern
+  class Request < Rack::Request
+    # rubocop:disable Style/MutableConstant
+    LOCAL_REQUEST_STORE = {}
+    # rubocop:enable Style/MutableConstant
+
+    attr_reader :logger
+
+    def initialize(env, logger)
+      super(env)
+
+      env["HTTP_X_REQUEST_ID"] ||= SecureRandom.uuid
+
+      @logger = logger.child(request_id: request_id)
+    end
+
+    def request_id
+      env["HTTP_X_REQUEST_ID"]
+    end
+
+    def local_store
+      LOCAL_REQUEST_STORE[request_id] ||= {}
+    end
+
+    def cleanup
+      LOCAL_REQUEST_STORE.delete(request_id)
+    end
+  end
+end

data/lib/modern/response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rack'
+
+require 'json'
+
+module Modern
+  class Response < Rack::Response
+    attr_reader :request
+    attr_reader :bypass
+
+    def initialize(request, body = [], status = 200, header = {})
+      super(body, status, header)
+
+      @request = request
+      @bypass = false
+    end
+
+    def bypass!
+      @bypass = true
+    end
+
+    def json(object, pretty: false)
+      headers["Content-Type"] = "application/json"
+
+      if pretty
+        write(JSON.pretty_generate(object))
+      else
+        write(JSON.generate(object))
+      end
+    end
+
+    def text(object)
+      headers["Content-Type"] = "text/plain"
+
+      write(object.to_s)
+    end
+  end
+end

data/lib/modern/services.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "modern/struct"
+
+module Modern
+  # The default services catalogue for a Modern app, and one that can be
+  # extended by a consuming application to add additional services. Mixins
+  # and multiple services from multiple packages can be done with `dry-struct`
+  # but looks a little bizarre:
+  #
+  # https://discourse.dry-rb.org/t/dry-struct-reusing-a-set-of-common-attributes/315/3
+  class Services < Modern::Struct
+    LoggerType = Types.Instance(Ougai::Logger) | Types.Instance(Ougai::ChildLogger)
+
+    attribute :base_logger, (LoggerType.default { Ougai::Logger.new($stderr) })
+  end
+end

data/lib/modern/struct.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'deep_merge/rails_compat'
+require 'dry/struct'
+
+require 'modern/types'
+
+module Modern
+  class Struct < Dry::Struct
+    module Copy
+      # This implementation is necessary because the "fast" way (hash, merge, recreate)
+      # WILL EAT YOUR TYPE DATA. This is the only way I can find to copy-but-change an
+      # object that doesn't.
+      #
+      # Computers are bad.
+      def copy(fields = {})
+        self.class[self.class.attribute_names.map { |n| [n, self[n]] }.to_h.merge(fields)]
+      end
+    end
+
+    constructor_type :strict_with_defaults
+
+    include Copy
+  end
+end

data/lib/modern/types.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'dry/types'
+require 'dry/struct'
+
+require 'ice_nine'
+
+module Modern
+  module Types
+    include Dry::Types.module
+
+    # rubocop:disable Style/MutableConstant
+    # This is left unfrozen so as to allow additional verbs to be added
+    # in the future. Should be rare, but I've seen it done...
+    HTTP_METHODS = %w[GET POST PUT DELETE PATCH HEAD OPTIONS TRACE]
+    # rubocop:enable Style/MutableConstant
+
+    Type = Instance(Dry::Types::Type)
+    Struct = Instance(Dry::Struct)
+
+    HttpMethod = Types::Coercible::String.enum(*HTTP_METHODS)
+    HttpPath = Types::Strict::String.constrained(
+      format: %r,/.*,
+    )
+
+    MIMEType = Types::Strict::String.constrained(
+      format: %r,\w+/[-.\w]+(?:\+[-.\w]+)?,
+    )
+
+    RouteAction = Instance(Proc)
+    SecurityAction = Instance(Proc)
+
+    ParameterStyle = Types::Coercible::String.enum(:matrix, :label, :form,
+                                                   :simple, :space_delimited,
+                                                   :pipe_delimited, :deep_object)
+
+    def self.array_of(type)
+      Modern::Types::Strict::Array.of(type).default([])
+    end
+  end
+end

data/lib/modern/util/header_parsing.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Modern
+  module Util
+    module HeaderParsing
+      def self.parse_accept_header(value)
+        # TODO: this is probably more garbage creation than necessary.
+        # TODO: may poorly prioritize specificity, i.e. `text/*` over `*/*`
+        # TODO: this doesn't support `;level=`, but should we bother?
+        value.split(",").map do |type_declaration|
+          tuple = type_declaration.strip.split(";q=")
+          tuple[1] = tuple[1]&.to_f || 1.0
+
+          tuple
+        end.sort do |a, b|
+          comp = a.last <=> b.last
+
+          if comp != 0
+            comp
+          else
+            -(a.first <=> b.first)
+          end
+        end.map(&:first)
+      end
+    end
+  end
+end

data/lib/modern/util/trie_node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "modern/errors/setup_errors"
+
+module Modern
+  module Util
+    class TrieNode
+      attr_reader :parent
+      attr_reader :path
+      attr_accessor :value
+
+      attr_reader :children
+
+      def initialize(path = [])
+        @path = path
+        @children = {}
+      end
+
+      def add(key, value, raise_if_present: false)
+        key = [key].flatten
+
+        if key.empty?
+          if @value
+            raise Modern::Errors::RoutingError, "Existing value at #{path.inspect}: #{@value}" \
+              if raise_if_present
+          end
+
+          @value = value
+        else
+          child_name = key.first
+          @children[child_name] ||= TrieNode.new(path + [child_name])
+
+          @children[child_name].add(key[1..-1], value, raise_if_present: raise_if_present)
+        end
+      end
+
+      def [](child_name)
+        @children[child_name] || @children[:templated]
+      end
+
+      def get(key = [])
+        key = [key].flatten
+
+        node = self
+        until key.empty? || node.nil?
+          node = node[key.shift]
+        end
+
+        node&.value
+      end
+    end
+  end
+end

data/lib/modern/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Modern
+  VERSION = "0.4.2"
+  OPENAPI_VERSION = "3.0.1"
+end

data/lib/modern.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "modern/version"
+
+require "modern/app"
+
+module Modern
+end