hanami 2.0.0.alpha7 → 2.0.0.beta1

data/lib/hanami/slice_registrar.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_relative "constants"
+require_relative "slice"
+
+module Hanami
+  # @api private
+  class SliceRegistrar
+    attr_reader :parent, :slices
+    private :parent, :slices
+
+    def initialize(parent)
+      @parent = parent
+      @slices = {}
+    end
+
+    def register(name, slice_class = nil, &block)
+      if slices.key?(name.to_sym)
+        raise SliceLoadError, "Slice '#{name}' is already registered"
+      end
+
+      # TODO: raise error unless name meets format (i.e. single level depth only)
+
+      slice = slice_class || build_slice(name, &block)
+
+      configure_slice(name, slice)
+
+      slices[name.to_sym] = slice
+    end
+
+    def [](name)
+      slices.fetch(name) do
+        raise SliceLoadError, "Slice '#{name}' not found"
+      end
+    end
+
+    def freeze
+      slices.freeze
+      super
+    end
+
+    def load_slices
+      return self unless root
+
+      slice_configs = Dir[root.join(CONFIG_DIR, SLICES_DIR, "*#{RB_EXT}")]
+        .map { |file| File.basename(file, RB_EXT) }
+
+      slice_dirs = Dir[File.join(root, SLICES_DIR, "*")]
+        .select { |path| File.directory?(path) }
+        .map { |path| File.basename(path) }
+
+      (slice_dirs + slice_configs).uniq.sort.each do |slice_name|
+        load_slice(slice_name)
+      end
+
+      self
+    end
+
+    def each(&block)
+      slices.each_value(&block)
+    end
+
+    def to_a
+      slices.values
+    end
+
+    private
+
+    # Runs when a slice file has been found at `config/slices/[slice_name].rb`, or a slice
+    # directory at `slices/[slice_name]`. Attempts to require the slice class, if defined,
+    # or generates a new slice class for the given slice name.
+    def load_slice(slice_name)
+      slice_const_name = inflector.camelize(slice_name)
+      slice_require_path = root.join(CONFIG_DIR, SLICES_DIR, slice_name).to_s
+
+      begin
+        require(slice_require_path)
+      rescue LoadError => e
+        raise e unless e.path == slice_require_path
+      end
+
+      slice_class =
+        begin
+          inflector.constantize("#{slice_const_name}::Slice")
+        rescue NameError => e
+          raise e unless e.name.to_s == slice_const_name || e.name.to_s == :Slice
+        end
+
+      register(slice_name, slice_class)
+    end
+
+    def build_slice(slice_name, &block)
+      slice_module =
+        begin
+          slice_module_name = inflector.camelize(slice_name.to_s)
+          inflector.constantize(slice_module_name)
+        rescue NameError
+          Object.const_set(inflector.camelize(slice_module_name), Module.new)
+        end
+
+      slice_module.const_set(:Slice, Class.new(Hanami::Slice, &block))
+    end
+
+    def configure_slice(slice_name, slice)
+      slice.instance_variable_set(:@parent, parent)
+
+      # Slices require a root, so provide a sensible default based on the slice's parent
+      slice.config.root ||= root.join(SLICES_DIR, slice_name.to_s)
+    end
+
+    def root
+      parent.root
+    end
+
+    def inflector
+      parent.inflector
+    end
+  end
+end

data/lib/hanami/version.rb

@@ -8,7 +8,7 @@ module Hanami
   module Version
     # @since 0.9.0
     # @api private
-    VERSION = "2.0.0.alpha7"
+    VERSION = "2.0.0.beta1"
 
     # @since 0.9.0
     # @api private

data/lib/hanami/web/rack_logger.rb

@@ -2,7 +2,7 @@
 
 module Hanami
   module Web
-    # Rack logger for Hanami applications
+    # Rack logger for Hanami apps
     class RackLogger
       REQUEST_METHOD = "REQUEST_METHOD"
       private_constant :REQUEST_METHOD

data/lib/hanami.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "hanami/application"
-require_relative "hanami/errors"
-require_relative "hanami/version"
-
-
 # A complete web framework for Ruby
 #
 # @since 0.1.0
@@ -12,39 +7,36 @@ require_relative "hanami/version"
 # @see http://hanamirb.org
 module Hanami
   @_mutex = Mutex.new
+  @_bundled = {}
 
-  def self.application
+  def self.app
     @_mutex.synchronize do
-      unless defined?(@_application)
-        raise ApplicationLoadError,
-          "Hanami.application is not yet configured. " \
-          "You may need to `require \"hanami/setup\"` to load your config/application.rb file."
+      unless defined?(@_app)
+        raise AppLoadError,
+              "Hanami.app is not yet configured. " \
+              "You may need to `require \"hanami/setup\"` to load your config/app.rb file."
       end
 
-      @_application
+      @_app
     end
   end
 
-  def self.application?
-    defined?(@_application)
+  def self.app?
+    defined?(@_app)
   end
 
-  def self.application=(klass)
+  def self.app=(klass)
     @_mutex.synchronize do
-      if defined?(@_application)
-        raise ApplicationLoadError, "Hanami.application is already configured."
+      if defined?(@_app)
+        raise AppLoadError, "Hanami.app is already configured."
       end
 
-      @_application = klass unless klass.name.nil?
+      @_app = klass unless klass.name.nil?
     end
   end
 
-  def self.rack_app
-    application.rack_app
-  end
-
   def self.env
-    (ENV["HANAMI_ENV"] || "development").to_sym
+    ENV.fetch("HANAMI_ENV") { ENV.fetch("RACK_ENV", "development") }.to_sym
   end
 
   def self.env?(*names)
@@ -52,22 +44,38 @@ module Hanami
   end
 
   def self.logger
-    application[:logger]
+    app[:logger]
   end
 
   def self.prepare
-    application.prepare
+    app.prepare
   end
 
   def self.boot
-    application.boot
+    app.boot
   end
 
   def self.shutdown
-    application.shutdown
+    app.shutdown
+  end
+
+  def self.bundled?(gem_name)
+    @_mutex.synchronize do
+      @_bundled[gem_name] ||= begin
+        gem(gem_name)
+        true
+      rescue Gem::LoadError
+        false
+      end
+    end
   end
 
   def self.bundler_groups
     [:plugins]
   end
+
+  require_relative "hanami/version"
+  require_relative "hanami/errors"
+  require_relative "hanami/extensions"
+  require_relative "hanami/app"
 end

data/spec/integration/application_middleware_stack_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe "App middleware stack", type: :integration do
+  it "mounts Rack middleware" do
+    with_project do
+      generate "action web home#index --url=/"
+      generate_middleware
+
+      # Add apps/web/middleware to the load paths
+      replace "apps/web/app.rb", "load_paths << [", "load_paths << ['middleware',"
+
+      # Require Rack::ETag
+      unshift "apps/web/app.rb", "require 'rack/etag'"
+
+      # Mount middleware
+      replace "apps/web/app.rb", "# middleware.use", "middleware.use 'Web::Middleware::Runtime'\nmiddleware.use 'Web::Middleware::Custom', 'OK'\nmiddleware.use Rack::ETag"
+
+      rewrite "apps/web/controllers/home/index.rb", <<~EOF
+        module Web::Controllers::Home
+          class Index
+            include Web::Action
+
+            def call(params)
+              self.body = "OK"
+            end
+          end
+        end
+      EOF
+
+      server do
+        get "/"
+
+        expect(last_response.status).to               eq(200)
+
+        expect(last_response.headers["X-Runtime"]).to eq("1ms")
+        expect(last_response.headers["X-Custom"]).to  eq("OK")
+        expect(last_response.headers["ETag"]).to_not  be_nil
+      end
+    end
+  end
+
+  private
+
+  def generate_middleware # rubocop:disable Metrics/MethodLength
+    write "apps/web/middleware/runtime.rb", <<~EOF
+      module Web
+        module Middleware
+          class Runtime
+            def initialize(app)
+              @app = app
+            end
+
+            def call(env)
+              status, headers, body = @app.call(env)
+              headers["X-Runtime"]  = "1ms"
+
+              [status, headers, body]
+            end
+          end
+        end
+      end
+    EOF
+
+    write "apps/web/middleware/custom.rb", <<~EOF
+      module Web
+        module Middleware
+          class Custom
+            def initialize(app, value)
+              @app   = app
+              @value = value
+            end
+
+            def call(env)
+              status, headers, body = @app.call(env)
+              headers["X-Custom"]   = @value
+
+              [status, headers, body]
+            end
+          end
+        end
+      end
+    EOF
+  end
+end

data/spec/integration/assets/cdn_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe "assets", type: :integration do
+  describe "CDN mode" do
+    it "servers assets with CDN url" do
+      with_project do
+        generate "action web home#index --url=/"
+
+        write "apps/web/assets/javascripts/app.css", <<~EOF
+          body { color: #333 };
+        EOF
+        rewrite "apps/web/templates/app.html.erb", <<~EOF
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Web</title>
+              <%= favicon %>
+              <%= stylesheet 'app' %>
+            </head>
+            <body>
+              <%= yield %>
+            </body>
+          </html>
+        EOF
+
+        replace_last "apps/web/app.rb", "# scheme 'https'",           "scheme 'https'"
+        replace      "apps/web/app.rb", "# host   'cdn.example.org'", "host   'cdn.example.org'"
+        replace_last "apps/web/app.rb", "# port   443",               "port   443"
+
+        #
+        # Precompile
+        #
+        RSpec::Support::Env["HANAMI_ENV"]   = "production"
+        RSpec::Support::Env["DATABASE_URL"] = "sqlite://#{Pathname.new('db').join('bookshelf.sqlite')}"
+        RSpec::Support::Env["SMTP_HOST"]    = "localhost"
+        RSpec::Support::Env["SMTP_PORT"]    = "25"
+
+        hanami "assets precompile"
+
+        server do
+          visit "/"
+
+          expect(page.body).to include(%(<link href="https://cdn.example.org/assets/app-5df86b4e9cbd733a027762b2f6bf8693.css" type="text/css" rel="stylesheet" integrity="sha256-LxaTcWkL8TAWFQWeHJ7OqoSoEXXaYapNIS+TCvGNf48=" crossorigin="anonymous">))
+        end
+      end
+    end
+  end
+end

data/spec/integration/assets/fingerprint_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+RSpec.describe "assets", type: :integration do
+  describe "fingerprint mode" do
+    it "servers assets with fingerprint url" do
+      with_project do
+        generate "action web home#index --url=/"
+
+        write "apps/web/assets/javascripts/app.css", <<~EOF
+          body { color: #333 };
+        EOF
+        rewrite "apps/web/templates/app.html.erb", <<~EOF
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Web</title>
+              <%= favicon %>
+              <%= stylesheet 'app' %>
+            </head>
+            <body>
+              <%= yield %>
+            </body>
+          </html>
+        EOF
+        #
+        # Precompile
+        #
+        RSpec::Support::Env["HANAMI_ENV"]   = "production"
+        RSpec::Support::Env["DATABASE_URL"] = "sqlite://#{Pathname.new('db').join('bookshelf.sqlite')}"
+        RSpec::Support::Env["SMTP_HOST"]    = "localhost"
+        RSpec::Support::Env["SMTP_PORT"]    = "25"
+        hanami "assets precompile"
+
+        server do
+          visit "/"
+
+          expect(page.body).to include(%(<link href="/assets/app-5df86b4e9cbd733a027762b2f6bf8693.css" type="text/css" rel="stylesheet" integrity="sha256-LxaTcWkL8TAWFQWeHJ7OqoSoEXXaYapNIS+TCvGNf48=" crossorigin="anonymous">))
+        end
+      end
+    end
+  end
+end

data/spec/integration/assets/helpers_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+RSpec.describe "assets", type: :integration do
+  describe "helpers" do
+    it "renders assets tags" do
+      with_project do
+        generate "action web home#index --url=/"
+
+        rewrite "apps/web/templates/app.html.erb", <<~EOF
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Web</title>
+              <%= favicon %>
+              <%= stylesheet 'app' %>
+            </head>
+            <body>
+              <%= yield %>
+              <%= javascript 'app' %>
+            </body>
+          </html>
+        EOF
+
+        rewrite "apps/web/templates/home/index.html.erb", <<~EOF
+          <%= image('app.jpg') %>
+          <%= video('movie.mp4') %>
+          <%=
+          video do
+            text "Your browser does not support the video tag"
+            source src: view.asset_path('movie.mp4'), type: 'video/mp4'
+            source src: view.asset_path('movie.ogg'), type: 'video/ogg'
+          end
+          %>
+        EOF
+
+        server do
+          visit "/"
+
+          expect(page.body).to include(%(<link href="/assets/favicon.ico" rel="shortcut icon" type="image/x-icon">))
+          expect(page.body).to include(%(<link href="/assets/app.css" type="text/css" rel="stylesheet">))
+          expect(page.body).to include(%(<script src="/assets/app.js" type="text/javascript"></script>))
+
+          expect(page.body).to include(%(<img src="/assets/app.jpg" alt="App">))
+          expect(page.body).to include(%(<video src="/assets/movie.mp4"></video>))
+          expect(page.body).to include(%(<video>\nYour browser does not support the video tag\n<source src="/assets/movie.mp4" type="video/mp4">\n<source src="/assets/movie.ogg" type="video/ogg">\n</video>))
+        end
+      end
+    end
+  end
+end

data/spec/integration/assets/serve_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.describe "assets", type: :integration do
+  describe "serve" do
+    it "compiles and serves assets in development mode" do
+      project = "bookshelf_serve_assets"
+
+      with_project(project, gems: ['sassc']) do
+        generate "action web home#index --url=/"
+
+        write "apps/web/assets/javascripts/app.css.sass", <<~EOF
+          $font-family: Helvetica, sans-serif
+
+          body
+            font: 100% $font-family
+        EOF
+        rewrite "apps/web/templates/app.html.erb", <<~EOF
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Web</title>
+              <%= favicon %>
+              <%= stylesheet 'app' %>
+            </head>
+            <body>
+              <%= yield %>
+            </body>
+          </html>
+        EOF
+
+        server do
+          visit "/"
+          expect(page.body).to include(%(<link href="/assets/app.css" type="text/css" rel="stylesheet">))
+
+          visit "/assets/app.css"
+          expect(page.body).to include(%(body {\n  font: 100% Helvetica, sans-serif; }\n))
+        end
+      end
+    end
+
+    it "serve assets with prefixes" do
+      with_project do
+        generate "action web home#index --url=/"
+
+        replace(
+          "apps/web/app.rb",
+          "# Specify sources for assets",
+          "prefix '/library/assets'\n# Specify sources for assets"
+        )
+
+        replace(
+          "apps/web/config/routes.rb",
+          "/",
+          "namespace :library { get '/', to: 'home#index' }"
+        )
+
+        write "apps/web/assets/javascripts/app.js", <<~EOF
+          console.log('test');
+        EOF
+
+        hanami "assets precompile"
+
+        server do
+          visit "/library/assets/app.js"
+          expect(page).to have_content("console.log('test');")
+        end
+      end
+    end
+  end
+end

data/spec/integration/assets/subresource_integrity_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "json"
+
+RSpec.describe "assets", type: :integration do
+  describe "subresource integrity" do
+    it "precompiles assets with checksums calculated with given algorithms" do
+      with_project do
+        generate "action web home#index --url=/"
+
+        write "apps/web/assets/javascripts/app.css", <<~EOF
+          body { font: Helvetica; }
+        EOF
+        rewrite "apps/web/templates/app.html.erb", <<~EOF
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Web</title>
+              <%= favicon %>
+              <%= stylesheet 'app' %>
+            </head>
+            <body>
+              <%= yield %>
+            </body>
+          </html>
+        EOF
+
+        replace "apps/web/app.rb", "subresource_integrity :sha256", "subresource_integrity :sha256, :sha512"
+
+        #
+        # Precompile
+        #
+        RSpec::Support::Env["HANAMI_ENV"] = "production"
+        # FIXME: database connection shouldn't be required for `assets precompile`
+        RSpec::Support::Env["DATABASE_URL"] = "sqlite://#{Pathname.new('db').join('bookshelf.sqlite')}"
+        RSpec::Support::Env["SMTP_HOST"] = "localhost"
+        RSpec::Support::Env["SMTP_PORT"] = "25"
+
+        hanami "assets precompile"
+
+        manifest = File.read("public/assets.json")
+        expect(JSON.parse(manifest)).to be_kind_of(Hash) # assert it's a well-formed JSON
+
+        expect(manifest).to include(%("/assets/app.css":{"target":"/assets/app-068e7d97b3671a14824bc20437ac5d06.css","sri":["sha256-cHgODQTP2nNk9ER+ViDGp+lC+ddHRmuLgJk05glJ4+w=","sha512-TDyxo1Ow7UjBib6ykALJh7J1OHEcE0yX4X21s1714ZBAhwdOz7k9t8+QQDAwWAmeH97bNaZGY7oTfVrwyTQ3cw=="]}))
+        expect(manifest).to include(%("/assets/favicon.ico":{"target":"/assets/favicon-b0979f93c7f7246ac70949a80f7cbdfd.ico","sri":["sha256-PLEDhpDsTBpxl1KtXjzBjg+PUG67zpf05B1z2db4iJU=","sha512-9NvaW7aVAywbLPPi3fw5s4wtWwd37i8VpzgfEo9uCOyr/mDT2dbYJtGNjfTJa4R8TOw69yHr4NhazPQsLt1WHw=="]}))
+
+        server do
+          visit "/"
+          expect(page.body).to include(%(<link href="/assets/app-068e7d97b3671a14824bc20437ac5d06.css" type="text/css" rel="stylesheet" integrity="sha256-cHgODQTP2nNk9ER+ViDGp+lC+ddHRmuLgJk05glJ4+w= sha512-TDyxo1Ow7UjBib6ykALJh7J1OHEcE0yX4X21s1714ZBAhwdOz7k9t8+QQDAwWAmeH97bNaZGY7oTfVrwyTQ3cw==" crossorigin="anonymous">))
+        end
+      end
+    end
+  end
+end

data/spec/integration/body_parsers_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+RSpec.describe "body parsers", type: :integration do
+  it "parses JSON payload for non-GET requests" do
+    with_project do
+      generate_action
+      enable_json_body_parser
+
+      server do
+        post "/books", %({"book": {"title": "CLI apps with Ruby"}}), "CONTENT_TYPE" => "app/json", "HTTP_ACCEPT" => "app/json"
+        expect(last_response.body).to eq(%({"book":{"title":"CLI apps with Ruby"}}))
+      end
+    end
+  end
+
+  it "doesn't eval untrusted JSON" do
+    with_project do
+      generate_action
+      enable_json_body_parser
+
+      server do
+        post "/books", %({"json_class": "Foo"}), "CONTENT_TYPE" => "app/json", "HTTP_ACCEPT" => "app/json"
+        expect(last_response.body).to eq(%({"json_class":"Foo"}))
+      end
+    end
+  end
+
+  private
+
+  def generate_action
+    generate "action web books#create --url=/books --method=POST"
+
+    rewrite "apps/web/controllers/books/create.rb", <<~EOF
+      require 'hanami/utils/json'
+      module Web::Controllers::Books
+        class Create
+          include Web::Action
+
+          def call(params)
+            self.body = Hanami::Utils::Json.generate(params.to_hash)
+          end
+        end
+      end
+    EOF
+  end
+
+  def enable_json_body_parser
+    inject_line_after "apps/web/app.rb", "configure do", "body_parsers :json"
+  end
+end