RubyGems - manveru-innate - Versions diffs - 2009.02.06 - Mend

manveru-innate 2009.02.06

Files changed (101) hide show

data/CHANGELOG +1409 -0
data/COPYING +18 -0
data/MANIFEST +100 -0
data/README.md +485 -0
data/Rakefile +139 -0
data/example/app/retro_games.rb +57 -0
data/example/app/whywiki_erb/layout/wiki.html.erb +15 -0
data/example/app/whywiki_erb/spec/wiki.rb +19 -0
data/example/app/whywiki_erb/start.rb +45 -0
data/example/app/whywiki_erb/view/edit.html.erb +6 -0
data/example/app/whywiki_erb/view/index.html.erb +10 -0
data/example/custom_middleware.rb +43 -0
data/example/error_handling.rb +31 -0
data/example/hello.rb +12 -0
data/example/howto_spec.rb +60 -0
data/example/link.rb +35 -0
data/example/providing_hash.rb +46 -0
data/example/session.rb +42 -0
data/innate.gemspec +118 -0
data/lib/innate.rb +191 -0
data/lib/innate/action.rb +156 -0
data/lib/innate/adapter.rb +89 -0
data/lib/innate/cache.rb +117 -0
data/lib/innate/cache/api.rb +106 -0
data/lib/innate/cache/drb.rb +58 -0
data/lib/innate/cache/file_based.rb +39 -0
data/lib/innate/cache/marshal.rb +17 -0
data/lib/innate/cache/memory.rb +22 -0
data/lib/innate/cache/yaml.rb +17 -0
data/lib/innate/core_compatibility/basic_object.rb +9 -0
data/lib/innate/core_compatibility/string.rb +3 -0
data/lib/innate/current.rb +37 -0
data/lib/innate/dynamap.rb +81 -0
data/lib/innate/helper.rb +195 -0
data/lib/innate/helper/aspect.rb +62 -0
data/lib/innate/helper/cgi.rb +39 -0
data/lib/innate/helper/flash.rb +36 -0
data/lib/innate/helper/link.rb +55 -0
data/lib/innate/helper/partial.rb +90 -0
data/lib/innate/helper/redirect.rb +85 -0
data/lib/innate/helper/send_file.rb +18 -0
data/lib/innate/log.rb +23 -0
data/lib/innate/log/color_formatter.rb +43 -0
data/lib/innate/log/hub.rb +72 -0
data/lib/innate/mock.rb +49 -0
data/lib/innate/node.rb +471 -0
data/lib/innate/options.rb +91 -0
data/lib/innate/options/dsl.rb +155 -0
data/lib/innate/request.rb +165 -0
data/lib/innate/response.rb +18 -0
data/lib/innate/route.rb +109 -0
data/lib/innate/session.rb +104 -0
data/lib/innate/session/flash.rb +94 -0
data/lib/innate/setup.rb +23 -0
data/lib/innate/spec.rb +42 -0
data/lib/innate/state.rb +22 -0
data/lib/innate/state/accessor.rb +130 -0
data/lib/innate/state/fiber.rb +68 -0
data/lib/innate/state/thread.rb +39 -0
data/lib/innate/traited.rb +20 -0
data/lib/innate/trinity.rb +22 -0
data/lib/innate/version.rb +3 -0
data/lib/innate/view.rb +67 -0
data/lib/innate/view/erb.rb +17 -0
data/lib/innate/view/none.rb +9 -0
data/lib/rack/middleware_compiler.rb +62 -0
data/lib/rack/reloader.rb +192 -0
data/spec/example/hello.rb +14 -0
data/spec/example/link.rb +29 -0
data/spec/helper.rb +2 -0
data/spec/innate/cache/common.rb +45 -0
data/spec/innate/cache/marshal.rb +5 -0
data/spec/innate/cache/memory.rb +5 -0
data/spec/innate/cache/yaml.rb +5 -0
data/spec/innate/dynamap.rb +22 -0
data/spec/innate/helper.rb +66 -0
data/spec/innate/helper/aspect.rb +80 -0
data/spec/innate/helper/cgi.rb +37 -0
data/spec/innate/helper/flash.rb +148 -0
data/spec/innate/helper/link.rb +82 -0
data/spec/innate/helper/partial.rb +66 -0
data/spec/innate/helper/redirect.rb +148 -0
data/spec/innate/helper/send_file.rb +21 -0
data/spec/innate/helper/view/aspect_hello.erb +1 -0
data/spec/innate/helper/view/locals.erb +1 -0
data/spec/innate/helper/view/loop.erb +4 -0
data/spec/innate/helper/view/num.erb +1 -0
data/spec/innate/helper/view/partial.erb +1 -0
data/spec/innate/helper/view/recursive.erb +8 -0
data/spec/innate/mock.rb +84 -0
data/spec/innate/node.rb +180 -0
data/spec/innate/node/bar.html +1 -0
data/spec/innate/node/foo.html.erb +1 -0
data/spec/innate/node/with_layout.erb +3 -0
data/spec/innate/options.rb +90 -0
data/spec/innate/parameter.rb +154 -0
data/spec/innate/request.rb +73 -0
data/spec/innate/route.rb +129 -0
data/spec/innate/session.rb +59 -0
data/spec/innate/traited.rb +55 -0
metadata +160 -0

data/lib/innate/helper/flash.rb ADDED Viewed

@@ -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 ADDED Viewed

@@ -0,0 +1,55 @@
+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')
+      def route(name = '/', *args)
+        hash = {}
+        hashes, names = args.partition{|arg| arg.respond_to?(:merge!) }
+        hashes.each{|to_merge| hash.merge!(to_merge) }
+        location = Innate.to(self) || Innate.to(self.class)
+        front = Array[location, name, *names].join('/').squeeze('/')
+        if hash.empty?
+          URI(front)
+        else
+          escape = Rack::Utils.method(:escape)
+          query = hash.map{|key, value| "#{escape[key]}=#{escape[value]}" }.join(';')
+          URI("#{front}?#{query}")
+        end
+      end
+      alias r route
+      # 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>'
+      def anchor(text, *args)
+        href = args.empty? ? r(text) : r(*args)
+        text = Rack::Utils.escape_html(text)
+        %(<a href="#{href}">#{text}</a>)
+      end
+      alias a anchor
+    end
+  end
+end

data/lib/innate/helper/partial.rb ADDED Viewed

@@ -0,0 +1,90 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+module Innate
+  module Helper
+    # = Helper::Partial
+    #
+    # === Example Usage
+    #
+    #   class MyController
+    #     def index
+    #     end
+    #
+    #     def list
+    #       plain = request['plain']
+    #       "Hello World from List!  Plain List == #{plain}"
+    #     end
+    #   end
+    #
+    #
+    #   <html>
+    #     <head><title>Partial Render Index</title></head>
+    #     <body>
+    #       #{render_partial(Rs(:list), 'plain' => true)}
+    #     </body>
+    #   </html>
+    module Partial
+      module_function
+      # Renders a url 'inline'.
+      #
+      # +url+      normal URL, like you'd use for redirecting.
+      # +options+  optional, will be used as request parameters.
+      #
+      # Issues a mock request to the given +url+ with +options+ turned into
+      # query arguments.
+      def render_partial(url, options = {})
+        uri = URI(url)
+        query = options # Innate::Current.request.params.merge(options)
+        uri.query = Rack::Utils.build_query(query)
+        body = nil
+        Innate::Mock.session do |session|
+          cookie = Innate::Current.session.cookie
+          session.cookie = cookie
+          body = session.get(uri.to_s, options).body
+        end
+        body
+      end
+      # Render the template file in view_root of the
+      # current controller.
+      #
+      # TODO:
+      # * the local variable hack isn't working because innate allocates a new
+      #   binding
+      #   For now one can simply use instance variables, which I prefer anyway.
+      # * Doesn't work for absolute paths, but there are no specs for that yet.
+      def render_template(path, variables = {})
+        path = path.to_s
+        ext = File.extname(path)
+        basename = File.basename(path, ext)
+        ext = ext[1..-1]
+        action = Innate::Current.action.dup
+        action.view   = action.node.find_view(basename, ext)
+        action.method = action.node.find_method(basename, action.params)
+        action.sync_variables(action)
+        action.variables.merge!(variables)
+=begin
+        variables.each do |key, value|
+          value = "ObjectSpace._id2ref(#{value.object_id})"
+          eval "#{key} = #{value}", action.binding
+        end
+=end
+        action.call
+      end
+      def render_action(method, *params)
+        render_partial(r(method), *params)
+      end
+    end
+  end
+end

data/lib/innate/helper/redirect.rb ADDED Viewed

@@ -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 = {'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/send_file.rb ADDED Viewed

@@ -0,0 +1,18 @@
+module Innate
+  module Helper
+    module SendFile
+      # Not optimally performing but convenient way to send files by their
+      # filename.
+      def send_file(filename, content_type = nil)
+        content_type ||= Rack::Mime.mime_type(::File.extname(filename))
+        response.body = ::File.readlines(filename, 'rb')
+        response['Content-Length'] = ::File.size(filename).to_s
+        response['Content-Type'] = content_type
+        response.status = 200
+        throw(:respond, response)
+      end
+    end
+  end
+end

data/lib/innate/log.rb ADDED Viewed

@@ -0,0 +1,23 @@
+require 'innate/log/hub'
+require 'innate/log/color_formatter'
+module Innate
+  logdev, *params = options.log.params
+  color = options.log.color
+  color = Logger::ColorFormatter.color?(logdev) if color.nil?
+  logger = Logger.new(logdev, *params)
+  if color
+    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 ADDED Viewed

@@ -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

data/lib/innate/log/hub.rb ADDED Viewed

@@ -0,0 +1,72 @@
+module Innate
+  # Innate only provides logging via stdlib Logger to avoid bloat and
+  # dependencies, you may specify multiple loggers in the Log instance of LogHub
+  # to accomendate your needs, by default we log to $stderr to be compatible with
+  # CGI.
+  #
+  # Please read the documentation of logger.rb (or even better, its source) to
+  # get a feeling of how to use it correctly within Innate
+  #
+  # A few shortcuts:
+  #
+  # 1. Create logger for stderr/stdout
+  #     logger = Logger.new($stdout)
+  #     logger = Logger.new($stderr)
+  #
+  # 2. Create logger for a file
+  #
+  #     logger = Logger.new('test.log')
+  #
+  # 3. Create logger for file object
+  #
+  #     file = File.open('test.log', 'a+')
+  #     logger = Logger.new(file)
+  #
+  # 4. Create logger with rotation on specified file size
+  #
+  #     # 10 files history, 5 MB each
+  #     logger = Logger.new('test.log', 10, (5 << 20))
+  #
+  #     # 100 files history, 1 MB each
+  #     logger = Logger.new('test.log', 100, (1 << 20))
+  #
+  # 5. Create a logger which ages logfiles daily/weekly/monthly
+  #
+  #     logger = Logger.new('test.log', 'daily')
+  #     logger = Logger.new('test.log', 'weekly')
+  #     logger = Logger.new('test.log', 'monthly')
+  class LogHub
+    include Logger::Severity
+    attr_accessor :loggers, :program, :active
+    # +loggers+ should be a list of Logger instances
+    def initialize(*loggers)
+      @loggers = loggers.flatten
+      @program = nil
+      @active = true
+      self.level = DEBUG
+    end
+    # set level for all loggers
+    def level=(lvl)
+      @loggers.each{|l| l.level = lvl }
+      @level = lvl
+    end
+    def start; @active = true;  end
+    def stop;  @active = false; end
+    def method_missing(meth, *args, &block)
+      eval %~
+        def #{meth}(*args, &block)
+          return unless @active
+          @loggers.each{|l| l.#{meth}(*args, &block) }
+        end
+      ~
+      send(meth, *args, &block)
+    end
+  end
+end

data/lib/innate/mock.rb ADDED Viewed

@@ -0,0 +1,49 @@
+module Innate
+  module Mock
+    HTTP_METHODS = %w[ CONNECT DELETE GET HEAD OPTIONS POST PUT TRACE ]
+    HTTP_METHODS.each do |method|
+      (class << self; self; end).
+        send(:define_method, method.downcase){|*args|
+        mock(method, *args)
+      }
+    end
+    def self.mock(method, *args)
+      mock_request.request(method, *args)
+    end
+    def self.mock_request
+      Rack::MockRequest.new(Innate)
+    end
+    def self.session
+      yield Session.new
+    end
+    class Session
+      attr_accessor :cookie
+      def initialize
+        @cookie = nil
+      end
+      HTTP_METHODS.each do |method|
+        define_method(method.downcase){|*args|
+          extract_cookie(method, *args)
+        }
+      end
+      def extract_cookie(method, path, hash = {})
+        hash['HTTP_COOKIE'] ||= @cookie if @cookie
+        response = Mock::mock(method, path, hash)
+        if cookie = response['Set-Cookie']
+          @cookie = cookie
+        end
+        response
+      end
+    end
+  end
+end