Directory = 'data/'

  Directory = nil
  Directory_error = nil  -- Any error encountered while determining Directory. If this is ever set, the app will do nothing but display it. (We can't rely on 'error' for that because we don't want to open up the sources in that situation.)

  Error_log.filename = Directory..'errors'

  Error_log.filename = nil  -- Will live within Directory. Don't forget to set this once Directory is initialized.

    print('loading settings')

    Directory = Settings.data_directory

    print('no saved settings; initializing to defaults')

  end
  if #arg > 0 then
    Directory = arg[1]
    print('setting Directory from commandline: '..arg[1])
    if Directory:sub(#Directory,#Directory) ~= '/' then
      Directory = Directory..'/'
    end
    print('Directory is now '..Directory)
  end
  if Directory == nil then
    print('setting Directory_error')
    if Settings == nil then
      Directory_error =
        "Please run pensieve.love once from a terminal window and specify the\n"..
        "location of your notes. The location will be remembered in future.\n"..
        "Thank you! If all goes well, you won't see this message ever again."
    else
      Directory_error =
        "Please perform a one-time migration for your notes:\n"..
        "\n"..
        "* (optional) Move any existing notes in "..App.save_dir.."data\n"..
        "   or similar locations to your preferred location.\n"..
        "\n"..
        "* (optional) Move any existing "..App.save_dir.."config\n"..
        "   file _inside_ your notes directory to preserve any prior state\n"..
        "   of your note-taking surface (open columns, etc.).\n"..
        "\n"..
        "* Please run pensieve.love once from a terminal window and specify the\n"..
        "   location of your notes as an absolute path. This location will be\n"..
        "   remembered in future.\n"..
        "\n"..
        "Thank you! If all goes well, you won't see this message ever again."
    end
    return

  assert(Directory)
  print('Directory initialized to '..Directory)
  Error_log.filename = Directory..'errors'
  run.load_more_settings_from_notes_directory()

  print_and_log('reading notes from '..App.save_dir..Directory)

  print_and_log('reading notes from '..Directory)

  Display_settings.column_width = Settings.column_width
  for _,column_name in ipairs(Settings.columns) do
    create_column(column_name)

end
function run.load_more_settings_from_notes_directory()
  local f = App.open_for_reading(Directory..'config')
  if f then
    local directory_settings = json.decode(f:read())
    f:close()
    Display_settings.column_width = directory_settings.column_width
    for _,column_name in ipairs(directory_settings.columns) do
      create_column(column_name)
    end
    Cursor_pane.col = directory_settings.cursor_col
    Cursor_pane.row = directory_settings.cursor_row
    Display_settings.x = directory_settings.surface_x
    Display_settings.y = directory_settings.surface_y
  else
    -- initialize surface with a single column
    command.recently_modified()

  Cursor_pane.col = Settings.cursor_col
  Cursor_pane.row = Settings.cursor_row
  Display_settings.x = Settings.surface_x
  Display_settings.y = Settings.surface_y

  -- initialize surface with a single column
  command.recently_modified()

  if Directory_error then return end

  if Directory_error then
    love.graphics.print(Directory_error, 50,50)
    return
  end

  if Directory_error then return end

  if Directory_error then return end

  if Settings == nil then Settings = {} end
  Settings.x, Settings.y, Settings.displayindex = App.screen.position()

  assert(Directory_error == nil)  -- this will go into an infinite loop if handle_error ever tries to save settings
  -- side effect: save notes-related settings inside Directory

  local f = App.open_for_writing(Directory..'config')
  assert(f)
  f:write(json.encode({
    columns=column_names,
    column_width=Display_settings.column_width,
    cursor_col=Cursor_pane.col,
    cursor_row=Cursor_pane.row,
    surface_x=Display_settings.x,
    surface_y=Display_settings.y,
  }))
  if Settings == nil then Settings = {} end
  Settings.x, Settings.y, Settings.displayindex = App.screen.position()

    column_width=Display_settings.column_width,
    surface_x=Display_settings.x,
    surface_y=Display_settings.y,
    cursor_col=Cursor_pane.col,
    cursor_row=Cursor_pane.row,
    columns=column_names,

    data_directory=Directory,

  if Directory_error then return end

  if Directory_error then return end

  if Directory_error then return end

  if Directory_error then return end

  if Directory_error then return end

  if Directory_error then return end

      if Directory_error then return end  -- make sure we never ever save 'run' settings if we failed to load Directory. All bets are off. Perform no operations that might persist past restart. Debugging errors in Directory_error code will be more inconvenient, but so it goes.

    if Directory_error then return end
    if Settings == nil then Settings = {} end

  local infile = App.open_for_reading(App.save_dir..filename)

  local infile = App.open_for_reading(filename)

  local infile = App.open_for_reading(App.save_dir..State.filename)

  local infile = App.open_for_reading(State.filename)

  local outfile = App.open_for_writing(App.save_dir..State.filename)

  local outfile = App.open_for_writing(State.filename)

      local f, err = io.open(App.save_dir..Directory..'recent', 'a')

      local f, err = io.open(Directory..'recent', 'a')

  local infile = App.open_for_reading(App.save_dir..Directory..id..'.json')

  local infile = App.open_for_reading(Directory..id..'.json')

  local links_filename = App.save_dir..Directory..id..'.json'
  local status = love.filesystem.createDirectory(dirname(links_filename))

  local links_filename = Directory..id..'.json'
  local status = App.mkdir(dirname(links_filename))

    love.filesystem.remove(links_filename)

    App.remove(links_filename)

function append_to_file(filename, contents)
  local f, err = App.open_for_reading(filename)
  if not f then
    return nil, err
  end
  local old_contents = f:read()
  f:close()
  f, err = App.open_for_writing(filename)
  if not f then
    return nil, err
  end
  f:write(old_contents..contents)
  f:close()
end

  local info = love.filesystem.getInfo(Directory..prefix)

  local info = nativefs.getInfo(Directory..prefix)

  local files = love.filesystem.getDirectoryItems(path)

  local files = App.files(path)

    info[file] = love.filesystem.getInfo(dir..'/'..file)

    info[file] = nativefs.getInfo(dir..'/'..file)

    print_and_log(('run_command: not implemented yet: %s'):format(function_name))

    print_and_log(('run_command: not implemented yet: %s'):format(cmd))

  for line in love.filesystem.lines(Directory..'recent') do

  local f = App.open_for_reading(Directory..'recent')
  for line in f:lines() do

  love.filesystem.remove(Directory..id)

  App.remove(Directory..id)

      top_level_files = love.filesystem.getDirectoryItems(Directory),

      top_level_files = App.files(Directory),

    local info = love.filesystem.getInfo(Directory..current_filename)

    local info = nativefs.getInfo(Directory..current_filename)

    local info = love.filesystem.getInfo(date_dir)

    local info = nativefs.getInfo(date_dir)

        local filenames = love.filesystem.getDirectoryItems(date_dir)

        local filenames = App.files(date_dir)

      local previous_year_info = love.filesystem.getInfo(Directory..Display_settings.search_all_state.year)

      local previous_year_info = nativefs.getInfo(Directory..Display_settings.search_all_state.year)

  local contents = love.filesystem.read(Directory..filename)

  local f = App.open_for_reading(Directory..filename)
  local contents = f:read()

    local success, errmsg = love.filesystem.append(outfilename, '[['..filename..']]\n')

    local success, errmsg = append_to_file(outfilename, '[['..filename..']]\n')

      local success, errmsg = love.filesystem.append(outfilename, '...'..snippet..'...\n\n')

      local success, errmsg = append_to_file(outfilename, '...'..snippet..'...\n\n')

    local success, errmsg = love.filesystem.append(outfilename, 'interrupted at '..Display_settings.search_all_progress_indicator..'\n')

    local success, errmsg = append_to_file(outfilename, 'interrupted at '..Display_settings.search_all_progress_indicator..'\n')

  love.filesystem.remove(Directory..pane.id)

  App.remove(Directory..pane.id)

  for line in love.filesystem.lines(Directory..'recent') do

  local f = App.open_for_reading(Directory..'recent')
  for line in f:lines() do

  local f = love.filesystem.newFile(Directory..'recent')
  f:open('w')

  local f = App.open_for_writing(Directory..'recent')

  local status = love.filesystem.createDirectory(Directory..dirname(id))

  local status = App.mkdir(Directory..dirname(id))

To try out pensieve.love with some sample data, run the following command from
this repo's top-level directory:

The first time you run pensieve.love, do so from a terminal and pass in the
directory where you want to store your notes.

```
love . sample
```

(The repo contains a 'data.sample/' directory for trying out with.)

This will read the notes from the `data.sample/` directory in this repo to
give you a flavor for what the app is like.

From here on out, restarting pensieve.love will open the same directory.
Run again from a terminal if you ever want to switch to a new directory.

While the sample gives you stuff to browse, don't use it to write any real
notes. LÖVE limits what directories apps can list files from (which is great
for privacy), but has some confusing rules around them. Each app can only
write to files under a single directory, the app's _save directory_
([love.filesystem.getSaveDirectory()](https://love2d.org/wiki/love.filesystem.getSaveDirectory)).
In addition, reads will also fall back to read from the repo directory,
enabling the sample experience. However, edits you make will not modify the
`data.sample/` directory in this repo. Your notes will fragment between two
directories, which can get confusing.
To create your own directory of notes, run without an argument:
```
love .
```
pensieve.love will then create a `data/` directory in the app's save directory
as above. Confusing location, but everything will be in one place.

  - start out with a non-default data set; default config file and data directory don't get clobbered
  - start out with a non-default data set and switch to editor and press ctrl+k to clear logs; default config file and data directory don't get clobbered

Load directory:
  - clear save dir, run, you get an error message telling you to specify a directory for notes
    - quit works
  - create an empty config file, run, you get an error message telling you to migrate your existing notes directory
    - quit works
  - clear save dir, run with a dir argument that doesn't exist; app creates dir and opens up with no data
    - quit works
    - on quit, app creates 'config' file within the dir
  - clear save dir, run with a dir argument that exists and contains no 'config'; app opens up
    - quit works
    - on quit, app creates 'config' file within the dir
  - run with a dir argument of '/' (that you don't have access to)
    ?? app should either throw an error or save data you put in _somewhere_
  - run app from terminal with a dir argument; the app uses settings from 'config' inside that directory
    - quit works
  - run app from terminal with a dir argument, hit C-w; the app switches to source editor
  - app has a config with a `data_directory` key, run app from terminal with a dir argument; app opens up with new data directory
    - on quit, app saves the new data directory to the `data_directory` key