passwd 0.1.5 → 0.2.0

data/lib/passwd/active_record.rb

@@ -1,62 +0,0 @@
-# coding: utf-8
-
-module Passwd
-  module ActiveRecord
-    module ClassMethods
-      def define_column(options={})
-        id_name = options.fetch(:id, :email)
-        salt_name = options.fetch(:salt, :salt)
-        password_name = options.fetch(: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(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(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(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
-
-      def define_update_password(salt_name, password_name)
-        define_method :update_password do |old_pass, new_pass, policy_check=false|
-          if Passwd.auth(old_pass, self.send(salt_name), self.send(password_name))
-            if policy_check
-              raise Passwd::PolicyNotMatch, "Policy not match" unless Passwd.policy_check(new_pass)
-            end
-
-            set_password(new_pass)
-          else
-            raise Passwd::AuthError
-          end
-        end
-      end
-    end
-
-    class << self
-      def included(base)
-        base.extend ClassMethods
-      end
-    end
-  end
-end

data/lib/passwd/configuration/abstract_config.rb

@@ -1,37 +0,0 @@
-# coding: utf-8
-
-module Passwd
-  class AbstractConfig
-    VALID_OPTIONS_KEYS = [
-      :algorithm,
-      :length,
-      :lower,
-      :upper,
-      :number,
-      :letters_lower,
-      :letters_upper,
-      :letters_number
-    ].freeze
-
-    attr_accessor *VALID_OPTIONS_KEYS
-
-    def configure
-      yield self
-    end
-
-    def merge(configs)
-      configs.keys.each do |k|
-        send("#{k}=", configs[k])
-      end
-    end
-
-    def letters
-      chars = []
-      chars.concat(self.letters_lower) if self.lower
-      chars.concat(self.letters_upper) if self.upper
-      chars.concat(self.letters_number) if self.number
-      raise "letters is empty" if chars.empty?
-      chars
-    end
-  end
-end

data/lib/passwd/configuration/config.rb

@@ -1,24 +0,0 @@
-# coding: utf-8
-
-require "passwd/configuration/abstract_config"
-
-module Passwd
-  class Config < AbstractConfig
-    include Singleton
-
-    def initialize
-      reset
-    end
-
-    def reset
-      self.algorithm = :sha512
-      self.length = 8
-      self.lower = true
-      self.upper = true
-      self.number = true
-      self.letters_lower = ("a".."z").to_a
-      self.letters_upper = ("A".."Z").to_a
-      self.letters_number = ("0".."9").to_a
-    end
-  end
-end

data/lib/passwd/configuration/policy.rb

@@ -1,46 +0,0 @@
-# coding: utf-8
-
-module Passwd
-  class Policy
-    include Singleton
-
-    VALID_OPTIONS_KEYS = [
-      :min_length,
-      :require_lower,
-      :require_upper,
-      :require_number
-    ].freeze
-
-    attr_accessor *VALID_OPTIONS_KEYS
-
-    def initialize
-      reset
-    end
-
-    def configure
-      yield self
-    end
-
-    def valid?(password, config)
-      return false if self.min_length > password.size
-      return false if self.require_lower && !include_char?(config.letters_lower, password)
-      return false if self.require_upper && !include_char?(config.letters_upper, password)
-      return false if self.require_number && !include_char?(config.letters_number, password)
-      true
-    end
-
-    def include_char?(letters, strings)
-      strings.each_char do |c|
-        return true if letters.include? c
-      end
-      false
-    end
-
-    def reset
-      self.min_length = 8
-      self.require_lower = true
-      self.require_upper = false
-      self.require_number = true
-    end
-  end
-end

data/lib/passwd/configuration/tmp_config.rb

@@ -1,18 +0,0 @@
-# coding: utf-8
-
-require "passwd/configuration/abstract_config"
-
-module Passwd
-  class TmpConfig < AbstractConfig
-    def initialize(config, options)
-      config.instance_variables.each do |v|
-        key = v.to_s.sub(/^@/, "").to_sym
-        if options.has_key? key
-          instance_variable_set v, options[key]
-        else
-          instance_variable_set v, config.instance_variable_get(v)
-        end
-      end
-    end
-  end
-end

data/spec/passwd/active_record_spec.rb

@@ -1,163 +0,0 @@
-# coding: utf-8
-
-require "spec_helper"
-
-describe Passwd::ActiveRecord do
-  class User
-    include Passwd::ActiveRecord
-    define_column
-  end
-
-  let(:salt) {Digest::SHA512.hexdigest("salt")}
-  let(:password_text) {"secret"}
-  let(:password_hash) {Digest::SHA512.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
-      }
-
-      context "without policy check" do
-        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 generate exception if authentication failed" do
-          Passwd.should_receive(:auth).and_return(false)
-          user.should_not_receive(:set_password)
-          expect {
-            user.update_password("invalid_password", "new_password")
-          }.to raise_error(Passwd::AuthError)
-        end
-      end
-
-      context "with policy check" do
-        it "should return update password" do
-          pass = "new_password"
-          Passwd.should_receive(:policy_check).and_return(true)
-          user.should_receive(:set_password).with(pass).and_return(pass)
-          expect(user.update_password(password_text, pass, true)).to eq(pass)
-        end
-
-        it "should generate exception if policy not match" do
-          pass = "new_password"
-          Passwd.should_receive(:policy_check).and_return(false)
-          expect {
-            user.update_password(password_text, pass, true)
-            }.to raise_error(Passwd::PolicyNotMatch)
-        end
-      end
-    end
-  end
-end

data/spec/passwd/configuration/config_spec.rb

@@ -1,250 +0,0 @@
-# coding: utf-8
-
-require "spec_helper"
-
-describe Passwd::Config do
-  let(:config) {Passwd::Config.instance}
-
-  describe "defined accessors" do
-    it "defined algorithm" do
-      expect(config.respond_to? :algorithm).to be_true
-    end
-
-    it "defined length" do
-      expect(config.respond_to? :length).to be_true
-    end
-
-    it "defined lower" do
-      expect(config.respond_to? :lower).to be_true
-    end
-
-    it "defined upper" do
-      expect(config.respond_to? :upper).to be_true
-    end
-
-    it "defined number" do
-      expect(config.respond_to? :number).to be_true
-    end
-
-    it "defined letters_lower" do
-      expect(config.respond_to? :letters_lower).to be_true
-    end
-
-    it "defined letters_upper" do
-      expect(config.respond_to? :letters_upper).to be_true
-    end
-
-    it "defined letters_number" do
-      expect(config.respond_to? :letters_number).to be_true
-    end
-  end
-
-  describe "#initialize" do
-    it "algorithm should be a default" do
-      expect(config.algorithm).to eq(:sha512)
-    end
-
-    it "length should be a default" do
-      expect(config.length).to eq(8)
-    end
-
-    it "lower should be a default" do
-      expect(config.lower).to be_true
-    end
-
-    it "upper should be a default" do
-      expect(config.upper).to be_true
-    end
-
-    it "number should be a default" do
-      expect(config.number).to be_true
-    end
-
-    it "letters_lower should be a default" do
-      expect(config.letters_lower).to eq(("a".."z").to_a)
-    end
-
-    it "letters_upper should be a default" do
-      expect(config.letters_upper).to eq(("A".."Z").to_a)
-    end
-
-    it "letters_number should be a default" do
-      expect(config.letters_number).to eq(("0".."9").to_a)
-    end
-  end
-
-  describe "#configure" do
-    before {
-      config.configure do |c|
-        c.length = 20
-        c.lower = false
-        c.upper = false
-        c.number = false
-        c.letters_lower = ["a"]
-        c.letters_upper = ["A"]
-        c.letters_number = ["0"]
-      end
-    }
-
-    it "set length from block" do
-      expect(config.length).to eq(20)
-    end
-
-    it "set lower from block" do
-      expect(config.lower).to be_false
-    end
-
-    it "set upper from block" do
-      expect(config.upper).to be_false
-    end
-
-    it "set number from block" do
-      expect(config.number).to be_false
-    end
-
-    it "set letters_lower from block" do
-      expect(config.letters_lower).to eq(["a"])
-    end
-
-    it "set letters_upper from block" do
-      expect(config.letters_upper).to eq(["A"])
-    end
-
-    it "set letters_number from block" do
-      expect(config.letters_number).to eq(["0"])
-    end
-
-    it "raise error unknown setting" do
-      expect {
-        config.configure do |c|
-          c.unknown = true
-        end
-      }.to raise_error
-    end
-  end
-
-  describe "#merge" do
-    it "set length from hash" do
-      config.merge(length: 10)
-      expect(config.length).to eq(10)
-    end
-
-    it "set lower from hash" do
-      config.merge(lower: false)
-      expect(config.lower).to be_false
-    end
-
-    it "set upper from hash" do
-      config.merge(upper: false)
-      expect(config.upper).to be_false
-    end
-
-    it "set number from hash" do
-      config.merge(number: false)
-      expect(config.number).to be_false
-    end
-
-    it "set letters_lower from hash" do
-      config.merge(letters_lower: ["a"])
-      expect(config.letters_lower).to eq(["a"])
-    end
-
-    it "set letters_upper from hash" do
-      config.merge(letters_upper: ["A"])
-      expect(config.letters_upper).to eq(["A"])
-    end
-
-    it "set letters_number from hash" do
-      config.merge(letters_number: ["0"])
-      expect(config.letters_number).to eq(["0"])
-    end
-
-    it "raise error unknown setting" do
-      expect {
-        config.merge(unknown: true)
-      }.to raise_error
-    end
-  end
-
-  describe "#letters" do
-    it "return Array object" do
-      expect(config.letters.is_a? Array).to be_true
-    end
-
-    it "all elements of the string" do
-      config.letters.each do |l|
-        expect(l.is_a? String).to be_true
-      end
-    end
-
-    it "return all letters" do
-      all_letters = ("a".."z").to_a.concat(("A".."Z").to_a).concat(("0".."9").to_a)
-      expect(config.letters).to eq(all_letters)
-    end
-
-    it "return except for the lower case" do
-      config.merge(lower: false)
-      expect(config.letters.include? "a").to be_false
-    end
-
-    it "return except for the upper case" do
-      config.merge(upper: false)
-      expect(config.letters.include? "A").to be_false
-    end
-
-    it "return except for the number case" do
-      config.merge(number: false)
-      expect(config.letters.include? "0").to be_false
-    end
-
-    it "raise error if letters is empty" do
-      config.merge(lower: false, upper: false, number: false)
-      expect {
-        config.letters
-      }.to raise_error
-    end
-  end
-
-  describe "#reset" do
-    before {
-      config.configure do |c|
-        c.length = 20
-        c.lower = false
-        c.upper = false
-        c.number = false
-        c.letters_lower = ["a"]
-        c.letters_upper = ["A"]
-        c.letters_number = ["0"]
-      end
-      config.reset
-    }
-
-    it "length should be a default" do
-      expect(config.length).to eq(8)
-    end
-
-    it "lower should be a default" do
-      expect(config.lower).to be_true
-    end
-
-    it "upper should be a default" do
-      expect(config.upper).to be_true
-    end
-
-    it "number should be a default" do
-      expect(config.number).to be_true
-    end
-
-    it "letters_lower should be a default" do
-      expect(config.letters_lower).to eq(("a".."z").to_a)
-    end
-
-    it "letters_upper should be a default" do
-      expect(config.letters_upper).to eq(("A".."Z").to_a)
-    end
-
-    it "letters_number should be a default" do
-      expect(config.letters_number).to eq(("0".."9").to_a)
-    end
-  end
-end