rango 0.1.1.3 → 0.2.pre

data/CHANGELOG

@@ -34,7 +34,7 @@
   * ImplicitRendering and ExplicitRendering mixins for using locals
     vs. rendering in context of current controller instance
 
-= Version 0.1.2, 13/12/2009, 22651050ea20e2997a9e5d07c8a409eb8e5de4fe
+= Version 0.1.2, 13/12/2009
   * Sequel support
   * Project generator renamed to stack generator
   * Removed app and bigapp generators
@@ -44,3 +44,19 @@
   * Much more modular design
   * Removed dependencies, since you can use whichever subset of Rango
   * There is Rango::Router.app instead of Project.router
+
+= Version 0.2.0, 24/12/2009
+  * Sequel support
+  * Logger is now configurable, you don't have to use any particular one
+  * Rango doesn't depend on RubyExts anymore
+  * Fixed status and headers settings in controller
+  * Fixed partial, extend_block and created includes for required-like functionality for templates
+  * Generators refactored, better env support
+  * Rango::Controller#redirect returns escaped location URL
+  * More modularity and granularity, Rango now plays nicely with other frameworks
+  * Refactored controller and it's now possible to write strategies for arguments passed to views
+  * ActionArgs for passing data from params to views (default behaviour in stack application)
+  * Rango itself use bundler rather than git submodules
+  * rake hooks will install task for removing whitespace in pre-commit hook, contributors should use it!
+  * Template helpers can work with paths relative to current template via ./path.html resp. ../path.html. All other paths are relative to the template paths.
+  * Use simple-logger as a default logger or standar logger if the simple-logger isn't installed.

data/Rakefile

@@ -3,14 +3,19 @@
 require_relative "lib/rango/version"
 
 # ENV setup for external commands
-ENV["RUBYLIB"] = Dir["vendor/*/lib"].join(":")
-$LOAD_PATH.clear.push(*Dir["vendor/*/lib"])
+ENV["RUBYLIB"] = Dir["gems/gems/*/lib"].join(":")
+$LOAD_PATH.clear.push(*Dir["gems/gems/*/lib"])
 
 # http://support.runcoderun.com/faqs/builds/how-do-i-run-rake-with-trace-enabled
 Rake.application.options.trace = true
 
+task :bundle do
+  # NOTE: the sense of the checkout is to avoid overwriting our changes in scripts
+  exec "gem bundle --cached && git checkout script"
+end
+
 # default task for RunCodeRun.com
-task :default => ["submodules:init", :spec]
+task :default => [:bundle, :spec]
 
 # load tasks
 Dir["tasks/*.rake"].each do |taskfile|

data/bin/rango

@@ -8,17 +8,6 @@ end
 base   = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
 libdir = File.expand_path(File.join(File.dirname(base), "..", "lib"))
 
-vendor = File.join(File.dirname(__FILE__), "..", "vendor")
-if File.directory?(vendor)
-  Dir["#{vendor}/*"].each do |path|
-    if File.directory?(path) && Dir["#{path}/*"].empty?
-      warn "Dependency #{File.basename(path)} in vendor seems to be empty. Run git submodule init && git submodule update to checkout it."
-    elsif File.directory?(path) && File.directory?(File.join(path, "lib"))
-      $:.unshift(File.join(path, "lib"))
-    end
-  end
-end
-
 # because of system installation, there is bin/../lib, but not bin/../lib/rango
 if File.directory?(File.join(libdir, "rango"))
   $:.unshift(libdir) unless $:.include?(libdir)
@@ -31,7 +20,6 @@ rescue LoadError
 end
 
 require "rango"
-require "rango/logger"
 
 # === Helpers === #
 # TODO: Generators.each { |generator| puts generator.help }
@@ -45,7 +33,6 @@ end
 begin
   ARGV.shift || usage # create
   generator_name = ARGV.shift
-  SimpleTemplater.logger = Rango.logger
   templater = SimpleTemplater.new(:rango)
   # This enables you to create custom generators for Rango
   load File.join(File.dirname(base), "..", "simple-templater.scope") # neccesary if we run rango locally and not from RubyGems

data/lib/rango.rb

@@ -4,16 +4,11 @@ if RUBY_VERSION < "1.9.1"
   raise "Rango requires at least Ruby 1.9.1. If you run JRuby, please ensure you used the --1.9 switch for JRuby command."
 end
 
-require "rango/core_ext"
-
 rango_lib = File.dirname(__FILE__)
 unless $:.include?(rango_lib) || $:.include?(File.expand_path(rango_lib))
   $:.unshift(rango_lib)
 end
 
-# It should solve problems with encoding in URL (flash messages) and templates
-Encoding.default_internal = "utf-8"
-
 module Rango
   # all the helpers are in Rango::Helpers
   # so if you want to register your own, just
@@ -37,9 +32,17 @@ module Rango
   end
 
   def self.logger
-    @@logger
-  rescue
-    raise NameError, "You have to assign a logger to Rango.logger"
+    @@logger ||= begin
+      require "simple-logger"
+      SimpleLogger::Logger.new(STDOUT).tap do |logger|
+        logger.auto_flush = true # disable in your code for production!
+      end
+    rescue LoadError
+      require "logger"
+      Logger.new(STDOUT).tap do |logger|
+        logger.warn("Using stdlib logger. If you want something more fancy with colors and #flush, install simple-logger.")
+      end
+    end
   end
 
   def self.logger=(logger)
@@ -89,13 +92,21 @@ module Rango
     require "irb"
     require "rango/utils"
 
-    ARGV.delete("-i") # otherwise irb will read it
-    ENV["RACK_ENV"] = Rango.environment # for racksh
-    unless try_require("racksh/boot")
+    begin
+      require "racksh/boot"
+    rescue LoadError
       Rango.logger.info("For more goodies install racksh gem")
-      try_require "irb/completion" # some people can have ruby compliled without readline
+    else
       Rango::Utils.load_rackup # so you can use Rango::Router.app etc
     end
+
+    begin
+      require "irb/completion"
+    rescue LoadError
+      # some people can have ruby compliled without readline
+    end
+
+    ARGV.delete("-i") # otherwise irb will read it
     IRB.start
   end
 end

data/lib/rango/controller.rb

@@ -2,100 +2,113 @@
 
 # http://wiki.github.com/botanicus/rango/controllers
 
+require "forwardable"
 require "rango/router"
 require "rango/exceptions"
 require "rango/rack/request"
-require "rubyexts/attribute"
 
 module Rango
   class Controller
     include Rango::UrlHelper
+    extend Forwardable
+    # for routers
+    def self.dispatcher(action)
+      lambda do |env|
+        Rango.logger.info("Dispatching to #{self}##{action} [#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}]")
+        env["rango.controller.action"] = action
+        return self.call(env)
+      end
+    end
+
     # [master] Change Merb::Controller to respond to #call and return a Rack Array. (wycats)http://rubyurl.com/BhoY
     # @since 0.0.2
     def self.call(env)
-      Rango::Router.set_rack_env(env)
-      request = Rango::Request.new(env)
-      options = env["rango.router.params"] || raise("rango.router.params property has to be setup at least to empty hash")
-      controller = self.new(env, options.merge(request.params))
+      Rango::Router.set_rack_env(env) # TODO: this shouldn't require router stuff, it might emit an event
+      controller = self.new(env)
       controller.to_response
     end
 
-    def to_response
-      method = request.env["rango.controller.action"].to_sym
-      if self.respond_to?(method) # TODO: what about method_missing?
-        self.process_action(method)
+    def run_action
+      if self.respond_to?(self.action)
+        self.invoke_action(self.action)
       else
-        raise NotFound, "Controller #{self.class.name} doesn't have method #{method}"
+        raise NotFound, "Controller #{self.class.name} doesn't have method #{self.action}"
       end
-      return self.response.finish
-    rescue HttpError => exception
-      self.rescue_http_error(exception)
     end
 
-    def process_action(method)
-      # If you don't care about arguments or if you prefer usage of params.
-      if self.method(method).arity.eql?(0)
-        Rango.logger.debug("Calling method #{self.class.name}##{method} without arguments")
-        self.response.body = self.method(method).call
-      else
-        args = self.params.values
-        Rango.logger.debug("Calling method #{self.class.name}##{method} with arguments #{args.inspect}")
-        self.response.body = self.method(method).call(*args)
-      end
+    # default, redefine in plugin if you need to
+    def invoke_action(action)
+      Rango.logger.debug("Calling method #{self.class.name}##{action} without arguments")
+      self.response.body = self.send(action)
     end
 
-    # for routers
-    def self.dispatcher(action)
-      lambda do |env|
-        Rango.logger.info("Dispatching to #{self}##{action} [#{env["REQUEST_METHOD"]} #{env["PATH_INFO"]}]")
-        env["rango.controller.action"] = action
-        return self.call(env)
-      end
+    def action
+      env["rango.controller.action"].to_sym
+    rescue NoMethodError
+      raise "You have to setup env['rango.controller.action'] to name of action you want to call"
     end
 
-    # @since 0.0.1
-    # @return [RubyExts::Logger] Logger for logging project related stuff.
-    # @see RubyExts::Logger
-    attribute :logger, Rango.logger
-    attribute :status
-    attribute :headers, Hash.new
+    def to_response
+      self.run_action
+      #self.response.finish # do we need this?
+      [response.status, response.headers, [response.body]] # this way we got real body rather than response object
+    rescue HttpError => exception
+      self.rescue_http_error(exception)
+    end
 
     # @since 0.0.1
-    # @return [Rango::Request]
-    # @see Rango::Request
-    attr_accessor :request, :params, :cookies, :response
-    # @since 0.0.1
-    # @return [Hash] Hash with params from request. For example <code>{messages: {success: "You're logged in"}, post: {id: 2}}</code>
-    attr_accessor :params
+    # @return [#debug, #info, #error, #fatal, #flush, #close] Logger for logging project related stuff.
+    def logger
+      Rango.logger
+    end
+
+    def_delegators :response, :status, :status=
+    def_delegators :response, :headers, :headers=
 
     # @since 0.0.2
+    # @return [String] Escaped URL (which is RFC recommendation)
     def redirect(url, options = Hash.new)
       self.status = 302
       self.headers["Location"] = URI.escape(url)
-      return String.new
     end
 
-    def initialize(env, params = Hash.new)
-      @request  = Rango::Request.new(env)
-      @response = Rack::Response.new
-      @params   = params
-      @cookies  = request.cookies
-      @session  = request.session
-      Rango.logger.inspect(params: params, cookies: cookies, session: session)
+    attr_reader :env
+    def initialize(env)
+      @env = env
+    end
+
+    def request
+      @request ||= Rango::Request.new(env)
+    end
+
+    def response
+      @response ||= Rack::Response.new
+    end
+
+    def_delegators :request, :cookies, :session
+
+    def router_params
+      @router_params ||= begin
+        self.env["rango.router.params"].symbolize_keys || raise("rango.router.params property has to be setup at least to empty hash")
+      end
+    end
+
+    def params
+      @params ||= self.request.params.merge(self.router_params).symbolize_keys
     end
-    attr_reader :session
 
     # redefine this method for your controller if you want to provide custom error pages
     # returns response array for rack
     # if you need to change just body of error message, define render_http_error method
     # @api plugin
     def rescue_http_error(exception)
-      status, headers, body = exception.to_response
-      if self.respond_to?(:render_http_error)
-        [status, headers, self.render_http_error(exception)]
-      else
-        [status, headers, body]
-      end
+      # we need to call it before we assign the variables
+      body = self.render_http_error(exception)
+      [exception.status, exception.headers, body]
+    end
+
+    def render_http_error(exception)
+      "EXCEPTION"
     end
   end
 end

data/lib/rango/core_ext.rb

@@ -1,21 +1,104 @@
 # encoding: utf-8
 
-module Kernel
-  # @since 0.1.1.3
-  # @example
-  #   try_require "term/ansicolor"
-  # @param [String] library Library to require.
-  # @return [Boolean] True if require was successful, false otherwise.
-  def try_require(library)
-    require library
-  rescue LoadError
-    return false
-  end
-
-  # @example require_gem "rubyexts", "rubyexts/logger"
-  def require_gem(gemname, library = gemname)
-    require library
-  rescue LoadError
-    raise LoadError, "You have to install #{gemname}!"
+module Enumerable
+  # similar to
+  def inject!(&block)
+    self.inject(self.class.new, &block)
+  end
+end
+
+class String
+  ##
+  # Convert to snake case.
+  #
+  #   "FooBar".snake_case           #=> "foo_bar"
+  #   "HeadlineCNNNews".snake_case  #=> "headline_cnn_news"
+  #   "CNN".snake_case              #=> "cnn"
+  #
+  # @return [String] Receiver converted to snake case.
+  #
+  # @api public
+  def snake_case
+    return self.downcase if self =~ /^[A-Z]+$/
+    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+      return $+.downcase
+  end
+
+  ##
+  # Convert to camel case.
+  #
+  #   "foo_bar".camel_case          #=> "FooBar"
+  #
+  # @return [String] Receiver converted to camel case.
+  #
+  # @api public
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+
+  ##
+  # Convert a path string to a constant name.
+  #
+  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
+  #
+  # @return [String] Receiver converted to a constant name.
+  #
+  # @api public
+  def to_const_string
+    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  ##
+  # Convert a constant name to a path, assuming a conventional structure.
+  #
+  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
+  #
+  # @return [String] Path to the file containing the constant named by receiver
+  #   (constantized string), assuming a conventional structure.
+  #
+  # @api public
+  def to_const_path
+    snake_case.gsub(/::/, "/")
+  end
+end
+
+class Hash
+  # Return duplication of self with all keys non-recursively converted to symbols
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Hash] A hash with all keys transformed into symbols
+  def symbolize_keys
+    self.inject(Hash.new) do |result, array|
+      result[array.first.to_sym] = array.last
+      result
+    end
+  end
+
+  # Replace keys in self by coresponding symbols
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Hash] A hash with all keys transformed into symbols
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+
+  # Return duplication of self with all keys recursively converted to symbols
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Hash] A hash with all keys transformed into symbols even in inner hashes
+  def deep_symbolize_keys
+    self.inject(Hash.new) do |result, array|
+      key, value = array.first, array.last
+      if value.respond_to?(:symbolize_keys)
+        result[key.to_sym] = value.symbolize_keys
+      else
+        result[key.to_sym] = value
+      end
+      result
+    end
   end
 end

data/lib/rango/environments.rb

@@ -2,25 +2,39 @@
 
 # http://wiki.github.com/botanicus/rango/environments-support
 
-require "rubyexts/attribute"
-
 module Rango
-  class << self
-    # @since 0.0.1
-    # @return [String] Returns current environment name.
-    attribute :environment, "development"
-
-    # clever environments support
-    attribute :development_environments, ["development"]
-    attribute :testing_environments,     ["test", "spec", "cucumber"]
-    attribute :production_environments,  ["stage", "production"]
-
-    questionable(:testing)     { self.testing_environments.include?(Rango.environment) }
-    questionable(:development) { self.development_environments.include?(Rango.environment) }
-    questionable(:production)  { self.production_environments.include?(Rango.environment) }
-
-    def environment?(environment)
-      self.environment.eql?(environment.to_s)
-    end
+  # @since 0.0.1
+  # @return [String] Returns current environment name.
+  def self.environment
+    @@environment ||= "development"
+  end
+
+  def self.environment=(environment)
+    @@environment = environment
+  end
+
+  # clever environments support
+  def self.environments
+    @@environments ||= {
+      development: ["development"],
+      testing:     ["test", "spec", "cucumber"],
+      production:  ["stage", "production"]
+    }
+  end
+
+  def self.testing?
+    self.environments[:testing].include?(Rango.environment)
+  end
+
+  def self.development?
+    self.environments[:development].include?(Rango.environment)
+  end
+
+  def self.production?
+    self.environments[:production].include?(Rango.environment)
+  end
+
+  def self.environment?(environment)
+    self.environment.eql?(environment.to_s)
   end
 end