snowpack 1.0.0.alpha2

data/lib/snowpack/instrumentation/appsignal/que.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "appsignal"
+require_relative "appsignal_ext"
+require "securerandom"
+
+# Remove Appsignal's own Que integration hook, so the Snowpack-hosted
+# integration can be included manually.
+Appsignal::Hooks.hooks.delete :que
+
+module Snowpack
+  module Instrumentation
+    module Appsignal
+      module Que
+        # Enable like so:
+        #
+        # Que.error_notifier = Snowpack::Instrumentation::Appsignal::Que::ErrorNotifier
+
+        # Actually, why is this even necessry?
+        ErrorNotifier = -> error, _job {
+          ::Appsignal::Transaction.current.set_error(error)
+        }
+
+        def self.included(base)
+          base.class_eval do
+            def _run_with_appsignal(*args)
+              env = {
+                :metadata    => {
+                  :id        => attrs[:job_id],
+                  :queue     => attrs[:queue],
+                  :run_at    => attrs[:run_at].to_s,
+                  :priority  => attrs[:priority],
+                  :attempts  => attrs[:error_count].to_i
+                },
+                :params => attrs[:args]
+              }
+
+              request = ::Appsignal::Transaction::GenericRequest.new(env)
+
+              transaction = ::Appsignal::Transaction.create(
+                SecureRandom.uuid,
+                ::Appsignal::Transaction::BACKGROUND_JOB,
+                request,
+              )
+
+              transaction.discard! unless instrument?
+
+              begin
+                ::Appsignal.instrument("perform_job.que") { _run_without_appsignal(*args) }
+              rescue Exception => error
+                transaction.set_error(error)
+                raise error
+              ensure
+                transaction.set_action "#{attrs[:job_class]}#run"
+                ::Appsignal::Transaction.complete_current!
+              end
+            end
+
+            alias_method :_run_without_appsignal, :_run
+            alias_method :_run, :_run_with_appsignal
+
+            def instrument?
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/instrumentation/appsignal/rack.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# use Snowpack::Instrumentation::Rack::Appsignal, {
+#   sample: 0.2,
+#   filters: {
+#     "/some/exact/route"   => 0.05,    # <- custom sample rate (5%) for specific URL
+#     %r{/another/.+/route} => false,   # <- do not instrument this URL, n.b. match via Regexp
+#   },
+# }
+
+require "appsignal"
+require_relative "appsignal_ext"
+require "rack"
+require "securerandom"
+
+module Snowpack
+  module Instrumentation
+    module Appsignal
+      class Rack
+        attr_reader :app, :options
+
+        def initialize(app, **options)
+          @app = app
+          @options = options
+        end
+
+        def call(env)
+          if ::Appsignal.active?
+            call_with_appsignal_monitoring(env)
+          else
+            app.call(env)
+          end
+        end
+
+        private
+
+        def call_with_appsignal_monitoring(env)
+          request = ::Rack::Request.new(env)
+
+          transaction = ::Appsignal::Transaction.create(
+            SecureRandom.uuid,
+            ::Appsignal::Transaction::HTTP_REQUEST,
+            request,
+          )
+
+          transaction.discard! unless sample?(request)
+
+          begin
+            ::Appsignal.instrument "process_action.generic" do
+              app.call(env)
+            end
+          rescue Exception => error
+            transaction.set_error(error)
+            raise error
+          ensure
+            if env["appsignal.route"]
+              transaction.set_action_if_nil(env["appsignal.route"])
+            else
+              transaction.set_action_if_nil("unknown")
+            end
+
+            transaction.set_metadata("path", request.path)
+            transaction.set_metadata("method", request.request_method)
+
+            transaction.set_http_or_background_queue_start
+            ::Appsignal::Transaction.complete_current!
+          end
+        end
+
+        def sample?(request)
+          rate = options.fetch(:sample, 1)
+
+          options.fetch(:filters, {}).each do |match, sample|
+            rate = sample and break if request.path.match?(match)
+          end
+
+          rate = 1 if rate == true
+
+          rate && rand <= rate
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/roda/web.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# TODO wrap in begin/rescue loaderror and raise a meaningful exception
+require "roda"
+require "roda/plugins/flow"
+
+module Snowpack
+  module Roda
+    # Mostly copied from Dry::Web::Roda::Application
+    class Web < ::Roda
+      extend Dry::Configurable
+
+      setting :container, reader: true
+      setting :routes
+
+      plugin :flow
+
+      # Disable this so we can better control when it's used
+      #
+      # def self.configure(&block)
+      #   super.tap do
+      #     use(container[:rack_monitor]) if container.config.listeners
+      #   end
+      # end
+
+      def self.resolve(name)
+        container[name]
+      end
+
+      def self.[](name)
+        container[name]
+      end
+
+      def self.load_routes!
+        Dir[root.join("#{config.routes}/**/*.rb")].each { |f| require f }
+      end
+
+      def self.root
+        container.config.root
+      end
+
+      # def notifications
+      #   self.class[:notifications]
+      # end
+    end
+  end
+end

data/lib/snowpack/slice.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../snowpack"
+
+module Snowpack
+  class Slice < Dry::System::Container
+    use :env, inferrer: -> { ENV.fetch('RACK_ENV', 'development').to_sym }
+
+    def self.inherited(klass)
+      super
+
+      if klass.superclass == Snowpack::Slice
+        raise "Snowpack.application not configured yet" unless Snowpack.application?
+
+        app = Snowpack.application
+
+        klass.instance_variable_set :@application, app
+
+        klass.config.env = app.env
+        klass.config.name = klass.slice_name.to_sym
+        klass.config.auto_register = [File.join("lib", klass.slice_namespace_path)]
+        klass.config.default_namespace = klass.slice_namespace_identifier_prefix
+
+        slice_path = File.join(app.config.root, app.config.slices_dir, klass.slice_name)
+        if File.directory?(slice_path)
+          klass.config.root = slice_path if File.directory?(slice_path)
+          klass.load_paths! "lib"
+        end
+
+        klass.import application: app
+      end
+    end
+
+    def self.import_slice(*slices)
+      @slice_imports ||= []
+      @slice_imports += slices
+      @slice_imports.uniq!
+      self
+    end
+
+    def self.application
+      @application
+    end
+
+    def self.boot!
+      finalize!
+    end
+
+    def self.finalize!
+      # Force `after :configure` hooks to run
+      configure do; end
+
+      super do
+        Array(@slice_imports).each do |slice|
+          import slice => application.slices.fetch(slice)
+        end
+      end
+    end
+
+    private
+
+    MODULE_DELIMITER = "::"
+
+    def self.slice_namespace
+      inflector.constantize(name.split(MODULE_DELIMITER)[0..-2].join(MODULE_DELIMITER))
+    end
+
+    def self.slice_namespace_path
+      inflector.underscore(slice_namespace.to_s)
+    end
+
+    def self.slice_namespace_identifier_prefix
+      slice_namespace_path.gsub("/", ".")
+    end
+
+    def self.slice_name
+      inflector.underscore(slice_namespace.to_s.split(MODULE_DELIMITER).last)
+    end
+
+    def self.inflector
+      application[:inflector]
+    end
+  end
+end

data/lib/snowpack/test/suite.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+require 'json'
+
+require_relative "../../snowpack"
+
+module Snowpack
+  module Test
+    module Helpers
+      module_function
+
+      def suite
+        @__suite__ ||= RSpec.configuration.suite
+      end
+    end
+
+    class Suite
+      DB_CLEANUP_PATH_REGEX = /(features|integration)/
+
+      class << self
+        attr_accessor :current
+
+        def root
+          @__root__ ||= Pathname(Dir.pwd).join("spec").freeze
+        end
+
+        def instance
+          @__instance__ ||= new
+        end
+      end
+
+      def self.inherited(klass)
+        super
+        Suite.current = klass
+      end
+
+      def self.configure
+        RSpec.configure do |config|
+          config.add_setting :suite
+
+          config.suite = self.new
+
+          config.include Helpers
+
+          config.disable_monkey_patching!
+
+          config.expect_with :rspec do |expectations|
+            expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+          end
+
+          config.mock_with :rspec do |mocks|
+            mocks.verify_partial_doubles = true
+          end
+
+          config.filter_run :focus
+          config.run_all_when_everything_filtered = true
+
+          config.example_status_persistence_file_path = root.join("../tmp").realpath.join("spec/examples.txt").to_s
+
+          if config.files_to_run.one?
+            config.default_formatter = "doc"
+          end
+
+          config.profile_examples = 10
+
+          config.order = :random
+
+          Kernel.srand config.seed
+
+          yield(config) if block_given?
+        end
+      end
+
+      attr_reader :application, :root
+
+      def initialize(application: Snowpack.application, root: self.class.root.join("suite"))
+        @application = application
+        @root = root
+
+        application.load_slices
+      end
+
+      def start_coverage
+        return unless coverage?
+
+        require 'simplecov'
+
+        if parallel?
+          SimpleCov.command_name(test_group_name)
+        end
+
+        SimpleCov.start do
+          add_filter '/spec/'
+          add_filter '/system/'
+        end
+      end
+
+      def coverage_threshold
+        ENV.fetch('COVERAGE_THRESHOLD').to_f.round
+      end
+
+      def current_coverage
+        data = JSON.load(application.root.join('coverage/.last_run.json'))
+        data.fetch('result').fetch('covered_percent').to_f.round
+      end
+
+      def test_group_name
+        @__test_group_name__ ||= "test_suite_#{build_idx}"
+      end
+
+      def chdir(name)
+        self.class.new(
+          application: application,
+          root: root.join(name.to_s),
+        )
+      end
+
+      def files
+        dirs.map { |dir| dir.join("**/*_spec.rb") }.flat_map { |path| Dir[path] }.sort
+      end
+
+      def groups
+        dirs.map(&:basename).map(&:to_s).map(&:to_sym).sort
+      end
+
+      def dirs
+        Dir[root.join("*")].map(&Kernel.method(:Pathname)).select(&:directory?)
+      end
+
+      def build_idx
+        ENV.fetch('CIRCLE_NODE_INDEX', -1).to_i
+      end
+
+      def coverage?
+        ENV['COVERAGE'] == 'true'
+      end
+
+      def ci?
+        !ENV['CIRCLECI'].nil?
+      end
+
+      def parallel?
+        ENV['CIRCLE_NODE_TOTAL'].to_i > 1
+      end
+
+      def capybara_server_port
+        3001
+      end
+
+      def log_dir
+        application.root.join("log").to_s
+      end
+
+      def tmp_dir
+        application.root.join("tmp").to_s
+      end
+
+      def clean_db?(example)
+        DB_CLEANUP_PATH_REGEX.match?(example.metadata[:file_path])
+      end
+    end
+  end
+end

data/lib/snowpack/test/tasks.rake

@@ -0,0 +1,40 @@
+begin
+  require "rspec/core/rake_task"
+  require "snowpack/test/suite"
+
+  require Snowpack::Test::Suite.root.join("support/suite")
+  suite = Snowpack::Test::Suite.current.new
+
+  desc "Run all specs"
+  RSpec::Core::RakeTask.new :spec do |t|
+    opts = ["#{suite.root} --pattern **/*_spec.rb"]
+
+    if suite.ci?
+      opts << "--format RspecJunitFormatter"
+      opts << "--out /tmp/test-results/rspec.xml"
+      opts << "--format progress"
+    end
+
+    t.rspec_opts = opts.join(" ")
+  end
+
+  namespace :spec do
+    suite.groups.each do |group|
+      desc "Run #{group} specs"
+      RSpec::Core::RakeTask.new(group) do |t|
+        t.rspec_opts = "#{suite.chdir(group).root} --pattern **/*_spec.rb"
+      end
+    end
+
+    desc 'Verify coverage'
+    task :verify_coverage do
+      if suite.current_coverage.to_i < suite.coverage_threshold
+        puts "Coverage too low. Current: #{suite.current_coverage}%; Expected min: #{suite.coverage_threshold}%"
+        exit 1
+      end
+    end
+  end
+
+  task default: [:spec]
+rescue LoadError; end
+# FIXME ^ make that way more specific

data/lib/snowpack/test_tasks.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "rake"
+load "snowpack/test/tasks.rake"

data/lib/snowpack/types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "dry/types"
+
+module Snowpack
+  module Types
+    include Dry.Types(default: :strict)
+  end
+end

data/lib/snowpack/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Snowpack
+  VERSION = "1.0.0.alpha2"
+end

data/lib/snowpack/view/part_builder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "dry/view/part_builder"
+require "snowpack/view/parts/pager"
+require_relative "parts/paginated"
+
+module Snowpack
+  module View
+    class PartBuilder < Dry::View::PartBuilder
+      def call(name, value, **options)
+        if paginated_collection?(value)
+          build_paginated_collection_part(name, value, **options)
+        else
+          super
+        end
+      end
+
+      private
+
+      def paginated_collection?(value)
+        value.respond_to?(:to_a) && value.respond_to?(:pager)
+      end
+
+      def build_paginated_collection_part(name, value, **options)
+        pager_part = build_part(:pager, value.pager, as: Snowpack::View::Parts::Pager)
+
+        collection_as = collection_options(name: name, **options)[:as]
+        item_name, item_as = collection_item_options(name: name, **options).values_at(:name, :as)
+
+        arr = value.to_ary.map { |obj|
+          call(item_name, obj, **options.merge(as: item_as))
+        }
+
+        collection_part_class = part_class(name: name, fallback_class: Parts::Paginated, **options.merge(as: collection_as))
+
+        collection_part_class.new(
+          name: name,
+          value: arr,
+          pager: pager_part,
+          render_env: render_env,
+        )
+      end
+    end
+  end
+end

data/lib/snowpack/view/parts/pager.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "dry/view/part"
+require "rack/utils"
+require "uri"
+
+module Snowpack
+  module View
+    module Parts
+      class Pager < Dry::View::Part
+        attr_reader :part_args
+        attr_reader :buffer
+
+        def initialize(buffer: 3, **part_args)
+          @part_args = part_args
+          @buffer = buffer
+
+          super(**part_args)
+        end
+
+        def with(**options)
+          new_options = {
+            buffer: buffer
+          }.merge(options)
+
+          self.class.new(**new_options, **part_args)
+        end
+
+        def first_page
+          1
+        end
+
+        def first_page?
+          current_page == first_page
+        end
+
+        def last_page
+          total_pages
+        end
+
+        def last_page?
+          current_page == last_page
+        end
+
+        def prev_gap?
+          current_page - buffer > first_page
+        end
+
+        def next_gap?
+          current_page + buffer < last_page
+        end
+
+        def single_page?
+          total_pages <= 1
+        end
+
+        def all_page_numbers
+          (first_page..last_page).to_a
+        end
+
+        def each_entry
+          return to_enum(:each_entry) unless block_given?
+
+          entry_numbers.each do |number|
+            yield Entry.new(number, current: number == current_page)
+          end
+        end
+
+        def url_for_page(page)
+          uri = URI(_context.fullpath)
+          params = Rack::Utils.parse_query(uri.query).merge("page" => page.to_s)
+          uri.query = Rack::Utils.build_query(params)
+          uri.to_s
+        end
+
+        private
+
+        def entry_numbers
+          left_edge = current_page - buffer
+          left_edge = 1 if left_edge < 1
+
+          right_edge = current_page + buffer
+          right_edge = total_pages if right_edge > total_pages
+
+          left_edge.upto(right_edge).to_a
+        end
+
+        class Entry
+          attr_reader :number
+
+          def initialize(number, current:)
+            @number = number
+            @current = current
+          end
+
+          def to_s
+            number.to_s
+          end
+
+          def current?
+            !!@current
+          end
+        end
+      end
+    end
+  end
+end

data/lib/snowpack/view/parts/paginated.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "dry/view/part"
+
+module Snowpack
+  module View
+    module Parts
+      class Paginated < Dry::View::Part
+        attr_reader :pager
+
+        def initialize(pager:, **part_args)
+          @pager = pager
+          super(**part_args)
+        end
+
+        def pagination(locals: {}, **options)
+          pager.with(**options).render(:pagination, **locals)
+        end
+      end
+    end
+  end
+end