innate 2009.04

data/lib/innate/helper/cgi.rb

@@ -0,0 +1,54 @@
+autoload(:CGI, 'cgi') # in case you want to use html_unescape
+
+module Innate
+
+  # Shortcuts to some CGI methods
+
+  module Helper
+    module CGI
+      module_function
+
+      # Shortcut for Rack::Utils.escape
+      #
+      # @param [#to_s] input
+      # @return [String] URI-encoded representation of +input+
+      def url_encode(input)
+        Rack::Utils.escape(input.to_s)
+      end
+      alias u url_encode
+
+      # Shortcut for Rack::Utils.unescape
+      #
+      # @param [#to_s] input
+      # @return [String] URI-decoded representation of +input+
+      def url_decode(input)
+        Rack::Utils.unescape(input.to_s)
+      end
+
+      # Shortcut for Rack::Utils.escape_html
+      #
+      # @param [#to_s] input
+      # @return [String]
+      def html_escape(input)
+        Rack::Utils.escape_html(input.to_s)
+      end
+
+      # Shortcut for CGI.unescapeHTML
+      #
+      # @param [#to_s] input
+      # @return [String]
+      def html_unescape(input)
+        ::CGI.unescapeHTML(input.to_s)
+      end
+
+      # safely escape all HTML and code
+      def html_and_code_escape(input)
+        Rack::Utils.escape_html(input.to_s).gsub(/#([{@$]@?)/, '#\1')
+      end
+      alias h html_and_code_escape
+
+      # aliases are ignored by module_function...
+      module_function :u, :h
+    end
+  end
+end

data/lib/innate/helper/flash.rb

@@ -0,0 +1,36 @@
+module Innate
+  module Helper
+    # Simple access to session.flash.
+    #
+    # Flash is a mechanism using sessions to provide a rotating holder of
+    # key/value pairs.
+    #
+    # Every request that is made will rotate one step, dropping contents stored
+    # two requests ago.
+    #
+    # The purpose of this class is to provide an easy way of setting/retrieving
+    # from the current flash.
+    #
+    # Flash is a way to keep a temporary pairs of keys and values for the duration
+    # of two requests, the current and following.
+    #
+    # Very vague Example:
+    #
+    # On the first request, for example on registering:
+    #
+    #   flash[:error] = "You should reconsider your username, it's taken already"
+    #   redirect R(self, :register)
+    #
+    # This is the request from the redirect:
+    #
+    #   do_stuff if flash[:error]
+    #
+    # On the request after this, flash[:error] is gone.
+    module Flash
+      # Just for convenience
+      def flash
+        session.flash
+      end
+    end
+  end
+end

data/lib/innate/helper/link.rb

@@ -0,0 +1,94 @@
+module Innate
+  module Helper
+    module Link
+      def self.included(into)
+        into.extend(self)
+      end
+
+      # Provide the path to given Node and actions.
+      # Escapes GET parameters.
+      #
+      # Usage, mapping is Pages => '/', Users => '/users':
+      #
+      #   Pages.r                       # => URI('/')
+      #   Pages.r(:foo)                 # => URI('/foo')
+      #   Pages.r(:foo, :bar)           # => URI('/foo/bar')
+      #   Pages.r(:foo, :a => :b)       # => URI('/foo?a=b')
+      #   Pages.r(:foo, :bar, :a => :b) # => URI('/foo/bar?a=b')
+      #
+      #   Users.r                       # => URI('/users/')
+      #   Users.r(:foo)                 # => URI('/users/foo')
+      #   Users.r(:foo, :bar)           # => URI('/users/foo/bar')
+      #   Users.r(:foo, :a => :b)       # => URI('/users/foo?a=b')
+      #   Users.r(:foo, :bar, :a => :b) # => URI('/users/foo/bar?a=b')
+      #
+      # @return [URI] to the location
+      def route(name = '/', *args)
+        hash = {}
+        hashes, names = args.partition{|arg| arg.respond_to?(:merge!) }
+        hashes.each{|to_merge| hash.merge!(to_merge) }
+
+        escape = Rack::Utils.method(:escape)
+        location = route_location(self)
+        front = Array[location, name, *names.map{|n| escape[n]}].join('/').squeeze('/')
+
+        return URI(front) if hash.empty?
+
+        query = hash.map{|k, v| "#{escape[k]}=#{escape[v]}" }.join(';')
+        URI("#{front}?#{query}")
+      end
+      alias r route
+
+      def route_location(klass)
+        prefix = Innate.options.prefix
+        location = Innate.to(klass) || Innate.to(klass.class)
+        [prefix, location].join('/')
+      end
+
+      # Create a route to the currently active Node.
+      #
+      # This method is mostly here in case you include this helper elsewhere
+      # and don't want (or can't) type SomeNode.r all the time.
+      #
+      # The usage is identical with {route}.
+      #
+      # @param [#to_s] name
+      # @return [URI] to the location
+      # @see Ramaze::Helper::Link#route
+      # @author manveru
+      def route_self(name = '/', *args)
+        Current.action.node.route(name, *args)
+      end
+      alias rs route_self
+
+      # Create a link tag
+      #
+      # Usage, given Wiki is mapped to `/wiki`:
+      #
+      #   Wiki.a(:home)                   # => '<a href="/wiki/home">home</a>'
+      #   Wiki.a('home', :home)           # => '<a href="/wiki/home">home</a>'
+      #   Wiki.a('home', :/)              # => '<a href="/wiki/">home</a>'
+      #   Wiki.a('foo', :/, :foo => :bar) # => '<a href="/wiki/?foo=bar">foo</a>'
+      #   Wiki.a('example', 'http://example.com')
+      #   # => '<a href="http://example.com">example</a>'
+      #
+      # @return [String]
+      def anchor(text, *args)
+        case first = (args.first || text)
+        when URI
+          href = first.to_s
+        when /^\w+:\/\//
+          uri = URI(first)
+          uri.query = Rack::Utils.escape_html(uri.query)
+          href = uri.to_s
+        else
+          href = args.empty? ? r(text) : r(*args)
+        end
+
+        text = Rack::Utils.escape_html(text)
+        %(<a href="#{href}">#{text}</a>)
+      end
+      alias a anchor
+    end
+  end
+end

data/lib/innate/helper/redirect.rb

@@ -0,0 +1,85 @@
+module Innate
+  module Helper
+    module Redirect
+      def respond(body, status = 200, header = {})
+        response.write body
+        response.status = status
+        header['Content-Type'] ||= 'text/html'
+        header.each{|k,v| response[k] = v }
+
+        throw(:respond, response)
+      end
+
+      def respond!(body, status = 200, header = {})
+        header['Content-Type'] ||= 'text/html'
+        throw(:respond, Response.new(body, status, header))
+      end
+
+      # +target+ should be anything responding to #to_s.
+      # To check or modify the URI the redirect will go to you may pass a
+      # block, the result value of the block is ignored:
+      #
+      #   redirect("/"){|uri| uri.scheme = 'http' }
+      #   redirect("/"){|uri| uri.host = 'secure.com' if uri.scheme =~ /s/ }
+      #
+      # +options+ may contain:
+      #
+      #   :scheme => "http" | "https" | "ftp" | ...
+      #   :host   => "localhost" | "foo.com" | "123.123.123.123" | ...
+      #   :port   => 7000 | "80" | 80 | ...
+      #
+      #   :status => 302 | 300 | 303 | ...
+      #   :body   => "This is a redirect, hold on while we teleport" | ...
+      #
+      #   :raw!   => true | false | nil | ...
+      #
+      # Note that all options are optional and you may just pass a +target+.
+
+      def redirect(target, options = {})
+        target = target.to_s
+
+        case target
+        when /^http/, /^\//
+          uri = URI(target)
+        else
+          uri = URI("/#{target}")
+        end
+
+        uri.scheme ||= options[:scheme] || request.scheme
+        uri.host   ||= options[:host]   || request.host
+        uri.port   ||= options[:port]   || request.port
+
+        uri = URI(uri.to_s)
+
+        yield(uri) if block_given?
+
+        raw_redirect(uri, options)
+      end
+
+      def raw_redirect(target, options = {}, &block)
+        header = response.header.merge('Location' => target.to_s)
+        status = options[:status] || 302
+        body   = options[:body] || redirect_body(target)
+
+        Log.debug "Redirect to: #{target}"
+        throw(:redirect, Response.new(body, status, header, &block))
+      end
+
+      def redirect_body(target)
+        "You are being redirected, please follow this link to: " +
+          "<a href='#{target}'>#{h target}</a>!"
+      end
+
+      def redirect_referrer(fallback = '/')
+        if referer = request.referer and url = request.url
+          referer_uri, request_uri = URI(referer), URI(url)
+
+          redirect(referer) unless referer_uri == request_uri
+        end
+
+        redirect(fallback)
+      end
+      alias redirect_referer redirect_referrer
+    end
+  end
+end

data/lib/innate/helper/render.rb

@@ -0,0 +1,87 @@
+module Innate
+  module Helper
+    module Render
+      # Enables you to simply call:
+      #
+      # @example of added functionality
+      #   YourController.render_partial(:foo, :x => 42)
+      #
+      def self.included(into)
+        into.extend(self)
+      end
+
+      # Renders the full action in the way a real request would.
+      #
+      # Please be aware that, if this is the first request from a client, you
+      # will not have access to the session in the action being rendered, as no
+      # actual session has been put into place yet.
+      #
+      # It should work as expected on any subsequent requests.
+      #
+      # As usual, patches welcome.
+      #
+      # @api external
+      # @see Mock.session
+      # @author manveru
+      def render_full(path, query = {})
+        uri = URI(path.to_s)
+        uri.query = Rack::Utils.build_query(query)
+
+        if cookie = request.env['HTTP_COOKIE']
+          Mock.session do |mock|
+            mock.cookie = cookie
+            return mock.get(uri.to_s).body
+          end
+        else
+          Mock.get(uri.to_s).body
+        end
+      end
+
+      # Renders an action without any layout.
+      # You can further tweak the action to be rendered by passing a block.
+      #
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_partial(action_name, variables = {})
+        render_custom(action_name, variables) do |action|
+          action.layout = nil
+          yield(action) if block_given?
+        end
+      end
+
+      # Renders an action view, doesn't execute any methods and won't wrap it
+      # into a layout.
+      # You can further tweak the action to be rendered by passing a block.
+      #
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_view(action_name, variables = {})
+        render_custom(action_name, variables) do |action|
+          action.layout = nil
+          action.method = nil
+          yield(action) if block_given?
+        end
+      end
+
+      def render_custom(action_name, variables = {})
+        unless action = resolve(action_name.to_s)
+          raise(ArgumentError, "No Action %p on #{self}" % action_name)
+        end
+
+        action.sync_variables(self.action)
+        action.instance = action.node.new
+        action.variables = action.variables.merge(variables)
+
+        yield(action) if block_given?
+
+        if action.valid?
+          action.render
+        else
+          Log.warn("Invalid action: %p" % action)
+        end
+      end
+    end
+  end
+end

data/lib/innate/helper/send_file.rb

@@ -0,0 +1,26 @@
+module Innate
+  module Helper
+    module SendFile
+      # Not optimally performing but convenient way to send files by their
+      # filename.
+      #
+      # I think we should remove this from the default helpers and move it into
+      # Ramaze, the functionality is almost never used, the naming is ambigous,
+      # and it doesn't use the send_file capabilities of frontend servers.
+      #
+      # So for now, I'll mark it for deprecation
+      def send_file(filename, content_type = nil, content_disposition = nil)
+        content_type ||= Rack::Mime.mime_type(::File.extname(filename))
+        content_disposition ||= File.basename(filename)
+
+        response.body = ::File.readlines(filename, 'rb')
+        response['Content-Length'] = ::File.size(filename).to_s
+        response['Content-Type'] = content_type
+        response['Content-Disposition'] = content_disposition
+        response.status = 200
+
+        throw(:respond, response)
+      end
+    end
+  end
+end

data/lib/innate/log.rb

@@ -0,0 +1,20 @@
+require 'innate/log/hub'
+require 'innate/log/color_formatter'
+
+module Innate
+  logdev = $stderr
+  logger = Logger.new(logdev)
+
+  if Logger::ColorFormatter.color?(logdev)
+    begin
+      require 'win32console' if RUBY_PLATFORM =~ /win32/i
+
+      logger.formatter = Logger::ColorFormatter.new
+
+    rescue LoadError
+      logger.debug "For colors on windows, please `gem install win32console`"
+    end
+  end
+
+  Log = LogHub.new(logger)
+end

data/lib/innate/log/color_formatter.rb

@@ -0,0 +1,43 @@
+class Logger
+  # Extended Formatter that supports ANSI colors.
+  class ColorFormatter < Formatter
+    LEVEL_COLOR = {
+      'DEBUG'   => :blue,
+      'INFO'    => :white,
+      'WARN'    => :yellow,
+      'ERROR'   => :red,
+      'FATAL'   => :red,
+      'UNKNOWN' => :green,
+    }
+
+    COLOR_CODE = {
+      :reset => 0, :bold => 1, :dark => 2, :underline => 4, :blink => 5,
+      :negative => 7, :black => 30, :red => 31, :green => 32, :yellow => 33,
+      :blue => 34, :magenta => 35, :cyan => 36, :white => 37,
+    }
+
+    FORMAT_TIME = "%Y-%m-%d %H:%M:%S"
+    FORMAT_LINE = "%s [%s $%d] %5s | %s: %s\n"
+
+    def call(severity, time, program, message)
+      hint = severity[0,1]
+      time = format_time(time)
+      pid = $$
+      string = colorize(msg2str(message), severity)
+
+      FORMAT_LINE % [hint, time, pid, severity, program, string]
+    end
+
+    def format_time(time)
+      time.strftime(FORMAT_TIME)
+    end
+
+    def colorize(string, severity)
+      "\e[#{COLOR_CODE[LEVEL_COLOR[severity]]}m#{string}\e[0m"
+    end
+
+    def self.color?(logdev)
+      logdev.respond_to?(:tty?) and logdev.tty?
+    end
+  end
+end