rango 0.1.0 → 0.1.1

data/CHANGELOG

@@ -23,3 +23,9 @@
   * [FEATURE] Generic view
   * [FEATURE] Project generator
   * [FEATURE] Rack-mount support
+
+= Version 0.1.1
+  * Tilt support
+  * Removed old merb-helpers
+  * Templates are rendered in separate namespace
+  * Reworked generic views

data/CONTRIBUTORS

@@ -1,2 +1,3 @@
 Jakub Šťastný aka Botanicus (main author)
+Grant Michael Levkoff aka grantmichaels (wrote awesome http://www.rubyinside.com/rango-ruby-web-app-framework-2858.html)
 Martin Hrdlička

data/README.textile

@@ -2,6 +2,7 @@ h1. Installation via RubyGems
 
 * Daily builds: @gem install rango --pre@ _(Daily builds currently doesn't work, I'm going to fix it till end of this week.)_
 * Stable version: @gem install rango@
+* JRuby: @jruby --1.9 -S gem install rango@
 
 _We were using option @--development@ for installing development dependencies, unfortunately Rack has Mongrel as a development dependency and Mongrel compilation fails on Ruby 1.9, so I put everything into normal dependencies for now._
 
@@ -14,12 +15,14 @@ h1. Documentation
 
 * "Wiki":http://wiki.github.com/botanicus/rango
 * "Tutorial":http://wiki.github.com/botanicus/rango/tutorial
-* "API Docs":http://rdoc.info/projects/botanicus/rango
+* "RDoc.info API Docs":http://rdoc.info/projects/botanicus/rango
+* "Yardoc.org API Docs":http://yardoc.org/docs/botanicus-rango
 * "Examples":http://github.com/botanicus/rango-examples
 * "Bug reporting":http://github.com/botanicus/rango/issues
 
 h1. Community
 
+* "Google Group":http://groups.google.com/group/rango-project
 * "Rango Blog":http://botanicus.github.com/rango
 * "Twitter":https://twitter.com/RangoProject
 * IRC: #rango at irc://irc.freenode.net

data/bin/rango

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby1.9
+#!/usr/bin/env ruby
 # encoding: utf-8
 
 base   = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__

data/lib/rango.rb

@@ -3,32 +3,98 @@
 require "ostruct"
 require "uri"
 require "media-path"
-require "rubyexts"
+require "rubyexts/logger"
+require "rango/mixins/application"
 
 rango_lib = File.dirname(__FILE__)
 unless $:.include?(rango_lib) || $:.include?(File.expand_path(rango_lib))
   $:.unshift(rango_lib)
 end
 
+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, for example jruby --1.9 -S rango create project blog"
+end
+
 # It should solve problems with encoding in URL (flash messages) and templates
 Encoding.default_internal = "utf-8"
 
-require_relative "rango/mixins/import"
-require_relative "rango/mixins/application"
-
 module Rango
-  VERSION ||= "0.1.0"
-  extend ImportMixin
+  VERSION ||= "0.1.1"
   extend ApplicationMixin
 
   def self.root
     File.join(File.dirname(__FILE__), "rango")
   end
-
-  # realoder
-  # require "rango/reloader"
-  # cattr_reader :reloader
-  # @@reloader = Rango::Reloader.new
 end
 
-require_relative "rango/rango"
+require "rango/project"
+
+module Rango
+  # all the helpers are in Rango::Helpers
+  # so if you want to register your own, just
+  # Rango::Helpers.send(:include, Pupu::Helpers)
+  Helpers ||= Module.new
+
+  class << self
+    # @since 0.0.2
+    # @example
+    #   Rango.path
+    #   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
+    # @return [Path] Rango root path
+    def path
+      @path ||= MediaPath.new(self.root)
+    end
+
+    # @since 0.0.1
+    # @example
+    #   Rango.root
+    #   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
+    # @return [RubyExts::Logger] Logger for logging framework-related stuff. For logging project-relating stuff please use Project.logger.
+    # @see Project::logger
+    def logger
+      @logger ||= RubyExts::Logger.new
+    end
+
+    # @since 0.0.1
+    # @example
+    #   Rango.boot # require init.rb
+    #   Rango.boot { require_relative "config/init.rb" } # custom boot
+    # @param [Hash] options You can specify flat: true for sinatra-like flat application.
+    # @return [Boolean] Returns true if boot succeed or false if not. If ARGV includes "-i", IRB interactive session will start.
+    def boot(options = Hash.new, &block)
+      self.environment = options[:environment] if options[:environment]
+      block.call if block_given?
+      self.bootloaders.each do |name, bootloader|
+        logger.debug "Calling bootloader #{name}"
+        bootloader.call
+      end
+    end
+
+    # @since 0.0.2
+    def reboot(options = Hash.new)
+      self.boot(options.merge(force: true))
+    end
+
+    attribute :bootloaders, Hash.new
+    def after_boot(name, &block)
+      self.bootloaders[name] = block
+    end
+
+    # Start IRB interactive session
+    # @since 0.0.1
+    def interactive
+      require "rango/utils"
+      require "rubyexts"
+      ARGV.delete("-i") # otherwise irb will read it
+      ENV["RACK_ENV"] = Rango.environment # for racksh
+      unless try_require("racksh/boot")
+        Rango.logger.info("For more goodies install racksh gem")
+        try_require "irb/completion" # some people can have ruby compliled without readline
+        Rango::Utils.load_rackup # so you can use Project.router etc
+      end
+      require "irb"
+      require "rango/utils"
+      IRB.start
+    end
+  end
+end

data/lib/rango/contrib/pagination.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+# http://wiki.github.com/botanicus/rango/pagination
+
 require "dm-aggregates"
 
 require "rango/contrib/pagination/page"

data/lib/rango/controller.rb

@@ -1,13 +1,18 @@
 # encoding: utf-8
 
+# http://wiki.github.com/botanicus/rango/controllers
+
 require "rango/mixins/render"
-require "rango/helpers"
+require "rango/exceptions"
+require "rango/project"
+require "rango/rack/request"
+require "rango/router"
+require "rango/templates/template"
 
 module Rango
   class Controller
     include Rango::Helpers
     include Rango::RenderMixin
-    include Rango::Templates::TemplateHelpers
 
     class << self
       # @since 0.0.2
@@ -50,11 +55,11 @@ module Rango
       # [master] Change Merb::Controller to respond to #call and return a Rack Array. (wycats)http://rubyurl.com/BhoY
       # @since 0.0.2
       def call(env)
-        Rango::Router.new.set_rack_env(env) # See rango/router/adapters/*
+        Rango::Router.set_rack_env(env) # See rango/router/adapters/*
         request = Rango::Request.new(env)
         options = env["rango.router.params"] || raise("rango.router.params property has to be setup at least to empty hash")
         method = env["rango.controller.action"].to_sym
-        controller = self.new(request, options.merge(request.params))
+        controller = self.new(env, options.merge(request.params))
         begin
           unless controller.respond_to?(method) # TODO: what about method_missing?
             raise NotFound, "Controller #{self.name} doesn't have method #{method}"
@@ -100,12 +105,52 @@ module Rango
       end
     end
 
-    def initialize(request, params)
-      @request = request
+    # @since 0.0.1
+    # @return [RubyExts::Logger] Logger for logging project related stuff.
+    # @see RubyExts::Logger
+    attribute :logger, Project.logger
+    attribute :status
+    attribute :headers, Hash.new
+
+    # @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
+
+    # The rails-style flash messages
+    # @since 0.0.2
+    def message
+      @message ||= (request.GET[:msg] || Hash.new)
+    end
+
+    def render(template, locals = Hash.new)
+      super template, self.locals.merge!(locals)
+    end
+
+    # @since 0.0.2
+    def redirect(url, options = Hash.new)
+      self.status = 302
+
+      # for example ?msg[error]=foo
+      [:error, :success, :notice].each do |type|
+        if msg = (options[type] || message[type])
+          url.concat("?msg[#{type}]=#{msg}")
+        end
+      end
+
+      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
+      @params   = params
+      @cookies  = request.cookies
+      @session  = request.session
       Rango.logger.inspect(params: params, cookies: cookies, session: session)
     end
     attr_reader :session
@@ -119,11 +164,12 @@ module Rango
     # 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)
-        message = self.render_http_error(exception)
-        exception.message = message unless message.nil?
+        [status, headers, self.render_http_error(exception)]
+      else
+        [status, headers, body]
       end
-      exception.to_response
     end
 
     # @since 0.0.2

data/lib/rango/environments.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+# 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
+  end
+end

data/lib/rango/exceptions.rb

@@ -1,21 +1,11 @@
 # encoding: utf-8
 
-SettingsNotFound = Class.new(StandardError)
-
-class TemplateNotFound < StandardError # TODO: should inherit from NotFound
-  # @since 0.0.2
-  attr_accessor :message
-
-  # @since 0.0.2
-  def initialize(template, locations)
-    self.message = "Template '#{template}' wasn't found in any of these locations: #{locations.join(", ")}."
-  end
-end
+# http://wiki.github.com/botanicus/rango/errors-handling
 
 # superclass of all the controller exceptions
 module Rango
   class HttpError < StandardError
-    CONTENT_TYPE ||= "text/plain"
+    CONTENT_TYPE ||= "text/html"
 
     attr_accessor :content_type, :headers
     def initialize(*args)
@@ -88,8 +78,6 @@ module Rango
   Error403 = Forbidden = Class.new(Rango::ClientError) { STATUS ||= 403 }
   Error404 = NotFound = Class.new(Rango::ClientError) { STATUS ||= 404 }
   ActionNotFound = Class.new(Rango::NotFound)
-  TemplateNotFound = Class.new(Rango::NotFound)
-  LayoutNotFound = Class.new(Rango::NotFound)
   Error405 = MethodNotAllowed = Class.new(Rango::ClientError) { STATUS ||= 405 }
   Error406 = NotAcceptable = Class.new(Rango::ClientError) { STATUS ||= 406 }
   Error407 = ProxyAuthenticationRequired = Class.new(Rango::ClientError) { STATUS ||= 407 }

data/lib/rango/gv.rb

@@ -1,98 +1,15 @@
 # encoding: utf-8
 
-# GV = generic views
-require "rango/mixins/render"
-
-# what about filters?
-#   - include to controller or use directly (include Rango::GV, but what if I want to include just for example static gv?)
-#   - or Rango::GV.extend FiltersMixin
+# Generic Views
+# Use directly or include into a controller if you want to use filters or customize them
+# http://wiki.github.com/botanicus/rango/generic-views
 
-#
-# TODO: each generic view should has its own module, so rather than
-# include Rango::GV we should do include Rango::GV::Static
-#
+require "rango/mini"
+require "rango/router"
+require "rango/mixins/render"
 
 module Rango
   module GV
-    class View
-      include Rango::Helpers
-      include Rango::RenderMixin
-      attr_reader :name, :definition
-      attr_accessor :args, :custom_block # we can't use just block because of block(:head)
-      attr_accessor :env, :request, :response
-      def initialize(name, &definition)
-        @name, @definition = name, definition
-      end
-      
-      def setup(*args, &custom_block)
-        self.args = args
-        self.custom_block = custom_block
-      end
-      
-      def call(env)
-        Rango::Router.new.set_rack_env(env) # so env["usher.params"] => env["rango.router.params"]
-        self.request = Rango::Request.new(env)
-        self.response = Rack::Response.new
-        self.env = env
-
-        # Welcome to Ruby 1.9 world! instance_exec is the same as instance_eval,
-        # but it can takes arguments for the custom_block
-        args = [*self.args, self.custom_block]
-        Rango.logger.debug("Calling generic view #{self.name} with #{args.inspect}")
-        body = self.instance_exec(*args, &self.definition)
-
-        # TODO: check how rack test if object is stringable, probably not this way
-        raise ArgumentError unless body.respond_to?(:each) || body.is_a?(String)
-        response.write(body)
-        response.finish
-      end
-    end
-
-    def self.define(action, &definition)
-      # instance method for including
-      define_method(action, &definition)
-
-      # class method for direct usage
-      # TODO: clean this mess before someone start vomit
-      @@view = View.new(action, &definition)
-      module_eval <<-RUBY, __FILE__, __LINE__
-      def self.#{action}(*args, &block)
-        view = @@view.dup
-        view.setup(*args, &block)
-        view # has #call
-      end
-      RUBY
-    end
+    extend Rango::RenderMixin
   end
 end
-
-# require params[:path]
-# @example
-#   Usher::Interface.for(:rack) do
-#     get("/").to(Rango::GV.static("index"))
-#     get("/:template").to(::Static.dispatcher(:show)).name(:static)
-#     get("/:template").to(Rango::GenericViews.dispatcher(:static)).name(:static)
-#     get("/:template").to do |env|
-#       env["rango.params"][:template] # transform
-#       Rango::GV.static
-#     end
-#   end
-
-# THE MAIN PROBLEM IS THIS CAN'T WORK WITH BLOCKS
-# BECAUSE OF instance_exec(*args, &block, &definition) will cause syntax error in Ruby
-
-###############
-# This might be the best solution:
-#Rango::GV.define(:static) do |view, template = nil, &block|
-#end
-
-# implementation: just definition.call(self, *self.args, &self.block)
-###############
-  
-Rango::GV.define(:static) do |hook = nil|
-  require "rango/helpers" # for javascripts etc helpers
-  path = env["rango.router.params"][:template]
-  path = hook.call(path) unless hook.nil?
-  Rango.logger.debug("Rendering '#{path}'")
-  render path
-end

data/lib/rango/gv/static.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require "rango/gv"
+
+module Rango
+  module GV
+    def self.static(template, locals = nil, &hook)
+      Rango::Mini.app do |request, response|
+        path = template || request.env["rango.router.params"][:template]
+        path = hook.call(path) unless hook.nil?
+        path = "#{path}.html" unless path.match(/\./)
+        Rango.logger.debug("Rendering '#{path}'")
+        # Rango::RenderMixin.context
+        locals = locals.call(request) if locals.respond_to?(:call) # lambda { |request| {msg: request.message} }
+        render path, locals
+      end
+    end
+
+    # you would usually define module Static with instance method static for
+    # including into controllers, but since controllers have render, it would be useless
+  end
+end