joy_ussd_engine 0.1.0

data/README.md

@@ -0,0 +1,559 @@
+# JoyUssdEngine
+
+A ruby library for building text based applications rapidly. It supports building whatsapp, ussd, telegram and various text or chat applications that communicate with your rails backend. With this library you can target multiple platforms(whatsapp, ussd, telegram, etc.) at once with just one codebase.
+
+## Table of Contents
+
+- [JoyUssdEngine](#joyussdengine)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+  - [Usage](#usage)
+    - [Bootstrap the App](#bootstrap-the-app)
+    - [Generators](#generators)
+    - [DataTransformer](#datatransformer)
+      - [Methods](#methods)
+      - [Example](#example)
+    - [Menu](#menu)
+      - [Menu Properties](#menu-properties)
+      - [Lifecycle Methods](#lifecycle-methods)
+      - [Render Methods](#render-methods)
+      - [Other Methods](#other-methods)
+      - [Create a menu](#create-a-menu)
+      - [Execution Order of Lifecycle Methods](#execution-order-of-lifecycle-methods)
+      - [Execution Order Diagram](#execution-order-diagram)
+      - [Get Http Post Data](#get-http-post-data)
+      - [Saving and Accessing Data](#saving-and-accessing-data)
+      - [Error Handling](#error-handling)
+    - [Routing Menus](#routing-menus)
+    - [PaginateMenu](#paginatemenu)
+      - [PaginateMenu Properties](#paginatemenu-properties)
+      - [PaginateMenu Methods](#paginatemenu-methods)
+      - [PaginateMenu Example](#paginatemenu-example)
+  - [Development](#development)
+  - [Contributing](#contributing)
+  - [License](#license)
+  - [Code of Conduct](#code-of-conduct)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'joy_ussd_engine'
+```
+
+And then execute:
+
+    bundle install
+
+Or install it yourself as:
+
+    gem install joy_ussd_engine
+
+## Usage
+
+The ussd engine handles user session and stores user data with redis. So in your `Gemfile` you will have to add the `redis` and the `redis-namespace` gem.
+
+```ruby
+gem 'redis'
+gem 'redis-namespace'
+
+# Not required but you can add connection pool for redis if you want
+gem 'connection_pool', '~> 2.2', '>= 2.2.2'
+```
+
+After installing redis you will need to setup the redis config in your rails application inside `config/initializers/redis.rb`
+
+```ruby
+# With Connection Pool
+require 'connection_pool'
+NAMESPACE = :DEFAULT_NAMESPACE
+REDIS = ConnectionPool.new(size: 10) { Redis::Namespace.new(NAMESPACE, :redis => Redis.new) }
+```
+
+```ruby
+# Without Connection Pool
+NAMESPACE = :DEFAULT_NAMESPACE
+REDIS = Redis::Namespace.new(NAMESPACE, :redis => Redis.new)
+```
+
+### Bootstrap the App
+
+In your rails app inside a controller create a post route and initialize the `JoyUssdEngine` by calling `JoyUssdEngine::Core.new` and providing some parameters. [Click here](#params) to view all the required parameters list.
+
+```ruby
+class MyController < ApplicationController
+  skip_before_action :verify_authenticity_token
+
+  def create
+    joy_ussd_engine = JoyUssdEngine::Core.new(ussd_params, Transformers::HubtelTransformer, start_point: Ussd::Menus::StartMenu, end_point: Ussd::Menus::EndMenu)
+    response = joy_ussd_engine.process
+    render json: response, status: :created
+  end
+
+  def ussd_params
+    params.permit(:SessionId, :Mobile, :ServiceCode, :Type, :Message, :Operator, :Sequence, :ClientState)
+  end
+end
+```
+
+The `JoyUssdEngine::Core.new` class takes the following parameters.<a id="params"></a>
+
+| Parameter                        | Type  | Description                                                                                                                          |
+| -------------------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| params                           | hash  | Params coming from a post end point in a rails controller                                                                            |
+| [data_transformer](#transformer) | class | A class to transform the incoming and outgoing request between a particular provider and `JoyUssdEngine`                             |
+| [start_point](#menu)             | class | Points to a menu that starts the application. This menu is the first menu that loads when the app starts                             |
+| [end_point](#menu)               | class | This menu will terminate the ussd session if a particular provider (`data_transformer`) returns true in the `app_terminator` method. |
+
+### Generators
+
+The rails terminal is very powerful and we can utilize it to generate menus easily.
+
+- Generate a Menu - `rails g joy_menu <Menu_Name>`
+- Generate a PaginateMenu - `rails g joy_paginate_menu <Menu_Name>`
+- Generate a Routing Menu - `rails g joy_route_menu <Menu_Name>`
+- Generate a DataTransformer - `rails g joy_data_transformer <Transformer_Name>`
+
+### DataTransformer
+
+A data transformer transforms the incoming request and outgoing response between a particular provider and the `JoyUssdEngine` so they can effectively communicate between each other. The `JoyUssdEngine` can accept any request object but there are two required fields that needs to be present for it to work properly. The required fields are `session_id` and `message`. This is why the `DataTransformer` is needed to convert the request so it can provide this two required fields (`session_id`, `message`).
+
+#### Methods
+
+| Method         | Parameters                                 | Return Value  | Description                                                                                                                                                                                             |
+| -------------- | ------------------------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| request_params | params: [hash]()                           | [hash]()      | Converts the incoming request into a format the ussd engine can understand. The hash is the params coming from the post request in a rails controller that calls `JoyUssdEngine::Core.new`.             |
+| response       | message: [string](), app_state: [string]() | [hash]()      | Converts the outgoing response coming from the ussd engine into a format the provider can understand. `(eg of providers: Whatsapp, Twilio, Hubtel, Telegram, etc.)`                                     |
+| release        | message: [string]()                        | [hash]()      | Converts the outgoing response coming from the ussd engine into a format the provider can understand and then terminates the application. `(eg of providers: Whatsapp, Twilio, Hubtel, Telegram, etc.)` |
+| app_terminator | params: [hash]()                           | [boolean]()   | Returns a true/false on whether to terminate the app when a particular condition is met based on the provider in use. `(eg of providers: Whatsapp, Twilio, Hubtel, Telegram, etc.)`                     |
+| expiration     | none                                       | [Date/Time]() | Sets the time for which to end the user's session if there is no response from the user. **Default value is 60 seconds**                                                                                |
+
+#### Example
+
+When using `hubtel` we need to convert the `hubtel` request into what the `JoyUssdEngine` expects with the `request_params` method. Also we need to convert the response back from `JoyUssdEngine` to `hubtel` with the `response` and `release` methods. With this approach we can easily extend the `JoyUssdEngine` to target multiple providers like (Twilio, Telegram, etc) with ease. The `app_terminator` returns a boolean and terminates the app when a particular condition is met(For example: On whatsapp the user sends a message with text `end` to terminate the app)
+
+```ruby
+class HubtelTransformer < JoyUssdEngine::DataTransformer
+    # Transforms request payload between hubtel and our application
+    # The session_id and message fields are required so we get them from hubtel (session_id: params[:Mobile] and message: params[:Message]).
+    # And we pass in other hubtel specific params like (ClientState: params[:ClientState], Type: params[:Type])
+    def request_params(params)
+        {
+            session_id: params[:Mobile],
+            message: params[:Message],
+            ClientState: params[:ClientState],
+            Type: params[:Type]
+        }
+    end
+
+    # We check if hubtel sends a params[:Type] == 'Release' and terminate the application
+    # OR
+    # the hubtel params[:Type] is not a string with value "Initiation" and state data is blank (@context.get_state.blank?)
+    def app_terminator(params)
+        params[:Type] == 'Release' || (params[:Type] != "Initiation" && @context.get_state.blank?)
+    end
+
+    # Transforms response payload back to the format hubtel accepts by setting the message field (Type: "Response",Message: message, ClientState: client_state)
+    def response(message, client_state)
+        {
+            Type: "Response",
+            Message: message,
+            ClientState: client_state
+        }
+    end
+
+
+    # Transforms response payload back to the format hubtel accepts by setting the message field (Type: "Response",Message: message, ClientState: client_state) and then end the user session
+    def release(message)
+        {
+            Type: "Release",
+            Message: message,
+            ClientState: "End"
+        }
+    end
+
+
+    # Time for which the session has to end if the user does not send a request.
+    def expiration
+        60.seconds
+    end
+end
+```
+
+### Menu
+
+Menus are simply the views for our application. They contain the code for rendering the text and menus that display on the user's device. Also they contain the business logic for your app.
+
+#### Menu Properties
+
+| Properties   | Type                                           | Description                                                                                                                             |
+| ------------ | ---------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| context      | object                                         | Provides methods for setting and getting state values                                                                                   |
+| field_name\* | string                                         | The name for a particular input field. This name can be used to later retrieve the value the user entered in that field. (**Required**) |
+| menu_text\*  | string                                         | The text to display to the user. (**Required**)                                                                                         |
+| error_text   | string                                         | If there is an error you will have to set the error message here. (**Optional**)                                                        |
+| skip_save    | boolean                                        | If set to true the user input will not be saved. **Default: false** (**Optional**)                                                      |
+| menu_items   | array <{title: '', menu: JoyUssdEngine::Menu}> | Stores an array of menu items.                                                                                                          |
+| field_error  | boolean                                        | If set to true it will route back to the menu the error was caught in for the user to input the correct values.                         |
+
+#### Lifecycle Methods
+
+| Methods       | Description                                                                                                                                              |
+| ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| before_render | Do all data processing and business logic here.                                                                                                          |
+| render        | Render the ussd menu here. This is for only rendering out the response. (Only these methods `joy_release`, `joy_response`, `load_menu` can be used here) |
+| after_render  | After rendering out the ussd menu you can put any additional logic here.                                                                                 |
+| on_validate   | Validate user input here.                                                                                                                                |
+| on_error      | This method will be called when the `field_error` value is set to true. You can change the error message and render it to the user here.                 |
+
+#### Render Methods
+
+| Methods      | Parameters | Description                                                                                                                                                     |
+| ------------ | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| joy_response | Menu       | This method takes a single argument (which is a class that points to the next menu) and is used to render out a menu to the user.                               |
+| joy_release  | none       | This method renders a text to the user and ends the users session                                                                                               |
+| load_menu    | Menu       | This method takes a single argument (which is a class that points to the next menu) and is used with the Routing and Paginating Menus to render out menu items. |
+
+#### Other Methods
+
+| Methods           | Description                                                            |
+| ----------------- | ---------------------------------------------------------------------- |
+| show_menu         | Returns a list of menus stored in the `menu_items` variable            |
+| get_selected_item | Gets the selected menu from the `menu_items` array                     |
+| raise_error       | Takes an error message as an arguments and ends the user session       |
+| has_selected?     | Checks if the user has selected an item in from the `menu_items` array |
+
+#### Create a menu
+
+```ruby
+class Menus::MainMenu < JoyUssdEngine::Menu
+    def on_validate
+        # use this method to validate the user's input
+
+        # use @context.get_state with the @field_name value set in the before_render method to get the user inputs
+        if @context.get_state[:request] != "john doe"
+            # in case of errors set the @field_error value to true and set an error message in @error_text
+            @field_error = true
+            @error_text = "Wrong Value enter the correct value"
+        end
+    end
+
+    def before_render
+        # Implement before call backs
+
+        # store the input name for this ussd menu in the @field_name variable
+        @field_name = "request"
+
+        # store the text to show or render out in the ussd menu with the @menu_text variable
+        @menu_text = "Type you name"
+    end
+
+    def on_error
+        # this method will be executed if @field_error is set to true
+
+        # catch errors and display the errors in the ussd menu by setting the @menu_text to include the error_message from @error_text
+        @menu_text = "#{@error_text}\n#{@menu_text}"
+    end
+
+    def after_render
+        # Implement after call backs
+    end
+
+    def render
+        # Render ussd menu here
+
+        # the joy_response renders out the ussd menu and takes the class of the next menu to route to as an argument.
+        joy_response(Menus::NextMenu)
+    end
+end
+```
+
+This will be rendered out to the user when this menu is executed for the first time.
+
+![Menu1](./images/menu_doc1.png)
+
+When the user enters a value which is not the string `"john doe"` an error will be displayed like we see in the screenshot below.
+
+![Menu2](./images/menu_doc2.png)
+
+#### Execution Order of Lifecycle Methods
+
+- before_render
+  ***
+  This is the first method that gets executed. It is used for querying the db and handling the business logic of our application. This method also is used to set the text (`menu_text`) to be rendered and the input name (`field_name`) for the current menu.
+- on_validate
+
+  ***
+
+  This method will be executed when the user submits a response. We use this method to validate the user's input and set an error_message to display when there is an error. Normally we will set `field_error` value to true and store the error message in `error_text`. Then we can later access the error_message in the `on_error` lifecycle method and append the error to `menu_text` so it will be rendered out to the user.
+
+- on_error
+
+  ***
+
+  This is the next method that gets executed and it is used to set error messages. It will only be executed if the `field_error` value is set to true.
+
+- render
+
+  ***
+
+  This method is used for rendering out the menu by using the text stored in the `menu_text` variable. There are only three methods that should be used in the render method. Which are [joy_release](#render_methods), [joy_response](#render_methods), and [load_menu](render_methods).
+
+- after_render
+  ***
+  Use this method to do any other business logic after the menu has been rendered out and awaiting user response.
+
+#### Execution Order Diagram
+
+The Diagram below shows how these methods are executed
+
+![Lifecycle Diagram](images/lifecycle.jpg)
+
+#### Get Http Post Data
+
+We can access the post request data coming from the rails controller in any menu with the `context` object. The `context` object can be used to access data by reading values from the `params` hash of a post request. This hash consist of the `session_id`, `message` and any other additional data returned by the `request_params` method in the [DataTransformer](#transformer) class.
+
+```ruby
+# Just call @context.params[key] to access a particular value coming from a post request made available to our app through the DataTransformer.request_params method.
+
+@context.params[:message] # Gets the message the user enters from the post end point.
+```
+
+#### Saving and Accessing Data
+
+We can save and access data in any menu with the `context` object. The `context` object has two methods `set_state` and `get_state` which are used for saving and retrieving data. The saved data will be destroyed once the user session ends or is expired and it is advisable to persist this data into a permanent storage like a database if you will need it after the user session has ended.
+
+```ruby
+# Just call @context.set_state(key: value) to set a key with a particular value
+@context.set_state(selected_book: selected_book)
+
+# To access the values @context.get_state[:key]
+@context.get_state[:selected_book]
+```
+
+Also by default any menu that has the `field_name` variable set. Will automatically save the users input with a key matching the string stored in the `field_name` variable.
+
+**Note:** However if the `skip_save` variable is set to true the user input will not be store for that particular menu. By default this value is false.
+
+```ruby
+# This stores the name of the input field for this menu
+@field_name = "user_email"
+
+# @skip_save = true -  user input will not be saved
+
+# We can now get the user's input any where in our application with @context.get_state.
+@context.get_state[:user_email]
+```
+
+#### Error Handling
+
+We can throw an error with a message and terminate the user session any where in our application by returning the `raise_error(error_message)` method and passing an error_message as an argument into the function.
+
+```ruby
+# We raise an error in our application
+return raise_error("Sorry something went wrong!")
+```
+
+There is also another way to handle errors without ending or terminating the user session. We can use the `on_validate` lifecycle method to validate user input and when there is an error we set the `field_error` variable to true and the `error_text` variable to include the error message.
+
+Then in the `on_error` lifecycle method we can append the `error_text` variable to the `menu_text` variable so it displays on the screen for the user.
+
+**Note:** The `on_error` method will only be invoke if the `field_error` variable is set to true.
+
+[View the example code on error handling here](#create_menu)
+
+### Routing Menus
+
+You can show a list of menu items with their corresponding routes. When the user selects any item it will automatically route to the selected menu.
+When the user selects a menu that is not in the list an error is displayed to the user and the user session wil be terminated.
+
+```ruby
+class Menus::InitialMenu < JoyUssdEngine::Menu
+
+    def before_render
+        # Implement before call backs
+        @field_name='initiation'
+        @skip_save = true
+
+        # Store a list of menu items with their routes
+        @menu_items = [
+            {title: 'Make Payments', route: Menus::MakePayments},
+            {title: 'View Transaction', route: Menus::ViewTransaction}
+        ]
+
+        # Show menu items on screen with the show_menu method.
+        # The show_menu takes an optional parameter which is used to display the title of the page.
+        @menu_text = show_menu('Welcome to JoyUssdEngine')
+    end
+
+    def render
+        # Render ussd menu here
+
+        # Use this to load the menu the user selects
+        # get_selected_item automatically listens to user inputs and passes the selected menu into load_menu method
+        load_menu(get_selected_item)
+    end
+end
+```
+
+This will be rendered out when this menu is executed
+
+![MenuRoutes](./images/menu_items_routes.png)
+
+If the `Menus::ViewTransaction` has a structure like this.
+
+```ruby
+class Menus::ViewTransaction < JoyUssdEngine::Menu
+
+    def before_render
+        # Implement before call backs
+
+        @menu_text = "Transactions. \n1. ERN_CODE_SSD\n2. ERN_DESA_DAS\nThanks for using our services."
+    end
+
+    def render
+        # Render ussd menu here
+        joy_release
+    end
+end
+```
+
+When the user enters 2 in the `Menus::InitialMenu` menu then the following will be rendered and the user session will be terminated.
+
+![transaction](./images/transactions_menu.png)
+
+The `Menus::ViewTransaction` menu uses the `joy_release` method to render out the text stored in the `@menu_text` variable and ends the user session.
+
+### PaginateMenu
+
+A `PaginateMenu` handles pagination automatically for you. You can store an array of items that you want to paginate and they will be paginated automatically.
+A `PaginateMenu` has all the properties and methods in a `Menu` in addition to the following properties.
+
+#### PaginateMenu Properties
+
+A `PaginateMenu` has the following properties in addition properties in [Menu](#menu).
+
+| Properties       | Type        | Description                                                               |
+| ---------------- | ----------- | ------------------------------------------------------------------------- |
+| paginating_items | array <any> | Stores an array of items to paginate on a particular menu.                |
+| items_per_page   | integer     | The number of items to show per page. **Default: 5**                      |
+| back_key         | string      | A string holding the input value for navigating back. **Default: '0'**    |
+| next_key         | string      | A string holding the input value for navigating forward. **Default: '#'** |
+
+#### PaginateMenu Methods
+
+| Methods           | Description                                                                                      |
+| ----------------- | ------------------------------------------------------------------------------------------------ |
+| paginate          | Returns a list of paginated items based on the page the user is currently on.                    |
+| show_menu         | Takes a list of paginated items and a page title as a parameter and renders it out on the screen |
+| get_selected_item | Returns the selected item                                                                        |
+| has_selected?     | Returns true if the user has selected an item                                                    |
+
+#### PaginateMenu Example
+
+```ruby
+ class Menus::Books < JoyUssdEngine::PaginateMenu
+
+        def before_render
+            # Implement before call backs
+
+            # set an array of items that are going to be paginated
+            @paginating_items = [
+                {title: "Data Structures", item: {id: 1}},
+                {title: "Excel Programming", item: {id: 2}},
+                {title: "Economics", item: {id: 3}},
+                {title: "Big Bang", item: {id: 4}},
+                {title: "Democracy Building", item: {id: 5}},
+                {title: "Python for Data Scientist", item: {id: 6}},
+                {title: "Money Mind", item: {id: 7}},
+                {title: "Design Patterns In C#", item: {id: 8}}
+            ]
+
+            # The paginate methods returns a list of paginated list for the current page when it is called
+            paginated_list = paginate
+
+            # In a PaginateMenu the show_menu take a list a two optional named parameter values (title,key).
+
+            # The title shows the page title for the menu.
+
+            # The key stores the key of the hash which contains the text to be rendered on each list item.
+
+            # If the key is not set the paginating_items is treated as a string and rendered to the user.
+            # eg: @paginating_items = ["Data Structures","Excel Programming","Economics","Big Bang","Democracy Building","Python for Data Scientist","Money Mind","Design Patterns In C#"]
+
+            @menu_text = show_menu(paginated_list, title: 'My Books', key: 'title')
+
+            # In other to select a paginating item we have to wrap the selection logic in an if has_selected? block to prevent some weird errors.
+            if has_selected?
+                # the get_selected_item is used to get the selected item from the paginating menu
+                selected_book = get_selected_item
+
+                # We save the selected book so we can access later
+                @context.set_state(selected_book: selected_book)
+            end
+        end
+
+        def render
+            # Render ussd menu here
+
+            # The load_menu function points to a menu to load when a book is selected.
+            load_menu(Menus::ShowBook)
+        end
+    end
+```
+
+To use a `PaginateMenu` we have to store the items to be paginated in the `paginating_items` variable. Then we call the `paginate` method and store the result in a variable. We can now pass the variable into the `show_menu` method and specify a `title` for the page if we have any. The `show_menu` method can also accept a `key` which is used to get the key containing the string to be rendered in a paginating_item. If the `key` is left blank the `paginating_items` are treated as strings and rendered automatically.
+
+In order to get the item the user selected we have to wrap the selection login in an `if has_selected?` block to prevent some weird errors, then we can access the selected item with the `get_selected_item` method.
+
+The following screenshots shows the paginating menu when it's first rendered.
+
+![paginate_menu1](./images/paginate_menu1.png)
+
+When the user enters '#' we move to the next page in the list.
+
+![paginate_menu2](./images/paginate_menu2.png)
+
+In the next menu (`Menus::ShowBook`) we have code that looks like this.
+
+```ruby
+class Menus::ShowBook < Ussd::Menu
+    def before_render
+        # Implement before call backs
+        book = @context.get_state[:selected_book]
+        @menu_text = "The selected book is \nid: #{book[:item][:id]}\nname: #{book[:title]}"
+    end
+
+    def after_render
+        # Implement after call backs
+    end
+
+    def render
+        # Render ussd menu here
+        joy_release
+    end
+end
+```
+
+When th user selects an item in the `PaginateMenu` we get the users selection with `@context.get_state[:selected_book]` and display the selected item back to the user and end the session.
+
+![paginate_item_select](images/paginate_item_selected.png)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/Caleb-Mantey/joy_ussd_engine>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/Caleb-Mantey/joy_ussd_engine/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the JoyUssdEngine project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Caleb-Mantey/joy_ussd_engine/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "joy_ussd_engine"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/joy_ussd_engine.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/joy_ussd_engine/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "joy_ussd_engine"
+  spec.version       = JoyUssdEngine::VERSION
+  spec.authors       = ["Caleb Mantey"]
+  spec.email         = ["manteycaleb@gmail.com"]
+
+  spec.summary       = "A gem for building ussd and text based applications rapidly."
+  spec.description   = "A ruby library for building text based applications rapidly. It supports building whatsapp, ussd, telegram and various text or chat applications that communicate with your rails backend. With this library you can target multiple platforms(whatsapp, ussd, telegram, etc.) at once with just one codebase."
+  spec.homepage      = "https://github.com/Caleb-Mantey/joy_ussd_engine"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.4.0"
+
+  # spec.metadata["allowed_push_host"] = "'https://rubygems.org'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Caleb-Mantey/joy_ussd_engine"
+  spec.metadata["changelog_uri"] = "https://github.com/Caleb-Mantey/joy_ussd_engine/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "will_paginate", "~> 3.3.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/generators/joy_data_transformer/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Will generate a DataTransformer class for transforming the incoming post request and outgoing response.
+
+Example:
+    bin/rails generate joy_data_transformer Hubtel
+
+    This will create:
+        app/services/ussd/transformers/hubtel_transformer.rb