appilix_notifications 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecd11d1e6132cec8349f2c25b8591e1ccec77398b2f06887a8d43efe4a9b2739
-  data.tar.gz: a5ef42effd83291505bd3942932a1408997b6510755881b57ff68b074e58a7c6
+  metadata.gz: 993a291ad2f0f97f3de0cd8a6d6f86fcf1e059db62ad03a541bfdf20c2c2f7b5
+  data.tar.gz: acfc393b5e518aa54d0b1242bb002f2e3446157a82dffcc5e950e780c79d7b1d
 SHA512:
-  metadata.gz: d7c18ee6d91200d0ec0e3f50921a80a91e34ee07919e63253bbfb061c55e4a5f37718c9944965b293992356fcadcc88bd733b1419a0ad65b85c079cc4f10db8b
-  data.tar.gz: 83bab8a4dd6b2799f5be4d6dc969ac49b61c1b72ca823603c9f28d837b2c06798e1eb875fa2233f3123b8d3107180288f7c3ca52aacf74c8d755a85a05887237
+  metadata.gz: 2f5d6d6a14ddcd7de2f784bd962b3544f0b0eb2da99c9ee58fa87d36d340c0c539b9e8579d6554ac37f64936a41f8ce0eb23959fb2eafc20da92d70b089d7638
+  data.tar.gz: 5fd69e72ab797f26954440566cac881a4014f68723cc65e7c0dbcf8b62babd27778d3ab9564b0f76e5460b5a18be5b382e5e815aab225baecf9de8fef412618a

data/.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - master
+
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Ruby ${{ matrix.ruby }}
+    strategy:
+      matrix:
+        ruby:
+          - '3.3.3'
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run the default task
+        run: bundle exec rake

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-01-20
+
+- Initial release

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in appilix_notifications.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "test-unit", "~> 3.0"
+
+gem "standard", "~> 1.3"
+
+gem 'rspec'

data/Gemfile.lock

@@ -0,0 +1,91 @@
+PATH
+  remote: .
+  specs:
+    appilix_notifications (0.1.1)
+      json (~> 2.0)
+      net-http (>= 0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.1)
+    json (2.9.1)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    net-http (0.10.0)
+      net-protocol (>= 0.3.0)
+      uri (>= 0.11.1)
+    net-protocol (0.4.0)
+      timeout
+    parallel (1.26.3)
+    parser (3.3.7.0)
+      ast (~> 2.4.1)
+      racc
+    power_assert (2.0.5)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    regexp_parser (2.10.0)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.2)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.2)
+    rubocop (1.70.0)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.36.2, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.37.0)
+      parser (>= 3.3.1.0)
+    rubocop-performance (1.23.1)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+    ruby-progressbar (1.13.0)
+    standard (1.44.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.70.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.6)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.6.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.23.0)
+    test-unit (3.6.7)
+      power_assert
+    timeout (0.6.1)
+    unicode-display_width (3.1.4)
+      unicode-emoji (~> 4.0, >= 4.0.4)
+    unicode-emoji (4.0.4)
+    uri (1.1.2)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  appilix_notifications!
+  rake (~> 13.0)
+  rspec
+  standard (~> 1.3)
+  test-unit (~> 3.0)
+
+BUNDLED WITH
+   2.6.2

data/README.md

@@ -0,0 +1,151 @@
+# AppilixNotifications
+
+`AppilixNotifications` is a Ruby gem crafted to streamline the process of sending push notifications and retrieving registered user tokens via the Appilix API. It offers a user-friendly interface to dispatch notifications with customizable parameters such as title, body, user identity, and links, as well as to fetch notification tokens for registered users. This gem leverages the capabilities of Appilix, a platform that enables the transformation of any website into a mobile application without requiring any coding. Developed by Alzahidi-tech, this gem ensures efficient notification management.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'appilix_notifications'
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+## Usage
+
+### Sending a Notification
+
+To send a notification, use the `appilix_send_notifications` method:
+
+```ruby
+require 'appilix_notifications'
+
+response = AppilixNotifications.appilix_send_notifications(
+  'your_app_key',
+  'your_api_key',
+  'Your Notification Title',
+  'Your Notification Body',
+  'optional_user_identity', # Optional; use "user-1::user-2" for multiple users
+  'https://example.com',    # Optional
+  notification_image: 'https://example.com/banner.png', # Optional; Android only
+  secondary_app_key: 'your_ios_app_key',                # Optional
+  secondary_api_key: 'your_ios_api_key'                 # Optional
+)
+
+puts response
+```
+#### Parameters for Sending Notifications
+
+- `app_key` (String): Your application's key from Appilix.
+- `api_key` (String): Your API key from Appilix.
+- `title` (String): The title of the notification.
+- `body` (String): The body content of the notification.
+- `user_identity` (String, optional): The user identifier for the notification.
+- `open_link_url` (String, optional): A URL to open when the notification is clicked.
+- `notification_image` (String, optional keyword): A public image URL (Android only).
+- `secondary_app_key` (String, optional keyword): The app key for a second app, such as iOS.
+- `secondary_api_key` (String, optional keyword): The API key for the second app.
+
+Notifications are submitted as a `POST` form request to the current Appilix push notification endpoint.
+
+
+On success, the method returns a parsed JSON response:
+
+```json
+{
+  "status": "success",
+  "message": "Notification sent successfully"
+}
+```
+
+On failure, the method returns an error hash:
+
+```json
+{
+  "error": "Invalid API key",
+  "code": "401",
+  "body": "The provided API key is incorrect."
+}
+```
+
+If the server response contains invalid JSON, you will receive:
+
+```json
+{
+  "error": "Invalid JSON response",
+  "body": "<Raw response body>"
+}
+```
+
+
+### Fetching Registered User Tokens
+
+To fetch registered user tokens, use the `appilix_get_registered_user` method:
+
+```ruby
+require 'appilix_notifications'
+
+response = AppilixNotifications.appilix_get_registered_user(
+  'your_app_key',
+  'your_api_key',
+  1, # Optional page number; defaults to 1
+  user_identity: 'optional_user_identity',
+  items_per_page: 50,
+  secondary_app_key: 'your_ios_app_key',
+  secondary_api_key: 'your_ios_api_key'
+)
+
+puts response
+```
+
+#### Parameters for Fetching Registered User Tokens
+
+- `app_key` (String): Your application's key from Appilix.
+- `api_key` (String): Your API key from Appilix.
+- `page` (Integer, optional): The page number, defaulting to `1`.
+- `user_identity` (String, optional keyword): Return tokens for a specific user.
+- `items_per_page` (Integer, optional keyword): Results per page, defaulting to `100`.
+- `secondary_app_key` (String, optional keyword): The app key for a second app.
+- `secondary_api_key` (String, optional keyword): The API key for the second app.
+
+
+On success, the method returns a parsed JSON response containing the tokens:
+
+```json
+{
+  "status": true,
+  "current_page": 1,
+  "has_next_page": false,
+  "tokens": [
+    {
+      "token": "fcm-device-token-string",
+      "user_identity": "user@example.com",
+      "modified_at": "2026-05-22 10:30:00"
+    }
+  ]
+}
+```
+
+On failure, the method returns an error hash:
+
+```json
+{
+  "error": "Invalid API key",
+  "code": "401",
+  "body": "The provided API key is incorrect."
+}
+```
+
+If the server response contains invalid JSON, you will receive:
+
+```json
+{
+  "error": "Invalid JSON response",
+  "body": "<Raw response body>"
+}
+```

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "standard/rake"
+
+task default: %i[test standard]

data/appilix_notifications.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+#require_relative "lib/appilix_notifications/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "appilix_notifications"
+  #spec.version = AppilixNotifications::VERSION
+  spec.version = "0.1.2"
+  spec.authors = ["RoaaAlqaisi"]
+  spec.email = ["rowaalqaisi@gmail.com"]
+  spec.license = "NGPL"
+
+  spec.summary = "A Ruby gem to send notifications using the appilix API."
+  spec.description = "appilixNotifications is a Ruby gem that simplifies sending push notifications to users of your application via the appilix API. It includes functionality to fetch registered users and send notifications with customizable titles, bodies, and optional user-specific or link-specific parameters."
+  spec.homepage = "https://github.com/RoaaAlqaisi/appilix_notifications"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/RoaaAlqaisi/appilix_notifications"
+  spec.metadata["changelog_uri"] = "https://github.com/RoaaAlqaisi/appilix_notifications/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 = `git ls-files -z`.split("\x0")
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Add dependencies for your gem
+  spec.add_dependency "json", "~> 2.0"
+  spec.add_dependency "net-http", ">= 0.1.1"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "appilix_notifications"
+
+# 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.
+
+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/lib/appilix_notifications/version.rb

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

data/lib/appilix_notifications.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "appilix_notifications/version"
+
+require "net/http"
+require "uri"
+require "json"
+
+module AppilixNotifications
+  BASE_URL = "https://appilix.com/api"
+  PUSH_NOTIFICATION_URL = "push-notification"
+  TOKEN_LIST_URL = "push-notification-token"
+
+  module_function
+
+  def appilix_send_notifications(app_key, api_key, title, body, user_identity = nil, open_link_url = nil,
+    notification_image: nil, secondary_app_key: nil, secondary_api_key: nil)
+    uri = URI("#{BASE_URL}/#{PUSH_NOTIFICATION_URL}")
+    form_data = compact_parameters(
+      "app_key" => app_key,
+      "api_key" => api_key,
+      "notification_title" => title,
+      "notification_body" => body,
+      "user_identity" => user_identity,
+      "open_link_url" => open_link_url,
+      "notification_image" => notification_image,
+      "secondary_app_key" => secondary_app_key,
+      "secondary_api_key" => secondary_api_key
+    )
+
+    request = Net::HTTP::Post.new(uri)
+    request.set_form_data(form_data)
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(request)
+    end
+
+    handle_response(response)
+  end
+
+  def appilix_get_registered_user(app_key, api_key, page = 1, user_identity: nil, items_per_page: 100,
+    secondary_app_key: nil, secondary_api_key: nil)
+    uri = URI("#{BASE_URL}/#{TOKEN_LIST_URL}")
+    uri.query = URI.encode_www_form(compact_parameters(
+      "app_key" => app_key,
+      "api_key" => api_key,
+      "page" => page,
+      "items_per_page" => items_per_page,
+      "user_identity" => user_identity,
+      "secondary_app_key" => secondary_app_key,
+      "secondary_api_key" => secondary_api_key
+    ))
+
+    request = Net::HTTP::Get.new(uri)
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(request)
+    end
+
+    handle_response(response)
+  end
+
+  def handle_response(response)
+    case response
+    when Net::HTTPSuccess
+      JSON.parse(response.body)
+    else
+      {"error" => response.message, "code" => response.code, "body" => parse_body_safe(response.body)}
+    end
+  rescue JSON::ParserError
+    {"error" => "Invalid JSON response", "body" => response.body}
+  end
+
+  def parse_body_safe(body)
+    JSON.parse(body)
+  rescue JSON::ParserError
+    body
+  end
+
+  def compact_parameters(parameters)
+    parameters.reject { |_key, value| value.nil? }
+  end
+end

data/sig/appilix_notifications.rbs

@@ -0,0 +1,4 @@
+module AppilixNotifications
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/appilix_notifications_spec.rb

@@ -0,0 +1,69 @@
+require_relative "../lib/appilix_notifications"
+
+RSpec.describe AppilixNotifications do
+  let(:app_key) { "key1" }
+  let(:api_key) { "apikey1" }
+  let(:http) { instance_double(Net::HTTP) }
+
+  before { allow(Net::HTTP).to receive(:start).and_yield(http) }
+
+  def successful_response(body)
+    response = Net::HTTPOK.new("1.1", "200", "OK")
+    allow(response).to receive(:body).and_return(JSON.generate(body))
+    response
+  end
+
+  it "sends a notification using a POST form request" do
+    allow(http).to receive(:request).and_return(successful_response("status" => true))
+
+    response = described_class.appilix_send_notifications(
+      app_key, api_key, "Hello", "Notification body", "user@example.com", "https://example.com",
+      notification_image: "https://example.com/image.png",
+      secondary_app_key: "ios-key", secondary_api_key: "ios-api-key"
+    )
+
+    expect(response).to eq("status" => true)
+    expect(http).to have_received(:request) do |request|
+      expect(request).to be_a(Net::HTTP::Post)
+      expect(request.uri.to_s).to eq("https://appilix.com/api/push-notification")
+      expect(URI.decode_www_form(request.body).to_h).to eq(
+        "app_key" => app_key, "api_key" => api_key,
+        "notification_title" => "Hello", "notification_body" => "Notification body",
+        "user_identity" => "user@example.com", "open_link_url" => "https://example.com",
+        "notification_image" => "https://example.com/image.png",
+        "secondary_app_key" => "ios-key", "secondary_api_key" => "ios-api-key"
+      )
+    end
+  end
+
+  it "fetches FCM tokens from the current endpoint with documented parameters" do
+    body = {"status" => true, "current_page" => 2, "has_next_page" => false, "tokens" => []}
+    allow(http).to receive(:request).and_return(successful_response(body))
+
+    response = described_class.appilix_get_registered_user(
+      app_key, api_key, 2, user_identity: "user@example.com", items_per_page: 50,
+      secondary_app_key: "ios-key", secondary_api_key: "ios-api-key"
+    )
+
+    expect(response).to eq(body)
+    expect(http).to have_received(:request) do |request|
+      expect(request).to be_a(Net::HTTP::Get)
+      expect(request.uri.path).to eq("/api/push-notification-token")
+      expect(URI.decode_www_form(request.uri.query).to_h).to eq(
+        "app_key" => app_key, "api_key" => api_key, "page" => "2", "items_per_page" => "50",
+        "user_identity" => "user@example.com", "secondary_app_key" => "ios-key",
+        "secondary_api_key" => "ios-api-key"
+      )
+    end
+  end
+
+  it "uses the API pagination defaults when token options are omitted" do
+    allow(http).to receive(:request).and_return(successful_response("status" => true, "tokens" => []))
+
+    described_class.appilix_get_registered_user(app_key, api_key)
+
+    expect(http).to have_received(:request) do |request|
+      expect(URI.decode_www_form(request.uri.query).to_h).to include("page" => "1", "items_per_page" => "100")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  # https://rspec.info/features/3-12/rspec-core/configuration/zero-monkey-patching-mode/
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/test/appilix_notifications_test.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class AppilixNotificationsTest < Test::Unit::TestCase
+  test "VERSION" do
+    assert do
+      ::AppilixNotifications.const_defined?(:VERSION)
+    end
+  end
+
+  test "something useful" do
+    assert_equal("expected", "actual")
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "appilix_notifications"
+
+require "test-unit"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: appilix_notifications
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - RoaaAlqaisi
 bindir: exe
 cert_chain: []
-date: 2025-01-23 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -46,7 +46,27 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- appilix_notifications-0.1.0.gem
+- appilix_notifications.gemspec
+- bin/console
+- bin/setup
+- lib/appilix_notifications.rb
+- lib/appilix_notifications/version.rb
+- sig/appilix_notifications.rbs
+- spec/appilix_notifications_spec.rb
+- spec/spec_helper.rb
+- test/appilix_notifications_test.rb
+- test/test_helper.rb
 homepage: https://github.com/RoaaAlqaisi/appilix_notifications
 licenses:
 - NGPL
@@ -69,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A Ruby gem to send notifications using the appilix API.
 test_files: []