rjspotter-innate 2009.06.29

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,152 @@
+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.
+      #
+      # @example usage
+      #
+      #   render_full('/blog/article/1')
+      #   render_full('/blog/article/1', :lang => :de)
+      #
+      # Please note that you have to give the full path in the same way you'd
+      # do in a direct request with curl or a browser.
+      #
+      # @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.
+      #
+      # @example usage
+      #
+      #   render_partial(:index)
+      #   render_partial(:index, :title => :foo)
+      #
+      # Please note that you only have to supply the action name, if your
+      # action requires arguments then you have to pass a name suitable for
+      # that.
+      #
+      # @example usage with action that requires arguments
+      #
+      #   # requires two arguments
+      #   def foo(a, b)
+      #   end
+      #
+      #   # pass two suitable arguments
+      #   render_partial('foo/1/2')
+      #
+      # @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.
+      #
+      # @example usage
+      #
+      #   render_view(:index)
+      #   render_view(:index, :title => :foo)
+      #
+      # @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
+
+      # Use the given file as a template and render it in the same scope as
+      # the current action.
+      # The +filename+ may be an absolute path or relative to the process
+      # working directory.
+      #
+      # @example usage
+      #
+      #   path = '/home/manveru/example/app/todo/view/index.xhtml'
+      #   render_file(path)
+      #   render_file(path, :title => :foo)
+      #
+      # Ramaze will emit a warning if you try to render an Action without a
+      # method or view template, but will still try to render it.
+      # The usual {Action#valid?} doesn't apply here, as sometimes you just
+      # cannot have a method associated with a template.
+      #
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_file(filename, variables = {})
+        action = Action.create(:view => filename)
+        action.sync_variables(self.action)
+
+        action.node      = self.class
+        action.engine    = self.action.engine
+        action.instance  = action.node.new
+        action.variables = variables.dup
+
+        yield(action) if block_given?
+
+        valid_action = action.view || action.method
+        Log.warn("Empty action: %p" % [action]) unless valid_action
+        action.render
+      end
+
+      # @api internal
+      # @author manveru
+      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?
+
+        valid_action = action.view || action.method
+        Log.warn("Empty action: %p" % [action]) unless valid_action
+        action.render
+      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