objectified_sessions 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  data.tar.gz: bff5500fbeed0f446febd09e23819d2b143d3592d3c957bcaedc836786d5bfdbb8c393c0659278f9b2c96fb2fd16cf1b81bddacbda97b9233c61dad7b5d0559b
-  metadata.gz: f24564e7778790033ba6307ec1c339e66e9ec8d87aff6c6b0bcb833b9a47793c402a29bc0f9ccc1bc4e57782b16bea70276f45c4ccbf6e74d90cddfa241fc724
 SHA1: 
-  data.tar.gz: a7f49fbd4fd51d8854823f9fd4c7f01041ce022b
-  metadata.gz: 557be601d1396648ece538afa384e65cc2f2ebe7
+  metadata.gz: 3ddbe03428f2939faa0bae986029767c4bcfa112
+  data.tar.gz: 8f562df0cc6716bcf4262d413a54375e1eca5810
+SHA512: 
+  metadata.gz: f10073ecd7bf153818d79d20d8470641e1f84c9493b8e2ec67f7e61fe1a38ec16ebeee57416b2abe39e172e08cc398a341a0e332b6d328d65940b0db69c83157
+  data.tar.gz: 39f589ecdb7e1422a4651843974c4c35bf10d720a9f3353eee551578b9d06fe12485a37e4f108410b3308526be2ded60c14b562671c73e7148314d2a0b7e7ed2

data/.travis.yml

@@ -3,10 +3,11 @@ before_install:
     - gem update --system 2.1.11
     - gem --version
 rvm:
+    - "2.1.0"
     - "2.0.0"
     - "1.9.3"
     - "1.8.7"
-    - "jruby-1.7.4"
+    - "jruby-1.7.9"
 env:
     - OBJECTIFIED_SESSIONS_RAILS_TEST_VERSION=3.0.20
     - OBJECTIFIED_SESSIONS_RAILS_TEST_VERSION=3.1.12

data/README.md

@@ -36,6 +36,14 @@ And, best of all, you can migrate to ObjectifiedSessions completely incrementall
 traditional session-handling code. You can migrate call site by call site, at your own pace; there's no need to
 migrate all at once, or even migrate all code for a given session key all at once.
 
+ObjectifiedSessions supports:
+
+* Ruby 1.8.7, 1.9.3, 2.0.0, 2.1.0, or JRuby 1.7.9
+* Rails 3.0.20, 3.1.12, 3.2.16, and 4.0.2.
+
+These are, however, just the versions it's tested against; ObjectifiedSessions contains no code that should be at all
+particularly dependent on exact Ruby or Rails versions, and should be compatible with a broad set of versions.
+
 Current build status: ![Current Build Status](https://api.travis-ci.org/ageweke/objectified_sessions.png?branch=master)
 
 ## Installation
@@ -199,6 +207,30 @@ to disappear_. (Hopefully this is obvious; this is because ObjectifiedSessions w
 key for that data.) It is, however, safe to do the reverse, by renaming a field and setting its storage alias to
 be its old name.
 
+#### Value Types
+
+By default, ObjectifiedSessions will let you store any arbitrary Ruby object in the session — just like the
+default Rails session support will. However, this can cause significant issues, particularly with sessions; if you
+put, for example, a User model into the session, and then pull it out later (perhaps months later!), any attributes
+you added in the mean time will simply not be present. This is dangerous.
+
+If you add this to your session class:
+
+    allowed_value_types :primitive
+
+...then you will receive an `ArgumentError` if you try to store anything in the session other than `nil`, `true`,
+`false`, a `String`, a `Symbol`, a `Numeric` (including both integers and floating-point numbers), or a `Time`.
+
+If you instead set this as follows:
+
+    allowed_value_types :primitive_and_compound
+
+...then the rules are relaxed to also include `Array`s and `Hash`es, as long as their constituent elements are valid
+simple scalars or themselves `Array`s or `Hash`es. (In other words, you can nest these data types as deeply as you
+would like.)
+
+If, for some reason, you need it, `allowed_value_types :anything` is the default setting.
+
 #### Retiring Fields
 
 Let's say you (probably wisely) stop supporting custom background colors, and remove that field. So far, so good.
@@ -389,3 +421,14 @@ for Gems, plugins, or other code that may be using the session without your know
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+### Running Specs
+
+ObjectifiedSessions is very thoroughly tested, including both system specs (that test the entire system at once) and
+unit specs (that test each class individually).
+
+To run these specs:
+
+1. `cd objectified_sessions` (the root of the gem).
+2. `bundle install`
+3. `bundle exec rspec spec` will run all specs. (Or just `rake`.)

data/lib/objectified_sessions/base.rb

@@ -116,10 +116,51 @@ module ObjectifiedSessions
     # ObjectifiedSessions::Errors::NoSuchFieldError.
     def []=(field_name, new_value)
       field = self.class._ensure_has_field_named(field_name)
+      validate_new_value_type!(new_value)
       _objectified_sessions_underlying_session(true)[field.storage_name] = new_value
       new_value
     end
 
+    # Validates that a new value being assigned to a field is acceptable, according to whatever #allowed_value_types
+    # setting you've set on this class. Does nothing if the data is valid; raises ArgumentError if it's invalid.
+    def validate_new_value_type!(new_value)
+      send("validate_new_value_type_for_#{self.class.allowed_value_types}!", new_value)
+    end
+
+    # Validates that a new value being assigned to a field is acceptable, according to the :anything
+    # #allowed_value_types setting. This allows storing anything, so this method is a no-op.
+    def validate_new_value_type_for_anything!(new_value)
+      # ok
+    end
+
+    # Validates that a new value being assigned to a field is acceptable, according to the :primitive
+    # #allowed_value_types setting. This raises an exception if passed anything but a simple scalar.
+    def validate_new_value_type_for_primitive!(new_value)
+      case new_value
+      when String, Symbol, Numeric, Time, true, false, nil then true
+      else
+        raise ArgumentError, "You've asked your ObjectifiedSession to only allow values of scalar types, but you're trying to store this: #{new_value.inspect}"
+      end
+    end
+
+    # Validates that a new value being assigned to a field is acceptable, according to the :primitive_and_compound
+    # #allowed_value_types setting. This does recursive examination of Arrays and Hashes. Raises an ArgumentError
+    # if there's an invalid value present.
+    def validate_new_value_type_for_primitive_and_compound!(new_value)
+      case new_value
+      when String, Symbol, Numeric, Time, true, false, nil then true
+      when Array then
+        new_value.each { |x| validate_new_value_type_for_primitive_and_compound!(x) }
+      when Hash then
+        new_value.each do |k,v|
+          validate_new_value_type_for_primitive_and_compound!(k)
+          validate_new_value_type_for_primitive_and_compound!(v)
+        end
+      else
+        raise ArgumentError, "You've asked your ObjectifiedSession to only allow values of scalar types, plus Arrays and Hashes, but you're trying to store this (possibly nested): #{new_value.inspect}"
+      end
+    end
+
     DYNAMIC_METHODS_MODULE_NAME = :ObjectifiedSessionsDynamicMethods
 
     class << self
@@ -204,6 +245,27 @@ module ObjectifiedSessions
         end
       end
 
+      ALLOWED_ALLOWED_VALUE_TYPES = %w{anything primitive_and_compound primitive}.map { |x| x.to_sym }
+
+      # Sets the allowed value types on this class, or returns the current setting if no argument is supplied.
+      # The valid settings are:
+      #
+      # [:anything] All values are allowed, including arbitrary Ruby objects.
+      # [:primitive] Only primitive, simple scalars are allowed: nil, true, false, Strings, Symbols, Numerics (including
+      #              both integer and floating-point numbers), and Times. Arrays and Hashes are not allowed.
+      # [:primitive_and_compound] All primitive scalars, plus Arrays and Hashes composed entirely of primitive
+      #                           scalars, plus other Arrays and Hashes, are allowed.
+      def allowed_value_types(allowed = nil)
+        if allowed
+          allowed = allowed.to_s.strip.downcase.to_sym
+          raise ArgumentError, "Invalid value for allowed_value_types: #{allowed.inspect}; we allow: #{ALLOWED_ALLOWED_VALUE_TYPES.inspect}" unless ALLOWED_ALLOWED_VALUE_TYPES.include?(allowed)
+
+          @allowed_value_types = allowed
+        end
+
+        @allowed_value_types ||= :anything
+      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.

data/lib/objectified_sessions/version.rb

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

data/spec/objectified_sessions/system/storage_types_system_spec.rb

@@ -0,0 +1,176 @@
+require 'objectified_sessions'
+require "objectified_sessions/helpers/controller_helper"
+require "objectified_sessions/helpers/exception_helpers"
+
+describe "ObjectifiedSessions storage types" do
+  include ObjectifiedSessions::Helpers::ControllerHelper
+  include ObjectifiedSessions::Helpers::ExceptionHelpers
+
+  before :each do
+    set_new_controller_instance
+  end
+
+  it "should have an object at #objsession, even with an empty class" do
+    define_objsession_class { }
+    @controller_instance.objsession.should be
+  end
+
+  it "should, by default, allow storing anything in the session" do
+    define_objsession_class { field :foo }
+
+    some_class = Class.new
+    some_object = some_class.new
+    some_object.instance_variable_set("@bar", 345)
+    some_object.instance_variable_set("@baz", /yo/)
+
+    expect(@underlying_session).to receive(:[]=).once.with('foo', some_object)
+    @controller_instance.objsession.foo = some_object
+  end
+
+  it "should allow storing anything in the session if explicitly told to" do
+    define_objsession_class do
+      field :foo
+      allowed_value_types :anything
+    end
+
+    some_class = Class.new
+    some_object = some_class.new
+    some_object.instance_variable_set("@bar", 345)
+    some_object.instance_variable_set("@baz", /yo/)
+
+    expect(@underlying_session).to receive(:[]=).once.with('foo', some_object)
+    @controller_instance.objsession.foo = some_object
+  end
+
+  describe ":primitive_and_compound" do
+    before :each do
+      define_objsession_class do
+        field :foo
+        field :bar
+
+        allowed_value_types :primitive_and_compound
+      end
+    end
+
+    it "should allow storing scalars" do
+      expect(@underlying_session).to receive(:[]=).once.with('foo', "foobar")
+      expect { @controller_instance.objsession.foo = "foobar" }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('bar', 134832.32)
+      expect { @controller_instance.objsession.bar = 134832.32 }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('foo', true)
+      expect { @controller_instance.objsession.foo = true }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('bar', false)
+      expect { @controller_instance.objsession.bar = false }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('foo', nil)
+      expect { @controller_instance.objsession.foo = nil }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('foo', :baz)
+      expect { @controller_instance.objsession.foo = :baz }.not_to raise_error
+
+      t = Time.now
+      expect(@underlying_session).to receive(:[]=).once.with('foo', t)
+      expect { @controller_instance.objsession.foo = t }.not_to raise_error
+    end
+
+    it "should allow storing Arrays of scalars" do
+      expect(@underlying_session).to receive(:[]=).once.with('foo', [ 3, 'foo', :zap ])
+      expect { @controller_instance.objsession.foo = [ 3, 'foo', :zap ] }.not_to raise_error
+    end
+
+    it "should allow storing Hashes of scalars" do
+      expect(@underlying_session).to receive(:[]=).once.with('foo', { :one => 1, 'two' => 2 })
+      expect { @controller_instance.objsession.foo = { :one => 1, 'two' => 2 } }.not_to raise_error
+    end
+
+    it "should allow storing compound Arrays" do
+      expect(@underlying_session).to receive(:[]=).once.with('foo', [ 3, [ 2, 4 ], { 'foo' => 'bar' } ])
+      expect { @controller_instance.objsession.foo = [ 3, [ 2, 4 ], { 'foo' => 'bar' } ] }.not_to raise_error
+    end
+
+    it "should allow storing compound Hashes" do
+      expect(@underlying_session).to receive(:[]=).once.with('foo', { [ 1, 2 ] => 'onetwo', 3 => { :bar => [ :foo, 'baz' ] } })
+      expect { @controller_instance.objsession.foo = { [ 1, 2 ] => 'onetwo', 3 => { :bar => [ :foo, 'baz' ] } } }.not_to raise_error
+    end
+
+    it "should not allow storing invalid scalars" do
+      expect { @controller_instance.objsession.foo = /yo/ }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing invalid scalars inside an Array" do
+      expect { @controller_instance.objsession.foo = [ 1, 2, /yo/ ] }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing invalid scalars inside a Hash" do
+      expect { @controller_instance.objsession.foo = { :foo => /yo/ } }.to raise_error(ArgumentError)
+      expect { @controller_instance.objsession.foo = { /yo/ => :foo } }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ":primitive" do
+    before :each do
+      define_objsession_class do
+        field :foo
+        field :bar
+
+        allowed_value_types :primitive
+      end
+    end
+
+    it "should allow storing scalars" do
+      expect(@underlying_session).to receive(:[]=).once.with('foo', "foobar")
+      expect { @controller_instance.objsession.foo = "foobar" }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('bar', 134832.32)
+      expect { @controller_instance.objsession.bar = 134832.32 }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('foo', true)
+      expect { @controller_instance.objsession.foo = true }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('bar', false)
+      expect { @controller_instance.objsession.bar = false }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('foo', nil)
+      expect { @controller_instance.objsession.foo = nil }.not_to raise_error
+
+      expect(@underlying_session).to receive(:[]=).once.with('foo', :baz)
+      expect { @controller_instance.objsession.foo = :baz }.not_to raise_error
+
+      t = Time.now
+      expect(@underlying_session).to receive(:[]=).once.with('foo', t)
+      expect { @controller_instance.objsession.foo = t }.not_to raise_error
+    end
+
+    it "should not allow storing Arrays of scalars" do
+      expect { @controller_instance.objsession.foo = [ 3, 'foo', :zap ] }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing Hashes of scalars" do
+      expect { @controller_instance.objsession.foo = { :one => 1, 'two' => 2 } }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing compound Arrays" do
+      expect { @controller_instance.objsession.foo = [ 3, [ 2, 4 ], { 'foo' => 'bar' } ] }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing compound Hashes" do
+      expect { @controller_instance.objsession.foo = { [ 1, 2 ] => 'onetwo', 3 => { :bar => [ :foo, 'baz' ] } } }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing invalid scalars" do
+      expect { @controller_instance.objsession.foo = /yo/ }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing invalid scalars inside an Array" do
+      expect { @controller_instance.objsession.foo = [ 1, 2, /yo/ ] }.to raise_error(ArgumentError)
+    end
+
+    it "should not allow storing invalid scalars inside a Hash" do
+      expect { @controller_instance.objsession.foo = { :foo => /yo/ } }.to raise_error(ArgumentError)
+      expect { @controller_instance.objsession.foo = { /yo/ => :foo } }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/objectified_sessions/unit/objectified_sessions/base_spec.rb

@@ -111,7 +111,27 @@ describe ObjectifiedSessions::Base do
   end
 
   describe "retrieving field names" do
+    before :each do
+      @field_foo = expect_and_create_field!(:foo, 'foo', true, false, { :type => :normal, :visibility => :public })
+      @class.field :foo
+      @field_bar = expect_and_create_field!(:bar, 'bar', true, false, { :type => :normal, :visibility => :public })
+      @class.field :bar
+      @field_baz = expect_and_create_field!(:baz, 'baz', true, false, { :type => :normal, :visibility => :public })
+      @class.field :baz
+      @field_ret = expect_and_create_field!(:ret, 'ret', false, true, { :type => :retired, :visibility => :public })
+      @class.retired :ret
+      @field_ina = expect_and_create_field!(:ina, 'ina', false, false, { :type => :inactive, :visibility => :public })
+      @class.inactive :ina
+    end
+
+    it "should return all normal fields, but not active or retired, from the class" do
+      @class.accessible_field_names.sort_by { |x| x.to_s }.should == %w{foo bar baz}.map { |x| x.to_sym }.sort_by { |x| x.to_s }
+    end
 
+    it "should return all normal fields, but not active or retired, from the instance" do
+      instance = new_instance!
+      instance.field_names.sort_by { |x| x.to_s }.should == %w{foo bar baz}.map { |x| x.to_sym }.sort_by { |x| x.to_s }
+    end
   end
 
   describe "reading fields" do
@@ -393,6 +413,64 @@ describe ObjectifiedSessions::Base do
     @class.unknown_fields.should == :preserve
   end
 
+  it "should allow setting allowed_value_types to any valid value, but not invalid values, and return it" do
+    @class.allowed_value_types.should == :anything
+    @class.allowed_value_types :primitive
+    @class.allowed_value_types.should == :primitive
+    @class.allowed_value_types :primitive_and_compound
+    @class.allowed_value_types.should == :primitive_and_compound
+    @class.allowed_value_types :anything
+    @class.allowed_value_types.should == :anything
+  end
+
+  describe "new-value type validation" do
+    before :each do
+      @field_foo = expect_and_create_field!(:foo, 'foo', true, false, { :type => :normal, :visibility => :public })
+      @class.field :foo
+
+      @instance = new_instance!
+
+      @scalars = [ "string", :symbol, true, false, nil, Time.now ]
+      @compound = [ [ 1, 2, 3 ], { 'foo' => 123 }, [ 1, [ 2, 3 ], 4 ], { 'foo' => [ 1, 2, 3 ] } ]
+
+      my_class = Class.new
+      @arbitrary = [ /something/, my_class.new, [ 1, 2, /foo/ ], { 'foo' => /foo/ } ]
+    end
+
+    it "should allow anything by default" do
+      (@scalars + @compound + @arbitrary).each do |value|
+        expect(@underlying_session).to receive(:[]=).once.with('foo', value)
+        @instance.send(:[]=, :foo, value)
+      end
+    end
+
+    it "should allow only simple scalars for :primitive" do
+      @class.allowed_value_types :primitive
+
+      (@scalars).each do |value|
+        expect(@underlying_session).to receive(:[]=).once.with('foo', value)
+        @instance.send(:[]=, :foo, value)
+      end
+
+      (@compound + @arbitrary).each do |value|
+        lambda { @instance.send(:[]=, :foo, value) }.should raise_error(ArgumentError)
+      end
+    end
+
+    it "should allow simple scalars and compounds of those for :primitive_and_compound" do
+      @class.allowed_value_types :primitive_and_compound
+
+      (@scalars + @compound).each do |value|
+        expect(@underlying_session).to receive(:[]=).once.with('foo', value)
+        @instance.send(:[]=, :foo, value)
+      end
+
+      (@arbitrary).each do |value|
+        lambda { @instance.send(:[]=, :foo, value) }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
   it "should return only fields in #accessible_field_names, return fields by name or storage name appropriately, and raise NoSuchFieldError when appropriate" do
     @field_foo = expect_and_create_field!(:foo, 'stg1', true, false, { :type => :normal, :visibility => :public, :storage => :stg1 })
     @class.field :foo, :storage => :stg1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: objectified_sessions
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors: 
 - Andrew Geweke
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-12-29 00:00:00 Z
+date: 2014-02-06 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler
@@ -85,6 +85,7 @@ files:
 - spec/objectified_sessions/system/prefix_system_spec.rb
 - spec/objectified_sessions/system/retired_inactive_system_spec.rb
 - spec/objectified_sessions/system/setup_system_spec.rb
+- spec/objectified_sessions/system/storage_types_system_spec.rb
 - spec/objectified_sessions/system/strings_symbols_system_spec.rb
 - spec/objectified_sessions/system/unknown_data_system_spec.rb
 - spec/objectified_sessions/system/visibility_system_spec.rb