ledger_tiller_export 0.1.0

data/lib/ledger_tiller_export.rb

@@ -0,0 +1,180 @@
+# coding: utf-8
+# typed: strict
+
+require 'ledger_tiller_export/version'
+require 'ledger_gen'
+require 'set'
+require 'google_drive'
+require 'csv'
+require 'open3'
+require 'sorbet-runtime'
+
+module LedgerTillerExport
+  class Row < T::Struct
+    extend T::Sig
+
+    prop :txn_date, Date
+    prop :txn_id, String
+    prop :account, String
+    prop :amount, Float
+    prop :description, String
+
+    sig {params(row: T::Hash[String, T.nilable(String)]).returns(Row)}
+    def self.from_csv_row(row)
+      new(
+        txn_date: Date.strptime(T.must(row["Date"]), "%m/%d/%Y"),
+        txn_id: T.must(row['Transaction ID']),
+        account: T.must(row['Account']),
+        amount: T.must(row["Amount"]).gsub('$', '').gsub(',', '').to_f,
+        description: T.must(row['Description']).gsub(/\+? /, '').capitalize,
+      )
+    end
+  end
+
+  module RuleInterface
+    extend T::Sig
+    extend T::Helpers
+
+    interface!
+
+    sig {abstract.params(row: Row).returns(T.nilable(String))}
+    def account_for_row(row); end
+  end
+
+  class RegexpRule < T::Struct
+    extend T::Sig
+    include RuleInterface
+
+    const :match, Regexp
+    const :account, String
+
+    sig {override.params(row: Row).returns(T.nilable(String))}
+    def account_for_row(row)
+      if match.match(row.description)
+        return account
+      end
+
+      nil
+    end
+  end
+
+  class Exporter
+    extend T::Sig
+
+    sig {returns(T::Array[RuleInterface])}
+    attr_reader :rules
+
+    sig {returns(String)}
+    attr_reader :spreadsheet
+
+    sig {returns(String)}
+    attr_reader :worksheet
+
+    sig {returns(String)}
+    attr_reader :default_account
+
+    sig {returns(String)}
+    attr_reader :ledger_pretty_print_options
+
+    sig {returns(GoogleDrive::Session)}
+    attr_reader :session
+
+    sig {returns(LedgerGen::Journal)}
+    attr_reader :journal
+
+    sig do
+      params(
+        rules: T::Array[RuleInterface],
+        spreadsheet: String,
+        worksheet: String,
+        default_account: String,
+        ledger_pretty_print_options: String,
+        ledger_date_format: String,
+      ).void
+    end
+    def initialize(rules:, spreadsheet:, worksheet: 'Transactions', default_account: 'Expenses:Misc', ledger_pretty_print_options: '--sort=date', ledger_date_format: '%m/%d')
+      @rules = T.let(rules, T::Array[RuleInterface])
+      @spreadsheet = T.let(spreadsheet, String)
+      @worksheet = T.let(worksheet, String)
+      @default_account = T.let(default_account, String)
+      @ledger_pretty_print_options = T.let(ledger_pretty_print_options, String)
+
+      @session = T.let(GoogleDrive::Session.from_config('.config.json'), GoogleDrive::Session)
+      @journal = T.let(LedgerGen::Journal.new, LedgerGen::Journal)
+
+      @journal.date_format = ledger_date_format
+    end
+
+    sig {void}
+    def run
+      @known_transactions = T.let(fetch_known_transactions, T.nilable(T::Set[String]))
+      @known_transactions = T.must(@known_transactions)
+
+      worksheets = session.spreadsheet_by_key(spreadsheet).worksheets
+
+      ws = worksheets.detect { |w| w.title == worksheet }
+      raw_csv = ws.export_as_string.force_encoding('utf-8')
+      csv = CSV.parse(raw_csv, headers: true)
+
+      T.must(csv).each do |raw_row|
+        row = Row.from_csv_row(raw_row.to_h)
+
+        next if @known_transactions.include?(row.txn_id)
+        next if skip_row?(row)
+
+        journal_transaction(row)
+      end
+
+      puts @journal.pretty_print(@ledger_pretty_print_options)
+    end
+
+    sig {params(row: Row).returns(T::Boolean)}
+    def skip_row?(row)
+      false
+    end
+
+    sig {returns(T::Set[String])}
+    def fetch_known_transactions
+      cmd = [
+        'ledger',
+        %q{--register-format=%(tag("tiller_id"))\n},
+        'reg',
+        'expr',
+        'has_tag(/tiller_id/)',
+      ]
+
+      raw_tags, err, status = Open3.capture3(*cmd)
+
+      if status.exitstatus && status.exitstatus != 0
+        STDERR.puts(err)
+        exit T.must(status.exitstatus)
+      end
+
+      Set.new(raw_tags.strip.split(/(\n|,)/).map(&:strip))
+    end
+
+    sig {params(row: Row).returns(String)}
+    def account_for_row(row)
+      rules.each do |rule|
+        account = rule.account_for_row(row)
+        return account if account
+      end
+
+      default_account
+    end
+
+    sig {params(row: Row).void}
+    def journal_transaction(row)
+      journal.transaction do |txn|
+        txn.cleared!
+        txn.date row.txn_date
+        txn.payee row.description
+        txn.comment "tiller_id: #{row.txn_id}"
+
+        txn.posting account_for_row(row), row.amount * -1
+        txn.posting row.account
+      end
+    end
+
+  end
+end

data/lib/ledger_tiller_export/version.rb

@@ -0,0 +1,4 @@
+# typed: strict
+module LedgerTillerExport
+  VERSION = "0.1.0"
+end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/gems/addressable.rbi

@@ -0,0 +1,199 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/addressable/all/addressable.rbi
+#
+# addressable-2.7.0
+
+module Addressable
+end
+module Addressable::VERSION
+end
+module Addressable::IDNA
+  def self.lookup_unicode_combining_class(codepoint); end
+  def self.lookup_unicode_compatibility(codepoint); end
+  def self.lookup_unicode_composition(unpacked); end
+  def self.lookup_unicode_lowercase(codepoint); end
+  def self.punycode_adapt(delta, numpoints, firsttime); end
+  def self.punycode_basic?(codepoint); end
+  def self.punycode_decode(punycode); end
+  def self.punycode_decode_digit(codepoint); end
+  def self.punycode_delimiter?(codepoint); end
+  def self.punycode_encode(unicode); end
+  def self.punycode_encode_digit(d); end
+  def self.to_ascii(input); end
+  def self.to_unicode(input); end
+  def self.unicode_compose(unpacked); end
+  def self.unicode_compose_pair(ch_one, ch_two); end
+  def self.unicode_decompose(unpacked); end
+  def self.unicode_decompose_hangul(codepoint); end
+  def self.unicode_downcase(input); end
+  def self.unicode_normalize_kc(input); end
+  def self.unicode_sort_canonical(unpacked); end
+end
+class Addressable::IDNA::PunycodeBadInput < StandardError
+end
+class Addressable::IDNA::PunycodeBigOutput < StandardError
+end
+class Addressable::IDNA::PunycodeOverflow < StandardError
+end
+class Addressable::URI
+  def +(uri); end
+  def ==(uri); end
+  def ===(uri); end
+  def absolute?; end
+  def authority; end
+  def authority=(new_authority); end
+  def basename; end
+  def default_port; end
+  def defer_validation; end
+  def display_uri; end
+  def domain; end
+  def dup; end
+  def empty?; end
+  def eql?(uri); end
+  def extname; end
+  def fragment; end
+  def fragment=(new_fragment); end
+  def freeze; end
+  def hash; end
+  def host; end
+  def host=(new_host); end
+  def hostname; end
+  def hostname=(new_hostname); end
+  def inferred_port; end
+  def initialize(options = nil); end
+  def inspect; end
+  def ip_based?; end
+  def join!(uri); end
+  def join(uri); end
+  def merge!(uri); end
+  def merge(hash); end
+  def normalize!; end
+  def normalize; end
+  def normalized_authority; end
+  def normalized_fragment; end
+  def normalized_host; end
+  def normalized_password; end
+  def normalized_path; end
+  def normalized_port; end
+  def normalized_query(*flags); end
+  def normalized_scheme; end
+  def normalized_site; end
+  def normalized_user; end
+  def normalized_userinfo; end
+  def omit!(*components); end
+  def omit(*components); end
+  def origin; end
+  def origin=(new_origin); end
+  def password; end
+  def password=(new_password); end
+  def path; end
+  def path=(new_path); end
+  def port; end
+  def port=(new_port); end
+  def query; end
+  def query=(new_query); end
+  def query_values(return_type = nil); end
+  def query_values=(new_query_values); end
+  def relative?; end
+  def remove_composite_values; end
+  def replace_self(uri); end
+  def request_uri; end
+  def request_uri=(new_request_uri); end
+  def route_from(uri); end
+  def route_to(uri); end
+  def scheme; end
+  def scheme=(new_scheme); end
+  def self.convert_path(path); end
+  def self.encode(uri, return_type = nil); end
+  def self.encode_component(component, character_class = nil, upcase_encoded = nil); end
+  def self.escape(uri, return_type = nil); end
+  def self.form_encode(form_values, sort = nil); end
+  def self.form_unencode(encoded_value); end
+  def self.heuristic_parse(uri, hints = nil); end
+  def self.ip_based_schemes; end
+  def self.join(*uris); end
+  def self.normalize_component(component, character_class = nil, leave_encoded = nil); end
+  def self.normalize_path(path); end
+  def self.normalized_encode(uri, return_type = nil); end
+  def self.parse(uri); end
+  def self.port_mapping; end
+  def self.unencode(uri, return_type = nil, leave_encoded = nil); end
+  def self.unencode_component(uri, return_type = nil, leave_encoded = nil); end
+  def self.unescape(uri, return_type = nil, leave_encoded = nil); end
+  def self.unescape_component(uri, return_type = nil, leave_encoded = nil); end
+  def site; end
+  def site=(new_site); end
+  def split_path(path); end
+  def tld; end
+  def tld=(new_tld); end
+  def to_hash; end
+  def to_s; end
+  def to_str; end
+  def user; end
+  def user=(new_user); end
+  def userinfo; end
+  def userinfo=(new_userinfo); end
+  def validate; end
+end
+class Addressable::URI::InvalidURIError < StandardError
+end
+module Addressable::URI::CharacterClasses
+end
+class Addressable::Template
+  def ==(template); end
+  def eql?(template); end
+  def expand(mapping, processor = nil, normalize_values = nil); end
+  def extract(uri, processor = nil); end
+  def freeze; end
+  def generate(params = nil, recall = nil, options = nil); end
+  def initialize(pattern); end
+  def inspect; end
+  def join_values(operator, return_value); end
+  def keys; end
+  def match(uri, processor = nil); end
+  def named_captures; end
+  def names; end
+  def normalize_keys(mapping); end
+  def normalize_value(value); end
+  def ordered_variable_defaults; end
+  def parse_template_pattern(pattern, processor = nil); end
+  def partial_expand(mapping, processor = nil, normalize_values = nil); end
+  def pattern; end
+  def source; end
+  def to_regexp; end
+  def transform_capture(mapping, capture, processor = nil, normalize_values = nil); end
+  def transform_partial_capture(mapping, capture, processor = nil, normalize_values = nil); end
+  def variable_defaults; end
+  def variables; end
+end
+class Addressable::Template::InvalidTemplateValueError < StandardError
+end
+class Addressable::Template::InvalidTemplateOperatorError < StandardError
+end
+class Addressable::Template::TemplateOperatorAbortedError < StandardError
+end
+class Addressable::Template::MatchData
+  def [](key, len = nil); end
+  def captures; end
+  def initialize(uri, template, mapping); end
+  def inspect; end
+  def keys; end
+  def mapping; end
+  def names; end
+  def post_match; end
+  def pre_match; end
+  def string; end
+  def template; end
+  def to_a; end
+  def to_s; end
+  def uri; end
+  def values; end
+  def values_at(*indexes); end
+  def variables; end
+end

data/sorbet/rbi/gems/declarative-option.rbi

@@ -0,0 +1,24 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/declarative-option/all/declarative-option.rbi
+#
+# declarative-option-0.1.0
+
+module Declarative
+  def self.Option(value, options = nil); end
+end
+module Declarative::Callable
+end
+class Declarative::Option
+  def call(value, options = nil); end
+  def callable?(value, options); end
+  def lambda_for_callable(value, options); end
+  def lambda_for_proc(value, options); end
+  def lambda_for_static(value, options); end
+  def lambda_for_symbol(value, options); end
+end

data/sorbet/rbi/gems/declarative.rbi

@@ -0,0 +1,75 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/declarative/all/declarative.rbi
+#
+# declarative-0.0.10
+
+module Declarative
+end
+class Declarative::Definitions < Hash
+  def add(name, options = nil, &block); end
+  def build_nested(options); end
+  def each(&block); end
+  def get(name); end
+  def initialize(definition_class); end
+end
+class Declarative::Definitions::Definition
+  def [](name); end
+  def initialize(name, options = nil, &block); end
+  def merge!(hash); end
+  def merge(hash); end
+end
+class Declarative::Defaults
+  def call(name, given_options); end
+  def handle_array_and_deprecate(variables); end
+  def initialize; end
+  def merge!(hash = nil, &block); end
+  def self.wrap_arrays(variables); end
+end
+class Declarative::Variables
+  def self.Append(appended_array); end
+  def self.Merge(merged_hash); end
+  def self.merge(defaults, overrides); end
+end
+class Declarative::Variables::Proc < Proc
+end
+class Declarative::DeepDup
+  def self.call(args); end
+  def self.dup_items(arr); end
+end
+class Declarative::Heritage < Array
+  def call!(inheritor, cfg); end
+  def call(inheritor, &block); end
+  def record(method, *args, &block); end
+end
+module Declarative::Heritage::DSL
+  def heritage; end
+end
+module Declarative::Heritage::Inherited
+  def inherited(subclass); end
+end
+module Declarative::Heritage::Included
+  def included(mod); end
+end
+module Declarative::Schema
+  def self.extended(extender); end
+end
+module Declarative::Schema::DSL
+  def _defaults; end
+  def build_definition(name, options = nil, &block); end
+  def defaults(options = nil, &block); end
+  def definition_class; end
+  def definitions; end
+  def nested_builder; end
+  def property(name, options = nil, &block); end
+  def wrap_arrays_from_block(block); end
+end
+module Declarative::Schema::Feature
+  def feature(*mods); end
+  def register_feature(mod); end
+end