rjspotter-innate 2009.06.29

data/lib/innate/session.rb

@@ -0,0 +1,133 @@
+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 Session instance is compatible with the specification of rack.session.
+  #
+  # Since the Time class is used to create the cookie expiration timestamp, you
+  # will have to keep the ttl in a reasonable range.
+  # The maximum value that Time can store on a 32bit system is:
+  #   Time.at(2147483647) # => Tue Jan 19 12:14:07 +0900 2038
+  #
+  # The default expiration time for cookies and the session cache was reduced
+  # to a default of 30 days.
+  # This was done to be compatible with the maximum ttl of MemCache. You may
+  # increase this value if you do not use MemCache to persist your sessions.
+  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, nil
+      o "Time to live for session cookies and cache, nil/false will prevent setting",
+        :ttl, (60 * 60 * 24 * 30) # 30 days
+
+      trigger(:expires){|v|
+        self.ttl = v - Time.now.to_i
+        Log.warn("Innate::Session.options.expires is deprecated, use #ttl instead")
+      }
+    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
+
+    # Rack interface
+
+    def store(key, value)
+      cache_sid[key] = value
+    end
+    alias []= store
+
+    def fetch(key, value = nil)
+      cache_sid[key]
+    end
+    alias [] fetch
+
+    def delete(key)
+      cache_sid.delete(key)
+    end
+
+    def clear
+      cache.delete(sid)
+      @cache_sid = nil
+    end
+
+    # Additional interface
+
+    def flush(response = @response)
+      return if !@cache_sid or @cache_sid.empty?
+
+      flash.rotate!
+      cache.store(sid, cache_sid, :ttl => options.ttl)
+      set_cookie(response)
+    end
+
+    def sid
+      @sid ||= cookie || generate_sid
+    end
+
+    private
+
+    def cache_sid
+      @cache_sid ||= cache[sid] || {}
+    end
+
+    def cookie
+      @request.cookies[options.key]
+    end
+
+    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
+      o = options
+      cookie = {:domain => o.domain, :path => o.path, :secure => o.secure}
+      cookie[:expires] = (Time.now + o.ttl) if o.ttl
+      cookie.merge!(:value => sid)
+    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 @@
+require 'innate/spec/bacon'

data/lib/innate/spec/bacon.rb

@@ -0,0 +1,28 @@
+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 :rack_test do
+  Innate.setup_dependencies
+  extend Rack::Test::Methods
+
+  def app; Innate.middleware; end
+end
+
+shared :mock do
+  warn 'behaves_like(:mock) is deprecated, use behaves_like(:rack_test) instead'
+  behaves_like :rack_test
+end

data/lib/innate/state.rb

@@ -0,0 +1,26 @@
+require 'thread'
+
+module Innate
+  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)
+      Thread.exclusive(&block)
+    end
+
+    def defer
+      outer = ::Thread.current
+      ::Thread.new{
+        inner = ::Thread.current
+        outer.keys.each{|k| inner[k] = outer[k] }
+        yield
+      }
+    end
+  end
+end

data/lib/innate/state/accessor.rb

@@ -0,0 +1,130 @@
+module Innate
+  # Simplify accessing Thread.current 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 Thread.current[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) Thread.current[%p] = obj; end" % [meth, key])
+      end
+    end
+
+    # Reader accessor for Thread.current[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 Thread.current.key?(key)
+              Thread.current[key] = instance_eval(&initializer)
+            else
+              Thread.current[key]
+            end
+          end
+        else
+          class_eval("def %s; Thread.current[%p]; end" % [meth, key])
+        end
+      end
+    end
+  end
+end

data/lib/innate/traited.rb

@@ -0,0 +1,90 @@
+module Innate
+  # Traited helps you doing configuration similar to class variables.
+  #
+  # It's built on a simple Hash, where keys are objects and the values the
+  # configuration.
+  # By using {Traited#ancestral_trait} you will get nicely inherited
+  # configuration, where keys later in the ancestors will take precedence.
+  #
+  # @example usage
+  #
+  #   class Foo
+  #     include Innate::Traited
+  #     trait :hello => 'Hello'
+  #
+  #     def initialize
+  #       trait :hello => 'World!'
+  #     end
+  #
+  #     def show
+  #       [class_trait[:hello], trait[:hello], ancestral_trait[:hello]]
+  #     end
+  #   end
+  #
+  #   Foo.trait[:hello] # => "Hello"
+  #   foo = Foo.new
+  #   foo.trait[:hello] # => "World!"
+  #   foo.show          # => ["Hello", "World!", "World!"]
+  module Traited
+    TRAITS, ANCESTRAL_TRAITS, ANCESTRAL_VALUES = {}, {}, {}
+
+    def self.included(into)
+      into.extend(self)
+    end
+
+    def trait(hash = nil)
+      if hash
+        TRAITS[self] ||= {}
+        result = TRAITS[self].merge!(hash)
+        ANCESTRAL_VALUES.clear
+        ANCESTRAL_TRAITS.clear
+        result
+      else
+        TRAITS[self] || {}
+      end
+    end
+
+    # Builds a trait from all the ancestors, closer ancestors overwrite distant
+    # ancestors
+    #
+    # class Foo
+    #   include Innate::Traited
+    #   trait :one => :eins, :first => :erstes
+    # end
+    #
+    # class Bar < Foo
+    #   trait :two => :zwei
+    # end
+    #
+    # class Foobar < Bar
+    #   trait :three => :drei, :first => :overwritten
+    # end
+    #
+    # Foobar.ancestral_trait
+    # # => {:three => :drei, :two => :zwei, :one => :eins, :first => :overwritten}
+    def ancestral_trait
+      klass = self.kind_of?(Module) ? self : self.class
+      ANCESTRAL_TRAITS[klass] ||=
+        each_ancestral_trait({}){|hash, trait| hash.update(trait) }
+    end
+
+    def ancestral_trait_values(key)
+      klass = self.kind_of?(Module) ? self : self.class
+      cache = ANCESTRAL_VALUES[klass] ||= {}
+      cache[key] ||= each_ancestral_trait([]){|array, trait|
+        array << trait[key] if trait.key?(key) }
+    end
+
+    def each_ancestral_trait(obj)
+      ancs = respond_to?(:ancestors) ? ancestors : self.class.ancestors
+      ancs.unshift(self)
+      ancs.reverse_each{|anc| yield(obj, TRAITS[anc]) if TRAITS.key?(anc) }
+      obj
+    end
+
+    # trait for self.class if we are an instance
+    def class_trait
+      respond_to?(:ancestors) ? trait : self.class.trait
+    end
+  end
+end