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

manveru-innate 2009.02.06

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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