passwd 0.1.3 → 0.4.0

data/.coveralls.yml

@@ -1 +0,0 @@
-repo_token: 106V5oEIwXeOfqT35UWifTnifi5sEO2QP

data/.travis.yml

@@ -1,10 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 2.0.0
-gemfile:
-  - Gemfile
-script: bundle exec rake spec
-notifications:
-  mails:
-    - i2bskn@gmail.com

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2013 i2bskn
-
-MIT License
-
-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/lib/passwd/active_record.rb

@@ -1,58 +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|
-          if Passwd.auth(old_pass, self.send(salt_name), self.send(password_name))
-            set_password(new_pass)
-          else
-            false
-          end
-        end
-      end
-    end
-
-    class << self
-      def included(base)
-        base.extend ClassMethods
-      end
-    end
-  end
-end

data/lib/passwd/base.rb

@@ -1,72 +0,0 @@
-# coding: utf-8
-
-require "singleton"
-require "passwd/configuration/config"
-require "passwd/configuration/tmp_config"
-require "passwd/configuration/policy"
-
-module Passwd
-  @config = Config.instance
-  @policy = Policy.instance
-
-  module Base
-    def create(options={})
-      if options.empty?
-        config = @config
-      else
-        config = TmpConfig.new(@config, options)
-      end
-      Array.new(config.length){config.letters[rand(config.letters.size)]}.join
-    end
-
-    def auth(password_text, salt_hash, password_hash)
-      enc_pass = Passwd.hashing("#{salt_hash}#{password_text}")
-      password_hash == enc_pass
-    end
-
-    def hashing(plain)
-      Digest::SHA1.hexdigest plain
-    end
-
-    def confirm_check(password, confirm, with_policy=false)
-      return false if password != confirm
-      return true unless with_policy
-      Passwd.policy_check(password)
-    end
-
-    def configure(options={}, &block)
-      if block_given?
-        @config.configure &block
-      else
-        if options.empty?
-          @config
-        else
-          @config.merge options
-        end
-      end
-    end
-    alias :config :configure
-
-    def policy_configure(&block)
-      if block_given?
-        @policy.configure &block
-      else
-        @policy
-      end
-    end
-
-    def policy_check(password)
-      @policy.valid?(password, @config)
-    end
-
-    def reset_config
-      @config.reset
-    end
-
-    def reset_policy
-      @policy.reset
-    end
-  end
-
-  extend Base
-end

data/lib/passwd/configuration/abstract_config.rb

@@ -1,36 +0,0 @@
-# coding: utf-8
-
-module Passwd
-  class AbstractConfig
-    VALID_OPTIONS_KEYS = [
-      :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,23 +0,0 @@
-# coding: utf-8
-
-require "passwd/configuration/abstract_config"
-
-module Passwd
-  class Config < AbstractConfig
-    include Singleton
-
-    def initialize
-      reset
-    end
-
-    def reset
-      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/lib/passwd/password.rb

@@ -1,41 +0,0 @@
-# coding: utf-8
-
-module Passwd
-  class Password
-    attr_reader :text, :hash, :salt_text, :salt_hash
-
-    def initialize(options={})
-      @text = options.fetch(:password, Passwd.create)
-      @salt_text = options.fetch(: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 ==(password)
-      enc_pass = Passwd.hashing("#{@salt_hash}#{password}")
-      @hash == enc_pass
-    end
-  end
-end

data/samples/activerecord/user.rake

@@ -1,28 +0,0 @@
-namespace :user do
-  # E.G. rake name="Taro Suzuki" email=taro@example.com password=secret user:create
-  desc "create user (specify env of name and email and password)"
-  task :create => :environment do
-    raise ArgumentError, "email is required" if ENV["email"].nil?
-    raise ArgumentError, "name is required" if ENV["name"].nil?
-
-    raise "must be a unique email" if User.exists?(email: ENV["email"])
-    
-    user = User.new(name: ENV["name"], email: ENV["email"])
-
-    password = user.set_password(ENV["password"])
-    user.save!
-    puts "Creating a user was successful.\nPassword: #{password}"
-  end
-
-  # E.G. rake email=taro@example.com password=secret user:password_update
-  desc "update password (specify env of email and password)"
-  task :password_update => :environment do
-    raise ArgumentError, "email is required" if ENV["email"].nil?
-    raise "must specify the email that exists" unless User.exists?(email: ENV["email"])
-
-    user = User.find_by(email: ENV["email"])
-    password = user.set_password(ENV["password"])
-    user.save!
-    puts "Password update was successful.\nPassword: #{password}"
-  end
-end

data/spec/passwd/active_record_spec.rb

@@ -1,142 +0,0 @@
-# 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