mega-pure-kit 0.0.1

data/stripe-19.3.0/lib/stripe/v2_list_object.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    class ListObject < StripeObject
+      OBJECT_NAME = "list"
+      def self.object_name
+        "list"
+      end
+
+      # An empty list object. This is returned from +fetch_next_page+ when we know that
+      # there isn't a next page.
+      def self.empty_list(opts = {})
+        ListObject.construct_from({ data: [] }, opts, nil, :v2)
+      end
+
+      def [](key)
+        case key
+        when String, Symbol
+          super
+        else
+          raise ArgumentError,
+                "You tried to access the #{key.inspect} index, but ListObject " \
+                "types only support String keys. (HINT: List calls return an " \
+                "object with a 'data' (which is the data array). You likely " \
+                "want to call #data[#{key.inspect}])"
+        end
+      end
+
+      # Iterates through each resource in the page represented by the current
+      # `ListObject`.
+      #
+      # Note that this method makes no effort to fetch a new page when it gets to
+      # the end of the current page's resources. See also +auto_paging_each+.
+      def each(&blk)
+        data.each(&blk)
+      end
+
+      # Iterates through each resource in the page represented by the current
+      # `ListObject` in reverse.
+      def reverse_each(&blk)
+        data.reverse_each(&blk)
+      end
+
+      # Iterates through each resource in all pages, making additional fetches to
+      # the API as necessary.
+      #
+      # Note that this method will make as many API calls as necessary to fetch
+      # all resources. For more granular control, please see +each+ and
+      # +fetch_next_page+.
+      def auto_paging_each(&blk)
+        return enum_for(:auto_paging_each) unless block_given?
+
+        page = self
+        loop do
+          page.each(&blk)
+
+          break if page.next_page_url.nil?
+
+          page = page.fetch_next_page
+        end
+      end
+
+      # Returns true if the page object contains no elements.
+      def empty?
+        data.empty?
+      end
+
+      # Fetches the next page in the resource list (if there is one).
+      #
+      # This method will try to respect the limit of the current page. If none
+      # was given, the default limit will be fetched again.
+      def fetch_next_page(opts = {})
+        return self.class.empty_list(opts) if next_page_url.nil?
+
+        _request(
+          method: :get,
+          path: next_page_url,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe/version.rb

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

data/stripe-19.3.0/lib/stripe/webhook.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Stripe
+  module Webhook
+    DEFAULT_TOLERANCE = 300
+
+    # Initializes an Event object from a JSON payload.
+    #
+    # This may raise JSON::ParserError if the payload is not valid JSON, or
+    # SignatureVerificationError if the signature verification fails.
+    def self.construct_event(payload, sig_header, secret,
+                             tolerance: DEFAULT_TOLERANCE)
+      Signature.verify_header(payload, sig_header, secret, tolerance: tolerance)
+
+      # It's a good idea to parse the payload only after verifying it. We use
+      # `symbolize_names` so it would otherwise be technically possible to
+      # flood a target's memory if they were on an older version of Ruby that
+      # doesn't GC symbols. It also decreases the likelihood that we receive a
+      # bad payload that fails to parse and throws an exception.
+      data = JSON.parse(payload, symbolize_names: true)
+
+      if data[:object] == "v2.core.event"
+        raise ArgumentError,
+              "You passed an event notification to Webhook.construct_event, which expects " \
+              "a webhook payload. Use StripeClient#parse_event_notification instead."
+      end
+
+      Event.construct_from(data, {}, nil, :v1, APIRequestor.active_requestor)
+    end
+
+    module Signature
+      EXPECTED_SCHEME = "v1"
+
+      # Computes a webhook signature given a time (probably the current time),
+      # a payload, and a signing secret.
+      def self.compute_signature(timestamp, payload, secret)
+        raise ArgumentError, "timestamp should be an instance of Time" \
+          unless timestamp.is_a?(Time)
+        raise ArgumentError, "payload should be a string" \
+          unless payload.is_a?(String)
+        raise ArgumentError, "secret should be a string" \
+          unless secret.is_a?(String)
+
+        timestamped_payload = "#{timestamp.to_i}.#{payload}"
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new("sha256"), secret,
+                                timestamped_payload)
+      end
+
+      # Generates a value that would be added to a `Stripe-Signature` for a
+      # given webhook payload.
+      #
+      # Note that this isn't needed to verify webhooks in any way, and is
+      # mainly here for use in test cases (those that are both within this
+      # project and without).
+      def self.generate_header(timestamp, signature, scheme: EXPECTED_SCHEME)
+        raise ArgumentError, "timestamp should be an instance of Time" \
+          unless timestamp.is_a?(Time)
+        raise ArgumentError, "signature should be a string" \
+          unless signature.is_a?(String)
+        raise ArgumentError, "scheme should be a string" \
+          unless scheme.is_a?(String)
+
+        "t=#{timestamp.to_i},#{scheme}=#{signature}"
+      end
+
+      # Extracts the timestamp and the signature(s) with the desired scheme
+      # from the header
+      def self.get_timestamp_and_signatures(header, scheme)
+        list_items = header.split(/,\s*/).map { |i| i.split("=", 2) }
+        timestamp = Integer(list_items.select { |i| i[0] == "t" }[0][1])
+        signatures = list_items.select { |i| i[0] == scheme }.map { |i| i[1] }
+        [Time.at(timestamp), signatures]
+      end
+      private_class_method :get_timestamp_and_signatures
+
+      # Verifies the signature header for a given payload.
+      #
+      # Raises a SignatureVerificationError in the following cases:
+      # - the header does not match the expected format
+      # - no signatures found with the expected scheme
+      # - no signatures matching the expected signature
+      # - a tolerance is provided and the timestamp is not within the
+      #   tolerance
+      #
+      # Returns true otherwise
+      def self.verify_header(payload, header, secret, tolerance: nil)
+        begin
+          timestamp, signatures =
+            get_timestamp_and_signatures(header, EXPECTED_SCHEME)
+
+        # TODO: Try to knock over this blanket rescue as it can unintentionally
+        # swallow many valid errors. Instead, try to validate an incoming
+        # header one piece at a time, and error with a known exception class if
+        # any part is found to be invalid. Rescue that class here.
+        rescue StandardError
+          raise SignatureVerificationError.new(
+            "Unable to extract timestamp and signatures from header",
+            header, http_body: payload
+          )
+        end
+
+        if signatures.empty?
+          raise SignatureVerificationError.new(
+            "No signatures found with expected scheme #{EXPECTED_SCHEME}",
+            header, http_body: payload
+          )
+        end
+
+        expected_sig = compute_signature(timestamp, payload, secret)
+        unless signatures.any? { |s| Util.secure_compare(expected_sig, s) }
+          raise SignatureVerificationError.new(
+            "No signatures found matching the expected signature for payload",
+            header, http_body: payload
+          )
+        end
+
+        if tolerance && timestamp < Time.now - tolerance
+          formatted_timestamp = Time.at(timestamp).strftime("%F %T")
+          raise SignatureVerificationError.new(
+            "Timestamp outside the tolerance zone (#{formatted_timestamp})",
+            header, http_body: payload
+          )
+        end
+
+        true
+      end
+    end
+  end
+end

data/stripe-19.3.0/lib/stripe.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+# Stripe Ruby bindings
+# API spec at https://stripe.com/docs/api
+require "cgi/escape"
+require "json"
+require "logger"
+require "net/http"
+require "openssl"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "socket"
+require "uri"
+require "forwardable"
+
+# Version
+require "stripe/api_version"
+require "stripe/version"
+
+# API operations
+require "stripe/api_operations/create"
+require "stripe/api_operations/delete"
+require "stripe/api_operations/list"
+require "stripe/api_operations/nested_resource"
+require "stripe/api_operations/request"
+require "stripe/api_operations/save"
+require "stripe/api_operations/singleton_save"
+require "stripe/api_operations/search"
+
+# API resource support classes
+require "stripe/errors"
+require "stripe/object_types"
+require "stripe/event_types"
+require "stripe/request_options"
+require "stripe/request_params"
+require "stripe/stripe_context"
+require "stripe/util"
+require "stripe/connection_manager"
+require "stripe/multipart_encoder"
+require "stripe/api_requestor"
+require "stripe/stripe_service"
+require "stripe/stripe_client"
+require "stripe/stripe_object"
+require "stripe/stripe_response"
+require "stripe/list_object"
+require "stripe/v2_list_object"
+require "stripe/search_result_object"
+require "stripe/error_object"
+require "stripe/api_resource"
+require "stripe/api_resource_test_helpers"
+require "stripe/singleton_api_resource"
+require "stripe/webhook"
+require "stripe/stripe_configuration"
+
+# Named API resources — autoloaded on first use to reduce boot time.
+# Call Stripe.eager_load! to load everything upfront (recommended
+# before forking in production). In Rails, this happens automatically
+# when config.eager_load is true.
+require "stripe/resources"
+require "stripe/services"
+require "stripe/params"
+
+# OAuth
+require "stripe/oauth"
+require "stripe/services/oauth_service"
+
+# Rails integration — registers Stripe in config.eager_load_namespaces
+# so Stripe.eager_load! is called automatically when config.eager_load is true.
+require "stripe/railtie" if defined?(Rails::Railtie)
+
+module Stripe
+  DEFAULT_CA_BUNDLE_PATH = __dir__ + "/data/ca-certificates.crt"
+
+  # map to the same values as the standard library's logger
+  LEVEL_DEBUG = Logger::DEBUG
+  LEVEL_ERROR = Logger::ERROR
+  LEVEL_INFO = Logger::INFO
+
+  # API base constants
+  DEFAULT_API_BASE = "https://api.stripe.com"
+  DEFAULT_CONNECT_BASE = "https://connect.stripe.com"
+  DEFAULT_UPLOAD_BASE = "https://files.stripe.com"
+  DEFAULT_METER_EVENTS_BASE = "https://meter-events.stripe.com"
+
+  # Options that can be configured globally by users
+  USER_CONFIGURABLE_GLOBAL_OPTIONS = Set.new(%i[
+    api_key
+    api_version
+    stripe_account
+    api_base
+    uploads_base
+    connect_base
+    meter_events_base
+    open_timeout
+    read_timeout
+    write_timeout
+    proxy
+    verify_ssl_certs
+    ca_bundle_path
+    log_level
+    logger
+    max_network_retries
+    enable_telemetry
+    client_id
+  ])
+
+  @app_info = nil
+
+  @config = Stripe::StripeConfiguration.setup
+
+  class << self
+    extend Forwardable
+
+    attr_reader :config
+
+    # User configurable options
+    def_delegators :@config, :api_key, :api_key=
+    def_delegators :@config, :api_version, :api_version=
+    def_delegators :@config, :stripe_account, :stripe_account=
+    def_delegators :@config, :api_base, :api_base=
+    def_delegators :@config, :uploads_base, :uploads_base=
+    def_delegators :@config, :connect_base, :connect_base=
+    def_delegators :@config, :meter_events_base, :meter_events_base=
+    def_delegators :@config, :open_timeout, :open_timeout=
+    def_delegators :@config, :read_timeout, :read_timeout=
+    def_delegators :@config, :write_timeout, :write_timeout=
+    def_delegators :@config, :proxy, :proxy=
+    def_delegators :@config, :verify_ssl_certs, :verify_ssl_certs=
+    def_delegators :@config, :ca_bundle_path, :ca_bundle_path=
+    def_delegators :@config, :log_level, :log_level=
+    def_delegators :@config, :logger, :logger=
+    def_delegators :@config, :max_network_retries, :max_network_retries=
+    def_delegators :@config, :enable_telemetry=, :enable_telemetry?
+    def_delegators :@config, :client_id=, :client_id
+
+    # Internal configurations
+    def_delegators :@config, :max_network_retry_delay
+    def_delegators :@config, :initial_network_retry_delay
+    def_delegators :@config, :ca_store
+  end
+
+  # Eagerly loads all autoloaded Stripe constants (resources, services,
+  # params) using the same file list and load order as previous versions
+  # of this gem that used eager require.
+  #
+  # Call this before forking in production (Puma, Unicorn, etc.) to
+  # avoid autoload in multi-threaded request handling. In Rails apps
+  # this is called automatically when config.eager_load is true.
+  #
+  #   # Non-Rails production / pre-fork hook:
+  #   Stripe.eager_load!
+  #
+  def self.eager_load!
+    (RESOURCE_FILES + SERVICE_FILES + PARAM_FILES).each do |path|
+      require path
+    end
+  end
+
+  # Gets the application for a plugin that's identified some. See
+  # #set_app_info.
+  def self.app_info
+    @app_info
+  end
+
+  def self.app_info=(info)
+    @app_info = info
+  end
+
+  # Sets some basic information about the running application that's sent along
+  # with API requests. Useful for plugin authors to identify their plugin when
+  # communicating with Stripe.
+  #
+  # Takes a name and optional partner program ID, plugin URL, and version.
+  def self.set_app_info(name, partner_id: nil, url: nil, version: nil)
+    @app_info = {
+      name: name,
+      partner_id: partner_id,
+      url: url,
+      version: version,
+    }
+  end
+end
+
+Stripe.log_level = ENV["STRIPE_LOG"] unless ENV["STRIPE_LOG"].nil?

data/stripe-19.3.0/rbi/stripe/resources/v2/core/event_notification.rbi

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# typed: true
+
+module Stripe
+  module V2
+    module Core
+      class EventReasonRequest
+        sig { returns(String) }
+        def id; end
+        sig { returns(String) }
+        def idempotency_key; end
+
+        sig { params(event_reason_request_payload: T::Hash[T.untyped, T.untyped]).void }
+        def initialize(event_reason_request_payload = {}); end
+      end
+
+      class EventReason
+        sig { returns(String) }
+        def type; end
+        sig { returns(::Stripe::V2::Core::EventReasonRequest) }
+        def request; end
+
+        sig { params(event_reason_payload: T::Hash[T.untyped, T.untyped]).void }
+        def initialize(event_reason_payload = {}); end
+      end
+
+      class EventNotification
+        sig { returns(String) }
+        def id; end
+        sig { returns(String) }
+        def type; end
+        sig { returns(String) }
+        def created; end
+        sig { returns(T.nilable(String)) }
+        def context; end
+        sig { returns(T::Boolean) }
+        def livemode; end
+        sig { returns(T.nilable(::Stripe::V2::Core::EventReason)) }
+        def reason; end
+      end
+    end
+  end
+end

data/stripe-19.3.0/rbi/stripe/stripe_client.rbi

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# typed: true
+
+module Stripe
+  class StripeClient
+    sig do
+      params(
+        payload: String,
+        sig_header: String,
+        secret: String,
+        tolerance: T.nilable(Integer)
+      )
+        .returns(::Stripe::V2::Core::EventNotification)
+    end
+    def parse_event_notification(payload, sig_header, secret, tolerance:); end
+  end
+end