hanami 2.0.0.alpha8 → 2.0.0.beta1

data/spec/new_integration/view/context/assets_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Context / Assets", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.prepare
+
+    module TestApp
+      module Views
+        class Context < Hanami::View::Context
+        end
+      end
+    end
+  end
+
+  let(:context_class) { TestApp::Views::Context }
+  subject(:context) { context_class.new }
+
+  describe "#assets" do
+    context "without assets provider" do
+      it "raises error" do
+        expect { context.assets }
+          .to raise_error(Hanami::ComponentLoadError, /hanami-assets/)
+      end
+    end
+
+    context "with assets provider" do
+      before do
+        Hanami.app.register_provider(:assets) do
+          start do
+            register "assets", Object.new
+          end
+        end
+      end
+
+      it "is the app assets by default" do
+        expect(context.assets).to be TestApp::App[:assets]
+      end
+
+      context "injected assets" do
+        subject(:context) {
+          context_class.new(assets: assets)
+        }
+
+        let(:assets) { double(:assets) }
+
+        it "is the injected assets" do
+          expect(context.assets).to be assets
+        end
+
+        context "rebuilt context" do
+          subject(:new_context) { context.with }
+
+          it "retains the injected assets" do
+            expect(new_context.assets).to be assets
+          end
+        end
+      end
+    end
+  end
+end

data/spec/new_integration/view/context/inflector_spec.rb

@@ -0,0 +1,48 @@
+require "hanami"
+
+RSpec.describe "App view / Context / Inflector", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.prepare
+
+    module TestApp
+      module Views
+        class Context < Hanami::View::Context
+        end
+      end
+    end
+  end
+
+  let(:context_class) { TestApp::Views::Context }
+  subject(:context) { context_class.new }
+
+  describe "#inflector" do
+    it "is the app inflector by default" do
+      expect(context.inflector).to be TestApp::App.inflector
+    end
+
+    context "injected inflector" do
+      subject(:context) {
+        context_class.new(inflector: inflector)
+      }
+
+      let(:inflector) { double(:inflector) }
+
+      it "is the injected inflector" do
+        expect(context.inflector).to be inflector
+      end
+
+      context "rebuilt context" do
+        subject(:new_context) { context.with }
+
+        it "retains the injected inflector" do
+          expect(new_context.inflector).to be inflector
+        end
+      end
+    end
+  end
+end

data/spec/new_integration/view/context/request_spec.rb

@@ -0,0 +1,61 @@
+require "hanami"
+
+RSpec.describe "App view / Context / Request", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.prepare
+
+    module TestApp
+      module Views
+        class Context < Hanami::View::Context
+        end
+      end
+    end
+  end
+
+  let(:context_class) { TestApp::Views::Context }
+
+  subject(:context) {
+    context_class.new(
+      request: request,
+      response: response,
+    )
+  }
+
+  let(:request) { double(:request) }
+  let(:response) { double(:response) }
+
+  describe "#request" do
+    it "is the provided request" do
+      expect(context.request).to be request
+    end
+  end
+
+  describe "#sesion" do
+    let(:session) { double(:session) }
+
+    before do
+      allow(request).to receive(:session) { session }
+    end
+
+    it "is the request's session" do
+      expect(context.session).to be session
+    end
+  end
+
+  describe "#flash" do
+    let(:flash) { double(:flash) }
+
+    before do
+      allow(response).to receive(:flash) { flash }
+    end
+
+    it "is the response's flash" do
+      expect(context.flash).to be flash
+    end
+  end
+end

data/spec/new_integration/view/context/routes_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Context / Routes", :app_integration do
+  it "accesses app routes" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            define do
+              root to: "home.index"
+            end
+          end
+        end
+      RUBY
+
+      write "app/action.rb", <<~RUBY
+        require "hanami/action"
+
+        module TestApp
+          class Action < Hanami::Action
+          end
+        end
+      RUBY
+
+      write "app/actions/home/index.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Home
+              class Index < Hanami::Action
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/views/context.rb", <<~RUBY
+        require "hanami/view/context"
+
+        module TestApp
+          module Views
+            class Context < Hanami::View::Context
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      context = TestApp::Views::Context.new
+      expect(context.routes.path(:root)).to eq "/"
+    end
+  end
+
+  it "can inject routes" do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.prepare
+
+    module TestApp
+      module Views
+        class Context < Hanami::View::Context
+        end
+      end
+    end
+
+    routes = double(:routes)
+
+    context = TestApp::Views::Context.new(routes: routes)
+
+    expect(context.routes).to be(routes)
+  end
+end

data/spec/new_integration/view/context/settings_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Context / Settings", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.prepare
+
+    module TestApp
+      module Views
+        class Context < Hanami::View::Context
+        end
+      end
+    end
+  end
+
+  let(:context_class) { TestApp::Views::Context }
+  subject(:context) { context_class.new }
+
+  describe "#settings" do
+    it "is the app settings by default" do
+      expect(context.settings).to be TestApp::App.settings
+    end
+
+    context "injected settings" do
+      subject(:context) {
+        context_class.new(settings: settings)
+      }
+
+      let(:settings) { double(:settings) }
+
+      it "is the injected settings" do
+        expect(context.settings).to be settings
+      end
+
+      context "rebuilt context" do
+        subject(:new_context) { context.with }
+
+        it "retains the injected settings" do
+          expect(new_context.settings).to be settings
+        end
+      end
+    end
+  end
+end

data/spec/new_integration/view/inflector_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Inflector", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+        config.root = "/test_app"
+      end
+    end
+
+    Hanami.app.instance_eval(&app_hook) if respond_to?(:app_hook)
+    Hanami.app.register_slice :main
+    Hanami.app.prepare
+
+    module TestApp
+      class View < Hanami::View
+      end
+    end
+  end
+
+  subject(:view_class) { TestApp::View }
+
+  context "default app inflector" do
+    it "configures the view with the default app inflector" do
+      expect(view_class.config.inflector).to be TestApp::App.config.inflector
+    end
+  end
+
+  context "custom inflections configured" do
+    let(:app_hook) {
+      proc do
+        config.inflections do |inflections|
+          inflections.acronym "NBA"
+        end
+      end
+    }
+
+    it "configures the view with the customized app inflector" do
+      expect(view_class.config.inflector).to be TestApp::App.config.inflector
+      expect(view_class.config.inflector.camelize("nba_jam")).to eq "NBAJam"
+    end
+  end
+
+  context "custom inflector configured on view class" do
+    let(:custom_inflector) { Object.new }
+
+    before do
+      view_class.config.inflector = custom_inflector
+    end
+
+    it "overrides the default app inflector" do
+      expect(view_class.config.inflector).to be custom_inflector
+    end
+  end
+end

data/spec/new_integration/view/part_namespace_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Part namespace", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+        config.root = "/test_app"
+      end
+    end
+
+    Hanami.app.instance_eval(&app_hook) if respond_to?(:app_hook)
+    Hanami.app.register_slice :main
+    Hanami.app.prepare
+
+    # The parts module (or any related setup) must exist _before_ we subclass
+    # Hanami::View, because the parts_namespace is configured at the time of
+    # subclassing (which happens right below)
+    parts_module! if respond_to?(:parts_module!)
+
+    module TestApp
+      class View < Hanami::View
+      end
+    end
+
+    module TestApp
+      module Views
+        module Article
+          class Index < TestApp::View
+          end
+        end
+      end
+    end
+  end
+
+  subject(:part_namespace) { view_class.config.part_namespace }
+
+  let(:view_class) { TestApp::Views::Article::Index }
+
+  context "default parts_path" do
+    let(:parts_module!) do
+      module TestApp
+        module Views
+          module Parts
+          end
+        end
+      end
+    end
+
+    it "is View::Parts" do
+      is_expected.to eq TestApp::Views::Parts
+    end
+  end
+
+  context "custom parts_path configured" do
+    let(:app_hook) {
+      proc do
+        config.views.parts_path = "views/custom_parts"
+      end
+    }
+
+    context "parts module exists" do
+      let(:parts_module!) do
+        module TestApp
+          module Views
+            module CustomParts
+            end
+          end
+        end
+      end
+
+      it "is the matching module within the slice" do
+        is_expected.to eq TestApp::Views::CustomParts
+      end
+    end
+
+    context "namespace does not exist" do
+      it "is nil" do
+        is_expected.to be_nil
+      end
+    end
+  end
+
+  context "nil parts_path configured" do
+    let(:app_hook) {
+      proc do
+        config.views.parts_path = nil
+      end
+    }
+
+    it "is nil" do
+      is_expected.to be_nil
+    end
+  end
+end

data/spec/new_integration/view/path_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Path", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+        config.root = "/test_app"
+      end
+    end
+
+    Hanami.app.instance_eval(&app_hook) if respond_to?(:app_hook)
+    Hanami.app.register_slice :main
+    Hanami.app.prepare
+
+    module TestApp
+      class View < Hanami::View
+      end
+    end
+  end
+
+  let(:view_class) { TestApp::View }
+
+  subject(:paths) { view_class.config.paths }
+
+  context "default path" do
+    it "is 'templates' appended to the slice's root path" do
+      expect(paths.map { |path| path.dir.to_s }).to eq ["/test_app/app/templates"]
+    end
+  end
+
+  context "relative path provided in app config" do
+    let(:app_hook) {
+      proc do
+        config.views.paths = ["my_templates"]
+      end
+    }
+
+    it "configures the path as the relative path appended to the slice's root path" do
+      expect(paths.map { |path| path.dir.to_s }).to eq ["/test_app/app/my_templates"]
+    end
+  end
+
+  context "absolute path provided in app config" do
+    let(:app_hook) {
+      proc do
+        config.views.paths = ["/absolute/path"]
+      end
+    }
+
+    it "leaves the absolute path in place" do
+      expect(paths.map { |path| path.dir.to_s }).to eq ["/absolute/path"]
+    end
+  end
+end

data/spec/new_integration/view/template_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Template", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+        config.root = "/test_app"
+      end
+    end
+
+    Hanami.app.instance_eval(&app_hook) if respond_to?(:app_hook)
+    Hanami.app.register_slice :main
+    Hanami.app.prepare
+
+    module TestApp
+      class View < Hanami::View
+      end
+    end
+  end
+
+  subject(:template) { view_class.config.template }
+
+  context "Ordinary app view" do
+    before do
+      module TestApp
+        module Views
+          module Article
+            class Index < TestApp::View
+            end
+          end
+        end
+      end
+    end
+
+    let(:view_class) { TestApp::Views::Article::Index }
+
+    it "configures the tempalte to match the class name" do
+      expect(template).to eq "article/index"
+    end
+  end
+
+  context "Slice view with namespace matching template inference base" do
+    before do
+      module TestApp
+        module MyViews
+          module Users
+            class Show < TestApp::View
+            end
+          end
+        end
+      end
+    end
+
+    let(:app_hook) {
+      proc do
+        config.views.template_inference_base = "my_views"
+      end
+    }
+
+    let(:view_class) { TestApp::MyViews::Users::Show }
+
+    it "configures the tempalte to match the class name" do
+      expect(template).to eq "users/show"
+    end
+  end
+end

data/spec/new_integration/view/views_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe "Hanami view integration", :app_integration do
+  specify "Views take their configuration from their slice in which they are defined" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/view.rb", <<~RUBY
+        # auto_register: false
+        require "hanami/view"
+
+        module TestApp
+          class View < Hanami::View
+          end
+        end
+      RUBY
+
+      write "app/views/users/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Users
+              class Show < TestApp::View
+                expose :name
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/templates/layouts/app.html.slim", <<~SLIM
+        html
+          body
+            == yield
+      SLIM
+
+      write "app/templates/users/show.html.slim", <<~'SLIM'
+        h1 Hello, #{name}
+      SLIM
+
+      require "hanami/prepare"
+
+      rendered = TestApp::App["views.users.show"].(name: "Jennifer")
+      expect(rendered.to_s).to eq "<html><body><h1>Hello, Jennifer</h1></body></html>"
+    end
+  end
+
+  specify "Views can also take configuration from the app when defined in the top-level app module" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/view.rb", <<~RUBY
+        # auto_register: false
+        require "hanami/view"
+
+        module TestApp
+          class View < Hanami::View
+          end
+        end
+      RUBY
+
+      write "app/views/users/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Users
+              class Show < TestApp::View
+                expose :name
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/templates/layouts/app.html.slim", <<~SLIM
+        html
+          body
+            == yield
+      SLIM
+
+      write "app/templates/users/show.html.slim", <<~'SLIM'
+        h1 Hello, #{name}
+      SLIM
+
+      require "hanami/prepare"
+
+      rendered = TestApp::App["views.users.show"].(name: "Jennifer")
+      expect(rendered.to_s).to eq "<html><body><h1>Hello, Jennifer</h1></body></html>"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+SPEC_ROOT = File.expand_path(__dir__).freeze
+
+require_relative "support/coverage" if ENV["COVERAGE"].eql?("true")
+
+require "hanami"
+begin; require "byebug"; rescue LoadError; end
+require "hanami/utils/file_list"
+require "hanami/devtools/unit"
+
+Hanami::Utils::FileList["./spec/support/**/*.rb"].each do |file|
+  next if file.include?("hanami-plugin")
+
+  require file
+end