manveru-innate 2009.02.21 → 2009.02.25

data/lib/innate.rb

@@ -59,81 +59,59 @@ module Innate
 
   extend Trinity
 
-  # This constant holds a couple of common middlewares and allows for easy
-  # addition of new ones.
-  # The Proc to use is determined by the value of options.mode.
-  # The Proc value is passed to setup_middleware if no block is given to
-  # Innate::start.
-  #
-  # A quick overview over the middleware used here:
-  #
-  #   * Rack::CommonLogger
-  #     Logs a line in Apache common log format or <tt>rack.errors</tt>.
-  #
-  #   * Rack::ShowExceptions
-  #     Catches all exceptions raised from the app it wraps. It shows a useful
-  #     backtrace with the sourcefile and clickable context, the whole Rack
-  #     environment and the request data.
-  #     Be careful when you use this on public-facing sites as it could reveal
-  #     information helpful to attackers.
-  #
-  #   * Rack::ShowStatus
-  #     Catches all empty responses the app it wraps and replaces them with a
-  #     site explaining the error.
-  #     Additional details can be put into <tt>rack.showstatus.detail</tt> and
-  #     will be shown as HTML. If such details exist, the error page is always
-  #     rendered, even if the reply was not empty.
-  #
-  #   * Rack::ConditionalGet
-  #     Middleware that enables conditional GET using If-None-Match and
-  #     If-Modified-Since. The application should set either or both of the
-  #     Last-Modified or Etag response headers according to RFC 2616. When
-  #     either of the conditions is met, the response body is set to be zero
-  #     length and the response status is set to 304 Not Modified.
-  #
-  #   * Rack::Head
-  #     Removes the body of the response for HEAD requests.
-  #
-  #   * Rack::Reloader
-  #     Pure ruby source reloader, runs on every request with a configurable
-  #     cooldown period.
-  #
-  #   * Rack::Lint
-  #     Rack::Lint validates your application and the requests and responses
-  #     according to the Rack spec.
-  #
-  # Note that `m.innate` takes away most of the boring part and leaves it up to
-  # you to select your middleware in your application.
-  #
-  # `m.innate` expands to:
-  #
-  #   use Rack::Cascade.new([
-  #     Rack::File.new('public'),
-  #     Innate::Current.new(
-  #       Rack::Cascade.new([
-  #         Innate::Rewrite.new(Innate::DynaMap),
-  #         Innate::Route.new(Innate::DynaMap)])))
-  #
-  # @see Rack::MiddlewareCompiler
-  MIDDLEWARE = {
-    :dev => lambda{|m|
-      m.use(Rack::Lint, Rack::CommonLogger, Rack::ShowExceptions,
-            Rack::ShowStatus, Rack::ConditionalGet, Rack::Head, Rack::Reloader)
-      m.innate },
-    :live => lambda{|m|
-      m.use(Rack::CommonLogger, Rack::ShowStatus, Rack::ConditionalGet,
-            Rack::Head)
-      m.innate }
-  }
-
+  # Contains all the module functions for Innate, we keep them in a module so
+  # Ramaze can simply use them as well.
   module SingletonMethods
-    def start(parameter = {}, &block)
-      options[:app][:root] = go_figure_root(parameter, caller)
-      parameter.reject!{|k, v| [:root, :file].include?(k) }
-      options.merge!(parameter)
+    # The method that starts the whole business.
+    #
+    # Call Innate.start after you defined your application.
+    #
+    # Usually, this is a blocking call and will not return until the adapter
+    # has finished, which usually happens when you kill the application or hit
+    # ^C.
+    #
+    # We do return if options.started is true, which indicates that all you
+    # wanted to do is setup the environment and update options.
+    #
+    # @usage
+    #
+    #   # passing options
+    #   Innate.start :adapter => :mongrel, :mode => :live
+    #
+    #   # defining custom middleware
+    #   Innate.start do |m|
+    #     m.innate
+    #   end
+    #
+    # @return [nil] if options.started is true
+    # @yield [MiddlewareCompiler]
+    # @param [Proc] block will be passed to {middleware!}
+    #
+    # @option param :host    [String]  ('0.0.0.0')
+    #   IP address or hostname that we respond to - 0.0.0.0 for all
+    # @option param :port    [Fixnum]  (7000)
+    #   Port for the server
+    # @option param :started [boolean] (false)
+    #   Indicate that calls Innate::start will be ignored
+    # @option param :adapter [Symbol]  (:webrick)
+    #   Web server to run on
+    # @option param :setup   [Array]   ([Innate::Cache, Innate::Node])
+    #   Will send ::setup to each element during Innate::start
+    # @option param :header  [Hash]    ({'Content-Type' => 'text/html'})
+    #   Headers that will be merged into the response before Node::call
+    # @option param :trap    [String]  ('SIGINT')
+    #   Trap this signal to issue shutdown, nil/false to disable trap
+    # @option param :state   [Symbol]  (:Fiber)
+    #   Keep state in Thread or Fiber, fall back to Thread if Fiber not available
+    # @option param :mode    [Symbol]  (:dev)
+    #   Indicates which default middleware to use, (:dev|:live)
+    def start(param = {}, &block)
+      options[:app][:root] = go_figure_root(param, caller)
+      param.reject!{|k, v| [:root, :file].include?(k) }
+      options.merge!(param)
 
       setup_dependencies
-      setup_middleware(&block)
+      middleware!(options.mode, &block) if block_given?
 
       return if options.started
       options.started = true
@@ -144,53 +122,42 @@ module Innate
     end
 
     def start!(options = Innate.options)
-      Adapter.start(middleware(:innate), options)
+      Adapter.start(middleware(options.mode), options)
     end
 
     def stop(wait = 3)
-      Log.info("Shutdown Innate within #{wait} seconds")
+      Log.info("Shutdown within #{wait} seconds")
       Timeout.timeout(wait){ exit }
     ensure
       exit!
     end
 
-    def middleware(name, &block)
-      Rack::MiddlewareCompiler.build(name, &block)
-    end
-
-    def middleware!(name, &block)
-      Rack::MiddlewareCompiler.build!(name, &block)
-    end
-
-    def middleware_recompile(name = :innate)
-      Rack::MiddlewareCompiler::COMPILED[name].compile!
-    end
-
     def setup_dependencies
       options[:setup].each{|obj| obj.setup }
     end
 
-    # Set the default middleware for applications.
-    def setup_middleware(force = false, &block)
-      mode = options.mode
-      block ||= MIDDLEWARE[mode]
-      raise("No Middleware for mode: %p found" % mode) unless block
-
-      force ? middleware!(:innate, &block) : middleware(:innate, &block)
+    # Treat Innate like a rack application, pass the rack +env+ and optionally
+    # the +mode+ the application runs in.
+    #
+    # @param [Hash] env rack env
+    # @param [Symbol] mode indicates the mode of the application
+    # @default mode options.mode
+    # @return [Array] with [body, header, status]
+    # @author manveru
+    def call(env, mode = options.mode)
+      middleware(mode).call(env)
     end
 
-    # Pass the +env+ to this method and it will be sent to the appropriate
-    # middleware called +mw+.
-    # Tries to avoid recursion.
-
-    def call(env, mw = :innate)
-      this_file = File.expand_path(__FILE__)
-      count = 0
-      caller_lines(caller){|f, l, m| count += 1 if f == this_file }
+    def middleware(mode, &block)
+      Rack::MiddlewareCompiler.build(mode, &block)
+    end
 
-      raise("Recursive loop in Innate::call") if count > 10
+    def middleware!(mode, &block)
+      Rack::MiddlewareCompiler.build!(mode, &block)
+    end
 
-      middleware(mw).call(env)
+    def middleware_recompile(mode = options.mode)
+      Rack::MiddlewareCompiler::COMPILED[mode].compile!
     end
 
     # Innate can be started by:
@@ -203,7 +170,6 @@ module Innate
     #
     # TODO: better documentation and nice defaults, don't want to rely on a
     #       filename, bad mojo.
-
     def go_figure_root(options, backtrace)
       if o_file = options[:file]
         return File.dirname(o_file)
@@ -240,4 +206,71 @@ module Innate
   end
 
   extend SingletonMethods
+
+  # This sets up the default modes.
+  # The Proc to use is determined by the value of options.mode.
+  # The Proc value is passed to setup_middleware if no block is given to
+  # Innate::start.
+  #
+  # A quick overview over the middleware used here:
+  #
+  #   * Rack::CommonLogger
+  #     Logs a line in Apache common log format or <tt>rack.errors</tt>.
+  #
+  #   * Rack::ShowExceptions
+  #     Catches all exceptions raised from the app it wraps. It shows a useful
+  #     backtrace with the sourcefile and clickable context, the whole Rack
+  #     environment and the request data.
+  #     Be careful when you use this on public-facing sites as it could reveal
+  #     information helpful to attackers.
+  #
+  #   * Rack::ShowStatus
+  #     Catches all empty responses the app it wraps and replaces them with a
+  #     site explaining the error.
+  #     Additional details can be put into <tt>rack.showstatus.detail</tt> and
+  #     will be shown as HTML. If such details exist, the error page is always
+  #     rendered, even if the reply was not empty.
+  #
+  #   * Rack::ConditionalGet
+  #     Middleware that enables conditional GET using If-None-Match and
+  #     If-Modified-Since. The application should set either or both of the
+  #     Last-Modified or Etag response headers according to RFC 2616. When
+  #     either of the conditions is met, the response body is set to be zero
+  #     length and the response status is set to 304 Not Modified.
+  #
+  #   * Rack::Head
+  #     Removes the body of the response for HEAD requests.
+  #
+  #   * Rack::Reloader
+  #     Pure ruby source reloader, runs on every request with a configurable
+  #     cooldown period.
+  #
+  #   * Rack::Lint
+  #     Rack::Lint validates your application and the requests and responses
+  #     according to the Rack spec.
+  #
+  # Note that `m.innate` takes away most of the boring part and leaves it up to
+  # you to select your middleware in your application.
+  #
+  # `m.innate` expands to:
+  #
+  #   use Rack::Cascade.new([
+  #     Rack::File.new('public'),
+  #     Innate::Current.new(
+  #       Rack::Cascade.new([
+  #         Innate::Rewrite.new(Innate::DynaMap),
+  #         Innate::Route.new(Innate::DynaMap)])))
+  #
+  # @see Rack::MiddlewareCompiler
+  middleware :dev do |m|
+    m.use(Rack::Lint, Rack::CommonLogger, Rack::ShowExceptions,
+          Rack::ShowStatus, Rack::ConditionalGet, Rack::Head, Rack::Reloader)
+    m.innate
+  end
+
+  middleware :live do |m|
+    m.use(Rack::CommonLogger, Rack::ShowStatus, Rack::ConditionalGet,
+          Rack::Head)
+    m.innate
+  end
 end

data/spec/example/hello.rb

@@ -1,5 +1,4 @@
 require 'spec/helper'
-
 require 'example/hello'
 
 describe 'example/hello' do

data/spec/example/link.rb

@@ -5,21 +5,17 @@ describe 'example/link' do
   behaves_like :mock
 
   should 'have index on Linking' do
-    get('/').body.should == 'simple link<br /><a href="/help">Help?</a>'
-  end
-
-  should 'have new on Linking' do
-    get('/new').body.should == 'Something new!'
+    get('/').body.should == 'Index links to <a href="/help">Help?</a>'
   end
 
   should 'have help on Linking' do
     get('/help').body.should ==
-      "You have help<br /><a href=\"/link_to/another\">A Different Node</a>"
+      "Help links to <a href=\"/link_to/another\">A Different Node</a>"
   end
 
   should 'have another on Different' do
     get('/link_to/another').body.
-      should == "<a href=\"/link_to/and/deeper\">Even deeper</a>"
+      should == "<a href=\"/link_to/and/deeper\">Another links even deeper</a>"
   end
 
   should 'have and__deeper on Different' do

data/spec/example/session.rb

@@ -0,0 +1,28 @@
+require 'spec/helper'
+require 'example/session'
+
+describe 'example/session' do
+  behaves_like :session
+
+  it 'starts at 0' do
+    session do |mock|
+      mock.get('/').should =~ /Value is: 0/
+    end
+  end
+
+  it 'increments the counter' do
+    session do |mock|
+      mock.get('/increment').should =~ /Value is: 1/
+      mock.get('/increment').should =~ /Value is: 2/
+      mock.get('/increment').should =~ /Value is: 3/
+    end
+  end
+
+  it 'decrements the counter' do
+    session do |mock|
+      mock.get('/decrement').should =~ /Value is: -1/
+      mock.get('/decrement').should =~ /Value is: -2/
+      mock.get('/decrement').should =~ /Value is: -3/
+    end
+  end
+end

data/spec/innate/helper/redirect.rb

@@ -1,7 +1,7 @@
 require 'spec/helper'
 
 class SpecRedirectHelper
-  include Innate::Node
+  Innate.node '/'
 
   def index
     self.class.name
@@ -59,9 +59,6 @@ class SpecRedirectHelper
   end
 end
 
-Innate.setup_dependencies
-Innate.setup_middleware
-
 describe Innate::Helper::Redirect do
   behaves_like :mock
 

data/spec/innate/node/only_view.html

@@ -0,0 +1 @@
+Only template

data/spec/innate/node.rb

@@ -206,6 +206,18 @@ describe 'Innate::Node' do
     got.body.should == 'No action found at: "/bar"'
   end
 
+  should 'get an action view if there is no method' do
+    got = Innate::Mock.get('/provide_template/only_view')
+    got.status.should == 200
+    got.body.strip.should == "Only template"
+  end
+
+  should 'not get an action view with params if there is no method' do
+    got = Innate::Mock.get('/provide_template/only_view/param')
+    got.status.should == 404
+    got.body.strip.should == 'No action found at: "/only_view/param"'
+  end
+
   should 'use alias_view' do
     assert_wish('/alias_view/aliased', "<h1>Hello, World!</h1>", 'text/html')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: manveru-innate
 version: !ruby/object:Gem::Version 
-  version: 2009.02.21
+  version: 2009.02.25
 platform: ruby
 authors: 
 - Michael 'manveru' Fellinger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-13 00:00:00 -08:00
+date: 2009-02-25 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,17 +37,19 @@ files:
 - README.md
 - Rakefile
 - example/app/retro_games.rb
+- example/app/todo/layout/default.erb
+- example/app/todo/spec/todo.rb
+- example/app/todo/start.rb
+- example/app/todo/view/index.erb
 - example/app/whywiki_erb/layout/wiki.html.erb
 - example/app/whywiki_erb/spec/wiki.rb
 - example/app/whywiki_erb/start.rb
 - example/app/whywiki_erb/view/edit.html.erb
 - example/app/whywiki_erb/view/index.html.erb
 - example/custom_middleware.rb
-- example/error_handling.rb
 - example/hello.rb
 - example/howto_spec.rb
 - example/link.rb
-- example/providing_hash.rb
 - example/session.rb
 - innate.gemspec
 - lib/innate.rb
@@ -84,7 +86,6 @@ files:
 - lib/innate/route.rb
 - lib/innate/session.rb
 - lib/innate/session/flash.rb
-- lib/innate/setup.rb
 - lib/innate/spec.rb
 - lib/innate/state.rb
 - lib/innate/state/accessor.rb
@@ -100,6 +101,7 @@ files:
 - lib/rack/reloader.rb
 - spec/example/hello.rb
 - spec/example/link.rb
+- spec/example/session.rb
 - spec/helper.rb
 - spec/innate/action/layout.rb
 - spec/innate/action/layout/file_layout.erb
@@ -127,6 +129,7 @@ files:
 - spec/innate/node/another_layout/another_layout.erb
 - spec/innate/node/bar.html
 - spec/innate/node/foo.html.erb
+- spec/innate/node/only_view.html
 - spec/innate/node/with_layout.erb
 - spec/innate/options.rb
 - spec/innate/parameter.rb

data/example/error_handling.rb

@@ -1,31 +0,0 @@
-require 'innate'
-
-class Flawed
-  include Innate::Node
-  map '/'
-
-  def index
-    raise ArgumentError, "No go"
-  end
-
-  def i_raise
-    100 * "foo"
-  end
-end
-
-class Errors
-  include Innate::Node
-  map '/error'
-
-  def internal
-    path = request.env['rack.route_exceptions.path_info']
-    exception = request.env['rack.route_exceptions.exception']
-
-    format = "Oh my, you just went to %p, something went horribly wrong: %p"
-    format % [path, exception.message]
-  end
-end
-
-Rack::RouteExceptions.route(Exception, '/error/internal')
-
-Innate.start

data/example/providing_hash.rb

@@ -1,46 +0,0 @@
-require 'innate'
-
-# This demonstrates how to obtain different content types from the return value
-# of action methods.
-#
-# Try following requests:
-#   /set/foo/bar
-#   /set/duh/duf
-#
-#   /index.json
-#   /index.yaml
-#
-#   /get/foo.json
-#   /get/foo.yaml
-# 
-# Note that this functionality is quite experimental, but by strategically
-# placing ressources in actions it may be possible to achieve interesting
-# effects and interoperability with JavaScript at a low cost.
-#
-# TODO:
-#   * parsing requests based on the content-type, but that's much less
-#     straight-forward and would require some kind of convention?
-
-class Dict
-  include Innate::Node
-  map '/'
-
-  DICT = {}
-
-  # /get/foo || /get/foo.json || /get/foo.yaml
-  def get(key)
-    {key => DICT[key]}
-  end
-
-  # /set/foo/bar || /set/foo/bar.json || /set/foo/bar.yaml
-  def set(key, value)
-    {key => (DICT[key] = value)}
-  end
-
-  # /index.json || /.json || /index.yaml || /.yaml
-  def index
-    DICT
-  end
-end
-
-Innate.start

data/lib/innate/setup.rb

@@ -1,23 +0,0 @@
-module Innate
-  def self.setup(&block)
-    Setup.new(&block)
-  end
-
-  class Setup
-    def initialize(&block)
-      instance_eval(&block) if block
-    end
-
-    def gem(*args)
-      raise
-    end
-
-    def start(options = {})
-      Innate.start(options)
-    end
-
-    def require(*libs)
-      libs.flatten.each{|lib| Kernel::require(lib) }
-    end
-  end
-end