rvgp 0.3.2

data/lib/rvgp/commands/new_project.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require_relative '../fakers/fake_feed'
+require_relative '../fakers/fake_reconciler'
+
+module RVGP
+  module Commands
+    # @!visibility private
+    # This class handles the request to create a new RVGP project.
+    class NewProject < RVGP::Base::Command
+      # @!visibility private
+      PROJECT_FILE = <<~END_OF_PROJECT_FILE
+        # vim:filetype=ledger
+
+        # Unautomated journals:
+        include journals/*.journal
+
+        # Reconciled journals:
+        include build/journals/*.journal
+
+        # Local Variables:
+        # project_name: "%<project_name>s"
+        # End:
+      END_OF_PROJECT_FILE
+
+      # @!visibility private
+      OPENING_BALANCES_FILE = <<~END_OF_BALANCES_FILE
+        2017/12/31 Opening Balances
+          Personal:Liabilities:AmericanExpress              %<liabilities>s
+          Personal:Equity:Opening Balances:AmericanExpress
+
+        2017/12/31 Opening Balances
+          Personal:Assets:AcmeBank:Checking                 %<assets>s
+          Personal:Equity:Opening Balances:AcmeBank
+      END_OF_BALANCES_FILE
+
+      # @!visibility private
+      YEARS_IN_NEW_PROJECT = 5
+
+      attr_reader :errors, :app_dir, :project_name
+
+      # @!visibility private
+      # We don't call super, mostly because this command needs to run in absence
+      # of an initialized project directory. This makes this command unique
+      # amongst the rest of the commands....
+      def initialize(*args) # rubocop:disable Lint/MissingSuper
+        @errors = []
+        @app_dir = args.first
+        @errors << I18n.t('commands.new_project.errors.missing_app_dir') unless @app_dir && !@app_dir.empty?
+      end
+
+      # @!visibility private
+      def execute!
+        confirm_operation = I18n.t('commands.new_project.confirm_operation')
+        # Let's make sure we don't accidently overwrite anything
+        if File.directory? app_dir
+          print [RVGP.pastel.yellow(I18n.t('error.warning')),
+                 I18n.t('commands.new_project.directory_exists_prompt', dir: app_dir)].join(' : ')
+          if $stdin.gets.chomp != confirm_operation
+            puts [RVGP.pastel.red(I18n.t('error.error')),
+                  I18n.t('commands.new_project.operation_aborted')].join(' : ')
+            exit 1
+          end
+        end
+
+        # Let's get the project name
+        @project_name = nil
+        loop do
+          print I18n.t('commands.new_project.project_name_prompt')
+          @project_name = $stdin.gets.chomp
+          unless @project_name.empty?
+            print I18n.t('commands.new_project.project_name_confirmation', project_name: @project_name)
+            break if $stdin.gets.chomp == confirm_operation
+          end
+        end
+
+        logger = RVGP::Application::StatusOutputRake.new pastel: RVGP.pastel
+        %i[project_directory bank_feeds reconcilers].each do |step|
+          logger.info self.class.name, I18n.t(format('commands.new_project.initialize.%s', step)) do
+            send format('initialize_%s', step).to_sym
+          end
+        end
+
+        puts I18n.t('commands.new_project.completed_banner', journal_path: project_journal_path)
+      end
+
+      private
+
+      def initialize_project_directory
+        @warnings = []
+        # Create the directory:
+        if Dir.exist? app_dir
+          @warnings << [I18n.t('commands.new_project.errors.directory_exists', dir: app_dir)]
+        else
+          Dir.mkdir app_dir
+        end
+
+        # Create the sub directories:
+        %w[build feeds].each do |dir|
+          full_dir = [app_dir, dir].join('/')
+          if Dir.exist? full_dir
+            @warnings << [I18n.t('commands.new_project.errors.directory_exists', dir: full_dir)]
+          else
+            Dir.mkdir full_dir
+          end
+        end
+
+        Dir.glob(RVGP::Gem.root('resources/skel/*')) do |filename|
+          FileUtils.cp_r filename, app_dir
+        end
+
+        # These are the app subdirectories...
+        %w[commands grids plots reconcilers validations].each do |dir|
+          full_dir = [app_dir, 'app', dir].join('/')
+          next if Dir.exist? full_dir
+
+          Dir.mkdir full_dir
+        end
+
+        # Main project journal:
+        File.write project_journal_path,
+                   format(PROJECT_FILE, project_name: @project_name.gsub('"', '\\"'))
+
+        # Opening Balances journal:
+        File.write destination_path('%<app_dir>s/journals/opening-balances.journal'),
+                   format(OPENING_BALANCES_FILE,
+                          liabilities: liabilities_at_month(-1).invert!.to_s(precision: 2),
+                          assets: assets_at_month(-1).to_s(precision: 2))
+
+        { warnings: @warnings, errors: [] }
+      end
+
+      def initialize_bank_feeds
+        each_year_in_project do |year|
+          File.write destination_path('%<app_dir>s/feeds/%<year>d-personal-basic-checking.csv', year: year),
+                     bank_feed(year)
+        end
+
+        { warnings: [], errors: [] }
+      end
+
+      def initialize_reconcilers
+        each_year_in_project do |year|
+          File.write destination_path('%<app_dir>s/app/reconcilers/%<year>d-personal-basic-checking.yml',
+                                      year: year),
+                     RVGP::Fakers::FakeReconciler.basic_checking(
+                       label: format('Personal AcmeBank:Checking (%<year>s)', year: year),
+                       input_path: format('%<year>d-personal-basic-checking.csv', year: year),
+                       output_path: format('%<year>d-personal-basic-checking.journal', year: year),
+                       format_path: 'config/csv-format-acme-checking.yml',
+                       income: [{ match: '/\AAmerican Express/', to: 'Personal:Liabilities:AmericanExpress' }] +
+                               income_companies.map do |company|
+                                 { 'match' => format('/%s/', company),
+                                   'to' => format('Personal:Income:%s', company.tr('^a-zA-Z0-9', '')) }
+                               end,
+                       expense: [{ match: '/\AAmerican Express/', to: 'Personal:Liabilities:AmericanExpress' }] +
+                                expense_companies.map do |company|
+                                  # I don't know how else to explain these asset mitigating events. lol
+                                  { match: format('/%s/', company), to: 'Personal:Expenses:Vices:Gambling' }
+                                end +
+                                monthly_expenses.keys.map do |category|
+                                  { match: format('/%s/', company_for(category)), to: category }
+                                end
+                     )
+        end
+
+        { warnings: [], errors: [] }
+      end
+
+      def income_companies
+        @income_companies ||= [Faker::Company.name]
+      end
+
+      def expense_companies
+        @expense_companies ||= [Faker::Company.name]
+      end
+
+      def company_for(category)
+        @company_for ||= {}
+        @company_for[category] ||= Faker::Company.name
+      end
+
+      def monthly_expenses
+        @monthly_expenses ||= {}.merge(
+          # Rents go up every year:
+          {
+            'Personal:Expenses:Rent' => (0...num_months_in_project).map do |i|
+              marginal_rent = RVGP::Journal::Commodity.from_symbol_and_amount '$', (50 * (i / 12).floor)
+              '$ 1800.00'.to_commodity + marginal_rent
+            end
+          },
+          # Fixed monthly costs:
+          {
+            'Personal:Expenses:Gym': '$ 102.00',
+            'Personal:Expenses:Phone': '$ 86.00'
+          }.to_h do |cat, amnt|
+            [cat.to_s, [amnt.to_commodity] * num_months_in_project]
+          end,
+          # Random-ish monthly Costs:
+          {
+            'Personal:Expenses:Food:Restaurants': { mean: 450, standard_deviation: 100 },
+            'Personal:Expenses:Food:Groceries': { mean: 750, standard_deviation: 150 },
+            'Personal:Expenses:DrugStores': { mean: 70, standard_deviation: 30 },
+            'Personal:Expenses:Department Stores': { mean: 100, standard_deviation: 80 },
+            'Personal:Expenses:Entertainment': { mean: 150, standard_deviation: 30 },
+            'Personal:Expenses:Dating': { mean: 250, standard_deviation: 100 },
+            'Personal:Expenses:Hobbies': { mean: 400, standard_deviation: 150 }
+          }.to_h do |cat, num_opts|
+            [cat.to_s,
+             num_months_in_project.times.map do
+               RVGP::Journal::Commodity.from_symbol_and_amount '$', Faker::Number.normal(**num_opts).abs
+             end]
+          end,
+          # 'Some months' Have these expenses.
+          {
+            'Personal:Expenses:Barber': { true_ratio: 0.75, mean: 50, standard_deviation: 10 },
+            'Personal:Expenses:Charity': { true_ratio: 0.5, mean: 200, standard_deviation: 100 },
+            'Personal:Expenses:Clothes': { true_ratio: 0.25, mean: 200, standard_deviation: 50 },
+            'Personal:Expenses:Cooking Supplies': { true_ratio: 0.25, mean: 100, standard_deviation: 50 },
+            'Personal:Expenses:Books': { true_ratio: 0.75, mean: 60, standard_deviation: 20 },
+            'Personal:Expenses:Health:Dental': { true_ratio: 0.125, mean: 300, standard_deviation: 50 },
+            'Personal:Expenses:Health:Doctor': { true_ratio: 0.0833, mean: 200, standard_deviation: 100 },
+            'Personal:Expenses:Health:Medications': { true_ratio: 0.0833, mean: 40, standard_deviation: 50 },
+            'Personal:Expenses:Home:Improvement': { true_ratio: 0.125, mean: 200, standard_deviation: 50 }
+          }.map do |cat, opts|
+            next unless Faker::Boolean.boolean true_ratio: opts.delete(:true_ratio)
+
+            [cat.to_s,
+             num_months_in_project.times.map do
+               RVGP::Journal::Commodity.from_symbol_and_amount '$', Faker::Number.normal(**opts).abs
+             end]
+          end.compact.to_h
+        )
+      end
+
+      def bank_feed(year)
+        @bank_feed ||= CSV.parse RVGP::Fakers::FakeFeed.personal_checking(
+          from: project_starts_on,
+          to: today,
+          expense_sources: expense_companies,
+          income_sources: income_companies,
+          opening_liability_balance: liabilities_at_month(-1),
+          opening_asset_balance: assets_at_month(-1),
+          monthly_expenses: monthly_expenses.transform_keys { |cat| company_for cat },
+          liability_sources: ['American Express'],
+          liabilities_by_month: (0...num_months_in_project).map { |i| liabilities_at_month i },
+          assets_by_month: (0...num_months_in_project).map { |i| assets_at_month i }
+        ), headers: true
+
+        CSV.generate headers: @bank_feed.headers, write_headers: true do |csv|
+          @bank_feed.each { |row| csv << row if Date.strptime(row['Date'], '%m/%d/%Y').year == year }
+        end
+      end
+
+      def today
+        @today ||= Date.today
+      end
+
+      def project_starts_on
+        @project_starts_on ||= Date.new(today.year - YEARS_IN_NEW_PROJECT, 1, 1)
+      end
+
+      def num_months_in_project
+        @num_months_in_project ||= ((today.year * 12) + today.month) -
+                                   ((project_starts_on.year * 12) +
+                                    project_starts_on.month) + 1
+      end
+
+      def each_year_in_project(&block)
+        today.year.downto(today.year - YEARS_IN_NEW_PROJECT).each(&block)
+      end
+
+      def destination_path(path, params = {})
+        params[:app_dir] ||= app_dir
+        format path, params
+      end
+
+      def liabilities_at_month(num)
+        # I played with this until it offered a nice contrast with the assets curve
+        RVGP::Journal::Commodity.from_symbol_and_amount('$',
+                                                        (Math.sin((num.to_f + 40) / 24) * 30_000) + 30_000)
+      end
+
+      def assets_at_month(num)
+        # This just happened to be an interesting graph... to me:
+        RVGP::Journal::Commodity.from_symbol_and_amount('$',
+                                                        (Math.sin((num.to_f - 32) / 20) * 40_000) + 50_000)
+      end
+
+      def project_journal_path
+        destination_path '%<app_dir>s/%<project_name>s.journal',
+                         project_name: project_name.downcase.tr(' ', '-')
+      end
+    end
+  end
+end

data/lib/rvgp/commands/plot.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../plot'
+
+module RVGP
+  module Commands
+    # @!visibility private
+    # This class contains the handling of the 'plot' command and task.
+    class Plot < RVGP::Base::Command
+      accepts_options OPTION_ALL, OPTION_LIST, %i[stdout s]
+
+      include RakeTask
+      rake_tasks :plot
+
+      # @!visibility private
+      def execute!
+        RVGP.app.ensure_build_dir! 'plots' unless options[:stdout]
+        super
+      end
+
+      # This class represents a plot, available for building. And dispatches a build request.
+      # Typically, the name of a plot takes the form of "#\\{year}-#\\{plotname}". See
+      # RVGP::Base::Command::PlotTarget, from which this class inherits, for a better
+      # representation of how this class works.
+      # @!visibility private
+      class Target < RVGP::Base::Command::PlotTarget
+        # @!visibility private
+        def execute(options)
+          if options[:stdout]
+            puts plot.script(name)
+          else
+            RVGP.app.ensure_build_dir! 'plots'
+            plot.write!(name)
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rvgp/commands/publish_gsheets.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../plot'
+require_relative '../plot/google-drive/sheet'
+require_relative '../plot/google-drive/output_google_sheets'
+require_relative '../plot/google-drive/output_csv'
+
+module RVGP
+  module Commands
+    # @!visibility private
+    # This class contains the handling of the 'publish_gsheets' command. This class
+    # works very similar to the RVGP::Commands:Plot command. Note that there is no
+    # rake integration in this command, as that function is irrelevent to the notion
+    # of an 'export'.
+    class PublishGsheets < RVGP::Base::Command
+      # @!visibility private
+      DEFAULT_SLEEP_BETWEEN_SHEETS = 5
+
+      accepts_options OPTION_ALL,
+                      OPTION_LIST,
+                      [:csvdir, :c, { has_value: 'DIRECTORY' }],
+                      [:title,  :t, { has_value: 'TITLE' }],
+                      [:sleep,  :s, { has_value: 'N' }]
+
+      # @!visibility private
+      # This class represents a Google 'sheet', built from a Plot, available for
+      # export to google. And dispatches a build request. Typically, the name of
+      # a sheet is identical to the name of its corresponding plot. And, takes
+      # the form of "#\\{year}-#\\{plotname}". See RVGP::Base::Command::PlotTarget, from
+      # which this class inherits, for a better representation of how this class
+      # works.
+      class Target < RVGP::Base::Command::PlotTarget
+        # @!visibility private
+        def to_sheet
+          RVGP::Plot::GoogleDrive::Sheet.new plot.title(name), plot.grid(name), { google: plot.google_options || {} }
+        end
+      end
+
+      # @!visibility private
+      def initialize(*args)
+        super(*args)
+
+        options[:title] ||= 'RVGP Finance Report %m/%d/%y %H:%M'
+        options[:sleep] = options.key?(:sleep) ? options[:sleep].to_i : DEFAULT_SLEEP_BETWEEN_SHEETS
+
+        if options.key? :csvdir
+          unless File.writable? options[:csvdir]
+            @errors << I18n.t('commands.publish_gsheets.errors.unable_to_write_to_csvdir', csvdir: options[:csvdir])
+          end
+        else
+          @secrets_path = RVGP.app.config.project_path('config/google-secrets.yml')
+
+          unless File.readable?(@secrets_path)
+            @errors << I18n.t('commands.publish_gsheets.errors.missing_google_secrets')
+          end
+        end
+      end
+
+      # @!visibility private
+      def execute!
+        output = if options.key?(:csvdir)
+                   RVGP::Plot::GoogleDrive::ExportLocalCsvs.new(destination: options[:csvdir], format: 'csv')
+                 else
+                   RVGP::Plot::GoogleDrive::ExportSheets.new(format: 'google_sheets',
+                                                             title: options[:title],
+                                                             secrets_file: @secrets_path)
+                 end
+
+        targets.each do |target|
+          RVGP.app.logger.info self.class.name, target.name do
+            output.sheet target.to_sheet
+
+            # NOTE: This should fix the complaints that google issues, from too many
+            # requests per second.
+            sleep options[:sleep] if output.is_a? RVGP::Plot::GoogleDrive::ExportSheets
+
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rvgp/commands/reconcile.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RVGP
+  module Commands
+    # @!visibility private
+    # This class contains the dispatch logic of the 'reconcile' command and task.
+    class Reconcile < RVGP::Base::Command
+      accepts_options OPTION_ALL, OPTION_LIST, %i[stdout s], %i[concise c]
+
+      include RakeTask
+      rake_tasks :reconcile
+
+      # @!visibility private
+      def initialize(*args)
+        super(*args)
+
+        if %i[stdout concise].all? { |output| options[output] }
+          @errors << I18n.t('commands.reconcile.errors.either_concise_or_stdout')
+        end
+      end
+
+      # @!visibility private
+      def execute!
+        RVGP.app.ensure_build_dir! 'journals' unless options[:stdout]
+        options[:stdout] || options[:concise] ? execute_each_target : super
+      end
+
+      # @!visibility private
+      # This class represents a reconciler. See RVGP::Base::Command::ReconcilerTarget, for
+      # most of the logic that this class inherits. Typically, these targets take the form
+      # of "#\\{year}-#\\{reconciler_name}"
+      class Target < RVGP::Base::Command::ReconcilerTarget
+        for_command :reconcile
+
+        # @!visibility private
+        def description
+          I18n.t 'commands.reconcile.target_description', input_file: @reconciler.input_file
+        end
+
+        # @!visibility private
+        def uptodate?
+          @reconciler.uptodate?
+        end
+
+        # @!visibility private
+        def execute(options)
+          if options[:stdout]
+            puts @reconciler.to_ledger
+          else
+            @reconciler.to_ledger!
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rvgp/commands/rotate_year.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module RVGP
+  module Commands
+    # @!visibility private
+    # This class contains the handling of the 'rotate_year' command. Note that
+    # there is no rake integration in this command, as that function is irrelevent
+    # to the notion of an 'export'.
+    class RotateYear < RVGP::Base::Command
+      accepts_options OPTION_ALL, OPTION_LIST
+
+      # @!visibility private
+      def execute!
+        puts I18n.t('commands.rotate_year.operations_header')
+
+        operations = []
+
+        unless File.directory? RotateYear.historical_path
+          operations << I18n.t('commands.rotate_year.operation_mkdir', path: RotateYear.historical_path)
+        end
+
+        operations += targets.map(&:operation_descriptions).flatten
+
+        operations.each do |operation|
+          puts I18n.t('commands.rotate_year.operation_element', operation: operation)
+        end
+
+        print I18n.t('commands.rotate_year.confirm_operation_prompt')
+
+        if $stdin.gets.chomp != I18n.t('commands.rotate_year.confirm_operation')
+          puts [RVGP.pastel.red(I18n.t('error.error')), I18n.t('commands.rotate_year.operation_aborted')].join(' : ')
+          exit 1
+        end
+
+        RVGP.app.ensure_build_dir! 'feeds/historical'
+
+        super
+      end
+
+      # @!visibility private
+      # This method returns the full path to the historical feed directory
+      def self.historical_path
+        RVGP.app.config.project_path('feeds/historical')
+      end
+
+      # @!visibility private
+      # This class represents a reconciler that's not 'historical'. Which, makes it different from the
+      # ReconcilerTarget. 'historical' is determined by whether its input_file is located in a '/historical/' basedir.
+      class Target < RVGP::Base::Command::Target
+        attr_reader :reconciler
+
+        # @!visibility private
+        # This is used as a catch in the mv! method
+        class GitError < StandardError
+        end
+
+        # Create a new RotateYear::Target
+        # @param [RVGP::Base::Reconciler] reconciler An instance of either {RVGP::Reconcilers::CsvReconciler}, or
+        #                                             {RVGP::Reconcilers::JournalReconciler}, to use as the basis
+        #                                             for this target.
+        def initialize(reconciler)
+          super reconciler.as_taskname, reconciler.label
+          @reconciler = reconciler
+        end
+
+        # @!visibility private
+        def operation_descriptions
+          [I18n.t('commands.rotate_year.operation_rotate', name: File.basename(reconciler.file))]
+        end
+
+        # @!visibility private
+        def description
+          I18n.t 'commands.rotate_year.target_description', basename: File.basename(reconciler.file)
+        end
+
+        # @!visibility private
+        def name_parts
+          raise StandardError, format('Unable to determine year from %s', name) unless /^(\d+)(.+)/.match name
+
+          [Regexp.last_match(1).to_i, Regexp.last_match(2)]
+        end
+
+        # @!visibility private
+        def year
+          name_parts.first
+        end
+
+        def git_repo?
+          @is_git_repo = begin
+            git! 'branch'
+            true
+          rescue GitError
+            false
+          end
+        end
+
+        # @!visibility private
+        def git!(*args)
+          @git_prefix ||= begin
+            output, exit_code = Open3.capture2 'which git'
+            raise GitError, output unless exit_code.to_i.zero?
+
+            [output.chomp, '-C', Shellwords.escape(RVGP.app.project_path)]
+          end
+
+          output, exit_code = Open3.capture2((@git_prefix + args.map { |a| Shellwords.escape a }).join(' '))
+
+          raise GitError, output unless exit_code.to_i.zero?
+
+          output
+        end
+
+        # @!visibility private
+        # This move will use git, if the source file is in a repo. If not, it'll use the system mv
+        def mv!(source, dest)
+          raise GitError if !git_repo? || !%r{^#{RVGP.app.project_path}/(.+)}.match(source)
+
+          project_relative_source = Regexp.last_match 1
+
+          raise GitError unless /^#{project_relative_source}$/.match(git!('ls-files'))
+
+          git! 'mv', project_relative_source, dest
+        rescue GitError
+          FileUtils.mv source, dest
+        end
+
+        # @!visibility private
+        def execute(_)
+          historical_feed_path = [File.dirname(reconciler.input_file), 'historical'].join('/')
+          rotated_basename = name_parts.tap { |parts| parts[0] += 1 }.join
+
+          FileUtils.mkdir_p historical_feed_path
+
+          # TODO: Is any of this working? It's very close. Test.
+          mv! reconciler.input_file, historical_feed_path
+
+          rotated_input_path = format('%<dir>s/%<file>s.%<ext>s',
+                                      dir: File.dirname(reconciler.input_file), file: rotated_basename, ext: 'csv')
+
+          FileUtils.touch rotated_input_path
+
+          rotated_reconciler_path = format('%<dir>s/%<basename>s.%<ext>s',
+                                           dir: File.dirname(reconciler.file), basename: rotated_basename, ext: 'yml')
+
+          File.write rotated_reconciler_path, rotated_reconciler_contents
+
+          git! 'add', rotated_reconciler_path if git_repo?
+
+          git! 'add', rotated_input_path if git_repo?
+
+          nil
+        end
+
+        # @!visibility private
+        # This method returns a rotated reconciler, based on the contents of the legacy reconciler.
+        # Root elements are preserved, but, child elements are not. Income and expense sections are
+        # pre-populated with catch-all rules.
+        def rotated_reconciler_contents
+          elements = File.read(reconciler.file).scan(/^[^\n ].+/)
+          from = elements.map { |r| ::Regexp.last_match(1) if /^from:[ \t]*(.+)/.match r }
+                         .compact.first&.tr('"\'', '')&.split(':')&.first
+
+          elements.map do |line|
+            if /^(expense|income):/.match line
+              direction = ::Regexp.last_match(1)
+              format("%<direction>s:\n  - match: /.*/\n    to: %<to>s",
+                     direction: direction,
+                     to: [from, direction == 'expense' ? 'Expenses' : 'Income', 'Unknown'].compact.join(':'))
+            else
+              line
+            end
+          end.join("\n").tr(year.to_s, (year + 1).to_s)
+        end
+
+        # All possible Reconciler Targets that the project has defined.
+        # @return [Array<RVGP::Base::Command::ReconcilerTarget>] A collection of targets.
+        def self.all
+          RVGP.app.reconcilers.map do |reconciler|
+            new reconciler unless File.dirname(reconciler.input_file).split('/').last == 'historical'
+          end.compact
+        end
+
+        private
+
+        def rotated_input_file_path
+          rotate_path reconciler.input_file
+        end
+
+        def rotate_path(path)
+          parts = path.split('/')
+          filepart = parts.pop
+
+          return path unless /\A(\d+)(.*)\Z/.match(filepart)
+
+          (parts + [[::Regexp.last_match(1).to_i + 1, ::Regexp.last_match(2)].join]).join('/')
+        end
+      end
+    end
+  end
+end