manveru-innate 2009.02.06

data/lib/innate/state/thread.rb

@@ -0,0 +1,39 @@
+require 'thread'
+
+module Innate
+  module State
+    # In case fibers are not available we fall back to this wrapper.
+    #
+    # It will raise errors happening inside the wrapping Thread even if
+    # Thread::raise_on_exception is false.
+    #
+    # For things that require a mutex in a threaded environment, use
+    # STATE#sync, if Fiber is available no mutex will be used.
+
+    class Thread
+      SEMAPHORE = Mutex.new
+
+      def [](key)
+        ::Thread.current[key]
+      end
+
+      def []=(key, value)
+        ::Thread.current[key] = value
+      end
+
+      # Execute given block in a new Thread and rescue any exceptions before
+      # they reach Thread::new, so in case Thread::raise_on_exception is false
+      # we can still reraise the error outside of the Thread.
+
+      def wrap
+        value = ::Thread.new{ begin; yield; rescue Exception => ex; ex; end }.value
+        raise(value) if Exception === value
+        return value
+      end
+
+      def sync(&block)
+        SEMAPHORE.synchronize(&block)
+      end
+    end
+  end
+end

data/lib/innate/traited.rb

@@ -0,0 +1,20 @@
+module Innate
+  module Traited
+    TRAITS = Hash.new{|h,k| h[k] = {}}
+
+    def self.included(into)
+      into.extend(self)
+    end
+
+    def trait(hash = nil)
+      hash ? TRAITS[self].update(hash) : TRAITS[self]
+    end
+
+    def ancestral_trait
+      ancs = respond_to?(:ancestors) ? ancestors : self.class.ancestors
+      ancs.reverse.inject({}){|s,v|
+        v.respond_to?(:trait) ? s.update(v.trait) : s
+      }.merge(trait)
+    end
+  end
+end

data/lib/innate/trinity.rb

@@ -0,0 +1,22 @@
+require 'innate/state/accessor'
+require 'innate/request'
+
+module Innate
+  # The module to be included into the Controller it basically just provides
+  # #request, #response and #session, each accessing Thread.current to
+  # retrieve the demanded object
+
+  module Trinity
+    extend StateAccessor
+
+    state_accessor :request, :response, :session, :actions
+
+    def action
+      actions.last
+    end
+
+    def action=(arg)
+      raise "You have to modify Current::actions or use Current::action.wrap"
+    end
+  end
+end

data/lib/innate/version.rb

@@ -0,0 +1,3 @@
+module Innate
+  VERSION = "2009.02.06"
+end

data/lib/innate/view.rb

@@ -0,0 +1,67 @@
+module Innate
+
+  # This is a container module for wrappers of templating engines and handles
+  # lazy requiring of needed engines.
+
+  module View
+    ENGINE, TEMP = {}, {}
+
+    module_function
+
+    # Try to obtain given engine by its registered name.
+
+    def get(engine_or_ext)
+      return unless engine_or_ext
+      eoe = engine_or_ext.to_s
+
+      if klass = TEMP[eoe]
+        return klass
+      elsif klass = ENGINE[eoe]
+        TEMP[eoe] = obtain(klass)
+      else
+        TEMP[eoe] = const_get(eoe.capitalize)
+      end
+    end
+
+    # We need to put this in a Mutex because simultanous calls for the same
+    # class will cause race conditions and one call may return the wrong class
+    # on the first request (before TEMP is set).
+    # No mutex is used in Fiber environment, see Innate::State and subclasses.
+
+    def obtain(klass)
+      STATE.sync do
+        obj = Object
+        klass.split('::').each{|e| obj = obj.const_get(e) }
+        obj
+      end
+    end
+
+    # Register given templating engine wrapper and extensions for later usage.
+    #
+    # +name+ : the class name of the templating engine wrapper
+    # +exts+ : any number of arguments will be turned into strings via #to_s
+    #          that indicate which filename-extensions the templates may have.
+
+    def register(klass, *exts)
+      exts.each do |ext|
+        ext = ext.to_s
+        if k = ENGINE[ext]
+          Log.warn "#{ext} is assigned to #{k} already"
+        else
+          ENGINE[ext] = klass
+        end
+      end
+    end
+
+    # Combine Kernel#autoload and Innate::View::register
+
+    def auto_register(name, *exts)
+      autoload(name, "innate/view/#{name}".downcase)
+      register("#{self}::#{name}", *exts)
+    end
+
+    auto_register :None, :css
+    auto_register :None, :html, :htm
+    auto_register :ERB,  :erb
+  end
+end

data/lib/innate/view/erb.rb

@@ -0,0 +1,17 @@
+require 'erb'
+
+module Innate
+  module View
+    module ERB
+      def self.render(action, string = action.view)
+        return unless string.respond_to?(:to_str)
+
+        action.copy_variables
+
+        erb = ::ERB.new(string.to_str, nil, '%<>')
+        erb.filename = (action.view || action.method).to_s
+        erb.result(action.binding)
+      end
+    end
+  end
+end

data/lib/innate/view/none.rb

@@ -0,0 +1,9 @@
+module Innate
+  module View
+    module None
+      def self.render(action, string = nil)
+        string || action.view
+      end
+    end
+  end
+end

data/lib/rack/middleware_compiler.rb

@@ -0,0 +1,62 @@
+module Rack
+  class MiddlewareCompiler
+    COMPILED = {}
+
+    def self.build(name, &block)
+      COMPILED[name] ||= new(name, &block)
+    end
+
+    def self.build!(name, &block)
+      COMPILED[name] = new(name, &block)
+    end
+
+    attr_reader :middlewares, :name
+
+    def initialize(name)
+      @name = name
+      @middlewares = []
+      @compiled = nil
+      yield(self) if block_given?
+    end
+
+    # FIXME: Should we use `|` or `+`?
+    def use(*mws)
+      @middlewares = mws | @middlewares
+    end
+
+    def run(app)
+      @app = app
+    end
+
+    def cascade(*apps)
+      @app = Rack::Cascade.new(apps)
+    end
+
+    # Default application for Innate
+    def innate
+      cascade(
+        Rack::File.new('public'),
+        Innate::Current.new(Innate::Route.new, Innate::Rewrite.new))
+    end
+
+    def static(path)
+      require 'rack/contrib'
+      Rack::ConditionalGet.new(Rack::ETag.new(Rack::File.new(path)))
+    end
+
+    def call(env)
+      compile
+      @compiled.call(env)
+    end
+
+    def compiled?
+      @compiled
+    end
+
+    def compile
+      return self if compiled?
+      @compiled = @middlewares.inject(@app){|a,e| e.new(a) }
+      self
+    end
+  end
+end

data/lib/rack/reloader.rb

@@ -0,0 +1,192 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'pathname'
+
+module Rack
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # It does not depend on Ramaze itself, but you might have to adjust the
+  # Reloader::Hooks module or include your own module to override the hooks.
+  # You also might have to set the Log constant.
+  #
+  # What makes it especially suited for use in a production environment is that
+  # any file will only be checked once and there will only be made one system
+  # call stat(2).
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called
+  # In case of Ramaze it is performing a check/reload cycle at the start of
+  # every request, but also respects a cool down time, during which nothing will
+  # be done.
+  #
+  # After every reload the OPTIONS hash will be checked for changed options and
+  # assigned to the instance, so you may change options during the lifetime of
+  # your application.
+  #
+  # A number of hooks will be executed during the reload cycle, see
+  # Ramaze::ReloaderHooks for more information.
+
+  class Reloader
+    OPTIONS = {
+      # At most check every n seconds
+      # nil/false will never trigger the reload cycle
+      # 0 will cycle on every call
+      :cooldown => 2,
+
+      # Compiled files cannot be reloaded during runtime
+      :ignore => /\.so$/,
+
+      # Run cycle in a Thread.exclusive, by default no threads are used.
+      :thread => false,
+
+      # If you assign a block here it will be instance_evaled instead of
+      # calling cycle. This allows you to use for example EventMachine for
+      # well performing asynchronous cycling.
+      :control => nil, # lambda{ cycle },
+    }
+
+
+    # Dirty! keep track of this in an instance :(
+    # Find out how to reasonably cache racks builder
+    @@last ||= Time.now
+    @@cache ||= {}
+    @@mtimes ||= {}
+
+    def initialize(app)
+      @app = app
+      options_reload
+    end
+
+    def options_reload
+      @cooldown, @ignore, @control, @thread =
+        OPTIONS.values_at(:cooldown, :ignore, :control, :thread)
+    end
+
+    def call(env)
+      options_reload
+
+      if @cooldown and Time.now > @@last + @cooldown
+        if @control
+          instance_eval(&@control)
+        elsif @thread
+          Thread.exclusive{ cycle }
+        else
+          cycle
+        end
+
+        @@last = Time.now
+      end
+
+      @app.call(env)
+    end
+
+    def cycle
+      before_cycle
+
+      rotation do |file, stat|
+        if mtime = stat.mtime
+          if mtime > (@@mtimes[file] ||= mtime)
+            safe_load(file, mtime)
+          end
+        else
+          @@cache.delete(file)
+        end
+      end
+
+      after_cycle
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file, mtime)
+      before_safe_load(file)
+      load(file)
+      after_safe_load_succeed(file)
+    rescue Object => ex
+      puts ex
+      after_safe_load_failed(file, ex)
+    ensure
+      @@mtimes[file] = mtime
+    end
+
+    def rotation
+      files = [$0, *$LOADED_FEATURES].uniq
+      paths = ['./', *$LOAD_PATH].uniq
+
+      files.each do |file|
+        next if file =~ @ignore
+        path, stat = figure_path(file, paths)
+
+        if path and stat
+          @@cache[file] = path
+          yield(path, stat)
+        else
+          # Mostly harmless
+        end
+      end
+    end
+
+    def figure_path(file, paths)
+      if cached = @@cache[file]
+        stat = ::File.stat(cached)
+        return cached, stat if stat.file?
+      elsif Pathname.new(file).absolute?
+        stat = ::File.stat(file)
+        return file, stat if stat.file? # do directories really end up in $" ?
+      end
+
+      paths.each do |possible_path|
+        path = ::File.join(possible_path, file)
+
+        begin
+          stat = ::File.stat(path)
+          return path, stat if stat.file?
+        rescue Errno::ENOENT, Errno::ENOTDIR
+        end
+      end
+
+      return nil
+    rescue Errno::ENOENT => ex
+      @@cache.delete(file)
+      retry
+    end
+
+    # Holds hooks that are called before and after #cycle and #safe_load
+    module Hooks
+      # Overwrite to add actions before the reload rotation is started.
+      def before_cycle
+      end
+
+      # Overwrite to add actions after the reload rotation has ended.
+      def after_cycle
+      end
+
+      # Overwrite to add actions before a file is Kernel::load-ed
+      def before_safe_load(file)
+        puts "reload #{file}" # Log.debug("reload #{file}")
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed successfully,
+      # by default we clean the Cache for compiled templates and resolved actions.
+      def after_safe_load_succeed(file)
+        after_safe_load(file)
+      end
+
+      # Overwrite to add custom hook in addition to default Cache cleaning
+      def after_safe_load(file)
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed unsuccessfully,
+      # by default we output an error-message with the exception.
+      def after_safe_load_failed(file, error)
+        puts error # Log.error(error)
+      end
+    end
+
+    include Hooks
+
+  end
+end

data/spec/example/hello.rb

@@ -0,0 +1,14 @@
+require 'spec/helper'
+
+require 'example/hello'
+
+describe 'example/hello' do
+  behaves_like :mock
+
+  should 'have index action' do
+    got = get('/')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should == 'Hello, World!'
+  end
+end