manveru-innate 2009.02.06

data/lib/innate/session.rb

@@ -0,0 +1,104 @@
+module Innate
+
+  # Mostly ported from Ramaze, but behaves lazy, no session will be created if
+  # no session is used.
+  #
+  # The way we do it is to keep session data in memory until #flush is called,
+  # at which point it will be persisted completely into the cache, no question
+  # asked.
+  #
+  # NOTE:
+  #   * You may store anything in here that you may also store in the
+  #     corresponding store, usually it's best to keep it to things that are
+  #     safe to Marshal.
+
+  class Session
+    attr_reader :cookie_set, :request, :response, :flash
+
+    def initialize(request, response)
+      @request, @response = request, response
+      @cookie_set = false
+      @cache_sid = nil
+      @flash = Flash.new(self)
+    end
+
+    def []=(key, value)
+      cache_sid[key] = value
+    end
+
+    def [](key)
+      cache_sid[key]
+    end
+
+    def delete(key)
+      cache_sid.delete(key)
+    end
+
+    def clear
+      cache.delete(sid)
+      @cache_sid = nil
+    end
+
+    def cache_sid
+      @cache_sid ||= cache[sid] || {}
+    end
+
+    def flush(response = @response)
+      return unless @cache_sid
+      return if @cache_sid.empty?
+
+      flash.rotate!
+      cache[sid] = cache_sid
+      set_cookie(response)
+    end
+
+    def sid
+      @sid ||= cookie || generate_sid
+    end
+
+    def cookie
+      @request.cookies[options.key]
+    end
+
+    def inspect
+      cache.inspect
+    end
+
+    private
+
+    def cache
+      Innate::Cache.session
+    end
+
+    def options
+      Innate.options[:session]
+    end
+
+    def set_cookie(response)
+      return if @cookie_set || cookie
+
+      @cookie_set = true
+      response.set_cookie(options.key, cookie_value)
+    end
+
+    def cookie_value
+      { :value   => sid,
+        :domain  => options.domain,
+        :path    => options.path,
+        :secure  => options.secure,
+        :expires => options.expires }
+    end
+
+    def entropy
+      [ srand, rand, Time.now.to_f, rand, $$, rand, object_id ]
+    end
+
+    def generate_sid
+      begin
+        sid = Digest::SHA1.hexdigest(entropy.join)
+      end while cache[sid]
+
+      return sid
+    end
+  end
+end

data/lib/innate/session/flash.rb

@@ -0,0 +1,94 @@
+module Innate
+  class Session
+
+    # The purpose of this class is to act as a unifier of the previous
+    # and current flash.
+    #
+    # Flash means pairs of keys and values that are held only over one
+    # request/response cycle. So you can assign a key/value in the current
+    # session and retrieve it in the current and following request.
+    #
+    # Please see the Innate::Helper::Flash for details on the usage in your
+    # application.
+    class Flash
+      include Enumerable
+
+      def initialize(session)
+        @session = session
+      end
+
+      # iterate over the combined session
+      def each(&block)
+        combined.each(&block)
+      end
+
+      # the current session[:FLASH_PREVIOUS]
+      def previous
+        session[:FLASH_PREVIOUS] || {}
+      end
+
+      # the current session[:FLASH]
+      def current
+        session[:FLASH] ||= {}
+      end
+
+      # combined key/value pairs of previous and current
+      # current keys overshadow the old ones.
+      def combined
+        previous.merge(current)
+      end
+
+      # flash[key] in your Controller
+      def [](key)
+        combined[key]
+      end
+
+      # flash[key] = value in your Controller
+      def []=(key, value)
+        prev = session[:FLASH] || {}
+        prev[key] = value
+        session[:FLASH] = prev
+      end
+
+      # Inspects combined
+      def inspect
+        combined.inspect
+      end
+
+      # Delete a key
+      def delete(key)
+        previous.delete(key)
+        current.delete(key)
+      end
+
+      # check if combined is empty
+      def empty?
+        combined.empty?
+      end
+
+      # merge into current
+      def merge!(hash)
+        current.merge!(hash)
+      end
+
+      # merge on current
+      def merge(hash)
+        current.merge(hash)
+      end
+
+      # Rotation means current values are assigned as old values for the next
+      # request.
+      def rotate!
+        old = session.delete(:FLASH)
+        session[:FLASH_PREVIOUS] = old if old
+      end
+
+      private
+
+      # Associated session object
+      def session
+        @session
+      end
+    end
+  end
+end

data/lib/innate/setup.rb

@@ -0,0 +1,23 @@
+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

data/lib/innate/spec.rb

@@ -0,0 +1,42 @@
+require 'bacon'
+
+Bacon.summary_on_exit
+Bacon.extend(Bacon::TestUnitOutput)
+
+innate = File.expand_path(File.join(File.dirname(__FILE__), '../innate'))
+require(innate) unless defined?(Innate)
+
+module Innate
+  # minimal middleware, no exception handling
+  middleware(:innate){|m| m.innate }
+
+  # skip merging of options
+  options.started = true
+end
+
+# Shortcut to use persistent cookies via Innate::Mock::Session
+#
+# Usage:
+#
+#   describe 'something' do
+#     behaves_like :session
+#
+#     should 'get some stuff' do
+#       session do |mock|
+#         mock.get('/')
+#       end
+#     end
+#   end
+shared :session do
+  Innate.setup_dependencies
+
+  def session(&block)
+    Innate::Mock.session(&block)
+  end
+end
+
+shared :mock do
+  def get(*args)
+    Innate::Mock.get(*args)
+  end
+end

data/lib/innate/state.rb

@@ -0,0 +1,22 @@
+module Innate
+  state = options[:state]
+
+  if state == :Fiber
+    begin
+      require 'innate/state/fiber'
+      STATE = State::Fiber.new
+    rescue LoadError
+      require 'innate/state/thread'
+      STATE = State::Thread.new
+    end
+  else
+    require 'innate/state/thread'
+    STATE = State::Thread.new
+  end
+
+  # Log.debug("Innate keeps state with %p" % STATE.class)
+
+  def self.sync(&block)
+    STATE.sync(&block)
+  end
+end

data/lib/innate/state/accessor.rb

@@ -0,0 +1,130 @@
+module Innate
+  # Simplify accessing STATE variables.
+  #
+  # Example:
+  #
+  #   class Foo
+  #     include Innate::StateAccessor
+  #     state_accessor :session
+  #
+  #     def calculate
+  #       session[:num1] + session[:num2]
+  #     end
+  #   end
+  #
+  # Foo#calculate can now be called from anywhere in your application and it
+  # will have direct access to the session in the current request/response
+  # cycle in a thread-safe way without the need to explicitly pass the session
+  # along.
+
+  module StateAccessor
+
+    # Iterate over the names and yield accordingly.
+    # names are either objects responding to #to_sym or hashes.
+    #
+    # It's only used within this module to make the code readable.
+    #
+    # Used below.
+
+    def self.each(*names)
+      names.each do |name|
+        if name.respond_to?(:to_hash)
+          name.to_hash.each do |key, meth|
+            yield(key.to_sym, meth.to_sym)
+          end
+        else
+          key = meth = name.to_sym
+          yield(key, meth)
+        end
+      end
+    end
+
+    # Combined state_writer and state_reader.
+    # +initializer+ is a block that may be given and its result will be the new
+    # value in case the method created by state_reader was never called before
+    # and the value wasn't set before.
+    #
+    # Example:
+    #
+    #   state_accessor(:session)
+    #   state_accessor(:user){ session[:user] }
+
+    def state_accessor(*names, &initializer)
+      state_writer(*names)
+      state_reader(*names, &initializer)
+    end
+
+    # Writer accessor to STATE[key]=
+    #
+    #   Example:
+    #
+    #   class Foo
+    #     include Innate::StateAccessor
+    #     state_writer(:result)
+    #
+    #     def calculate
+    #       self.result = 42
+    #     end
+    #   end
+    #
+    #   class Bar
+    #     include Innate::StateAccessor
+    #     state_reader(:result)
+    #
+    #     def calculcate
+    #       result * result
+    #     end
+    #   end
+    #
+    #   Foo.new.calculate # => 42
+    #   Bar.new.calculate # => 1764
+
+    def state_writer(*names)
+      StateAccessor.each(*names) do |key, meth|
+        class_eval("def %s=(obj) STATE[%p] = obj; end" % [meth, key])
+      end
+    end
+
+    # Reader accessor for STATE[key]
+    #
+    # Example:
+    #
+    #   class Foo
+    #     include Innate::StateAccessor
+    #     state_reader(:session)
+    #     state_reader(:random){ rand(100_000) }
+    #
+    #     def calculate
+    #       val1 = session[:num1] + session[:num2] + random
+    #       val2 = session[:num1] + session[:num2] + random
+    #       val1 == val2 # => true
+    #     end
+    #   end
+    #
+    # NOTE:
+    #   If given +initializer+, there will be some performance impact since we
+    #   cannot use class_eval and have to use define_method instead, we also
+    #   have to check every time whether the initializer was executed already.
+    #
+    #   In 1.8.x the overhead of define_method is 3x that of class_eval/def
+    #   In 1.9.1 the overhead of define_method is 1.5x that of class_eval/def
+    #
+    #   This may only be an issue for readers that are called a lot of times.
+
+    def state_reader(*names, &initializer)
+      StateAccessor.each(*names) do |key, meth|
+        if initializer
+          define_method(meth) do
+            unless STATE.key?(key)
+              STATE[key] = instance_eval(&initializer)
+            else
+              STATE[key]
+            end
+          end
+        else
+          class_eval("def %s; STATE[%p]; end" % [meth, key])
+        end
+      end
+    end
+  end
+end

data/lib/innate/state/fiber.rb

@@ -0,0 +1,68 @@
+require 'fiber'
+
+module Innate
+  # Innate subclasses Fiber to enable lightweight request/respose-cycle local
+  # variables.
+  #
+  # We do that by adding a state Hash to the Fiber instance on initalization
+  # which can be accessed by #[], #[]= and #key?. Other Hash methods are not
+  # necessary right now but may be added.
+  #
+  # We subclass to keep your Ruby clean and polished.
+  #
+  # TODO:
+  #   * 1.9.1 includes a patch from matz that will call #initialize, so we can
+  #     remove our ::new hack, just have to get my hands on a properly
+  #     compiling version of 1.9.1
+  class Fiber < ::Fiber
+    attr_accessor :state
+
+    def self.new(*args)
+      instance = super
+      instance.state = {}
+      instance
+    end
+
+    def [](key)
+      state[key]
+    end
+
+    def []=(key, value)
+      state[key] = value
+    end
+
+    def key?(key)
+      state.key?(key)
+    end
+  end
+
+  module State
+    # Our accessor to the currently active Fiber, an instance of
+    # Innate::State::Fiber will be assigned to Innate::STATE if fibers are
+    # available.
+    class Fiber
+      def [](key)
+        Innate::Fiber.current[key]
+      end
+
+      def []=(key, value)
+        Innate::Fiber.current[key] = value
+      end
+
+      # We don't use Fiber in a concurrent manner and they don't run
+      # concurrently by themselves, so we directly #resume the Fiber to get the
+      # return value of +block+.
+
+      def wrap(&block)
+        Innate::Fiber.new(&block).resume
+      end
+
+      # In an environment where only Fiber is used there is no concurrency, so
+      # we don't have to lock with a Mutex.
+
+      def sync
+        yield
+      end
+    end
+  end
+end