curly-templates 2.5.0 → 2.6.0

data/spec/compiler_spec.rb

@@ -1,192 +0,0 @@
-describe Curly::Compiler do
-  include CompilationSupport
-
-  describe ".compile" do
-    it "raises ArgumentError if the presenter class is nil" do
-      expect do
-        Curly::Compiler.compile("foo", nil)
-      end.to raise_exception(ArgumentError)
-    end
-
-    it "makes sure only public methods are called on the presenter object" do
-      expect { render("{{bar}}") }.to raise_exception(Curly::InvalidComponent)
-    end
-
-    it "includes the invalid component when failing to compile" do
-      begin
-        render("{{bar}}")
-        fail
-      rescue Curly::InvalidComponent => e
-        e.component.should == "bar"
-      end
-    end
-
-    it "propagates yields to the caller" do
-      define_presenter do
-        def i_want
-          "I want #{yield}!"
-        end
-      end
-
-      render("{{i_want}}") { "$$$" }.should == "I want $$$!"
-    end
-
-    it "sends along arguments passed to yield" do
-      define_presenter do
-        def hello(&block)
-          "Hello, #{block.call('world')}!"
-        end
-      end
-
-      render("{{hello}}") {|v| v.upcase }.should == "Hello, WORLD!"
-    end
-
-    it "escapes non HTML safe strings returned from the presenter" do
-      define_presenter do
-        def dirty
-          "<p>dirty</p>"
-        end
-      end
-
-      render("{{dirty}}").should == "&lt;p&gt;dirty&lt;/p&gt;"
-    end
-
-    it "does not escape HTML safe strings returned from the presenter" do
-      define_presenter do
-        def dirty
-          "<p>dirty</p>".html_safe
-        end
-      end
-
-      render("{{dirty}}").should == "<p>dirty</p>"
-    end
-
-    it "does not escape HTML in the template itself" do
-      render("<div>").should == "<div>"
-    end
-
-    it "treats all values returned from the presenter as strings" do
-      define_presenter do
-        def foo; 42; end
-      end
-
-      render("{{foo}}").should == "42"
-    end
-
-    it "removes comments from the output" do
-      render("hello{{! I'm a comment, yo }}world").should == "helloworld"
-    end
-
-    it "removes text in false blocks" do
-      define_presenter do
-        def false?
-          false
-        end
-      end
-
-      render("{{#false?}}wut{{/false?}}").should == ""
-    end
-
-    it "keeps text in true blocks" do
-      define_presenter do
-        def true?
-          true
-        end
-      end
-
-      render("{{#true?}}yello{{/true?}}").should == "yello"
-    end
-
-    it "removes text in inverse true blocks" do
-      define_presenter do
-        def true?
-          true
-        end
-      end
-
-      render("{{^true?}}bar{{/true?}}").should == ""
-    end
-
-    it "keeps text in inverse false blocks" do
-      define_presenter do
-        def false?
-          false
-        end
-      end
-
-      render("{{^false?}}yeah!{{/false?}}").should == "yeah!"
-    end
-
-    it "passes an argument to blocks" do
-      define_presenter do
-        def hello?(value)
-          value == "world"
-        end
-      end
-
-      render("{{#hello.world?}}foo{{/hello.world?}}").should == "foo"
-      render("{{#hello.mars?}}bar{{/hello.mars?}}").should == ""
-    end
-
-    it "passes attributes to blocks" do
-      define_presenter do
-        def square?(width:, height:)
-          width.to_i == height.to_i
-        end
-      end
-
-      render("{{#square? width=2 height=2}}yeah!{{/square?}}").should == "yeah!"
-    end
-
-    it "gives an error on incomplete blocks" do
-      expect do
-        render("{{#hello?}}")
-      end.to raise_exception(Curly::IncompleteBlockError)
-    end
-
-    it "gives an error when closing unopened blocks" do
-      expect do
-        render("{{/goodbye?}}")
-      end.to raise_exception(Curly::IncorrectEndingError)
-    end
-
-    it "gives an error on mismatching block ends" do
-      expect do
-        render("{{#x?}}{{#y?}}{{/x?}}{{/y?}}")
-      end.to raise_exception(Curly::IncorrectEndingError)
-    end
-
-    it "does not execute arbitrary Ruby code" do
-      render('#{foo}').should == '#{foo}'
-    end
-  end
-
-  describe ".valid?" do
-    it "returns true if only available methods are referenced" do
-      define_presenter do
-        def foo; end
-      end
-
-      validate("Hello, {{foo}}!").should == true
-    end
-
-    it "returns false if a missing method is referenced" do
-      define_presenter
-      validate("Hello, {{i_am_missing}}").should == false
-    end
-
-    it "returns false if an unavailable method is referenced" do
-      define_presenter do
-        def self.available_components
-          []
-        end
-      end
-
-      validate("Hello, {{inspect}}").should == false
-    end
-
-    def validate(template)
-      Curly.valid?(template, ShowPresenter)
-    end
-  end
-end

data/spec/component_compiler_spec.rb

@@ -1,107 +0,0 @@
-describe Curly::ComponentCompiler do
-  describe ".compile" do
-    let(:presenter_class) do
-      Class.new do
-        def title
-          "Welcome!"
-        end
-
-        def i18n(key, fallback: nil)
-          case key
-          when "home.welcome" then "Welcome to our lovely place!"
-          else fallback
-          end
-        end
-
-        def summary(length = "long")
-          case length
-          when "long" then "This is a long summary"
-          when "short" then "This is a short summary"
-          end
-        end
-
-        def invalid(x, y)
-        end
-
-        def widget(size:, color: nil)
-          s = "Widget (#{size})"
-          s << " - #{color}" if color
-          s
-        end
-
-        def form(&block)
-          "some form"
-        end
-
-        def self.component_available?(name)
-          true
-        end
-      end
-    end
-
-    it "compiles components with identifiers" do
-      evaluate("i18n.home.welcome").should == "Welcome to our lovely place!"
-    end
-
-    it "compiles components with optional identifiers" do
-      evaluate("summary").should == "This is a long summary"
-      evaluate("summary.short").should == "This is a short summary"
-    end
-
-    it "compiles components with attributes" do
-      evaluate("widget size=100px").should == "Widget (100px)"
-    end
-
-    it "compiles components with optional attributes" do
-      evaluate("widget color=blue size=50px").should == "Widget (50px) - blue"
-    end
-
-    it "compiles context block components" do
-      evaluate("form", type: :context).should == "some form"
-    end
-
-    it "allows both identifier and attributes" do
-      evaluate("i18n.hello fallback=yolo").should == "yolo"
-    end
-
-    it "fails when an invalid attribute is used" do
-      expect { evaluate("i18n.foo extreme=true") }.to raise_exception(Curly::Error)
-    end
-
-    it "fails when a component is missing a required identifier" do
-      expect { evaluate("i18n") }.to raise_exception(Curly::Error)
-    end
-
-    it "fails when a component is missing a required attribute" do
-      expect { evaluate("widget") }.to raise_exception(Curly::Error)
-    end
-
-    it "fails when an identifier is specified for a component that doesn't support one" do
-      expect { evaluate("title.rugby") }.to raise_exception(Curly::Error)
-    end
-
-    it "fails when the method takes more than one argument" do
-      expect { evaluate("invalid") }.to raise_exception(Curly::Error)
-    end
-
-    it "fails when a context block component is used with a method that doesn't take a block" do
-      expect { evaluate("title", type: :context) }.to raise_exception(Curly::Error)
-    end
-  end
-
-  def evaluate(text, type: nil, &block)
-    name, identifier, attributes = Curly::ComponentScanner.scan(text)
-    component = Curly::Parser::Component.new(name, identifier, attributes)
-    code = Curly::ComponentCompiler.compile(presenter_class, component, type: type)
-    presenter = presenter_class.new
-    context = double("context", presenter: presenter)
-
-    context.instance_eval(<<-RUBY)
-      def self.render
-        #{code}
-      end
-    RUBY
-
-    context.render(&block)
-  end
-end

data/spec/component_scanner_spec.rb

@@ -1,36 +0,0 @@
-describe Curly::ComponentScanner do
-  it "scans the component name, identifier, and attributes" do
-    scan('hello.world weather="sunny"').should == [
-      "hello",
-      "world",
-      { "weather" => "sunny" },
-      []
-    ]
-  end
-
-  it "allows context namespaces" do
-    scan('island:beach:hello.world').should == [
-      "hello",
-      "world",
-      {},
-      ["island", "beach"]
-    ]
-  end
-
-  it "allows a question mark after the identifier" do
-    scan('hello.world?').should == ["hello?", "world", {}, []]
-  end
-
-  it 'allows spaces before and after component' do
-    scan('  hello.world weather="sunny"   ').should == [
-      "hello",
-      "world",
-      { "weather" => "sunny" },
-      []
-    ]
-  end
-
-  def scan(component)
-    described_class.scan(component)
-  end
-end

data/spec/components_spec.rb

@@ -1,43 +0,0 @@
-describe "Components" do
-  include CompilationSupport
-
-  example "with neither identifier nor attributes" do
-    define_presenter do
-      def title
-        "A Clockwork Orange"
-      end
-    end
-
-    render("{{title}}").should == "A Clockwork Orange"
-  end
-
-  example "with an identifier" do
-    define_presenter do
-      def reverse(str)
-        str.reverse
-      end
-    end
-
-    render("{{reverse.123}}").should == "321"
-  end
-
-  example "with attributes" do
-    define_presenter do
-      def double(number:)
-        number.to_i * 2
-      end
-    end
-
-    render("{{double number=3}}").should == "6"
-  end
-
-  example "with both identifier and attributes" do
-    define_presenter do
-      def a(href:, title:)
-        content_tag :a, nil, href: href, title: title
-      end
-    end
-
-    render(%({{a href="/welcome.html" title="Welcome!"}})).should == %(<a href="/welcome.html" title="Welcome!"></a>)
-  end
-end

data/spec/conditional_blocks_spec.rb

@@ -1,40 +0,0 @@
-describe "Conditional block components" do
-  include CompilationSupport
-
-  example "with neither identifier nor attributes" do
-    define_presenter do
-      def high?
-        true
-      end
-
-      def low?
-        false
-      end
-    end
-
-    render("{{#high?}}yup{{/high?}}").should == "yup"
-    render("{{#low?}}nah{{/low?}}").should == ""
-  end
-
-  example "with an identifier" do
-    define_presenter do
-      def even?(number)
-        number.to_i % 2 == 0
-      end
-    end
-
-    render("{{#even.42?}}even{{/even.42?}}").should == "even"
-    render("{{#even.13?}}even{{/even.13?}}").should == ""
-  end
-
-  example "with attributes" do
-    define_presenter do
-      def square?(width:, height:)
-        width.to_i == height.to_i
-      end
-    end
-
-    render("{{#square? width=2 height=2}}square{{/square?}}").should == "square"
-    render("{{#square? width=3 height=2}}square{{/square?}}").should == ""
-  end
-end

data/spec/dummy/.gitignore

@@ -1 +0,0 @@
-log

data/spec/dummy/app/controllers/application_controller.rb

@@ -1,2 +0,0 @@
-class ApplicationController < ActionController::Base
-end

data/spec/dummy/app/controllers/dashboards_controller.rb

@@ -1,14 +0,0 @@
-class DashboardsController < ApplicationController
-  def show
-    @message = "Hello, World!"
-  end
-
-  def collection
-    @name = "numbers"
-    @items = ["uno", "dos", "tres!"]
-  end
-
-  def new
-    @name = "test"
-  end
-end