rango 0.1.0 → 0.1.1

data/lib/rango/templates/{erubis.rb → exts/erubis.rb}

@@ -61,24 +61,5 @@ module Erubis
       rest = pos == 0 ? input : input[pos..-1]   # ruby1.9
       add_text(src, rest)
     end
-
-  end
-
-  class MEruby < Erubis::Eruby
-    include PercentLineEnhancer
-    include StringBufferEnhancer
-  end
-
-  # Loads a file, runs it through Erubis and parses it as YAML.
-  #
-  # ===== Parameters
-  # file<String>:: The name of the file to load.
-  # binding<Binding>::
-  #   The binding to use when evaluating the ERB tags. Defaults to the current
-  #   binding.
-  #
-  # :api: private
-  def self.load_yaml_file(file, binding = binding)
-    YAML::load(Erubis::MEruby.new(IO.read(File.expand_path(file))).result(binding))
   end
 end

data/lib/rango/templates/exts/tilt.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require "tilt"
+require "rubyexts/mixins/chainable"
+
+module Tilt
+  ErubisTemplate.class_eval do
+    extend RubyExts::Chainable
+    chainable do
+      def initialize_engine
+        super
+        require "rango/templates/erubis"
+      end
+    end
+  end
+end

data/lib/rango/templates/helpers.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+require "rango"
+
+module Rango
+  module Templates
+    module TemplateHelpers
+      def self.extended(context)
+        class << context
+          attr_accessor :_template
+          # @example Capture being used in a .html.erb page:
+          #   <% @foo = capture do %>
+          #     <p>Some Foo content!</p>
+          #   <% end %>
+          #
+          # @params [*args]  Arguments to pass to the block.
+          # @params [&block] The template block to call.
+          # @return [String] The output of the block.
+          # @api private
+          def capture(*args, &block)
+            capture_method = "capture_#{self._template.adapter}"
+            if self.respond_to?(capture_method) # tilt doesn't support @_out_buf for haml
+              self.send("capture_#{self._template.adapter}", *args, &block)
+            else
+              # @_out_buf comes from tilt
+              unless self.instance_variable_defined?("@_out_buf")
+                raise "Adapter #{self._template.adapter} doesn't support capturing"
+              end
+              _old_buf, @_out_buf = @_out_buf, ""
+              block.call(*args)
+              @_out_buf = _old_buf.chomp.strip
+            end
+          end
+
+          def concat(string)
+            concat_method = "concat_#{self._template.adapter}"
+            if self.respond_to?(concat_method) # tilt doesn't support @_out_buf for haml
+              self.send("concat_#{self._template.adapter}", string)
+            else
+              # @_out_buf comes from tilt
+              unless self.instance_variable_defined?("@_out_buf")
+                raise "Adapter #{self._template.adapter} doesn't support concating"
+              end
+              @_out_buf << string
+            end
+          end
+        end
+      end
+
+      def self.included(context_class)
+        context_class.class_eval { attr_accessor :_template}
+      end
+
+      # post/show.html: it's block is the block we like to see in output
+      # post/base.html
+      # base.html: here it will be rendered, so we need block to returns the correct block code
+      # @since 0.0.2
+      def block(name, value = nil, &block)
+        value = self._template.context.capture(&block) if value.nil? && block
+        self._template.blocks[name] ||= 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
+      def extend_block(name, value = nil, &block)
+        value = self._template.context.capture(&block) if value.nil? && block
+        self._template.blocks[name] += value
+        return self._template.blocks[name]
+      end
+
+      # partial "products/list"
+      # @since 0.0.2
+      def partial(template, locals = Hash.new)
+        if template.match(%r[/])
+          path, last = File.split(template)[0..-1]
+          template = File.join(path, "_#{last}")
+        else
+          template = "_#{template}"
+        end
+        template = Rango::Templates::Template.new(template, self._template.context, locals)
+        template.partial = true
+        # TODO: #block in partial templates
+        output = template.render
+        return output
+      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
+      end
+    end
+  end
+end

data/lib/rango/templates/template.rb

@@ -1,151 +1,80 @@
 # encoding: utf-8
 
-# TODO: questionable :partial, true
-# => define #partial?
-
+require "rango/templates/exts/tilt"
 require "rubyexts/attribute"
+require "rubyexts/string" # String#snake_case
+require "rango/templates/helpers"
+require "rango/exceptions"
 
 module Rango
+  module Errors # so we can catch it with other HTTP errors
+    TemplateNotFound = Class.new(NotFound)
+  end
+
   module Templates
     class Template
       # template -> supertemplate is the same relationship as class -> superclass
       # @since 0.0.2
-      attr_accessor :template, :context, :locals, :supertemplate
+      attr_accessor :path, :context, :supertemplate
 
       # @since 0.0.2
       attribute :blocks, Hash.new
 
       # @since 0.0.2
-      attribute :partial, false
-
-      # @since 0.0.2
-      def initialize(template, context, locals = Hash.new)
-        self.template = template#[context.class.template_prefix.chomp("/"), template].join("/")
-        self.context  = context
-        self.locals   = locals
+      def initialize(path, context = Object.new)
+        self.path    = path#[context.class.template_prefix.chomp("/"), template].join("/")
+        self.context = context.extend(TemplateHelpers)
+        self.context._template = self
       end
 
       # @since 0.0.2
-      def render
-        @body ||= begin
-          self.context = extend_context(self.context) unless self.partial
-          path = self.find(self.template)
-          raise TemplateNotFound.new("Template #{template} wasn't found in these template_dirs: #{Project.settings.template_dirs.inspect}") if path.nil?
-          file = File.new(path)
-          value = self.engine.render(file, context, self.locals)
-          STDOUT.puts
-          Rango.logger.info("Rendering template #{self.template}")
-          # Rango.logger.inspect(self.blocks)
-          if self.supertemplate
-            Rango.logger.debug("Extends call: #{self.supertemplate}")
-            supertemplate = self.class.new(self.supertemplate, self.context, self.locals)
-            supertemplate.blocks = self.blocks
-            return supertemplate.render
+      def fullpath
+        @fullpath ||= begin
+          if self.path.match(/^\//)
+            Dir[self.path, "#{self.path}.*"].first
+          else
+            self.find_in_template_dirs
           end
-          value
         end
       end
 
-      # @since 0.0.2
-      def extend_context(context)
-        class << context
-          include TemplateHelpers
-          attr_accessor :_template
-        end
-        context._template = self
-        return context
-      end
-
-      # @since 0.0.2
-      def engine
-        # TODO: test if Project.settings.template_engine nil => useful message
-        # TODO: maybe more template engines?
-        engine_name = Project.settings.template_engine
-        require "rango/templates/adapters/#{engine_name}.rb"
-        engine_class = Rango::Templates.engine(engine_name)
-        engine_class.new
-      rescue LoadError
-        Rango.logger.fatal("Template engine #{engine_name} can't be loaded.")
-        raise Error406.new(self.params)
-      end
-
-      def mtime
-        @mtime ||= File.mtime(self.template)
+      def adapter
+        self.template.class.name.split("::").last.snake_case.sub("_template", "")
       end
 
-      # @since 0.0.2
-      def find(template)
-        if template.match(/^\//)
-          if File.exist?(template)
-            return template
-          elsif template = Dir["#{template}.*"].first
-            return template
-          end
-        else
-          Project.settings.template_dirs.each do |directory|
-            path = File.join(directory, template)
-            if File.exist?(path)
-              return path
-            elsif first = Dir["#{path}.*"].first
-              return first
-            end
-          end
-          return nil
-        end
+      def extension # haml, erb ...
+        File.extname(path)[1..-1]
       end
-    end
 
-    module TemplateHelpers
-      # post/show.html: it's block is the block we like to see in output
-      # post/base.html
-      # base.html: here it will be rendered, so we need block to returns the correct block code
-      # @since 0.0.2
-      def block(name, value = nil, &block)
-        value = self._template.context.capture(&block) if value.nil? && block
-        self._template.blocks[name] ||= value
-        return self._template.blocks[name]
+      def options
+        @options ||= Project.settings.send(self.extension) rescue Hash.new
       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
-      def extend_block(name, value = nil, &block)
-        value = self._template.context.capture(&block) if value.nil? && block
-        self._template.blocks[name] += value
-        return self._template.blocks[name]
+      def template
+        @template ||= Tilt.new(self.fullpath, nil, self.options)
       end
 
-      # partial "products/list"
       # @since 0.0.2
-      def partial(template, locals = Hash.new)
-        if template.match(%r[/])
-          path, last = File.split(template)[0..-1]
-          template = File.join(path, "_#{last}")
-        else
-          template = "_#{template}"
+      def render(locals = Hash.new)
+        raise Errors::TemplateNotFound.new("Template #{self.path} wasn't found in these template_dirs: #{Project.settings.template_dirs.inspect}") if self.fullpath.nil?
+        value = self.template.render(self.context, locals)
+        Rango.logger.info("Rendering template #{self.path}")
+        Rango.logger.inspect(self.blocks)
+        if self.supertemplate
+          Rango.logger.debug("Extends call: #{self.supertemplate}")
+          supertemplate = self.class.new(self.supertemplate, self.context)
+          supertemplate.blocks = self.blocks
+          return supertemplate.render(locals)
         end
-        template = Rango::Templates::Template.new(template, self._template.context, locals)
-        template.partial = true
-        # TODO: #block in partial templates
-        output = template.render
-        # Rango.logger.debug("Partial: #{output[0..20]} ...")
-        return output
+        value
       end
 
-      # extends "base.html"
-      # @since 0.0.2
-      def extends(template)
-        self._template.supertemplate = template
+      protected
+      def find_in_template_dirs
+        Project.settings.template_dirs.each do |directory|
+          path = File.join(directory, self.path)
+          return Dir[path, "#{path}.*"].first
+        end
       end
     end
   end

data/lib/rango/utils.rb

@@ -1,13 +1,18 @@
 # encoding: utf-8
 
+require "rack"
+
+# class App
+#   extend Rango::Utils
+#   def load_rackup
+#     super(File.join(File.join(self.root, "config.ru")), "config.ru")
+#   end
+# end
 module Rango
   module Utils
     extend self
     def load_rackup(path = "config.ru")
-      fullpath = File.join(Project.root, "config.ru")
-      Rango.logger.debug("Parsing #{fullpath}")
-      rackup = File.read(fullpath)
-      eval("Rack::Builder.new {( #{rackup}\n )}.to_app", nil, fullpath)
+      eval("Rack::Builder.new {( #{File.read(path)}\n )}.to_app", nil, File.expand_path(path))
     end
   end
 end

data/spec/rango/controller_spec.rb

@@ -3,10 +3,12 @@
 require_relative "../spec_helper"
 
 require "rango/controller"
+require "rack/mock"
 
 describe Rango::Controller do
   before(:each) do
-    @controller = Factory.controller
+    env = Rack::MockRequest.env_for("/")
+    @controller = Rango::Controller.new(env)
   end
 
   it "should respond to request" do

data/spec/rango/environments_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require_relative "../spec_helper"
+require "rango/environments"
+
+describe "Rango environments" do
+  it "should defaults to development" do
+    Rango.environment.should eql("development")
+  end
+
+  describe ".development?" do
+    it "should be true if Rango.environment is 'development'" do
+      Rango.environment = "development"
+      Rango.should be_development
+    end
+
+    it "should be true if Rango.environment is included in Rango.development_environments" do
+      Rango.environment = "foobar"
+      Rango.should_not be_development
+      Rango.development_environments.push("foobar")
+      Rango.should be_development
+    end
+  end
+
+  describe ".production?" do
+    %w{production stage}.each do |environment|
+      it "should be true if Rango.environment is '#{environment}'" do
+        Rango.environment = environment
+        Rango.should be_production
+      end
+    end
+
+    it "should be true if Rango.environment is included in Rango.production_environments" do
+      Rango.environment = "foobar"
+      Rango.should_not be_production
+      Rango.production_environments.push("foobar")
+      Rango.should be_production
+    end
+  end
+
+  describe ".testing?" do
+    %w{test spec cucumber}.each do |environment|
+      it "should be true if Rango.environment is '#{environment}'" do
+        Rango.environment = environment
+        Rango.should be_testing
+      end
+    end
+
+    it "should be true if Rango.environment is included in Rango.testing_environments" do
+      Rango.environment = "foobar"
+      Rango.should_not be_testing
+      Rango.testing_environments.push("foobar")
+      Rango.should be_testing
+    end
+  end
+
+  describe ".environment?" do
+    it "should returns true if current environment is the same as the only argument" do
+      Rango.environment = "development"
+      Rango.environment?("development").should be_true
+    end
+
+    it "should returns false if current environment is different than the only argument" do
+      Rango.environment = "production"
+      Rango.environment?("development").should be_false
+    end
+  end
+end