rango 0.0.3

data/lib/rango/tasks/bundle.thor

@@ -0,0 +1,28 @@
+# coding: utf-8
+
+require "rango/ext/thor"
+
+class Bundle < Rango::Tasks
+  def initialize(*args)
+    self.boot
+    super(*args)
+  end
+
+  # @since 0.0.1
+  desc "install", "install all the runtime dependencies"
+  def install
+    Rango.dependencies.each(&:install)
+  end
+
+  # @since 0.0.1
+  desc "list", "list all the runtime dependencies"
+  def list
+    Rango.dependencies.each do |dependency|
+      if dependency.options.empty?
+        puts "- #{dependency.name}"
+      else
+        puts "- #{dependency.name} #{dependency.options}"
+      end
+    end
+  end
+end

data/lib/rango/templates/adapter.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+class Rango
+  module Templates
+    class << self
+      # @since 0.0.2
+      def engine(name)
+        Rango::Templates.const_get(name.capitalize)
+      end
+    end
+
+    class Adapter
+      # @since 0.0.2
+      def proceed(io)
+        raise "This must be redefined in subclasses!"
+      end
+    end
+  end
+end

data/lib/rango/templates/adapters/erb.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+require "erb"
+Rango.import("templates/adapter")
+
+class Rango
+  module Templates
+    class Erb < ::Rango::Templates::Adapter
+      # @since 0.0.2
+      def render(io, context)
+        ::ERB.new(io.read).result(context.binding)
+      end
+    end
+  end
+
+  class Controller
+    # ==== Parameters
+    # *args:: Arguments to pass to the block.
+    # &block:: The template block to call.
+    #
+    # ==== Returns
+    # String:: The output of the block.
+    #
+    # ==== Examples
+    # Capture being used in a .html.erb page:
+    #
+    #   <% @foo = capture do %>
+    #     <p>Some Foo content!</p>
+    #   <% end %>
+    #
+    # :api: private
+    def capture_erb(*args, &block)
+      _old_buf, @_erb_buf = @_erb_buf, ""
+      block.call(*args)
+      ret = @_erb_buf
+      @_erb_buf = _old_buf
+      ret
+    end
+
+    # :api: private
+    def concat_erb(string, binding)
+      @_erb_buf << string
+    end
+  end
+end

data/lib/rango/templates/adapters/erubis.rb

@@ -0,0 +1,60 @@
+# coding: utf-8
+
+require "erubis"
+Rango.import("templates/adapter")
+
+class Rango
+  module Templates
+    class Erubis < ::Rango::Templates::Adapter
+      # TODO: context {foo: "bar"} => @foo instead of just foo
+      # http://www.kuwata-lab.com/erubis/users-guide.02.html#tut-context
+
+      # TODO: result vs. evaluate
+      # http://www.kuwata-lab.com/erubis/users-guide.02.html#tut-context
+      # http://www.kuwata-lab.com/erubis/users-guide.06.html#topics-context-vs-binding
+
+      # TODO: maybe preprocessing
+      # http://www.kuwata-lab.com/erubis/users-guide.05.html#rails-preprocessing
+      # http://www.kuwata-lab.com/erubis/users-guide.06.html#topics-caching
+
+      # @since 0.0.2
+      # @see http://www.kuwata-lab.com/erubis/users-guide.02.html#tut-escape
+      def render(io, context)
+        if Project.settings.erubis.custom_class
+          klass = Project.settings.erubis.custom_class
+        elsif Project.settings.autoescape
+          klass = ::Erubis::EscapedEruby
+        else
+          klass = ::Erubis::Eruby
+        end
+        pattern = Project.settings.erubis_pattern
+        klass.new(io.read).result(context, binding, pattern: pattern)
+      end
+    end
+  end
+
+  class Controller
+    # ==== Parameters
+    # *args:: Arguments to pass to the block.
+    # &block:: The template block to call.
+    #
+    # ==== Returns
+    # String:: The output of the block.
+    #
+    # ==== Examples
+    # Capture being used in a .html.erb page:
+    #
+    #   <% @foo = capture do %>
+    #     <p>Some Foo content!</p>
+    #   <% end %>
+    #
+    # :api: private
+    def capture_erubis(*args, &block)
+      _old_buf, @_erb_buf = @_erb_buf, ""
+      block.call(*args)
+      ret = @_erb_buf
+      @_erb_buf = _old_buf
+      ret
+    end
+  end
+end

data/lib/rango/templates/adapters/haml.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+require "haml"
+Rango.import("templates/adapter")
+
+class Rango
+  module Templates
+    class Haml < ::Rango::Templates::Adapter
+      # @since 0.0.2
+      def render(io, scope, locals = Hash.new)
+        options = Project.settings.haml.to_hash ### FIXME
+        options[:filename] = io.path
+        ::Haml::Engine.new(io.read, options).render(scope, locals)
+      end
+    end
+  end
+end

data/lib/rango/templates/template.rb

@@ -0,0 +1,123 @@
+# TODO: qattribute :partial, true
+# => define #partial?
+
+class Rango
+  module Templates
+    class Template
+      # template -> supertemplate is the same relationship as class -> superclass
+      # @since 0.0.2
+      attr_accessor :template, :context, :locals, :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
+      end
+
+      # @since 0.0.2
+      def render
+        self.context = extend_context(self.context) unless self.partial
+        path = self.find(self.template)
+        raise TemplateNotFound.new(template, Project.settings.template_dirs) 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
+        end
+        return value
+      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
+        Rango.import("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
+
+      # @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
+      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]
+      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
+        # Rango.logger.debug("Partial: #{output[0..20]} ...")
+        return output
+      end
+
+      # extends "base.html"
+      # @since 0.0.2
+      def extends(template)
+        self._template.supertemplate = template
+      end
+    end
+  end
+end

data/rango.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+# Run thor package:gem or gem build rango.gemspec
+$:.unshift(File.join(File.dirname(__FILE__), "lib"))
+
+begin
+  require "rubygems/specification"
+rescue SecurityError
+  # http://gems.github.com
+end
+
+class Rango
+  VERSION  = "0.0.3"
+  CODENAME = "Smart Kangaroo"
+  SPECIFICATION = ::Gem::Specification.new do |s|
+    s.name = "rango"
+    # s.version = Rango::VERSION
+    s.version = Rango::VERSION
+    s.authors = ["Jakub Šťastný aka Botanicus"]
+    s.homepage = "http://github.com/botanicus/rango"
+    s.summary = "Rango is ultralightweight, ultracustomizable, ultracool web framework deeply inspired by Django."
+    s.description = "" # TODO: long description
+    s.cert_chain = nil
+    s.email = ["knava.bestvinensis", "gmail.com"].join("@")
+    s.files = Dir.glob("**/*") - Dir.glob("pkg/*")
+    s.executables = ["rango"]
+    s.default_executable = "rango"
+    s.add_dependency "rack"
+    # s.add_dependency "thor"
+    s.add_dependency "extlib"
+    s.require_paths = ["lib"]
+    s.required_ruby_version = ::Gem::Requirement.new(">= 1.9.1")
+    s.rubyforge_project = "rango"
+  end
+end

data/spec/factories.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+class Factory
+  class << self
+    def rack_env(environment = Hash.new)
+      {"PATH_INFO" => "/blog/post/a-slug", "REQUEST_METHOD" => "GET"}.merge(environment)
+    end
+
+    # TODO: Rack MocRequest
+    def request
+      Rango::Request.new(self.rack_env)
+    end
+
+    def controller
+      controller = Rango::Controller.new
+      controller.request
+      controller.params
+      return controller
+    end
+  end
+end

data/spec/rango/boot_spec.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+
+require File.join(Dir.pwd, "spec", "spec_helper")
+
+describe Rango do
+  describe ".environment" do
+    it "should have environment" do
+      Rango.should respond_to(:environment)
+    end
+
+    it "should be development by default" do
+      Rango.environment.should eql("development")
+    end
+  end
+
+  describe ".dependency" do
+    # TODO
+  end
+end