snowpack 1.0.0.alpha2

data/lib/snowpack/cli/standalone/commands.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Snowpack
+  module CLI
+    module Standalone
+      module Commands
+        extend Hanami::CLI::Registry
+
+        require_relative "commands/new"
+      end
+    end
+  end
+end

data/lib/snowpack/components/formalist.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "dry/system"
+require "snowpack/types"
+
+Dry::System.register_component(:formalist, provider: :snowpack) do
+  settings do
+    key :embedded_forms_container, Snowpack::Types::Any
+    key :embedded_forms, Snowpack::Types::Hash
+  end
+
+  init do
+    require "formalist"
+  end
+
+  start do
+    embedded_forms_container = config.embedded_forms_container
+
+    if embedded_forms_container
+      config.embedded_forms.each do |name, klass|
+        embedded_forms_container.register(name, klass)
+      end
+
+      register "container", embedded_forms_container
+    end
+  end
+end

data/lib/snowpack/components/persistence.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "dry/system"
+require "snowpack/types"
+
+Dry::System.register_component(:persistence, provider: :snowpack) do
+  settings do
+    types = Snowpack::Types
+
+    key :database_url, types::String
+    key :global_extensions, types::Array.of(types::Symbol)
+    key :connection_extensions, types::Array.of(types::Symbol)
+    key :auto_registration_root, types::String.optional.default(nil)
+    key :auto_registration_namespace, types::String.optional.default(nil)
+    key :max_connections, types::Integer.optional.default(4)
+  end
+
+  init do
+    require "sequel"
+    require "rom"
+    require "rom/sql"
+
+    use :settings
+
+    ROM::SQL.load_extensions(*config.global_extensions)
+
+    Sequel.database_timezone = :utc
+    Sequel.application_timezone = :local
+
+    rom_config = ROM::Configuration.new(
+      :sql,
+      config.database_url,
+      max_connections: config.max_connections,
+      extensions: config.connection_extensions
+    )
+
+    rom_config.plugin :sql, relations: :instrumentation do |plugin_config|
+      plugin_config.notifications = notifications
+    end
+
+    rom_config.plugin :sql, relations: :auto_restrictions
+
+    register "config", rom_config
+    register "db", rom_config.gateways[:default].connection
+  end
+
+  start do
+    rom_config = container["persistence.config"]
+    rom_config.auto_registration(
+      config.auto_registration_root || target.root.join("lib/persistence"),
+      namespace: config.auto_registration_namespace || true,
+    )
+
+    register "rom", ROM.container(rom_config)
+  end
+end

data/lib/snowpack/components.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'dry/system'
+
+Dry::System.register_provider(:snowpack, boot_path: Pathname(__dir__).join('components').realpath)

data/lib/snowpack/console/context.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "plugins/relation_readers"
+require_relative "plugins/slice_readers"
+
+module Snowpack
+  module Console
+    class Context < SimpleDelegator
+      attr_reader :application
+
+      def self.new(*args)
+        ctx = super
+
+        if ctx.rom
+          ctx.extend(Snowpack::Console::Plugins::RelationReaders.new(ctx))
+          ctx.extend(Snowpack::Console::Plugins::SliceReaders.new(ctx))
+        end
+
+        ctx
+      end
+
+      def initialize(application)
+        super(application)
+        @application = application
+      end
+
+      def rom
+        application["persistence.rom"] if application.key?("persistence.rom")
+      end
+    end
+  end
+end

data/lib/snowpack/console/plugins/relation_readers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Snowpack
+  module Console
+    module Plugins
+      class RelationReaders < Module
+        def initialize(ctx)
+          ctx.rom.relations.each do |name, relation|
+            define_method(name) do
+              relation
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/console/plugins/slice_readers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Snowpack
+  module Console
+    module Plugins
+      class SliceReaders < Module
+        def initialize(ctx)
+          ctx.application.slices.each do |name, slice|
+            define_method(name) do
+              SliceDelegator.new(slice)
+            end
+          end
+        end
+
+        class SliceDelegator < SimpleDelegator
+          def method_missing(name, *args, &block)
+            if args.empty? && key?(name)
+              self[name]
+            else
+              super
+            end
+          end
+
+          private
+
+          def respond_to_missing?(name)
+            key?(name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "erb"
+require "hanami/utils/files"
+require "pathname"
+
+module Snowpack
+  class Generator
+    attr_reader :templates_dir
+    # attr_reader :templates
+    attr_reader :files
+    attr_reader :file_helper
+
+    def initialize(templates_dir:)
+      @templates_dir = templates_dir
+      @files = Hanami::Utils::Files
+    end
+
+    def call(output_dir, **env)
+      templates(**env).each do |template|
+        output_file_path = render_file_path(template.relative_path_from(templates_dir).to_s, env)
+
+        if File.extname(template) == ".tt"
+          result = render(template.to_s, env)
+
+          files.write \
+            File.join(output_dir, output_file_path.sub(%r{#{File.extname(template)}$}, "")),
+            result
+        else
+          files.cp template, File.join(output_dir, output_file_path)
+        end
+      end
+    end
+
+    private
+
+    # TODO: when we go to multi-template dirs, we'll need to make it so that the
+    # returned templates are bundled up with their root dirs
+    def templates(**env)
+      Dir[File.join(templates_dir, "**/{*,.*}")].select(&File.method(:file?)).map(&method(:Pathname))
+    end
+
+    def render(template, env)
+      ERB.new(File.read(template), nil, _trim_mode = "-").result_with_hash(env)
+    end
+
+    FILE_PATH_VAR_DELIMITER = "__"
+    FILE_PATH_VAR_REGEXP = /#{FILE_PATH_VAR_DELIMITER}\S+#{FILE_PATH_VAR_DELIMITER}/
+
+    def render_file_path(path, env)
+      path.gsub(FILE_PATH_VAR_REGEXP) { |match|
+        var_name = match.gsub(FILE_PATH_VAR_DELIMITER, "")
+        env.fetch(var_name.to_sym).to_s
+      }
+    end
+  end
+end

data/lib/snowpack/generators/application/generator.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "securerandom"
+require "shellwords"
+require "snowpack/version"
+require_relative "../../generator"
+
+module Snowpack
+  module Generators
+    module Application
+      class Generator < Snowpack::Generator
+        # FIXME: need to make templates_dir handling nicer, also support multiple dirs
+        def initialize(templates_dir: nil)
+          templates_dir ||= File.join(__dir__, "templates")
+          super(templates_dir: templates_dir)
+        end
+
+        def call(output_dir, application_name)
+          super(output_dir, env(application_name))
+          generate_tool_versions output_dir
+        end
+
+        private
+
+        def env(application_name)
+          {
+            application_path: inflector.underscore(application_name),
+            application_module: inflector.camelize(application_name),
+            random: -> name, *args { SecureRandom.public_send(name, *args) },
+            snowpack_version: Snowpack::VERSION,
+          }
+        end
+
+        def generate_tool_versions(output_dir)
+          if `which asdf` && $?.success?
+            versions = %w[nodejs postgres ruby]
+              .map { |tool|
+                version = asdf_current_version(tool)
+                "#{tool} #{version}" if version
+              }
+              .compact
+
+            if versions.any?
+              files.write(
+                File.join(output_dir, ".tool-versions"),
+                versions.join("\n") + "\n",
+              )
+            end
+          end
+        end
+
+        def asdf_current_version(tool)
+          output = `asdf current #{Shellwords.shellescape(tool)}`
+
+          # Handle this output:
+          # 2.6.2    (set by /path/to/.tool-versions)
+          output.split(" ").first if $?.success?
+        end
+
+        def inflector
+          @inflector ||= Dry::Inflector.new
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/generators/application/templates/.env-example.tt

@@ -0,0 +1,10 @@
+# Web app
+LOG_TO_STDOUT=false
+SESSION_SECRET=_____replace_me_with_a_real_secret_____
+
+# Assets
+ASSETS_PRECOMPILED=false
+ASSETS_SERVER_URL=http://localhost:8080
+
+# Persistence
+DATABASE_URL=postgres://localhost/<%= application_path %>_development

data/lib/snowpack/generators/application/templates/.env.test-example.tt

@@ -0,0 +1 @@
+DATABASE_URL=postgres://localhost/<%= application_path %>_test

data/lib/snowpack/generators/application/templates/.gitignore

@@ -0,0 +1,20 @@
+# Local service data
+/data/*
+
+# App settings (keeping e.g. *-example files checked in)
+/.env*
+!/.env-*
+!/.env*-*
+
+# RSpec
+/spec/examples.txt
+
+# Logs
+/log/*.log
+
+# Temp files
+tmp/*
+
+# Front-end
+/node_modules
+/public/assets

data/lib/snowpack/generators/application/templates/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/snowpack/generators/application/templates/Brewfile

@@ -0,0 +1,4 @@
+tap "icelab/devtools"
+brew "asdf"
+brew "overmind"
+brew "yarn"

data/lib/snowpack/generators/application/templates/Gemfile.tt

@@ -0,0 +1,46 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+ruby "<%= RUBY_VERSION %>"
+
+gem "rake"
+gem "snowpack", "<%= snowpack_version %>"
+gem "hanami-cli", github: "hanami/cli", branch: "unstable"
+
+# Web framework
+gem "dry-system"
+gem "dry-web"
+gem "hanami-utils", github: "hanami/utils", branch: "unstable"
+gem "hanami-router", github: "hanami/router", branch: "unstable"
+gem "hanami-controller", github: "hanami/controller", branch: "unstable"
+gem "puma", "~> 3.0"
+gem "rack", "~> 2.0"
+
+# Persistence
+gem "pg"
+gem "rom", "~> 5.0"
+gem "rom-sql", "~> 3.0"
+gem "sequel_pg"
+
+# Application dependencies
+gem "dry-auto_inject"
+gem "dry-matcher"
+gem "dry-monads", "~> 1.0"
+gem "dry-schema", "~> 1.0"
+gem "dry-struct", "~> 1.0"
+gem "dry-transaction"
+gem "dry-types", "~> 1.0"
+gem "dry-validation", "~> 1.0"
+gem "dry-view"
+gem "slim", "~> 4.0"
+
+group :development, :test do
+  gem "guard"
+  gem "guard-puma"
+  gem "pry-byebug", platform: :mri
+end
+
+group :test do
+  gem "rspec", "~> 3.0"
+end

data/lib/snowpack/generators/application/templates/Guardfile

@@ -0,0 +1,7 @@
+guard "puma" do
+  watch "Gemfile.lock"
+  watch %r{config/.+}
+  watch %r{lib/.+}
+  watch %r{slices/.+}
+  watch %r{system/.+}
+end

data/lib/snowpack/generators/application/templates/Procfile.dev

@@ -0,0 +1,3 @@
+web: bundle exec guard --no-notify --no-interactions
+# assets: yarn run start
+# worker: bundle exec que ./config/que.rb

data/lib/snowpack/generators/application/templates/Procfile.support

@@ -0,0 +1 @@
+postgres: postgres

data/lib/snowpack/generators/application/templates/README.md.tt

@@ -0,0 +1,45 @@
+# <%= application_module %>
+
+## Installation
+
+After cloning, run:
+
+```
+./script/bootstrap
+```
+
+## Running support services
+
+To start the supporting services, run:
+
+```
+./script/support
+```
+
+This must be running before completing the following steps.
+
+## Setup
+
+To set up for the first time, run:
+
+```
+./script/setup
+```
+
+## After pulling changes
+
+After pulling changes from the remote, run:
+
+```
+./script/update
+```
+
+This will install any new dependencies and run any migrations.
+
+## Running the app
+
+After updating, run:
+
+```
+./script/server
+```

data/lib/snowpack/generators/application/templates/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/setup"
+require_relative "config/application"
+require "snowpack/test_tasks"
+
+Rake.add_rakelib "tasks"

data/lib/snowpack/generators/application/templates/bin/run

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "snowpack/cli/application/cli"
+require_relative "../config/application"
+
+Snowpack::CLI::Application::CLI.new.call

data/lib/snowpack/generators/application/templates/config/application.rb.tt

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "logger"
+require "snowpack/application"
+require "snowpack/components"
+require "snowpack/web/plugin"
+
+module <%= application_module %>
+  class Application < Snowpack::Application
+    use :web
+
+    configure do
+      config.name = :<%= application_path %>
+      config.log_levels = %i[test development production].map { |e| [e, Logger::DEBUG] }.to_h
+      config.default_namespace = "<%= application_path %>"
+      config.auto_register = %w[lib/<%= application_path %>]
+    end
+  end
+end

data/lib/snowpack/generators/application/templates/config/puma.rb.tt

@@ -0,0 +1,14 @@
+workers Integer(ENV["WEB_CONCURRENCY"] || 2)
+
+threads_count = Integer(ENV["MAX_THREADS"] || 4)
+threads threads_count, threads_count
+
+preload_app!
+
+rackup DefaultRackup
+port ENV["PORT"] || 3000
+environment ENV["RACK_ENV"] || "development"
+
+before_fork do
+  <%= application_module %>::Application["persistence.rom"].disconnect
+end

data/lib/snowpack/generators/application/templates/config/routes.rb.tt

@@ -0,0 +1,15 @@
+require "snowpack/web"
+require "rack"
+
+Snowpack::Web.routes do |application|
+  use Rack::Lint
+
+  use Rack::Static,
+    urls: ["/assets"],
+    root: "public"
+
+  use Rack::Session::Cookie,
+    key: "<%= application_path %>.session",
+    secret: application[:settings].session_secret,
+    expire_after: 10 * 365 * 24 * 60 * 60 # 10 years
+end

data/lib/snowpack/generators/application/templates/config.ru

@@ -0,0 +1,5 @@
+require_relative "config/application"
+require_relative "config/routes"
+
+Snowpack.application.boot!
+run Snowpack::Web.application

data/lib/snowpack/generators/application/templates/db/sample_data.rb

@@ -0,0 +1 @@
+# Build your sample data here

data/lib/snowpack/generators/application/templates/db/seed.rb

@@ -0,0 +1 @@
+# Build your seed data here

data/lib/snowpack/generators/application/templates/lib/__application_path__/operation.rb.tt

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# auto_register: false
+
+require "dry/transaction/operation"
+
+module <%= application_path %>
+  class Operation
+    def self.inherited(subclass)
+      subclass.include Dry::Transaction::Operation
+    end
+  end
+end

data/lib/snowpack/generators/application/templates/lib/__application_path__/types.rb.tt

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+# auto_register: false
+
+require "dry/struct"
+require "dry/types"
+
+module <%= application_module %>
+  module Types
+    include Dry.Types(default: :strict)
+  end
+end

data/lib/snowpack/generators/application/templates/lib/__application_path__/web/action.rb.tt

@@ -0,0 +1,56 @@
+# auto_register: false
+
+require "json" # required for Hanami::Action::Flash to work
+require "hanami/controller"
+require "hanami/action/cookies"
+require "hanami/action/csrf_protection"
+require "hanami/action/session"
+require "<%= application_path %>/import"
+
+module <%= application_module %>
+  module Web
+    class Action < Hanami::Action
+      def self.inherited(klass)
+        super
+
+        # It would be nice if these could just be included on the top class,
+        # rather than on subclasses via this inherited hook
+        klass.include Hanami::Action::Cookies
+        klass.include Hanami::Action::Session
+        klass.include Hanami::Action::CSRFProtection
+      end
+
+      include Import[
+        "assets",
+        "web.action.configuration",
+        view_context: "web.view.context",
+      ]
+
+      attr_reader :_deps
+
+      def initialize(**deps)
+        @_deps = deps
+        super
+      end
+
+      def with(**new_deps)
+        self.class.new(_deps.merge(new_deps))
+      end
+
+      private
+
+      def render(view, req, res, **args)
+        res.body = view.(context: view_context.with(view_context_options(req, res)), **args)
+        res
+      end
+
+      def view_context_options(req, res)
+        {
+          assets: assets,
+          csrf_token: req.session[Hanami::Action::CSRFProtection::CSRF_TOKEN],
+          flash: res.flash,
+        }
+      end
+    end
+  end
+end

data/lib/snowpack/generators/application/templates/lib/__application_path__/web/view/context.rb.tt

@@ -0,0 +1,31 @@
+require "dry/view/context"
+
+module <%= application_module %>
+  module Web
+    module View
+      class Context < Dry::View::Context
+        def assets
+          self[:assets]
+        end
+
+        def csrf_token
+          self[:csrf_token]
+        end
+
+        def flash
+          self[:flash]
+        end
+
+        def flash?
+          %i[notice alert].any? { |type| flash[type] }
+        end
+
+        private
+
+        def [](name)
+          _options.fetch(name)
+        end
+      end
+    end
+  end
+end