authlogic_crowd 0.2.3

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,26 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+doc
+pkg
+.bundle
+.idea
+.yardoc
+
+## PROJECT::SPECIFIC
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in simple_crowd.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,14 @@
+= authlogic_crowd
+
+Incomplete Authlogic plugin for Atlassian Crowd ( do not use )
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc 'Run tests for InheritedResources.'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for InheritedResources.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'InheritedResources'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/authlogic_crowd.gemspec

@@ -0,0 +1,47 @@
+$:.push File.expand_path("../lib",__FILE__)
+require 'authlogic_crowd/version'
+
+Gem::Specification.new do |s|
+  s.name = %q{authlogic_crowd}
+  s.version = AuthlogicCrowd::VERSION.dup
+  s.platform = Gem::Platform::RUBY
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Paul Strong"]
+  s.description = %q{Authlogic Crowd}
+  s.email = %q{paul@thestrongfamily.org}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = %w(
+    .document
+    .gitignore
+    Gemfile
+    README.rdoc
+    Rakefile
+    authlogic_crowd.gemspec
+    lib/authlogic_crowd.rb
+    lib/authlogic_crowd/acts_as_authentic.rb
+    lib/authlogic_crowd/acts_as_authentic_callbacks.rb
+    lib/authlogic_crowd/session.rb
+    lib/authlogic_crowd/session_callbacks.rb
+    lib/authlogic_crowd/version.rb
+    test/helper.rb
+    test/test_authlogic_crowd.rb
+  )
+  s.test_files = %w(
+    test/helper.rb
+    test/test_authlogic_crowd.rb
+  )
+  s.homepage = %q{http://github.com/lapluviosilla/authlogic_crowd}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Atlassian Crowd support for Authlogic}
+
+  s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  s.add_development_dependency(%q<fcoury-matchy>, [">= 0"])
+  s.add_development_dependency(%q<rr>, [">= 0"])
+  s.add_runtime_dependency(%q<authlogic>, [">= 2.1.3", "< 3.0.0"])
+  s.add_runtime_dependency(%q<simple_crowd>, [">= 1.0.0"])
+
+end
+

data/lib/authlogic_crowd/acts_as_authentic.rb

@@ -0,0 +1,134 @@
+module AuthlogicCrowd
+  module ActsAsAuthentic
+    # Adds in the neccesary modules for acts_as_authentic to include and also disabled password validation if
+    # OpenID is being used.
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        add_acts_as_authentic_module(Methods, :prepend)
+      end
+    end
+    module Config
+
+      # **REQUIRED**
+      #
+      # Specify your crowd service url.
+      # @param [String] url to use when calling Crowd
+      def crowd_service_url(url=nil)
+        rw_config(:crowd_service_url, url, "http://localhost:8095/crowd/services/SecurityServer")
+      end
+      alias_method :crowd_service_url=, :crowd_service_url
+
+      # **REQUIRED**
+      #
+      # Specify your crowd app name.
+      # @param [String] name of app to use when calling Crowd
+      def crowd_app_name(name=nil)
+        rw_config(:crowd_app_name, name, nil)
+      end
+      alias_method :crowd_app_name=, :crowd_app_name
+
+      # **REQUIRED**
+      #
+      # Specify your crowd app password.
+      # @param [String] password Plain-text password for crowd app validation
+      def crowd_app_password(password=nil)
+        rw_config(:crowd_app_password, password, nil)
+      end
+      alias_method :crowd_app_password=, :crowd_app_password
+
+      def crowd_user_token_field(value = nil)
+        rw_config(:crowd_user_token_field, value, :crowd_user_token)
+      end
+      alias_method :crowd_user_token_field=, :crowd_user_token_field
+
+    end
+    module Methods
+      def self.included(klass)
+        klass.class_eval do
+          validate_on_create :must_have_unique_crowd_login
+
+          # TODO: Cleanup and refactor into callbacks
+          def create
+            if using_crowd? && !crowd_record
+              crowd_user = self.create_crowd_user
+              if crowd_user
+                # Crowd is going to store password so clear them from local object
+                self.clear_passwords
+                result = super
+                # Delete crowd user if local creation failed
+                crowd_client.delete_user crowd_user.user unless result
+                if result
+                  user_token = crowd_client.create_user_token crowd_user.username
+                  session_class.crowd_user_token = user_token unless
+                      session_class.controller && session_class.controller.session[:"crowd.token_key"]
+                end
+                return result
+              end
+            end
+            super
+          end
+          validates_length_of_password_field_options validates_length_of_password_field_options.merge(:on => :create)
+          validates_confirmation_of_password_field_options validates_confirmation_of_password_field_options.merge(:on => :create)
+          validates_length_of_password_confirmation_field_options validates_length_of_password_confirmation_field_options.merge(:on => :create)
+        end
+      end
+
+      attr_accessor :crowd_record
+
+      protected
+
+      def create_crowd_user
+        return unless self.login && @password
+        self.crowd_record = SimpleCrowd::User.new({:username => self.login})
+        sync_on_create
+        crowd_client.add_user self.crowd_record, @password
+      end
+
+      def clear_passwords
+        @password = nil
+        @password_changed = false
+        send("#{self.class.crypted_password_field}=", nil) if self.class.crypted_password_field
+        send("#{self.class.password_salt_field}=", nil) if self.class.password_salt_field
+      end
+
+      private
+
+      def must_have_unique_crowd_login
+        login = send(self.class.login_field)
+        crowd_user = crowd_client.find_user_by_name(login)
+        errors.add(self.class.login_field, "is already taken") unless crowd_user.nil? || !errors.on(self.class.login_field).nil?
+      end
+
+      def crowd_client
+        @crowd_client ||= SimpleCrowd::Client.new(crowd_config)
+      end
+      def load_crowd_app_token
+        cached_token = Rails.cache.read('crowd_app_token')
+        crowd_client.app_token = cached_token unless cached_token.nil?
+        Rails.cache.write('crowd_app_token', crowd_client.app_token) unless cached_token == crowd_client.app_token
+      end
+      def crowd_cookie_info
+        unless @crowd_cookie_info
+          cached_info = Rails.cache.read('crowd_cookie_info')
+          @crowd_cookie_info ||= cached_info || crowd_client.get_cookie_info
+          Rails.cache.write('crowd_cookie_info', @crowd_cookie_info) unless cached_info == @crowd_cookie_info
+        end
+        @crowd_cookie_info
+      end
+      def crowd_config
+        {:service_url => self.class.crowd_service_url,
+          :app_name => self.class.crowd_app_name,
+          :app_password => self.class.crowd_app_password}
+      end
+
+      def using_crowd?
+        !(self.class.crowd_app_name.nil? || self.class.crowd_app_password.nil? || self.class.crowd_service_url.nil?)
+      end
+
+      def validate_password_with_crowd?
+        #!using_crowd? && require_password?
+      end
+    end
+  end
+end

data/lib/authlogic_crowd/acts_as_authentic_callbacks.rb

@@ -0,0 +1,26 @@
+module AuthlogicCrowd
+  module ActsAsAuthenticCallbacks
+    def self.included(klass)
+      klass.class_eval do
+        add_acts_as_authentic_module(Methods, :prepend)
+      end
+    end
+    module Methods
+      METHODS = [
+        "sync_on_create"
+      ]
+      def self.included(base)
+        base.send :include, ActiveSupport::Callbacks
+        base.define_callbacks *METHODS
+      end
+      private
+      METHODS.each do |method|
+        class_eval <<-"end_eval", __FILE__, __LINE__
+          def #{method}
+            run_callbacks(:#{method}) { |result, object| result == false }
+          end
+        end_eval
+      end
+    end
+  end
+end

data/lib/authlogic_crowd/session.rb

@@ -0,0 +1,285 @@
+module AuthlogicCrowd
+  module Session
+    def self.included(klass)
+      klass.class_eval do
+        extend Config
+        include Methods
+      end
+    end
+    module Config
+
+      # Single Signout (defaults to true)
+      # @param [Boolean] value
+      def crowd_sso(value=nil)
+        rw_config(:crowd_sso, value, true)
+      end
+      alias_method :crowd_sso=, :crowd_sso
+      
+      def crowd_sso?
+        crowd_sso
+      end
+
+      # Auto Register is enabled by default.
+	  # Add this in your Session object if you need to disable auto-registration via crowd
+      def auto_register(value=true)
+        auto_register_value(value)
+      end
+      def auto_register_value(value=nil)
+        rw_config(:auto_register,value,true)
+      end
+      alias_method :auto_register=,:auto_register
+
+      def crowd_user_token= token
+        session_user_token = controller && controller.session[:"crowd.token_key"]
+        cookie_user_token = crowd_sso? && controller && controller.cookies[:"crowd.token_key"]
+        cached_info = Rails.cache.read('crowd_cookie_info')
+        @crowd_client ||= SimpleCrowd::Client.new({
+          :service_url => klass.crowd_service_url,
+          :app_name => klass.crowd_app_name,
+          :app_password => klass.crowd_app_password})
+        crowd_cookie_info ||= cached_info || @crowd_client.get_cookie_info
+        controller.session[:"crowd.token_key"] = token unless session_user_token == token || !controller
+        controller.cookies[:"crowd.token_key"] = {:domain => crowd_cookie_info[:domain],
+                                                  :secure => crowd_cookie_info[:secure],
+                                                  :value => token} unless cookie_user_token == token || !crowd_sso? || !controller
+      end
+      def crowd_user_token
+        controller && (controller.params["crowd.token_key"] || controller.cookies[:"crowd.token_key"] || controller.session[:"crowd.token_key"])
+      end
+    end
+    module Methods
+      def self.included(klass)
+        klass.class_eval do
+          attr_accessor :new_registration
+          validate :validate_by_crowd, :if => :authenticating_with_crowd?
+          persist :validate_by_crowd, :if => :authenticating_with_crowd?
+          after_create :sync_with_crowd, :if => :authenticating_with_crowd?
+          before_destroy :logout_of_crowd, :if => [:authenticating_with_crowd?, :sso?]
+        end
+      end
+
+      # Temporary storage of crowd record for syncing purposes
+      attr_accessor :crowd_record
+
+      # Determines if the authenticated user is also a new registration.
+      # For use in the session controller to help direct the most appropriate action to follow.
+      def new_registration?
+        new_registration || !new_registration.nil?
+      end
+
+      # Determines if the authenticated user has a complete registration (no validation errors)
+      # For use in the session controller to help direct the most appropriate action to follow.
+      def registration_complete?
+        attempted_record && attempted_record.valid?
+      end
+
+      def auto_register?
+        self.class.auto_register_value
+      end
+
+      protected
+
+      # Determines whether to use crowd to authenticate and validate the current request
+      # For now we assume the app wants to use Crowd exclusively.
+      # Use crowd authentication if tokens are present or if login/password is available but not valid or is blank in db
+      # TODO: Add flexibility regarding multiple authentication methods and identity mapping
+      def authenticating_with_crowd?
+        errors.empty? &&
+        !klass.crowd_app_name.blank? &&
+        !klass.crowd_app_password.blank? &&
+        ((login_field && (!send(login_field).nil? || !send("protected_#{password_field}").nil?)) ||
+          controller && (controller.cookies[:"crowd.token_key"] || controller.session[:"crowd.token_key"] || controller.params["crowd.token_key"]))
+      end
+
+      def authenticating_with_password?
+        !authenticating_with_crowd? && login_field && (!send(login_field).nil? || !send("protected_#{password_field}").nil?)
+      end
+
+      def sso?
+        self.class.crowd_sso
+      end
+
+#      def credentials
+#        if authenticating_with_crowd?
+#          details = {}
+#          details[login_field.to_sym] = send(login_field)
+#          details[password_field.to_sym] = "<protected>"
+#          details[crowd_user_token_field.to_sym] = send(crowd_user_token_field)
+#          details
+#        else
+#          super
+#        end
+#      end
+
+      def credentials=(value)
+        super
+        values = value.is_a?(Array) ? value : [value]
+        if values.first.is_a?(Hash)
+          values.first.with_indifferent_access.slice(login_field, password_field).each do |field, value|
+            next if value.blank?
+            send("#{field}=", value)
+          end
+        end
+      end
+
+      private
+
+      # Main session validation using Crowd user token.
+      # Uses simple_crowd to verify the user token on the configured crowd server
+      # If no *local* user is found and auto_register is enabled (default) then automatically create *local* user for them
+      # TODO: Cleanup and figure out reason for duplicate calls
+      def validate_by_crowd
+        begin
+        load_crowd_app_token
+        login = send(login_field) || (unauthorized_record && unauthorized_record.login)
+        password = send("protected_#{password_field}")
+        params_user_token = controller && controller.params["crowd.token_key"]
+        session_user_token = controller && controller.session[:"crowd.token_key"]
+        cookie_user_token = sso? && controller && controller.cookies[:"crowd.token_key"]
+        user_token = crowd_user_token
+        crowd_user = nil
+
+        # Lets see if the user passed in an email or a login using the db
+        if !login.blank? && self.unauthorized_record.nil?
+          self.unauthorized_record = klass.respond_to?(:login_or_email_equals) ?
+                                         klass.send(:login_or_email_equals, login).first :
+                                         klass.send("find_by_#{login_field}", login)
+          # If passed in login equals the user email then get the REAL login used by crowd instead
+          login = unauthorized_record.login if !unauthorized_record.nil? && login = unauthorized_record.email
+        end
+
+        if user_token && crowd_client.is_valid_user_token?(user_token)
+        elsif login && password
+          # Authenticate if we don't have token
+          user_token = crowd_client.authenticate_user login, password rescue nil
+
+          # Try one last time to login with crowd email field instead of login
+          if user_token.nil? && self.unauthorized_record.nil? && login =~ Authlogic::Regex.email
+            crowd_user ||= crowd_client.find_user_by_email(login)
+            if crowd_user
+              login = crowd_user.username
+              user_token = crowd_client.authenticate_user login, password rescue nil
+            end
+          end
+        else
+          user_token = nil
+        end
+
+        raise "No user token" if user_token.blank?
+
+        login = crowd_client.find_username_by_token user_token unless login && 
+                (!cookie_user_token || session_user_token == cookie_user_token) &&
+                (!params_user_token || session_user_token == params_user_token)
+        send("#{login_field}=", login)
+        
+        self.class.crowd_user_token = user_token
+        
+        if !self.unauthorized_record.nil? && self.unauthorized_record.login == login
+          self.attempted_record = self.unauthorized_record
+        else
+          self.attempted_record = self.unauthorized_record = klass.send(:"find_by_#{login_field}", login)
+        end
+
+        if !attempted_record
+          # If auto_register enabled then create new user with crowd info
+          if auto_register?
+            crowd_user ||= crowd_client.find_user_by_token user_token
+            self.attempted_record = klass.new :login => crowd_user.username, :email => crowd_user.email
+            self.new_registration = true
+            self.attempted_record.crowd_record = crowd_user
+            self.crowd_record = crowd_user
+            sync
+            self.attempted_record.save_without_session_maintenance
+          else
+            errors.add_to_base("We did not find any accounts with that login. Enter your details and create an account.")
+            return false
+          end
+        end
+        rescue Exception => e
+          errors.add_to_base("Authentication failed. Please try again")
+          # Don't know why it doesn't work the first time,
+          # but if we nil the session key here then the session doesn't get deleted
+          # Leaving the token triggers the validation a second time and successfully destroys the session
+          # REMOVED AS HACK
+          # Hack to fix user_credentials not being deleted on session destroy
+
+          if controller
+            controller.session[:"crowd.token_key"] = nil
+            unless (send(login_field) || (unauthorized_record && unauthorized_record.login) && send("protected_#{password_field}"))
+              # Hack to try and check session without recreating it. (we only want to destroy it if it exists already)
+              # This is to avoid a infinite recursive session creation bug we had a while back
+              curr_klass = klass
+              curr_session = controller.instance_eval { @current_user_session }
+              curr_session.destroy if curr_session
+              controller.session.clear
+            end
+            # Delete by klass name instead of generic user
+            controller.cookies.delete :"#{klass.name.underscore}_credentials"
+            controller.cookies.delete :"crowd.token_key", :domain => crowd_cookie_info[:domain] if sso?
+          end
+          false
+        end
+      end
+
+      def sync_with_crowd
+        # If it's a new registration then the crowd data was just pulled, so skip syncing on login
+        unless new_registration? || !self.attempted_record
+          login = send(login_field) || (!attempted_record.nil? && attempted_record.login)
+          user_token = controller && (controller.params["crowd.token_key"] || controller.cookies[:"crowd.token_key"] || controller.session[:"crowd.token_key"])
+          crowd_user = if login
+            crowd_client.find_user_by_name login
+          elsif user_token
+            crowd_client.find_user_by_token user_token
+          end
+          if crowd_user && before_sync
+            self.crowd_record = crowd_user
+            # Callbacks to sync data
+            sync
+            self.attempted_record.save
+            after_sync
+          end
+        end
+      end
+
+      # Single Sign-out
+      def logout_of_crowd
+        # Send an invalidate call for single signout
+        # Apparently there is no way of knowing if this was successful or not.
+        crowd_client.invalidate_user_token crowd_user_token unless crowd_user_token.nil?
+        # Remove cookie and session
+        if controller
+          controller.session[:"crowd.token_key"] = nil
+          controller.cookies.delete :"crowd.token_key", :domain => crowd_cookie_info[:domain] if sso?
+          controller.cookies.delete :"#{klass.name.underscore}_credentials"
+        end
+        true
+      end
+
+
+      def crowd_user_token
+        self.class.crowd_user_token
+      end
+      def crowd_client
+        @crowd_client ||= SimpleCrowd::Client.new(crowd_config)
+      end
+      def load_crowd_app_token
+        cached_token = Rails.cache.read('crowd_app_token')
+        crowd_client.app_token = cached_token unless cached_token.nil?
+        Rails.cache.write('crowd_app_token', crowd_client.app_token) unless cached_token == crowd_client.app_token
+      end
+      def crowd_cookie_info
+        unless @crowd_cookie_info
+          cached_info = Rails.cache.read('crowd_cookie_info')
+          @crowd_cookie_info ||= cached_info || crowd_client.get_cookie_info
+          Rails.cache.write('crowd_cookie_info', @crowd_cookie_info) unless cached_info == @crowd_cookie_info
+        end
+        @crowd_cookie_info
+      end
+      def crowd_config
+        {:service_url => klass.crowd_service_url,
+          :app_name => klass.crowd_app_name,
+          :app_password => klass.crowd_app_password}
+      end
+    end
+  end
+end

data/lib/authlogic_crowd/session_callbacks.rb

@@ -0,0 +1,19 @@
+module AuthlogicCrowd
+  module SessionCallbacks
+    METHODS = [
+      "before_sync", "sync", "after_sync"
+    ]
+    def self.included(base)
+      base.send :include, ActiveSupport::Callbacks
+      base.define_callbacks *METHODS
+    end
+    private
+    METHODS.each do |method|
+      class_eval <<-"end_eval", __FILE__, __LINE__
+        def #{method}
+          run_callbacks(:#{method}) { |result, object| result == false }
+        end
+      end_eval
+    end
+  end
+end

data/lib/authlogic_crowd/version.rb

@@ -0,0 +1,3 @@
+module AuthlogicCrowd
+  VERSION = "0.2.3"
+end

data/lib/authlogic_crowd.rb

@@ -0,0 +1,9 @@
+require "authlogic_crowd/acts_as_authentic"
+require "authlogic_crowd/session"
+require "authlogic_crowd/session_callbacks"
+require "authlogic_crowd/acts_as_authentic_callbacks"
+
+ActiveRecord::Base.send(:include, AuthlogicCrowd::ActsAsAuthentic)
+ActiveRecord::Base.send(:include, AuthlogicCrowd::ActsAsAuthenticCallbacks)
+Authlogic::Session::Base.send(:include, AuthlogicCrowd::Session)
+Authlogic::Session::Base.send(:include, AuthlogicCrowd::SessionCallbacks)

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'matchy'
+require 'rr'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'authlogic_crowd'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end

data/test/test_authlogic_crowd.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestAuthlogicCrowd < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: authlogic_crowd
+version: !ruby/object:Gem::Version 
+  hash: 17
+  prerelease: 
+  segments: 
+  - 0
+  - 2
+  - 3
+  version: 0.2.3
+platform: ruby
+authors: 
+- Paul Strong
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-11 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: fcoury-matchy
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rr
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: authlogic
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 1
+        - 3
+        version: 2.1.3
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: simple_crowd
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id005
+description: Authlogic Crowd
+email: paul@thestrongfamily.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- authlogic_crowd.gemspec
+- lib/authlogic_crowd.rb
+- lib/authlogic_crowd/acts_as_authentic.rb
+- lib/authlogic_crowd/acts_as_authentic_callbacks.rb
+- lib/authlogic_crowd/session.rb
+- lib/authlogic_crowd/session_callbacks.rb
+- lib/authlogic_crowd/version.rb
+- test/helper.rb
+- test/test_authlogic_crowd.rb
+has_rdoc: true
+homepage: http://github.com/lapluviosilla/authlogic_crowd
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Atlassian Crowd support for Authlogic
+test_files: 
+- test/helper.rb
+- test/test_authlogic_crowd.rb