keynote 1.1.1 → 2.0.0

data/spec/presenter_spec.rb

@@ -1,179 +0,0 @@
-# encoding: UTF-8
-
-require 'helper'
-
-TestPresenter = Keynote::Presenter
-
-describe Keynote::Presenter do
-  describe "delegation" do
-    let(:klass) do
-      Class.new(TestPresenter) do
-        presents :grizzly, :bear
-        delegate :adams, :to => :grizzly
-        delegate :man, :to => :grizzly, :prefix => true
-      end
-    end
-
-    it "should be able to use ActiveSupport Module#delegate method" do
-      mock = mock()
-      mock.expects(:adams)
-      mock.expects(:man)
-
-      klass.new(nil, mock, nil).tap do |p|
-        p.adams
-        p.grizzly_man
-      end
-    end
-  end
-
-  describe ".presents" do
-    it "should take just the view context by default" do
-      klass = Class.new(TestPresenter)
-
-      klass.new(1).instance_variable_get(:@view).must_equal 1
-    end
-
-    describe "with two parameters" do
-      let(:klass) do
-        Class.new(TestPresenter) do
-          presents :grizzly, :bear
-        end
-      end
-
-      it "should let you specify other objects to take" do
-        klass.new(1, 2, 3).instance_eval do
-          @view.must_equal 1
-          @grizzly.must_equal 2
-          @bear.must_equal 3
-        end
-      end
-
-      it "should not be callable with the wrong arity" do
-        proc { klass.new(1, 2) }.must_raise ArgumentError
-      end
-
-      it "should generate readers for the objects" do
-        klass.new(1, 2, 3).tap do |p|
-          p.view.must_equal 1
-          p.grizzly.must_equal 2
-          p.bear.must_equal 3
-        end
-      end
-    end
-  end
-
-  describe ".use_html5_tags" do
-    let(:klass) do
-      Class.new(TestPresenter) do
-        def generate_h3(content)
-          build_html { h3 content }
-        end
-
-        def generate_small(content)
-          build_html { small content }
-        end
-      end
-    end
-
-    it "should add Rumble tags like `small` while preserving existing tags" do
-      presenter = klass.new(nil)
-
-      presenter.generate_h3("hi").must_equal "<h3>hi</h3>"
-      proc { presenter.generate_small("uh-oh") }.must_raise NoMethodError
-
-      klass.use_html_5_tags
-
-      presenter.generate_h3("hi").must_equal "<h3>hi</h3>"
-      presenter.generate_small("hi").must_equal "<small>hi</small>"
-    end
-  end
-
-  describe ".object_names" do
-    it "doesn't leak between classes" do
-      c1 = Class.new(Keynote::Presenter)
-      c2 = Class.new(Keynote::Presenter)
-
-      c1.object_names << :foo
-      c1.object_names.must_equal [:foo]
-      c2.object_names.must_equal []
-    end
-
-    it "matches the list of presented objects" do
-      c = Class.new(Keynote::Presenter)
-      c.object_names.must_equal []
-      c.presents :biff, :bam, :pow
-      c.object_names.must_equal [:biff, :bam, :pow]
-    end
-  end
-
-  describe "#present" do
-    it "should pass its view context through to the new presenter" do
-      mock = mock()
-      mock.expects(:pizza)
-
-      p1 = TestPresenter.new(mock)
-      p2 = p1.present(:test)
-
-      p1.wont_equal p2
-      p2.pizza
-    end
-  end
-
-  describe "#inspect" do
-    it "includes the class name" do
-      CombinedPresenter.new(:view, :a, :b).inspect.
-        must_match(/^#<CombinedPresenter /)
-    end
-
-    it "shows .inspect output for each presented object" do
-      c1 = Class.new(Object) { def inspect; "c1"; end }
-      c2 = Class.new(Object) { def inspect; "c2"; end }
-      p  = CombinedPresenter.new(:view, c1.new, c2.new)
-
-      p.inspect.must_equal "#<CombinedPresenter model_1: c1, model_2: c2>"
-    end
-
-    it "shouldn't leave extra padding for zero-arg presenters" do
-      EmptyPresenter.new(:view).inspect.must_equal "#<EmptyPresenter>"
-    end
-  end
-
-  describe "#method_missing" do
-    it "should pass unknown method calls through to the view" do
-      mock = mock()
-      mock.expects(:talking).with(:heads)
-
-      object = Class.new do
-        define_method(:talking) do |arg|
-          mock.talking(arg)
-        end
-        private :talking
-      end.new
-
-      TestPresenter.new(object).talking(:heads)
-    end
-
-    it "should respond_to? methods of the view" do
-      object = Class.new do
-        define_method(:talking) do |arg|
-        end
-        private :talking
-      end.new
-
-      TestPresenter.new(object).respond_to?(:talking).must_equal true
-    end
-
-    it "should raise unknown methods at the presenter, not the view" do
-      err = nil
-
-      begin
-        Keynote::Presenter.new(Object.new).talking(:heads)
-      rescue NoMethodError => e
-        err = e
-      end
-
-      err.wont_be_nil
-      err.message.must_match(/Keynote::Presenter/)
-    end
-  end
-end

data/spec/railtie_spec.rb

@@ -1,33 +0,0 @@
-# encoding: UTF-8
-
-require 'helper'
-
-describe Keynote::Railtie do
-  let(:controller) { HelloController.new }
-  let(:context)    { controller.view_context }
-
-  it "should make the present and k methods available to controllers" do
-    controller.must_respond_to :present
-    controller.must_respond_to :k
-  end
-
-  it "should make the present and k methods available to views" do
-    context.must_respond_to :present
-    context.must_respond_to :k
-  end
-
-  it "should pass present call from controller to Keynote.present" do
-    context = stub
-    controller.stubs(:view_context).returns(context)
-
-    Keynote.expects(:present).with(context, :dallas, :leeloo, :multipass)
-
-    controller.present(:dallas, :leeloo, :multipass)
-  end
-
-  it "should pass present call from view to Keynote.present" do
-    Keynote.expects(:present).with(context, :dallas, :leeloo, :multipass)
-
-    context.present(:dallas, :leeloo, :multipass)
-  end
-end

data/spec/rumble_spec.rb

@@ -1,277 +0,0 @@
-# encoding: UTF-8
-
-# Original Rumble tests (c) 2011 Magnus Holm (https://github.com/judofyr).
-
-require 'helper'
-
-if defined?(Minitest::Test)
-  klass = Minitest::Test
-else
-  klass = MiniTest::Unit::TestCase
-end
-
-class TestRumble < klass
-  include Keynote::Rumble
-
-  def assert_rumble(str, &blk)
-    exp = str.gsub(/(\s+(<)|>\s+)/) { $2 || '>' }
-    res = nil
-    build_html {
-      res = yield.to_s
-    }
-    assert_equal exp, res
-    assert_instance_of ActiveSupport::SafeBuffer, res
-  end
-
-  def setup
-    @rumble_context = nil
-    super
-    assert_nil @rumble_context
-  end
-
-  def teardown
-    super
-    assert_nil @rumble_context
-  end
-
-  def test_simple
-    str = <<-HTML
-      <form>
-        <div id="wrapper">
-          <h1>My Site</h1>
-        </div>
-        <div class="input">
-          <input type="text" name="value">
-        </div>
-      </form>
-    HTML
-
-    assert_rumble str do
-      form do
-        div.wrapper! do
-          h1 "My Site"
-        end
-
-        div.input do
-          input type: 'text', name: 'value'
-        end
-      end
-    end
-  end
-
-  def test_string_data
-    assert_rumble '<div data="whatever"></div>' do
-      div data: "whatever"
-    end
-  end
-
-  def test_true_as_value
-    assert_rumble '<input disabled="disabled">' do
-      input disabled: true
-    end
-  end
-
-  def test_hash_data
-    str = <<-HTML
-      <div data-modal="true" data-safe="&quot;&quot;&quot;" data-unsafe="&quot;&amp;quot;&quot;">
-      </div>
-    HTML
-
-    assert_rumble str do
-      div data: {
-        modal: true,
-        safe: '"&quot;"'.html_safe,
-        absent: nil,
-        unsafe: '"&quot;"'
-      }
-    end
-  end
-
-  def test_string_aria
-    assert_rumble '<div aria="whatever"></div>' do
-      div aria: "whatever"
-    end
-  end
-
-  def test_hash_aria
-    str = <<-HTML
-      <div aria-modal="true" aria-safe="&quot;&quot;&quot;" aria-unsafe="&quot;&amp;quot;&quot;">
-      </div>
-    HTML
-
-    assert_rumble str do
-      div aria: {
-        modal: true,
-        safe: '"&quot;"'.html_safe,
-        absent: nil,
-        unsafe: '"&quot;"'
-      }
-    end
-  end
-
-  def test_array_attrs
-    str = <<-HTML
-      <div class="hello &quot;uns&amp;amp;fe&quot; &quot;w&amp;rld&quot;">
-      </div>
-    HTML
-
-    assert_rumble str do
-      div class: ["hello", '"uns&amp;fe"', '"w&amp;rld"'.html_safe]
-    end
-  end
-
-  def test_nil_attr
-    str = <<-HTML
-      <div id="id" class="class"></div>
-    HTML
-
-    assert_rumble str do
-      div id: "id", title: nil, class: "class"
-    end
-  end
-
-  def test_several
-    str = <<-HTML
-      <p>Hello</p>
-      <p>World</p>
-    HTML
-
-    assert_rumble str do
-      p "Hello"
-      p "World"
-    end
-  end
-
-  def test_several_capture
-    str = <<-HTML
-      <div>
-        <p>Hello</p>
-        <p>Hello</p>
-        |
-        <p>World</p>
-        <p>World</p>
-      </div>
-    HTML
-
-    assert_rumble str do
-      div do
-        (%w[Hello World].map { |x| build_html { p x; p x } } * '|').html_safe
-      end
-    end
-  end
-
-  def test_capture_raise
-    assert_raises RuntimeError do
-      build_html {
-        div do
-          build_html { raise }
-        end
-      }
-    end
-  end
-
-  def test_escape
-    str = <<-HTML
-      <p class="&quot;test&quot;">Hello &amp; World</p>
-    HTML
-
-    assert_rumble str do
-      p "Hello & World", :class => '"test"'
-    end
-  end
-
-  def test_multiple_css_classes
-    str = <<-HTML
-      <p class="one two three"></p>
-    HTML
-
-    assert_rumble str do
-      p.one.two.three
-    end
-  end
-
-  def test_selfclosing
-    assert_rumble "<br>" do
-      br
-    end
-  end
-
-  def test_text
-    assert_rumble "hello" do
-      text "hello"
-    end
-  end
-
-  def test_escaping_unsafe_input
-    str = "<br>"
-
-    assert_rumble "<div>&lt;br&gt;</div>" do
-      div { str }
-    end
-
-    assert_rumble "<div>&lt;br&gt;</div>" do
-      div str
-    end
-
-    assert_rumble "<div>&lt;br&gt;</div>" do
-      div { text { str } }
-    end
-
-    assert_rumble "<div>&lt;br&gt;</div>" do
-      div { text str }
-    end
-  end
-
-  def test_not_escaping_safe_input
-    str = "<br>".html_safe
-
-    assert_rumble "<div><br></div>" do
-      div { str }
-    end
-
-    assert_rumble "<div><br></div>" do
-      div str
-    end
-
-    assert_rumble "<div><br></div>" do
-      div { text { str } }
-    end
-
-    assert_rumble "<div><br></div>" do
-      div { text str }
-    end
-  end
-
-  def test_error_tags_outside_rumble_context
-    assert_raises Keynote::Rumble::Error do
-      div "content"
-    end
-  end
-
-  def test_error_selfclosing_content
-    assert_raises Keynote::Rumble::Error do
-      build_html {
-        br "content"
-      }
-    end
-  end
-
-  def test_error_css_proxy_continue
-    assert_raises Keynote::Rumble::Error do
-      build_html {
-        p.one("test").two
-      }
-    end
-  end
-
-  # The real test here is if @rumble_context is nil in the teardown.
-  def test_error_general
-    assert_raises RuntimeError do
-      build_html {
-        div do
-          raise
-        end
-      }
-    end
-  end
-end

data/spec/test_case_spec.rb

@@ -1,12 +0,0 @@
-# encoding: UTF-8
-
-class Keynote::NestedPresenterTest < Keynote::TestCase
-  setup do
-    @presenter = Keynote::NestedPresenter.new(view, :model)
-  end
-
-  test "presenter has view context" do
-    assert_equal "<div id=\"hi\"><a href=\"Hello\">#</a></div>",
-      @presenter.generate_div
-  end
-end