negroni 0.1.0

data/lib/negroni/configuration.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Negroni
+  # `Configuration` encapsulates all of the configuration for Negroni,
+  # keeping it out of the main module.
+  class Configuration
+    # The default email validation regex.
+    DEFAULT_EMAIL_VALIDATION_REGEX = /\A[^@\s]+@[^@\s]+\z/i
+    # /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
+
+    # @!group Authenticable Configuration
+
+    # Keys used when authenticating
+    # @return [Array<Symbol>]
+    attr_accessor :authentication_keys
+
+    # Keys that should be treated as case-insensitive
+    # @return [Array<Symbol>]
+    attr_accessor :case_insensitive_keys
+
+    # Keys that should have whitespace skipped
+    # @return [Array<Symbol>]
+    attr_accessor :strip_whitespace_keys
+
+    # When true, send an email to notify password changes
+    # @return [Boolean]
+    attr_accessor :send_password_change_notification
+
+    # How long before a token is expired. If nil is provided, token will
+    # last forever.
+    #
+    # @return [ActiveSupport::Duration]
+    attr_accessor :token_lifetime
+
+    # The audience claim to identify the recipients that the token
+    # is intended for.
+    #
+    # @return [Object]
+    attr_accessor :token_audience
+
+    # The name of the exception class that will be raised upon receiving an
+    # invalid auth token.
+    #
+    # Default: {Negroni::TokenNotFound}
+    #
+    # @return [Class, String]
+    attr_accessor :not_found_exception
+
+    # @!group Validatable Configuration
+
+    # Regular expression to validate emails
+    # @return [RegExp]
+    attr_accessor :email_regexp
+
+    # Range validation for password
+    # @return [Range]
+    attr_accessor :password_length
+
+    # @!group Encryption Configuration
+
+    # The number of times to hash the password
+    # @return [Integer]
+    attr_accessor :stretches
+
+    # Used to hash the password. Generate one with `rake secret`.
+    # @return [String] the pepper used to hash the password
+    attr_accessor :pepper
+
+    # The algorithm used to encode the token.  Default: 'HS256'
+    #
+    # @return [String]
+    attr_accessor :token_algorithm
+
+    # The secret key that will be used for the token.  Default:
+    # {Negroni::secret_key}.
+    #
+    # @return [String]
+    attr_accessor :token_secret
+
+    # An optional public key used to decode tokens.
+    #
+    # @return [String]
+    attr_accessor :token_public_key
+
+    # @!group Lockable Configuration
+
+    # Defines which strategy will be used to lock an account.
+    #
+    #   * `:failed_attempts` = Locks an account after a number of failed
+    #           attempts.
+    #   * `:none`            = No lock strategy. You should handle locking by
+    #           yourself.
+    #
+    # @return [Symbol] the name of the lock strategy.
+    attr_accessor :lock_strategy
+
+    # Defines which key will be used when locking and unlocking an account
+    # @return [Array<Symbol>]
+    attr_accessor :unlock_keys
+
+    # Defines which strategy can be used to unlock an account.
+    # Valid values: `:email,` `:time,` `:both`
+    # @return [Symbol]
+    attr_accessor :unlock_strategy
+
+    # Number of authentication tries before locking an account
+    # @return [Integer]
+    attr_accessor :maximum_attempts
+
+    # Time interval to unlock the account if `:time` is defined as
+    # `unlock_strategy`.
+    #
+    # @return [ActiveSupport::Duration]
+    attr_accessor :unlock_in
+
+    # Defines which key will be used when recovering the password for an account
+    # @return [Array<Symbol>]
+    attr_accessor :reset_password_keys
+
+    # Time interval you can reset your password with a reset password key
+    # @return [ActiveSupport::Duration]
+    attr_accessor :reset_password_within
+
+    # @!group Mailer Configuration
+
+    # The sender for all mailers
+    # @return [String] the email address for the sender
+    attr_accessor :mailer_sender
+
+    # The class `Mailer` should inherit from (`'ActionMailer::Base'` by default)
+    # @return [String]
+    attr_accessor :parent_mailer
+
+    # @!group Controller Configuration
+
+    # The class `Negroni::BaseController` should inherit from.
+    #
+    # Default: ActionController::API
+    #
+    # @return [String, Class]
+    attr_accessor :parent_controller
+
+    # @!endgroup
+
+    # Create a new instance of `Configuration`, using default values for all
+    # attributes.
+    def initialize # rubocop:disable Metrics/AbcSize,MethodLength
+      @authentication_keys = [:email]
+      @case_insensitive_keys = [:email]
+      @strip_whitespace_keys = [:email]
+      @send_password_change_notification = false
+      @token_lifetime = 1.day
+      @token_algorithm = 'HS256'
+      @not_found_exception = 'Negroni::TokenNotFound'
+      @email_regexp = DEFAULT_EMAIL_VALIDATION_REGEX
+      @password_length = 8..72
+      @stretches = 11
+      @pepper = nil
+      @lock_strategy = :failed_attempts
+      @unlock_keys = [:email]
+      @unlock_strategy = :both
+      @maximum_attempts = 20
+      @unlock_in = 1.hour
+      @reset_password_keys = [:email]
+      @reset_password_within = 6.hours
+      @mailer_sender = nil
+      @parent_mailer = 'ActionMailer::Base'
+      @parent_controller = 'ActionController::API'
+    end
+
+    # `Delegation` adds methods to the including or extending class to delegate
+    # parameters to an instance of {Configuration}.
+    #
+    # Additionally, it provides a method `{#configuration}`, which is simply a
+    # lazily-instantiated instance of {Configuration}.
+    #
+    module Delegation
+      # Create delegation method for configuration
+      #
+      def self.config_delegator(*attrs)
+        attrs.each do |attribute|
+          class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def #{attribute}
+              configuration.#{attribute}
+            end
+
+            def #{attribute}=(new_value)
+              configuration.#{attribute} = new_value
+            end
+          METHOD
+        end
+      end
+
+      # The configuration object
+      # @return [Configuration]
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      # @!macro [attach] cfg.delegator
+      #   Delegates `$1` to #configuration.
+      #
+      #   {render:Configuration#$1}
+      #
+      config_delegator :authentication_keys
+      config_delegator :case_insensitive_keys
+      config_delegator :strip_whitespace_keys
+      config_delegator :send_password_change_notification
+      config_delegator :token_lifetime
+      config_delegator :token_audience
+      config_delegator :not_found_exception
+      config_delegator :email_regexp
+      config_delegator :password_length
+      config_delegator :stretches
+      config_delegator :pepper
+      config_delegator :token_algorithm
+      config_delegator :token_secret
+      config_delegator :token_public_key
+      config_delegator :lock_strategy
+      config_delegator :unlock_keys
+      config_delegator :unlock_strategy
+      config_delegator :maximum_attempts
+      config_delegator :unlock_in
+      config_delegator :reset_password_keys
+      config_delegator :reset_password_within
+      config_delegator :mailer_sender
+      config_delegator :parent_mailer
+      config_delegator :parent_controller
+    end
+  end
+end

data/lib/negroni/controllers/helpers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Negroni
+  module Controllers
+    # Helpers for controllers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        prepend PrependedMethods
+      end
+
+      # Methods that are prepended into the class that includes {Helpers}
+      module PrependedMethods
+        extend ActiveSupport::Concern
+
+        included do
+          rescue_from Negroni.not_found_exception, with: :not_found
+        end
+
+        private
+
+        def not_found
+          head :not_found
+        end
+      end
+    end
+  end
+end

data/lib/negroni/controllers/token_authenticable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'knock/authenticable'
+
+module Negroni
+  module Controllers
+    # TokenAuthenticable adds methods to the including controller class to
+    # enable authentication via json web tokens.  Basically, it just includes
+    # {Knock::Authenticable} in the class.
+    #
+    # @see Knock::Authenticable
+    module TokenAuthenticable
+      extend ActiveSupport::Concern
+
+      included do
+        include Knock::Authenticable
+      end
+    end
+  end
+end

data/lib/negroni/encryptor.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'bcrypt'
+
+module Negroni
+  # Handles password encryption and digestion
+  module Encryptor
+    class << self
+      # Digest a password
+      #
+      # @param klass [Class] the class for which to digest
+      # @param password [String] the password to digest
+      def digest(klass, password)
+        password = "#{password}#{klass.pepper}" if klass.pepper.present?
+
+        ::BCrypt::Password.create(password, cost: klass.stretches).to_s
+      end
+
+      # Compare two passwords
+      #
+      # @param klass [Class] the class for which to digest
+      # @param hashed_password [String] the hashed password to compare
+      # @param password [String] the password to compare with `hashed_password`
+      def compare(klass, hashed_password, password)
+        return false if hashed_password.blank?
+
+        bcrypt   = ::BCrypt::Password.new(hashed_password)
+        password = "#{password}#{klass.pepper}" if klass.pepper.present?
+        password = ::BCrypt::Engine.hash_secret(password, bcrypt.salt)
+
+        Negroni.secure_compare(password, hashed_password)
+      end
+    end
+  end
+end

data/lib/negroni/engine.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Negroni
+  # The Rails engine
+  class Engine < ::Rails::Engine
+    isolate_namespace Negroni
+
+    config.generators do |g|
+      g.api_only = true
+      g.test_framework :rspec, fixture_replacement: :factory_girl
+      g.factory_girl dir: 'spec/factories'
+    end
+
+    config.negroni = Negroni
+
+    initializer 'negroni.omniauth', after: :load_config_initializers,
+                                    before: :build_middleware_stack do |app|
+      Negroni.omniauth_configs.each do |_provider, config|
+        app.middleware.use config.strategy_class, *config.args do |strategy|
+          config.strategy = strategy
+        end
+      end
+    end
+
+    initializer 'negroni.secret_key' do |app|
+      Negroni.secret_key ||= app.secrets.secret_key_base
+      Negroni.token_secret ||= app.secrets.secret_key_base
+
+      Negroni.token_generator ||=
+        if (secret_key = Negroni.secret_key)
+          Negroni::TokenGenerator.new(secret_key: secret_key)
+        end
+    end
+  end
+end

data/lib/negroni/mailers/helpers.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Negroni
+  # Namespace for Mailer-related code
+  module Mailers
+    # Common helpers for mailers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      protected
+
+      # @!attribute [r] resource
+      #   @return [Object, #email] the resource object that we are mailing to
+      attr_reader :resource
+
+      # @!attribute [r] scope_name
+      #   @return [String] the name of the record's class, underscored
+      attr_reader :scope_name
+
+      # Configure default email options
+      #
+      # @param record [Object] the object (record) that we are mailing to
+      # @param action [Symbol] the mail action to perform
+      # @param opts [Hash] a hash of options that will be sent to `headers_for`
+      #
+      def negroni_mail(record, action, opts = {}, &block)
+        initialize_from_record(record)
+        mail headers_for(action, opts), &block
+      end
+
+      # Initialize the including class with a record
+      #
+      # @param record [Object] the record to send the email to
+      #
+      def initialize_from_record(record)
+        @scope_name = record.class.to_s.underscore
+        @resource = instance_variable_set("@#{scope_name}", record)
+      end
+
+      # Generate a set of mail headers for a given action
+      #
+      # @param action [String, Symbol, #to_s] The mail action that will occur
+      # @param opts [Hash] a hash of additional options to merge with the
+      #         headers
+      def headers_for(action, opts = {})
+        headers = {
+          subject: subject_for(action),
+          to: resource.email,
+          from: mailer_from,
+          reply_to: mailer_reply_to,
+          template_path: template_paths,
+          template_name: action
+        }.merge(opts)
+
+        @email = headers[:to]
+        headers
+      end
+
+      def mailer_reply_to
+        mailer_sender(:reply_to)
+      end
+
+      def mailer_from
+        mailer_sender(:from)
+      end
+
+      def mailer_sender(sender = :from)
+        default_sender = default_params[sender]
+
+        unless default_sender.present?
+          ms = Negroni.mailer_sender
+          return ms.is_a?(Proc) ? instance_eval(&ms) : ms
+        end
+
+        if default_sender.respond_to?(:to_proc)
+          instance_eval(&default_sender)
+        else
+          default_sender
+        end
+      end
+
+      def template_paths
+        _prefixes.dup
+      end
+
+      # Set up a subject doing an I18n lookup. At first, it attempts to set a
+      # subject based on the current mapping:
+      #
+      #   en:
+      #     negroni:
+      #       mailer:
+      #         confirmation_instructions:
+      #           user_subject: '...'
+      #
+      # If one does not exist, it fallbacks to ActionMailer default:
+      #
+      #   en:
+      #     negroni:
+      #       mailer:
+      #         confirmation_instructions:
+      #           subject: '...'
+      #
+      # @param key [Symbol, String] the key to lookup for I18n
+      # @return [String]
+      def subject_for(key)
+        I18n.t(:"#{@scope_name}_subject",
+               scope: [:negroni, :mailer, key],
+               default: [:subject, key.to_s.humanize])
+      end
+    end
+  end
+end