objectified_sessions 1.0.0

data/lib/objectified_sessions/base.rb

@@ -0,0 +1,299 @@
+require 'objectified_sessions'
+require 'objectified_sessions/field_definition'
+require 'objectified_sessions/errors'
+
+module ObjectifiedSessions
+  # ObjectifiedSessions::Base is the base class for all objectified sessions -- in other words, all classes that
+  # actually implement an objectified session must inherit from this class. It therefore contains the methods that
+  # allow you to define new fields, set various options (like #unknown_fields and #default_visibility), and so on.
+  #
+  # Most functionality here is actually implemented on the class itself (the <tt>class << self</tt> block below), as
+  # most of the functionality has to do with defining which fields exist, how they should behave, and so on.
+  # Behavior for an actual instance is smaller, and largely limited to reading and writing data from fields, as
+  # most such access comes through dynamically-generated methods via the class.
+  class Base
+    # Creates a new instance. +underlying_session+ is the Rails session object -- _i.e._, whatever is returned by
+    # calling #session in a controller. (The actual class of this object varies among Rails versions, but its
+    # behavior is identical for our purposes.)
+    #
+    # This method also takes care of calling #_delete_unknown_fields_if_needed!, which, as its name suggests, is
+    # responsible for deleting any data that does not map to any known fields.
+    def initialize(underlying_session)
+      @_base_underlying_session = underlying_session
+      _delete_unknown_fields_if_needed!
+    end
+
+    # A convenient alias for accessible_field_names, so you don't have to go through the class.
+    def field_names
+      self.class.accessible_field_names
+    end
+
+    # Returns the (possibly empty) set of all field names that actually have data present.
+    def keys
+      field_names.select { |f| self[f] != nil }
+    end
+
+    # Returns a nice, pretty string of the current set of values for this session. We abbreviate long values by default,
+    # so that we don't return some absurdly-long string.
+    def to_s(abbreviate = true)
+      out = "<#{self.class.name}: "
+
+      out << keys.sort_by(&:to_s).map do |k|
+        s = self[k].inspect
+        s = s[0..36] + "..." if abbreviate && s.length > 40
+        "#{k}: #{s}"
+      end.join(", ")
+
+      out << ">"
+      out
+    end
+
+    # Make #inspect do the same as #to_s, so we also get this in debugging output.
+    def inspect(abbreviate = true)
+      to_s(abbreviate)
+    end
+
+    private
+    # This method returns the 'true' underlying session we should use. Typically this is nothing more than
+    # +@_base_underlying_session+ -- the argument passed in to our constructor -- but, if a prefix is set, this is
+    # responsible for fetching the "sub-session" Hash we should use to store all our data, instead.
+    #
+    # +create_if_needed+ should be set to +true+ if, when calling this method, we should create the prefixed
+    # "sub-session" Hash if it's not present. If +false+, this method can return +nil+, if there is no
+    # prefixed sub-session. We allow this parameter to make sure we don't bind an empty Hash to our prefix if there's
+    # nothing to store in it anyway.
+    def _objectified_sessions_underlying_session(create_if_needed)
+      prefix = self.class.prefix
+
+      if prefix
+        out = @_base_underlying_session[prefix]
+
+        if (! out) && create_if_needed
+          @_base_underlying_session[prefix] = { }
+          out = @_base_underlying_session[prefix]
+        end
+
+        out
+      else
+        @_base_underlying_session
+      end
+    end
+
+    # Takes care of deleting any unknown fields, if unknown_fields == :delete.
+    def _delete_unknown_fields_if_needed!
+      if self.class.unknown_fields == :delete
+        underlying = _objectified_sessions_underlying_session(false)
+
+        if underlying # can be nil, if there's a prefix and nothing stored in it yet
+          # Find all keys that either don't map to a field, or map to a field with #delete_data_with_storage_name? =>
+          # true -- that is, retired fields.
+          unknown = underlying.keys.select do |k|
+            field = self.class._field_with_storage_name(k)
+            (! field) || field.delete_data_with_storage_name?
+          end
+
+          underlying.delete(unknown) if unknown.length > 0
+        end
+      end
+    end
+
+    # Returns the current value for the field with the given name. +field_name+ can be specified as a String or a
+    # Symbol. Returns nil if nothing has been set yet.
+    #
+    # If passed a field name that hasn't been defined on this class, raises
+    # ObjectifiedSessions::Errors::NoSuchFieldError.
+    def [](field_name)
+      field = self.class._ensure_has_field_named(field_name)
+
+      underlying = _objectified_sessions_underlying_session(false)
+      underlying[field.storage_name] if underlying
+    end
+
+    # Stores a new value to the given field. +field_name+ can be specified as a String or a Symbol. If passed +nil+,
+    # will store +nil+ to the underlying session, which deletes the given key from the session entirely.
+    #
+    # If passed a field name that hasn't been defined on this class, raises
+    # ObjectifiedSessions::Errors::NoSuchFieldError.
+    def []=(field_name, new_value)
+      field = self.class._ensure_has_field_named(field_name)
+      _objectified_sessions_underlying_session(true)[field.storage_name] = new_value
+      new_value
+    end
+
+    DYNAMIC_METHODS_MODULE_NAME = :ObjectifiedSessionsDynamicMethods
+
+    class << self
+      # Defines a new field. +name+ is the name of the field, specified as either a String or a Symbol. +options+ can
+      # contain:
+      #
+      # [:visibility] If +:private+, methods generated for this field will be marked as private, meaning they can only
+      #               be accessed from inside the objectified-session class itself. If +:public+, methods will be
+      #               marked as public, making them accessible from anywhere. If omitted, the class's
+      #               #default_visibility will be used (which itself defaults to +:public+).
+      # [:storage] If specified, this field will be stored in the session under the given String or Symbol (which will
+      #            be converted to a String before being used). If not specified, data will be stored under the name of
+      #            the field (converted to a String), instead.
+      def field(name, options = { })
+        @fields ||= { }
+        @fields_by_storage_name ||= { }
+
+        # Compute our effective options.
+        options = { :visibility => default_visibility }.merge(options)
+        options[:type] ||= :normal
+
+        # Create a new FieldDefinition instance.
+        new_field = ObjectifiedSessions::FieldDefinition.new(self, name, options)
+
+        # Check for a conflict with the field name.
+        if @fields[new_field.name]
+          raise ObjectifiedSessions::Errors::DuplicateFieldNameError.new(self, new_field.name)
+        end
+
+        # Check for a conflict with the storage name.
+        if @fields_by_storage_name[new_field.storage_name]
+          raise ObjectifiedSessions::Errors::DuplicateFieldStorageNameError.new(self, @fields_by_storage_name[new_field.storage_name].name, new_field.name, new_field.storage_name)
+        end
+
+        @fields[new_field.name] = new_field
+        @fields_by_storage_name[new_field.storage_name] = new_field
+      end
+
+      # Defines a retired field. A retired field is really nothing more than a marker indicating that you _used_ to
+      # have a field with a given name (and, potentially, storage alias); you can't access its data, and, if
+      # you've set <tt>unknown_fields :delete</tt>, any data _will_ be deleted.
+      #
+      # So, what's the point? You will still get an error if you try to define another field with the same name, or
+      # storage alias. If you re-use a field, then, especially if you're using Rails' default CookieStore, you
+      # can run into awful problems where data from some previous usage is interpreted as being valid data for the new
+      # usage. Instead of simply removing fields when you're done with them, make them retired (and move them to the
+      # bottom of the class, if you want, for better readability); this will have the same effect as removing them,
+      # but will keep you from accidentally reusing them in the future.
+      #
+      # +name+ is the name of the field; the only valid option for +options+ is +:storage+. (+:visibility+ is accepted
+      # but ignored, since no methods are generated for retired fields.)
+      def retired(name, options = { })
+        field(name, options.merge(:type => :retired))
+      end
+
+      # Defines an inactive field. An inactive field is identical to a retired field, except that, if you've set
+      # <tt>unknown_fields :delete</tt>, data from an inactive field will _not_ be deleted. You can use it as a way of
+      # retiring a field that you no longer want to use from code, but whose data you still want preserved. (If you
+      # have not set <tt>unknown_fields :delete</tt>, then it behaves identically to a retired field.)
+      #
+      # +name+ is the name of the field; the only valid option for +options+ is +:storage+. (+:visibility+ is accepted
+      # but ignored, since no methods are generated for inactive fields.)
+      def inactive(name, options = { })
+        field(name, options.merge(:type => :inactive))
+      end
+
+      # Sets the default visibility of new fields on this class. This is ordinarily +:public+, meaning fields will
+      # generate accessor methods (_e.g._, +#foo+ and +#foo=+) that are public unless you explicitly say
+      # <tt>:visibility => :private</tt> in the field definition. However, you can change it to +:private+, meaning
+      # fields will be private unless you explicitly specify <tt>:visibility => :public</tt>.
+      #
+      # If called without an argument, returns the current default visibility for fields on this class.
+      def default_visibility(new_visibility = nil)
+        if new_visibility
+          if [ :public, :private ].include?(new_visibility)
+            @default_visibility = new_visibility
+          else
+            raise ArgumentError, "Invalid default visibility: #{new_visibility.inspect}; must be :public or :private"
+          end
+        else
+          @default_visibility ||= :public
+        end
+      end
+
+      # Sets the prefix. If a prefix is set, then all field data is taken from (and stored into) a Hash bound to this
+      # prefix within the session, rather than directly in the session; this segregates all your ObjectifiedSession
+      # data from other usage of the session. This is not generally necessary, but can be useful in certain situations.
+      # Note that setting a prefix affects _all_ fields, not just those defined after it's set; the prefix is global
+      # to your objectified session, and you can only have a single prefix at once.
+      #
+      # Perhaps obvious, but changing the prefix will effectively cause all your objectified-session data to disappear,
+      # as it'll be stored under a different key. Choose once, at the beginning.
+      #
+      # If called with no arguments, returns the current prefix.
+      def prefix(new_prefix = :__none_specified)
+        if new_prefix == :__none_specified
+          @prefix
+        elsif new_prefix.kind_of?(String) || new_prefix.kind_of?(Symbol) || new_prefix == nil
+          @prefix = if new_prefix then new_prefix.to_s.strip else nil end
+        else
+          raise ArgumentError, "Invalid prefix; must be a String or Symbol: #{new_prefix.inspect}"
+        end
+      end
+
+      # Sets what to do with unknown fields. With +:preserve+, the default setting, any data residing under keys that
+      # aren't defined as a field will simply be preserved, even as it's inaccessible. With +:delete+, any data
+      # residing under keys that aren't defined as a field will be *deleted* when your objectified session class is
+      # instantiated. Obviously, be careful if you set this to +:delete+; if you're using traditional session access
+      # anywhere else in code, and you don't duplicate its use as a field in your objectified session, really bad things
+      # will happen as the objectified session removes keys being used by other parts of the code. But it's a very nice
+      # way to keep your session tidy, too.
+      def unknown_fields(what_to_do = nil)
+        if what_to_do == nil
+          @unknown_fields ||= :preserve
+        elsif [ :delete, :preserve ].include?(what_to_do)
+          @unknown_fields = what_to_do
+        else
+          raise ArgumentError, "You must pass :delete or :preserve, not: #{what_to_do.inspect}"
+        end
+      end
+
+      # What are the names of all fields that are accessible -- that is, whose data can be accessed? This returns an
+      # array of field names, not storage names; retired fields and inactive fields don't allow access to their data,
+      # so they won't be included.
+      def accessible_field_names
+        if @fields
+          @fields.values.select { |f| f.allow_access_to_data? }.map(&:name)
+        else
+          [ ]
+        end
+      end
+
+      # Returns the FieldDefinition object with the given name, if any.
+      def _field_named(name)
+        name = ObjectifiedSessions::FieldDefinition.normalize_name(name)
+        @fields[name]
+      end
+
+      # Returns the FieldDefinition object that stores its data under the given key, if any.
+      def _field_with_storage_name(storage_name)
+        storage_name = ObjectifiedSessions::FieldDefinition.normalize_name(storage_name).to_s
+        @fields_by_storage_name[storage_name]
+      end
+
+      # If this class doesn't have an active field (not retired or inactive) with the given name, raises
+      # ObjectifiedSessions::Errors::NoSuchFieldError. This is used as a guard to make sure we don't try to retrieve
+      # data that hasn't been defined as a field.
+      def _ensure_has_field_named(name)
+        out = _field_named(name)
+        out = nil if out && (! out.allow_access_to_data?)
+        out || (raise ObjectifiedSessions::Errors::NoSuchFieldError.new(self, name))
+      end
+
+      # Returns the dynamic-methods module. The dynamic-methods module is a new Module that is automatically included
+      # into the objectified-sessions class and given a reasonable name; it also has #define_method and #private made
+      # into public methods, so that it's easy to define methods on it.
+      #
+      # The dynamic-methods module is where we define all the accessor methods that #field generates. We do this instead
+      # of defining them directly on this class so that you can override them, and #super will still work properly.
+      def _dynamic_methods_module
+        @_dynamic_methods_module ||= begin
+          out = Module.new do
+            class << self
+              public :define_method, :private
+            end
+          end
+
+          remove_const(DYNAMIC_METHODS_MODULE_NAME) if const_defined?(DYNAMIC_METHODS_MODULE_NAME)
+          const_set(DYNAMIC_METHODS_MODULE_NAME, out)
+
+          include out
+          out
+        end
+      end
+    end
+  end
+end

data/lib/objectified_sessions/errors.rb

@@ -0,0 +1,55 @@
+module ObjectifiedSessions
+  # This module contains definitions of errors for ObjectifiedSessions.
+  module Errors
+    # The base class from which all ObjectifiedSessions errors descend.
+    class Base < StandardError; end
+
+    # Raised when we cannot create the ObjectifiedSessions subclass, when someone calls #objsession; this usually means
+    # either the subclass hasn't been defined, or its constructor, for some reason, raised an error.
+    class CannotCreateSessionError < Base; end
+
+    # Raised when you try to read or write a field (via hash-indexing) that simply isn't defined on your objectified
+    # session.
+    class NoSuchFieldError < Base
+      attr_reader :session_class, :field_name
+
+      def initialize(session_class, field_name)
+        @session_class = session_class
+        @field_name = field_name
+
+        super("Class #{@session_class.name} has no field named #{@field_name.inspect}; its fields are: #{accessible_field_names.inspect}")
+      end
+
+      def accessible_field_names
+        session_class.accessible_field_names
+      end
+    end
+
+    # Raised when you try to define a field that has the same name as a previously-defined field.
+    class DuplicateFieldNameError < Base
+      attr_reader :session_class, :field_name
+
+      def initialize(session_class, field_name)
+        @session_class = session_class
+        @field_name = field_name
+
+        super("Class #{@session_class.name} already has one field named #{@field_name.inspect}; you can't define another.")
+      end
+    end
+
+    # Raised when you try to define a field that has a different name, but the same storage name, as a previously-defined
+    # field.
+    class DuplicateFieldStorageNameError < Base
+      attr_reader :session_class, :original_field_name, :new_field_name, :storage_name
+
+      def initialize(session_class, original_field_name, new_field_name, storage_name)
+        @session_class = session_class
+        @original_field_name = original_field_name
+        @new_field_name = new_field_name
+        @storage_name = storage_name
+
+        super("Class #{@session_class.name} already has a field, #{@original_field_name.inspect}, with storage name #{@storage_name.inspect}; you can't define field #{@new_field_name.inspect} with that same storage name.")
+      end
+    end
+  end
+end

data/lib/objectified_sessions/field_definition.rb

@@ -0,0 +1,105 @@
+module ObjectifiedSessions
+  # A FieldDefinition represents, well, the definition of a single field against a single class (which must be a
+  # descendant of ObjectifiedSessions::Base). It knows how to respond to a few questions, and is responsible for
+  # creating appropriate delegated methods in its owning class's +_dynamic_methods_module+.
+  class FieldDefinition
+    class << self
+      # Normalizes the name of a field. We use this method to make sure we don't get confused between Strings and
+      # Symbols, and so on.
+      def normalize_name(name)
+        unless name.kind_of?(String) || name.kind_of?(Symbol)
+          raise ArgumentError, "A field name must be a String or Symbol, not: #{name.inspect}"
+        end
+
+        name.to_s.strip.to_sym
+      end
+    end
+
+    attr_reader :name, :storage_name
+
+    # Creates a new instance. +session_class+ must be the Class that you're using as your objectified-session class --
+    # _i.e._, a subclass of ObjectifiedSessions::Base. +name+ is the name of the field. +options+ are the options for
+    # the field:
+    #
+    # [:type] Required; must be one of: +:normal+, +:retired+, or +:inactive+, each corresponding to the field type
+    #         documented in ObjectifiedSessions::Base.
+    # [:storage] If present, this field will use the specified string as the key under which it should be stored; if
+    #            not present, the name will be used instead.
+    # [:visibility] Required; must be +:private+ or +:public+. Methods created on the #_dynamic_methods_module on
+    #               the base class will be of this visibility.
+    def initialize(session_class, name, options = { })
+      raise ArgumentError, "Session class must be a Class, not: #{session_class.inspect}" unless session_class.kind_of?(Class)
+
+      @session_class = session_class
+      @name = self.class.normalize_name(name)
+      process_options!(options)
+
+      create_methods!
+    end
+
+    # Returns the key under which this field should read and write its data. This will be its name, unless a
+    # +:storage+ option was passed to the constructor, in which case it will be that value, instead.
+    def storage_name
+      @storage_name || name
+    end
+
+    # If someone has set <tt>unknown_fields :delete</tt> on the base class, should we delete data with this field's
+    # #storage_name anyway? This is true only for retired fields.
+    def delete_data_with_storage_name?
+      type == :retired
+    end
+
+    # Should we allow users to access the data in this field? Retired and inactive fields don't allow access to their
+    # data.
+    def allow_access_to_data?
+      type == :normal
+    end
+
+    private
+    attr_reader :type, :visibility
+
+    # Process the options passed in; this validates them, and sets +@type+, +@visibility+, and +@storage_name+
+    # appropriately.
+    def process_options!(options)
+      options.assert_valid_keys(:storage, :type, :visibility)
+
+      case options[:storage]
+      when nil, String, Symbol then nil
+      else raise ArgumentError, "Invalid value for :storage: #{options[:storage].inspect}"
+      end
+
+      if options[:storage]
+        @storage_name = self.class.normalize_name(options[:storage]).to_s
+      else
+        @storage_name = self.name.to_s
+      end
+
+      raise ArgumentError, "Invalid value for :type: #{options[:type].inspect}" unless [ :normal, :inactive, :retired ].include?(options[:type])
+      @type = options[:type]
+
+      raise ArgumentError, "Invalid value for :visibility: #{options[:visibility].inspect}" unless [ :public, :private ].include?(options[:visibility])
+      @visibility = options[:visibility]
+    end
+
+    # Creates methods on the dynamic-methods module, as appropriate.
+    def create_methods!
+      return unless type == :normal
+
+      fn = name
+      dmm = @session_class._dynamic_methods_module
+      mn = name.to_s.downcase
+
+      dmm.define_method(mn) do
+        self[fn]
+      end
+
+      dmm.define_method("#{mn}=") do |new_value|
+        self[fn] = new_value
+      end
+
+      if visibility == :private
+        dmm.send(:private, mn, "#{mn}=".to_sym)
+      end
+    end
+  end
+end

data/lib/objectified_sessions/version.rb

@@ -0,0 +1,3 @@
+module ObjectifiedSessions
+  VERSION = "1.0.0"
+end

data/lib/objectified_sessions.rb

@@ -0,0 +1,157 @@
+require "action_controller"
+require "objectified_sessions/version"
+require "objectified_sessions/base"
+require "objectified_session_generator"
+
+# ObjectifiedSessions is the outermost interface to the ObjectifiedSessions Gem. This module exists only as a namespace
+# (_i.e._, is not included into any classes), and has a single public method, #session_class, that lets you configure
+# which class is to be used as your +objsession+.
+module ObjectifiedSessions
+  DEFAULT_OBJSESSION_CLASS_NAME = "Objsession"
+
+  class << self
+    # Should be called from code internal to the ObjectifiedSessions Gem only. Given the underlying Session object
+    # (as returned by `#session` in a controller), creates a new instance of the correct objectified-session class
+    # and returns it.
+    #
+    # This method is actually trivially simple; it's more than two lines just because we want to be careful to raise
+    # good, usable exceptions if there's a problem.
+    def _create_new_objsession(underlying_session)
+      klass = _session_class_object
+      out = nil
+
+      # Create a new instance...
+      begin
+        out = klass.new(underlying_session)
+      rescue Exception => e
+        raise ObjectifiedSessions::Errors::CannotCreateSessionError, %{When objectified_sessions went to create a new instance of the session class, it
+got an exception from the call to #{klass.name}.new:
+
+(#{e.class.name}) #{e.message}
+    #{e.backtrace.join("\n    ")}}
+      end
+
+      # ...and make sure it's a subclass of ::ObjectifiedSessions::Base.
+      unless out.kind_of?(::ObjectifiedSessions::Base)
+        raise ObjectifiedSessions::Errors::CannotCreateSessionError, %{When objectified_sessions went to create a new instance of the session class, it
+got back an object that isn't an instance of a subclass of ObjectifiedSessions::Base.
+
+It got back an instance of #{out.class.name}:
+#{out.inspect}}
+      end
+
+      out
+    end
+
+    # Returns the session class that's been set -- in whatever format it's been set. This means that the return value
+    # can be a String, Symbol, or Class, depending on how the client set it.
+    def session_class
+      @session_class ||= DEFAULT_OBJSESSION_CLASS_NAME
+    end
+
+    # Sets the class that should be instantiated and bound to #objsession in controllers. You can pass a String or
+    # Symbol that's the name of the class, or the actual Class object itself.
+    #
+    # Class loading: if the class is not already loaded, then ObjectifiedSessions will attempt to load it, using
+    # Kernel#require, using a file path that's the Rails-style mapping from the name of the class. (In other words,
+    # if you pass 'Foo::BarBaz' for +target_class+, then ObjectifiedSessions will <tt>require 'foo/bar_baz'</tt>.)
+    #
+    # However specified, the class must be a subclass of ObjectifiedSessions::Base, or you'll get an error when you
+    # call #objsession.
+    #
+    # Note that this is evaluated the first time you call #objsession from within a controller, not immediately. This
+    # means your application will be fully booted and all of Rails available when you do this, but it also means that
+    # if you set a class that can't be resolved or has an error in it, you won't find out until you first try to access
+    # the #objsession. Be aware.
+    def session_class=(target_class)
+      unless [ String, Symbol, Class ].include?(target_class.class)
+        raise ArgumentError, "You must pass a String, Symbol, or Class, not: #{target_class.inspect}"
+      end
+
+      if target_class.kind_of?(String) || target_class.kind_of?(Symbol)
+        target_class = target_class.to_s.camelize
+      end
+
+      @session_class = target_class
+      @_session_class_object = nil
+    end
+
+    private
+    # Returns the actual Class object specified by #session_class, above. This is the method that does the work of
+    # resolving a String or Symbol that was passed there.
+    def _session_class_object
+      # We cache this so that we don't call #constantize, a relatively expensive operation, every time we need to
+      # instantiate a new #objsession.
+      @_session_class_object ||= begin
+        klass = session_class
+
+        unless klass.kind_of?(Class)
+          path = nil
+          load_error = nil
+
+          begin
+            # Compute the path this class would have...
+            path = klass.underscore
+
+            # ...and try to Kernel#require it. If we get an error, that's fine; we'll keep going and try to use the
+            # class anyway -- but we'll report on it if that fails, since it's very useful information in debugging.
+            begin
+              require path
+            rescue LoadError => le
+              load_error = le
+            end
+
+            klass = klass.constantize
+          rescue NameError => ne
+            message = nil
+
+            # If you haven't changed the default session-class name, then you probably just haven't run the generator;
+            # let's tell you to do that.
+            if klass.to_s == DEFAULT_OBJSESSION_CLASS_NAME.to_s
+              message = %{Before using objectified_sessions, you need to define the class that implements your
+  objectfied session. By default, this is named #{klass.inspect}; simply create a class of
+  that name, in the appropriate place in your project (e.g., lib/objsession.rb). You can
+  run 'rails generate objectified_session' to do this for you.
+
+  Alternatively, tell objectified_sessions to use a particular class, by saying
+
+    ObjectifiedSessions.session_class = <class name>
+
+  somewhere in your config/application.rb, or some similar initialization code.}
+            else
+              # If you *have* changed the default session-class name, you probably know what you're doing, so let's
+              # give you a different error message.
+              message = %{When objectified_sessions went to create a new instance of the session class, it
+  couldn't resolve the actual class. You specified #{klass.inspect} as the session class,
+  but, when we called #constantize on it, we got the following NameError:
+
+  (#{ne.class.name}) #{ne}}
+            end
+
+            # This is where we add information about the LoadError, above.
+            if load_error
+              message += %{
+
+  (When we tried to require the file presumably containing this class (with 'require #{path.inspect}'),
+  we got a LoadError: #{load_error.message}. This may not be an issue, if you have this class defined elsewhere; in
+  that case, you can simply ignore the error. But it may also indicate that the file you've defined this class in,
+  if any, isn't on the load path.)}
+            end
+
+            raise NameError, message
+          end
+        end
+
+        klass
+      end
+    end
+  end
+end
+
+# This is what actually makes #objsession in a controller work. Returns an instance of whatever class you have specified
+# as your objectified-session class (usually just named +Objsession+).
+class ActionController::Base
+  def objsession
+    @_objsession ||= ::ObjectifiedSessions::_create_new_objsession(session)
+  end
+end

data/objectified_sessions.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'objectified_sessions/version'
+
+Gem::Specification.new do |s|
+  s.name          = "objectified_sessions"
+  s.version       = ObjectifiedSessions::VERSION
+  s.authors       = ["Andrew Geweke"]
+  s.email         = ["andrew@geweke.org"]
+  s.description   = %q{Encapsulate and carefully manage access to your Rails session.}
+  s.summary       = %q{Encapsulate and carefully manage access to your Rails session.}
+  s.homepage      = "https://github.com/ageweke/objectified_sessions"
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|s|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.14"
+
+  if (RUBY_VERSION =~ /^1\.9\./ || RUBY_VERSION =~ /^2\.0\./) && ((! defined?(RUBY_ENGINE)) || (RUBY_ENGINE != 'jruby'))
+    s.add_development_dependency "pry"
+    s.add_development_dependency "pry-debugger"
+    s.add_development_dependency "pry-stack_explorer"
+  end
+
+  rails_version = ENV['OBJECTIFIED_SESSIONS_RAILS_TEST_VERSION']
+  rails_version = rails_version.strip if rails_version
+
+  version_spec = case rails_version
+  when nil then [ ">= 3.0", "<= 4.99.99" ]
+  when 'master' then nil
+  else [ "=#{rails_version}" ]
+  end
+
+  if version_spec
+    s.add_dependency("rails", *version_spec)
+  end
+end