Homegrown #Scala Collections - Part 1 - Credit Card Generator & Validator

Introduction

In today's video, we’ll embark on an exciting journey to create our own tiny collections library using Scala. Before diving into that, however, we will build a small project that showcases the capabilities of a well-structured library. Our task is to write a command-line tool capable of validating credit card numbers and generating valid ones as a byproduct. Let’s get started!

Project Setup

We'll be using an Ubuntu virtual machine with Sublime Text as our IDE and a terminal open side by side. We have a standard project structure with directories for our source code and a main Scala file. The build file specifies the version, organization, and Scala version.

1. Naming the Project: We rename our folder to "credit_card" to reflect the new project.
2. Main Object: We have a standard main method ready for use.

After starting the SBT (Scala Build Tool), we’ll create a new file named CreditCard.scala. Here, we will define our main abstraction.

Designing the Credit Card Abstraction

We’ll start by declaring a sealed trait CreditCard, which includes a number represented as a string. The companion object for CreditCard includes two implementations: Invalid and Valid.

sealed trait CreditCard (
  def number: String
)

object CreditCard (
  final case class Invalid(number: String) extends CreditCard
  final case class Valid(number: String) extends CreditCard
)

To facilitate validation checks, we will add convenience methods:

• isValid: to check if the credit card is valid,
• isNotValid: to check if it is not valid.

Next, we will implement the apply method in the companion object to validate the card number on creation.

Implementing Credit Card Validation

To validate a credit card, we define an isValid function that returns a boolean, initially set to return false. The constructor for Invalid and Valid cases will be made private to restrict direct instantiation.

The plan is that users will create credit cards using the apply method:

def apply(number: String): CreditCard = (
  if (isValid(number)) {
    Valid(number)
  ) else (
    Invalid(number)
  )
}

The isValid function should implement the Luhn algorithm, which checks whether a provided number is a valid credit card number.

The Luhn Algorithm

The Luhn algorithm operates by validating the sum of the digits in the credit card number, factoring in the check digit. Here’s a simplified breakdown:

1. Reverse the numbers.
2. Zip the digits with their indices.
3. Double every second digit.
4. If doubling results in a number greater than 9, subtract 9.
5. Calculate the sum.
6. Check if the total modulo 10 is 0.

Credit Card Number Generation

We’ll also implement a function to generate valid credit card numbers. This function will generate a random payload, apply the Luhn algorithm to generate a valid check digit, and return a complete valid credit card number.

Demonstration in Main

In the main method, we will allow users to pass an argument when running the application to validate a specific credit card number. If no argument is provided, the program will demonstrate how the credit card validator works with both valid and invalid numbers.

The console output will clearly indicate whether the provided credit card number is valid, invalid, or if the demo is being run.

Extending the Functionality

As a bonus, we encourage you to enhance the credit card generator to create a range of numbers by retrieving them from a website with valid credit card numbers. This way, you can check against real credit card data.

Conclusion

The project at hand demonstrates the power of Scala's collections library in creating a clean, reusable API for credit card validation and generation. We’ve encapsulated the logic required for validation and provided a structure to create valid credit card numbers. In the next video, we will explore testing this functionality automatically.

Keywords

• Scala
• Collections
• Credit Card
• Validation
• Generation
• Luhn Algorithm
• Command-Line Tool
• Functional Programming

FAQ

Q1: What is the purpose of the credit card application?
A1: The application is designed to validate credit card numbers and generate valid ones using Scala.

Q2: What is the Luhn algorithm?
A2: The Luhn algorithm is a checksum formula used to validate a variety of identification numbers, including credit card numbers.

Q3: How can I run the application?
A3: You can run the application from the command line, optionally passing a credit card number as an argument for validation.

Q4: Can I generate multiple credit card numbers?
A4: Yes, the application allows for the generation of multiple valid credit card numbers with a simple command in the main method.

Q5: Where can I find the code for this project?
A5: The complete code will be uploaded to GitHub for you to explore and test at your convenience.