curly-templates 2.5.0 → 2.6.0

data/perf/component_benchmark.rb

@@ -1,41 +0,0 @@
-require 'bundler/setup'
-require 'benchmark/ips'
-
-ENV["RAILS_ENV"] = "test"
-
-require_relative '../spec/dummy/config/environment'
-
-class TestPresenter < Curly::Presenter
-  def hello_with_delegation
-    some_helper
-  end
-
-  def hello_without_delegation
-    not_some_helper
-  end
-
-  private
-
-  def not_some_helper
-  end
-end
-
-class TestContext
-  def some_helper
-  end
-end
-
-context = TestContext.new
-presenter = TestPresenter.new(context)
-
-Benchmark.ips do |x|
-  x.report "presenter method that delegates to the view context" do
-    presenter.hello_with_delegation
-  end
-
-  x.report "presenter method that doesn't delegate to the view context" do
-    presenter.hello_without_delegation
-  end
-
-  x.compare!
-end

data/spec/attribute_scanner_spec.rb

@@ -1,44 +0,0 @@
-describe Curly::AttributeScanner do
-  it "scans attributes" do
-    scan("width=10px height=20px").should == {
-      "width" => "10px",
-      "height" => "20px"
-    }
-  end
-
-  it "scans single quoted values" do
-    scan("title='hello world'").should == { "title" => "hello world" }
-  end
-
-  it "scans double quoted values" do
-    scan('title="hello world"').should == { "title" => "hello world" }
-  end
-
-  it "scans mixed quotes" do
-    scan(%[x=y q="foo's bar" v='bim " bum' t="foo ' bar"]).should == {
-      "x" => "y",
-      "q" => "foo's bar",
-      "t" => "foo ' bar",
-      "v" => 'bim " bum'
-    }
-  end
-
-  it "deals with weird whitespace" do
-    scan(" size=big  ").should == { "size" => "big" }
-  end
-
-  it "scans empty attribute lists" do
-    scan(nil).should == {}
-    scan("").should == {}
-    scan(" ").should == {}
-  end
-
-  it "fails when an invalid attribute list is passed" do
-    expect { scan("foo") }.to raise_exception(Curly::AttributeError)
-    expect { scan("foo=") }.to raise_exception(Curly::AttributeError)
-  end
-
-  def scan(str)
-    described_class.scan(str)
-  end
-end

data/spec/collection_blocks_spec.rb

@@ -1,78 +0,0 @@
-describe "Collection block components" do
-  include CompilationSupport
-
-  before do
-    define_presenter "ItemPresenter" do
-      presents :item
-
-      def name
-        @item
-      end
-    end
-  end
-
-  example "with neither identifier nor attributes" do
-    define_presenter do
-      def items
-        ["one", "two", "three"]
-      end
-    end
-
-    render("{{*items}}<{{name}}>{{/items}}").should == "<one><two><three>"
-  end
-
-  example "with an identifier" do
-    define_presenter do
-      def items(filter = nil)
-        if filter == "even"
-          ["two"]
-        elsif filter == "odd"
-          ["one", "three"]
-        else
-          ["one", "two", "three"]
-        end
-      end
-    end
-
-    render("{{*items.even}}<{{name}}>{{/items.even}}").should == "<two>"
-    render("{{*items.odd}}<{{name}}>{{/items.odd}}").should == "<one><three>"
-    render("{{*items}}<{{name}}>{{/items}}").should == "<one><two><three>"
-  end
-
-  example "with attributes" do
-    define_presenter do
-      def items(length: "1")
-        ["x"] * length.to_i
-      end
-    end
-
-    render("{{*items length=3}}<{{name}}>{{/items}}").should == "<x><x><x>"
-    render("{{*items}}<{{name}}>{{/items}}").should == "<x>"
-  end
-
-  example "with nested collection blocks" do
-    define_presenter do
-      def items
-        [{ parts: [1, 2] }, { parts: [3, 4] }]
-      end
-    end
-
-    define_presenter "ItemPresenter" do
-      presents :item
-
-      def parts
-        @item[:parts]
-      end
-    end
-
-    define_presenter "PartPresenter" do
-      presents :part
-
-      def number
-        @part
-      end
-    end
-
-    render("{{*items}}<{{*parts}}[{{number}}]{{/parts}}>{{/items}}").should == "<[1][2]><[3][4]>"
-  end
-end

data/spec/compiler/collections_spec.rb

@@ -1,230 +0,0 @@
-describe Curly::Compiler do
-  include CompilationSupport
-
-  context "normal rendering" do
-    before do
-      define_presenter "ItemPresenter" do
-        presents :item
-        delegate :name, to: :@item
-      end
-    end
-
-    it "compiles collection blocks" do
-      define_presenter do
-        presents :items
-        attr_reader :items
-      end
-
-      item1 = double("item1", name: "foo")
-      item2 = double("item2", name: "bar")
-
-      template = "<ul>{{*items}}<li>{{name}}</li>{{/items}}</ul>"
-      expect(render(template, locals: { items: [item1, item2] })).
-        to eql "<ul><li>foo</li><li>bar</li></ul>"
-    end
-
-    it "allows attributes on collection blocks" do
-      define_presenter do
-        presents :items
-
-        def items(status: nil)
-          if status
-            @items.select {|item| item.status == status }
-          else
-            @items
-          end
-        end
-      end
-
-      item1 = double("item1", name: "foo", status: "active")
-      item2 = double("item2", name: "bar", status: "inactive")
-
-      template = "<ul>{{*items status=active}}<li>{{name}}</li>{{/items}}</ul>"
-      expect(render(template, locals: { items: [item1, item2] })).
-        to eql "<ul><li>foo</li></ul>"
-    end
-
-    it "fails if the component doesn't support enumeration" do
-      template = "<ul>{{*numbers}}<li>{{name}}</li>{{/numbers}}</ul>"
-      expect { render(template) }.to raise_exception(Curly::Error)
-    end
-
-    it "works even if the component method doesn't return an Array" do
-      define_presenter do
-        def companies
-          "Arla"
-        end
-      end
-
-      define_presenter "CompanyPresenter" do
-        presents :company
-
-        def name
-          @company
-        end
-      end
-
-      template = "<ul>{{*companies}}<li>{{name}}</li>{{/companies}}</ul>"
-      expect(render(template)).to eql "<ul><li>Arla</li></ul>"
-    end
-
-    it "passes the index of the current item to the nested presenter" do
-      define_presenter do
-        presents :items
-        attr_reader :items
-      end
-
-      define_presenter "ItemPresenter" do
-        presents :item_counter
-
-        def index
-          @item_counter
-        end
-      end
-
-      item1 = double("item1")
-      item2 = double("item2")
-
-      template = "<ul>{{*items}}<li>{{index}}</li>{{/items}}</ul>"
-      expect(render(template, locals: { items: [item1, item2] })).
-        to eql "<ul><li>1</li><li>2</li></ul>"
-    end
-
-    it "restores the previous scope after exiting the collection block" do
-      define_presenter do
-        presents :items
-        attr_reader :items
-
-        def title
-          "Inventory"
-        end
-      end
-
-      define_presenter "ItemPresenter" do
-        presents :item
-        delegate :name, :parts, to: :@item
-      end
-
-      define_presenter "PartPresenter" do
-        presents :part
-        delegate :identifier, to: :@part
-      end
-
-      part = double("part", identifier: "X")
-      item = double("item", name: "foo", parts: [part])
-
-      template = "{{*items}}{{*parts}}{{identifier}}{{/parts}}{{name}}{{/items}}{{title}}"
-      expect(render(template, locals: { items: [item] })).
-        to eql "XfooInventory"
-    end
-
-    it "passes the parent presenter's options to the nested presenter" do
-      define_presenter do
-        presents :items, :prefix
-        attr_reader :items
-      end
-
-      define_presenter "ItemPresenter" do
-        presents :item, :prefix
-        delegate :name, to: :@item
-        attr_reader :prefix
-      end
-
-      item1 = double(name: "foo")
-      item2 = double(name: "bar")
-
-      template = "{{*items}}{{prefix}}: {{name}}; {{/items}}"
-      expect(render(template, locals: { prefix: "SKU", items: [item1, item2] })).
-        to eql "SKU: foo; SKU: bar; "
-    end
-
-    it "compiles nested collection blocks" do
-      define_presenter do
-        presents :items
-        attr_reader :items
-      end
-
-      define_presenter "ItemPresenter" do
-        presents :item
-        delegate :name, :parts, to: :@item
-      end
-
-      define_presenter "PartPresenter" do
-        presents :part
-        delegate :identifier, to: :@part
-      end
-
-      item1 = double("item1", name: "item1", parts: [double(identifier: "A"), double(identifier: "B")])
-      item2 = double("item2", name: "item2", parts: [double(identifier: "C"), double(identifier: "D")])
-
-      template = "{{*items}}{{name}}: {{*parts}}{{identifier}}{{/parts}}; {{/items}}"
-      expect(render(template, locals: { items: [item1, item2] })).
-        to eql "item1: AB; item2: CD; "
-    end
-  end
-
-  context "re-using assign names" do
-    before do
-      define_presenter do
-        presents :comment
-
-        attr_reader :comment
-
-        def comments
-          ["yolo", "xoxo"]
-        end
-
-        def comment(&block)
-          block.call("foo!")
-        end
-
-        def form(&block)
-          block.call
-        end
-      end
-
-      define_presenter "CommentPresenter" do
-        presents :comment
-      end
-
-      define_presenter "FormPresenter" do
-        presents :comment
-        attr_reader :comment
-      end
-    end
-
-    it "allows re-using assign names in collection blocks" do
-      options = { "comment" => "first post!" }
-      template = "{{*comments}}{{/comments}}{{@form}}{{comment}}{{/form}}"
-      expect(render(template, locals: options)).to eql "first post!"
-    end
-
-    it "allows re-using assign names in context blocks" do
-      options = { "comment" => "first post!" }
-      template = "{{@comment}}{{/comment}}{{@form}}{{comment}}{{/form}}"
-      expect(render(template, locals: options)).to eql "first post!"
-    end
-  end
-
-  context "using namespaced names" do
-    before do
-      define_presenter "Layouts::ShowPresenter" do
-        def comments
-          ["hello", "world"]
-        end
-      end
-
-      define_presenter "Layouts::ShowPresenter::CommentPresenter" do
-        presents :comment
-
-        attr_reader :comment
-      end
-    end
-
-    it "renders correctly" do
-      template = "{{*comments}}{{comment}} {{/comments}}"
-      expect(render(template, presenter: "Layouts::ShowPresenter")).
-        to eql "hello world "
-    end
-  end
-end

data/spec/compiler/context_blocks_spec.rb

@@ -1,106 +0,0 @@
-describe Curly::Compiler do
-  include CompilationSupport
-
-  it "compiles context blocks" do
-    define_presenter do
-      def form(&block)
-        "<form>".html_safe + block.call("yo") + "</form>".html_safe
-      end
-    end
-
-    define_presenter "FormPresenter" do
-      presents :form
-
-      def text_field(&block)
-        block.call(@form)
-      end
-    end
-
-    define_presenter "TextFieldPresenter" do
-      presents :text_field
-
-      def field
-        %(<input type="text" value="#{@text_field.upcase}">).html_safe
-      end
-
-      def value?
-        true
-      end
-    end
-
-    render('{{@form}}{{@text_field}}{{field}}{{/text_field}}{{/form}}').should == '<form><input type="text" value="YO"></form>'
-  end
-
-  it "compiles using the right presenter" do
-    define_presenter "Layouts::SomePresenter" do
-
-      def contents(&block)
-        block.call("hello, world")
-      end
-    end
-
-    define_presenter "Layouts::SomePresenter::ContentsPresenter" do
-      presents :contents
-
-      def contents
-        @contents
-      end
-    end
-
-    render("foo: {{@contents}}{{contents}}{{/contents}}", presenter: "Layouts::SomePresenter").should == 'foo: hello, world'
-  end
-
-  it "fails if the component is not a context block" do
-    define_presenter do
-      def form
-      end
-    end
-
-    expect {
-      render('{{@form}}{{/form}}')
-    }.to raise_exception(Curly::Error)
-  end
-
-  it "fails if the component doesn't match a presenter class" do
-    define_presenter do
-      def dust(&block)
-      end
-    end
-
-    expect {
-      render('{{@dust}}{{/dust}}')
-    }.to raise_exception(Curly::Error)
-  end
-
-  it "fails if the component is not a context block" do
-    expect { render('{{@invalid}}yo{{/invalid}}') }.to raise_exception(Curly::Error)
-  end
-
-  it "compiles shorthand context components" do
-    define_presenter do
-      def tree(&block)
-        yield
-      end
-    end
-
-    define_presenter "TreePresenter" do
-      def branch(&block)
-        yield
-      end
-    end
-
-    define_presenter "BranchPresenter" do
-      def leaf
-        "leaf"
-      end
-    end
-
-    render('{{tree:branch:leaf}}').should == "leaf"
-  end
-
-  it "requires shorthand blocks to be closed with the same set of namespaces" do
-    expect do
-      render('{{#tree:branch}}{{/branch}}{{/tree}}')
-    end.to raise_exception(Curly::IncorrectEndingError)
-  end
-end