New Design System + Codebase Refresh (#1823)

Since the very first 0.1.0-alpha.1 release, we've been moving quickly to add new features to the Maybe app. In doing so, some parts of the codebase have become outdated, unnecessary, or overly-complex as a natural result of this feature prioritization.

Now that "core" Maybe is complete, we're moving into a second phase of development where we'll be working hard to improve the accuracy of existing features and build additional features on top of "core". This PR is a quick overhaul of the existing codebase aimed to:

- Establish the brand new and simplified dashboard view (pictured above)
- Establish and move towards the conventions introduced in Cursor rules and project design overview #1788
- Consolidate layouts and improve the performance of layout queries
- Organize the core models of the Maybe domain (i.e. Account::Entry, Account::Transaction, etc.) and break out specific traits of each model into dedicated concerns for better readability
- Remove stale / dead code from codebase
- Remove overly complex code paths in favor of simpler ones

app/models/income_statement.rb

@@ -0,0 +1,118 @@
+class IncomeStatement
+  include Monetizable
+
+  monetize :median_expense, :median_income
+
+  attr_reader :family
+
+  def initialize(family)
+    @family = family
+  end
+
+  def totals(transactions_scope: nil)
+    transactions_scope ||= family.transactions.active
+
+    result = totals_query(transactions_scope: transactions_scope)
+
+    total_income = result.select { |t| t.classification == "income" }.sum(&:total)
+    total_expense = result.select { |t| t.classification == "expense" }.sum(&:total)
+
+    ScopeTotals.new(
+      transactions_count: transactions_scope.count,
+      income_money: Money.new(total_income, family.currency),
+      expense_money: Money.new(total_expense, family.currency),
+      missing_exchange_rates?: result.any?(&:missing_exchange_rates?)
+    )
+  end
+
+  def expense_totals(period: Period.current_month)
+    build_period_total(classification: "expense", period: period)
+  end
+
+  def income_totals(period: Period.current_month)
+    build_period_total(classification: "income", period: period)
+  end
+
+  def median_expense(interval: "month", category: nil)
+    if category.present?
+      category_stats(interval: interval).find { |stat| stat.classification == "expense" && stat.category_id == category.id }&.median || 0
+    else
+      family_stats(interval: interval).find { |stat| stat.classification == "expense" }&.median || 0
+    end
+  end
+
+  def avg_expense(interval: "month", category: nil)
+    if category.present?
+      category_stats(interval: interval).find { |stat| stat.classification == "expense" && stat.category_id == category.id }&.avg || 0
+    else
+      family_stats(interval: interval).find { |stat| stat.classification == "expense" }&.avg || 0
+    end
+  end
+
+  def median_income(interval: "month")
+    family_stats(interval: interval).find { |stat| stat.classification == "income" }&.median || 0
+  end
+
+  private
+    ScopeTotals = Data.define(:transactions_count, :income_money, :expense_money, :missing_exchange_rates?)
+    PeriodTotal = Data.define(:classification, :total, :currency, :missing_exchange_rates?, :category_totals)
+    CategoryTotal = Data.define(:category, :total, :currency, :weight)
+
+    def categories
+      @categories ||= family.categories.all.to_a
+    end
+
+    def build_period_total(classification:, period:)
+      totals = totals_query(transactions_scope: family.transactions.active.in_period(period)).select { |t| t.classification == classification }
+      classification_total = totals.sum(&:total)
+
+      category_totals = totals.map do |ct|
+        # If parent category is nil, it's a top-level category.  This means we need to
+        # sum itself + SUM(children) to get the overall category total
+        children_totals = if ct.parent_category_id.nil? && ct.category_id.present?
+          totals.select { |t| t.parent_category_id == ct.category_id }.sum(&:total)
+        else
+          0
+        end
+
+        category_total = ct.total + children_totals
+
+        weight = (category_total.zero? ? 0 : category_total.to_f / classification_total) * 100
+
+        CategoryTotal.new(
+          category: categories.find { |c| c.id == ct.category_id } || family.categories.uncategorized,
+          total: category_total,
+          currency: family.currency,
+          weight: weight,
+        )
+      end
+
+      PeriodTotal.new(
+        classification: classification,
+        total: category_totals.reject { |ct| ct.category.subcategory? }.sum(&:total),
+        currency: family.currency,
+        missing_exchange_rates?: totals.any?(&:missing_exchange_rates?),
+        category_totals: category_totals
+      )
+    end
+
+    def family_stats(interval: "month")
+      @family_stats ||= {}
+      @family_stats[interval] ||= FamilyStats.new(family, interval:).call
+    end
+
+    def category_stats(interval: "month")
+      @category_stats ||= {}
+      @category_stats[interval] ||= CategoryStats.new(family, interval:).call
+    end
+
+    def totals_query(transactions_scope:)
+      @totals_query_cache ||= {}
+      cache_key = Digest::MD5.hexdigest(transactions_scope.to_sql)
+      @totals_query_cache[cache_key] ||= Totals.new(family, transactions_scope: transactions_scope).call
+    end
+
+    def monetizable_currency
+      family.currency
+    end
+end