elambot_secure_password 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5df4870c3b88f99bb82f6266a19d01398f6f656467226e55536e47a600479850
+  data.tar.gz: 459d62622440889b85090703218107b9d55e1eca8f6b901e582c422d6173cd16
+SHA512:
+  metadata.gz: c7865342f1396814cba6147a77a7d43d9dbc262c4452411738669cf35cf53cf0874edfd97614a5e7bb9b0e3d54be5c8fc178817253901aa5bc0ae3ab4a19c9d7
+  data.tar.gz: 89d7c8e722037074f8b2ef9e3b2c5e8e928ca32933745aba74ada32d37c1310b7f54a8c8fd3f2ed0fa5caf6a663eff074a309972c23740aa9c6c890a5eca2f0e

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-03-18
+
+- Initial release

data/README.md

@@ -0,0 +1,111 @@
+# ElambotSecurePassword
+
+ElambotSecurePassword is a simple Ruby gem for generating secure passwords. It can be used within a Rails application
+or as a simple password generation tool from the command line.
+
+## Installation
+
+From the command line, install the gem by executing:
+
+```bash
+gem install elambot_secure_password
+````
+Or add this line to your application's Gemfile:
+
+```ruby
+gem 'elambot_secure_password'
+```
+
+## Getting started
+
+To generate a password simply include the following lines in your application or run these commands in an irb session:
+
+```ruby
+require 'elambot_secure_password'
+
+ElambotSecurePassword.generate_password
+```
+
+## Available options
+
+The `generate_password` method accepts a hash of options. The available options are:
+
+- `length (Integer)` - (default: 10) - The length of the password to generate
+- `lowercase (Boolean)` - (default: true) - Include one or more lowercase `a-z` characters.
+- `uppercase (Boolean)` - (default: false) - Include one or more uppercase `A-Z` characters.
+- `number` - (default: 0) - The exact number of numeric characters to include.
+- `special` - (default: 0) - The exact number of special characters to include.
+
+## Examples
+
+### Generate a password with a length of 12 characters
+
+```ruby
+ElambotSecurePassword.generate_password(12)
+```
+
+### Generate a password with a length of 12 characters and advanced options
+
+```ruby
+ElambotSecurePassword.generate_password(12, {
+  uppercase: true, # Include uppercase characters
+  lowercase: true, # Include lowercase characters
+  special: 3, # Include 3 special characters
+  number: 5, # Include 5 numeric characters
+})
+```
+
+## Error messaging
+
+If the options provided are invalid, the gem will raise an error with a message indicating the issue.
+
+### Example (Invalid special character option)
+
+```ruby
+ElambotSecurePassword.generate_password(12, {
+  special: true, # Invalid special character option
+})
+
+special option must be a number(ArgumentError)
+```
+
+## Notes on the project
+
+I found this project to be a great learning experience. I had never created a Ruby gem before, so it was a great opportunity to learn how to do so.
+
+I decided to use RubyMine's built in interface to set up the project. Now that I have a better 
+understanding of the file structure of a Ruby gem, if I were to do this project again I would like to set up the gem manually.
+
+### Approach
+
+The main challenge I faced when developing the logic for the password creation was to ensure that the password would contain the selected
+number of special characters and numbers whilst maintaining the specified length.
+
+To solve this, I first subtracted the number of special characters and numbers from the length option and stored the result in a variable called `remaining_length`. 
+I then created an empty array to store the password characters and added the required number of special characters and numbers to the array. 
+
+Next, I used the `remaining_length` variable to add the remaining number of characters to the `characters` array. Either lowercase, uppercase or a mix of both depending on the options selected.
+
+Finally, I shuffled the `characters` array and joined the elements to create the password.
+
+I have chosen to return a default password of random lowercase characters if no options are provided, or if uppercase and lowercase are set to `false` and `special` and `number` are not set.
+I felt this was a better approach than raising an error as it makes the gem more user-friendly.
+
+### Challenges
+
+I didn't encounter any major difficulties developing the gem. RubyMine made setting up the gem very straightforward. And deciding on the logic, whilst challenging, was also very rewarding.
+
+The main challenge was keeping the logic as clean and simple as possible. I'm happy with the result but there are definitely improvements I would like to make.
+
+### Improvements
+
+If I were to continue working on this project my main area of focus would be the `validate_options` method. I would like to change the `if` statement I have used. I would
+store validation conditions and error messages in a hash. I think setting the error message by selecting from a hash would make the code cleaner and easier to read. I have an idea
+of how I would like to implement this, but I would like to spend more time on it.
+
+I like to use a 'make it work, make it better, make it beautiful' approach when developing. I managed to get the gem working and defnitely improved upon my first attempt, but I would like
+to spend more time making the code cleaner and more beautiful.
+
+Overall I found the challenge really enjoyable. I am happy with it and learned a lot from it!
+
+

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/elambot_secure_password/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ElambotSecurePassword
+  VERSION = "0.1.0"
+end

data/lib/elambot_secure_password.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "elambot_secure_password/version"
+
+module ElambotSecurePassword
+  def self.generate_password(length = 10, options = {})
+    validate_options(options.merge(length: length))
+
+    special_length = options[:special] || 0
+    number_length = options[:number] || 0
+    remaining_length = length - special_length - number_length
+
+    characters = []
+    characters.concat(special_characters(special_length)) if special_length.positive?
+    characters.concat([*0..9].sample(number_length)) if number_length.positive?
+
+    if options[:uppercase] && options[:lowercase]
+      characters.concat([*"A".."Z", *"a".."z"].sample(remaining_length))
+    elsif options[:uppercase]
+      characters.concat([*"A".."Z"].sample(remaining_length))
+    else
+      characters.concat([*"a".."z"].sample(remaining_length))
+    end
+
+    characters.shuffle.join
+  end
+
+  def self.validate_options(options)
+    error_message = if options[:length] < 10
+                      "length option must be greater than 10"
+                    elsif options[:special] && !options[:special].is_a?(Integer)
+                      "special option must be a number"
+                    elsif options[:number] && !options[:number].is_a?(Integer)
+                      "number option must be a number"
+                    elsif options[:number] && options[:number] > options[:length]
+                      "number option must be less than or equal to length option"
+                    elsif options[:special] && options[:special] > options[:length]
+                      "special option must be less than or equal to length option"
+                    elsif options[:special] && options[:number] && (options[:special].to_i + options[:number].to_i) > options[:length]
+                      "special and number options combined must be less than or equal to length option"
+                    elsif options[:uppercase] && !options[:uppercase].is_a?(TrueClass) && !options[:uppercase].is_a?(FalseClass)
+                      "uppercase option must be a boolean"
+                    elsif options[:lowercase] && !options[:lowercase].is_a?(TrueClass) && !options[:lowercase].is_a?(FalseClass)
+                      "lowercase option must be a boolean"
+                    end
+    raise ArgumentError, error_message if error_message
+  end
+
+  def self.special_characters(length)
+    %w(! @ # $ % ^ & \( \) { } [ ] - _ < > ?).sample(length)
+  end
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: elambot_secure_password
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Baz86
+bindir: exe
+cert_chain: []
+date: 2025-03-20 00:00:00.000000000 Z
+dependencies: []
+email:
+- thomasebale@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- Rakefile
+- lib/elambot_secure_password.rb
+- lib/elambot_secure_password/version.rb
+homepage: https://github.com/Baz86/elambot_secure_password
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Baz86/elambot_secure_password
+  source_code_uri: https://github.com/Baz86/elambot_secure_password
+  changelog_uri: https://github.com/Baz86/elambot_secure_password/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A simple secure password generator gem
+test_files: []