lunchmoney 1.4.0 → 1.5.0

data/bin/check_vcr_version

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+# This script checks if a newer version of VCR has been released beyond 6.3.1
+# If a newer version is found, it raises an error indicating that we should
+# switch back to using the released gem instead of the git commit.
+
+CURRENT_VCR_VERSION = "6.3.1"
+VCR_COMMIT_SHA = "ce35c236fe48899f02ddf780973b44cdb756c0ee"
+
+def fetch_latest_vcr_version
+  uri = URI("https://rubygems.org/api/v1/gems/vcr.json")
+  response = Net::HTTP.get_response(uri)
+
+  unless response.is_a?(Net::HTTPSuccess)
+    puts "Warning: Could not fetch VCR version information from RubyGems API"
+    puts "Response: #{response.code} #{response.message}"
+    return nil
+  end
+
+  gem_info = JSON.parse(response.body)
+  gem_info["version"]
+rescue StandardError => e
+  puts "Warning: Error fetching VCR version information: #{e.message}"
+  nil
+end
+
+def version_greater?(version1, version2)
+  # Simple version comparison - splits by dots and compares numerically
+  v1_parts = version1.split(".").map(&:to_i)
+  v2_parts = version2.split(".").map(&:to_i)
+
+  # Pad shorter version with zeros
+  max_length = [v1_parts.length, v2_parts.length].max
+  v1_parts += [0] * (max_length - v1_parts.length)
+  v2_parts += [0] * (max_length - v2_parts.length)
+
+  v1_parts.zip(v2_parts).each do |v1, v2|
+    return true if v1 > v2
+    return false if v1 < v2
+  end
+
+  false # versions are equal
+end
+
+def main
+  puts "Checking for newer VCR releases..."
+  puts "Current pinned version: #{CURRENT_VCR_VERSION}"
+  puts "Using commit: #{VCR_COMMIT_SHA}"
+  puts ""
+
+  latest_version = fetch_latest_vcr_version
+
+  if latest_version.nil?
+    puts "Could not determine latest VCR version. Skipping check."
+    exit 0
+  end
+
+  puts "Latest released version: #{latest_version}"
+
+  if version_greater?(latest_version, CURRENT_VCR_VERSION)
+    puts ""
+    puts "🚨 NEWER VCR VERSION AVAILABLE! 🚨"
+    puts ""
+    puts "A newer version of VCR (#{latest_version}) has been released!"
+    puts "This is likely to include the Ruby 3.5+ compatibility fix from commit #{VCR_COMMIT_SHA}."
+    puts ""
+    puts "ACTION REQUIRED:"
+    puts "1. Update Gemfile to use the released version:"
+    puts "   gem \"vcr\", \"~> #{latest_version}\", require: false"
+    puts ""
+    puts "2. Remove the git reference and commit SHA"
+    puts ""
+    puts "3. Run 'bundle update vcr' to update to the new version"
+    puts ""
+    puts "4. Test to ensure everything works with the released version"
+    puts ""
+    puts "5. Consider removing this version check script once updated"
+    puts ""
+
+    exit 1
+  else
+    puts "No newer version available. Continuing to use commit #{VCR_COMMIT_SHA}."
+    exit 0
+  end
+end
+
+if __FILE__ == $0
+  main
+end

data/lib/lunchmoney/api.rb

@@ -3,6 +3,7 @@
 
 require_relative "exceptions"
 require_relative "configuration"
+require_relative "deprecate"
 
 require_relative "calls/base"
 require_relative "objects/object"
@@ -29,7 +30,7 @@ module LunchMoney
 
     sig { params(api_key: T.nilable(String)).void }
     def initialize(api_key: nil)
-      @api_key = T.let((api_key || LunchMoney.configuration.api_key), T.nilable(String))
+      @api_key = T.let(api_key || LunchMoney.configuration.api_key, T.nilable(String))
     end
 
     delegate :me, to: :user_calls
@@ -40,9 +41,7 @@ module LunchMoney
     #   api.me
     sig { returns(LunchMoney::Calls::Base) }
     def user_calls
-      with_valid_api_key do
-        @user_calls ||= T.let(LunchMoney::Calls::Users.new(api_key:), T.nilable(LunchMoney::Calls::Users))
-      end
+      memoized_call_instance(:@user_calls, LunchMoney::Calls::Users)
     end
 
     delegate :categories,
@@ -83,9 +82,7 @@ module LunchMoney
     #   api.force_delete_category(1234567)
     sig { returns(LunchMoney::Calls::Base) }
     def category_calls
-      with_valid_api_key do
-        @category_calls ||= T.let(LunchMoney::Calls::Categories.new(api_key:), T.nilable(LunchMoney::Calls::Categories))
-      end
+      memoized_call_instance(:@category_calls, LunchMoney::Calls::Categories)
     end
 
     delegate :tags, to: :tag_calls
@@ -96,9 +93,7 @@ module LunchMoney
     #   api.tags
     sig { returns(LunchMoney::Calls::Base) }
     def tag_calls
-      with_valid_api_key do
-        @tag_calls ||= T.let(LunchMoney::Calls::Tags.new(api_key:), T.nilable(LunchMoney::Calls::Tags))
-      end
+      memoized_call_instance(:@tag_calls, LunchMoney::Calls::Tags)
     end
 
     delegate :transactions,
@@ -159,12 +154,7 @@ module LunchMoney
     #   api.delete_transaction_group(905483362)
     sig { returns(LunchMoney::Calls::Base) }
     def transaction_calls
-      with_valid_api_key do
-        @transaction_calls ||= T.let(
-          LunchMoney::Calls::Transactions.new(api_key:),
-          T.nilable(LunchMoney::Calls::Transactions),
-        )
-      end
+      memoized_call_instance(:@transaction_calls, LunchMoney::Calls::Transactions)
     end
 
     delegate :recurring_expenses, to: :recurring_expense_calls
@@ -175,12 +165,7 @@ module LunchMoney
     #   api.recurring_expenses
     sig { returns(LunchMoney::Calls::Base) }
     def recurring_expense_calls
-      with_valid_api_key do
-        @recurring_expense_calls ||= T.let(
-          LunchMoney::Calls::RecurringExpenses.new(api_key:),
-          T.nilable(LunchMoney::Calls::RecurringExpenses),
-        )
-      end
+      memoized_call_instance(:@recurring_expense_calls, LunchMoney::Calls::RecurringExpenses)
     end
 
     delegate :budgets, :upsert_budget, :remove_budget, to: :budget_calls
@@ -192,14 +177,12 @@ module LunchMoney
     # @example [Upsert Budget](https://lunchmoney.dev/#upsert-budget)
     #   api = LunchMoney::Api.new
     #   api.upsert_budget(start_date: "2023-01-01", category_id: 777052, amount: 400.99)
-    # @example [Remove Budget(https://lunchmoney.dev/#remove-budget)
+    # @example [Remove Budget](https://lunchmoney.dev/#remove-budget)
     #   api = LunchMoney::Api.new
     #   api.remove_budget(start_date: "2023-01-01", category_id: 777052)
     sig { returns(LunchMoney::Calls::Base) }
     def budget_calls
-      with_valid_api_key do
-        @budget_calls ||= T.let(LunchMoney::Calls::Budgets.new(api_key:), T.nilable(LunchMoney::Calls::Budgets))
-      end
+      memoized_call_instance(:@budget_calls, LunchMoney::Calls::Budgets)
     end
 
     delegate :assets, :create_asset, :update_asset, to: :asset_calls
@@ -220,9 +203,7 @@ module LunchMoney
     #   api.update_asset(93746, balance: "99.99")
     sig { returns(LunchMoney::Calls::Base) }
     def asset_calls
-      with_valid_api_key do
-        @asset_calls ||= T.let(LunchMoney::Calls::Assets.new(api_key:), T.nilable(LunchMoney::Calls::Assets))
-      end
+      memoized_call_instance(:@asset_calls, LunchMoney::Calls::Assets)
     end
 
     delegate :plaid_accounts, :plaid_accounts_fetch, to: :plaid_account_calls
@@ -236,12 +217,7 @@ module LunchMoney
     #   api.plaid_accounts_fetch
     sig { returns(LunchMoney::Calls::Base) }
     def plaid_account_calls
-      with_valid_api_key do
-        @plaid_account_calls ||= T.let(
-          LunchMoney::Calls::PlaidAccounts.new(api_key:),
-          T.nilable(LunchMoney::Calls::PlaidAccounts),
-        )
-      end
+      memoized_call_instance(:@plaid_account_calls, LunchMoney::Calls::PlaidAccounts)
     end
 
     delegate :crypto, :update_crypto, to: :crypto_calls
@@ -255,9 +231,7 @@ module LunchMoney
     #   api.update_crypto(1234567, name: "New Crypto Name")
     sig { returns(LunchMoney::Calls::Base) }
     def crypto_calls
-      with_valid_api_key do
-        @crypto_calls ||= T.let(LunchMoney::Calls::Crypto.new(api_key:), T.nilable(LunchMoney::Calls::Crypto))
-      end
+      memoized_call_instance(:@crypto_calls, LunchMoney::Calls::Crypto)
     end
 
     private
@@ -268,5 +242,19 @@ module LunchMoney
 
       yield
     end
+
+    sig do
+      type_parameters(:T)
+        .params(
+          ivar_name: Symbol,
+          klass: T.class_of(LunchMoney::Calls::Base),
+        )
+        .returns(LunchMoney::Calls::Base)
+    end
+    def memoized_call_instance(ivar_name, klass)
+      with_valid_api_key do
+        instance_variable_get(ivar_name) || instance_variable_set(ivar_name, klass.new(api_key:))
+      end
+    end
   end
 end

data/lib/lunchmoney/calls/assets.rb

@@ -11,11 +11,10 @@ module LunchMoney
       def assets
         response = get("assets")
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body[:assets].map do |asset|
-          LunchMoney::Objects::Asset.new(**asset)
+        handle_api_response(response) do |body|
+          body[:assets].map do |asset|
+            LunchMoney::Objects::Asset.new(**asset)
+          end
         end
       end
 
@@ -50,10 +49,9 @@ module LunchMoney
 
         response = post("assets", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        LunchMoney::Objects::Asset.new(**response.body)
+        handle_api_response(response) do |body|
+          LunchMoney::Objects::Asset.new(**body)
+        end
       end
 
       sig do
@@ -88,10 +86,9 @@ module LunchMoney
 
         response = put("assets/#{asset_id}", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        LunchMoney::Objects::Asset.new(**response.body)
+        handle_api_response(response) do |body|
+          LunchMoney::Objects::Asset.new(**body)
+        end
       end
     end
   end

data/lib/lunchmoney/calls/base.rb

@@ -22,14 +22,15 @@ module LunchMoney
 
       sig { params(api_key: T.nilable(String)).void }
       def initialize(api_key: nil)
-        @api_key = T.let((api_key || LunchMoney.configuration.api_key), T.nilable(String))
+        @api_key = T.let(api_key || LunchMoney.configuration.api_key, T.nilable(String))
+        @connections = T.let({}, T::Hash[Symbol, Faraday::Connection])
       end
 
       private
 
       sig { params(endpoint: String, query_params: T.nilable(T::Hash[Symbol, T.untyped])).returns(Faraday::Response) }
       def get(endpoint, query_params: nil)
-        connection = request(flat_params: true)
+        connection = connection_for(:flat_params)
 
         if query_params.present?
           connection.get(BASE_URL + endpoint, query_params)
@@ -40,19 +41,19 @@ module LunchMoney
 
       sig { params(endpoint: String, params: T.nilable(T::Hash[Symbol, T.untyped])).returns(Faraday::Response) }
       def post(endpoint, params)
-        request(json_request: true).post(BASE_URL + endpoint, params)
+        connection_for(:json).post(BASE_URL + endpoint, params)
       end
 
       sig { params(endpoint: String, body: T::Hash[Symbol, T.untyped]).returns(Faraday::Response) }
       def put(endpoint, body)
-        request(json_request: true).put(BASE_URL + endpoint) do |req|
+        connection_for(:json).put(BASE_URL + endpoint) do |req|
           req.body = body
         end
       end
 
       sig { params(endpoint: String, query_params: T.nilable(T::Hash[Symbol, T.untyped])).returns(Faraday::Response) }
       def delete(endpoint, query_params: nil)
-        connection = request(flat_params: true)
+        connection = connection_for(:flat_params)
 
         if query_params.present?
           connection.delete(BASE_URL + endpoint, query_params)
@@ -61,12 +62,24 @@ module LunchMoney
         end
       end
 
+      sig { params(connection_type: Symbol).returns(Faraday::Connection) }
+      def connection_for(connection_type)
+        @connections[connection_type] ||= case connection_type
+        when :json
+          build_connection(json_request: true)
+        when :flat_params
+          build_connection(flat_params: true)
+        else
+          build_connection
+        end
+      end
+
       sig { params(json_request: T::Boolean, flat_params: T::Boolean).returns(Faraday::Connection) }
-      def request(json_request: false, flat_params: false)
+      def build_connection(json_request: false, flat_params: false)
         Faraday.new do |conn|
           conn.request(:authorization, "Bearer", @api_key)
           conn.request(:json) if json_request
-          # conn.options.params_encoder = Faraday::FlatParamsEncoder if flat_params
+          conn.options.params_encoder = Faraday::FlatParamsEncoder if flat_params
           conn.response(:json, content_type: /json$/, parser_options: { symbolize_names: true })
         end
       end
@@ -113,6 +126,45 @@ module LunchMoney
       def clean_params(params)
         params.reject! { |_key, value| value.nil? }
       end
+
+      sig do
+        type_parameters(:T)
+          .params(
+            response: Faraday::Response,
+            block: T.proc.params(body: T.untyped).returns(T.type_parameter(:T)),
+          )
+          .returns(T.any(T.type_parameter(:T), LunchMoney::Errors))
+      end
+      def handle_api_response(response, &block)
+        api_errors = errors(response)
+        return api_errors if api_errors.present?
+
+        yield(response.body)
+      end
+
+      sig do
+        type_parameters(:T)
+          .params(
+            response: Faraday::Response,
+            collection_key: Symbol,
+            lazy: T::Boolean,
+            block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T)),
+          )
+          .returns(T.any(T::Enumerable[T.type_parameter(:T)], T::Array[T.type_parameter(:T)], LunchMoney::Errors))
+      end
+      def handle_collection_response(response, collection_key, lazy: false, &block)
+        api_errors = errors(response)
+        return api_errors if api_errors.present?
+
+        collection = response.body[collection_key]
+        return [] unless collection
+
+        if lazy
+          collection.lazy.map(&block)
+        else
+          collection.map(&block)
+        end
+      end
     end
   end
 end

data/lib/lunchmoney/calls/budgets.rb

@@ -18,29 +18,28 @@ module LunchMoney
         params = clean_params({ start_date:, end_date:, currency: })
         response = get("budgets", query_params: params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
+        handle_api_response(response) do |body|
+          body.map do |budget|
+            if budget[:data]
+              data_keys = budget[:data].keys
+              data_keys.each do |data_key|
+                budget[:data][data_key] = LunchMoney::Objects::Data.new(**budget[:data][data_key])
+              end
+            end
 
-        response.body.map do |budget|
-          if budget[:data]
-            data_keys = budget[:data].keys
-            data_keys.each do |data_key|
-              budget[:data][data_key] = LunchMoney::Objects::Data.new(**budget[:data][data_key])
+            if budget[:config]
+              config_keys = budget[:config].keys
+              config_keys.each do |config_key|
+                budget[:config][config_key] = LunchMoney::Objects::Data.new(**budget[:config][config_key])
+              end
             end
-          end
 
-          if budget[:config]
-            config_keys = budget[:config].keys
-            config_keys.each do |config_key|
-              budget[:config][config_key] = LunchMoney::Objects::Data.new(**budget[:config][config_key])
+            if budget[:recurring]
+              budget[:recurring][:list]&.map! { |recurring| LunchMoney::Objects::RecurringExpenseBase.new(**recurring) }
             end
-          end
 
-          if budget[:recurring]
-            budget[:recurring][:list]&.map! { |recurring| LunchMoney::Objects::RecurringExpenseBase.new(**recurring) }
+            LunchMoney::Objects::Budget.new(**budget)
           end
-
-          LunchMoney::Objects::Budget.new(**budget)
         end
       end
 
@@ -59,10 +58,9 @@ module LunchMoney
         params = clean_params({ start_date:, category_id:, amount:, currency: })
         response = put("budgets", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
 
       sig { params(start_date: String, category_id: Integer).returns(T.any(T::Boolean, LunchMoney::Errors)) }
@@ -74,10 +72,9 @@ module LunchMoney
 
         response = delete("budgets", query_params: params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
     end
   end

data/lib/lunchmoney/calls/categories.rb

@@ -7,7 +7,7 @@ module LunchMoney
   module Calls
     # https://lunchmoney.dev/#categories
     class Categories < LunchMoney::Calls::Base
-      # Valid query parameter formets for categories
+      # Valid query parameter formats for categories
       VALID_FORMATS = T.let(
         [
           "flattened",
@@ -24,13 +24,12 @@ module LunchMoney
       def categories(format: nil)
         response = get("categories", query_params: categories_params(format:))
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
+        handle_api_response(response) do |body|
+          body[:categories].map do |category|
+            category[:children]&.map! { |child_category| LunchMoney::Objects::Category.new(**child_category) }
 
-        response.body[:categories].map do |category|
-          category[:children]&.map! { |child_category| LunchMoney::Objects::Category.new(**child_category) }
-
-          LunchMoney::Objects::Category.new(**category)
+            LunchMoney::Objects::Category.new(**category)
+          end
         end
       end
 
@@ -38,12 +37,11 @@ module LunchMoney
       def category(category_id)
         response = get("categories/#{category_id}")
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body[:children]&.map! { |child_category| LunchMoney::Objects::ChildCategory.new(**child_category) }
+        handle_api_response(response) do |body|
+          body[:children]&.map! { |child_category| LunchMoney::Objects::ChildCategory.new(**child_category) }
 
-        LunchMoney::Objects::Category.new(**response.body)
+          LunchMoney::Objects::Category.new(**body)
+        end
       end
 
       sig do
@@ -70,10 +68,9 @@ module LunchMoney
         })
         response = post("categories", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
 
       sig do
@@ -89,7 +86,6 @@ module LunchMoney
       end
       def create_category_group(name:, description: nil, is_income: false, exclude_from_budget: false,
         exclude_from_totals: false, category_ids: [], new_categories: [])
-
         params = {
           name:,
           description:,
@@ -102,10 +98,9 @@ module LunchMoney
 
         response = post("categories/group", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
 
       sig do
@@ -122,7 +117,6 @@ module LunchMoney
       end
       def update_category(category_id, name: nil, description: nil, is_income: nil, exclude_from_budget: nil,
         exclude_from_totals: nil, archived: nil, group_id: nil)
-
         params = clean_params({
           name:,
           description:,
@@ -134,10 +128,9 @@ module LunchMoney
         })
         response = put("categories/#{category_id}", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
 
       sig do
@@ -155,30 +148,27 @@ module LunchMoney
 
         response = post("categories/group/#{group_id}/add", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        LunchMoney::Objects::Category.new(**response.body)
+        handle_api_response(response) do |body|
+          LunchMoney::Objects::Category.new(**body)
+        end
       end
 
       sig { params(category_id: Integer).returns(T.any(T::Boolean, LunchMoney::Errors)) }
       def delete_category(category_id)
         response = delete("categories/#{category_id}")
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
 
       sig { params(category_id: Integer).returns(T.any(T::Boolean, LunchMoney::Errors)) }
       def force_delete_category(category_id)
         response = delete("categories/#{category_id}/force")
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
 
       private

data/lib/lunchmoney/calls/crypto.rb

@@ -11,11 +11,10 @@ module LunchMoney
       def crypto
         response = get("crypto")
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body[:crypto].map do |crypto|
-          LunchMoney::Objects::Crypto.new(**crypto)
+        handle_api_response(response) do |body|
+          body[:crypto].map do |crypto|
+            LunchMoney::Objects::Crypto.new(**crypto)
+          end
         end
       end
 
@@ -40,10 +39,9 @@ module LunchMoney
 
         response = put("crypto/manual/#{crypto_id}", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        LunchMoney::Objects::CryptoBase.new(**response.body)
+        handle_api_response(response) do |body|
+          LunchMoney::Objects::CryptoBase.new(**body)
+        end
       end
     end
   end

data/lib/lunchmoney/calls/plaid_accounts.rb

@@ -11,11 +11,10 @@ module LunchMoney
       def plaid_accounts
         response = get("plaid_accounts")
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body[:plaid_accounts].map do |plaid_account|
-          LunchMoney::Objects::PlaidAccount.new(**plaid_account)
+        handle_api_response(response) do |body|
+          body[:plaid_accounts].map do |plaid_account|
+            LunchMoney::Objects::PlaidAccount.new(**plaid_account)
+          end
         end
       end
 
@@ -30,10 +29,9 @@ module LunchMoney
         params = clean_params({ start_date:, end_date:, plaid_account_id: })
         response = post("plaid_accounts/fetch", params)
 
-        api_errors = errors(response)
-        return api_errors if api_errors.present?
-
-        response.body
+        handle_api_response(response) do |body|
+          body
+        end
       end
     end
   end