hoboken 0.0.1 → 0.9.0

data/lib/hoboken/templates/puma.rb.tt

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+workers_count = Integer(ENV['WEB_CONCURRENCY'] || 1)
+threads_count = Integer(ENV['MAX_THREADS'] || 5)
+threads threads_count, threads_count
+
+port        ENV['PORT']     || 9292
+environment ENV['RACK_ENV'] || 'production'
+
+if workers_count > 1
+  preload_app!
+  workers workers_count
+
+  # rubocop:disable Lint/EmptyBlock
+  before_fork do
+  end
+
+  on_worker_boot do
+  end
+  # rubocop:enable Lint/EmptyBlock
+end

data/lib/hoboken/templates/rspec.rake.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)

data/lib/hoboken/templates/rubocop.yml.tt

@@ -0,0 +1,31 @@
+require:
+    - rubocop-rake
+<% if rspec? -%>
+    - rubocop-rspec
+<% end -%>
+
+AllCops:
+    Exclude:
+        - 'bin/*'
+        - 'tmp/*'
+        - 'vendor/bundle/**/*'
+    NewCops: enable
+    TargetRubyVersion: <%= RUBY_VERSION %>
+
+Layout/SpaceAroundEqualsInParameterDefault:
+    EnforcedStyle: no_space
+
+Metrics/ClassLength:
+    Max: 150
+
+Metrics/MethodLength:
+    Max: 15
+
+Layout/LineLength:
+    Max: 90
+
+Style/BlockDelimiters:
+    EnforcedStyle: braces_for_chaining
+
+Style/YodaCondition:
+    EnforcedStyle: require_for_equality_operators_only

data/lib/hoboken/templates/sequel.rake

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 namespace :db do
   require 'sequel'
 
   Sequel.extension :migration
-  DB = Sequel.connect(ENV['DATABASE_URL'] || "sqlite://db/development.db")
+  db = Sequel.connect(ENV['DATABASE_URL'] || 'sqlite://db/development.db')
 
   desc 'Migrate the database to latest version'
   task :migrate do
-    Sequel::Migrator.run(DB, 'db/migrate')
+    Sequel::Migrator.run(db, 'db/migrate')
     puts '<= db:migrate executed'
   end
 
   desc 'Perform migration reset (full erase and migration up)'
   task :reset do
-    Sequel::Migrator.run(DB, 'db/migrate', :target => 0)
-    Sequel::Migrator.run(DB, 'db/migrate')
+    Sequel::Migrator.run(db, 'db/migrate', target: 0)
+    Sequel::Migrator.run(db, 'db/migrate')
     puts '<= db:reset executed'
   end
 end

data/lib/hoboken/templates/server.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+if gem list foreman -i
+then
+  echo 'Foreman detected... starting server with Procfile'
+  rerun --background foreman start
+else
+  echo 'Foreman not installed... starting server with rackup'
+  rerun --background rackup
+fi

data/lib/hoboken/templates/setup.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/hoboken/templates/spec/app_spec.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# rubocop:disable RSpec/DescribeClass
+RSpec.describe 'GET /', rack: true do
+  before { get '/' }
+
+  it { expect(last_response).to have_http_status(:ok) }
+<% if options[:api_only] -%>
+  it { expect(last_response).to have_content_type(:json) }
+<% else -%>
+  it { expect(last_response).to have_content_type(:html) }
+<% end -%>
+  it { expect(last_response.body).to include('Smoke test successful!') }
+end
+# rubocop:enable RSpec/DescribeClass

data/lib/hoboken/templates/spec/rack_matchers.rb.tt

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define :have_http_status do |expected|
+  match do |response|
+    response.status == response_codes[expected]
+  end
+
+  failure_message do |response|
+    'expected last response status to be ' \
+    "#{response_codes.fetch(expected, 'unknown')}, " \
+    "but was #{response.status}"
+  end
+
+  def response_codes
+    {
+      ok: 200,
+      not_authorized: 401,
+      not_found: 404,
+      redirect: 302
+    }.freeze
+  end
+end
+
+RSpec::Matchers.define :have_content_type do |expected|
+  match do |response|
+    response.content_type == content_types[expected]
+  end
+
+  failure_message do |response|
+    'expected last response to have content type ' \
+    "'#{content_types.fetch(expected, 'unknown')}', " \
+    "but was '#{response.content_type}'"
+  end
+
+  def content_types
+    {
+      html: 'text/html;charset=utf-8',
+      json: 'application/json'
+    }.freeze
+  end
+end
+
+RSpec::Matchers.define :redirect_to do |expected|
+  match do |response|
+    path(response) == expected
+  end
+
+  failure_message do |response|
+    "expected last response to redirect to '#{expected}', " \
+    "but it redirected to '#{path(response)}'"
+  end
+
+  def path(response)
+    URI(response.location).path
+  end
+end

data/lib/hoboken/templates/spec/spec_helper.rb.tt

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+ENV['RACK_ENV'] = 'test'
+
+require 'bundler/setup'
+
+require 'warning'
+
+# Ignore all warnings in Gem dependencies
+Gem.path.each { |path| Warning.ignore(//, path) }
+
+require 'dotenv'
+require 'rack/test'
+require 'support/rack_helpers'
+
+require_relative '../app'
+
+Dotenv.load
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.include RackHelpers, rack: true
+
+  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.default_formatter = 'doc' if config.files_to_run.one?
+  config.disable_monkey_patching!
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+  config.filter_run_when_matching :focus
+  config.order = :random
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.warnings = true
+
+  Kernel.srand config.seed
+end

data/lib/hoboken/templates/sprockets.rake

@@ -1,33 +1,39 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
 namespace :assets do
   require 'sprockets'
   require 'uglifier'
   require 'yui/compressor'
-  sprockets = Sprockets::Environment.new { |env| env.logger = Logger.new(STDOUT) }
+  sprockets = Sprockets::Environment.new { |env| env.logger = Logger.new($stdout) }
   sprockets.css_compressor = YUI::CssCompressor.new
-  sprockets.js_compressor = :uglifier
+  sprockets.js_compressor = Uglifier.new(harmony: true)
 
-  %w(assets vendor).each do |f|
+  %w[assets vendor].each do |f|
     sprockets.append_path File.expand_path("../../#{f}", __FILE__)
   end
 
-  output_path = File.expand_path('../../public', __FILE__)
+  output_path = File.expand_path('../public', __dir__)
 
+  desc 'Pre-compile CSS assets'
   task :precompile_css do
     asset = sprockets['styles.css']
     outfile = Pathname.new(output_path).join('css/styles.css')
     FileUtils.mkdir_p outfile.dirname
     asset.write_to(outfile)
-    puts "successfully compiled css assets"
+    puts 'successfully compiled css assets'
   end
 
+  desc 'Pre-compile JavaScript assets'
   task :precompile_js do
     asset = sprockets['app.js']
     outfile = Pathname.new(output_path).join('js/app.js')
     FileUtils.mkdir_p outfile.dirname
     asset.write_to(outfile)
-    puts "successfully compiled javascript assets"
+    puts 'successfully compiled javascript assets'
   end
 
   desc 'precompile all assets'
-  task :precompile => [:precompile_css, :precompile_js]
+  task precompile: %i[precompile_css precompile_js]
 end
+# rubocop:enable Metrics/BlockLength

data/lib/hoboken/templates/sprockets_chain.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require 'sprockets'
 
 module Middleware
+  # Sprockets Rack middleware.
+  #
   class SprocketsChain
     attr_reader :app, :prefix, :sprockets
 
@@ -12,15 +16,15 @@ module Middleware
     end
 
     def call(env)
-      path_info = env["PATH_INFO"]
+      path_info = env['PATH_INFO']
       if path_info =~ prefix
-        env["PATH_INFO"].sub!(prefix, "")
+        env['PATH_INFO'].sub!(prefix, '')
         sprockets.call(env)
       else
         app.call(env)
       end
     ensure
-      env["PATH_INFO"] = path_info
+      env['PATH_INFO'] = path_info
     end
   end
 end

data/lib/hoboken/templates/sprockets_helper.rb

@@ -1,13 +1,17 @@
-  module Helpers
-    module Sprockets
-      def stylesheet_tag(name)
-        folder = 'production' == ENV['RACK_ENV'] ? 'css' : 'assets'
-        "<link href='/#{folder}/#{name}.css' rel='stylesheet' type='text/css' />"
-      end
+# frozen_string_literal: true
 
-      def javascript_tag(name)
-        folder = 'production' == ENV['RACK_ENV'] ? 'js' : 'assets'
-        "<script type='text/javascript' src='/#{folder}/#{name}.js'></script>"
-      end
+module Helpers
+  # Sprockets view helpers.
+  #
+  module Sprockets
+    def stylesheet_tag(name)
+      folder = 'production' == ENV['RACK_ENV'] ? 'css' : 'assets'
+      "<link href='/#{folder}/#{name}.css' rel='stylesheet' type='text/css' />"
+    end
+
+    def javascript_tag(name)
+      folder = 'production' == ENV['RACK_ENV'] ? 'js' : 'assets'
+      "<script type='text/javascript' src='/#{folder}/#{name}.js'></script>"
     end
   end
+end

data/lib/hoboken/templates/support/rack_helpers.rb.tt

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+<% if 'test-unit' == options[:test_framework] -%>
+require_relative 'rack_test_assertions'
+<% end -%>
+<% if 'rspec' == options[:test_framework] -%>
+require_relative 'rack_matchers'
+<% end -%>
+
+# Helpers for running Rack-based tests or specs. Decorates normal Rack methods
+# with an optional `:as` parameter. If present, the `rack.session` will
+# include the value of the given user's ID, effectively signing them in for
+# the request.
+#
+# Example
+# ```
+# # Find or create a user. You can name the class anything you'd like, the
+# # only requirement is that it responds to a `id` method.
+# user = User.new(id: 1) # or User.find, etc.
+# get '/', as: user
+# ```
+#
+# The above will add a `current_user` to the `rack.session` with a value of
+# the user's ID.
+#
+module RackHelpers
+  include Rack::Test::Methods
+<% if 'test-unit' == options[:test_framework] -%>
+  include Rack::Test::Assertions
+<% end -%>
+
+  %w[get post put patch delete options].each do |type|
+    define_method(type) do |uri, params={}, env={}, &block|
+      extract_user!(params, env)
+      super uri, params, env, &block
+    end
+  end
+
+  private
+
+  def extract_user!(params, env)
+    user = params.delete(:as)
+    return unless user
+
+    if env.key?('rack.session')
+      env['rack.session'].merge!(current_user: user.id)
+    else
+      env.merge!({ 'rack.session' => { current_user: user.id } })
+    end
+  end
+
+  def app
+    Sinatra::Application
+  end
+end

data/lib/hoboken/templates/support/rack_test_assertions.rb.tt

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Rack
+  module Test
+    module Assertions
+      RESPONSE_CODES = {
+        ok: 200,
+        not_authorized: 401,
+        not_found: 404,
+        redirect: 302
+      }.freeze
+
+      CONTENT_TYPES = {
+        json: 'application/json',
+        html: 'text/html;charset=utf-8'
+      }.freeze
+
+      def assert_body_contains(expected, message=nil)
+        msg = build_message(
+          message,
+          "expected body to contain <?>\n#{last_response.body}",
+          expected
+        )
+
+        assert_block(msg) { last_response.body.include?(expected) }
+      end
+
+      def assert_content_type(content_type)
+        unless CONTENT_TYPES.keys.include?(content_type)
+          raise ArgumentError, "unrecognized content_type (#{content_type})"
+        end
+
+        assert_equal CONTENT_TYPES[content_type], last_response.content_type
+      end
+
+      def assert_flash(type=:notice, message=nil)
+        msg = build_message(
+          message,
+          'expected <?> flash to exist, but was nil',
+          type.to_s
+        )
+
+        assert_block(msg) { last_request.env['rack.session']['flash'] }
+      end
+
+      def assert_flash_message(expected, type=:notice, message=nil)
+        assert_flash(type, message)
+        flash = last_request.env['rack.session']['flash'][type.to_s]
+
+        msg = build_message(
+          message,
+          'expected flash to be <?> but was <?>',
+          expected,
+          flash
+        )
+
+        assert_block(msg) { expected == flash }
+      end
+
+      def assert_has_session(message=nil)
+        msg = build_message(message, 'expected a valid session')
+        assert_block(msg) { last_request.env['rack.session'] }
+      end
+
+      def assert_session_has_key(key, message=nil)
+        assert_has_session
+        msg = build_message(message, 'expected session to have key named <?>', key)
+        assert_block(msg) { last_request.env['rack.session'].keys.include?(key.to_s) }
+      end
+
+      def assert_session(key, expected, message=nil)
+        assert_session_has_key(key)
+        actual = last_request.env['rack.session'][key.to_s]
+        msg = build_message(
+          message,
+          'expected session key <?> to be <?>, but was <?>',
+          key,
+          expected,
+          actual
+        )
+
+        assert_block(msg) { expected == actual }
+      end
+
+      def assert_response(expected, message=nil)
+        status = last_response.status
+        msg = build_message(
+          message,
+          'expected last response to be <?> but was <?>',
+          "#{RESPONSE_CODES[expected]}:#{expected}",
+          "#{status}:#{RESPONSE_CODES.key(status)}"
+        )
+
+        assert_block(msg) { status == RESPONSE_CODES[expected] }
+      end
+
+      def assert_redirected_to(expected, message=nil)
+        assert_response(:redirect)
+        actual = URI(last_response.location).path
+        msg = build_message(
+          message,
+          'expected to be redirected to <?> but was <?>',
+          expected,
+          actual
+        )
+
+        assert_block(msg) { expected == actual }
+      end
+    end
+  end
+end