passwd 0.0.6 → 0.0.7

data/README.md

@@ -2,8 +2,8 @@
 
 [![Gem Version](https://badge.fury.io/rb/passwd.png)](http://badge.fury.io/rb/passwd)
 [![Build Status](https://travis-ci.org/i2bskn/passwd.png?branch=master)](https://travis-ci.org/i2bskn/passwd)
-[![Code Climate](https://codeclimate.com/github/i2bskn/passwd.png)](https://codeclimate.com/github/i2bskn/passwd)
 [![Coverage Status](https://coveralls.io/repos/i2bskn/passwd/badge.png?branch=master)](https://coveralls.io/r/i2bskn/passwd?branch=master)
+[![Code Climate](https://codeclimate.com/github/i2bskn/passwd.png)](https://codeclimate.com/github/i2bskn/passwd)
 
 Password utilities.
 

data/lib/passwd.rb

@@ -19,33 +19,36 @@ module Passwd
 
   class << self
     def create(options={})
-      config = @@config.merge(options)
+      config = @@config.merge(config_validator(options))
       letters = get_retters(config)
-
-      # Create random password
       Array.new(config[:length]){letters[rand(letters.size)]}.join
     end
 
-    def get_retters(config)
-      # Create letters
-      letters = Array.new
-      letters += config[:letters_lower] if config[:lower]
-      letters += config[:letters_upper] if config[:upper]
-      letters += config[:letters_number] if config[:number]
-      letters
-    end
-
     def auth(password_text, salt_hash, password_hash)
       enc_pass = Passwd.hashing("#{salt_hash}#{password_text}")
       password_hash == enc_pass
     end
 
-    def hashing(passwd)
-      Digest::SHA1.hexdigest passwd
+    def hashing(password)
+      Digest::SHA1.hexdigest password
     end
 
     def config(options={})
-      @@config.merge!(options)
+      @@config.merge!(config_validator(options))
+    end
+
+    private
+    def get_retters(config)
+      ["lower", "upper", "number"].inject([]) do |letters, type|
+        letters.concat(config["letters_#{type}".to_sym]) if config[type.to_sym]
+        letters
+      end
+    end
+
+    def config_validator(config_hash)
+      parameters = [:length, :lower, :upper, :number, :letters_lower, :letters_upper, :letters_number]
+      config = config_hash.inject({}){|r, (k, v)| r.store(k.to_sym, v); r}
+      config.select{|k, v| parameters.include? k}
     end
   end
 end

data/lib/passwd/active_record.rb

@@ -4,30 +4,44 @@ module Passwd
   module ActiveRecord
     module ClassMethods
       def define_column(options={})
-        idc = options[:id] || :email
-        saltc = options[:salt] || :salt
-        passwordc = options[:password] || :password
+        id_name = options[:id] || :email
+        salt_name = options[:salt] || :salt
+        password_name = options[:password] || :password
 
+        define_singleton_auth(id_name, salt_name, password_name)
+        define_instance_auth(id_name, salt_name, password_name)
+        define_set_password(id_name, salt_name, password_name)
+        define_update_password(salt_name, password_name)
+      end
+
+      private
+      def define_singleton_auth(id_name, salt_name, password_name)
         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))
+          user = self.where(id_name => id).first
+          user if user && Passwd.auth(pass, user.send(salt_name), user.send(password_name))
         end
+      end
 
+      def define_instance_auth(id_name, salt_name, password_name)
         define_method :authenticate do |pass|
-          Passwd.auth(pass, self.send(saltc), self.send(passwordc))
+          Passwd.auth(pass, self.send(salt_name), self.send(password_name))
         end
+      end
 
+      def define_set_password(id_name, salt_name, password_name)
         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}"))
+          salt = self.send(salt_name) || Passwd.hashing("#{self.send(id_name)}#{Time.now.to_s}")
+          self.send("#{salt_name.to_s}=", salt)
+          self.send("#{password_name.to_s}=", Passwd.hashing("#{salt}#{password}"))
           password
         end
+      end
 
-        define_method :update_password do |old, new|
-          if Passwd.auth(old, self.send(saltc), self.send(passwordc))
-            set_password(new)
+      def define_update_password(salt_name, password_name)
+        define_method :update_password do |old_pass, new_pass|
+          if Passwd.auth(old_pass, self.send(salt_name), self.send(password_name))
+            set_password(new_pass)
           else
             false
           end
@@ -36,8 +50,8 @@ module Passwd
     end
 
     class << self
-      def included(klass)
-        klass.extend ClassMethods
+      def included(base)
+        base.extend ClassMethods
       end
     end
   end

data/lib/passwd/version.rb

@@ -1,3 +1,3 @@
 module Passwd
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/spec/passwd/password_spec.rb

@@ -3,136 +3,149 @@
 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)
+  let(:default) {@default}
+  let(:password) {Passwd::Password.new}
+
+  describe "#initialize" do
+    context "with default params" do
+      let!(:password_text) {
+        password_text = Passwd.create
+        Passwd.should_receive(:create).and_return(password_text)
+        password_text
+      }
+
+      let!(:time_now) {
+        time_now = Time.now
+        Time.should_receive(:now).and_return(time_now)
+        time_now
+      }
+
+      it "@text should be a random password" do
+        expect(password.text.size).to eq(default[:length])
+        expect(password.text).to eq(password_text)
+      end
+
+      it "@salt_text should be a auto created" do
+        expect(password.salt_text).to eq(time_now.to_s)
+      end
+
+      it "@salt_hash should be a hashed salt" do
+        expect(password.salt_hash).to eq(Passwd.hashing(time_now.to_s))
+      end
+
+      it "@password_hash should be a hashed password with salt" do
+        password_hash = Passwd.hashing("#{Passwd.hashing(time_now.to_s)}#{password_text}")
+        expect(password.hash).to eq(password_hash)
+      end
+    end
+
+    context "with custom params" do
+      let(:password_text) {Passwd.create}
+      let(:salt_text) {"salt"}
+      let!(:time_now) {
+        time_now = Time.now
+        Time.stub(:create).and_return(time_now)
+        time_now
+      }
+
+      it "@text is specified password" do
+        password = Passwd::Password.new(password: password_text)
+        expect(password.text).to eq(password_text)
+      end
+
+      it "@hash is hash of specified password" do
+        password = Passwd::Password.new(password: password_text)
+        password_hash = Passwd.hashing("#{Passwd.hashing(time_now.to_s)}#{password_text}")
+        expect(password.hash).to eq(password_hash)
+      end
+
+      it "@salt_text is specified salt" do
+        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_hash = Passwd.hashing(salt_text)
+        password = Passwd::Password.new(salt_text: salt_text)
+        expect(password.salt_hash).to eq(salt_hash)
+      end
     end
   end
 
-  context "#text=" do
-    before(:each) do
-      @password = Passwd::Password.new(password: "Secret!!")
-    end
-
+  describe "#text=" do
     it "@text is changed" do
-      old_password = @password.text
-      @password.text = Passwd.create
-      expect(@password.text).not_to eq(old_password)
+      old_password = password.text
+      password.text = password.text.reverse
+      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)
+      old_hash = password.hash
+      new_password = password.text = password.text.reverse
+      expect(password.hash).not_to eq(old_hash)
+      expect(password.hash).to eq(Passwd.hashing("#{password.salt_hash}#{new_password}"))
     end
   end
 
-  context "#hash=" do
-    before(:each) do
-      @password = Passwd::Password.new
-    end
-
+  describe "#hash=" do
     it "@text is nil" do
-      @password.hash = Passwd.hashing("Secret!!")
-      expect(@password.text).to eq(nil)
+      password.hash = Passwd.hashing("secret")
+      expect(password.text).to be_nil
     end
 
     it "@hash is changed" do
-      old_hash = @password.hash
-      @password.hash = Passwd.hashing("Secret!!")
-      expect(@password.hash).not_to eq(old_hash)
+      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
-
+  describe "#salt_text=" do
     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)
+      old_salt = password.salt_text
+      password.salt_text = "salt"
+      expect(password.salt_text).not_to eq(old_salt)
     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)
+      old_salt = password.salt_hash
+      password.salt_text = "salt"
+      expect(password.salt_hash).not_to eq(old_salt)
     end
 
     it "@hash is changed" do
-      old_hash = @password.hash
-      @password.salt_text = "salt"
-      expect(@password.hash).not_to eq(old_hash)
+      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
-
+  describe "#salt_hash=" do
     it "@salt_text is nil" do
-      @password.salt_hash = Passwd.hashing("salt")
-      expect(@password.salt_text).to eq(nil)
+      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)
+      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)
+      old_hash = password.hash
+      password.salt_hash = Passwd.hashing("salt")
+      expect(password.hash).not_to eq(old_hash)
     end
   end
 
-  context "#==" do
-    before(:each) do
-      @password = Passwd::Password.new
-    end
-
+  describe "#==" do
     it "return true with valid password" do
-      expect(@password == @password.text).to eq(true)
+      expect(password == password.text).to be_true
     end
 
     it "return false with invalid password" do
-      expect(@password == "Secret!!").to eq(false)
+      expect(password == "secret").to be_false
     end
   end
 end

data/spec/passwd_spec.rb

@@ -3,82 +3,135 @@
 require "spec_helper"
 
 describe Passwd do
-  describe "singleton methods" do
-    context "#create" do
-      it "return string object" do
-        expect(Passwd.create.class).to eq(String)
-      end
-
-      it "password was created 8 characters" do
-        expect(Passwd.create.size).to eq(8)
-      end
-
-      it "password was created specified characters" do
-        expect(Passwd.create(length: 10).size).to eq(10)
-      end
-
-      it "password create without lower case" do
-        password = Passwd.create(lower: false)
-        expect(("a".."z").to_a.include?(password)).to eq(false)
-      end
-
-      it "password create without upper case" do
-        password = Passwd.create(upper: false)
-        expect(("A".."Z").to_a.include?(password)).to eq(false)
-      end
-
-      it "password create without number" do
-        password = Passwd.create(number: false)
-        expect(("0".."9").to_a.include?(password)).to eq(false)
-      end
-    end
-
-    context "#auth" do
-      it "return true with valid password" do
-        password = Passwd.create
-        salt_hash = Passwd.hashing(Time.now.to_s)
-        password_hash = Passwd.hashing("#{salt_hash}#{password}")
-        expect(Passwd.auth(password, salt_hash, password_hash)).to eq(true)
-      end
-
-      it "return false with invalid password" do
-        password = "Secret!!"
-        salt_hash = Passwd.hashing(Time.now.to_s)
-        password_hash = Passwd.hashing("#{salt_hash}#{password}")
-        expect(Passwd.auth("Secret!", salt_hash, password_hash)).to eq(false)
-      end
-    end
-
-    context "#hashing" do
-      it "return string object" do
-        expect(Passwd.hashing(Passwd.create).class).to eq(String)
-      end
-
-      it "return hashed password" do
-        password = Passwd.create
-        password_hash = Digest::SHA1.hexdigest(password)
-        expect(Passwd.hashing(password)).to eq(password_hash)
-      end
-    end
-
-    context "#config" do
-      before(:all) do
-        @default_value = Passwd.config.clone
-      end
-
-      after(:all) do
-        Passwd.config(@default_value)
-      end
-
-      it "return config hash" do
-        expect(Passwd.config.class).to eq(Hash)
-      end
-
-      it "set config value" do
-        old_value = Passwd.config[:length]
-        Passwd.config(length: 10)
-        expect(Passwd.config[:length]).not_to eq(old_value)
-      end
+  let(:default) {@default}
+
+  describe "default settings" do
+    let(:config) {Passwd.config}
+
+    it "length should be a default" do
+      expect(config[:length]).to eq(default[:length])
+    end
+
+    it "lower should be a default" do
+      expect(config[:lower]).to eq(default[:lower])
+    end
+
+    it "upper should be a default" do
+      expect(config[:upper]).to eq(default[:upper])
+    end
+
+    it "number should be a default" do
+      expect(config[:number]).to eq(default[:number])
+    end
+
+    it "letters_lower should be a default" do
+      expect(config[:letters_lower]).to eq(default[:letters_lower])
+    end
+
+    it "letters_upper should be a default" do
+      expect(config[:letters_upper]).to eq(default[:letters_upper])
+    end
+
+    it "letters_number should be a default" do
+      expect(config[:letters_number]).to eq(default[:letters_number])
+    end
+  end
+
+  describe ".create" do
+    it "create random password" do
+      password = Passwd.create
+      expect(password.is_a? String).to be_true
+      expect(password.size).to eq(default[:length])
+    end
+
+    it "password was created specified characters" do
+      expect(Passwd.create(length: 10).size).to eq(10)
+    end
+
+    it "password create without lower case" do
+      password = Passwd.create lower: false
+      expect(default[:letters_lower].include? password).to be_false
+    end
+
+    it "password create without upper case" do
+      password = Passwd.create upper: false
+      expect(default[:letters_upper].include? password).to be_false
+    end
+
+    it "password create without number" do
+      password = Passwd.create(number: false)
+      expect(default[:letters_number].include? password).to be_false
+    end
+  end
+
+  describe ".auth" do
+    let!(:password) do
+      password = Passwd.create
+      salt_hash = Passwd.hashing(Time.now.to_s)
+      password_hash = Passwd.hashing("#{salt_hash}#{password}")
+      {text: password, salt: salt_hash, hash: password_hash}
+    end
+
+    it "return true with valid password" do
+      expect(Passwd.auth(password[:text], password[:salt], password[:hash])).to be_true
+    end
+
+    it "return false with invalid password" do
+      expect(Passwd.auth("invalid", password[:salt], password[:hash])).to be_false
+    end
+
+    it "should create exception if not specified arguments" do
+      expect(proc{Passwd.auth}).to raise_error
+    end
+  end
+
+  describe ".hashing" do
+    it "return hashed password" do
+      Digest::SHA1.should_receive(:hexdigest).with("secret").and_return("hash")
+      expect(Passwd.hashing("secret")).to eq("hash")
+    end
+
+    it "should create exception if not specified argument" do
+      expect(proc{Passwd.hashing}).to raise_error
+    end
+  end
+
+  describe ".config" do
+    after {Passwd.config(default)}
+
+    it "return config hash" do
+      expect(Passwd.config.is_a? Hash).to be_true
+    end
+
+    it "set config value" do
+      Passwd.config(length: 10)
+      expect(Passwd.config[:length]).not_to eq(default[:length])
+      expect(Passwd.config[:lower]).to eq(default[:lower])
+    end
+  end
+
+  describe ".get_retters" do
+    it "return letters" do
+      letters = Passwd.send(:get_retters, default)
+      expect(letters.is_a? Array).to be_true
+      expect(letters.select{|s| s.is_a? String}).to eq(letters)
+      expect(letters).to eq(default[:letters_lower] + default[:letters_upper] + default[:letters_number])
+    end
+
+    it "should create exception if not specified argument" do
+      expect(proc{Passwd.send(:get_retters)}).to raise_error
+    end
+  end
+
+  describe ".config_validator" do
+    it "convert to symbol the key" do
+      config = default.inject({}){|r, (k, v)| r.store(k.to_s, v); r}
+      expect(Passwd.send(:config_validator, config)).to eq(default)
+    end
+
+    it "delete not defined parameters" do
+      config = default.merge(invalid_parameter: true)
+      expect(Passwd.send(:config_validator, config)).to eq(default)
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,3 +2,18 @@ require "passwd"
 
 require "coveralls"
 Coveralls.wear!
+
+RSpec.configure do |config|
+  config.order = "random"
+  config.before do
+    @default = {
+      length: 8,
+      lower: true,
+      upper: true,
+      number: true,
+      letters_lower: ('a'..'z').to_a,
+      letters_upper: ('A'..'Z').to_a,
+      letters_number: ('0'..'9').to_a
+    }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: passwd
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-28 00:00:00.000000000 Z
+date: 2013-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,7 +97,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -540825171026277875
+      hash: 35413922955959980
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -106,10 +106,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -540825171026277875
+      hash: 35413922955959980
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Password utility