innate 2009.04

data/lib/innate/session.rb

@@ -0,0 +1,121 @@
+module Innate
+
+  # Mostly ported from Ramaze, but behaves lazy, no session will be created if
+  # no session is used.
+  #
+  # We keep session data in memory until #flush is called, at which point it
+  # will be persisted completely into the cache, no question asked.
+  #
+  # 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.
+  #
+  # The default time of expiration is *
+  #
+  #   Time.at(2147483647) # => Tue Jan 19 12:14:07 +0900 2038
+  #
+  # Hopefully we all have 64bit systems by then.
+
+  class Session
+    include Optioned
+
+    options.dsl do
+      o "Key for the session cookie",
+        :key, 'innate.sid'
+      o "Domain the cookie relates to, unspecified if false",
+        :domain, false
+      o "Path the cookie relates to",
+        :path, '/'
+      o "Use secure cookie",
+        :secure, false
+      o "Time of cookie expiration",
+        :expires, Time.at((1 << 31) - 1)
+    end
+
+    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 if !@cache_sid or @cache_sid.empty?
+
+      flash.rotate!
+      ttl = (Time.at(cookie_value[:expires]) - Time.now).to_i
+      cache.store(sid, cache_sid, :ttl => ttl)
+      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 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 generate_sid
+      begin sid = sid_algorithm end while cache[sid]
+      sid
+    end
+
+    begin
+      require 'securerandom'
+      def sid_algorithm; SecureRandom.hex(32); end
+    rescue LoadError
+      def sid_algorithm
+        entropy = [ srand, rand, Time.now.to_f, rand, $$, rand, object_id ]
+        Digest::SHA2.hexdigest(entropy.join)
+      end
+    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/spec.rb

@@ -0,0 +1,23 @@
+begin; require 'rubygems'; rescue LoadError; end
+
+require 'bacon'
+require 'rack/test'
+require(File.expand_path("#{__FILE__}/../")) unless defined?(Innate)
+
+Bacon.summary_on_exit
+
+module Innate
+  # minimal middleware, no exception handling
+  middleware(:spec){|m| m.innate }
+
+  # skip starting adapter
+  options.started = true
+  options.mode = :spec
+end
+
+shared :mock do
+  Innate.setup_dependencies
+  extend Rack::Test::Methods
+
+  def app; Innate.middleware; end
+end

data/lib/innate/state.rb

@@ -0,0 +1,27 @@
+module Innate
+  begin
+    require 'innate/state/fiber'
+    STATE = State::Fiber.new
+  rescue LoadError
+    require 'innate/state/thread'
+    STATE = State::Thread.new
+  end
+
+  module SingletonMethods
+    # Use this method to achieve thread-safety for sensitive operations.
+    #
+    # This should be of most use when manipulating files to prevent other
+    # threads from doing the same, no other code will be scheduled during
+    # execution of this method.
+    #
+    # @param [Proc] block the things you want to execute
+    # @see State::Thread#sync State::Fiber#sync
+    def sync(&block)
+      STATE.sync(&block)
+    end
+
+    def defer(&block)
+      STATE.defer(&block)
+    end
+  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,74 @@
+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.
+  class Fiber < ::Fiber
+    attr_accessor :state
+
+    def initialize(*args)
+      super
+      @state = {}
+    end
+
+    def [](key)
+      state[key]
+    end
+
+    def []=(key, value)
+      state[key] = value
+    end
+
+    def key?(key)
+      state.key?(key)
+    end
+
+    def keys
+      state.keys
+    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)
+        ::Fiber.current[key]
+      end
+
+      def []=(key, value)
+        ::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
+
+      def defer
+        a = Innate::Fiber.current
+        ::Thread.new do
+          b = Innate::Fiber.new{ a.keys.each{|k| b[k] = a[k] }; yield }
+          b.resume
+        end
+      end
+    end
+  end
+end