hanami 2.3.2 → 3.0.0.rc1

data/spec/unit/hanami/config/views_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config"
-require "saharspec/matchers/dont"
-
-RSpec.describe Hanami::Config, "#views" do
-  let(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { "MyApp::app" }
-
-  subject(:views) { config.views }
-
-  context "hanami-view is bundled" do
-    it "exposes Hanami::Views's app config" do
-      is_expected.to be_an_instance_of(Hanami::Config::Views)
-
-      is_expected.to respond_to(:finalize!)
-      is_expected.to respond_to(:layouts_dir)
-      is_expected.to respond_to(:layouts_dir=)
-    end
-
-    it "includes base view config" do
-      expect(views).to respond_to(:paths)
-      expect(views).to respond_to(:paths=)
-    end
-
-    it "does not include the inflector setting" do
-      expect(views).not_to respond_to(:inflector)
-      expect(views).not_to respond_to(:inflector=)
-    end
-
-    it "preserves default values from the base view config" do
-      expect(views.layouts_dir).to eq Hanami::View.config.layouts_dir
-    end
-
-    it "allows settings to be configured independently of the base view config" do
-      expect { views.layouts_dir = "custom_layouts" }
-        .to change { views.layouts_dir }.to("custom_layouts")
-        .and(dont.change { Hanami::View.config.layouts_dir })
-    end
-
-    describe "specialised default values" do
-      describe "layout" do
-        it 'is "app"' do
-          expect(views.layout).to eq "app"
-        end
-      end
-    end
-
-    describe "finalized config" do
-      before do
-        views.finalize!
-      end
-
-      it "is frozen" do
-        expect(views).to be_frozen
-      end
-
-      it "does not allow changes to base view settings" do
-        expect { views.paths = [] }.to raise_error(Dry::Configurable::FrozenConfigError)
-      end
-    end
-  end
-
-  context "hanami-view is not bundled" do
-    before do
-      allow(Hanami).to receive(:bundled?).and_call_original
-      expect(Hanami).to receive(:bundled?).with("hanami-view").and_return(false)
-    end
-
-    it "does not expose any settings" do
-      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
-      is_expected.not_to respond_to(:layouts_dir)
-      is_expected.not_to respond_to(:layouts_dir=)
-    end
-
-    it "can be finalized" do
-      is_expected.to respond_to(:finalize!)
-    end
-  end
-end

data/spec/unit/hanami/env_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hanami, ".env" do
-  subject { described_class.env(e: env) }
-
-  context "HANAMI_ENV, APP_ENV and RACK_ENV in ENV" do
-    let(:env) { { "HANAMI_ENV" => "test", "APP_ENV" => "development", "RACK_ENV" => "production" } }
-
-    it "is the value of HANAMI_ENV" do
-      is_expected.to eq(:test)
-    end
-  end
-
-  context "APP_ENV and RACK_ENV in ENV" do
-    let(:env) { {"APP_ENV" => "development", "RACK_ENV" => "production" } }
-
-    it "is the value of APP_ENV" do
-      is_expected.to eq(:development)
-    end
-  end
-
-  context "RACK_ENV in ENV" do
-    let(:env) { { "RACK_ENV" => "production" } }
-
-    it "is the value of RACK_ENV" do
-      is_expected.to eq(:production)
-    end
-  end
-
-  context "no ENV vars set" do
-    let(:env) { {} }
-
-    it "defaults to \"development\"" do
-      is_expected.to eq(:development)
-    end
-  end
-end

data/spec/unit/hanami/extensions/view/context_spec.rb

@@ -1,59 +0,0 @@
-require "hanami/view"
-require "hanami/view/context"
-require "hanami/extensions/view/context"
-
-RSpec.describe(Hanami::View::Context) do
-  subject(:context) { described_class.new(**args) }
-  let(:args) { {} }
-
-  describe "#assets" do
-    context "assets given" do
-      let(:args) { {assets: assets} }
-      let(:assets) { double(:assets) }
-
-      it "returns the assets" do
-        expect(context.assets).to be assets
-      end
-    end
-
-    context "no assets given" do
-      it "raises a Hanami::ComponentLoadError" do
-        expect { context.assets }.to raise_error Hanami::ComponentLoadError
-      end
-    end
-  end
-
-  describe "#request" do
-    context "request given" do
-      let(:args) { {request: request} }
-      let(:request) { double(:request) }
-
-      it "returns the request" do
-        expect(context.request).to be request
-      end
-    end
-
-    context "no request given" do
-      it "raises a Hanami::ComponentLoadError" do
-        expect { context.request }.to raise_error Hanami::ComponentLoadError
-      end
-    end
-  end
-
-  describe "#routes" do
-    context "routes given" do
-      let(:args) { {routes: routes} }
-      let(:routes) { double(:routes) }
-
-      it "returns the routes" do
-        expect(context.routes).to be routes
-      end
-    end
-
-    context "no routes given" do
-      it "raises a Hanami::ComponentLoadError" do
-        expect { context.routes }.to raise_error Hanami::ComponentLoadError
-      end
-    end
-  end
-end

data/spec/unit/hanami/helpers/assets_helper/asset_url_spec.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hanami::Helpers::AssetsHelper, "#asset_url", :app_integration do
-  subject(:obj) {
-    helpers = described_class
-    Class.new {
-      include helpers
-
-      attr_reader :_context
-
-      def initialize(context)
-        @_context = context
-      end
-    }.new(context)
-  }
-
-  def asset_url(...)
-    subject.asset_url(...)
-  end
-
-  let(:context) { TestApp::Views::Context.new }
-  let(:root) { make_tmp_directory }
-
-  before do
-    with_directory(root) do
-      write "config/app.rb", <<~RUBY
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "app/views/context.rb", <<~RUBY
-        # auto_register: false
-
-        require "hanami/view/context"
-
-        module TestApp
-          module Views
-            class Context < Hanami::View::Context
-            end
-          end
-        end
-      RUBY
-
-      write "app/assets/js/app.ts", <<~JS
-        import "../css/app.css";
-
-        console.log("Hello from index.ts");
-      JS
-
-      write "app/assets/css/app.css", <<~CSS
-        .btn {
-          background: #f00;
-        }
-      CSS
-
-      stub_assets("app.js")
-
-      require "hanami/setup"
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  context "when configurated relative path only" do
-    context "without manifest" do
-      it "returns the relative URL to the asset" do
-        expect(asset_url("app.js")).to eq("/assets/app.js")
-      end
-
-      it "returns absolute URL if the argument is an absolute URL" do
-        result = asset_url("http://assets.hanamirb.org/assets/application.css")
-        expect(result).to eq("http://assets.hanamirb.org/assets/application.css")
-      end
-    end
-
-    context "with manifest" do
-      before { compile_assets! }
-
-      it "returns the relative URL to the asset" do
-        expect(asset_url("app.js")).to match(%r{/assets/app-[A-Z0-9]{8}\.js})
-      end
-    end
-  end
-
-  context "when configured with base url" do
-    let(:base_url) { "https://hanami.test" }
-
-    def before_prepare
-      Hanami.app.config.assets.base_url = base_url
-    end
-
-    context "without manifest" do
-      it "returns the absolute URL to the asset" do
-        expect(asset_url("app.js")).to eq("#{base_url}/assets/app.js")
-      end
-    end
-
-    context "with manifest" do
-      before { compile_assets! }
-
-      it "returns the relative path to the asset" do
-        expect(asset_url("app.js")).to match(%r{#{base_url}/assets/app-[A-Z0-9]{8}.js})
-      end
-    end
-  end
-
-  context "given an asset object" do
-    it "returns the URL for the asset" do
-      asset = Hanami::Assets::Asset.new(
-        path: "/foo/bar.js",
-        base_url: Hanami.app.config.assets.base_url
-      )
-
-      expect(asset_url(asset)).to eq "/foo/bar.js"
-    end
-  end
-end

data/spec/unit/hanami/helpers/assets_helper/audio_tag_spec.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hanami::Helpers::AssetsHelper, "#audio", :app_integration do
-  subject(:obj) {
-    helpers = described_class
-    Class.new {
-      include helpers
-
-      attr_reader :_context
-
-      def initialize(context)
-        @_context = context
-      end
-    }.new(context)
-  }
-
-  def audio_tag(...)
-    subject.audio_tag(...)
-  end
-
-  let(:context) { TestApp::Views::Context.new }
-  let(:root) { make_tmp_directory }
-
-  before do
-    with_directory(root) do
-      write "config/app.rb", <<~RUBY
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "app/views/context.rb", <<~RUBY
-        # auto_register: false
-
-        require "hanami/view/context"
-
-        module TestApp
-          module Views
-            class Context < Hanami::View::Context
-            end
-          end
-        end
-      RUBY
-
-      stub_assets("song.ogg", "song.pt-BR.vtt")
-
-      require "hanami/setup"
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  it "returns an instance of HtmlBuilder" do
-    actual = audio_tag("song.ogg")
-    expect(actual).to be_instance_of(::Hanami::View::HTML::SafeString)
-  end
-
-  it "renders <audio> tag" do
-    actual = audio_tag("song.ogg").to_s
-    expect(actual).to eq(%(<audio src="/assets/song.ogg"></audio>))
-  end
-
-  it "renders with html attributes" do
-    actual = audio_tag("song.ogg", autoplay: true, controls: true).to_s
-    expect(actual).to eq(%(<audio autoplay="autoplay" controls="controls" src="/assets/song.ogg"></audio>))
-  end
-
-  it "renders with fallback content" do
-    actual = audio_tag("song.ogg") do
-      "Your browser does not support the audio tag"
-    end.to_s
-
-    expect(actual).to eq(%(<audio src="/assets/song.ogg">Your browser does not support the audio tag</audio>))
-  end
-
-  it "renders with tracks" do
-    actual = audio_tag("song.ogg") do
-      tag.track kind: "captions", src: subject.asset_url("song.pt-BR.vtt"), srclang: "pt-BR", label: "Portuguese"
-    end.to_s
-
-    expect(actual).to eq(%(<audio src="/assets/song.ogg"><track kind="captions" src="/assets/song.pt-BR.vtt" srclang="pt-BR" label="Portuguese"></audio>))
-  end
-
-  xit "renders with sources" do
-    actual = audio do
-      tag.text "Your browser does not support the audio tag"
-      tag.source src: subject.asset_url("song.ogg"), type: "audio/ogg"
-      tag.source src: subject.asset_url("song.wav"), type: "audio/wav"
-    end.to_s
-
-    expect(actual).to eq(%(<audio>Your browser does not support the audio tag<source src="/assets/song.ogg" type="audio/ogg"><source src="/assets/song.wav" type="audio/wav"></audio>))
-  end
-
-  it "raises an exception when no arguments" do
-    expect do
-      audio_tag
-    end.to raise_error(
-      ArgumentError,
-      "You should provide a source via `src` option or with a `source` HTML tag"
-    )
-  end
-
-  it "raises an exception when no src and no block" do
-    expect do
-      audio_tag(controls: true)
-    end.to raise_error(
-      ArgumentError,
-      "You should provide a source via `src` option or with a `source` HTML tag"
-    )
-  end
-
-  describe "cdn mode" do
-    let(:base_url) { "https://hanami.test" }
-
-    def before_prepare
-      Hanami.app.config.assets.base_url = base_url
-    end
-
-    it "returns absolute url for src attribute" do
-      actual = audio_tag("song.ogg").to_s
-      expect(actual).to eq(%(<audio src="#{base_url}/assets/song.ogg"></audio>))
-    end
-  end
-
-  private
-
-  def tag(...)
-    subject.__send__(:tag, ...)
-  end
-end

data/spec/unit/hanami/helpers/assets_helper/favicon_tag_spec.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hanami::Helpers::AssetsHelper, "#favicon", :app_integration do
-  subject(:obj) {
-    helpers = described_class
-    Class.new {
-      include helpers
-
-      attr_reader :_context
-
-      def initialize(context)
-        @_context = context
-      end
-    }.new(context)
-  }
-
-  def favicon_tag(...)
-    obj.instance_eval { favicon_tag(...) }
-  end
-
-  let(:root) { make_tmp_directory }
-  let(:context) { TestApp::Views::Context.new }
-
-  before do
-    with_directory(root) do
-      write "config/app.rb", <<~RUBY
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "app/views/context.rb", <<~RUBY
-        # auto_register: false
-
-        require "hanami/view/context"
-
-        module TestApp
-          module Views
-            class Context < Hanami::View::Context
-            end
-          end
-        end
-      RUBY
-
-      stub_assets("favicon.ico", "favicon.png")
-
-      require "hanami/setup"
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  it "returns an instance of SafeString" do
-    actual = favicon_tag
-    expect(actual).to be_instance_of(::Hanami::View::HTML::SafeString)
-  end
-
-  it "renders <link> tag" do
-    actual = favicon_tag.to_s
-    expect(actual).to eq(%(<link href="/assets/favicon.ico" rel="shortcut icon" type="image/x-icon">))
-  end
-
-  it "renders with HTML attributes" do
-    actual = favicon_tag("favicon.png", rel: "icon", type: "image/png").to_s
-    expect(actual).to eq(%(<link href="/assets/favicon.png" rel="icon" type="image/png">))
-  end
-
-  it "ignores href passed as an option" do
-    actual = favicon_tag("favicon.png", href: "wrong").to_s
-    expect(actual).to eq(%(<link href="/assets/favicon.png" rel="shortcut icon" type="image/x-icon">))
-  end
-
-  describe "cdn mode" do
-    let(:base_url) { "https://hanami.test" }
-
-    def before_prepare
-      Hanami.app.config.assets.base_url = "https://hanami.test"
-    end
-
-    it "returns absolute url for href attribute" do
-      actual = favicon_tag.to_s
-      expect(actual).to eq(%(<link href="#{base_url}/assets/favicon.ico" rel="shortcut icon" type="image/x-icon">))
-    end
-  end
-end

data/spec/unit/hanami/helpers/assets_helper/image_tag_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Hanami::Helpers::AssetsHelper, "#image", :app_integration do
-  subject(:obj) {
-    helpers = described_class
-    Class.new {
-      include helpers
-
-      attr_reader :_context
-
-      def initialize(context)
-        @_context = context
-      end
-    }.new(context)
-  }
-
-  def image_tag(...)
-    subject.image_tag(...)
-  end
-
-  let(:root) { make_tmp_directory }
-  let(:context) { TestApp::Views::Context.new }
-
-  before do
-    with_directory(root) do
-      write "config/app.rb", <<~RUBY
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "app/views/context.rb", <<~RUBY
-        # auto_register: false
-
-        require "hanami/view/context"
-
-        module TestApp
-          module Views
-            class Context < Hanami::View::Context
-            end
-          end
-        end
-      RUBY
-
-      stub_assets("application.jpg")
-
-      require "hanami/setup"
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  it "returns an instance of HtmlBuilder" do
-    actual = image_tag("application.jpg")
-    expect(actual).to be_instance_of(::Hanami::View::HTML::SafeString)
-  end
-
-  it "renders an <img> tag" do
-    actual = image_tag("application.jpg").to_s
-    expect(actual).to eq(%(<img src="/assets/application.jpg" alt="Application">))
-  end
-
-  it "custom alt" do
-    actual = image_tag("application.jpg", alt: "My Alt").to_s
-    expect(actual).to eq(%(<img src="/assets/application.jpg" alt="My Alt">))
-  end
-
-  it "custom data attribute" do
-    actual = image_tag("application.jpg", "data-user-id" => 5).to_s
-    expect(actual).to eq(%(<img src="/assets/application.jpg" alt="Application" data-user-id="5">))
-  end
-
-  it "ignores src passed as an option" do
-    actual = image_tag("application.jpg", src: "wrong").to_s
-    expect(actual).to eq(%(<img src="/assets/application.jpg" alt="Application">))
-  end
-
-  describe "cdn mode" do
-    let(:base_url) { "https://hanami.test" }
-
-    def before_prepare
-      Hanami.app.config.assets.base_url = "https://hanami.test"
-    end
-
-    it "returns absolute url for src attribute" do
-      actual = image_tag("application.jpg").to_s
-      expect(actual).to eq(%(<img src="#{base_url}/assets/application.jpg" alt="Application">))
-    end
-  end
-end