rango 0.2 → 0.2.1.pre

data/lib/rango/mixins/rendering.rb

@@ -3,6 +3,60 @@
 require "rango/mixins/render"
 
 module Rango
+  module FormatMixin
+    def self.extended
+    end
+
+    def inherited
+    end
+
+    attr_writer :format
+    def formats
+      @formats ||= Hash.new { |hash, format| hash[:html] if hash.has_key?(:html) }
+    end
+
+    # format(:json) do |object|
+    #   object.to_json
+    # end
+    def format(format, &block)
+      self.formats[:format] = block
+    end
+  end
+  module StackRendering
+    include Rango::RenderMixin
+    def template_dirname
+      self.class.name.gsub("::", "/").camel_case
+    end
+
+    def template_basename
+      request["router.action"]
+    end
+
+    #def template_basename
+    #  case request["router.action"]
+    #  when "show"
+    #    self.class.name.singularize
+    #  when "index"
+    #  else
+    #  end
+    #end
+
+    def template_path
+      File.join(template_dirname, template_basename)
+    end
+
+    def render(context = Hash.new)
+      super(self.template_path, self.scope, self.context.merge!(context))
+    end
+
+    def display(object)
+      render
+    rescue TemplateNotFound
+      callback = self.formats[request.action]
+      callback.call
+    end
+  end
+
   module ExplicitRendering
     include Rango::RenderMixin
     def render(template, context = Hash.new)

data/lib/rango/orm/tasks/datamapper.nake

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+# @since 0.0.2.1
+# ./tasks.rb db:automigrate test
+Task.new("db:automigrate") do |task|
+  task.description = "Automigrate the database. It will destroy all the data!"
+  task.define do |environment = "development", options|
+    Task[:environment].call(environment)
+    Rango.logger.info("[#{Rango.environment}] Migrating databases ...")
+    result = DataMapper.auto_migrate!
+    Rango.logger.debug("Result: #{result.inspect}")
+  end
+end
+
+# @since 0.0.2.1
+# ./tasks.rb db:autoupgrade test
+Task.new("db:autoupgrade") do |task|
+  task.description = "Autoupgrade the database structure. Data should stay untouched."
+  task.define do |environment = "development", options|
+    Task[:environment].call(environment)
+    Rango.logger.info("[#{Rango.environment}] Upgrading databases ...")
+    result = DataMapper.auto_upgrade!
+    Rango.logger.debug("Result: #{result.inspect}")
+  end
+end
+
+# @since 0.0.2.1
+# ./tasks.rb db:report test
+Task.new("db:report") do |task|
+  task.description = "Report count of objects in database."
+  task.define do |environment = "development", options|
+    Task[:environment].call(environment)
+    ObjectSpace.classes.each do |klass|
+      if klass.included(DataMapper::Resource)
+        puts "#{model_class}: #{model_class.count}"
+      end
+    end
+  end
+end
+
+Task.new("db:migrate") do |task|
+  task.hidden = true
+  task.define do |*args, options|
+    abort "Use #{$0} db:migrate:up version or #{$0} db:migrate:down version"
+  end
+end
+
+Task.new("db:migrate:load") do |task|
+  task.hidden = true
+  task.define do |environment, options|
+    Task[:environment].call(environment)
+    begin
+      require "dm-migrations/migration_runner"
+    rescue LoadError
+      abort "You have to install dm-migrations gem for this!"
+    end
+    Dir["db/migrations/*.rb"].each do |migration|
+      load migration
+    end
+  end
+end
+
+# @since 0.0.2.1
+# ./tasks.rb db:migrate:up test --version=10
+Task.new("db:migrate:up") do |task|
+  task.description = "Migrate up using migrations."
+  task.define do |environment = "development", options|
+    Task["db:migrate:load"].call(environment)
+    migrate_up!(options[:version])
+  end
+end
+
+# @since 0.0.2.1
+# ./tasks.rb db:migrate:down test --version=10
+Task.new("db:migrate:down") do |task|
+  task.description = "Migrate down using migrations."
+  task.define do |environment = "development", options|
+    Task["db:migrate:load"].call(environment)
+    migrate_down!(options[:version])
+  end
+end

data/lib/rango/orm/tasks/sequel.nake

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+# @since 0.0.2.1
+# ./tasks.rb db:migrate test
+Task.new("db:migrate") do |task|
+  task.description = "Perform migration using migrations in schema/migrations"
+  task.define do |environment = "development", options|
+    Task[:environment].call(environment)
+    require "sequel/extensions/migration"
+    Sequel::Migrator.apply(Sequel::Model.db, "db/migrations", options[:version])
+  end
+end
+
+# @since 0.0.2.1
+# ./tasks.rb db:drop:all test
+Task.new("db:drop:all") do |task|
+  task.description = "Drop all the tables"
+  task.define do |environment = "development", options|
+    Task[:environment].call(environment)
+    Sequel::Model.db.drop_table *Sequel::Model.db.tables
+  end
+end
+
+# @since 0.0.2.1
+# ./tasks.rb db:reset test
+Task.new("db:reset") do |task|
+  task.description = "Drop all tables and perform migrations"
+  task.define do |environment = "development", options|
+    Task[:environment].call(environment)
+    Task["db:drop:all"].call
+    Task["db:migrate"]
+  end
+end
+
+# @since 0.0.2.1
+# ./tasks.rb db:truncate test
+Task.new("db:truncate") do |task|
+  task.description = "Truncate all tables in database"
+  task.define do |environment = "development", options|
+    Task[:environment].call(environment)
+    Sequel::Model.db << "TRUNCATE #{db.tables.join(', ')} CASCADE;"
+  end
+end

data/lib/rango/router/adapters/usher.rb

@@ -3,7 +3,8 @@
 require "usher"
 
 Rango::Router.implement(:usher) do |env|
-  env["rango.router.params"] = env["usher.params"]
+  # when usher routes to the default app, then usher.params is nil
+  env["rango.router.params"] = env["usher.params"] || Hash.new
 end
 
 module Rango

data/lib/rango/stacks/controller.rb

@@ -1,6 +1,18 @@
 # encoding: utf-8
 
 require "rango"
+require "rango/helpers"
 require "rango/controller"
 require "rango/environments"
+require "rango/mixins/rendering"
+require "rango/mixins/message"
+require "rango/mixins/filters"
 require "rango/rack/middlewares/basic"
+
+module Rango
+  class StackController < Controller
+    include ExplicitRendering
+    include FiltersMixin
+    include MessageMixin
+  end
+end

data/lib/rango/tasks/spec.nake

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+Task.new(:spec) do |task|
+  task.description = "Run specs"
+  task.define do |path = "spec", options|
+    path = args.path ? "spec" : args.path
+    sh "./bin/spec --options spec/spec.opts #{path}"
+  end
+end

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

@@ -6,7 +6,7 @@
 # Attributes of each tag will reverse merged with his default attributes, so you
 # don't have to write over and over that script tag has attribute `type` with value
 # `text/javascript`. For example, `%script` compiles to `<script type="text/javascript"></script>`.
-# Defaults to `{:script => {:type => "text/javascript"}, :form => {:method => "POST"}}`
+# Defaults to `{script: {type: "text/javascript"}, form: {method: "POST"}}`
 
 module Haml
   class Engine

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

@@ -14,13 +14,23 @@ module Tilt
     end
   end
 
+  # Tilt::HamlTemplate.options[:default_attributes] = {script: {type: "text/javascript"}, form: {method: "POST"}}
   HamlTemplate.class_eval do
     extend Chainable
+
+    def self.options
+      @options ||= Hash.new
+    end
+
     chainable do
       def initialize_engine
         super
         require "rango/templates/exts/haml"
       end
+
+      def haml_options
+        super.merge!(self.class.options)
+      end
     end
   end
 end

data/lib/rango/templates/helpers.rb

@@ -4,10 +4,12 @@ require "rango"
 require "rango/templates/template"
 
 module Rango
+  SubtemplateNotFound = Class.new(StandardError)
+
   module TemplateHelpers
     def self.extended(scope)
       class << scope
-        attr_accessor :_template
+        attr_accessor :template
         # @example Capture being used in a .html.erb page:
         #   <% @foo = capture do %>
         #     <p>Some Foo content!</p>
@@ -18,13 +20,13 @@ module Rango
         # @return [String] The output of the block.
         # @api private
         def capture(*args, &block)
-          capture_method = "capture_#{self._template.adapter}"
+          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)
+            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"
+              raise "Adapter #{self.template.adapter} doesn't support capturing"
             end
             _old_buf, @_out_buf = @_out_buf, ""
             block.call(*args)
@@ -33,13 +35,13 @@ module Rango
         end
 
         def concat(string)
-          concat_method = "concat_#{self._template.adapter}"
+          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)
+            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"
+              raise "Adapter #{self.template.adapter} doesn't support concating"
             end
             @_out_buf << string
           end
@@ -48,7 +50,7 @@ module Rango
     end
 
     def self.included(scope_class)
-      scope_class.class_eval { attr_accessor :_template}
+      scope_class.class_eval { attr_accessor :template }
     end
 
     # post/show.html: it's block is the block we like to see in output
@@ -59,15 +61,15 @@ module Rango
     def 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
-      self._template.blocks[name] ||= block ? self._template.scope.capture(&block) : value
-      return self._template.blocks[name]
+      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)
     def extend_block(name, value = nil, &block)
-      unless self._template.blocks[name]
+      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)
@@ -76,9 +78,9 @@ module Rango
     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] = "#{self._template.blocks[name]}\n#{value}" if value
-      return self._template.blocks[name]
+      value = self.template.scope.capture(&block) if value.nil? && block
+      self.template.blocks[name] = "#{self.template.blocks[name]}\n#{value}" if value
+      return self.template.blocks[name]
     end
 
     # Low-level rendering method for templates.
@@ -88,22 +90,24 @@ module Rango
     #   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
+    def render(path, context = Hash.new)
+      full_path = normalize_template_path(path)
+      original_template = self.template
+      template = Rango::Template.new(full_path, self) # self is scope
+      self.template = original_template
       return template.render(context)
+    rescue Exceptions::TemplateNotFound # FIXME: this doesn't work
+      raise SubtemplateNotFound, "Template #{path} doesn't exist in #{full_path}"
     end
 
     # partial "products/list"
     # @since 0.0.2
-    # @version 0.2
-    def partial(template, context = Hash.new)
+    # @version 0.2.1
+    def partial(template, extra_context = Hash.new)
       # 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}")
+      render File.join(path.join("/"), "_#{basename}"), self.template.context.merge(extra_context)
     end
 
     # @since 0.2
@@ -116,15 +120,15 @@ module Rango
     # @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 = normalize_template_path(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))
+        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))
+        File.expand_path(File.join(File.dirname(self.template.fullpath), "..", template))
       else
         template
       end

data/lib/rango/templates/template.rb

@@ -6,7 +6,7 @@ require "rango/templates/helpers"
 require "rango/exceptions"
 
 module Rango
-  module Errors # so we can catch it with other HTTP errors
+  module Exceptions # so we can catch it with other HTTP errors
     TemplateNotFound = Class.new(NotFound)
   end
 
@@ -17,7 +17,7 @@ module Rango
 
     # template -> supertemplate is the same relationship as class -> superclass
     # @since 0.0.2
-    attr_accessor :path, :scope, :supertemplate
+    attr_accessor :path, :scope, :supertemplate, :context
 
     # @since 0.0.2
     attr_writer :blocks
@@ -29,7 +29,7 @@ module Rango
     def initialize(path, scope = Object.new)
       self.path  = path#[scope.class.template_prefix.chomp("/"), template].join("/")
       self.scope = scope.extend(TemplateHelpers)
-      self.scope._template = self
+      self.scope.template = self
     end
 
     # @since 0.0.2
@@ -57,10 +57,11 @@ 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.class.template_paths.inspect}") if self.fullpath.nil?
+      raise Exceptions::TemplateNotFound.new("Template #{self.path} wasn't found in these template_paths: #{self.class.template_paths.inspect}") if self.fullpath.nil?
+      Rango.logger.info("Rendering template #{self.path} with context keys #{context.keys.inspect}")
+      self.context = context
       value = self.template.render(self.scope, context)
-      Rango.logger.info("Rendering template #{self.path}")
-      # #Rango.logger.inspect(self.blocks)
+      Rango.logger.debug("Available blocks: #{self.blocks.keys.inspect}")
       if self.supertemplate
         Rango.logger.debug("Extends call: #{self.supertemplate}")
         supertemplate = self.class.new(self.supertemplate, self.scope)

data/rango.gemspec

@@ -0,0 +1,52 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+require "base64"
+
+Gem::Specification.new do |s|
+  s.name = "rango"
+  s.version = "0.2.1"
+  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 = Base64.decode64("c3Rhc3RueUAxMDFpZGVhcy5jeg==\n")
+  s.has_rdoc = true
+
+  # files
+  s.files = `git ls-files`.split("\n")
+
+  Dir["bin/*"].map(&File.method(:basename))
+  s.default_executable = "rango"
+  s.require_paths = ["lib"]
+
+  # Ruby version
+  # Current JRuby with --1.9 switch has RUBY_VERSION set to "1.9.2dev"
+  # and RubyGems don't play well with it, so we have to set minimal
+  # Ruby version to 1.9, even if it actually is 1.9.1
+  s.required_ruby_version = ::Gem::Requirement.new("~> 1.9")
+
+  # === Dependencies ===
+  # RubyGems has runtime dependencies (add_dependency) and
+  # development dependencies (add_development_dependency)
+  # Rango isn't a monolithic framework, so you might want
+  # to use just one specific part of it, so it has no sense
+  # to specify dependencies for the whole gem. If you want
+  # to install everything what you need for start with Rango,
+  # just run gem install rango --development
+
+  s.add_development_dependency "simple-templater", ">= 0.0.1.2"
+  s.add_development_dependency "bundler"
+
+  begin
+    require "changelog"
+  rescue LoadError
+    warn "You have to have changelog gem installed for post install message"
+  else
+    s.post_install_message = CHANGELOG.new.version_changes
+  end
+
+  # RubyForge
+  s.rubyforge_project = "rango"
+end