snowpack 1.0.0.alpha2

data/lib/snowpack/web/application.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rack"
+require "hanami/controller"
+require_relative "router"
+
+module Snowpack
+  module Web
+    class Application
+      def initialize(application, &routes)
+        resolver = application.config.web.routing.endpoint_resolver.new(
+          application: application,
+          namespace: application.config.web.routing.action_key_namespace,
+        )
+
+        router = Router.new(
+          application: application,
+          endpoint_resolver: resolver,
+          &routes
+        )
+
+        @app = Rack::Builder.new do
+          use application[:rack_monitor]
+
+          router.middlewares.each do |(*middleware, block)|
+            use(*middleware, &block)
+          end
+
+          run router
+        end
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/snowpack/web/assets.rb

@@ -0,0 +1,56 @@
+require "yaml"
+require "down"
+
+module Snowpack
+  module Web
+    class Assets
+      attr_reader :root
+      attr_reader :precompiled
+      attr_reader :server_url
+
+      def initialize(root:, precompiled:, server_url: nil)
+        @root = root
+        @precompiled = precompiled
+        @server_url = server_url
+      end
+
+      def [](asset)
+        if precompiled
+          asset_path_from_manifest(asset)
+        else
+          asset_path_on_server(asset)
+        end
+      end
+
+      def read(asset)
+        path = self[asset]
+
+        if File.exist?("#{root}/public#{path}")
+          File.read("#{root}/public#{path}")
+        else
+          Down.open(path).read
+        end
+      end
+
+      private
+
+      def asset_path_from_manifest(asset)
+        if (hashed_asset = manifest[asset])
+          "/assets/#{hashed_asset}"
+        end
+      end
+
+      def asset_path_on_server(asset)
+        "#{server_url}/assets/#{asset}"
+      end
+
+      def manifest
+        @manifest ||= YAML.load_file(manifest_path)
+      end
+
+      def manifest_path
+        "#{root}/public/assets/asset-manifest.json"
+      end
+    end
+  end
+end

data/lib/snowpack/web/endpoint_resolver.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# FIXME: This is for the NotCallableEndpointError. It would be good if this
+# could be require-able without having to bring in all the routing files
+require "hanami/routing"
+
+module Snowpack
+  module Web
+    class EndpointResolver
+      attr_reader :application
+      attr_reader :container
+      attr_reader :base_namespace
+
+      def initialize(application:, container: application, namespace:)
+        @application = application
+        @container = container
+        @base_namespace = namespace
+      end
+
+      def sliced(name)
+        raise "Slices can only be mounted from top-level application" unless application.respond_to?(:slices)
+
+        slice = application.slices[name]
+        return unless slice
+
+        self.class.new(
+          application: application,
+          container: slice,
+          namespace: base_namespace,
+        )
+      end
+
+      def call(name, namespace = nil, configuration = nil)
+        endpoint =
+          case name
+          when String
+            resolve_string_identifier(name, namespace, configuration)
+          when Class
+            name.respond_to?(:call) ? name : name.new
+          else
+            name
+          end
+
+        unless endpoint.respond_to?(:call)
+          raise Hanami::Routing::NotCallableEndpointError.new(endpoint)
+        end
+
+        endpoint
+      end
+
+      private
+
+      def resolve_string_identifier(name, namespace, configuration)
+        identifier = [base_namespace, namespace, name].compact.join(".")
+
+        container[identifier].yield_self { |endpoint|
+          if configuration && endpoint.class < Hanami::Action
+            endpoint.with(configuration: configuration)
+          else
+            endpoint
+          end
+        }
+      end
+    end
+  end
+end

data/lib/snowpack/web/form.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+
+require "formalist"
+require "formalist/elements/standard"
+
+module Snowpack
+  module Web
+    class Form < ::Formalist::Form
+      setting :prefix
+
+      def self.prefix(value)
+        config.prefix = value
+      end
+
+      def prefix
+        self.class.config.prefix
+      end
+
+      def fill(input: {}, errors: {}, **args)
+        super(input: Hash(input), errors: errors, **args)
+      end
+
+      def to_h(config = {})
+        if config.any?
+          {ast: to_ast, prefix: prefix, config: {global: config}}
+        else
+          {ast: to_ast, prefix: prefix}
+        end
+      end
+
+      def to_s
+        JSON.generate(to_h)
+      end
+    end
+  end
+end

data/lib/snowpack/web/plugin.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "dry/system/plugins"
+require_relative "endpoint_resolver"
+require_relative "rack_logger"
+
+module Snowpack
+  module Web
+    module Plugin
+      def self.extended(system)
+        super
+
+        system.setting :web do
+          setting :routing do
+            setting :endpoint_resolver, EndpointResolver
+            setting :action_key_namespace, "web.actions"
+          end
+
+          setting :logging do
+            setting :filter_params, %w[_csrf password password_confirmation]
+          end
+        end
+
+        system.after :configure do
+          register_rack_monitor
+          attach_rack_logger
+        end
+      end
+
+      def register_rack_monitor
+        return self if key?(:rack_monitor)
+        register :rack_monitor, Dry::Monitor::Rack::Middleware.new(self[:notifications])
+        self
+      end
+
+      def attach_rack_logger
+        RackLogger.new(self[:logger], filter_params: config.web.logging.filter_params).attach(self[:rack_monitor])
+        self
+      end
+    end
+
+    Dry::System::Plugins.register :web, Plugin
+  end
+end

data/lib/snowpack/web/rack_logger.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack/request"
+
+module Snowpack
+  module Web
+    class RackLogger
+      attr_reader :logger
+      attr_reader :filter_params
+
+      def initialize(logger, filter_params: [])
+        @logger = logger
+        @filter_params = filter_params
+      end
+
+      def attach(rack_monitor)
+        rack_monitor.on :stop do |env:, status:, time:|
+          log_request env, status, time
+        end
+
+        rack_monitor.on :error do |event|
+          log_exception event[:exception]
+        end
+      end
+
+      def log_request(env, status, time)
+        request = Rack::Request.new(env)
+
+        params = request.GET
+        params = params.merge(Hash(request.POST))
+
+        # TODO: support both roda and hanami params
+        json_params = Hash(request.get_header("roda.json_params"))
+        params = params.merge(json_params)
+
+        data = {
+          method: request.request_method,
+          path: request.path,
+          for: request.get_header("REMOTE_ADDR"),
+          status: status,
+          duration: time,
+          params: filter(params),
+        }
+
+        logger.info JSON.generate(data)
+      end
+
+      def log_exception(e)
+        logger.error e.message
+        logger.error (e.backtrace).join("\n")
+      end
+
+      private
+
+      FILTERED = "[FILTERED]"
+
+      def filter(params)
+        params.each_with_object({}) do |(k, v), h|
+          if filter_params.include?(k)
+            h.update(k => FILTERED)
+          elsif v.is_a?(Hash)
+            h.update(k => filter_params(v))
+          elsif v.is_a?(Array)
+            h.update(k => v.map { |m| m.is_a?(Hash) ? filter_params(m) : m })
+          else
+            h[k] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/web/router.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "hanami/router"
+
+module Snowpack
+  module Web
+    class Router < Hanami::Router
+      attr_reader :middlewares
+
+      def initialize(application:, **options, &block)
+        @application = application
+        @options = options
+        @middlewares = []
+
+        super(**options, &nil)
+        instance_exec(application, &block) if block
+        freeze overridden: true
+      end
+
+      # Do nothing when the superclass calls freeze during its own initialize
+      # (we need to do it later, after our instance_exec of the routes block)
+      def freeze(overridden: false)
+        super() if overridden
+      end
+
+      # Ensure we always return a rack-conformant result (sometimes we get a
+      # Hanami::Action::Response here, when we actually want the standard rack
+      # 3-element array)
+      def call(*)
+        super.to_a
+      end
+
+      def use(*args, &block)
+        middlewares << (args << block)
+      end
+
+      def mount(app, at:, host: nil, &block)
+        if app.is_a?(Symbol) && (sliced_resolver = @endpoint_resolver.sliced(app))
+          sliced_router = self.class.new(
+            application: @application.slices[app],
+            **@options,
+            endpoint_resolver: sliced_resolver,
+            &block
+          )
+
+          super(sliced_router, at: at, host: host)
+        else
+          super(app, at: at, host: host)
+        end
+      end
+
+      # Allow router objects to be mounted within themselves
+      def match?(env)
+        match_path?(env)
+      end
+    end
+  end
+end

data/lib/snowpack/web.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../snowpack"
+require_relative "web/application"
+
+module Snowpack
+  module Web
+    def self.routes(&block)
+      if block
+        @routes = block
+      else
+        @routes
+      end
+    end
+
+    def self.application
+      @application ||= Application.new(Snowpack.application, &routes)
+    end
+  end
+end

data/lib/snowpack.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "snowpack/version"
+
+module Snowpack
+  @_mutex = Mutex.new
+
+  def self.application
+    @_mutex.synchronize do
+      raise "Snowpack.application not configured" unless defined?(@_application)
+
+      @_application
+    end
+  end
+
+  def self.application?
+    defined?(@_application) && @_application
+  end
+
+  def self.application=(klass)
+    @_mutex.synchronize do
+      raise "Snowpack.application already configured" if defined?(@_application)
+
+      @_application = klass unless klass.name.nil?
+    end
+  end
+end

data/snowpack.gemspec

@@ -0,0 +1,34 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'snowpack/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "snowpack"
+  spec.version       = Snowpack::VERSION
+  spec.authors       = ["Tim Riley", "Piotr Solnica"]
+  spec.email         = ["tim@icelab.com.au", "piotr@icelab.com.au"]
+
+  spec.summary       = "Lightweight application framework for Icelab"
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/icelab/snowpack"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "dry-inflector", "~> 0.1"
+  spec.add_runtime_dependency "dry-monitor", "~> 0.3.1"
+  spec.add_runtime_dependency "dry-system", "~> 0.12", ">= 0.12.0"
+  spec.add_runtime_dependency "dry-types", "~> 1.0"
+  spec.add_runtime_dependency "down", "~> 4.0"
+  spec.add_runtime_dependency "hanami-cli"    # requires unstable branch from github in application Gemfile
+  spec.add_runtime_dependency "hanami-utils"  # requires unstable branch from github in application Gemfile
+  spec.add_runtime_dependency "rack", "~> 2.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end