snowpack 1.0.0.alpha2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 117edd0edd3fc41b750a9123cc92c8d7629f6d07273b92782716fbb273dc1994
+  data.tar.gz: 19d7853057dd9ab75dc9e2de63b2cb7c4f17dceb7135abcb677c9ec598326460
+SHA512:
+  metadata.gz: 35241faca184cdb00a5ccf8061f3b4df83760c1afbcf282cea88ab9deb6923d81c49aa43f7306a283f215a6b498044bafd9dbb413338d0b5e0e81bc67513e6b8
+  data.tar.gz: 3b1b3308b56b87579230df9c7f59a18598953ca296cadfba884a7fd36009ec3be29a23572df88151af9d52c946db65ec77446e44c816fdd56916747677558cab

data/.gitignore

@@ -0,0 +1,17 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# dummy app files created in specs
+spec/dummy/db/migrate/*
+!spec/dummy/db/migrate/.keep
+spec/dummy/db/structure.sql

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--order random

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.2

data/.travis.yml

@@ -0,0 +1,16 @@
+dist: trusty
+sudo: required
+language: ruby
+cache: bundler
+addons:
+  postgresql: 9.5
+services:
+  - postgresql
+script:
+  - bundle exec rake spec
+rvm:
+  - 2.6.2
+notifications:
+    on_success: false
+    on_failure: false
+    on_start: false

data/Brewfile

@@ -0,0 +1,2 @@
+tap "icelab/devtools"
+brew "asdf"

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## [1.0.0.alpha2] - 2019-07-01 [YANKED]
+
+### Changed
+
+- Fix case of gem name (now "snowpack", fully lowercase)
+
+## [1.0.0.alpha1] - 2019-07-01 [YANKED]
+
+### Added
+
+- Introduce app/slices structure via `Snowpack::Application` and `Snowpack::Slice`
+- Introduce `Snowpack::Web` module for holding route definitions and preparing rack app
+- Introduce `Snowpack::Web::Application` and `Snowpack::Web::Plugin` dry-system plugin, which provide a rack-mountable web application (and supporting infrastructure) depending upon hanami-router (unstable branch) for routing and hanami-controller (unstable branch) for HTTP endpoint handling
+- Introduce `snowpack` CLI with `new` command for generating new applications
+- Add `generate slice` application CLI command
+
+### Changed
+
+- Rebuild application CLI using hanami-cli
+
+### Removed
+
+- Remove repo readers from console environment

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+gemspec
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem "hanami-cli", github: "hanami/cli", branch: "unstable"
+
+gem "rom", github: "rom-rb/rom"
+gem "rom-sql", github: "rom-rb/rom-sql"
+gem "pg"
+
+gem "pry-byebug"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2019 Icelab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,116 @@
+# Disclaimer
+
+**This project is not intended for public usage and is not open for contributions. Icelab takes no responsibility for usage in your projects**.
+
+# Snowpack
+
+[![Build Status](https://travis-ci.org/icelab/snowpack.svg?branch=master)](https://travis-ci.org/icelab/snowpack)
+
+Snowpack is lightwight application framework for Icelab’s Ruby applications. It builds upon [dry-system][dry-system], and integrates Hanami [router][hanami-router]/[controller][hanami-controller] (unstable branches) for HTTP request handling, and [rom-rb] for database persistence.
+
+[dry-system]: https://github.com/dry-rb/dry-system
+[hanami-router]: https://github.com/hanami/router
+[hanami-controller]: https://github.com/hanami/controller
+[rom-rb]: https://rom-rb.org/
+
+## Getting started
+
+Install the gem:
+
+```
+gem install snowpack -v "1.0.0.alpha1"
+```
+
+Generate a new application:
+
+```
+snowpack new my_app
+```
+
+Then enter the application and (if required) generate a new slice:
+
+```
+./bin/run generate slice main
+```
+
+## CLI
+
+Snowpack’ application CLI is accessible via the `bin/run` executable, which provides access to various commands. To learn about these, simply run:
+
+```
+$ ./bin/run
+Commands:
+  run assets [SUBCOMMAND]
+  run console                            # Open interactive console
+  run db [SUBCOMMAND]
+  run generate [SUBCOMMAND]
+  ```
+
+To learn about sub-commands, run the parent command:
+
+```
+$ ./bin/run db
+Commands:
+  run db create                                  # Create database
+  run db create_migration [NAME]                 # Create new migration file
+  run db drop                                    # Delete database
+  run db migrate                                 # Migrates database
+  run db reset                                   # Drop, create, and migrate database
+  run db rollback                                # Rollback database to a previous migration
+  run db sample_data                             # Load sample data
+  run db seed                                    # Load database seeds
+  run db structure [SUBCOMMAND]
+  run db version                                 # Print schema version
+```
+
+To learn about any specific command, pass the `-h` or `--help` option:
+
+```
+$ ./bin/run db migrate --help
+Command:
+  run db migrate
+
+Usage:
+  run db migrate
+
+Description:
+  Migrates database
+
+Options:
+  --env=VALUE, -e VALUE                 # Application environment
+  --target=VALUE, -t VALUE              # Target migration number
+  --help, -h                            # Print this help
+```
+
+## Console
+
+An application console is available via `bin/run console`. It provides convenient access to various components:
+
+```
+=> starting my_app[development] console
+=> my_app[development] booted in in 0.4s
+my_app[development]>
+```
+
+### Console helpers
+
+The console offers convenient access to all rom-rb relations:
+
+```
+my_app[development]> users
+=> #<Persistence::Relations::Users dataset=#<Sequel::Postgres::Dataset: "SELECT \"id\", \"email\", \"encrypted_password\", \"access_token\", \"access_token_expiration\", \"active\", \"created_at\", \"updated_at\", \"name\" FROM \"users\" ORDER BY \"users\".\"id\"">>
+```
+
+As well as all slices:
+
+```
+my_app[development]> main
+=> MyApp::Main::Slice
+```
+
+As well as any root-level registrations on the slices:
+
+```
+my_app[development]> main.user_repo
+# => #<MyApp::Main::UserRepo struct_namespace=MyApp::Main::Entities auto_struct=true>
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/bootstrap

@@ -0,0 +1,25 @@
+#!/bin/sh
+# bootstrap script - install or update project dependencies
+set -e
+
+cd "$(dirname "$0")/.."
+
+if [ "$(uname -s)" = "Darwin" ]; then
+  brew bundle check >/dev/null 2>&1  || {
+    echo "==> Installing Homebrew dependencies…"
+    brew bundle
+  }
+
+  echo "==> Installing package versions…"
+  brew bootstrap-asdf
+fi
+
+bundle check >/dev/null 2>&1 || {
+  echo "==> Installing gem dependencies…"
+  bundle install --quiet
+}
+
+bundle check >/dev/null 2>&1 || {
+  echo "==> Installing node packages…"
+  yarn --silent
+}

data/exe/snowpack

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "snowpack/cli/standalone/cli"
+
+Snowpack::CLI::Standalone::CLI.new.call

data/lib/snowpack/application.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "dry/monitor" # from dry-web
+require "dry/system/container"
+require "dry/system/components"
+require "pathname"
+require_relative "../snowpack"
+
+Dry::Monitor.load_extensions :rack # from dry-web
+
+module Snowpack
+  class Application < Dry::System::Container
+    setting :inflector, Dry::Inflector.new, reader: true
+    setting :slices_dir, "slices"
+
+    use :env, inferrer: -> { ENV.fetch("RACK_ENV", "development").to_sym }
+    use :logging
+    use :notifications
+    use :monitoring
+
+    @_mutex = Mutex.new
+
+    def self.inherited(klass)
+      super
+
+      klass.after :configure do
+        register_inflector
+        load_paths! "lib"
+      end
+
+      @_mutex.synchronize do
+        Snowpack.application = klass
+      end
+    end
+
+    def self.slices
+      @slices ||= load_slices
+    end
+
+    def self.load_slices
+      @slices ||= Dir[File.join(config.root, config.slices_dir, "*")]
+        .map(&method(:load_slice))
+        .compact
+        .to_h
+    end
+
+    # We can't call this `.boot` because it is the name used for registering
+    # bootable components. (It would be good to change that)
+    def self.boot!
+      return self if booted?
+
+      finalize! freeze: false
+
+      load_slices
+      slices.values.each(&:boot!)
+
+      @booted = true
+
+      freeze
+      self
+    end
+
+    def self.booted?
+      @booted.equal?(true)
+    end
+
+    MODULE_DELIMITER = "::"
+
+    def self.module
+      inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
+    end
+
+    private
+
+    def self.load_slice(base_path)
+      base_path = Pathname(base_path)
+      full_defn_path = Dir["#{base_path}/system/**/slice.rb"].first
+
+      return unless full_defn_path
+
+      require full_defn_path
+
+      const_path = Pathname(full_defn_path)
+        .relative_path_from(base_path.join("system")).to_s
+        .yield_self { |path| path.sub(/#{File.extname(path)}$/, "") }
+
+      const = inflector.constantize(inflector.camelize(const_path))
+
+      [File.basename(base_path).to_sym, const]
+    end
+
+    def self.register_inflector
+      return self if key?(:inflector)
+      register :inflector, inflector
+    end
+  end
+end

data/lib/snowpack/application_cli.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require_relative "../snowpack"
+require_relative "cli/command"
+require_relative "cli/commands"
+
+module Snowpack
+  class ApplicationCLI < Hanami::CLI
+    def self.application
+      if Snowpack.application?
+        Snowpack.application
+      else
+        nil
+      end
+    end
+
+    attr_reader :application
+
+    def initialize(application: self.class.application, commands: Commands)
+      super(commands)
+      @application = application
+    end
+
+    private
+
+    # TODO: we should make a prepare_command method upstream
+    def parse(result, out)
+      command, arguments = super
+
+      if command.respond_to?(:with_application)
+        application.config.env = arguments[:env] if arguments[:env]
+        [command.with_application(application), arguments]
+      else
+        [command, arguments]
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/cli.rb

@@ -0,0 +1,32 @@
+require "hanami/cli"
+require "snowpack"
+require_relative "commands"
+
+module Snowpack
+  module CLI
+    module Application
+      class CLI < Hanami::CLI
+        attr_reader :application
+
+        def initialize(application: Snowpack.application, commands: Commands)
+          super(commands)
+          @application = application
+        end
+
+        private
+
+        # TODO: we should make a prepare_command method upstream
+        def parse(result, out)
+          command, arguments = super
+
+          if command.respond_to?(:with_application)
+            application.config.env = arguments[:env] if arguments[:env]
+            [command.with_application(application), arguments]
+          else
+            [command, arguments]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/command.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+
+module Snowpack
+  module CLI
+    module Application
+      class Command < Snowpack::CLI::Command
+        def self.inherited(klass)
+          super
+
+          klass.option :env, aliases: ["-e"], default: nil, desc: "Application environment"
+        end
+
+        attr_reader :application
+
+        def initialize(application: nil, **opts)
+          super(**opts)
+          @application = application
+        end
+
+        # TODO: inject application inflector
+        def with_application(application)
+          self.class.new(
+            command_name: @command_name,
+            application: application,
+            out: out,
+            files: files,
+          )
+        end
+
+        private
+
+        def run_command(klass, *args)
+          klass.new(
+            command_name: klass.name,
+            application: application,
+            out: out,
+            files: files,
+          ).call(*args)
+        end
+
+        def measure(desc, &block)
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          block.call
+          stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          out.puts "=> #{desc} in #{(stop - start).round(1)}s"
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/assets/clobber.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "snowpack/cli/application/command"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module Assets
+          class Clobber < Command
+            desc "Delete compiled assets"
+
+            def call(**)
+              FileUtils.rm_rf(compiled_assets_path)
+              out.puts "=> assets removed from #{compiled_assets_path}"
+            end
+
+            private
+
+            def compiled_assets_path
+              File.join(application.root, "public/assets")
+            end
+          end
+        end
+
+        register "assets clobber", Assets::Clobber
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/assets/compile.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "snowpack/cli/application/command"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module Assets
+          class Compile < Command
+            desc "Compiles assets"
+
+            def call(**)
+              measure "assets compiled into #{compiled_assets_path}" do
+                `yarn run build-production` # TODO use shell helper here
+              end
+            end
+
+            private
+
+            def compiled_assets_path
+              File.join(application.root, "public/assets")
+            end
+          end
+        end
+
+        register "assets compile", Assets::Compile, aliases: ["precompile"]
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/console.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "snowpack/cli/application/command"
+require "snowpack/console/context"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        class Console < Command
+          REPL = begin
+            require 'pry'
+            Pry
+          rescue LoadError
+            require 'irb'
+            IRB
+          end
+
+          desc "Open interactive console"
+
+          def call(**)
+            measure "#{prompt_prefix} booted in" do
+              out.puts "=> starting #{prompt_prefix} console"
+              application.boot!
+            end
+
+            start_repl
+          end
+
+          private
+
+          def start_repl
+            context = Snowpack::Console::Context.new(application)
+            REPL.start(context, prompt: [proc { default_prompt }, proc { indented_prompt }])
+          end
+
+          def default_prompt
+            "#{prompt_prefix}> "
+          end
+
+          def indented_prompt
+            "#{prompt_prefix}* "
+          end
+
+          def prompt_prefix
+            "#{inflector.underscore(application.config.name)}[#{application.env}]"
+          end
+        end
+
+        register "console", Console
+      end
+    end
+  end
+end

data/lib/snowpack/cli/application/commands/db/create.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "snowpack/cli/application/command"
+require_relative "utils/database_config"
+
+module Snowpack
+  module CLI
+    module Application
+      module Commands
+        module DB
+          class Create < Command
+            desc "Create database"
+
+            def call(**)
+              db_name = database_config.db_name
+
+              system(database_config.cli_env_vars, "createdb #{Shellwords.escape(db_name)}")
+              out.puts "=> database #{db_name} created" if $?.success?
+            end
+
+            private
+
+            def database_config
+              @database_config ||= Utils::DatabaseConfig.for_application(application)
+            end
+          end
+        end
+
+        register "db create", DB::Create
+      end
+    end
+  end
+end