permissive 0.0.0 → 0.0.1

data/.gemspec

@@ -0,0 +1,45 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{permissive}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Flip Sasser", "Simon Parsons"]
+  s.date = %q{2009-11-01}
+  s.description = %q{Permissive combines a model-based permissions system with bitmasking to
+    create a flexible approach to maintaining permissions on your ActiveRecord
+    models. It supports an easy-to-use set of methods for accessing and
+    determining permissions, including some fun metaprogramming.}
+  s.email = %q{flip@x451.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "VERSION"
+  ]
+  s.homepage = %q{http://github.com/flipsasser/permissive}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Permissive gives your ActiveRecord models granular permission support}
+  s.test_files = [
+    "spec/acts_as_permissive_spec.rb",
+     "spec/permissions_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+pkg/

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Flip Sasser
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -13,7 +13,7 @@ Installation
 	`gem install permissive`
 
 	or as a plugin:
-	
+
 	`script/plugin install git://github.com/flipsasser/permissive.git`
 
 2. Generate a migration so you can get some sweet table action:
@@ -30,20 +30,20 @@ First, define a few permissions constants. We'll define them in `Rails.root/conf
 Permission constants need to be int values counting up from zero. We use ints because Permissive uses bit masking to keep permissions data compact and performant.
 
 	module Permissive::Permissions
-		MANAGE_GAMES = 0
-		CONTROL_RIDES = 1
-		PUNCH = 2
+	  MANAGE_GAMES = 0
+	  CONTROL_RIDES = 1
+	  PUNCH = 2
 	end
 
 And that's all it takes to configure permissions! Now that we have them, let's grant them to a model or two:
 
 	class Employee < ActiveRecord::Base
-		acts_as_permissive
-		validates_presence_of :first_name, :last_name
+	  acts_as_permissive
+	  validates_presence_of :first_name, :last_name
 	end
 
 	class Company < ActiveRecord::Base
-		validates_presence_of :name
+	  validates_presence_of :name
 	end
 
 Easy-peasy, right? Let's try granting a few permissions:
@@ -98,7 +98,7 @@ Scoping
 Permissive supports scoping at the class-configuration level, which adds relationships to permitted objects:
 
 	class Employee < ActiveRecord::Base
-		acts_as_permissive :scope => :company
+	  acts_as_permissive :scope => :company
 	end
 
 	@frigo.permissive_companies #=> [Company 1, Company 2]
@@ -116,10 +116,10 @@ Next Steps
 There's a number of things I want to add to the permissive settings. At the moment, Permissive currently support scoping at the class level, BUT all it really does is add a `has_many` relationship. `@employee.can!(:do_anything)` will still work, as will `@employee.can!(:do_something, :on => @something_that_isnt_a_company)`. That's pretty confusing to me. Adding more granular permissions might be cooler:
 
 	class Employee < ActiveRecord::Base
-		has_permissions do
-			on :companies
-			on :employees
-		end
+	  has_permissions do
+	    on :companies
+	    on :employees
+	  end
 	end
 
 which might yield something like
@@ -154,10 +154,10 @@ Next up! I currently use a manual reset to grant permissions through a controlle
 .. and in the controller:
 
 	def update
-		@employee.can!(params[:employees].delete(:permissions), :revert => true)
-		respond_to do |format|
-			...
-		end
+	  @employee.can!(params[:employees].delete(:permissions), :revert => true)
+	  respond_to do |format|
+	    ...
+	  end
 	end
 
 Finally, I'd like to use the `grant_mask` support that exists on the Permissive::Permission model to control what people can or cannot allow others to do. This would necessitate one of two things - first, a quick way of iterating over a person's granting permissions, e.g.:
@@ -169,11 +169,11 @@ Finally, I'd like to use the `grant_mask` support that exists on the Permissive:
 and second, write-time checking of grantor permissions. Something like this, maybe:
 
 	def update
-		current_user.grant(params[:employees][:permissions], :to => @employee)
+	  current_user.grant(params[:employees][:permissions], :to => @employee)
 	end
 
 which would allow the Permissive::Permission model to make sure whatever `current_user` is granting to @employee, they're **allowed** to grant to @employee.
 
 And that's it! Like all of my projects, I extracted it from some live development - which means it, too, is still in development. So please feel free to contribute!
 
-Copyright (c) 2009 Flip Sasser, released under the MIT license
+Copyright (c) 2009 Flip Sasser & Simon Parsons, released under the MIT license

data/README.markdown.html

@@ -0,0 +1,191 @@
+<h1>Permissive gives your ActiveRecord models granular permission support</h1>
+
+<p>Permissive combines a model-based permissions system with bitmasking to
+create a flexible approach to maintaining permissions on your ActiveRecord
+models. It supports an easy-to-use set of methods for accessing and
+determining permissions, including some fun metaprogramming.</p>
+
+<h2>Installation</h2>
+
+<ol>
+<li><p>Get yourself some code. You can install as a gem:</p>
+
+<p><code>gem install permissive</code></p>
+
+<p>or as a plugin:</p>
+
+<p><code>script/plugin install git://github.com/flipsasser/permissive.git</code></p></li>
+<li><p>Generate a migration so you can get some sweet table action:</p>
+
+<p><code>script/generate permissive_migration</code></p>
+
+<p><code>rake db:migrate</code></p></li>
+</ol>
+
+
+<h2>Usage</h2>
+
+<p>First, define a few permissions constants. We'll define them in <code>Rails.root/config/initializers/permissive.rb</code>. The best practice is to name them in a verb format that follows this pattern: "Object can <code>DO_PERMISSION_NAME</code>".</p>
+
+<p>Permission constants need to be int values counting up from zero. We use ints because Permissive uses bit masking to keep permissions data compact and performant.</p>
+
+<pre><code>module Permissive::Permissions
+  MANAGE_GAMES = 0
+  CONTROL_RIDES = 1
+  PUNCH = 2
+end
+</code></pre>
+
+<p>And that's all it takes to configure permissions! Now that we have them, let's grant them to a model or two:</p>
+
+<pre><code>class Employee &lt; ActiveRecord::Base
+  acts_as_permissive
+  validates_presence_of :first_name, :last_name
+end
+
+class Company &lt; ActiveRecord::Base
+  validates_presence_of :name
+end
+</code></pre>
+
+<p>Easy-peasy, right? Let's try granting a few permissions:</p>
+
+<pre><code>@james = Employee.create(:first_name =&gt; 'James', :last_name =&gt; 'Brennan')
+@frigo = Employee.create(:first_name =&gt; 'Tommy', :last_name =&gt; 'Frigo')
+@adventureland = Company.create(:name =&gt; 'Adventureland')
+
+# Okay, let's do some granting. We'll start by scoping to a specific company.
+@james.can!(:manage_games, :on =&gt; @adventureland)
+
+# Now let's do some permission checking.
+@james.can?(:manage_games, :on =&gt; @adventureland) #=&gt; true
+
+# We can also use the metaprogramming syntax:
+@james.can_manage_games_on?(@adventureland) #=&gt; true
+@james.can_control_rides_on?(@adventureland) #=&gt; false
+
+# We can check for multiple permissions, too:
+@james.can?(:manage_games, :control_rides) #=&gt; false
+# OR:
+@james.can_manage_games_and_control_rides?
+
+# Scoping can be done through any object
+@frigo.can!(:punch, :on =&gt; @james)
+@frigo.can_punch_on?(@james) #=&gt; true
+
+# And the permissions aren't reciprocal
+@james.can_punch_on?(@frigo) #=&gt; false
+
+# Of course, we can grant global (non-scoped) permissions, too:
+@frigo.can!(:control_rides)
+@frigo.can_control_rides? #=&gt; true
+
+# BUT! Global permissions don't override scoped permissions.
+@frigo.can_control_rides_on?(@adventureland) #=&gt; false
+
+# Likewise, scoped permissions don't bubble up globally:
+@james.can_manage_games? #=&gt; false
+
+# And, last but not least, let's take all of those great permissions away:
+@james.revoke(:manage_games, :on =&gt; @adventureland)
+
+# We can revoke all permissions, in any scope, too:
+@frigo.revoke(:all)
+</code></pre>
+
+<p>And that's it!</p>
+
+<h2>Scoping</h2>
+
+<p>Permissive supports scoping at the class-configuration level, which adds relationships to permitted objects:</p>
+
+<pre><code>class Employee &lt; ActiveRecord::Base
+  acts_as_permissive :scope =&gt; :company
+end
+
+@frigo.permissive_companies #=&gt; [Company 1, Company 2]
+</code></pre>
+
+<h2>Replacing Permissions</h2>
+
+<p>Sometimes you want to overwrite all previous permissions in a can! method. That's pretty easy: just add :reset => true to the options.</p>
+
+<pre><code>@frigo.can!(:control_rides, :on =&gt; @adventureland, :reset =&gt; true)
+</code></pre>
+
+<h2>Next Steps</h2>
+
+<p>There's a number of things I want to add to the permissive settings. At the moment, Permissive currently support scoping at the class level, BUT all it really does is add a <code>has_many</code> relationship. <code>@employee.can!(:do_anything)</code> will still work, as will <code>@employee.can!(:do_something, :on =&gt; @something_that_isnt_a_company)</code>. That's pretty confusing to me. Adding more granular permissions might be cooler:</p>
+
+<pre><code>class Employee &lt; ActiveRecord::Base
+  has_permissions do
+    on :companies
+    on :employees
+  end
+end
+</code></pre>
+
+<p>which might yield something like</p>
+
+<pre><code>@employee.permissive_companies
+# and
+@employee.can_control_rides_in_company @adventureland
+</code></pre>
+
+<p>I'd also like to support a more intelligent grammar:</p>
+
+<pre><code>@james.can_punch? @frigo
+@frigo.can!(:control_rides, :in =&gt; @adventureland)
+</code></pre>
+
+<p>Meta-programmed methods for granting and revoking would be cool, too:</p>
+
+<pre><code>@james.can_punch! @frigo
+@frigo.cannot_control_rides_in! @adventureland
+</code></pre>
+
+<p>And while we're on the subject of metaprogramming, let's add some OR-ing to the whole thing:</p>
+
+<pre><code>@james.can_control_rides_or_manage_games_in? @adventureland
+</code></pre>
+
+<p>I'd also like to enable Permissive::Templates (pre-set permission groups, like roles):</p>
+
+<pre><code>administrator = Permissive::Template.named('Administrator')
+@james.acts_like administrator
+</code></pre>
+
+<p>Next up! I currently use a manual reset to grant permissions through a controller. It would by great to DRY this stuff up and provide some decent path for moving permissions into HTML forms. Right now, it looks something like this:</p>
+
+<pre><code>&lt;%= check_box_tag("employee[permissions][]", Permissive::Permissions::CONTROL_RIDES, @employee.can_control_rides?) %&gt; Control rides
+</code></pre>
+
+<p>.. and in the controller:</p>
+
+<pre><code>def update
+  @employee.can!(params[:employees].delete(:permissions), :revert =&gt; true)
+  respond_to do |format|
+    ...
+  end
+end
+</code></pre>
+
+<p>Finally, I'd like to use the <code>grant_mask</code> support that exists on the Permissive::Permission model to control what people can or cannot allow others to do. This would necessitate one of two things - first, a quick way of iterating over a person's granting permissions, e.g.:</p>
+
+<pre><code>&lt;% current_user.grant_permissions.each do |permission| %&gt;
+&lt;!-- Do something! --&gt;
+&lt;% end %&gt;
+</code></pre>
+
+<p>and second, write-time checking of grantor permissions. Something like this, maybe:</p>
+
+<pre><code>def update
+  current_user.grant(params[:employees][:permissions], :to =&gt; @employee)
+end
+</code></pre>
+
+<p>which would allow the Permissive::Permission model to make sure whatever <code>current_user</code> is granting to @employee, they're <strong>allowed</strong> to grant to @employee.</p>
+
+<p>And that's it! Like all of my projects, I extracted it from some live development - which means it, too, is still in development. So please feel free to contribute!</p>
+
+<p>Copyright (c) 2009 Flip Sasser, released under the MIT license</p>

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc 'Run the specs with Rcov output'
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_files = FileList['spec/**/*.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'examples']
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "permissive"
+    gemspec.summary = "Permissive gives your ActiveRecord models granular permission support"
+    gemspec.description = %{Permissive combines a model-based permissions system with bitmasking to
+    create a flexible approach to maintaining permissions on your ActiveRecord
+    models. It supports an easy-to-use set of methods for accessing and
+    determining permissions, including some fun metaprogramming.}
+    gemspec.email = "flip@x451.com"
+    gemspec.homepage = "http://github.com/flipsasser/permissive"
+    gemspec.authors = ["Flip Sasser", "Simon Parsons"]
+  end
+rescue LoadError
+end

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/generators/permissive_migration/USAGE

@@ -0,0 +1,7 @@
+Usage:
+
+  script/generate permissive_migration
+  
+This will create a migration that will add the Permissive tables to your
+application. You can modify this migration to your heart's content. When
+you're done, run `rake db:migrate` and Permissive will be ready to go!

data/generators/permissive_migration/permissive_migration_generator.rb

@@ -0,0 +1,7 @@
+class PermissiveMigrationGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.migration_template 'permissive_migration.rb', File.join('db', 'migrate'), :migration_file_name => 'install_permissive'
+    end
+  end
+end

data/generators/permissive_migration/templates/permissive_migration.rb

@@ -0,0 +1,20 @@
+class InstallPermissive < ActiveRecord::Migration
+  def self.up
+    create_table :permissive_permissions do |t|
+      t.integer :permitted_object_id
+      t.string :permitted_object_type, :limit => 32
+      t.integer :scoped_object_id
+      t.string :scoped_object_type, :limit => 32
+      t.integer :mask, :default => 0
+      t.integer :grant_mask, :default => 0
+    end
+    add_index :permissive_permissions, [:permitted_object_id, :permitted_object_type], :name => 'permissive_permitted'
+    add_index :permissive_permissions, [:scoped_object_id, :scoped_object_type], :name => 'permissive_scoped'
+    add_index :permissive_permissions, :mask, :name => 'permissive_masks'
+    add_index :permissive_permissions, :grant_mask, :name => 'permissive_grant_masks'
+  end
+
+  def self.down
+    drop_table :permissive_permissions
+  end
+end

data/lib/permissive.rb

@@ -0,0 +1,15 @@
+require 'permissive/permission'
+require 'permissive/acts_as_permissive'
+require 'permissive/permissions'
+
+module Permissive
+  @@strong = false
+
+  def self.strong
+    @@strong
+  end
+
+  def self.strong=(new_strong)
+    @@strong = !!new_strong
+  end
+end

data/lib/permissive/acts_as_permissive.rb

@@ -0,0 +1,134 @@
+module Permissive
+  module ActsAsPermissive
+    def self.included(base)
+      base.class_eval do
+        # This is the core of the Permissive module. It allows you to define a
+        # permissive model structure complete with :scope. This will dynamically
+        # generate scoped, polymorphic relationships across one or more models.
+        def self.acts_as_permissive(options = {})
+          options.assert_valid_keys(:scope)
+          has_many :permissions, :class_name => 'Permissive::Permission', :as => :permitted_object do
+            def can!(*args)
+              options = args.last.is_a?(Hash) ? args.pop : {}
+              options.assert_valid_keys(:on, :reset)
+              if options[:on]
+                permission = proxy_owner.permissions.find_or_initialize_by_scoped_object_id_and_scoped_object_type(options[:on].id, options[:on].class.to_s)
+              else
+                permission = Permissive::Permission.find_or_initialize_by_permitted_object_id_and_permitted_object_type(proxy_owner.id, proxy_owner.class.to_s)
+              end
+              if options[:reset]
+                permission.mask = 0
+                permission.grant_mask = 0
+              end
+              args.flatten.each do |name|
+                bit = bit_for(name)
+                unless permission.mask & bit != 0
+                  permission.mask = permission.mask | bit
+                end
+              end
+              permission.save!
+            end
+
+            def can?(*args)
+              options = args.last.is_a?(Hash) ? args.pop : {}
+              bits = args.map{|name| bit_for(name) }
+              # scope = nil
+              # if options[:on]
+              #   scope = scoped(:conditions => ['scoped_object_id = ? AND scoped_object_type = ?', options[:on].id, options[:on].class.to_s])
+              # else
+              #   scope = scoped(:conditions => ['scoped_object_id IS NULL AND scoped_object_type IS NULL'])
+              # end
+              # Skip the trip to the database if the proxy has been loaded up already...
+              # TODO: Fix this per-scope ... somehow ... probably beyond the scope of this project.
+              # if @loaded
+              #   bits.all?{|bit| self.select{|permission| permission.mask & bit != 0} }
+              # else
+              on(options[:on]).count(:conditions => [bits.map { 'permissive_permissions.mask & ?' }.join(' AND '), *bits]) > 0
+              # end
+            end
+
+            def revoke(*args)
+              options = args.last.is_a?(Hash) ? args.pop : {}
+              if args.length == 1 && args.first == :all
+                on(options[:on]).destroy_all
+              else
+                bits = args.map{|name| bit_for(name) }
+                on(options[:on]).each do |permission|
+                  bits.each do |bit|
+                    if permission.mask & bit
+                      permission.mask = permission.mask ^ bit
+                    end
+                  end
+                  permission.save!
+                end
+              end
+            end
+          end
+
+          if options[:scope]
+            scope_name = "permissive_#{options[:scope].to_s}"
+            unless reflection = reflect_on_association(scope_name)
+              # TODO: There's just no way this should be working. It's WAY too
+              # fragile. We need support for something more intelligent here,
+              # like an options hash that includes :scope_type.
+              namespace = self.to_s.split('::')
+              if namespace.length > 1
+                namespace.pop
+                class_name = namespace.join('::') 
+              else
+                class_name = ''
+              end
+              class_name << "::#{options[:scope].to_s.classify}"
+              has_many scope_name, :through => :permissions, :source => :scoped_object, :source_type => class_name
+            end
+          end
+
+          class_eval do
+            # Pass calls to the instance down to its permissions collection
+            #   e.g. current_user.can(:view_comments) will bubble to
+            #        current_user.permissions.can(:view_comments)
+            def can!(*args)
+              permissions.can!(*args)
+            end
+
+            # Pass calls to the instance down to its permissions collection
+            #   e.g. current_user.can(:view_comments) will bubble to
+            #        current_user.permissions.can(:view_comments)
+            def can?(*args)
+              permissions.can?(*args)
+            end
+
+            def revoke(*args)
+              permissions.revoke(*args)
+            end
+
+            def method_missing(method, *args)
+              if method.to_s =~ /^can_([^\?]+)\?$/
+                permissions = $1
+                options = {}
+                if permissions =~ /_on$/
+                  permissions.chomp!('_on')
+                  options[:on] = args.shift
+                end
+                permissions = permissions.split('_and_')
+                if permissions.all? {|permission| Permissive::Permissions.hash.has_key?(permission.downcase.to_sym) }
+                  class_eval <<-end_eval
+                    def #{method}#{"(scope)" if options[:on]}
+                      can?(#{[permissions, args].flatten.join(', ').inspect}#{", :on => scope" if options[:on]})
+                    end
+                  end_eval
+                  return can?(*[permissions, options].flatten)
+                end
+              end
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send :include, Permissive::ActsAsPermissive
+end

data/lib/permissive/permission.rb

@@ -0,0 +1,43 @@
+# This is the core permission class that Permissive uses.
+module Permissive
+  class Permission < ActiveRecord::Base
+    attr_writer :grant_template, :template
+    belongs_to :permitted_object, :polymorphic => true
+    belongs_to :scoped_object, :polymorphic => true
+    named_scope :on, lambda {|scoped_object|
+      if scoped_object.nil?
+        {:conditions => ['scoped_object_id IS NULL AND scoped_object_type IS NULL']}
+      else
+        {:conditions => ['scoped_object_id = ? AND scoped_object_type = ?', scoped_object.id, scoped_object.class.to_s]}
+      end
+    }
+    set_table_name :permissive_permissions
+    validates_presence_of :grant_mask, :mask, :permitted_object
+
+    class << self
+      # Use this anywhere!
+      def bit_for(permission)
+        Permissive::Permissions.hash[permission.to_s.downcase.to_sym] || 0
+      end
+    end
+
+    protected
+    def before_save
+      # Save permission templates or "Roles"
+      if @grant_template
+        grant_mask = @grant_template
+      end
+      if @template
+        mask = @template
+      end
+
+      # If Permissive is set to be seriously intense about who can grant what to
+      # whom, it makes sure no bits on the grant_mask exceed those of the
+      # permission mask
+      # TODO: You know ... this.
+      # if grant_mask && Permissive.strong
+      #   grant_mask = grant_mask & mask
+      # end
+    end
+  end
+end

data/lib/permissive/permissions.rb

@@ -0,0 +1,29 @@
+# TODO: Abstract this module more later
+module Permissive
+  class PermissionError < StandardError; end;
+
+  module Permissions
+    class << self
+      def const_set(*args)
+        @@hash = nil
+        super
+      end
+
+      def hash
+        @@hash ||= begin
+          bitwise_hash = constants.inject({}) do |hash, constant_name|
+            hash[constant_name.downcase] = 2 ** Permissive::Permissions.const_get(constant_name.to_sym)
+            hash
+          end
+          inverted_hash = bitwise_hash.invert
+          bitwise_hash.values.sort.inject(ActiveSupport::OrderedHash.new) do |hash, value|
+            hash[inverted_hash[value].to_sym] = value
+            hash
+          end
+        rescue ArgumentError
+          raise Permissive::PermissionError.new("Permissions must be integers or longs. Strings, symbols, and floats are not currently supported.")
+        end
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+# Init.rb is here to make this gem'able down the road
+require 'permissive'

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude "spec/*,gems/*"
+--rails

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--colour
+--format progress
+--loadby mtime

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: permissive
 version: !ruby/object:Gem::Version 
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors: 
 - Flip Sasser
@@ -26,9 +26,28 @@ extensions: []
 
 extra_rdoc_files: 
 - README.markdown
+- README.markdown.html
 files: 
-- VERSION
+- .gemspec
+- .gitignore
+- MIT-LICENSE
 - README.markdown
+- Rakefile
+- VERSION
+- generators/permissive_migration/USAGE
+- generators/permissive_migration/permissive_migration_generator.rb
+- generators/permissive_migration/templates/permissive_migration.rb
+- lib/permissive.rb
+- lib/permissive/acts_as_permissive.rb
+- lib/permissive/permission.rb
+- lib/permissive/permissions.rb
+- rails/init.rb
+- spec/acts_as_permissive_spec.rb
+- spec/permissions_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+- README.markdown.html
 has_rdoc: true
 homepage: http://github.com/flipsasser/permissive
 licenses: []