yauth 0.1.0

data/.autotest

@@ -0,0 +1 @@
+require 'test_notifier/runner/autotest'

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use ruby-1.8.7-p302@yauth

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Matteo Collina
+
+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.rdoc

@@ -0,0 +1,122 @@
+= Yauth
+
+Yauth is a extremely simple authentication solution for prototypes, and provides a drop-in solution for http basic authentication.
+It uses a yaml file to store usernames and hashed password combined with the http basic authentication. 
+The whole gem provides a better-than-nothing security, and it was designed with small prototypes in mind.
+It is entirely developed as a https://github.com/hassox/warden strategy, the same library on which the popular Devise is based. 
+
+Yauth resolves one well defined problem: protecting a web application that is going to be accessed by a few users.
+As adding new users requires manual intervention (only launching a command, see below), it's a good choice for single-users web applications or prototypes. In this way you can password-protect your app easily and expose it to your clients on the web.
+
+== Installation
+
+First, install the gem:
+
+  gem install yauth
+
+Or if you are using Bundler:
+
+  echo "gem 'yauth'" >> Gemfile
+  bundle install
+
+Add the first user (username 'bar' and password 'foo'):
+
+  yauth add bar foo
+
+Check the 'config/users.yml' into your version control system:
+
+  git add config/users.yml
+  git commit -m "Added user 'bar'."
+
+== Configuration
+
+Yauth requires almost no configuration, 5 lines of code.
+
+=== Sinatra
+
+In your application.rb, simply put:
+
+  Yauth::Strategy.install!
+  
+  use Warden::Manager do |manager|
+    manager.default_strategies :yauth_users
+    manager.failure_app = Yauth::FailureApp.new("Your Realm")
+  end
+
+To require authentication inside an action, simply call:
+
+  get '/' do
+    request.env['warden'].authenticate! # execution stop and auth is required
+    "hello world\n"
+  end
+
+=== Rails 3
+
+In your config/application.rb file put:
+
+  Yauth::Strategy.install!
+  
+  config.middleware.use Warden::Manager do |manager|
+    manager.default_strategies :yauth_users
+    manager.failure_app = Yauth::FailureApp.new("Your Realm")
+  end
+
+To require authentication inside an action, add this method to app/controllers/application_controller.rb:
+
+  private
+  def authenticate
+    env['warden'].authenticate!
+  end
+
+Then, you can use the +authenticate+ method as a before filter for every method that requires authentication:
+
+  before_filter :authenticate, :only => :your_method_here
+
+== Adding and removing users
+
+If you want to add the user 'foo', with password 'bar', just launch:
+
+  yauth add foo bar
+
+Then, if you want to change 'foo' password to 'oof', just launch:
+
+  yauht add foo oof
+
+Finally, to remove 'foo' user:
+
+  yauth rm foo
+
+== Security Considerations
+
+Users are stored in the 'config/users.yml' file, with the password stored as SHA256 hash. 
+In this way it's safe to add the 'config/users.yml' to the version control system.
+
+You can see an example of the 'config/users.yml' file:
+
+  --- 
+  - user: 
+      username: admin
+      password: 8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918
+
+
+== TODO
+
+Future versions will include:
+* drop-in api key solution, i.e. user might have a key for API prototypation;
+* authentication scopes, as defined in warden.
+
+== Contributing to yauth
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Matteo Collina. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "yauth"
+  gem.homepage = "http://github.com/mcollina/yauth"
+  gem.license = "MIT"
+  gem.summary = %Q{A drop-in authentication solution for prototypes.}
+  gem.description = %Q{Yauth is a extremely simple authentication solution for prototipes, developed as a warden strategy. It uses a yaml file to store usernames and hashed password. It provides a better-than-nothing security.}
+  gem.email = "matteo@matteocollina.com"
+  gem.authors = ["Matteo Collina"]
+  gem.add_runtime_dependency 'warden', '~> 1.0'
+  gem.add_runtime_dependency 'thor', '~> 0.14.0'
+  gem.add_development_dependency 'test_notifier', '~> 0.3.6'
+  gem.add_development_dependency 'autotest', '~> 4.4'
+  gem.add_development_dependency 'rcov'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+  spec.rcov_opts = ["--text-summary", "--exclude","lib\/rspec,bin\/rspec,lib\/rcov," + 
+             "spec,diff-lcs,thor,warden,rack"]
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "yauth #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/yauth

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "rubygems" # ruby1.9 doesn't "require" it though
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib") 
+require "yauth"
+Yauth::CLI.start

data/examples/sinatra/app.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'sinatra'
+require File.join(File.dirname(__FILE__), "..", "..", "lib", "yauth")
+
+configure do
+  enable :sessions #needed by warden
+end
+
+Yauth::Strategy.install!
+
+use Warden::Manager do |manager|
+  manager.default_strategies :yauth_users
+  manager.failure_app = Yauth::FailureApp.new
+end
+
+get '/' do
+  # the configured user is "admin:admin"
+  request.env['warden'].authenticate!
+  "hello world\n"
+end

data/examples/sinatra/config/users.yml

@@ -0,0 +1,4 @@
+--- 
+- user: 
+    username: admin
+    password: 8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918

data/lib/yauth.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+require 'digest/sha1'
+require 'thor'
+require 'warden'
+
+module Yauth
+  class << self
+    attr_accessor :location
+  end
+  Yauth.location = "config/users.yml"
+end
+
+require File.join(File.dirname(__FILE__), "yauth", "user")
+require File.join(File.dirname(__FILE__), "yauth", "user_manager")
+require File.join(File.dirname(__FILE__), "yauth", "cli")
+require File.join(File.dirname(__FILE__), "yauth", "strategy")
+require File.join(File.dirname(__FILE__), "yauth", "failure_app")

data/lib/yauth/cli.rb

@@ -0,0 +1,34 @@
+
+class Yauth::CLI < Thor
+
+  attr_reader :manager
+
+  desc "add USERNAME PASSWORD", "Adds or updates a user"
+  method_options :config => Yauth.location
+  def add(username, password)
+    init_manager
+    user = Yauth::User.new
+    user.username = username
+    user.plain_password = password
+    manager.add(user)
+    save_manager
+  end
+
+  desc "rm USERNAME", "Remove a user"
+  method_options :config => Yauth.location
+  def rm(username)
+    init_manager
+    manager.remove(username)
+    save_manager
+  end
+
+  private
+  def init_manager
+    @manager = Yauth::UserManager.load(options[:config])
+  end
+
+  def save_manager
+    FileUtils.mkdir_p(File.dirname(options[:config]))
+    @manager.save(options[:config])
+  end
+end

data/lib/yauth/failure_app.rb

@@ -0,0 +1,15 @@
+
+class Yauth::FailureApp
+  attr_accessor :realm
+
+  def initialize(realm="Yauth secured area")
+    self.realm = realm
+  end
+
+  def call(env)
+    [401, 
+      { "Content-Type" => "text/plain", 
+        "WWW-Authenticate" => %(Basic realm="#{realm}") }, 
+      ["#{env['warden'].message}\n"]]
+  end
+end

data/lib/yauth/strategy.rb

@@ -0,0 +1,24 @@
+
+class Yauth::Strategy < Warden::Strategies::Base
+
+  attr_reader :manager
+
+  def initialize(*args)
+    super(*args)
+    @manager = Yauth::UserManager.load(Yauth.location)
+  end
+
+  def authenticate!
+    auth = Rack::Auth::Basic::Request.new(env)
+    credentials = auth.provided? && auth.basic? && auth.credentials 
+    if not credentials or not user = manager.authenticate(*credentials)
+      fail!("Could not log in") 
+    else
+      success!(user)
+    end
+  end
+
+  def self.install!
+    Warden::Strategies.add(:yauth_users, self)
+  end
+end

data/lib/yauth/user.rb

@@ -0,0 +1,31 @@
+
+class Yauth::User
+  attr_accessor :username, :password
+  attr_reader :plain_password
+
+  def initialize(hash={})
+    hash = hash[:user] if hash[:user]
+    hash = hash["user"] if hash["user"]
+
+    self.username = hash[:username] || hash["username"]
+    self.password = hash[:password] || hash["password"]
+  end
+
+  def plain_password=(plain_password)
+    self.password = Digest::SHA256.hexdigest(plain_password)
+    @plain_password = plain_password
+  end
+  
+  def to_hash
+    { "user" => { "username" => username, "password" => password } }
+  end
+
+  def to_yaml(opts={})
+    to_hash.to_yaml(opts)
+  end
+
+  def authenticate(password)
+    return false if password.to_s == "" 
+    Digest::SHA256.hexdigest(password) == self.password
+  end
+end

data/lib/yauth/user_manager.rb

@@ -0,0 +1,45 @@
+
+class Yauth::UserManager
+  include Enumerable
+
+  def initialize
+    @list = []
+  end
+
+  def add(user)
+    remove(user.username)
+    @list << user
+  end
+
+  def remove(name)
+    @list.delete(find_by_username(name))
+  end
+
+  def each(&block)
+    @list.each(&block)
+  end
+
+  def save(path)
+    open(path, "w") do |io|
+      io << @list.to_yaml
+    end
+  end
+
+  def find_by_username(name)
+    @list.find { |u| u.username == name }
+  end
+
+  def authenticate(username, password)
+    user = find_by_username(username)
+    user if user and user.authenticate(password)
+  end
+
+  def self.load(path)
+    manager = self.new
+    return manager unless File.exists? path
+    open(path) do |io|
+      YAML.load(io).each { |h| manager.add(Yauth::User.new(h)) }
+    end
+    manager
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'yauth'
+require 'stringio'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+include Yauth
+
+RSpec.configure do |config|
+  
+end

data/spec/yauth/cli_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+require 'fileutils'
+
+describe CLI do
+
+  subject { CLI.new }
+
+  before :each do
+    FileUtils.stub!(:mkdir_p)
+    @options = {}
+    subject.stub!(:options).and_return(@options)
+  end
+
+  [:add, :rm].each do |m|
+    it { should respond_to(m) }
+  end
+
+  it "should add a user to the manager with the specified config" do
+    @options[:config] = "config/users.yml"
+    manager = mock "Manager"
+    UserManager.should_receive(:load).with("config/users.yml").and_return(manager)
+
+    user = mock "User"
+    User.should_receive(:new).and_return(user)
+    user.should_receive(:username=).with("bar")
+    user.should_receive(:plain_password=).with("foo")
+
+    manager.should_receive(:add).with(user)
+
+    FileUtils.should_receive(:mkdir_p).with("config")
+    manager.should_receive(:save).with("config/users.yml")
+    subject.add("bar", "foo")
+  end
+
+  it "should remove from the manager with the specified config" do
+    @options[:config] = "config/users.yml"
+    manager = mock "Manager"
+    UserManager.should_receive(:load).with("config/users.yml").and_return(manager)
+
+    manager.should_receive(:remove).with("bar")
+
+    FileUtils.should_receive(:mkdir_p).with("config")
+    manager.should_receive(:save).with("config/users.yml")
+    subject.rm("bar")
+  end
+end

data/spec/yauth/failure_app_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe FailureApp do
+
+  subject { FailureApp.new }
+
+  def mock_env(message="hello")
+    warden = mock "warden"
+    warden.stub!(:message).and_return(message)
+    { 'warden' => warden }
+  end
+
+  it "should return 401" do
+    subject.call(mock_env)[0].should == 401
+  end
+
+  it "should have Content-Type 'text/plain'" do
+    subject.call(mock_env)[1]["Content-Type"].should == 'text/plain'
+  end
+
+  it "should have WWW-Authenticate set" do
+    subject.call(mock_env)[1]["WWW-Authenticate"].should == %(Basic realm="Yauth secured area")
+  end
+
+  it "should have the body set as the warden message" do
+    subject.call(mock_env("hello world"))[2][0].should =~ /hello world/
+  end
+
+  it { should respond_to(:realm) } 
+
+  it { should respond_to(:realm=) }
+
+  it "should have a default realm" do
+    subject.realm.should == "Yauth secured area"
+  end
+
+  it "should have WWW-Authenticate with the realm configured" do
+    subject.realm = "My Realm"
+    subject.call(mock_env)[1]["WWW-Authenticate"].should == %(Basic realm="My Realm")
+  end
+end

data/spec/yauth/strategy_spec.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+require 'rack'
+
+describe Strategy do
+  subject { Strategy.new({}) }
+
+  it { subject.should respond_to(:authenticate!) }
+
+  it "should loads a manager" do
+    manager = mock "Manager"
+    UserManager.should_receive(:load).with(Yauth.location).and_return(manager)
+    subject #needed to initialize the subject
+  end
+
+  describe "with a loaded manager" do
+
+    before(:each) do
+      @manager = mock "Manager"
+      UserManager.stub(:load).and_return(@manager)
+
+      env = mock "Env"
+      subject.should_receive(:env).and_return(env)
+      @request = mock "Request"
+      Rack::Auth::Basic::Request.should_receive(:new).with(env).and_return(@request)
+    end
+
+    it "should authenticate if valid credentials are passed" do
+      @request.should_receive(:provided?).and_return(true)
+      @request.should_receive(:basic?).and_return(true)
+      credentials = [mock("credentials1"), mock("credentials2")]
+      @request.should_receive(:credentials).and_return(credentials)
+
+      user = mock "user"
+      @manager.should_receive(:authenticate).with(*credentials).and_return(user)
+      subject.should_receive(:success!).with(user)
+      subject.authenticate!
+    end
+
+    it "should not authenticate if there are no credentials" do
+      @request.should_receive(:provided?).and_return(false)
+
+      subject.should_receive(:fail!).with("Could not log in")
+      subject.should_not_receive(:success!)
+      subject.authenticate!
+    end
+  end
+end
+
+describe Strategy, "as a class" do
+  it "should install itself into Warden" do
+    Warden::Strategies.should_receive(:add).with(:yauth_users, Strategy)
+    Strategy.install!
+  end 
+end

data/spec/yauth/user_manager_spec.rb

@@ -0,0 +1,141 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe UserManager do
+  subject { UserManager.new }
+
+  [:add, :remove, :each, :save].each do |m|
+    it do
+      should respond_to(m)
+    end
+  end
+
+  def mock_user(name)
+    user = mock "user #{name}"
+    user.stub(:username).and_return(name)
+    user
+  end
+
+  it "should add a user" do
+    user = mock_user "user"
+    subject.add user
+    subject.to_a.should == [user]
+  end
+
+  it "should not add the same user twice" do
+    user = mock_user "user"
+    subject.add user
+    subject.add user
+    subject.to_a.should == [user]
+  end
+
+  it "should remove a user given its username" do
+    user = mock_user "name"
+    subject.add user
+    subject.remove("name").should == user
+    subject.to_a.should == []
+  end
+
+  it "should yield each added user" do 
+    first = mock_user "first"
+    second = mock_user "second"
+    subject.should_receive(:each).and_yield(first, second)
+    subject.add first 
+    subject.add second 
+    subject.each {}
+  end
+
+  it "should save all its user to the specified file" do
+    first = User.new(:username => "first", :password => "123") 
+    second = User.new(:username => "second", :password => "456") 
+    subject.add(first)
+    subject.add(second)
+
+    path = "a/path/to.yml"
+    io = StringIO.new
+    subject.should_receive(:open).with(path, "w").and_yield(io)
+    subject.save(path)
+    io.string.should == <<-EOF
+--- 
+- user: 
+    username: first
+    password: "123"
+- user: 
+    username: second
+    password: "456"
+EOF
+  end
+
+  it "should find a user by its username" do
+    first = User.new(:username => "first", :password => "123") 
+    second = User.new(:username => "second", :password => "456") 
+    subject.add(first)
+    subject.add(second)
+
+    subject.find_by_username("first").should == first
+    subject.find_by_username("second").should == second
+  end
+
+  it "should authenticate a user by its username and password" do
+    user = mock "user"
+    subject.should_receive(:find_by_username).with("name").and_return(user)
+    user.should_receive(:authenticate).with("password").and_return(true)
+
+    subject.authenticate("name", "password").should == user
+  end
+
+  it "should not authenticate a user if the password doesn't match" do
+    user = mock "user"
+    subject.should_receive(:find_by_username).with("name").and_return(user)
+    user.should_receive(:authenticate).with("password").and_return(false)
+
+    subject.authenticate("name", "password").should be_false
+  end
+
+  it "should not authenticate if there is no match" do
+    subject.should_receive(:find_by_username).with("name").and_return(nil)
+    subject.authenticate("name", "password").should be_false
+  end
+end
+
+describe UserManager, "as a class" do
+
+  subject { UserManager }
+
+  it "should mix in Enumerable" do
+    subject.ancestors.should include(Enumerable)
+  end
+
+  it { should respond_to(:load) }
+
+  describe "#load" do
+    it "should load from a yaml file if that file exists" do 
+      path = "a/path/to.yml"
+      io = StringIO.new <<-EOF
+- user:
+    username: first
+    password: 123456
+- user:
+    username: second
+    password: 789012
+      EOF
+      File.stub(:exists?).with(path).and_return(true)
+      UserManager.should_receive(:open).with(path).and_yield(io)
+      manager = UserManager.load(path)
+
+      ary = manager.to_a
+      ary.size.should == 2
+
+      ary[0].username.should == "first"
+      ary[0].password.should == 123456
+      ary[1].username.should == "second"
+      ary[1].password.should == 789012
+    end
+
+    it "should create a new UserManager if the file doesn't exists" do 
+      path = "a/path/to.yml"
+      File.stub(:exists?).with(path).and_return(false)
+      manager = UserManager.load(path)
+      manager.to_a.should == []
+    end
+  end
+end

data/spec/yauth/user_spec.rb

@@ -0,0 +1,95 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe User do
+  subject { User.new }
+
+  [:username, :password, :plain_password].each do |attr|
+    it "should have an #{attr} accessor" do
+      should respond_to(attr)
+      should respond_to(attr.to_s + "=")
+    end
+  end
+
+  it "should set the real password based on the plain password" do
+    password = "hello world"
+    hash = Digest::SHA256.hexdigest(password)
+    subject.plain_password = password
+    subject.password.should == hash
+  end
+
+  it "should memorize the plain password until the end of the session" do
+    password = "hello world"
+    subject.plain_password = password
+    subject.plain_password.should == password
+  end
+
+  it "should be transformed to an hash" do
+    subject.username = "XYZ"
+    subject.password = "ABC"
+    subject.to_hash.should == { "user" => { "username" => "XYZ", "password" => "ABC" } }
+  end
+
+  it "should yaml nicely" do
+    subject.username = "XYZ"
+    subject.password = "ABC"
+    subject.to_yaml.should ==<<-EOF
+--- 
+user: 
+  username: XYZ
+  password: ABC
+EOF
+  end
+
+  it { should respond_to(:authenticate) }
+
+  it "should authenticate with the right password" do
+    subject.username = "XYZ"
+    subject.plain_password = "ABC"
+    subject.authenticate("ABC").should be_true
+  end
+
+  it "should not authenticate with the wrong password" do
+    subject.username = "XYZ"
+    subject.plain_password = "ABC"
+    subject.authenticate("XYZ").should be_false
+  end
+
+  it "should not authenticate with the empty password" do
+    subject.username = "XYZ"
+    subject.plain_password = "ABC"
+    subject.authenticate("").should be_false
+  end
+
+  it "should not authenticate with the nil password" do
+    subject.username = "XYZ"
+    subject.plain_password = "ABC"
+    subject.authenticate(nil).should be_false
+  end
+
+  describe "as a class" do
+
+    it "should build a user from a prefixed hash with strings" do
+      u = User.new({ "user" => { "username" => "XYZ", "password" => "ABC" } })
+      u.username.should == "XYZ"
+      u.password.should == "ABC"
+    end
+
+    it "should build a user from an prefixed hash with symbols" do
+      u = User.new({ :"user" => { :"username" => "XYZ", :"password" => "ABC" } })
+      u.username.should == "XYZ"
+      u.password.should == "ABC"
+    end
+
+    it "should build a user from a hash with strings" do
+      u = User.new({ "username" => "XYZ", "password" => "ABC" })
+      u.username.should == "XYZ"
+      u.password.should == "ABC"
+    end
+
+    it "should build a user from an hash with symbols" do
+      u = User.new({ :"username" => "XYZ", :"password" => "ABC" })
+      u.username.should == "XYZ"
+      u.password.should == "ABC"
+    end
+  end
+end

data/spec/yauth_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Yauth do
+  subject { Yauth }
+
+  it { should respond_to(:location) }
+  it { should respond_to(:location=) }
+
+  it "should store the default yml location" do
+    subject.location.should == "config/users.yml"    
+  end
+
+  it "should be possible to overwrite the default yml location" do
+    subject.location = "users.yml"
+    subject.location.should == "users.yml"
+  end
+end

data/yauth.gemspec

@@ -0,0 +1,88 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{yauth}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matteo Collina"]
+  s.date = %q{2011-03-01}
+  s.default_executable = %q{yauth}
+  s.description = %q{Yauth is a extremely simple authentication solution for prototipes, developed as a warden strategy. It uses a yaml file to store usernames and hashed password. It provides a better-than-nothing security.}
+  s.email = %q{matteo@matteocollina.com}
+  s.executables = ["yauth"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bin/yauth",
+    "examples/sinatra/app.rb",
+    "examples/sinatra/config/users.yml",
+    "lib/yauth.rb",
+    "lib/yauth/cli.rb",
+    "lib/yauth/failure_app.rb",
+    "lib/yauth/strategy.rb",
+    "lib/yauth/user.rb",
+    "lib/yauth/user_manager.rb",
+    "spec/spec_helper.rb",
+    "spec/yauth/cli_spec.rb",
+    "spec/yauth/failure_app_spec.rb",
+    "spec/yauth/strategy_spec.rb",
+    "spec/yauth/user_manager_spec.rb",
+    "spec/yauth/user_spec.rb",
+    "spec/yauth_spec.rb",
+    "yauth.gemspec"
+  ]
+  s.homepage = %q{http://github.com/mcollina/yauth}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{A drop-in authentication solution for prototypes.}
+  s.test_files = [
+    "examples/sinatra/app.rb",
+    "spec/spec_helper.rb",
+    "spec/yauth/cli_spec.rb",
+    "spec/yauth/failure_app_spec.rb",
+    "spec/yauth/strategy_spec.rb",
+    "spec/yauth/user_manager_spec.rb",
+    "spec/yauth/user_spec.rb",
+    "spec/yauth_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<warden>, ["~> 1.0"])
+      s.add_runtime_dependency(%q<thor>, ["~> 0.14.0"])
+      s.add_development_dependency(%q<test_notifier>, ["~> 0.3.6"])
+      s.add_development_dependency(%q<autotest>, ["~> 4.4"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<warden>, ["~> 1.0"])
+      s.add_dependency(%q<thor>, ["~> 0.14.0"])
+      s.add_dependency(%q<test_notifier>, ["~> 0.3.6"])
+      s.add_dependency(%q<autotest>, ["~> 4.4"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<warden>, ["~> 1.0"])
+    s.add_dependency(%q<thor>, ["~> 0.14.0"])
+    s.add_dependency(%q<test_notifier>, ["~> 0.3.6"])
+    s.add_dependency(%q<autotest>, ["~> 4.4"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification 
+name: yauth
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Matteo Collina
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-01 00:00:00 +01:00
+default_executable: yauth
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: warden
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 39
+        segments: 
+        - 0
+        - 14
+        - 0
+        version: 0.14.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: test_notifier
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 3
+        - 6
+        version: 0.3.6
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: autotest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 4
+        - 4
+        version: "4.4"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Yauth is a extremely simple authentication solution for prototipes, developed as a warden strategy. It uses a yaml file to store usernames and hashed password. It provides a better-than-nothing security.
+email: matteo@matteocollina.com
+executables: 
+- yauth
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .autotest
+- .document
+- .rspec
+- .rvmrc
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/yauth
+- examples/sinatra/app.rb
+- examples/sinatra/config/users.yml
+- lib/yauth.rb
+- lib/yauth/cli.rb
+- lib/yauth/failure_app.rb
+- lib/yauth/strategy.rb
+- lib/yauth/user.rb
+- lib/yauth/user_manager.rb
+- spec/spec_helper.rb
+- spec/yauth/cli_spec.rb
+- spec/yauth/failure_app_spec.rb
+- spec/yauth/strategy_spec.rb
+- spec/yauth/user_manager_spec.rb
+- spec/yauth/user_spec.rb
+- spec/yauth_spec.rb
+- yauth.gemspec
+has_rdoc: true
+homepage: http://github.com/mcollina/yauth
+licenses: 
+- MIT
+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.5.2
+signing_key: 
+specification_version: 3
+summary: A drop-in authentication solution for prototypes.
+test_files: 
+- examples/sinatra/app.rb
+- spec/spec_helper.rb
+- spec/yauth/cli_spec.rb
+- spec/yauth/failure_app_spec.rb
+- spec/yauth/strategy_spec.rb
+- spec/yauth/user_manager_spec.rb
+- spec/yauth/user_spec.rb
+- spec/yauth_spec.rb