rango 0.2 → 0.2.1.pre

data/lib/rango/environments.rb

@@ -3,22 +3,12 @@
 # http://wiki.github.com/botanicus/rango/environments-support
 
 module Rango
-  # @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"]
+      production:  ["stagging", "production"]
     }
   end
 
@@ -33,8 +23,4 @@ module Rango
   def self.production?
     self.environments[:production].include?(Rango.environment)
   end
-
-  def self.environment?(environment)
-    self.environment.eql?(environment.to_s)
-  end
 end

data/lib/rango/exceptions.rb

@@ -2,102 +2,160 @@
 
 # http://wiki.github.com/botanicus/rango/errors-handling
 
+require "uri"
+
 # superclass of all the controller exceptions
 module Rango
-  class HttpError < StandardError
-    CONTENT_TYPE ||= "text/html"
+  module Exceptions
+    class HttpError < StandardError
+      def self.name=(name)
+        @name = name
+      end
 
-    attr_accessor :content_type, :headers
-    def initialize(*args)
-      @headers = Hash.new
-      super(*args)
-    end
+      def self.name
+        @name
+      end
 
-    def inspect
-      self.to_response.inspect
-    end
+      def name
+        @name ||= self.class.name
+      end
 
-    # @returns [String]
-    # @example NotFound.new.to_snakecase # "not_found"
-    def to_snakecase
-      self.class.name.split("::").last.snake_case
-    end
+      def self.message=(message)
+        @message = message
+      end
 
-    def status() self.class::STATUS end
-    def content_type
-      @content_type || self.class::CONTENT_TYPE
-    end
+      def self.message
+        @message ||= begin
+          self.superclass.message
+        rescue NoMethodError
+        end
+      end
+
+      attr_writer :message
+      def message
+        @message ||= self.class.message
+      end
+
+      def self.status=(status)
+        @status = status
+      end
+
+      def self.status
+        @status ||= begin
+          self.superclass.status
+        rescue NoMethodError
+        end
+      end
+
+      # If we have a redirection but we don't know the status yet,
+      # then rather than use raise Error301 we create a new instance
+      # of the Redirection class and set the status manualy
+      attr_writer :status
+
+      def status
+        @status ||= self.class.status
+      end
 
-    def to_response
-      headers = {"Content-Type" => self.content_type}.merge(self.headers)
-      [self.status, headers, [self.message]]
+      def self.headers
+        @headers ||= {"Content-Type" => "text/html"}
+      end
+
+      def headers
+        @headers ||= self.class.headers.dup
+      end
+
+      # raise Redirection.new("/", 301)
+      def initialize(message = self.class.name, status = nil)
+        self.status = status unless status.nil?
+        self.message = message
+      end
+
+      def inspect
+        self.to_response.inspect
+      end
+
+      # @returns [String]
+      # @example NotFound.new.to_snakecase # "not_found"
+      def to_snakecase
+        self.class.name.split("::").last.snake_case
+      end
+
+      def to_response
+        [self.status, self.headers, [self.message].compact]
+      end
     end
 
-    def self.const_missing(name)
-      if [:STATUS, :CONTENT_TYPE].include?(name)
-        raise NameError, "Every descendant of HttpError class has to have defined constant #{name}."
-      else
-        super(name)
+    # http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+
+    # informational
+    Informational = Class.new(HttpError)
+    Error100 = Continue = Class.new(Informational)                 { self.status ||= 100; self.name ||= "Continue" }
+    Error101 = SwitchingProtocols = Class.new(Informational)       { self.status ||= 101; self.name ||= "Switching Protocols" }
+
+    # successful
+    Successful = Class.new(HttpError)
+    Error200 = OK = Class.new(Successful)                          { self.status ||= 200; self.name ||= "OK" }
+    Error201 = Created = Class.new(Successful)                     { self.status ||= 201; self.name ||= "Created" }
+    Error202 = Accepted = Class.new(Successful)                    { self.status ||= 202; self.name ||= "Accepted" }
+    Error203 = NonAuthoritativeInformation = Class.new(Successful) { self.status ||= 203; self.name ||= "Non Authoritative Information" }
+    Error204 = NoContent = Class.new(Successful)                   { self.status ||= 204; self.name ||= "No Content" }
+    Error205 = ResetContent = Class.new(Successful)                { self.status ||= 205; self.name ||= "Reset Content" }
+    Error206 = PartialContent = Class.new(Successful)              { self.status ||= 206; self.name ||= "Partial Content" }
+
+    # redirection
+    class Redirection < HttpError
+      self.name ||= "Redirection"
+      alias_method :location, :message
+
+      # use raise MovedPermanently, "http://example.com"
+      # Yes, you can use just redirect method from the controller, but
+      # this will work even in filters or in environments without controllers
+      # raise Redirection.new("/", 301)
+      def initialize(location, status = nil)
+        super(location, status)
+        location = URI.escape(location)
+        headers["Location"] = location
       end
     end
-  end
 
-  # http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
-
-  # informational
-  Informational = Class.new(Rango::HttpError)
-  Error100 = Continue = Class.new(Rango::Informational) { STATUS ||= 100 }
-  Error101 = SwitchingProtocols = Class.new(Rango::Informational) { STATUS ||= 101 }
-
-  # successful
-  Successful = Class.new(Rango::HttpError)
-  Error200 = OK = Class.new(Rango::Successful) { STATUS ||= 200 }
-  Error201 = Created = Class.new(Rango::Successful) { STATUS ||= 201 }
-  Error202 = Accepted = Class.new(Rango::Successful) { STATUS ||= 202 }
-  Error203 = NonAuthoritativeInformation = Class.new(Rango::Successful) { STATUS ||= 203 }
-  Error204 = NoContent = Class.new(Rango::Successful) { STATUS ||= 204 }
-  Error205 = ResetContent = Class.new(Rango::Successful) { STATUS ||= 205 }
-  Error206 = PartialContent = Class.new(Rango::Successful) { STATUS ||= 206 }
-
-  # redirection
-  Redirection = Class.new(Rango::HttpError)
-  Error300 = MultipleChoices = Class.new(Rango::Redirection) { STATUS ||= 300 }
-  Error301 = MovedPermanently = Class.new(Rango::Redirection) { STATUS ||= 301 }
-  Error302 = MovedTemporarily = Class.new(Rango::Redirection) { STATUS ||= 302 }
-  Error303 = SeeOther = Class.new(Rango::Redirection) { STATUS ||= 303 }
-  Error304 = NotModified = Class.new(Rango::Redirection) { STATUS ||= 304 }
-  Error305 = UseProxy = Class.new(Rango::Redirection) { STATUS ||= 305 }
-  Error307 = TemporaryRedirect = Class.new(Rango::Redirection) { STATUS ||= 307 }
-
-  # client error
-  ClientError = Class.new(Rango::HttpError)
-  Error400 = BadRequest = Class.new(Rango::ClientError) { STATUS ||= 400 }
-  MultiPartParseError = Class.new(Rango::BadRequest)
-  Error401 = Unauthorized = Class.new(Rango::ClientError) { STATUS ||= 401 }
-  Error402 = PaymentRequired = Class.new(Rango::ClientError) { STATUS ||= 402 }
-  Error403 = Forbidden = Class.new(Rango::ClientError) { STATUS ||= 403 }
-  Error404 = NotFound = Class.new(Rango::ClientError) { STATUS ||= 404 }
-  ActionNotFound = 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 }
-  Error408 = RequestTimeout = Class.new(Rango::ClientError) { STATUS ||= 408 }
-  Error409 = Conflict = Class.new(Rango::ClientError) { STATUS ||= 409 }
-  Error410 = Gone = Class.new(Rango::ClientError) { STATUS ||= 410 }
-  Error411 = LengthRequired = Class.new(Rango::ClientError) { STATUS ||= 411 }
-  Error412 = PreconditionFailed = Class.new(Rango::ClientError) { STATUS ||= 412 }
-  Error413 = RequestEntityTooLarge = Class.new(Rango::ClientError) { STATUS ||= 413 }
-  Error414 = RequestURITooLarge = Class.new(Rango::ClientError) { STATUS ||= 414 }
-  Error415 = UnsupportedMediaType = Class.new(Rango::ClientError) { STATUS ||= 415 }
-  Error416 = RequestRangeNotSatisfiable = Class.new(Rango::ClientError) { STATUS ||= 416 }
-  Error417 = ExpectationFailed = Class.new(Rango::ClientError) { STATUS ||= 417 }
-
-  # server error
-  ServerError = Class.new(Rango::HttpError)
-  Error500 = InternalServerError = Class.new(Rango::ServerError) { STATUS ||= 500 }
-  Error501 = NotImplemented = Class.new(Rango::ServerError) { STATUS ||= 501 }
-  Error502 = BadGateway = Class.new(Rango::ServerError) { STATUS ||= 502 }
-  Error503 = ServiceUnavailable = Class.new(Rango::ServerError) { STATUS ||= 503 }
-  Error504 = GatewayTimeout = Class.new(Rango::ServerError) { STATUS ||= 504 }
-  Error505 = HTTPVersionNotSupported = Class.new(Rango::ServerError) { STATUS ||= 505 }
+    Error300 = MultipleChoices = Class.new(Redirection)             { self.status ||= 300; self.name ||= "Multiple Choices" }
+    Error301 = MovedPermanently = Class.new(Redirection)            { self.status ||= 301; self.name ||= "Moved Permanently" }
+    Error302 = MovedTemporarily = Class.new(Redirection)            { self.status ||= 302; self.name ||= "Moved Temporarily" }
+    Error303 = SeeOther = Class.new(Redirection)                    { self.status ||= 303; self.name ||= "See Other" }
+    Error304 = NotModified = Class.new(Redirection)                 { self.status ||= 304; self.name ||= "Not Modified" }
+    Error305 = UseProxy = Class.new(Redirection)                    { self.status ||= 305; self.name ||= "Use Proxy" }
+    Error307 = TemporaryRedirect = Class.new(Redirection)           { self.status ||= 307; self.name ||= "Temporary Redirect" }
+
+    # client error
+    ClientError = Class.new(HttpError)
+    Error400 = BadRequest = Class.new(ClientError)                  { self.status ||= 400; self.name ||= "Bad Request" }
+    MultiPartParseError = Class.new(BadRequest)
+    Error401 = Unauthorized = Class.new(ClientError)                { self.status ||= 401; self.name ||= "Unauthorized" }
+    Error402 = PaymentRequired = Class.new(ClientError)             { self.status ||= 402; self.name ||= "Payment Required" }
+    Error403 = Forbidden = Class.new(ClientError)                   { self.status ||= 403; self.name ||= "Forbidden" }
+    Error404 = NotFound = Class.new(ClientError)                    { self.status ||= 404; self.name ||= "Not Found" }
+    ActionNotFound = Class.new(NotFound)
+    Error405 = MethodNotAllowed = Class.new(ClientError)            { self.status ||= 405; self.name ||= "Method Not Allowed" }
+    Error406 = NotAcceptable = Class.new(ClientError)               { self.status ||= 406; self.name ||= "Not Acceptable" }
+    Error407 = ProxyAuthenticationRequired = Class.new(ClientError) { self.status ||= 407; self.name ||= "Proxy Authentication Required" }
+    Error408 = RequestTimeout = Class.new(ClientError)              { self.status ||= 408; self.name ||= "Request Timeout" }
+    Error409 = Conflict = Class.new(ClientError)                    { self.status ||= 409; self.name ||= "Conflict" }
+    Error410 = Gone = Class.new(ClientError)                        { self.status ||= 410; self.name ||= "Gone" }
+    Error411 = LengthRequired = Class.new(ClientError)              { self.status ||= 411; self.name ||= "Length Required" }
+    Error412 = PreconditionFailed = Class.new(ClientError)          { self.status ||= 412; self.name ||= "Precondition Failed" }
+    Error413 = RequestEntityTooLarge = Class.new(ClientError)       { self.status ||= 413; self.name ||= "Request Entity Too Large" }
+    Error414 = RequestURITooLarge = Class.new(ClientError)          { self.status ||= 414; self.name ||= "Request URI Too Large" }
+    Error415 = UnsupportedMediaType = Class.new(ClientError)        { self.status ||= 415; self.name ||= "Unsupported Media Type" }
+    Error416 = RequestRangeNotSatisfiable = Class.new(ClientError)  { self.status ||= 416; self.name ||= "Request Range Not Satisfiable" }
+    Error417 = ExpectationFailed = Class.new(ClientError)           { self.status ||= 417; self.name ||= "Expectation Failed" }
+
+    # server error
+    ServerError = Class.new(HttpError)
+    Error500 = InternalServerError = Class.new(ServerError)         { self.status ||= 500; self.name ||= "Internal Server Error" }
+    Error501 = NotImplemented = Class.new(ServerError)              { self.status ||= 501; self.name ||= "Not Implemented" }
+    Error502 = BadGateway = Class.new(ServerError)                  { self.status ||= 502; self.name ||= "Bad Gateway" }
+    Error503 = ServiceUnavailable = Class.new(ServerError)          { self.status ||= 503; self.name ||= "Service Unavailable" }
+    Error504 = GatewayTimeout = Class.new(ServerError)              { self.status ||= 504; self.name ||= "Gateway Timeout" }
+    Error505 = HTTPVersionNotSupported = Class.new(ServerError)     { self.status ||= 505; self.name ||= "HTTP Version Not Supported" }
+  end
 end

data/lib/rango/helpers.rb

@@ -8,12 +8,20 @@ module Rango
     def tag(tag, content, attrs = Hash.new, &block)
       attrs, content = content, String.new if attrs.empty? && content.is_a?(Hash)
       block.call if block
-      %[<#{tag} #{attrs.to_html_attrs}>#{content}</#{tag}>]
+      %[<#{tag}#{attrs_to_html(attrs)}>#{content}</#{tag}>]
     end
 
     # @since 0.0.2
     def single_tag(tag, attrs = Hash.new)
-      %[<#{tag} #{attrs.to_html_attrs} />]
+      %[<#{tag}#{attrs_to_html(attrs)} />]
+    end
+
+    private
+    def attrs_to_html(attrs)
+      attrs.inject(String.new) do |result, pair|
+        key, value = pair
+        result += " #{key}='#{value}'"
+      end
     end
   end
 end

data/lib/rango/mailer.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require "net/smtp"
+
+# Mailer.new("noreply@rangoproject.org", "RangoProject.org")
+#  self.to = "tony@example.com"
+#  self.subject = "Just hey"
+#  self.body = "Hey Tony, what's up?"
+# end
+module Rango
+  class Mailer
+    @@config = {smtp: ["localhost", 25]}
+
+    def self.mail(options = Hash.new)
+      self.new(options[:from]).tap do |mailer|
+        mailer.body = options[:body]
+      end
+    end
+
+    attr_accessor :to, :to_alias
+    attr_accessor :from, :from_alias
+    attr_accessor :body, :subject
+
+    def initialize(from, from_alias = from, &block)
+      @from, @from_alias = from, from_alias
+      unless block.nil?
+        block.instance_eval(&block)
+        block.send
+      end
+    end
+
+    def raw
+      <<-EOF
+From: #{from_alias} <#{from}>
+To: #{to_alias} <#{to}>
+Subject: #{subject}
+
+#{body}
+      EOF
+    end
+
+    def send(to)
+      Net::SMTP.start(*@@config[:smtp]) do |smtp|
+        smtp.send_message(self.raw, @from, to)
+      end
+    end
+  end
+end

data/lib/rango/mixins/action_args.rb

@@ -10,11 +10,9 @@
 # => [[:req, :name], [:opt, :params], [:rest, :args]]
 
 if RUBY_VERSION < "1.9.2"
-  begin
-    require "methopara"
-  rescue LoadError
-    raise LoadError, "Method#parameters is part of Ruby 1.9.2 and higher. If you want to use this feature with Ruby 1.9.1, you have to install methopara gem (http://github.com/genki/methopara)"
-  end
+  raise <<-EOF
+Method#parameters is a part of Ruby 1.9.2 and higher, you can't use it with Ruby #{RUBY_VERSION}.
+  EOF
 end
 
 module Rango
@@ -41,8 +39,8 @@ module Rango
       view.parameters.each do |type, name|
         args.push(self.params[name]) if type.eql?(:req) || (type.eql?(:opt) && !self.params[name].nil?) # this is a bit complex, but we have to do because of rewriting optional args by nil value if we use just map with params[name]
       end
-      puts "Rendering #{self}##{action} with #{args.map(&:inspect).join(", ")}"
-      self.send(action, *args)
+      puts "Rendering #{self.class}##{action} with #{args.map(&:inspect).join(", ")}"
+      self.response.body = self.send(action, *args)
     end
   end
 end

data/lib/rango/mixins/filters.rb

@@ -7,18 +7,18 @@ module Rango
     end
 
     # for Rango::Controller
-    def process_action(method)
-      self.run_filters(:before, method)
-      super(method)
-      self.run_filters(:after, method)
+    def invoke_action(action)
+      self.run_filters(:before, action)
+      super(action)
+      self.run_filters(:after, action)
     end
 
     # @since 0.0.2
-    def run_filters(name, method)
+    def run_filters(name, action)
       # Rango.logger.debug(self.class.instance_variables)
-      # #Rango.logger.inspect(name: name, method: method)
+      # Rango.logger.inspect(name: name, action: action)
       self.class.get_filters(name).each do |filter_method, options|
-        unless options[:except] && options[:except].include?(method)
+        unless options[:except] && options[:except].include?(action)
           if filter_method.is_a?(Symbol) && self.respond_to?(filter_method)
             Rango.logger.info("Calling filter #{filter_method} for controller #{self}")
             self.send(filter_method)
@@ -33,23 +33,27 @@ module Rango
     end
 
     module ClassMethods
-      #def inherited(subclass)
-      #  subclass.before_filters = self.before_filters.dup
-      #  subclass.after_filters  = self.after_filters.dup
-      #end
+      # If you are using your own inherited hook, you have
+      # to use super here, otherwise your filters won't work!
+      def inherited(subclass)
+        subclass.before_filters.replace(self.before_filters)
+        subclass.after_filters.replace(self.after_filters)
+      end
 
       # @since 0.2
+      # we can't use class variables because they
+      # are shared between parent and child classes
       def before_filters
-        @@before_filters ||= Hash.new
+        @before_filters ||= Hash.new
       end
 
       # @since 0.2
       def after_filters
-        @@after_filters ||= Hash.new
+        @after_filters ||= Hash.new
       end
 
       # before :login
-      # before :login, actions: [:send]
+      # before :login, except: [:send]
       # @since 0.0.2
       def before(action = nil, options = Hash.new, &block)
         self.before_filters[action || block] = options

data/lib/rango/mixins/message.rb

@@ -1,44 +1,50 @@
 # encoding: utf-8
 
+require "rango/mixins/chainable"
+
 module Rango
   module MessageMixin
     # The rails-style flash messages
     # @since 0.0.2
     # NOTE: it's important to include this mixin after ImplicitRendering mixin
     def self.included(controller)
+      unless controller.method_defined?(:request)
+        raise "Rango::MessageMixin requires method request to be defined"
+      end
       if controller.method_defined?(:context)
+        Rango.logger.debug("Extending context by message")
         controller.class_eval do
-          def context
-            @context ||= super.merge!(message: self.message)
+          extend Chainable
+          chainable do
+            def context
+              super.merge!(message: self.message)
+            end
+
+            def redirect(uri, status = 301, options = Hash.new)
+              status, options = 301, status if status.is_a?(Hash)
+              if options.respond_to?(:inject)
+                # redirect "/post", error: "Try again"
+                # ?msg[error]="Try again"
+                uri = options.inject(uri) do |uri, pair|
+                  type, message = pair
+                  uri + "?msg[#{type}]=#{message}"
+                end
+              else
+                # redirect "/post", "Try again"
+                # ?msg="Try again"
+                uri.concat("?msg=#{options}")
+              end
+              super(uri, status)
+            end
           end
         end
+      else
+        Rango.logger.warn("Context method isn't defined")
       end
     end
 
     def message
       @message ||= (request.GET[:msg] || Hash.new)
     end
-
-    # @since 0.0.2
-    def redirect(url, options = Hash.new)
-      url = [self.request.base_url.chomp("/"), url].join("/").chomp("/") unless url.match(/^http/)
-
-      if options.respond_to?(:inject)
-        # redirect "/post", error: "Try again"
-        # ?msg[error]="Try again"
-        url = options.inject(url) do |url, pair|
-          type, message = pair
-          url + "?msg[#{type}]=#{message}"
-        end
-      else
-        # redirect "/post", "Try again"
-        # ?msg="Try again"
-        url.concat("?msg=#{options}")
-      end
-
-      self.status = 302
-      self.headers["Location"] = URI.escape(url)
-      return String.new
-    end
   end
 end