rango 0.1.1.3 → 0.2.pre

data/lib/rango/templates/helpers.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require "rango"
+require "rango/templates/template"
 
 module Rango
   module TemplateHelpers
@@ -54,52 +55,79 @@ module Rango
     # post/base.html
     # base.html: here it will be rendered, so we need block to returns the correct block code
     # @since 0.0.2
+    # @version 0.2
     def block(name, value = nil, &block)
-      value = self._template.scope.capture(&block) if value.nil? && block
-      self._template.blocks[name] ||= value
+      raise ArgumentError, "Block has to have a name!" if name.nil?
+      raise ArgumentError, "You have to provide value or block, not both of them!" if value && block
+      self._template.blocks[name] ||= block ? self._template.scope.capture(&block) : value
       return self._template.blocks[name]
     end
 
     # - extend_block(:head) do
-    #   != pupu :lighter, syntax: "html", theme: "standard"
-    #   != block(:head)
-    #
-    # TODO: something more intuitive like:
-    # - block(:head) do
-    #   != pupu :lighter, syntax: "html", theme: "standard"
-    #   != block(:head)
-    #
-    # OR even:
-    # - block(:head) do
-    #   != pupu :lighter, syntax: "html", theme: "standard"
-    #   = superblock
+    #   = pupu :lighter, syntax: "html", theme: "standard"
+    #   = block(:head)
     def extend_block(name, value = nil, &block)
+      unless self._template.blocks[name]
+        raise NameError, "Block #{name.inspect} wasn't defined yet, you can't extend it!"
+      end
+      self.enhance_block(name, value, &block)
+    end
+
+    def enhance_block(name, value = nil, &block)
+      raise ArgumentError, "Block has to have a name!" if name.nil?
+      raise ArgumentError, "You have to provide value or block, not both of them!" if value && block
       value = self._template.scope.capture(&block) if value.nil? && block
-      self._template.blocks[name] += value
+      self._template.blocks[name] = "#{self._template.blocks[name]}\n#{value}" if value
       return self._template.blocks[name]
     end
 
+    # Low-level rendering method for templates.
+    #
+    # @since 0.2
+    # @example
+    #   render "base.html"
+    #   render "./base.html"
+    #   render "../base.html"
+    def render(template, context = Hash.new)
+      normalize_template_path(template)
+      original_template = self._template
+      template = Rango::Template.new(template, self) # self is scope
+      self._template = original_template
+      return template.render(context)
+    end
+
     # partial "products/list"
     # @since 0.0.2
+    # @version 0.2
     def partial(template, context = Hash.new)
-      if template.match(%r[/])
-        path, last = File.split(template)[0..-1]
-        template = File.join(path, "_#{last}")
-      else
-        template = "_#{template}"
-      end
-      template = Rango::Template.new(template, self._template.scope, context)
-      template.partial = true
-      # TODO: #block in partial templates
-      output = template.render
-      return output
+      # NOTE: we can't use File.split because it normalize the path,
+      # so "./base.html" will be the same as "base.html", but it shouldn't be
+      *path, basename = template.split("/")
+      render File.join(*path, "_#{basename}")
+    end
+
+    # @since 0.2
+    def includes(template, context = Hash.new)
+      render template, context
+      return true
     end
 
     # extends "base.html"
     # @since 0.0.2
     def extends(path)
       # we can't just create a new template, because it has to do it after it reads the whole file
-      self._template.supertemplate = path
+      self._template.supertemplate = normalize_template_path(path)
+    end
+
+    # @since 0.2
+    def normalize_template_path(template)
+      if template.start_with?("./")
+        File.expand_path(File.join(File.dirname(self._template.fullpath), template))
+      elsif template.start_with?("../")
+        File.expand_path(File.join(File.dirname(self._template.fullpath), "..", template))
+      else
+        template
+      end
     end
   end
 end

data/lib/rango/templates/template.rb

@@ -1,9 +1,7 @@
 # encoding: utf-8
 
 require "rango/templates/exts/tilt"
-require "rubyexts/attribute"
-require "rubyexts/string" # String#snake_case
-require "rubyexts/class" # cattr_accessor
+require "rango/core_ext" # String#snake_case
 require "rango/templates/helpers"
 require "rango/exceptions"
 
@@ -13,19 +11,23 @@ module Rango
   end
 
   class Template
-    cattr_accessor :template_paths
-    self.template_paths = [File.join(Rango.root, "templates")]
+    def self.template_paths
+      @@template_paths ||= [File.join(Rango.root, "templates")]
+    end
 
     # template -> supertemplate is the same relationship as class -> superclass
     # @since 0.0.2
     attr_accessor :path, :scope, :supertemplate
 
     # @since 0.0.2
-    attribute :blocks, Hash.new
+    attr_writer :blocks
+    def blocks
+      @blocks ||= Hash.new
+    end
 
     # @since 0.0.2
     def initialize(path, scope = Object.new)
-      self.path    = path#[scope.class.template_prefix.chomp("/"), template].join("/")
+      self.path  = path#[scope.class.template_prefix.chomp("/"), template].join("/")
       self.scope = scope.extend(TemplateHelpers)
       self.scope._template = self
     end
@@ -55,10 +57,10 @@ module Rango
 
     # @since 0.0.2
     def render(context = Hash.new)
-      raise Errors::TemplateNotFound.new("Template #{self.path} wasn't found in these template_paths: #{self.template_paths.inspect}") if self.fullpath.nil?
+      raise Errors::TemplateNotFound.new("Template #{self.path} wasn't found in these template_paths: #{self.class.template_paths.inspect}") if self.fullpath.nil?
       value = self.template.render(self.scope, context)
       Rango.logger.info("Rendering template #{self.path}")
-      # Rango.logger.inspect(self.blocks)
+      # #Rango.logger.inspect(self.blocks)
       if self.supertemplate
         Rango.logger.debug("Extends call: #{self.supertemplate}")
         supertemplate = self.class.new(self.supertemplate, self.scope)

data/spec/rango/controller_spec.rb

@@ -2,7 +2,6 @@
 
 require_relative "../spec_helper"
 
-require "rango/logger"
 require "rango/controller"
 require "rack/mock"
 

data/spec/rango/environments_spec.rb

@@ -14,10 +14,10 @@ describe "Rango environments" do
       Rango.should be_development
     end
 
-    it "should be true if Rango.environment is included in Rango.development_environments" do
+    it "should be true if Rango.environment is included in Rango.environments[:development]" do
       Rango.environment = "foobar"
       Rango.should_not be_development
-      Rango.development_environments.push("foobar")
+      Rango.environments[:development].push("foobar")
       Rango.should be_development
     end
   end
@@ -30,10 +30,10 @@ describe "Rango environments" do
       end
     end
 
-    it "should be true if Rango.environment is included in Rango.production_environments" do
+    it "should be true if Rango.environment is included in Rango.environments[:production]" do
       Rango.environment = "foobar"
       Rango.should_not be_production
-      Rango.production_environments.push("foobar")
+      Rango.environments[:production].push("foobar")
       Rango.should be_production
     end
   end
@@ -46,10 +46,10 @@ describe "Rango environments" do
       end
     end
 
-    it "should be true if Rango.environment is included in Rango.testing_environments" do
+    it "should be true if Rango.environment is included in Rango.environments[:testing]" do
       Rango.environment = "foobar"
       Rango.should_not be_testing
-      Rango.testing_environments.push("foobar")
+      Rango.environments[:testing].push("foobar")
       Rango.should be_testing
     end
   end

data/spec/rango/mixins/action_args_spec.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require_relative "../../spec_helper"
+
+require "rango"
+require "logger"
+Rango.logger = Logger.new("/dev/null")
+
+require "rango/controller"
+require "rango/mixins/action_args"
+
+Rango::Router.use(:urlmap)
+
+describe Rango::ActionArgsMixin do
+  controller = Class.new(Rango::Controller) do
+    include Rango::ActionArgsMixin
+
+    def show(id)
+      id
+    end
+
+    def create(post, msg = "Created successfuly")
+      "#{post} - #{msg}"
+    end
+
+    def view_with_a_splat(*args)
+    end
+
+    def view_with_a_block(&block)
+    end
+  end
+
+  def env_for_action(action, url = "/")
+    env = Rack::MockRequest.env_for(url)
+    env.merge("rango.controller.action" => action)
+  end
+
+  it "should raise argument error if there is a splat argument" do
+    env = env_for_action(:view_with_a_splat)
+    -> { controller.call(env) }.should raise_error(ArgumentError)
+  end
+
+  it "should raise argument error if there is a block argument" do
+    env = env_for_action(:view_with_a_block)
+    -> { controller.call(env) }.should raise_error(ArgumentError)
+  end
+
+  it "should raise argument error if there are arguments which doesn't match any key in params" do
+    env = env_for_action(:show)
+    -> { controller.call(env) }.should raise_error(ArgumentError)
+  end
+
+  it "should call a view with arguments matching params[argument]" do
+    env = env_for_action(:show, "/?id=12")
+    status, headers, body = controller.call(env)
+    body.should eql(["12"])
+  end
+
+  it "should call a view with arguments matching params[argument]" do
+    env = env_for_action(:show, "/?id=12&msg=hi") # nevadi ze je tam toho vic
+    instance = controller.new(env)
+    status, headers, body = controller.call(env)
+    body.should eql(["12"])
+  end
+
+# NOTE: we can't use stubs because the stub redefine the method, so parameters of this method will be everytime just optional args and block
+  it "should call a view with arguments matching params[argument]" do
+    env = env_for_action(:create, "/?post=neco&msg=message")
+    status, headers, body = controller.call(env)
+    body.should eql(["neco - message"])
+  end
+
+  it "should not require optinal arguments to be in params" do
+    env = env_for_action(:create, "/?post=neco")
+    status, headers, body = controller.call(env)
+    body.should eql(["neco - Created successfuly"])
+  end
+end

data/spec/rango/mixins/message_spec.rb

@@ -7,6 +7,10 @@ require "rango/controller"
 require "rango/mixins/message"
 require "rango/mixins/rendering"
 
+# HACK because of rSpec, the trouble was:
+# TestController.method_defined?(:context) => true
+Rango::Controller.send(:undef_method, :context)
+
 class TestController < Rango::Controller
   include Rango::MessageMixin
 end
@@ -19,7 +23,6 @@ describe Rango::MessageMixin do
 
   describe ".included" do
     it "should not do anything if method context isn't defined" do
-      pending "How to implement it?"
       @controller.should_not respond_to(:context)
     end
 

data/spec/rango/mixins/render_spec.rb

@@ -4,7 +4,7 @@ require_relative "../../spec_helper"
 
 require "rango/mixins/render"
 
-Rango::Template.template_paths = [File.join(STUBS_ROOT, "templates")]
+Rango::Template.template_paths.clear.push(File.join(STUBS_ROOT, "templates"))
 
 describe Rango::RenderMixin do
   it "should work standalone" do

data/spec/rango/templates/helpers_spec.rb

@@ -0,0 +1,125 @@
+# encoding: utf-8
+
+require_relative "../../spec_helper"
+require "rango/templates/helpers"
+
+Rango::Template.template_paths.clear.push(File.join(STUBS_ROOT, "templates"))
+
+describe Rango::TemplateHelpers do
+  include Rango::TemplateHelpers
+  describe "#partial" do
+    it "should work" do
+      partial "basic.html"
+    end
+
+    it "should share context with the parent template"
+    it "should be able to specify additional context which isn't propagated to the parent template"
+  end
+
+  describe "#render" do
+    it "should consider 'path.html' as a path relative to Template.template_paths"
+    it "should consider './path.html' as a path relative to the current template"
+    it "should look for '../path.html' in the parent directory of directory with current template"
+  end
+
+  describe "#includes" do
+    require "rango/mixins/render"
+    it "should return true" do
+      Rango::RenderMixin.render("includes/basic.html").strip.should eql("true")
+    end
+
+    it "should work with blocks" do
+      Rango::RenderMixin.render("includes/includes.html")
+    end
+
+    it "should work with extends" do
+      output = Rango::RenderMixin.render("includes/integration.html")
+      output.strip.should eql("Greeting by Jakub Stastny")
+    end
+
+    it "should work with extends" do
+      output = Rango::RenderMixin.render("includes/integration2.html")
+      output.strip.should eql("Greeting by Jakub Stastny")
+    end
+  end
+
+  describe "extends" do
+  end
+
+  describe "block" do
+    it "should raise argument error if name isn't specified" do
+      -> { block(nil) }.should raise_error(ArgumentError)
+    end
+
+    it "should work as a setter if a value is provided" do
+      output = Rango::RenderMixin.render("block/value.html")
+      output.strip.should eql("a value")
+    end
+
+    it "should work as a setter if a block is provided" do
+      output = Rango::RenderMixin.render("block/block.html")
+      output.strip.should eql("a block")
+    end
+
+    it "should work as a getter" do
+      output = Rango::RenderMixin.render("block/getter.html")
+      output.strip.should eql("Hello World!")
+    end
+
+    it "should raise argument error if both value and block is provided" do
+      -> { Rango::RenderMixin.render("block/error.html") }.should raise_error(ArgumentError)
+    end
+
+    it "should store the first non-nil value" do
+      output = Rango::RenderMixin.render("block/blocks.html")
+      output.strip.should eql("first")
+    end
+  end
+
+  describe "extend_block" do
+    it "should raise argument error if name isn't specified" do
+      -> { Rango::RenderMixin.render("extend_block/name_error.html") }.should raise_error(NameError)
+    end
+
+    it "should raise argument error if both value and block is provided" do
+      -> { Rango::RenderMixin.render("extend_block/error.html") }.should raise_error(ArgumentError)
+    end
+
+    it "should raise argument error if block of given name doesn't exist so far" do
+      -> { Rango::RenderMixin.render("extend_block/error2.html") }.should raise_error
+    end
+
+    it "should work with super()-like inheritance" do
+      Rango::RenderMixin.render("extend_block/basic.html")
+    end
+
+    it "should do nothing if the value or block is nil" do
+      output = Rango::RenderMixin.render("extend_block/nil.html")
+      output.strip.should eql("Original")
+    end
+  end
+
+  describe "enhance_block" do
+    it "should work even if the block isn't defined so far" do
+      output = Rango::RenderMixin.render("enhance_block/standalone.html")
+      output.strip.should eql("Hello World!")
+    end
+
+    it "should not raise argument error if name isn't specified" do
+      -> { Rango::RenderMixin.render("enhance_block/name_error.html") }.should_not raise_error(NameError)
+    end
+
+    it "should raise argument error if both value and block is provided" do
+      -> { Rango::RenderMixin.render("enhance_block/error.html") }.should raise_error(ArgumentError)
+    end
+
+    it "should work with super()-like inheritance" do
+      Rango::RenderMixin.render("enhance_block/basic.html")
+    end
+
+    it "should do nothing if the value or block is nil" do
+      output = Rango::RenderMixin.render("enhance_block/nil.html")
+      output.strip.should eql("Original")
+    end
+  end
+end