passwd 0.0.4 → 0.0.5

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+gemfile:
+  - Gemfile
+script: bundle exec rspec
+branches:
+  only:
+    - master
+notifications:
+  mails:
+    - i2bskn@gmail.com
+  on_sucess: always
+  on_failure: always

data/README.md

@@ -2,13 +2,15 @@
 
 [![Build Status](https://travis-ci.org/i2bskn/passwd.png?branch=master)](https://travis-ci.org/i2bskn/passwd)
 
-Password utility
+Password utilities.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'passwd'
+```ruby
+gem 'passwd'
+```
 
 And then execute:
 
@@ -20,11 +22,33 @@ Or install it yourself as:
 
 ## Usage
 
-    require 'passwd'
+```ruby
+require 'passwd'
+```
 
-Create random password:
+### Create random password
 
-    password = Passwd.create
+```ruby
+password = Passwd.create
+```
+
+### Hashing password
+
+Hashing with SHA1.
+
+```ruby
+password_hash = Passwd.hashing(password)
+```
+
+### Password settings
+
+Default config is stored in the class variable. (@@config)
+Changing the default configs are as follows:
+
+```ruby
+Passwd.config => Get config hash.
+Passwd.config(length: 10) => Change to the default length.
+```
 
 Options that can be specified:
 
@@ -36,19 +60,21 @@ Options that can be specified:
 * :letters_upper => Define an array of upper case. default is ("A".."Z").to_a
 * :letters_number => Define an array of numbers. default is ("0".."9").to_a
 
-Default config is stored in the class variable. (@@config)
-Changing the default configs are as follows:
-
-    Passwd.config => Get config hash.
-    Passwd.config(length: 10) => Change to the default length.
+### Password policy check
 
-Password hashing:
+```ruby
+Passwd.policy_check(password)
+```
 
-    password_hash = Passwd.hashing(password)
+### Policy settings
 
-Password policy check:
+Default policy is stored in the class variable. (@@policy)
+Changing the default policy are as follows:
 
-    Passwd.policy_check(password)
+```ruby
+Passwd.policy => Get policy hash.
+Passwd.policy(min_length: 10) => Change to the default min_length.
+```
 
 Options that can be specified:
 
@@ -59,22 +85,18 @@ Options that can be specified:
 * :require_upper => Require upper case if set true. specify_type enabled when true.
 * :require_number => Require number case if set true. specify_type enabled when true.
 
-Default policy is stored in the class variable. (@@policy)
-Changing the default policy are as follows:
-
-    Passwd.policy => Get policy hash.
-    Passwd.policy(min_length: 10) => Change to the default min_length.
-
-Passwd object:
+### Password object
 
 Default password is randomly generated.
 Default salt is "#{Time.now.to_s}".
 
-    password = Passwd::Password.new
-    password.text # return text password.
-    password.salt_text # return text salt.
-    password.salt_hash # return hash salt.
-    password.hash # return hash password.
+```ruby
+password = Passwd::Password.new
+password.text # return text password.
+password.salt_text # return text salt.
+password.salt_hash # return hash salt.
+password.hash # return hash password.
+```
 
 Options that can be specified:
 
@@ -83,12 +105,75 @@ Options that can be specified:
 
 Password authenticate:
 
-    password = Passwd::Password.new
-    Passwd.auth(password.text, password.salt_hash, password.hash) # => true
-    Passwd.auth("invalid!!", password.salt_hash, password.hash) # => false
-
-    password == password.text # => true
-    password == "invalid!!" # => false
+```ruby
+password = Passwd::Password.new
+Passwd.auth(password.text, password.salt_hash, password.hash) # => true
+Passwd.auth("invalid!!", password.salt_hash, password.hash) # => false
+
+password == password.text # => true
+password == "invalid!!" # => false
+```
+
+## For ActiveRecord User model
+
+model:
+
+```ruby
+class User < ActiveRecord::Base
+  include Passwd::ActiveRecord
+  # if not specified arguments for define_column => {id: :email, salt: :salt, password: :password}
+  define_column id: :id_colname, salt: :salt_colname, password: :password_colname
+
+  ...
+end
+```
+
+Authentication:
+
+```ruby
+user = User.authenticate("foo@example.com", "secret") # => return user object or nil.
+
+if user
+  puts "Hello #{user.name}!"
+else
+  puts "Authentication failed"
+end
+```
+
+```ruby
+user = User.find(params[:id])
+if user.authenticate("secret") # => return true or false
+  puts "Authentication is successful!"
+else
+  puts "Authentication failed!"
+end
+```
+
+Change passowrd:
+
+```ruby
+user = User.find(params[:id])
+# set random password. (salt also set if salt is nil)
+# return set password text.
+# set specified password if specified argument.
+#   user.set_password("secret")
+password_text = user.set_password
+
+if user.save
+  NoticeMailer.change_mail(user, password_text).deliver
+end
+```
+
+```ruby
+user.find(params[:id])
+if user.update_password(old_pass, new_pass) # => return new password(text) or false
+  if user.save
+    NoticeMailer.change_mail(user, password_text).deliver
+  end
+else
+  puts "Authentication failed!"
+end
+```
 
 ## Contributing
 
@@ -96,4 +181,4 @@ Password authenticate:
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+5. Create new Pull Request

data/Rakefile

@@ -5,7 +5,7 @@ require 'rspec/core/rake_task'
 
 task default: [:spec]
 
-desc "run spec"
+desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.rspec_opts = ["-c", "-fs"]
 end

data/lib/passwd/active_record.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+module Passwd
+  module ActiveRecord
+    module ClassMethods
+      def define_column(options={})
+        idc = options[:id] || :email
+        saltc = options[:salt] || :salt
+        passwordc = options[:password] || :password
+
+        define_singleton_method :authenticate do |id, pass|
+          user = self.where(idc => id).first
+          user if user && Passwd.auth(pass, user.send(saltc), user.send(passwordc))
+        end
+
+        define_method :authenticate do |pass|
+          Passwd.auth(pass, self.send(saltc), self.send(passwordc))
+        end
+
+        define_method :set_password do |pass=nil|
+          password = pass || Passwd.create
+          salt = self.send(saltc) || Passwd.hashing("#{self.send(idc)}#{Time.now.to_s}")
+          self.send("#{saltc.to_s}=", salt)
+          self.send("#{passwordc.to_s}=", Passwd.hashing("#{salt}#{password}"))
+          password
+        end
+
+        define_method :update_password do |old, new|
+          if Passwd.auth(old, self.send(saltc), self.send(passwordc))
+            set_password(new)
+          else
+            false
+          end
+        end
+      end
+    end
+
+    class << self
+      def included(klass)
+        klass.extend ClassMethods
+      end
+    end
+  end
+end

data/lib/passwd/password.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+module Passwd
+  class Password
+    attr_reader :text, :hash, :salt_text, :salt_hash
+
+    def initialize(options={})
+      @text = options[:password] || Passwd.create
+      @salt_text = options[:salt_text] || Time.now.to_s
+      @salt_hash = Passwd.hashing(@salt_text)
+      @hash = Passwd.hashing("#{@salt_hash}#{@text}")
+    end
+
+    def text=(password)
+      @hash = Passwd.hashing("#{@salt_hash}#{password}")
+      @text = password
+    end
+
+    def hash=(password_hash)
+      @text = nil
+      @hash = password_hash
+    end
+
+    def salt_text=(salt_text)
+      @salt_hash = Passwd.hashing(salt_text)
+      @hash = Passwd.hashing("#{@salt_hash}#{@text}")
+      @salt_text = salt_text
+    end
+
+    def salt_hash=(salt_hash)
+      @salt_text = nil
+      @hash = Passwd.hashing("#{salt_hash}#{@text}")
+      @salt_hash = salt_hash
+    end
+
+    def policy_check
+      Passwd.policy_check @text
+    end
+
+    def ==(password)
+      enc_pass = Passwd.hashing("#{@salt_hash}#{password}")
+      @hash == enc_pass
+    end
+  end
+end

data/lib/passwd/version.rb

@@ -1,3 +1,3 @@
 module Passwd
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/lib/passwd.rb

@@ -1,8 +1,11 @@
 # coding: utf-8
 
-require "passwd/version"
 require "digest/sha1"
 
+require "passwd/version"
+require "passwd/password"
+require "passwd/active_record"
+
 module Passwd
   @@config = {
     length: 8,
@@ -23,48 +26,6 @@ module Passwd
     require_number: true
   }
 
-  class Password
-    attr_reader :text, :hash, :salt_text, :salt_hash
-
-    def initialize(options={password: nil, salt_text: Time.now.to_s})
-      @text = options[:password].nil? ? Passwd.create : options[:password]
-      @salt_text = options[:salt_text] || Time.now.to_s
-      @salt_hash = Passwd.hashing(@salt_text)
-      @hash = Passwd.hashing("#{@salt_hash}#{@text}")
-    end
-
-    def text=(password)
-      @hash = Passwd.hashing("#{@salt_hash}#{password}")
-      @text = password
-    end
-
-    def hash=(password_hash)
-      @text = nil
-      @hash = password_hash
-    end
-
-    def salt_text=(salt_text)
-      @salt_hash = Passwd.hashing(salt_text)
-      @hash = Passwd.hashing("#{@salt_hash}#{@text}")
-      @salt_text = salt_text
-    end
-
-    def salt_hash=(salt_hash)
-      @salt_text = nil
-      @hash = Passwd.hashing("#{salt_hash}#{@text}")
-      @salt_hash = salt_hash
-    end
-
-    def policy_check
-      Passwd.policy_check @text
-    end
-
-    def ==(password)
-      enc_pass = Passwd.hashing("#{@salt_hash}#{password}")
-      @hash == enc_pass
-    end
-  end
-
   class << self
     def create(options={})
       config = @@config.merge(options)

data/passwd.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'passwd/version'

data/spec/passwd/active_record_spec.rb

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+require "spec_helper"
+
+describe Passwd::ActiveRecord do
+  class User
+    include Passwd::ActiveRecord
+    define_column
+  end
+
+  let(:salt) {Digest::SHA1.hexdigest("salt")}
+  let(:password_text) {"secret"}
+  let(:password_hash) {Digest::SHA1.hexdigest("#{salt}#{password_text}")}
+
+  describe ".included" do
+    it "define singleton methods" do
+      expect(User.respond_to? :define_column).to be_true
+    end
+  end
+
+  describe "extend methods" do
+    describe ".define_column" do
+      let(:user) {User.new}
+
+      it "define singleton methods" do
+        expect(User.respond_to? :authenticate).to be_true
+      end
+
+      it "define authenticate method" do
+        expect(user.respond_to? :authenticate).to be_true
+      end
+
+      it "define set_password method" do
+        expect(user.respond_to? :set_password).to be_true
+      end
+
+      it "define update_password" do
+        expect(user.respond_to? :update_password).to be_true
+      end
+    end
+  end
+
+  describe "defined methods from define_column" do
+    describe ".authenticate" do
+      let!(:record) {
+        record = double("record mock")
+        record.stub(:salt).and_return(salt)
+        record.stub(:password).and_return(password_hash)
+        response = [record]
+        User.stub(:where).and_return(response)
+        record
+      }
+
+      it "user should be returned if authentication is successful" do
+        User.should_receive(:where)
+        expect(User.authenticate("valid_id", password_text)).to eq(record)
+      end
+
+      it "should return nil if authentication failed" do
+        User.should_receive(:where)
+        expect(User.authenticate("valid_id", "invalid_secret")).to be_nil
+      end
+
+      it "should return nil if user not found" do
+        User.should_receive(:where).with(:email => "invalid_id").and_return([])
+        expect(User.authenticate("invalid_id", password_text)).to be_nil
+      end
+    end
+
+    describe "#authenticate" do
+      let!(:user) {
+        user = User.new
+        user.stub(:salt).and_return(salt)
+        user.stub(:password).and_return(password_hash)
+        user
+      }
+
+      it "should return true if authentication is successful" do
+        expect(user.authenticate(password_text)).to be_true
+      end
+
+      it "should return false if authentication failed" do
+        expect(user.authenticate("invalid_pass")).to be_false
+      end
+    end
+
+    describe "#set_password" do
+      let!(:user) {
+        user = User.new
+        user.stub(:salt).and_return(salt)
+        user
+      }
+
+      it "should return set password" do
+        user.should_receive(:salt=).with(salt)
+        user.should_receive(:password=).with(Passwd.hashing("#{salt}#{password_text}"))
+        expect(user.set_password(password_text)).to eq(password_text)
+      end
+
+      it "should set random password if not specified" do
+        user.should_receive(:salt=).with(salt)
+        random_password = Passwd.create
+        Passwd.should_receive(:create).and_return(random_password)
+        user.should_receive(:password=).with(Passwd.hashing("#{salt}#{random_password}"))
+        user.set_password
+      end
+
+      it "should set salt if salt is nil" do
+        mail_addr = "foo@example.com"
+        time_now = Time.now
+        salt2 = Passwd.hashing("#{mail_addr}#{time_now.to_s}")
+        Time.stub(:now).and_return(time_now)
+        user.stub(:email).and_return(mail_addr)
+        user.should_receive(:salt).and_return(nil)
+        user.should_receive(:salt=).with(salt2)
+        user.should_receive(:password=).with(Passwd.hashing("#{salt2}#{password_text}"))
+        user.set_password(password_text)
+      end
+    end
+
+    describe "#update_password" do
+      let!(:user) {
+        user = User.new
+        user.stub(:salt).and_return(salt)
+        user.stub(:password).and_return(password_hash)
+        user
+      }
+
+      it "should return update password" do
+        pass = "new_password"
+        user.should_receive(:set_password).with(pass).and_return(pass)
+        expect(user.update_password(password_text, pass)).to eq(pass)
+      end
+
+      it "should return false if authentication failed" do
+        Passwd.should_receive(:auth).and_return(false)
+        user.should_not_receive(:set_password)
+        user.update_password("invalid_password", "new_password")
+      end
+    end
+  end
+end

data/spec/passwd/password_spec.rb

@@ -0,0 +1,147 @@
+# coding: utf-8
+
+require "spec_helper"
+
+describe Passwd::Password do
+  context "#initialize" do
+    it "set instance valiables" do
+      password = Passwd::Password.new
+      expect(password.text.size).to eq(8)
+      expect(password.text.class).to eq(String)
+      expect(password.hash.class).to eq(String)
+      expect(password.salt_text.class).to eq(String)
+      expect(password.salt_hash.class).to eq(String)
+    end
+
+    it "@text is specified password" do
+      pass_text = Passwd.create
+      password = Passwd::Password.new(password: pass_text)
+      expect(password.text).to eq(pass_text)
+    end
+
+    it "@hash is hash of specified password" do
+      pass_text = Passwd.create
+      password = Passwd::Password.new(password: pass_text)
+      pass_hash = Passwd.hashing("#{password.salt_hash}#{pass_text}")
+      expect(password.hash).to eq(pass_hash)
+    end
+
+    it "@salt_text is specified salt" do
+      salt_text = "salt"
+      password = Passwd::Password.new(salt_text: salt_text)
+      expect(password.salt_text).to eq(salt_text)
+    end
+
+    it "@salt_hash is hash of specified salt" do
+      salt_text = "salt"
+      salt_hash = Passwd.hashing(salt_text)
+      password = Passwd::Password.new(salt_text: salt_text)
+      expect(password.salt_hash).to eq(salt_hash)
+    end
+  end
+
+  context "#text=" do
+    before(:each) do
+      @password = Passwd::Password.new(password: "Secret!!")
+    end
+
+    it "@text is changed" do
+      old_password = @password.text
+      @password.text = Passwd.create
+      expect(@password.text).not_to eq(old_password)
+    end
+
+    it "@hash is changed" do
+      old_hash = @password.hash
+      @password.text = Passwd.create
+      expect(@password.hash).not_to eq(old_hash)
+    end
+  end
+
+  context "#hash=" do
+    before(:each) do
+      @password = Passwd::Password.new
+    end
+
+    it "@text is nil" do
+      @password.hash = Passwd.hashing("Secret!!")
+      expect(@password.text).to eq(nil)
+    end
+
+    it "@hash is changed" do
+      old_hash = @password.hash
+      @password.hash = Passwd.hashing("Secret!!")
+      expect(@password.hash).not_to eq(old_hash)
+    end
+  end
+
+  context "#salt_text=" do
+    before(:each) do
+      @password = Passwd::Password.new
+    end
+
+    it "@salt_text is changed" do
+      old_salt_text = @password.salt_text
+      @password.salt_text = "salt"
+      expect(@password.salt_text).not_to eq(old_salt_text)
+    end
+
+    it "@salt_hash is changed" do
+      old_salt_hash = @password.salt_hash
+      @password.salt_text = "salt"
+      expect(@password.salt_hash).not_to eq(old_salt_hash)
+    end
+
+    it "@hash is changed" do
+      old_hash = @password.hash
+      @password.salt_text = "salt"
+      expect(@password.hash).not_to eq(old_hash)
+    end
+  end
+
+  context "#salt_hash=" do
+    before(:each) do
+      @password = Passwd::Password.new
+    end
+
+    it "@salt_text is nil" do
+      @password.salt_hash = Passwd.hashing("salt")
+      expect(@password.salt_text).to eq(nil)
+    end
+
+    it "@salt_hash is changed" do
+      old_salt_hash = @password.salt_hash
+      @password.salt_hash = Passwd.hashing("salt")
+      expect(@password.salt_hash).not_to eq(old_salt_hash)
+    end
+
+    it "@hash is changed" do
+      old_hash = @password.hash
+      @password.salt_hash = Passwd.hashing("salt")
+      expect(@password.hash).not_to eq(old_hash)
+    end
+  end
+
+  context "#policy_check" do
+    it "Passwd.policy_check is called with pass_text" do
+      pass_text = Passwd.create
+      Passwd.should_receive(:policy_check).with(pass_text)
+      password = Passwd::Password.new(password: pass_text)
+      password.policy_check
+    end
+  end
+
+  context "#==" do
+    before(:each) do
+      @password = Passwd::Password.new
+    end
+
+    it "return true with valid password" do
+      expect(@password == @password.text).to eq(true)
+    end
+
+    it "return false with invalid password" do
+      expect(@password == "Secret!!").to eq(false)
+    end
+  end
+end

data/spec/passwd_spec.rb

@@ -1,9 +1,6 @@
 # coding: utf-8
 
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-
-require "passwd"
-require "digest/sha1"
+require "spec_helper"
 
 describe Passwd do
   describe "singleton methods" do
@@ -139,148 +136,4 @@ describe Passwd do
       end
     end
   end
-
-  describe 'Password' do
-    context "#initialize" do
-      it "set instance valiables" do
-        password = Passwd::Password.new
-        expect(password.text.size).to eq(8)
-        expect(password.text.class).to eq(String)
-        expect(password.hash.class).to eq(String)
-        expect(password.salt_text.class).to eq(String)
-        expect(password.salt_hash.class).to eq(String)
-      end
-
-      it "@text is specified password" do
-        pass_text = Passwd.create
-        password = Passwd::Password.new(password: pass_text)
-        expect(password.text).to eq(pass_text)
-      end
-
-      it "@hash is hash of specified password" do
-        pass_text = Passwd.create
-        password = Passwd::Password.new(password: pass_text)
-        pass_hash = Passwd.hashing("#{password.salt_hash}#{pass_text}")
-        expect(password.hash).to eq(pass_hash)
-      end
-
-      it "@salt_text is specified salt" do
-        salt_text = "salt"
-        password = Passwd::Password.new(salt_text: salt_text)
-        expect(password.salt_text).to eq(salt_text)
-      end
-
-      it "@salt_hash is hash of specified salt" do
-        salt_text = "salt"
-        salt_hash = Passwd.hashing(salt_text)
-        password = Passwd::Password.new(salt_text: salt_text)
-        expect(password.salt_hash).to eq(salt_hash)
-      end
-    end
-
-    context "#text=" do
-      before(:each) do
-        @password = Passwd::Password.new(password: "Secret!!")
-      end
-
-      it "@text is changed" do
-        old_password = @password.text
-        @password.text = Passwd.create
-        expect(@password.text).not_to eq(old_password)
-      end
-
-      it "@hash is changed" do
-        old_hash = @password.hash
-        @password.text = Passwd.create
-        expect(@password.hash).not_to eq(old_hash)
-      end
-    end
-
-    context "#hash=" do
-      before(:each) do
-        @password = Passwd::Password.new
-      end
-
-      it "@text is nil" do
-        @password.hash = Passwd.hashing("Secret!!")
-        expect(@password.text).to eq(nil)
-      end
-
-      it "@hash is changed" do
-        old_hash = @password.hash
-        @password.hash = Passwd.hashing("Secret!!")
-        expect(@password.hash).not_to eq(old_hash)
-      end
-    end
-
-    context "#salt_text=" do
-      before(:each) do
-        @password = Passwd::Password.new
-      end
-
-      it "@salt_text is changed" do
-        old_salt_text = @password.salt_text
-        @password.salt_text = "salt"
-        expect(@password.salt_text).not_to eq(old_salt_text)
-      end
-
-      it "@salt_hash is changed" do
-        old_salt_hash = @password.salt_hash
-        @password.salt_text = "salt"
-        expect(@password.salt_hash).not_to eq(old_salt_hash)
-      end
-
-      it "@hash is changed" do
-        old_hash = @password.hash
-        @password.salt_text = "salt"
-        expect(@password.hash).not_to eq(old_hash)
-      end
-    end
-
-    context "#salt_hash=" do
-      before(:each) do
-        @password = Passwd::Password.new
-      end
-
-      it "@salt_text is nil" do
-        @password.salt_hash = Passwd.hashing("salt")
-        expect(@password.salt_text).to eq(nil)
-      end
-
-      it "@salt_hash is changed" do
-        old_salt_hash = @password.salt_hash
-        @password.salt_hash = Passwd.hashing("salt")
-        expect(@password.salt_hash).not_to eq(old_salt_hash)
-      end
-
-      it "@hash is changed" do
-        old_hash = @password.hash
-        @password.salt_hash = Passwd.hashing("salt")
-        expect(@password.hash).not_to eq(old_hash)
-      end
-    end
-
-    context "#policy_check" do
-      it "Passwd.policy_check is called with pass_text" do
-        pass_text = Passwd.create
-        Passwd.should_receive(:policy_check).with(pass_text)
-        password = Passwd::Password.new(password: pass_text)
-        password.policy_check
-      end
-    end
-
-    context "#==" do
-      before(:each) do
-        @password = Passwd::Password.new
-      end
-
-      it "return true with valid password" do
-        expect(@password == @password.text).to eq(true)
-      end
-
-      it "return false with invalid password" do
-        expect(@password == "Secret!!").to eq(false)
-      end
-    end
-  end
 end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "passwd"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passwd
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-23 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,14 +67,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/passwd.rb
+- lib/passwd/active_record.rb
+- lib/passwd/password.rb
 - lib/passwd/version.rb
 - passwd.gemspec
+- spec/passwd/active_record_spec.rb
+- spec/passwd/password_spec.rb
 - spec/passwd_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/i2bskn/passwd
 licenses:
 - MIT
@@ -90,7 +96,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2599599372076087466
+      hash: 109903666620076134
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -99,12 +105,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2599599372076087466
+      hash: 109903666620076134
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Password utility
 test_files:
+- spec/passwd/active_record_spec.rb
+- spec/passwd/password_spec.rb
 - spec/passwd_spec.rb
+- spec/spec_helper.rb