manveru-innate 2009.02.06

data/example/link.rb

@@ -0,0 +1,35 @@
+require 'innate'
+
+class Linking
+  include Innate::Node
+  map '/'
+
+  def index
+    "simple link<br />" +
+      a('Help?', :help)
+  end
+
+  def new
+    "Something new!"
+  end
+
+  def help
+    "You have help<br />" +
+      Different.a('A Different Node', :another)
+  end
+end
+
+class Different
+  include Innate::Node
+  map '/link_to'
+
+  def another
+    a('Even deeper', 'and/deeper')
+  end
+
+  def and__deeper
+    Linking.a('Back to Linking Node', :index)
+  end
+end
+
+Innate.start

data/example/providing_hash.rb

@@ -0,0 +1,46 @@
+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/example/session.rb

@@ -0,0 +1,42 @@
+require 'innate'
+
+class Hello
+  include Innate::Node
+  map '/'
+
+  helper :link, :cgi
+
+  provide :html => :haml
+
+  TEMPLATE = '
+!!! XML
+!!!
+%html
+  %head
+    %title Session example
+  %body
+    %h1 Session example
+    = "Value is #{session[:value]}"
+    %br/
+    = a :increment
+    %br/
+    = a :decrement
+'.strip
+
+  def index
+    session[:value] = 0
+    TEMPLATE
+  end
+
+  def increment
+    session[:value] += 1 if session[:value]
+    TEMPLATE
+  end
+
+  def decrement
+    session[:value] -= 1 if session[:value]
+    TEMPLATE
+  end
+end
+
+Innate.start

data/innate.gemspec

@@ -0,0 +1,118 @@
+Gem::Specification.new do |s|
+  s.name = "innate"
+  s.version = "2009.02.06"
+
+  s.summary = "Powerful web-framework wrapper for Rack."
+  s.description = "Simple, straight-forward, base for web-frameworks."
+  s.platform = "ruby"
+  s.has_rdoc = true
+  s.author = "Michael 'manveru' Fellinger"
+  s.email = "m.fellinger@gmail.com"
+  s.homepage = "http://github.com/manveru/innate"
+  s.require_path = "lib"
+
+  s.add_dependency('rack', '>= 0.4.0')
+
+  s.files = [
+    "CHANGELOG",
+    "COPYING",
+    "MANIFEST",
+    "README.md",
+    "Rakefile",
+    "example/app/retro_games.rb",
+    "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",
+    "lib/innate/action.rb",
+    "lib/innate/adapter.rb",
+    "lib/innate/cache.rb",
+    "lib/innate/cache/api.rb",
+    "lib/innate/cache/drb.rb",
+    "lib/innate/cache/file_based.rb",
+    "lib/innate/cache/marshal.rb",
+    "lib/innate/cache/memory.rb",
+    "lib/innate/cache/yaml.rb",
+    "lib/innate/core_compatibility/basic_object.rb",
+    "lib/innate/core_compatibility/string.rb",
+    "lib/innate/current.rb",
+    "lib/innate/dynamap.rb",
+    "lib/innate/helper.rb",
+    "lib/innate/helper/aspect.rb",
+    "lib/innate/helper/cgi.rb",
+    "lib/innate/helper/flash.rb",
+    "lib/innate/helper/link.rb",
+    "lib/innate/helper/partial.rb",
+    "lib/innate/helper/redirect.rb",
+    "lib/innate/helper/send_file.rb",
+    "lib/innate/log.rb",
+    "lib/innate/log/color_formatter.rb",
+    "lib/innate/log/hub.rb",
+    "lib/innate/mock.rb",
+    "lib/innate/node.rb",
+    "lib/innate/options.rb",
+    "lib/innate/options/dsl.rb",
+    "lib/innate/request.rb",
+    "lib/innate/response.rb",
+    "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",
+    "lib/innate/state/fiber.rb",
+    "lib/innate/state/thread.rb",
+    "lib/innate/traited.rb",
+    "lib/innate/trinity.rb",
+    "lib/innate/version.rb",
+    "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/helper.rb",
+    "spec/innate/cache/common.rb",
+    "spec/innate/cache/marshal.rb",
+    "spec/innate/cache/memory.rb",
+    "spec/innate/cache/yaml.rb",
+    "spec/innate/dynamap.rb",
+    "spec/innate/helper.rb",
+    "spec/innate/helper/aspect.rb",
+    "spec/innate/helper/cgi.rb",
+    "spec/innate/helper/flash.rb",
+    "spec/innate/helper/link.rb",
+    "spec/innate/helper/partial.rb",
+    "spec/innate/helper/redirect.rb",
+    "spec/innate/helper/send_file.rb",
+    "spec/innate/helper/view/aspect_hello.erb",
+    "spec/innate/helper/view/locals.erb",
+    "spec/innate/helper/view/loop.erb",
+    "spec/innate/helper/view/num.erb",
+    "spec/innate/helper/view/partial.erb",
+    "spec/innate/helper/view/recursive.erb",
+    "spec/innate/mock.rb",
+    "spec/innate/node.rb",
+    "spec/innate/node/bar.html",
+    "spec/innate/node/foo.html.erb",
+    "spec/innate/node/with_layout.erb",
+    "spec/innate/options.rb",
+    "spec/innate/parameter.rb",
+    "spec/innate/request.rb",
+    "spec/innate/route.rb",
+    "spec/innate/session.rb",
+    "spec/innate/traited.rb"
+  ]
+end

data/lib/innate.rb

@@ -0,0 +1,191 @@
+# What can be done with fewer assumptions is done in vain with more.
+# -- William of Ockham (ca. 1285-1349)
+#
+# Name-space of Innate, just about everything goes in here.
+#
+# Exceptions are:
+#
+# * Logger::ColorFormatter
+# * In 1.8, we define ::BasicObject
+# * In 1.9, we define ::String#each
+#
+module Innate
+  ROOT = File.expand_path(File.dirname(__FILE__))
+
+  unless $LOAD_PATH.any?{|lp| File.expand_path(lp) == ROOT }
+    $LOAD_PATH.unshift(ROOT)
+  end
+end
+
+# stdlib
+require 'pp'
+require 'set'
+require 'pathname'
+require 'digest/sha1'
+require 'ipaddr'
+require 'socket'
+require 'logger'
+require 'uri'
+
+# 3rd party
+require 'rack'
+
+# innate core patches
+require 'innate/core_compatibility/string'
+require 'innate/core_compatibility/basic_object'
+
+# innate core
+require 'innate/version'
+require 'innate/traited'
+require 'innate/cache'
+require 'innate/node'
+require 'innate/options'
+require 'innate/log'
+require 'innate/state'
+require 'innate/trinity'
+require 'innate/current'
+require 'innate/mock'
+require 'innate/adapter'
+require 'innate/action'
+require 'innate/helper'
+require 'innate/view'
+require 'innate/session'
+require 'innate/session/flash'
+require 'innate/dynamap'
+require 'innate/route'
+
+require 'rack/reloader'
+require 'rack/middleware_compiler'
+
+module Innate
+  extend Trinity
+
+  # Note that `m.innate` takes away most of the boring part and leaves it up to
+  # you to select your middleware in your application.
+  #
+  # This expands to:
+  #
+  #   use Rack::ShowExceptions
+  #   use Rack::RouteExceptions
+  #   use Rack::ShowStatus
+  #   use Rack::Reloader
+  #   use Rack::Cascade.new([
+  #     Rack::File.new('public'),
+  #     Innate::Current.new(
+  #       Rack::Cascade.new([
+  #         Innate::Rewrite.new(Innate::DynaMap),
+  #         Innate::Route.new(Innate::DynaMap)])))
+  DEFAULT_MIDDLEWARE = lambda{|m|
+    m.use Rack::CommonLogger  # usually fast, depending on the output
+    m.use Rack::ShowExceptions  # fast
+    # m.use Rack::RouteExceptions # fast, use when you have custom error pages.
+    m.use Rack::ShowStatus      # fast
+    m.use Rack::Reloader        # reasonably fast depending on settings
+    # m.use Rack::Lint          # slow, use only while developing
+
+    m.innate
+  }
+
+  module_function
+
+  def start(parameter = {}, &block)
+    setup_dependencies
+    setup_middleware(&block)
+
+    options[:app][:root] = go_figure_root(parameter, caller)
+    parameter.reject!{|k, v| [:root, :file].include?(k) }
+    options.merge!(parameter)
+
+    return if options.started
+    options.started = true
+
+    trap(options[:trap]){ stop(10) } if options[:trap]
+
+    start!(options)
+  end
+
+  def start!(options = Innate.options)
+    Adapter.start(middleware(:innate), options)
+  end
+
+  def stop(wait = 3)
+    Log.info("Shutdown Innate 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 setup_dependencies
+    options[:setup].each{|obj| obj.setup }
+  end
+
+  # Set the default middleware for applications.
+  def setup_middleware(&block)
+    middleware(:innate, &(block || DEFAULT_MIDDLEWARE))
+  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 }
+
+    raise RuntimeError, "Recursive loop in Innate::call" if count > 10
+
+    middleware(mw).call(env)
+  end
+
+  # Innate can be started by:
+  #
+  #   Innate.start :file => __FILE__
+  #   Innate.start :root => '/path/to/here'
+  #
+  # In case these options are not passed we will try to figure out a file named
+  # `start.rb` in the backtrace and use the directory it resides in.
+  #
+  # 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)
+    elsif root = options[:root]
+      return root
+    end
+
+    pwd = Dir.pwd
+
+    return pwd if File.file?(File.join(pwd, 'start.rb'))
+
+    caller_lines(backtrace) do |file, line, method|
+      dir, file = File.split(File.expand_path(file))
+      return dir if file == "start.rb"
+    end
+
+    return nil
+  end
+
+  # yields +file+, +line+, +method+
+  def caller_lines(backtrace)
+    backtrace.each do |line|
+      if line =~ /^(.*?):(\d+):in `(.*)'$/
+        file, line, method = $1, $2.to_i, $3
+      elsif line =~ /^(.*?):(\d+)$/
+        file, line, method = $1, $2.to_i, nil
+      end
+
+      yield(File.expand_path(file), line, method) if file and File.file?(file)
+    end
+  end
+end

data/lib/innate/action.rb

@@ -0,0 +1,156 @@
+module Innate
+  ACTION_MEMBERS = [ :node, :method, :params, :view, :layout, :instance, :exts,
+                     :wish, :options, :variables, :value, :view_value, :name ]
+
+  class Action < Struct.new(*ACTION_MEMBERS)
+    # Create a new Action instance.
+    #
+    # @param [Hash, #values_at] hash used to seed new Action instance
+    # @return [Action] action with the given defaults from hash
+    # @author manveru
+    def self.create(hash = {})
+      new(*hash.values_at(*ACTION_MEMBERS))
+    end
+
+    # Call the Action instance, will insert itself temporarily into Current.actions during the render operation so even in nested calls one can still access all other Action instances.
+    # Will initialize the assigned node and call Action#render
+    #
+    # @return [String] The rendition of all nested calls
+    # @see Action#render Node#action_found
+    # @author manveru
+    def call
+      Current.actions << self
+      self.instance = node.new
+      self.variables[:content] ||= nil
+      render
+    ensure
+      Current.actions.delete(self)
+    end
+
+    # @return [Binding] binding of the instance for this Action
+    # @see Node#binding
+    # @author manveru
+    def binding
+      instance.binding
+    end
+
+    # Copy the instance variable names and values from given
+    # from_action#instance into the Action#variables of the action this method
+    # is called on.
+    #
+    # @param [Action #instance] from_action
+    # @return [Action] from_action
+    # @see Action#wrap_in_layout
+    # @author manveru
+    def sync_variables(from_action)
+      instance = from_action.instance
+
+      instance.instance_variables.each{|iv|
+        iv_value = instance.instance_variable_get(iv)
+        iv_name = iv.to_s[1..-1]
+        self.variables[iv_name.to_sym] = iv_value
+      }
+
+      from_action
+    end
+
+    # Copy Action#variables as instance variables into the given binding.
+    #
+    # This relies on Innate::STATE, so should be thread-safe and doesn't depend
+    # on Innate::Current::actions order.
+    # So we avoid nasty business with Objectspace#_id2ref which may not work on
+    # all ruby implementations and seems to cause other problems as well.
+    #
+    # @param [Binding #eval] binding
+    # @return [NilClass] there is no indication of failure or success
+    # @see View::ERB::render
+    # @author manveru
+    def copy_variables(binding = self.binding)
+      return unless variables.any?
+
+      STATE.sync do
+        STATE[:action_variables] = self.variables
+
+        binding.eval('
+          STATE[:action_variables].each do |iv, value|
+            instance_variable_set("@#{iv}", value)
+          end')
+
+        STATE[:action_variables] = nil
+      end
+    end
+
+    def render
+      instance.wrap_action_call(self) do
+        self.value = instance.__send__(method, *params) if method
+        self.view_value = File.read(view) if view
+      end
+
+      content_type, body = send(Innate.options.action.wish[wish] || :as_html)
+      Current.response['Content-Type'] ||= content_type
+
+      body
+    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']
+
+      if way
+        # Rack::Mime.mime_type(".#{wish}", 'text/html')
+        View.get(way).render(self, string)
+      else
+        raise("No templating engine was found for %p" % way)
+      end
+    end
+
+    def wrap_in_layout
+      return yield unless layout
+
+      action = dup
+      action.view, action.method = layout_view_or_method(*layout)
+      action.layout = nil
+      action.sync_variables(self)
+      action.variables[:content] = yield
+      action.call
+    end
+
+    def layout_view_or_method(name, arg)
+      return arg, nil if name == :layout || name == :view
+      return nil, arg
+    end
+
+    #Try to figure out a sane name for current action.
+    def name
+      File.basename((method || view).to_s).split('.').first
+    end
+  end
+end