sparkly-auth 1.0.0

data/lib/auth/generators/route_generator.rb

@@ -0,0 +1,19 @@
+class Auth::Generators::RouteGenerator < Rails::Generator::NamedBase
+  attr_reader :model
+  
+  def initialize(model, options = {})
+    @model = model
+    args = [ model.name ]
+    super(args, options)
+  end
+  
+  def manifest
+    record do |m|
+      m.route_resources plural_name
+    end
+  end
+  
+  def spec
+    @spec ||= Rails::Generator::Spec.new("route", File.join(Auth.path, "auth/generators"), nil)
+  end
+end

data/lib/auth/generators/views_generator.rb

@@ -0,0 +1,26 @@
+class Auth::Generators::ViewsGenerator < Rails::Generator::NamedBase
+  attr_reader :model
+  
+  def initialize(model, options = {})
+    @model = model
+    args = [ model.name ]
+    super(args, options)
+  end
+  
+  def manifest
+    record do |m|
+      m.directory resource_directory = File.join("app/views", model.accounts_controller.underscore)
+      m.directory sessions_directory = File.join("app/views", model.sessions_controller.underscore)
+      
+      %w(edit new show).each do |f|
+        m.file "views/sparkly_accounts/#{f}.html.erb", File.join(resource_directory, "#{f}.html.erb")
+      end
+      
+      m.file "views/sparkly_sessions/new.html.erb", File.join(sessions_directory, "new.html.erb")
+    end
+  end
+  
+  def spec
+    @spec ||= Rails::Generator::Spec.new("views", File.join(Auth.path, "auth/generators"), nil)
+  end
+end

data/lib/auth/model.rb

@@ -0,0 +1,94 @@
+class Auth::Model
+  module Authenticated
+    def self.included(base)
+      base.send(:cattr_accessor, :sparkly_config)
+    end
+  end
+  
+  
+  def self.option(name, default = name)
+    define_method(name) do
+      self.options[name] ||= Auth.configuration.send(default)
+    end
+  end
+  
+  include Auth::BehaviorLookup
+  attr_reader :options
+  option :behaviors
+  option :password_update_frequency
+  option :accounts_controller, :default_accounts_controller_name
+  option :sessions_controller, :default_sessions_controller_name
+  delegate :name, :table_name, :to => :target
+  
+  # Options include:
+  #   :behaviors                 => an array of behaviors to override Auth.configuration.behaviors
+  #   :password_update_frequency => a time (ie 30.days) to override Auth.configuration.password_update_frequency
+  #   :skip_routes               => true if you do not want to generate routes (useful if you need to map them yourself).
+  #   :key                       => the key upon which to authenticate (the username, basically)
+  #   :with                      => a regular expression used to validate the password
+  #   :accounts_controller       => the name of the controller to route to for creating accounts, deleting them, etc.
+  #   :sessions_controller       => the name of the controller to route to for logging in, logging out, etc.
+  #
+  def initialize(name_or_constant, options = {})
+    begin
+      @target = resolve(name_or_constant).name
+    rescue NameError
+      # we fail silently because the user might not have generated the model yet. That would mean they're trying
+      # to do it now.
+      @target = name_or_constant.to_s.camelize
+    end
+    
+    @options = options.reverse_merge(default_options)
+  end
+  
+  def target
+    returning @target.constantize do |klass|
+      unless klass.include?(Auth::Model::Authenticated)
+        klass.send(:include, Auth::Model::Authenticated)
+        klass.sparkly_config = self
+      end
+    end
+  end
+  
+  # Returns true if the specified String, Symbol or constant resolves to the same constant affected by this Model.
+  def matches?(name_or_constant)
+    target == resolve(name_or_constant)
+  end
+  
+  # The key upon which this model is to be authenticated. (The username.) Defaults to :email
+  def key
+    options[:key]
+  end
+  
+  # Merges the specified hash of options with this Model's hash of options. Same as model.options.merge!(options)
+  def merge_options!(options)
+    self.options.merge! options
+  end
+  
+  def apply_options!
+    apply_behaviors!
+  end
+  
+  private
+  def apply_behaviors!
+    behaviors.each do |behavior|
+      behavior = lookup_behavior(behavior)
+      behavior.new.apply_to(self)
+    end
+  end
+  
+  def resolve(name_or_constant)
+    case name_or_constant
+      when Symbol then name_or_constant.to_s.camelize.constantize
+      when String then name_or_constant.camelize.constantize
+      else name_or_constant
+    end
+  end
+  
+  def default_options
+  {
+    :key => :email,
+    :with => :password
+  }
+  end
+end

data/lib/auth/observer.rb

@@ -0,0 +1,21 @@
+class Auth::Observer < ActiveRecord::Observer
+  public :add_observer!
+  
+  class << self
+    # Attaches the observer to the supplied model classes.
+    def observe(*models)
+      models.flatten!
+      models.collect! { |model| model.is_a?(Symbol) ? model.to_s.camelize.constantize : model }
+      observed_classes.concat models
+      observed_classes.uniq!
+    end
+    
+    def observed_classes
+      @observed_classes ||= []
+    end
+  end
+  
+  def observed_classes
+    Set.new(self.class.observed_classes)
+  end
+end

data/lib/auth/target_list.rb

@@ -0,0 +1,5 @@
+class Auth::TargetList < Array
+  def find(which)
+    select { |o| o.matches?(which) }.shift
+  end
+end

data/lib/auth/tasks/migrations.rb

@@ -0,0 +1,71 @@
+namespace :auth do
+  namespace :migrate do
+    desc "Migrate from Authlogic to Sparkly Auth"
+    task :authlogic => :environment do
+      require 'console_app'
+      
+      models = Auth.authenticated_models.collect { |config| config.target }
+      # So we need to undo the existing Auth config so that there's no validation being done on the authenticated
+      # models. So we first reset the config...
+      Auth.reset_configuration!
+      # Then remove all behaviors (including :core)...
+      Auth.configuration.behaviors = []
+      # Then reload the models...
+      reload!
+      # Then apply the new config.
+      Auth.kick!
+
+      # And finally, we use a TOTALLY different Password model. Since the core behavior hasn't been applied to this
+      # version of Password, it's unenforced -- meaning we can assign encrypted passwords to it without having to
+      # worry about them being re-encrypted.
+      class UnenforcedPasswordModel < ActiveRecord::Base
+        set_table_name Password.table_name
+        belongs_to :authenticatable, :polymorphic => true
+      end
+            
+
+      for model in models
+        model.instance_eval do
+          has_many :passwords, :as => :authenticatable
+        end
+        
+        model.all.each do |record|
+          unless record.attributes['crypted_password'].blank? # skip those users registered AFTER migration
+            record.passwords.destroy_all
+            
+            password = UnenforcedPasswordModel.new(:authenticatable => record)
+            password.save(false)
+            password.update_attribute(:secret, record.attributes['crypted_password'])
+            password.update_attribute(:salt, record.attributes['password_salt'])
+            
+            if password.secret != record.attributes['crypted_password']
+              raise "Passwords don't match"
+            end
+            
+            if record.attributes.keys.include?('persistence_token')
+              password.update_attribute(:persistence_token, record.attributes['persistence_token'])
+            else
+              password.update_attribute(:persistence_token, Auth::Token.new.to_s)
+            end
+    
+            if record.attributes.keys.include?('single_access_token')
+              password.update_attribute(:single_access_token, record.attributes['single_access_token'])
+            else
+              password.update_attribute(:single_access_token, Auth::Token.new.to_s)
+            end
+    
+            if record.attributes.keys.include?('perishable_token')
+              password.update_attribute(:perishable_token, record.attributes['perishable_token'])
+            else
+              password.update_attribute(:perishable_token, Auth::Token.new.to_s)
+            end
+            
+            password.save!
+          end
+        end
+      end
+      
+      puts "Tables have been migrated."
+    end
+  end
+end

data/lib/auth/token.rb

@@ -0,0 +1,10 @@
+class Auth::Token
+  attr_reader :token
+  alias_method :to_s, :token
+  
+  def initialize
+    @hex = ActiveSupport::SecureRandom.hex(64)
+    # base64 url, see RFC4648
+    @token = SecureRandom.base64(15).tr('+/=', '-_ ').strip.delete("\n")
+  end
+end

data/lib/sparkly-auth.rb

@@ -0,0 +1 @@
+require File.expand_path("../auth.rb", __FILE__)

data/rails/init.rb

@@ -0,0 +1,17 @@
+# This file sets up the various include paths and whatnot that would have been set up
+# for us by Rails if this were a Rails plugin.
+
+base_path = File.expand_path("../..", __FILE__)
+
+Rails.configuration.controller_paths << File.join(base_path, "app/controllers")
+Rails.configuration.load_paths << File.join(base_path, 'lib')
+Rails.configuration.load_paths << File.join(base_path, 'app/models')
+
+ActionController::Base.view_paths << File.join(base_path, 'app/views')
+
+# Routes
+ActionController::Routing::Routes.add_configuration_file(File.join(base_path, "rails/routes.rb"))
+
+
+# Finally, we're ready to load the app as if it were a plugin.
+require File.expand_path("../../init", __FILE__)

data/rails/routes.rb

@@ -0,0 +1,19 @@
+if Auth.generate_routes?
+  ActionController::Routing::Routes.draw do |map|
+    Auth.configuration.authenticated_models.each do |model|
+      catch :missing do
+        begin
+          model.name # if an error is going to occur due to missing model, it'll happen here.
+        rescue NameError
+          # we rescue silently because the user's already been warned.
+          throw :missing
+        end
+
+        map.resource model.name.underscore, :controller => model.accounts_controller,
+                                            :requirements => { :model => model.name } do |model_res|
+          model_res.resource :session, :controller => model.sessions_controller, :requirements => { :model => model.name }
+        end
+      end
+    end
+  end
+end

data/sparkly-auth.gemspec

@@ -0,0 +1,143 @@
+# 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{sparkly-auth}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Colin MacKenzie IV"]
+  s.date = %q{2010-08-09}
+  s.description = %q{As fate would have it, I found other authentication solutions unable to suit my needs. So I rolled my own.}
+  s.email = %q{sinisterchipmunk@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "app/controllers/sparkly_accounts_controller.rb",
+     "app/controllers/sparkly_controller.rb",
+     "app/controllers/sparkly_sessions_controller.rb",
+     "app/models/password.rb",
+     "app/models/remembrance_token.rb",
+     "app/views/sparkly_accounts/edit.html.erb",
+     "app/views/sparkly_accounts/new.html.erb",
+     "app/views/sparkly_accounts/show.html.erb",
+     "app/views/sparkly_sessions/new.html.erb",
+     "dependencies.rb",
+     "generators/sparkly/USAGE",
+     "generators/sparkly/sparkly_generator.rb",
+     "generators/sparkly/templates/accounts_controller.rb",
+     "generators/sparkly/templates/accounts_helper.rb",
+     "generators/sparkly/templates/help_file.txt",
+     "generators/sparkly/templates/initializer.rb",
+     "generators/sparkly/templates/migrations/add_confirmed_to_sparkly_passwords.rb",
+     "generators/sparkly/templates/migrations/create_sparkly_passwords.rb",
+     "generators/sparkly/templates/migrations/create_sparkly_remembered_tokens.rb",
+     "generators/sparkly/templates/sessions_controller.rb",
+     "generators/sparkly/templates/sessions_helper.rb",
+     "generators/sparkly/templates/tasks/migrations.rb",
+     "generators/sparkly/templates/views/sparkly_accounts/edit.html.erb",
+     "generators/sparkly/templates/views/sparkly_accounts/new.html.erb",
+     "generators/sparkly/templates/views/sparkly_accounts/show.html.erb",
+     "generators/sparkly/templates/views/sparkly_sessions/new.html.erb",
+     "init.rb",
+     "lib/auth.rb",
+     "lib/auth/behavior/base.rb",
+     "lib/auth/behavior/core.rb",
+     "lib/auth/behavior/core/authenticated_model_methods.rb",
+     "lib/auth/behavior/core/controller_extensions.rb",
+     "lib/auth/behavior/core/controller_extensions/class_methods.rb",
+     "lib/auth/behavior/core/controller_extensions/current_user.rb",
+     "lib/auth/behavior/core/password_methods.rb",
+     "lib/auth/behavior/remember_me.rb",
+     "lib/auth/behavior/remember_me/configuration.rb",
+     "lib/auth/behavior/remember_me/controller_extensions.rb",
+     "lib/auth/behavior_lookup.rb",
+     "lib/auth/configuration.rb",
+     "lib/auth/encryptors/sha512.rb",
+     "lib/auth/generators/configuration_generator.rb",
+     "lib/auth/generators/controllers_generator.rb",
+     "lib/auth/generators/migration_generator.rb",
+     "lib/auth/generators/route_generator.rb",
+     "lib/auth/generators/views_generator.rb",
+     "lib/auth/model.rb",
+     "lib/auth/observer.rb",
+     "lib/auth/target_list.rb",
+     "lib/auth/tasks/migrations.rb",
+     "lib/auth/token.rb",
+     "lib/sparkly-auth.rb",
+     "rails/init.rb",
+     "rails/routes.rb",
+     "sparkly-auth.gemspec",
+     "spec/controllers/application_controller_spec.rb",
+     "spec/generators/sparkly_spec.rb",
+     "spec/lib/auth/behavior/core_spec.rb",
+     "spec/lib/auth/behavior/remember_me_spec.rb",
+     "spec/lib/auth/extensions/controller_spec.rb",
+     "spec/lib/auth/model_spec.rb",
+     "spec/lib/auth_spec.rb",
+     "spec/mocks/models/user.rb",
+     "spec/routes_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/views_spec.rb"
+  ]
+  s.homepage = %q{http://www.thoughtsincomputation.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{User authentication with Sparkles!}
+  s.test_files = [
+    "spec/controllers",
+     "spec/controllers/application_controller_spec.rb",
+     "spec/generators",
+     "spec/generators/sparkly_spec.rb",
+     "spec/lib",
+     "spec/lib/auth",
+     "spec/lib/auth/behavior",
+     "spec/lib/auth/behavior/core_spec.rb",
+     "spec/lib/auth/behavior/remember_me_spec.rb",
+     "spec/lib/auth/extensions",
+     "spec/lib/auth/extensions/controller_spec.rb",
+     "spec/lib/auth/model_spec.rb",
+     "spec/lib/auth_spec.rb",
+     "spec/mocks",
+     "spec/mocks/models",
+     "spec/mocks/models/user.rb",
+     "spec/routes_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/support",
+     "spec/views_spec.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
+      s.add_runtime_dependency(%q<sc-core-ext>, [">= 1.2.0"])
+      s.add_development_dependency(%q<rspec-rails>, [">= 1.3.2"])
+      s.add_development_dependency(%q<webrat>, [">= 0.7.1"])
+      s.add_development_dependency(%q<genspec>, [">= 0.1.1"])
+      s.add_development_dependency(%q<email_spec>, [">= 0.6.2"])
+    else
+      s.add_dependency(%q<sc-core-ext>, [">= 1.2.0"])
+      s.add_dependency(%q<rspec-rails>, [">= 1.3.2"])
+      s.add_dependency(%q<webrat>, [">= 0.7.1"])
+      s.add_dependency(%q<genspec>, [">= 0.1.1"])
+      s.add_dependency(%q<email_spec>, [">= 0.6.2"])
+    end
+  else
+    s.add_dependency(%q<sc-core-ext>, [">= 1.2.0"])
+    s.add_dependency(%q<rspec-rails>, [">= 1.3.2"])
+    s.add_dependency(%q<webrat>, [">= 0.7.1"])
+    s.add_dependency(%q<genspec>, [">= 0.1.1"])
+    s.add_dependency(%q<email_spec>, [">= 0.6.2"])
+  end
+end
+

data/spec/controllers/application_controller_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe ApplicationController do
+  # sanity check to make sure I haven't added methods and forgot to tell Rails they're not actions
+  it "should have only 'not_found' action" do
+    ApplicationController.action_methods.to_a.should == ["not_found"]
+  end
+  
+#  it "should respond_to current_user" do
+#    Auth.kick!
+#    ApplicationController.new.should respond_to(:current_user)
+#  end
+end