wallet_passkit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ca6dbbeb4df4946ae410fadb3c040d8770e9a9ba1db838d90d151e805d98ab0
+  data.tar.gz: 83efa527ed456b51131a8a0bcc15c870bb618a4837bebbd2c4dde72cb089e32d
+SHA512:
+  metadata.gz: a436ab2fe7597f2740b58eb996090641ee66134b22d0bf64829928696a5bf76442dd8a22e90a701545f6a41ef36505347753b5d71a4db988c8601a74f3b9fa54
+  data.tar.gz: e6c5eb667e70f6e638e449b6c50bad4c22d1a8d60e2020d682d9066e780e89e6ace194076d174841848471a3cad61ff0d908d6413f1574b1bbfac908cfd52a90

data/README.md

@@ -0,0 +1,110 @@
+# wallet_passkit
+
+A modern Ruby gem to generate Apple Wallet passes (.pkpass) and integrate easily into Rails projects. Also includes Google Wallet helpers (Save link, object updates).
+
+[![CI](https://github.com/gioggi/wallet_passkit/actions/workflows/test.yml/badge.svg)](https://github.com/gioggi/wallet_passkit/actions/workflows/test.yml)
+
+Status: initial implementation for Apple + Google (Save link + updater).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wallet_passkit', path: '.' # or gem 'wallet_passkit', version: '0.1.0'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+## Configuration
+
+Global configuration in plain Ruby:
+
+```ruby
+require 'wallet_passkit'
+
+WalletPasskit.configure do |c|
+  c.apple_pass_certificate_p12_path = "/path/to/pass_certificate.p12"
+  c.apple_pass_certificate_password = ENV["APPLE_PASS_P12_PASSWORD"]
+  c.apple_wwdr_certificate_path     = "/path/to/AppleWWDRCAG3.pem" # download from Apple
+  c.apple_team_identifier           = "TEAMID1234"
+  c.apple_organization_name         = "My Org"
+
+  # Google Wallet (optional for Save link / updater)
+  c.google_service_account_credentials = "/path/to/service_account.json"
+  c.google_issuer_id   = "issuer-id" # optional
+  c.google_class_prefix = "com.example" # optional
+end
+```
+
+Rails (config/initializers/wallet_passkit.rb):
+
+```ruby
+Rails.application.config.wallet_passkit.apple_pass_certificate_p12_path = Rails.root.join('config', 'certs', 'pass_cert.p12').to_s
+Rails.application.config.wallet_passkit.apple_pass_certificate_password = ENV['APPLE_PASS_P12_PASSWORD']
+Rails.application.config.wallet_passkit.apple_wwdr_certificate_path     = Rails.root.join('config', 'certs', 'AppleWWDRCAG3.pem').to_s
+Rails.application.config.wallet_passkit.apple_team_identifier           = ENV['APPLE_TEAM_ID']
+Rails.application.config.wallet_passkit.apple_organization_name         = 'My Org'
+
+Rails.application.config.wallet_passkit.google_service_account_credentials = Rails.root.join('config', 'google', 'service_account.json').to_s
+```
+
+## Apple Wallet: Generate a .pkpass
+
+At minimum you need:
+- A pass type ID certificate (.p12) and password
+- Apple WWDR certificate (PEM)
+- A `pass.json` payload
+- Required images (icon.png; icon@2x.png recommended)
+
+Example in Rails controller action:
+
+```ruby
+payload = WalletPasskit::Apple::Service.build_pass_payload(
+  description: 'Loyalty Card',
+  pass_type_identifier: 'pass.com.example.loyalty',
+  serial_number: 'ABC123',
+  logo_text: 'My Store',
+  primary_fields: [ { key: 'points', label: 'Points', value: '100' } ],
+  background_color: 'rgb(255,0,0)',
+  foreground_color: 'rgb(255,255,255)'
+)
+
+assets = {
+  'icon.png' => File.binread(Rails.root.join('app/assets/images/pass/icon.png')),
+  'icon@2x.png' => File.binread(Rails.root.join('app/assets/images/pass/icon@2x.png')),
+  # add logo.png, strip.png, background.png as needed
+}
+
+pkpass_binary = WalletPasskit::Apple::Service.generate_pkpass(pass_payload: payload, assets: assets)
+
+send_data pkpass_binary, filename: 'loyalty.pkpass', type: 'application/vnd.apple.pkpass'
+```
+
+If you prefer to fully control pass.json, just pass your own hash to `generate_pkpass`.
+
+## Google Wallet
+
+For step-by-step setup (Issuer, API enablement, Service Account, LoyaltyClass) and usage examples (Save link and updates), see the dedicated guide:
+- https://github.com/gioggi/wallet_passkit/blob/main/lib/wallet_passkit/google/README.md
+
+This gem generates a Save to Google Wallet link (JWT) and provides a minimal updater for loyalty points.
+
+## Development
+
+- Run tests: `bundle exec rspec`
+- Lint: pending
+
+## Notes & Limitations
+
+- Apple requires asset files to be included and a correctly signed manifest. This gem signs with PKCS#7 (DER) using your pass certificate and Apple WWDR intermediate.
+- You must handle obtaining and managing certificates/keys securely.
+- For Google Wallet, this gem builds a Save link JWT and provides a minimal updater; for full class/object management, extend accordingly.
+
+## License
+
+MIT

data/lib/wallet_passkit/apple/service.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+require "digest/sha1"
+require "zip"
+
+module WalletPasskit
+  module Apple
+    class Service
+      def self.build_pass_payload(description:, pass_type_identifier:, serial_number:, logo_text:, primary_fields: [], secondary_fields: [], auxiliary_fields: [], back_fields: [], team_identifier: nil, organization_name: nil, pass_type: :storeCard, background_color: nil, label_color: nil, foreground_color: nil)
+        team_identifier ||= WalletPasskit.config.apple_team_identifier
+        organization_name ||= WalletPasskit.config.apple_organization_name
+
+        base = {
+          formatVersion: 1,
+          description: description,
+          organizationName: organization_name,
+          teamIdentifier: team_identifier,
+          passTypeIdentifier: pass_type_identifier,
+          serialNumber: serial_number,
+          logoText: logo_text
+        }
+
+        section_key = pass_type.to_sym == :storeCard ? :storeCard : :generic
+        section_payload = {}
+        section_payload[:primaryFields] = primary_fields if primary_fields && !primary_fields.empty?
+        section_payload[:secondaryFields] = secondary_fields if secondary_fields && !secondary_fields.empty?
+        section_payload[:auxiliaryFields] = auxiliary_fields if auxiliary_fields && !auxiliary_fields.empty?
+        section_payload[:backFields] = back_fields if back_fields && !back_fields.empty?
+
+        base[section_key] = section_payload unless section_payload.empty?
+
+        base[:backgroundColor] = background_color if background_color
+        base[:labelColor] = label_color if label_color
+        base[:foregroundColor] = foreground_color if foreground_color
+
+        base
+      end
+
+      def self.generate_pkpass(pass_payload:, assets: {})
+        p12_path = WalletPasskit.config.apple_pass_certificate_p12_path
+        p12_password = WalletPasskit.config.apple_pass_certificate_password
+        wwdr_path = WalletPasskit.config.apple_wwdr_certificate_path
+
+        raise WalletPasskit::Error, "Missing Apple certificate configuration" unless p12_path && p12_password && wwdr_path
+
+        files = { "pass.json" => JSON.pretty_generate(pass_payload) }
+        files.merge!(assets)
+
+        manifest = {}
+        files.each do |name, content|
+          manifest[name] = Digest::SHA1.hexdigest(content)
+        end
+        manifest_json = JSON.generate(manifest)
+
+        signature_der = WalletPasskit::Apple::Signer.sign(
+          data: manifest_json,
+          p12_path: p12_path,
+          p12_password: p12_password,
+          wwdr_path: wwdr_path
+        )
+
+        io = StringIO.new
+        Zip::OutputStream.write_buffer(io) do |zip|
+          files.each do |name, content|
+            zip.put_next_entry(name)
+            zip.write(content)
+          end
+
+          zip.put_next_entry("manifest.json")
+          zip.write(manifest_json)
+
+          zip.put_next_entry("signature")
+          zip.write(signature_der)
+        end
+        io.rewind
+        io.read
+      end
+    end
+  end
+end

data/lib/wallet_passkit/apple/signer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module WalletPasskit
+  module Apple
+    class Signer
+      def self.sign(data:, p12_path:, p12_password:, wwdr_path:)
+        p12 = OpenSSL::PKCS12.new(File.binread(p12_path), p12_password)
+        key = p12.key
+        cert = p12.certificate
+        wwdr = OpenSSL::X509::Certificate.new(File.read(wwdr_path))
+
+        store = OpenSSL::X509::Store.new
+        store.add_cert(wwdr) rescue nil
+
+        flags = OpenSSL::PKCS7::BINARY | OpenSSL::PKCS7::DETACHED
+        pkcs7 = OpenSSL::PKCS7.sign(cert, key, data, [wwdr], flags)
+        pkcs7.to_der
+      end
+    end
+  end
+end

data/lib/wallet_passkit/apple.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "apple/service"
+require_relative "apple/signer"

data/lib/wallet_passkit/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module WalletPasskit
+  # Global configuration container
+  class Configuration
+    # Apple Wallet certs configuration
+    attr_accessor :apple_pass_certificate_p12_path, :apple_pass_certificate_password,
+                  :apple_wwdr_certificate_path, :apple_team_identifier, :apple_organization_name
+
+    # Google Wallet configuration (service account credentials JSON path or hash)
+    attr_accessor :google_service_account_credentials, :google_issuer_id, :google_class_prefix
+
+    def initialize
+      @apple_pass_certificate_p12_path = nil
+      @apple_pass_certificate_password = nil
+      @apple_wwdr_certificate_path     = nil
+      @apple_team_identifier           = nil
+      @apple_organization_name         = nil
+
+      @google_service_account_credentials = nil # path or parsed hash
+      @google_issuer_id = nil
+      @google_class_prefix = nil
+    end
+  end
+end

data/lib/wallet_passkit/error.rb

@@ -0,0 +1,3 @@
+module WalletPasskit
+  class Error < StandardError; end
+end

data/lib/wallet_passkit/google/README.md

@@ -0,0 +1,136 @@
+# WalletPasskit – Google Wallet Guide
+
+Helpers to create Save to Google Wallet links and update Loyalty cards using Ruby.
+
+### What you can do
+- Generate a "Save to Google Wallet" link (JWT)
+- Customize brand colors, logo, hero image, and store locations
+- Assign a QR/barcode and dynamic loyalty points
+- Update points later via REST (PATCH)
+
+---
+
+## Prerequisites
+- A Google Wallet Issuer account for your business
+- A Google Cloud project with the Google Wallet API enabled
+- A Service Account with a JSON key file
+
+---
+
+## Step-by-step setup
+
+### 1) Request/Configure your Issuer
+- Open the Google Pay & Wallet Console: `https://pay.google.com/business/console`
+- Request an Issuer account if you do not have one yet and complete verification (business info, branding, domain if applicable)
+- Note your Issuer ID (a long numeric id, e.g. `3388000000000000000`)
+
+### 2) Enable the API in Google Cloud
+- Go to `https://console.cloud.google.com` and select or create a project
+- Enable "Google Wallet API" from the API Library
+
+### 3) Create a Service Account + key
+- In Google Cloud Console: IAM & Admin → Service Accounts → Create
+- Grant a role that can access Wallet Objects (Editor is sufficient for development)
+- Create a JSON key and download it
+- Store it in your app, e.g. `config/google/service_account.json`
+
+### 4) Grant the Service Account access to the Issuer
+- In the Google Pay & Wallet Console, add the service account email as a member/collaborator for your Issuer so it can create/update objects
+
+### 5) Create a LoyaltyClass
+Your passes (objects) must reference an existing LoyaltyClass.
+
+You can create it via the Console (if available) or via REST API. The class id format is:
+
+- `loyaltyClass.id = "<ISSUER_ID>.<CLASS_ID>"` (e.g., `3388000000000000000.keristo_loyalty`)
+
+Minimal LoyaltyClass via REST:
+
+```bash
+curl -X POST \
+  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "id": "3388000000000000000.keristo_loyalty",
+    "issuerName": "My Brand",
+    "programName": "Keristo Loyalty",
+    "reviewStatus": "underReview"
+  }' \
+  https://walletobjects.googleapis.com/walletobjects/v1/loyaltyClass
+```
+
+You can add branding fields later (logo, colors, etc.) directly on the class or customize per-object.
+
+---
+
+## Configuration in your app
+Add the service account path to your configuration. For Rails:
+
+```ruby
+Rails.application.config.wallet_passkit.google_service_account_credentials = \
+  Rails.root.join("config", "google", "service_account.json").to_s
+```
+
+---
+
+## Generate a Save to Google Wallet link
+Build your company and customer hashes, then create the URL.
+
+```ruby
+company = {
+  issuer_id: ENV["GOOGLE_ISSUER_ID"],      # e.g. "3388000000000000000"
+  class_id:  "keristo_loyalty",           # your LoyaltyClass suffix
+  background_color: "#112233",            # optional
+  font_color: "#FFFFFF",                  # optional
+  logo_uri: "https://example.com/logo.png",        # optional
+  hero_image_uri: "https://example.com/hero.png",  # optional
+  locations: [ { latitude: 45.4642, longitude: 9.1900 } ] # optional
+}
+
+customer = {
+  id: "customer-123",
+  first_name: "Mario",
+  last_name: "Rossi",
+  points: 120,
+  qr_value: "UUID-1234" # or use :barcode_value and optional :barcode_type
+}
+
+url = WalletPasskit::Google::Pass.new(
+  company: company,
+  customer: customer,
+  service_account_path: Rails.application.config.wallet_passkit.google_service_account_credentials
+).save_url
+# Redirect the user to `url`, or render it as a link/button
+```
+
+What the gem generates
+- A JWT with `payload.loyaltyObjects[0]` that includes your colors, images, locations, and the customer’s points/barcode
+- The Save URL: `https://pay.google.com/gp/v/save/<JWT>`
+
+---
+
+## Update points later (PATCH)
+Use the object id format: `<ISSUER_ID>.<CUSTOMER_ID>`.
+
+```ruby
+object_id = "#{company[:issuer_id]}.#{customer[:id]}"
+
+WalletPasskit::Google::PassUpdater.new(
+  object_id: object_id,
+  service_account_path: Rails.application.config.wallet_passkit.google_service_account_credentials
+).update_points(new_point_value: 480)
+```
+
+---
+
+## Troubleshooting
+- 401/403 errors: ensure the Service Account is added to your Issuer in the Wallet Console and the API is enabled
+- Not found: verify the LoyaltyClass exists and your object references `classId = "<ISSUER_ID>.<CLASS_ID>"`
+- Branding not visible: check whether you set colors/images on the class vs object; some UI elements derive from the class
+
+---
+
+## Useful links
+- Developer site: `https://developers.google.com/wallet`
+- Loyalty cards API reference: `https://developers.google.com/wallet/retail/loyalty-cards`
+

data/lib/wallet_passkit/google/auth.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "googleauth"
+
+module WalletPasskit
+  module Google
+    module Auth
+      def self.access_token(service_account_path:)
+        credentials = ::Google::Auth::ServiceAccountCredentials.make_creds(
+          json_key_io: File.open(service_account_path),
+          scope: ["https://www.googleapis.com/auth/wallet_object.issuer"]
+        )
+        credentials.fetch_access_token!
+        credentials.access_token
+      end
+    end
+  end
+end

data/lib/wallet_passkit/google/pass.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require "googleauth"
+require "jwt"
+require "net/http"
+require "uri"
+require "json"
+
+module WalletPasskit
+  module Google
+    class Pass
+      def initialize(company:, customer:, service_account_path:)
+        @company = company.transform_keys(&:to_sym)
+        @customer = customer.transform_keys(&:to_sym)
+        @service_account_path = service_account_path
+      end
+
+      def save_url
+        # For save URL, we need a simplified object structure
+        # The full object structure is only for API calls
+        save_object = {
+          id: "#{issuer_id}.#{@customer[:id]}",
+          classId: "#{issuer_id}.#{@company[:class_id]}",
+          state: "active",
+          accountId: @customer[:id],
+          accountName: "#{@customer[:first_name]} #{@customer[:last_name]}",
+          loyaltyPoints: {
+            label: "Punti",
+            balance: {
+              int: @customer[:points] || 0
+            }
+          }
+        }
+
+        # Add optional fields for save URL
+        if @company[:background_color]
+          save_object[:hexBackgroundColor] = @company[:background_color]
+        end
+
+        if @company[:font_color]
+          save_object[:hexFontColor] = @company[:font_color]
+        end
+
+        # Add barcode for save URL
+        if @customer[:qr_value]
+          save_object[:barcode] = {
+            type: "QR_CODE",
+            value: @customer[:qr_value]
+          }
+        elsif @customer[:barcode_value]
+          save_object[:barcode] = {
+            type: (@customer[:barcode_type] || "QR_CODE"),
+            value: @customer[:barcode_value]
+          }
+        end
+
+        payload = {
+          iss: service_account_email,
+          aud: "google",
+          typ: "savetowallet",
+          payload: {
+            loyaltyObjects: [save_object]
+          }
+        }
+
+        jwt = JWT.encode(payload, private_key, "RS256", kid: key_id)
+        "https://pay.google.com/gp/v/save/#{jwt}"
+      end
+
+      # Creates a loyalty object in Google Wallet using the API
+      def create_loyalty_object
+        loyalty_object_data = build_loyalty_object
+        
+        uri = URI("https://walletobjects.googleapis.com/walletobjects/v1/loyaltyObject")
+        req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
+        req["Authorization"] = "Bearer #{access_token}"
+        req.body = loyalty_object_data.to_json
+
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+
+        if res.is_a?(Net::HTTPSuccess)
+          created_object = JSON.parse(res.body)
+          puts "✅ Loyalty object created successfully!"
+          puts "   ID: #{created_object['id']}"
+          puts "   State: #{created_object['state']}"
+          created_object
+        else
+          error_message = "Failed to create loyalty object: #{res.code} #{res.message}"
+          if res.body
+            error_data = JSON.parse(res.body) rescue nil
+            if error_data && error_data['error']
+              error_message += " - #{error_data['error']['message']}"
+            end
+          end
+          raise WalletPasskit::Error, error_message
+        end
+      end
+
+      # Creates loyalty object and returns the save URL
+      def create_and_save_url
+        create_loyalty_object
+        save_url
+      end
+
+      private
+
+      def access_token
+        WalletPasskit::Google::Auth.access_token(service_account_path: @service_account_path)
+      end
+
+      def service_account_email
+        JSON.parse(File.read(@service_account_path))["client_email"]
+      end
+
+      def issuer_id
+        @company[:issuer_id]
+      end
+
+      def key_id
+        JSON.parse(File.read(@service_account_path))["private_key_id"]
+      end
+
+      def private_key
+        OpenSSL::PKey::RSA.new(
+          JSON.parse(File.read(@service_account_path))["private_key"]
+        )
+      end
+
+      def build_loyalty_object
+        object = {
+          id: "#{issuer_id}.#{@customer[:id]}",
+          classId: "#{issuer_id}.#{@company[:class_id]}",
+          state: "active",
+          accountId: @customer[:id],
+          accountName: "#{@customer[:first_name]} #{@customer[:last_name]}",
+          loyaltyPoints: {
+            label: "Punti",
+            balance: {
+              int: @customer[:points] || 0
+            }
+          }
+        }
+
+        if @company[:background_color]
+          object[:hexBackgroundColor] = @company[:background_color]
+        end
+
+        if @company[:font_color]
+          object[:hexFontColor] = @company[:font_color]
+        end
+
+        image_modules = []
+        if @company[:logo_uri]
+          image_modules << {
+            mainImage: {
+              sourceUri: { uri: @company[:logo_uri] }
+            }
+          }
+        end
+        if @company[:hero_image_uri]
+          image_modules << {
+            mainImage: {
+              sourceUri: { uri: @company[:hero_image_uri] }
+            }
+          }
+        end
+        object[:imageModulesData] = image_modules unless image_modules.empty?
+
+        # Note: merchantLocations requires special authorization from Google
+        # For now, we'll skip locations to avoid API errors
+        # if @company[:locations].is_a?(Array)
+        #   object[:merchantLocations] = @company[:locations].map do |loc|
+        #     {
+        #       latitude: loc[:latitude] || loc["latitude"],
+        #       longitude: loc[:longitude] || loc["longitude"]
+        #     }
+        #   end
+        # end
+
+        if @customer[:qr_value]
+          object[:barcode] = {
+            type: "QR_CODE",
+            value: @customer[:qr_value]
+          }
+        elsif @customer[:barcode_value]
+          object[:barcode] = {
+            type: (@customer[:barcode_type] || "QR_CODE"),
+            value: @customer[:barcode_value]
+          }
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/wallet_passkit/google/pass_updater.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module WalletPasskit
+  module Google
+    class PassUpdater
+      def initialize(object_id:, service_account_path:)
+        @object_id = object_id
+        @service_account_path = service_account_path
+      end
+
+      def update_points(new_point_value:)
+        patch({ loyaltyPoints: { balance: { int: new_point_value }}})
+      end
+
+      # Recupera un oggetto loyalty specifico dal Google Wallet
+      def retrieve_object
+        uri = URI("https://walletobjects.googleapis.com/walletobjects/v1/loyaltyObject/#{@object_id}")
+        req = Net::HTTP::Get.new(uri)
+        req["Authorization"] = "Bearer #{access_token}"
+
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+
+        raise WalletPasskit::Error, "Errore API: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
+        JSON.parse(res.body)
+      end
+
+      # Metodo pubblico per recuperare l'oggetto
+      def get_object
+        retrieve_object
+      end
+
+      # Metodi per ottenere informazioni specifiche dell'oggetto
+      def get_points
+        object = retrieve_object
+        object.dig('loyaltyPoints', 'balance', 'int') || 0
+      end
+
+      def get_state
+        object = retrieve_object
+        object['state']
+      end
+
+      def get_account_name
+        object = retrieve_object
+        object['accountName']
+      end
+
+      def get_account_id
+        object = retrieve_object
+        object['accountId']
+      end
+
+      def get_creation_time
+        object = retrieve_object
+        object['createTime']
+      end
+
+      def get_update_time
+        object = retrieve_object
+        object['updateTime']
+      end
+
+      # Metodo di classe per recuperare un oggetto senza creare un'istanza
+      def self.retrieve_object(object_id:, service_account_path:)
+        new(object_id: object_id, service_account_path: service_account_path).get_object
+      end
+
+      private
+
+      def patch(data)
+        uri = URI("https://walletobjects.googleapis.com/walletobjects/v1/loyaltyObject/#{@object_id}")
+        req = Net::HTTP::Patch.new(uri, "Content-Type" => "application/json")
+        req["Authorization"] = "Bearer #{access_token}"
+        req.body = data.to_json
+
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+
+        raise WalletPasskit::Error, "Errore API: #{res.body}" unless res.is_a?(Net::HTTPSuccess)
+        JSON.parse(res.body)
+      end
+
+      def access_token
+        WalletPasskit::Google::Auth.access_token(service_account_path: @service_account_path)
+      end
+    end
+  end
+end

data/lib/wallet_passkit/google.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "google/pass"
+require_relative "google/pass_updater"
+require_relative "google/auth"

data/lib/wallet_passkit/railtie.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+begin
+  require 'rails'
+rescue LoadError
+end
+
+module WalletPasskit
+  if defined?(Rails)
+    class Railtie < ::Rails::Railtie
+      # Allow configuration via Rails.application.config.wallet_passkit
+      config.wallet_passkit = ActiveSupport::OrderedOptions.new
+
+      initializer 'wallet_passkit.configure' do |app|
+        cfg = app.config.wallet_passkit
+        WalletPasskit.configure do |c|
+          c.apple_pass_certificate_p12_path = cfg.apple_pass_certificate_p12_path if cfg.key?(:apple_pass_certificate_p12_path)
+          c.apple_pass_certificate_password = cfg.apple_pass_certificate_password if cfg.key?(:apple_pass_certificate_password)
+          c.apple_wwdr_certificate_path     = cfg.apple_wwdr_certificate_path if cfg.key?(:apple_wwdr_certificate_path)
+          c.apple_team_identifier           = cfg.apple_team_identifier if cfg.key?(:apple_team_identifier)
+          c.apple_organization_name         = cfg.apple_organization_name if cfg.key?(:apple_organization_name)
+
+          c.google_service_account_credentials = cfg.google_service_account_credentials if cfg.key?(:google_service_account_credentials)
+          c.google_issuer_id   = cfg.google_issuer_id if cfg.key?(:google_issuer_id)
+          c.google_class_prefix = cfg.google_class_prefix if cfg.key?(:google_class_prefix)
+        end
+      end
+    end
+  end
+end

data/lib/wallet_passkit/version.rb

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

data/lib/wallet_passkit.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "json"
+require "digest/sha1"
+require "zip"
+
+require_relative "wallet_passkit/version"
+require_relative "wallet_passkit/configuration"
+require_relative "wallet_passkit/google"
+require_relative "wallet_passkit/apple"
+require_relative "wallet_passkit/railtie"
+require_relative "wallet_passkit/error"
+
+module WalletPasskit
+
+  class Error < StandardError; end
+
+  def self.configure
+    yield(config)
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: wallet_passkit
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gioggi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A modern, lightweight Ruby gem for generating Apple Wallet passes (.pkpass)
+  with OpenSSL signing, easy Rails integration services, and a minimal Google Wallet
+  Save link generator.
+email:
+- info@giovanniesposito.it
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/wallet_passkit.rb
+- lib/wallet_passkit/apple.rb
+- lib/wallet_passkit/apple/service.rb
+- lib/wallet_passkit/apple/signer.rb
+- lib/wallet_passkit/configuration.rb
+- lib/wallet_passkit/error.rb
+- lib/wallet_passkit/google.rb
+- lib/wallet_passkit/google/README.md
+- lib/wallet_passkit/google/auth.rb
+- lib/wallet_passkit/google/pass.rb
+- lib/wallet_passkit/google/pass_updater.rb
+- lib/wallet_passkit/railtie.rb
+- lib/wallet_passkit/version.rb
+homepage: https://example.com/wallet_passkit
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Generate Apple Wallet .pkpass and integrate with Rails; scaffold for Google
+  Wallet
+test_files: []