increase 0.3.2 → 1.0.0

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.standard.yml

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

data/Gemfile

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in increase.gemspec
-gemspec

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2023 Gary Tou
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/OPENAPI_VERSION

@@ -1 +0,0 @@
-v0.0.1

data/Rakefile

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-require "standard/rake"
-
-task default: %i[spec standard]

data/bin/generate

@@ -1,152 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# OpenAPI client generators for Ruby seem to be a bit of a mess. I'm
-# essentially writing my own crude generator here. It's not perfect, but it
-# gets the job done :)
-
-require 'bundler/setup'
-require 'irb'
-
-require 'json'
-require 'erb'
-require 'ostruct'
-require 'pry'
-
-spec = JSON.parse(File.read('openapi.json'))
-
-# Parse OpenAPI spec
-resources = Hash.new { |h, k| h[k] = [] } # Default value of new keys is []
-spec['paths'].each do |path, methods|
-  methods.each do |method, details|
-    name = details['x-tag'] # Resource name
-
-    endpoint = {
-      http_method: method.to_sym,
-      path: path.split('/').reject(&:empty?),
-      operation: details['operationId'].split('_').first.downcase,
-
-      # Extra info
-      details: details,
-    }
-
-    # Convert path params to symbols
-    path_params = details['parameters'].select { |p| p['in'] == 'path' }
-    endpoint[:path].map! do |p|
-      # Find path param for this segment
-      param = path_params.find { |param| "{#{param['name']}}" == p }
-      param ? param['name'].to_sym : p
-    end
-
-    # Handle case for "/groups/current".
-    # Changes operation from :retrieve to :current
-    if endpoint[:path].size > 1 && endpoint[:path].last.is_a?(String)
-      endpoint[:operation] = endpoint[:path].last.to_sym
-    end
-
-    # Add endpoint to resource
-    resources[name] << endpoint
-  end
-end
-
-# Write OpenAPI version to file
-api_version = spec['info']['version']
-File.open('OPENAPI_VERSION', 'w') do |file|
-  file.write("v#{api_version}")
-end
-
-# Clear resources directory
-Dir.glob('lib/increase/resources/*.rb').each do |file|
-  File.delete(file)
-end
-
-# Generate code
-OPERATION_ALIASES = [
-  {
-    name: 'create',
-    operation: 'create',
-    http_method: :post,
-    path_regex: /^\w+$/
-  },
-  {
-    name: 'list',
-    operation: 'list',
-    http_method: :get,
-    path_regex: /^\w+$/
-  },
-  {
-    name: 'update',
-    operation: 'update',
-    http_method: :patch,
-    path_regex: /^\w+\/\w+_id$/
-  },
-  {
-    name: 'retrieve',
-    operation: 'retrieve',
-    http_method: :get,
-    path_regex: /^\w+\/\w+_id$/
-  }
-]
-
-template = File.read('generate/resource.rb.erb')
-render = ERB.new(template, trim_mode: '-')
-
-resources.delete('Simulations') # TODO
-
-resources.each do |name, operations|
-  # Convert name to class name (pascal case with no special characters)
-  class_name = name.split(/[\s\W]/).map(&:capitalize).join
-
-  # Resource type
-  resource_type = operations.first[:path].first
-
-  # Format operations
-  ops = operations.each do |op|
-    # Try to find an alias for this operation
-    op_alias = OPERATION_ALIASES.find do |alias_op|
-      op[:operation] == alias_op[:operation] &&
-        op[:http_method] == alias_op[:http_method] &&
-        alias_op[:path_regex].match(op[:path].join('/'))
-    end
-    op.merge!(alias: op_alias&.dig(:name))
-
-    # Check to make sure path doesn't not contain more than 1 param
-    if op[:path].select { |p| p.is_a?(Symbol) }.size > 1
-      raise StandardError, "Multiple path params for #{name} #{op[:path].inspect}"
-    end
-
-    # Remove resource root path segment
-    op[:path].shift
-    if op[:path].size == 1
-      op[:path] = op[:path].first
-    end
-  end
-
-  # Check operation uniqueness
-  if ops.map { |op| op[:operation] }.uniq.size != ops.size
-    raise StandardError, "Duplicate operations for #{name}"
-  end
-
-  # Render template
-  namespace = OpenStruct.new(
-    class_name: class_name,
-    name: name,
-    api_name: resource_type,
-    operations: ops
-  )
-  contents = render.result(namespace.instance_eval { binding })
-
-  # Write to file
-  File.open("lib/increase/resources/#{resource_type}.rb", 'w') do |file|
-    file.write(contents)
-  end
-
-  # Print messages
-  puts "Generated #{class_name}"
-  ops.each do |op|
-    puts "  #{op[:operation]}"
-  end
-  puts
-end
-
-raise "TODO Reminder: Handle special case for Increase::Files.create"

data/bin/setup

@@ -1,8 +0,0 @@
-#!/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/generate/resource.rb.erb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "increase/resource"
-
-module Increase
-  class <%= class_name %> < Resource
-    NAME = <%= name.inspect %>
-    API_NAME = <%= api_name.inspect %>
-
-    <%- operations.each do |op| -%>
-    # <%= op[:details]['summary'] %>
-    <%- if op[:alias] -%>
-    <%= op[:alias] -%>
-    <%- else -%>
-    endpoint <%= op[:operation].inspect %>, <%= op[:http_method].inspect %>, path: <%= op[:path].inspect -%>
-    <%- end -%><%# close if %>
-    <%- end %><%# close loop %>  end
-end

data/lib/increase/configuration.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Increase
-  class Configuration
-    attr_reader :base_url
-    attr_accessor :api_key
-    attr_accessor :raise_api_errors
-    # TODO: support Faraday config
-
-    def initialize(config = nil)
-      reset
-      configure(config) if config
-    end
-
-    def reset
-      @base_url = ENV["INCREASE_BASE_URL"] || Increase::PRODUCTION_URL
-      @api_key = ENV["INCREASE_API_KEY"]
-      @raise_api_errors = true
-    end
-
-    def configure(config = nil)
-      if config.is_a?(Hash)
-        config.each do |key, value|
-          unless respond_to?("#{key}=")
-            raise ArgumentError, "Invalid configuration: #{key}"
-          end
-          public_send("#{key}=", value)
-        end
-      end
-
-      if block_given?
-        yield self
-      end
-
-      self
-    end
-
-    def base_url=(url)
-      url = PRODUCTION_URL if url == :production
-      url = SANDBOX_URL if [:sandbox, :development].include?(url)
-
-      # Validate url
-      unless url&.match?(URI::DEFAULT_PARSER.make_regexp(%w[http https]))
-        raise ArgumentError, "Invalid url: #{url}"
-      end
-
-      @base_url = url
-    end
-  end
-end

data/lib/increase/file_upload.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "tempfile"
-require "marcel"
-require "faraday"
-require "pathname"
-
-module Increase
-  class FileUpload
-    attr_reader :file, :filename, :content_type
-
-    def initialize(file_or_path, filename: nil, content_type: nil)
-      @filename = filename
-      @content_type = content_type
-
-      if file_or_path.is_a?(File) || file_or_path.is_a?(Tempfile)
-        @file = file_or_path
-        @filename ||= File.basename(file_or_path.path)
-      elsif file_or_path.is_a?(String)
-        # Treat string as a filepath
-        @file = File.open(file_or_path)
-        @filename ||= File.basename(file_or_path)
-      elsif file_or_path.respond_to?(:read)
-        @file = Tempfile.new(default_filename)
-        @file.write(file_or_path.read)
-      else
-        raise ArgumentError, "File or path required"
-      end
-
-      # Try to guess content type
-      @content_type ||= Marcel::MimeType.for(@file, name: @filename)
-      @filename ||= default_filename
-    end
-
-    def file_part
-      if Gem::Version.new(Faraday::VERSION) >= Gem::Version.new("2.0")
-        Faraday::Multipart::FilePart.new(
-          @file,
-          @content_type,
-          @filename
-        )
-      else
-        Faraday::FilePart.new(
-          @file,
-          @content_type,
-          @filename
-        )
-      end
-    end
-
-    private
-
-    def default_filename
-      "file upload #{Time.now}"
-    end
-  end
-end

data/lib/increase/middleware/encode_json.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-
-module Increase
-  module Middleware
-    # JSON request middleware for Faraday 1.0
-    # In Faraday 2.0, the JSON middleware is bundled with the Faraday gem itself
-    #
-    # This middleware is from
-    # https://github.com/lostisland/faraday_middleware/blob/main/lib/faraday_middleware/request/encode_json.rb
-    class EncodeJson < Faraday::Middleware
-      CONTENT_TYPE = "Content-Type"
-      MIME_TYPE = "application/json"
-      MIME_TYPE_REGEX = %r{^application/(vnd\..+\+)?json$}.freeze
-
-      dependency do
-        require "json" unless defined?(::JSON)
-      end
-
-      def call(env)
-        match_content_type(env) do |data|
-          env[:body] = encode data
-        end
-        @app.call env
-      end
-
-      def encode(data)
-        ::JSON.generate data
-      end
-
-      def match_content_type(env)
-        return unless process_request?(env)
-
-        env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
-        yield env[:body] unless env[:body].respond_to?(:to_str)
-      end
-
-      def process_request?(env)
-        type = request_type(env)
-        has_body?(env) && (type.empty? || MIME_TYPE_REGEX =~ type)
-      end
-
-      def has_body?(env)
-        (body = env[:body]) && !(body.respond_to?(:to_str) && body.empty?)
-      end
-
-      def request_type(env)
-        type = env[:request_headers][CONTENT_TYPE].to_s
-        type = type.split(";", 2).first if type.index(";")
-        type
-      end
-    end
-  end
-end
-
-Faraday::Request.register_middleware(json: Increase::Middleware::EncodeJson)

data/lib/increase/middleware/parse_json.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "json"
-
-module Increase
-  module Middleware
-    # JSON response middleware for Faraday 1.0
-    # In Faraday 2.0, the JSON middleware is bundled with the Faraday gem itself
-    #
-    # This middleware is from
-    # https://github.com/jsmestad/jsonapi-consumer/blob/7d9721ea7feb888ea1e43edb9f1c0c38334762ed/lib/jsonapi/consumer/middleware/parse_json.rb
-    class ParseJson < Faraday::Middleware
-      def call(environment)
-        @app.call(environment).on_complete do |env|
-          if process_response_type?(response_type(env))
-            env[:raw_body] = env[:body]
-            env[:body] = parse(env[:body])
-          end
-        end
-      end
-
-      private
-
-      def parse(body)
-        ::JSON.parse(body) unless body.strip.empty?
-      end
-
-      def response_type(env)
-        type = env[:response_headers]["Content-Type"].to_s
-        type = type.split(";", 2).first if type.index(";")
-        type
-      end
-
-      def process_response_type?(type)
-        !!type.match(/\bjson$/)
-      end
-    end
-  end
-end
-
-Faraday::Response.register_middleware(json: Increase::Middleware::ParseJson)

data/lib/increase/middleware/raise_api_error.rb

@@ -1,13 +0,0 @@
-require "faraday"
-
-module Increase
-  module Middleware
-    class RaiseApiError < Faraday::Middleware
-      def on_complete(env)
-        return if env[:status] < 400
-
-        raise Increase::ApiError.from_response(env)
-      end
-    end
-  end
-end

data/lib/increase/resource.rb

@@ -1,205 +0,0 @@
-require "increase/response_hash"
-require "increase/response_array"
-
-module Increase
-  class Resource
-    PAGINATION_MAX_LIMIT = 100
-
-    def initialize(client: nil)
-      if instance_of?(Resource)
-        raise NotImplementedError, "Resource is an abstract class. You should perform actions on its subclasses (Accounts, Transactions, Card, etc.)"
-      end
-      @client = client || Increase.default_client
-    end
-
-    def self.with_config(config)
-      if config.is_a?(Client)
-        new(client: config)
-      else
-        new(client: Client.new(config))
-      end
-    end
-
-    def self.resource_url
-      "/#{self::API_NAME}"
-    end
-
-    def self.endpoint(name, http_method, path: nil, with: nil)
-      path = [path].flatten.compact
-      with = [with].flatten.compact
-
-      # TODO: This doesn't support multiple path params
-      is_id = ->(path_segment) { path_segment.is_a?(Symbol) && path_segment.to_s.end_with?("id") }
-      has_id = path.any? is_id
-
-      request_method = :request
-      request_method = :paginated_request if with.include?(:pagination)
-
-      method =
-        if has_id
-          # Method signature with a required `id` param
-          ->(id, params = nil, headers = nil, &block) do
-            segments = path.map { |segment| is_id.call(segment) ? id : segment }
-            url = ([self.class.resource_url] + segments).join("/")
-
-            if with.include?(:file_upload)
-              headers = {"Content-Type" => "multipart/form-data"}.merge(headers || {})
-            end
-
-            send(request_method, http_method, url, params, headers, &block)
-          end
-        else
-          # Method signature without a required `id` param
-          ->(params = nil, headers = nil, &block) do
-            url = ([self.class.resource_url] + path).join("/")
-
-            if with.include?(:file_upload)
-              headers = {"Content-Type" => "multipart/form-data"}.merge(headers || {})
-            end
-
-            send(request_method, http_method, url, params, headers, &block)
-          end
-        end
-
-      # Define instance method
-      define_method(name, &method)
-
-      # Define class method (uses default config by calling `new`)
-      define_singleton_method(name) do |*args, &block|
-        new.send(name, *args, &block)
-      end
-    end
-
-    private_class_method :endpoint
-
-    class << self
-      private
-
-      # These methods here are shortcuts for the `endpoint` method. They define
-      # commonly used endpoints. For example, nearly all resources have a `list`
-      # endpoint which is a `GET` request to the resource's root URL.
-
-      def create
-        endpoint :create, :post
-      end
-
-      def list
-        endpoint :list, :get, with: :pagination
-      end
-
-      def update
-        endpoint :update, :patch, path: [:id]
-      end
-
-      def retrieve
-        endpoint :retrieve, :get, path: [:id]
-      end
-    end
-
-    private
-
-    def request(method, path, params = nil, headers = nil, &block)
-      params ||= {}
-      headers ||= {}
-
-      if block
-        # Assume the caller wants to automatically paginate
-        return paginated_request(method, path, params, headers, &block)
-      end
-
-      if method == :post
-        headers = {"Content-Type" => "application/json"}.merge!(headers || {})
-      end
-
-      # Hack to check for correct file upload params
-      if headers["Content-Type"] == "multipart/form-data"
-        attr = :file # TODO: Make this configurable
-        if params[attr]
-          unless params[attr].is_a?(FileUpload)
-            params[attr] = FileUpload.new(params[attr])
-          end
-
-          params[attr] = params[attr].file_part
-        end
-      end
-
-      response = @client.connection.send(method, path, params, headers)
-      ResponseHash.new(response.body, response: response)
-    end
-
-    def paginated_request(method, path, params = nil, headers = nil, &block)
-      params ||= {}
-      limit = params[:limit] || params["limit"]
-      if limit == :all || limit&.>(PAGINATION_MAX_LIMIT)
-        # Request `limit` can not be greater than `PAGINATION_MAX_LIMIT`
-        params.delete("limit")
-        params[:limit] = PAGINATION_MAX_LIMIT
-      end
-
-      results = []
-      count = 0
-
-      loop do
-        res = request(method, path, params, headers)
-        data = res["data"]
-
-        # Handle case where endpoint doesn't support pagination.
-        # For example, someone passes a block to `Accounts.create`
-        if data.nil?
-          # In this case, we'll both yield and return the response.
-          # `res` here is already a `ResponseHash` since it comes from `request`
-          if block
-            yield res and return
-          end
-          return res
-        end
-
-        # From here on, the endpoint definitely supports pagination
-
-        count += data.size
-        # Restrict number of results to the limit
-        if ![nil, :all].include?(limit) && count >= limit
-          data = data[0..(limit - (count - data.size) - 1)]
-        end
-
-        # Either yield or collect the results
-        if block
-          block.call(ResponseArray.new(data, full_response: res, response: res.response))
-        else
-          results += data
-        end
-
-        # Handle case where user doesn't want to paginate
-        if limit.nil?
-          if block
-            # Block has already been called above
-            return
-          else
-            return ResponseArray.new(results, full_response: res, response: res.response)
-          end
-        end
-
-        # From here on, this is for sure a paginated request
-
-        # Handle case where we've hit the last page
-        if (limit != :all && count >= limit) || res["next_cursor"].nil?
-          if block
-            # We've already yielded all the data above
-            return
-          else
-            # Wrap with a `ResponseArray`. However, there are multiple
-            # requests/responses associated with this array. The `full_response`
-            # and `response` only store the last response.
-            return ResponseArray.new(results, full_response: res, response: res.response)
-          end
-        end
-
-        # Update the cursor and loop again!
-        params[:cursor] = res["next_cursor"]
-        if limit != :all
-          params[:limit] = [limit - count, PAGINATION_MAX_LIMIT].min
-        end
-      end
-    end
-  end
-end

data/lib/increase/resources/card_profiles.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "increase/resource"
-
-module Increase
-  class CardProfiles < Resource
-    NAME = "Card Profiles"
-    API_NAME = "card_profiles"
-
-    # Create a Card Profile
-    create
-    # List Card Profiles
-    list
-    # Retrieve a Card Profile
-    retrieve
-  end
-end

data/lib/increase/resources/inbound_ach_transfer_returns.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "increase/resource"
-
-module Increase
-  class InboundAchTransferReturns < Resource
-    NAME = "Inbound ACH Transfer Returns"
-    API_NAME = "inbound_ach_transfer_returns"
-
-    # Create an ACH Return
-    create
-    # List Inbound ACH Transfer Returns
-    list
-    # Retrieve an Inbound ACH Transfer Return
-    retrieve
-  end
-end