negroni 0.1.0

data/lib/negroni/models/registerable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Negroni
+  module Models
+    # Registerable is responsible for everything related to registering a new
+    # resource (ie user sign up).
+    module Registerable
+      # Required fields for this module (_none_)
+      def self.required_fields(_klass = nil)
+        []
+      end
+    end
+  end
+end

data/lib/negroni/models/validatable.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Negroni
+  module Models
+    # Validatable creates all needed validations for a user email and password.
+    # It's optional, given you may want to create the validations by yourself.
+    # Automatically validate if the email is present, unique and its format is
+    # valid. Also tests presence of password, confirmation and length.
+    #
+    # ## Options
+    #
+    # Validatable adds the following options to devise_for:
+    #
+    #   * `email_regexp`: the regular expression used to validate e-mails
+    #   * `password_length`: a range expressing password length. Default: 8..72
+    #
+    module Validatable
+      extend ActiveSupport::Concern
+
+      # Required fields for :validatable
+      def self.required_fields(_klass = nil)
+        []
+      end
+
+      included do
+        raise RuntimeError unless respond_to?(:validates)
+
+        validates :email, presence: true, if: :email_required?
+
+        with_options allow_blank: true, if: :email_changed? do |val|
+          val.validates :email, uniqueness: true
+          val.validates :email, format: { with: email_regexp }
+        end
+
+        validates :password, presence: true, if: :password_required?
+
+        validates :password, confirmation: true, if: :password_required?
+
+        validates :password, length: { in: password_length }, allow_blank: true
+
+        validates :password_confirmation, presence: true,
+                                          on: [:create, :update],
+                                          if: :password_required?
+      end
+
+      protected
+
+      def password_required?
+        !persisted? || !password.nil? || !password_confirmation.nil?
+      end
+
+      # Override this method if an email is not required for your model
+      def email_required?
+        true
+      end
+
+      # Class methods for Validations
+      module ClassMethods
+        Negroni::Models.config(self, :email_regexp, :password_length)
+      end
+    end
+  end
+end

data/lib/negroni/modules.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/with_options'
+
+Negroni.with_options model: true do |negroni|
+  negroni.register_module :authenticable
+  negroni.register_module :registerable
+  negroni.register_module :lockable
+  negroni.register_module :omniauthable
+  negroni.register_module :recoverable
+  negroni.register_module :validatable
+end

data/lib/negroni/omniauth.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+begin
+  require 'omniauth'
+  require 'omniauth/version'
+rescue LoadError
+  warn 'Could not load `omniauth`.  ' \
+       'Please ensure you have the omniauth gem in your gemfile (>= 1.0.0).'
+  raise
+end
+
+unless OmniAuth::VERSION =~ /^1\./
+  raise 'You are using an old OmniAuth version, please make sure it is >= 1.0.0'
+end
+
+OmniAuth.config.path_prefix = nil
+OmniAuth.config.logger = Rails.logger
+
+module Negroni
+  # The `OmniAuth` module encloses configuration and providers for OmniAuth
+  # integration.
+  module OmniAuth
+    autoload :Config, 'negroni/omniauth/config'
+  end
+end

data/lib/negroni/omniauth/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Negroni
+  module OmniAuth
+    # Raised if a strategy is unknown or not found.
+    class UnknownStrategy < NameError
+      # Raise a new error for `strategy`.
+      def initialize(strategy)
+        @strategy = strategy
+        super("Could not find a strategy named `#{strategy}`.  " \
+              "Please ensure it is `require`d or explicitly set using " \
+              "the :strategy_class option.")
+      end
+    end
+
+    # Config encapsulates OmniAuth configuration for Negroni
+    class Config
+      # @!attribute [rw] strategy
+      #   @return [Symbol] the strategy for OmniAuth
+      attr_accessor :strategy
+
+      # @!attribute [r] args
+      #   @return [Array<Object>] arguments needed to configure the provider
+      attr_reader :args
+
+      # @!attribute [r] options
+      #   @return [Hash] options needed to configure the provider
+      attr_reader :options
+
+      # @!attribute [r] provider
+      #   @return [Symbol] the name of the OmniAuth provider
+      attr_reader :provider
+
+      # @!attribute [r] strategy_name
+      #   @return [String, Symbol] the name of the strategy, if different from
+      #     `provider`
+      attr_reader :strategy_name
+
+      # Create a new OmniAuth::Config
+      #
+      # @param provider [Symbol] the name of the provider to use
+      # @param args [Array<Object>] any arguments to pass to the provider
+      #
+      def initialize(provider, args)
+        @provider       = provider
+        @args           = args
+        @options        = @args.last.is_a?(Hash) ? @args.last : {}
+        @strategy       = nil
+        @strategy_name  = options[:name] || @provider
+        @strategy_class = options.delete(:strategy_class)
+      end
+
+      # @!attribute [r] strategy_class
+      #   @return [Class] the class for the OmniAuth strategy
+
+      # @return [Class] the class for the OmniAuth strategy
+      def strategy_class
+        @strategy_class ||= find_strategy || autoload_strategy
+      end
+
+      # Find a the strategy, using the name provided
+      def find_strategy
+        ::OmniAuth.strategies.find do |klass|
+          klass.to_s =~ /#{::OmniAuth::Utils.camelize(strategy_name)}$/ ||
+            klass.default_options[:name] == strategy_name
+        end
+      end
+
+      # Autoload a strategy
+      def autoload_strategy
+        name = ::OmniAuth::Utils.camelize(provider.to_s)
+
+        if ::OmniAuth::Strategies.const_defined?(name)
+          return ::OmniAuth::Strategies.const_get(name)
+        end
+
+        raise UnknownStrategy, name
+      end
+    end
+  end
+end

data/lib/negroni/orm/active_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'orm_adapter/adapters/active_record'
+
+ActiveSupport.on_load(:active_record) do
+  extend Negroni::Models
+end

data/lib/negroni/orm/mongoid.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+ActiveSupport.on_load(:mongoid) do
+  require 'orm_adapter/adapters/mongoid'
+  Mongoid::Document::ClassMethods.send :include, Negroni::Models
+end

data/lib/negroni/param_filter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Negroni
+  # ParamFilter is responsible for filtering blacklisted parameters from a
+  # request for validation and authentication.
+  class ParamFilter
+    # Creates a new instance of `ParamFilter`.
+    #
+    # @param case_insensitive_keys [Array<Symbol>] keys which are not case
+    #   sensitive
+    # @param strip_whitespace_keys [Array<Symbol>] keys which should have
+    #   whitespace stripped
+    #
+    def initialize(case_insensitive_keys, strip_whitespace_keys)
+      @case_insensitive_keys = case_insensitive_keys || []
+      @strip_whitespace_keys = strip_whitespace_keys || []
+    end
+
+    # Filter the `conditions` based on \@case_insensitive_keys and
+    #   \@strip_whitespace_keys.
+    #
+    # @param conditions [Hash] the conditions hash to filter
+    #
+    # @return [Hash] the filtered `conditions` hash
+    def filter(conditions)
+      conditions = stringify_params(conditions.dup.to_h)
+
+      conditions.merge! filtered_hash_by_meth_for_keys(conditions.dup,
+                                                       :downcase,
+                                                       @case_insensitive_keys)
+
+      conditions.merge! filtered_hash_by_meth_for_keys(conditions.dup,
+                                                       :strip,
+                                                       @strip_whitespace_keys)
+    end
+
+    private
+
+    def filtered_hash_by_meth_for_keys(conditions, method, condition_keys)
+      condition_keys.each do |key|
+        value = conditions[key]
+        conditions[key] = value.send(method) if value.respond_to?(method)
+      end
+
+      conditions
+    end
+
+    def stringify_params(conditions)
+      return conditions unless conditions.is_a? Hash
+      conditions.each { |k, v| conditions[k] = v.to_s }
+    end
+  end
+end

data/lib/negroni/resolver.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Negroni
+  # @api private
+  # Resolver is responsible for getting and `constantizing` a string.
+  class Resolver
+    # Create a Resolver
+    def initialize(reference)
+      @reference = reference
+    end
+
+    # Resolve a string to a constant
+    def resolve
+      ActiveSupport::Dependencies.constantize(@reference)
+    end
+  end
+end

data/lib/negroni/token_generator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module Negroni
+  # Generates a secure token.
+  class TokenGenerator
+    # Creates a new token generator.
+    #
+    # @param key_generator [ActiveSupport::CachingKeyGenerator] the generator
+    # @param digest [String, Symbol] The digest to use.  Must be a stringified
+    # version of an OpenSSL::Digest subclass.  Default: `SHA256`.
+    def initialize(key_generator = nil, digest = 'SHA256', secret_key: nil)
+      @key_generator = if secret_key
+                         ActiveSupport::CachingKeyGenerator.new(
+                           ActiveSupport::KeyGenerator.new(secret_key)
+                         )
+                       elsif key_generator
+                         key_generator
+                       else
+                         raise ArgumentError, 'Unexpected arguments!'
+                       end
+      @digest = digest
+    end
+
+    # Digest a key.
+    #
+    # @param _klass [Class] the class for which to digest the value.
+    # @param column [String] the column name to digest.
+    # @param value [#to_s] the value to digest.
+    #
+    # @return [String] the digested value.
+    def digest(_klass, column, value)
+      return unless value.present?
+      OpenSSL::HMAC.hexdigest(@digest, key_for(column), value.to_s)
+    end
+
+    # Generate a key.
+    #
+    # @param klass [Class] the class for which to generate the key.
+    # @param column [String] the column name to generate a key for.
+    def generate(klass, column)
+      key = key_for(column)
+
+      loop do
+        raw = Negroni.friendly_token
+        enc = OpenSSL::HMAC.hexdigest(@digest, key, raw)
+        break [raw, enc] unless klass.to_adapter.find_first(column => enc)
+      end
+    end
+
+    private
+
+    def key_for(column)
+      @key_generator.generate_key "Negroni #{column}"
+    end
+  end
+end

data/lib/negroni/token_not_found.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Negroni
+  # Raised when a token is bad
+  class TokenNotFound < StandardError
+    # Override for better `raise` calls
+    #
+    # @param object [Object] whatever you want
+    def self.exception(object)
+      super "The record #{object} could not be found."
+    end
+  end
+end

data/lib/negroni/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Negroni
+  # Version number
+  VERSION = '0.1.0'
+end

data/lib/tasks/negroni_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :api_auth do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: negroni
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- J. Morgan Lieberthal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+- !ruby/object:Gem::Dependency
+  name: knock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: orm_adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+description: Very light user management plugin for rails api apps
+email:
+- j.morgan.lieberthal@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- app/mailers/negroni/mailer.rb
+- app/views/negroni/mailer/password_change.html.erb
+- app/views/negroni/mailer/reset_password_instructions.html.erb
+- app/views/negroni/mailer/unlock_instructions.html.erb
+- config/locales/en.yml
+- config/routes.rb
+- lib/negroni.rb
+- lib/negroni/configuration.rb
+- lib/negroni/controllers/helpers.rb
+- lib/negroni/controllers/token_authenticable.rb
+- lib/negroni/encryptor.rb
+- lib/negroni/engine.rb
+- lib/negroni/mailers/helpers.rb
+- lib/negroni/models.rb
+- lib/negroni/models/authenticable.rb
+- lib/negroni/models/base.rb
+- lib/negroni/models/lockable.rb
+- lib/negroni/models/omniauthable.rb
+- lib/negroni/models/recoverable.rb
+- lib/negroni/models/registerable.rb
+- lib/negroni/models/validatable.rb
+- lib/negroni/modules.rb
+- lib/negroni/omniauth.rb
+- lib/negroni/omniauth/config.rb
+- lib/negroni/orm/active_record.rb
+- lib/negroni/orm/mongoid.rb
+- lib/negroni/param_filter.rb
+- lib/negroni/resolver.rb
+- lib/negroni/token_generator.rb
+- lib/negroni/token_not_found.rb
+- lib/negroni/version.rb
+- lib/tasks/negroni_tasks.rake
+homepage: https://github.com/baberthal/negroni
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Very light user management plugin for rails api apps
+test_files: []