manveru-innate 2009.02.25 → 2009.03.24

data/innate.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "innate"
-  s.version = "2009.02.25"
+  s.version = "2009.03.24"
 
   s.summary = "Powerful web-framework wrapper for Rack."
   s.description = "Simple, straight-forward, base for web-frameworks."
@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/manveru/innate"
   s.require_path = "lib"
 
-  s.add_dependency('rack', '>= 0.4.0')
+  s.add_dependency('rack', '>= 0.9.1')
 
   s.files = [
     "CHANGELOG",
@@ -33,6 +33,7 @@ Gem::Specification.new do |s|
     "example/hello.rb",
     "example/howto_spec.rb",
     "example/link.rb",
+    "example/provides.rb",
     "example/session.rb",
     "innate.gemspec",
     "lib/innate.rb",
@@ -60,10 +61,12 @@ Gem::Specification.new do |s|
     "lib/innate/log.rb",
     "lib/innate/log/color_formatter.rb",
     "lib/innate/log/hub.rb",
+    "lib/innate/middleware_compiler.rb",
     "lib/innate/mock.rb",
     "lib/innate/node.rb",
     "lib/innate/options.rb",
     "lib/innate/options/dsl.rb",
+    "lib/innate/options/stub.rb",
     "lib/innate/request.rb",
     "lib/innate/response.rb",
     "lib/innate/route.rb",
@@ -80,8 +83,6 @@ Gem::Specification.new do |s|
     "lib/innate/view.rb",
     "lib/innate/view/erb.rb",
     "lib/innate/view/none.rb",
-    "lib/rack/middleware_compiler.rb",
-    "lib/rack/reloader.rb",
     "spec/example/hello.rb",
     "spec/example/link.rb",
     "spec/example/session.rb",
@@ -108,17 +109,25 @@ Gem::Specification.new do |s|
     "spec/innate/helper/view/partial.erb",
     "spec/innate/helper/view/recursive.erb",
     "spec/innate/mock.rb",
-    "spec/innate/node.rb",
-    "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/node/mapping.rb",
+    "spec/innate/node/node.rb",
+    "spec/innate/node/resolve.rb",
+    "spec/innate/node/view/another_layout/another_layout.erb",
+    "spec/innate/node/view/bar.erb",
+    "spec/innate/node/view/foo.html.erb",
+    "spec/innate/node/view/only_view.erb",
+    "spec/innate/node/view/with_layout.erb",
+    "spec/innate/node/wrap_action_call.rb",
     "spec/innate/options.rb",
     "spec/innate/parameter.rb",
+    "spec/innate/provides.rb",
+    "spec/innate/provides/list.html.erb",
+    "spec/innate/provides/list.txt.erb",
     "spec/innate/request.rb",
     "spec/innate/route.rb",
     "spec/innate/session.rb",
+    "spec/innate/state/fiber.rb",
+    "spec/innate/state/thread.rb",
     "spec/innate/traited.rb"
   ]
 end

data/lib/innate/action.rb

@@ -1,19 +1,25 @@
 module Innate
   ACTION_MEMBERS = [ :node, :method, :params, :view, :layout, :instance, :exts,
-                     :wish, :options, :variables, :value, :view_value, :name ]
+    :wish, :options, :variables, :value, :view_value, :engine ]
 
   class Action < Struct.new(*ACTION_MEMBERS)
-    # Holds the default values for merging in {Action::create}
-    DEFAULT = {:options => {}, :variables => {}, :params => []}
-
     # Create a new Action instance.
+    # Note that the default cannot be a constant as assigning the value objects
+    # to the struct would modify them and might lead to bugs due to persisting
+    # action contents.
     #
     # @param [Hash, #to_hash] hash used to seed new Action instance
     # @return [Action] action with the given defaults from hash
     # @api stable
     # @author manveru
     def self.create(hash = {})
-      new(*DEFAULT.merge(hash.to_hash).values_at(*ACTION_MEMBERS))
+      default = {:options => {}, :variables => {}, :params => []}
+      new(*default.merge(hash.to_hash).values_at(*ACTION_MEMBERS))
+    end
+
+    def merge!(hash)
+      hash.each_pair{|key, value| send("#{key}=", value) }
+      self
     end
 
     # Call the Action instance, will insert itself temporarily into
@@ -96,51 +102,14 @@ module Innate
       instance.wrap_action_call(self) do
         self.value = instance.__send__(method, *params) if method
         self.view_value = File.read(view) if view
+        copy_variables
 
-        content_type, body = send(Innate.options.action.wish[wish] || :as_html)
-        response = Current.response
-        response['Content-Type'] ||= content_type if response
-
+        body, content_type = wrap_in_layout{ engine.call(self, view_value || value) }
+        options[:content_type] ||= content_type if content_type
         body
       end
     end
 
-    # @return [Array] Content-Type and rendered action
-    # @see Action#render Action#wrap_in_layout
-    # @author manveru
-    def as_html
-      return 'text/html', wrap_in_layout{ fulfill_wish(view_value || value) }
-    end
-
-    # @return [Array] Content-Type and rendered action
-    # @see Action#render Action#wrap_in_layout
-    # @author manveru
-    def as_yaml
-      require 'yaml'
-      return 'text/yaml', (value || view_value).to_yaml
-    end
-
-    # @return [Array] Content-Type and rendered action
-    # @see Action#render Action#wrap_in_layout
-    # @author manveru
-    def as_json
-      require 'json'
-      return 'application/json', (value || view_value).to_json
-    end
-
-    # @param [String, #to_str] string to be rendered
-    # @return [String] The rendered result of the templating engine
-    # @raise [RuntimeError] if no suitable templating engine was found
-    # @see Action#as_html
-    # @author manveru
-    def fulfill_wish(string)
-      way = File.basename(view).gsub!(/.*?#{wish}\./, '') if view
-      way ||= node.provide[wish] || node.provide['html']
-
-      return View.render(way, self, string || view) if way
-      raise("No templating engine was found for %p" % way)
-    end
-
     def wrap_in_layout
       return yield unless layout
 
@@ -148,8 +117,9 @@ module Innate
       action.view, action.method = layout_view_or_method(*layout)
       action.layout = nil
       action.sync_variables(self)
-      action.variables[:content] = yield
-      action.call
+      body, content_type = yield
+      action.variables[:content] = body
+      return action.call, content_type
     end
 
     def layout_view_or_method(name, arg)
@@ -161,5 +131,9 @@ module Innate
     def name
       File.basename((method || view).to_s).split('.').first
     end
+
+    def valid?
+      method || view
+    end
   end
 end

data/lib/innate/adapter.rb

@@ -17,73 +17,82 @@ module Innate
   # where Rack doesn't want to take a stand.
 
   module Adapter
-    class << self
-
-      # Pass given app to the Handler, handler is chosen based on
-      # config.adapter option.
-      # If there is a method named start_name_of_adapter it will be run instead
-      # of the default run method of the handler, this makes it easy to define
-      # custom startup of handlers for your server of choice
-      def start(app, options = Innate.options)
-        adapter_name = options[:adapter].to_s.downcase
-        config = { :Host => options[:host], :Port => options[:port] }
-        Log.debug "Using #{adapter_name}"
-
-        if respond_to?(method = "start_#{adapter_name}")
-          send(method, app, config)
-        else
-          Rack::Handler.get(adapter_name).run(app, config)
-        end
-      end
+    include Optional
 
-      # Due to buggy autoload on Ruby 1.8 we have to require 'ebb' manually.
-      # This most likely happens because autoload doesn't respect the require
-      # of rubygems and uses the C require directly.
-      def start_ebb(app, config)
-        require 'ebb'
-        Rack::Handler.get('ebb').run(app, config)
-      end
+    options.dsl do
+      o "IP address or hostname that we respond to - 0.0.0.0 for all",
+        :host, "0.0.0.0"
 
-      # We want webrick to use our logger.
+      o "Port for the server",
+        :port, 7000
 
-      def start_webrick(app, config)
-        handler = Rack::Handler.get('webrick')
-        config = {
-          :BindAddress => config[:Host],
-          :Port => config[:Port],
-          :Logger => Log,
-          :AccessLog => [
-            [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
-            [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]]
-        }
+      o "Web server to run on",
+        :handler, :webrick
+    end
 
-        handler.run(app, config)
-      end
+    # Pass given app to the Handler, handler is chosen based on config.adapter
+    # option.
+    # If there is a method named start_name_of_adapter it will be run instead
+    # of the default run method of the handler, this makes it easy to define
+    # custom startup of handlers for your server of choice.
+    def self.start(app, given_options = nil)
+      options.merge!(given_options) if given_options
 
-      # Thin shouldn't give excessive output, especially not to $stdout
+      handler = options[:handler].to_s.downcase
+      config = { :Host => options[:host], :Port => options[:port] }
 
-      def start_thin(app, config)
-        require 'thin'
-        handler = Rack::Handler.get('thin')
-        ::Thin::Logging.silent = true
-        handler.run(app, config)
+      Log.debug "Using #{handler}"
+
+      if respond_to?(method = "start_#{handler}")
+        send(method, app, config)
+      else
+        Rack::Handler.get(handler).run(app, config)
       end
+    end
 
-      # swiftcore has its own handler outside of rack
+    # Due to buggy autoload on Ruby 1.8 we have to require 'ebb' manually.
+    # This most likely happens because autoload doesn't respect the require of
+    # rubygems and uses the C require directly.
+    def self.start_ebb(app, config)
+      require 'ebb'
+      Rack::Handler.get('ebb').run(app, config)
+    end
 
-      def start_emongrel(app, config)
-        require 'swiftcore/evented_mongrel'
-        handler = Rack::Handler.get('emongrel')
-        handler.run(app, config)
-      end
+    # We want webrick to use our logger.
+    def self.start_webrick(app, config)
+      handler = Rack::Handler.get('webrick')
+      config = {
+        :BindAddress => config[:Host],
+        :Port => config[:Port],
+        :Logger => Log,
+        :AccessLog => [
+          [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+          [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]]
+      }
+
+      handler.run(app, config)
+    end
+
+    # Thin shouldn't give excessive output, especially not to $stdout
+    def self.start_thin(app, config)
+      require 'thin'
+      handler = Rack::Handler.get('thin')
+      ::Thin::Logging.silent = true
+      handler.run(app, config)
+    end
 
-      # swiftcore has its own handler outside of rack
+    # swiftcore has its own handler outside of rack
+    def self.start_emongrel(app, config)
+      require 'swiftcore/evented_mongrel'
+      handler = Rack::Handler.get('emongrel')
+      handler.run(app, config)
+    end
 
-      def start_smongrel(app, config)
-        require 'swiftcore/swiftiplied_mongrel'
-        handler = Rack::Handler.get('smongrel')
-        handler.run(app, config)
-      end
+    # swiftcore has its own handler outside of rack
+    def self.start_smongrel(app, config)
+      require 'swiftcore/swiftiplied_mongrel'
+      handler = Rack::Handler.get('smongrel')
+      handler.run(app, config)
     end
   end
 end

data/lib/innate/cache.rb

@@ -14,7 +14,7 @@ module Innate
   #
   # Configuration:
   #
-  #   Innate.options.cache do |cache|
+  #   Innate::Cache.options do |cache|
   #     cache.names = [:session, :user]
   #     cache.session = Innate::Cache::Marshal
   #     cache.user = Innate::Cache::YAML
@@ -61,20 +61,28 @@ module Innate
     autoload :Marshal,   'innate/cache/marshal'
     autoload :FileBased, 'innate/cache/file_based'
 
+    include Optional
+
+    options.dsl do
+      o "Assign a cache to each of these names on Innate::Cache::setup",
+        :names, [:session]
+
+      default "If no option for the cache name exists, fall back to this",
+        Innate::Cache::Memory
+    end
+
     attr_reader :name, :instance
 
     def initialize(name, klass = nil)
       @name = name.to_s.dup.freeze
 
-      options = Innate.options
-
-      klass ||= options[:cache, @name.to_sym]
+      klass ||= options[@name.to_sym]
       @instance = klass.new
 
       @instance.cache_setup(
-        options.env.host,
-        options.env.user,
-        options.app.name,
+        ENV['HOSTNAME'],
+        ENV['USER'],
+        'pristine',
         @name
       )
     end
@@ -86,7 +94,7 @@ module Innate
     # @return [Array] names of caches initialized
     # @author manveru
     def self.setup
-      Innate.options.cache.names.each{|name| add(name) }
+      options.names.each{|name| add(name) }
     end
 
     # Add accessors for cache

data/lib/innate/dynamap.rb

@@ -1,38 +1,48 @@
 module Innate
+  class URLMap < Rack::URLMap
+    def initialize(map = {})
+      @originals = map
+      super
+    end
 
-  # This is a dynamic routing mapper used to outsmart Rack::URLMap
-  # Every time a mapping is changed a new Rack::URLMap will be put into
-  # Innate::DynaMap::CACHE[:map]
-  class DynaMap
-    MAP = {}
-    CACHE = {}
+    # super may raise when given invalid locations, so we only replace the
+    # `@originals` if we are sure the new map is valid
+    def remap(map)
+      value = super
+      @originals = map
+      value
+    end
 
-    # Delegate the call to the current Rack::URLMap instance.
-    #
-    # @note Currently Rack::URLMap will destructively modify PATH_INFO and
-    #   SCRIPT_NAME, which leads to incorrect routing as parts of the PATH_INFO
-    #   are cut out if they matched once. Here I repair this damage and hope
-    #   that my patch to rack will be accepted.
-    #   Update: patch was accepted, will remove it on next rack release
-    def self.call(env)
-      if app = CACHE[:map]
-        script_name, path_info = env['SCRIPT_NAME'], env['PATH_INFO']
-        answer = app.call(env)
-        env.merge!('SCRIPT_NAME' => script_name, 'PATH_INFO' => path_info)
-        answer
-      else
-        raise "Nothing mapped yet"
-      end
+    def map(location, object)
+      return unless location and object
+      remap(@originals.merge(location.to_s => object))
     end
 
-    # Map node to location, create a new Rack::URLMap instance and cache it.
-    def self.map(location, node)
-      return unless location
-      MAP[location.to_s] = node
-      CACHE[:map] = Rack::URLMap.new(MAP)
+    def at(location)
+      @originals[location]
+    end
+
+    def to(object)
+      @originals.invert[object]
+    end
+
+    def to_hash
+      @originals.dup
+    end
+
+    def call(env)
+      raise "Nothing mapped yet" if @originals.empty?
+      super
     end
   end
 
+  DynaMap = URLMap.new
+
+  # script_name, path_info = env['SCRIPT_NAME'], env['PATH_INFO']
+  # answer = app.call(env)
+  # env.merge!('SCRIPT_NAME' => script_name, 'PATH_INFO' => path_info)
+  # answer
+
   module SingletonMethods
     # Maps the given +object+ or +block+ to +location+, +object+ must respond to
     # #call in order to be of any use.
@@ -61,7 +71,7 @@ module Innate
     #
     #   Innate.at('/') # => Hello
     def at(location)
-      DynaMap::MAP[location.to_s]
+      DynaMap.at(location)
     end
 
     # Returns one of the paths the given +object+ is mapped to.
@@ -75,7 +85,7 @@ module Innate
     #
     #   Innate.to(Hello) # => '/'
     def to(object)
-      DynaMap::MAP.invert[object]
+      DynaMap.to(object)
     end
   end
 end

data/lib/innate/helper/aspect.rb

@@ -2,11 +2,14 @@ module Innate
   module Helper
 
     # Provides before/after wrappers for actions
+    #
+    # This helper is essential for proper working of {Action#render}.
     module Aspect
       AOP = Hash.new{|h,k| h[k] = Hash.new{|hh,kk| hh[kk] = {} }}
 
       def self.included(into)
         into.extend(SingletonMethods)
+        into.add_action_wrapper(5.0, :aspect_wrap)
       end
 
       # Consider objects that have Aspect included
@@ -37,7 +40,56 @@ module Innate
         result
       end
 
+      # This awesome piece of hackery implements action AOP.
+      #
+      # The so-called aspects are simply methods that may yield the next aspect
+      # in the chain, this is similar to racks concept of middleware, but instead
+      # of initializing with an app we simply pass a block that may be yielded
+      # with the action being processed.
+      #
+      # This gives us things like logging, caching, aspects, authentication, etc.
+      #
+      # Add the name of your method to the trait[:wrap] to add your own method to
+      # the wrap_action_call chain.
+      #
+      # @example adding your method
+      #
+      #   class MyNode
+      #     Innate.node '/'
+      #
+      #     private
+      #
+      #     def wrap_logging(action)
+      #       Innate::Log.info("Executing #{action.name}")
+      #       yield
+      #     end
+      #
+      #     trait[:wrap]
+      #   end
+      #
+      #
+      # methods may register
+      # themself in the trait[:wrap] and will be called in left-to-right order,
+      # each being passed the action instance and a block that they have to yield
+      # to continue the chain.
+      #
+      # @param [Action] action instance that is being passed to every registered method
+      # @param [Proc] block contains the instructions to call the action method if any
+      #
+      # @see Action#render
+      # @author manveru
+      def wrap_action_call(action, &block)
+        wrap = SortedSet.new
+        action.node.ancestral_trait_values(:wrap).each{|sset| wrap.merge(sset) }
+        head, *tail = wrap.map{|k,v| v }
+        tail.reverse!
+        combined = tail.inject(block){|s,v| lambda{ __send__(v, action, &s) } }
+        __send__(head, action, &combined)
+      end
+
       module SingletonMethods
+        include Traited
+
         def before_all(&block)
           AOP[self][:before_all] = block
         end
@@ -58,6 +110,14 @@ module Innate
           before(name, &block)
           after(name, &block)
         end
+
+        def add_action_wrapper(order, method_name)
+          if wrap = trait[:wrap]
+            wrap.merge(SortedSet[[order, method_name]])
+          else
+            trait :wrap => SortedSet[[order, method_name]]
+          end
+        end
       end
     end
   end

data/lib/innate/helper/cgi.rb

@@ -34,6 +34,8 @@ module Innate
       # one-letter versions help in case like #{h foo.inspect}
       # ERb/ERuby/Rails compatible
       alias u url_encode
+
+      module_function(:url_encode, :url_decode, :html_escape, :html_unescape, :h, :u)
     end
   end
 end

data/lib/innate/helper/link.rb

@@ -28,31 +28,63 @@ module Innate
         hashes, names = args.partition{|arg| arg.respond_to?(:merge!) }
         hashes.each{|to_merge| hash.merge!(to_merge) }
 
-        prefix = Innate.options.app.prefix
-        location = Innate.to(self) || Innate.to(self.class)
-        front = Array[prefix, location, name, *names].join('/').squeeze('/')
+        location = route_location(self)
+        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
+        return URI(front) if hash.empty?
+
+        escape = Rack::Utils.method(:escape)
+        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)
-        href = args.empty? ? r(text) : r(*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

data/lib/innate/helper/partial.rb

@@ -72,16 +72,17 @@ module Innate
 
         ext = File.extname(path)
         basename = File.basename(path, ext)
-        ext = ext[1..-1] || action.node.provide[action.wish].to_s
-        
+
         action = Innate::Current.action.dup
         action.layout    = nil
-        action.view      = action.node.find_view(basename, ext)
+        action.view      = action.node.find_view(basename, 'html')
         action.method    = action.node.find_method(basename, action.params)
+
         action.variables = action.variables.merge(variables)
         action.sync_variables(action)
-        
-        action.call
+
+        return action.call if action.valid?
+        raise(ArgumentError, "cannot render %p" % path)
       end
 
       def render_action(method, *params)