passwd 0.2.0 → 0.3.0

data/example/public/robots.txt

@@ -1,5 +0,0 @@
-# See http://www.robotstxt.org/robotstxt.html for documentation on how to use the robots.txt file
-#
-# To ban all spiders from the entire site uncomment the next two lines:
-# User-agent: *
-# Disallow: /

data/lib/generators/passwd/config_generator.rb

@@ -1,13 +0,0 @@
-module Passwd
-  module Generators
-    class ConfigGenerator < ::Rails::Generators::Base
-      source_root File.expand_path(File.join(File.dirname(__FILE__), "templates"))
-
-      desc "Create Passwd configuration file"
-      def create_configuration_file
-        template "passwd_config.rb", "config/initializers/passwd.rb"
-      end
-    end
-  end
-end
-

data/lib/generators/passwd/templates/passwd_config.rb

@@ -1,41 +0,0 @@
-Passwd.configure do |c|
-  # Password settings
-  # The following settings are all default values.
-
-  # Hashing algorithm
-  # Supported algorithm is :md5, :rmd160, :sha1, :sha256, :sha384 and :sha512
-  # c.algorithm = :sha512
-
-  # Random generate password length
-  # c.length = 8
-
-  # Number of hashed by stretching
-  # Not stretching if specified nil.
-  # c.stretching = nil
-
-  # Character type that is used for password
-  # c.lower = true
-  # c.upper = true
-  # c.number = true
-end
-
-Passwd.policy_configure do |c|
-  # Minimum password length
-  # c.min_length = 8
-
-  # Character types to force the use
-  # c.require_lower = true
-  # c.require_upper = false
-  # c.require_number = true
-end
-
-# Session key for authentication
-Rails.application.config.passwd.session_key = :user_id
-
-# Authentication Model Class
-Rails.application.config.passwd.authenticate_class = :User
-
-# Redirect path when not signin
-# E.G. :signin_path # Do not specify ***_url
-Rails.application.config.passwd.redirect_to = nil
-

data/lib/passwd/action_controller_ext.rb

@@ -1,48 +0,0 @@
-module Passwd
-  module ActionControllerExt
-    extend ActiveSupport::Concern
-
-    included do
-      helper_method :current_user
-    end
-
-    def current_user
-      @current_user ||= auth_class.find_by(id: session[auth_key])
-    end
-
-    def signin!(user)
-      @current_user = user
-      session[auth_key] = user.id
-    end
-
-    def signout!
-      @current_user = session[auth_key] = nil
-    end
-
-    private
-      def auth_key
-        Rails.application.config.passwd.session_key || :user_id
-      end
-
-      def auth_class
-        @_auth_class ||=
-          (Rails.application.config.passwd.authenticate_class || :User).to_s.constantize
-      end
-
-      def _redirect_path
-        _to = Rails.application.config.passwd.redirect_to
-        _to ? Rails.application.routes.url_helpers.send(_to) : nil
-      end
-
-      def require_signin
-        unless current_user
-          if _redirect_path
-            redirect_to _redirect_path
-          else
-            raise UnauthorizedAccess
-          end
-        end
-      end
-  end
-end
-

data/lib/passwd/active_record_ext.rb

@@ -1,65 +0,0 @@
-module Passwd
-  module ActiveRecordExt
-    def with_authenticate(options = {})
-      _id_key = options.fetch(:id, :email)
-      _salt_key = options.fetch(:salt, :salt)
-      _pass_key = options.fetch(:password, :password)
-
-      _define_passwd(_salt_key, _pass_key)
-      _define_singleton_auth(_id_key)
-      _define_instance_auth
-      _define_set_password(_salt_key, _pass_key)
-      _define_update_password(_salt_key, _pass_key)
-    end
-
-    private
-      def _define_passwd(_salt_key, _pass_key)
-        define_method :passwd do |cache = true|
-          return @_passwd if cache && @_passwd
-          self.reload unless self.new_record?
-          _salt, _pass = self.send(_salt_key), self.send(_pass_key)
-          if _salt.present? && _pass.present?
-            @_passwd = Passwd::Password.from_hash(_pass, _salt)
-          else
-            self.set_password
-          end
-        end
-      end
-
-      def _define_singleton_auth(_id_key)
-        define_singleton_method :authenticate do |_id, _pass|
-          _condition = Array(_id_key).map {|k| "#{k} = :id"}.join(" OR ")
-          _user = self.find_by(_condition, id: _id)
-          _user if _user && _user.passwd.match?(_pass)
-        end
-      end
-
-      def _define_instance_auth
-        define_method :authenticate do |_pass|
-          self.passwd.match?(_pass)
-        end
-      end
-
-      def _define_set_password(_salt_key, _pass_key)
-        define_method :set_password do |_pass = nil|
-          _options = _pass ? {plain: _pass} : {}
-          _passwd = Passwd::Password.new(_options)
-          self.send("#{_salt_key}=", _passwd.salt.hash)
-          self.send("#{_pass_key}=", _passwd.hash)
-          self.instance_variable_set(:@_passwd, _passwd)
-        end
-      end
-
-      def _define_update_password(_salt_key, _pass_key)
-        define_method :update_password do |_old, _new, _policy = false|
-          raise PolicyNotMatch if _policy && !Passwd.policy_check(_new)
-          if self.passwd.match?(_old)
-            self.set_password(_new)
-          else
-            raise AuthenticationFails
-          end
-        end
-      end
-  end
-end
-

data/lib/passwd/base.rb

@@ -1,31 +0,0 @@
-module Passwd
-  module Base
-    def random(options = {})
-      c = PwConfig.merge(options)
-      Array.new(c.length){c.letters[rand(c.letters.size)]}.join
-    end
-
-    def digest(plain, _algorithm = nil)
-      _algorithm ||= PwConfig.algorithm
-
-      if PwConfig.stretching
-        _pass = plain
-        PwConfig.stretching.times do
-          _pass = digest_without_stretching(_pass, _algorithm)
-        end
-      else
-        digest_without_stretching(plain, _algorithm)
-      end
-    end
-
-    def digest_without_stretching(plain, _algorithm = nil)
-      algorithm(_algorithm || PwConfig.algorithm).hexdigest(plain)
-    end
-
-    private
-      def algorithm(_algorithm)
-        Digest.const_get(_algorithm.upcase, false)
-      end
-  end
-end
-

data/lib/passwd/configuration.rb

@@ -1,82 +0,0 @@
-module Passwd
-  class Configuration
-    KINDS = %i(lower upper number).freeze
-    LETTERS = KINDS.map {|k| "letters_#{k}".to_sym}.freeze
-
-    VALID_OPTIONS = [
-      :algorithm,
-      :length,
-      :policy,
-      :stretching,
-    ].concat(KINDS).concat(LETTERS).freeze
-
-    attr_accessor *VALID_OPTIONS
-
-    def initialize
-      reset
-    end
-
-    def configure
-      yield self
-    end
-
-    def merge(params)
-      self.dup.merge!(params)
-    end
-
-    def merge!(params)
-      params.keys.each do |key|
-        self.send("#{key}=", params[key])
-      end
-      self
-    end
-
-    KINDS.each do |kind|
-      define_method "#{kind}_chars" do
-        self.send("letters_#{kind}") || []
-      end
-    end
-
-    def letters
-      KINDS.detect {|k| self.send(k)} || (raise ConfigError, "letters is empry.")
-      LETTERS.zip(KINDS).map {|l, k|
-        self.send(l) if self.send(k)
-      }.compact.flatten
-    end
-
-    def reset
-      self.algorithm = :sha512
-      self.length = 8
-      self.policy = Policy.new
-      self.stretching = nil
-      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
-
-    module Writable
-      def self.extended(base)
-        base.send(:include, Accessible)
-      end
-
-      def configure(options = {}, &block)
-        PwConfig.merge!(options) unless options.empty?
-        PwConfig.configure(&block) if block_given?
-      end
-
-      def policy_configure(&block)
-        PwConfig.policy.configure(&block) if block_given?
-      end
-    end
-
-    module Accessible
-      def self.included(base)
-        base.const_set(:PwConfig, Configuration.new)
-      end
-    end
-  end
-end
-

data/lib/passwd/password.rb

@@ -1,89 +0,0 @@
-module Passwd
-  class Password
-    include Base
-
-    attr_reader :plain, :hash, :salt
-
-    def initialize(options = {})
-      options = default_options.merge(options)
-
-      if options.has_key?(:hash)
-        raise ArgumentError unless options.has_key?(:salt_hash)
-        @salt = Salt.from_hash(options[:salt_hash], self)
-        @hash = options[:hash]
-      else
-        @salt =
-          case
-          when options.has_key?(:salt_hash)
-            Salt.from_hash(options[:salt_hash], self)
-          when options.has_key?(:salt_plain)
-            Salt.from_plain(options[:salt_plain], self)
-          else
-            Salt.new(password: self)
-          end
-        self.update_plain(options[:plain])
-      end
-    end
-
-    def update_plain(value)
-      @plain = value
-      rehash
-    end
-
-    def update_hash(value, salt_hash)
-      @plain = nil
-      @hash = value
-      self.salt.update_hash(salt_hash)
-    end
-
-    def rehash
-      raise PasswdError unless self.plain
-      @hash = digest([self.salt.hash, self.plain].join)
-    end
-
-    def match?(value)
-      self.hash == digest([self.salt.hash, value].join)
-    end
-
-    def ==(other)
-      match?(other)
-    end
-
-    def to_s
-      self.plain.to_s
-    end
-
-    def valid?
-      raise PasswdError unless self.plain
-
-      return false if PwConfig.policy.min_length > self.plain.size
-
-      Configuration::KINDS.each do |key|
-        if PwConfig.policy.send("require_#{key}")
-          return false unless include_char?(PwConfig.send("letters_#{key}"))
-        end
-      end
-      true
-    end
-
-    def self.from_plain(value, options = {})
-      new(options.merge(plain: value))
-    end
-
-    def self.from_hash(value, salt_hash)
-      new(hash: value, salt_hash: salt_hash)
-    end
-
-    private
-      def default_options
-        {plain: random}
-      end
-
-      def include_char?(letters)
-        raise PasswdError unless self.plain
-        self.plain.chars.uniq.each {|c| return true if letters.include?(c)}
-        false
-      end
-  end
-end
-

data/lib/passwd/policy.rb

@@ -1,28 +0,0 @@
-module Passwd
-  class Policy
-    VALID_OPTIONS = [
-      :min_length,
-      :require_lower,
-      :require_upper,
-      :require_number
-    ].freeze
-
-    attr_accessor *VALID_OPTIONS
-
-    def initialize
-      reset
-    end
-
-    def configure
-      yield self
-    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/salt.rb

@@ -1,50 +0,0 @@
-module Passwd
-  class Salt
-    include Base
-
-    attr_reader :plain, :hash
-
-    def initialize(options = {})
-      options = default_options.merge(options)
-
-      @password = options[:password]
-      if options.has_key?(:hash)
-        @plain = nil
-        @hash = options[:hash]
-      else
-        @plain = options[:plain] || (raise ArgumentError)
-        @hash = digest_without_stretching(@plain)
-      end
-    end
-
-    def update_plain(value)
-      @plain = value
-      @hash = digest_without_stretching(@plain)
-      update_password!
-    end
-
-    def update_hash(value)
-      @plain = nil
-      @hash = value
-      update_password!
-    end
-
-    def self.from_plain(value, password = nil)
-      new(plain: value, password: password)
-    end
-
-    def self.from_hash(value, password = nil)
-      new(hash: value, password: password)
-    end
-
-    private
-      def default_options
-        {plain: Time.now.to_s}
-      end
-
-      def update_password!
-        @password.rehash if @password && @password.plain
-      end
-  end
-end
-