yorn 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d83575804f3ca230fe0c088f91732b3aa763a378f35efc900913f1c0c422e766
+  data.tar.gz: 7a11a5e9a58787f209fd950cd300bacd3782a913bb7f7175b0d58617f8878bec
+SHA512:
+  metadata.gz: 3e27ef551fee30d9a74f733a4e16ca4f113ae246145ca9fee7a3d073f497dd8fea161344acb4c9ce257be14fe838d185c06f2be7053876b155ce254c6219f296
+  data.tar.gz: 961436d6bd24aa2c8c272303e06885ac631b06db778471636d572a506124d4531d034a7d4311ddae47ec7236de99c031d8fc647efa8857c98b8e824aefb33086

data/bin/yorn

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+### yorn is a program for managing journals (yornals)
+### uses git for version control
+
+require "emanlib"
+require "optimist"
+require "openssl"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "stdlib"
+require "misc"
+require "yornal"
+require "entry"
+require "format"
+require "parse"
+require "validate"
+require "options"
+
+### globals
+
+DEPTH = {
+  box: 0,
+  year: 1,
+  month: 2,
+  day: 3,
+  hour: 4,
+  minute: 5, min: 5,
+}
+
+SHA256 = OpenSSL::Digest.new("SHA256")
+
+# system "rm -rf ~/.yornal.testing 2> /dev/null"
+# ENV["YORNAL_PATH"] = File.expand_path "~/.yornal.testing"
+
+data_dir = File.expand_path (ENV["XDG_DATA_HOME"] or "~/.cache") + "/yornal"
+path = (ENV["YORNAL_PATH"] or data_dir or "~/.yornal")
+$yornalPath = File.expand_path path
+$dotyornal = [$yornalPath, ".yornal"].jomp("/")
+
+if ARGV[0] == "git"
+  die do
+    if Dir.exist?($yornalPath)
+      Dir.chdir $yornalPath
+      system ARGV.join " "
+    else
+      err "Yornal repository does not exist."
+    end
+  end
+end
+
+opts = Optimist.options do
+  $options.each do |option, hash|
+    opt option, $options[option][:syntax],
+        type: :string, **hash
+  end
+
+  opt :delete, "Delete selected entries or yornal"
+  opt :yes, "Assume yes when asked a question"
+  opt :usage, "Print example flag usage", type: :string, default: "all"
+  opt :full_path, "Print absolute path when printing paths", short: :F
+  opt :init, "Initialize yornal repository. Affected by YORNAL_PATH environment variable"
+
+  $options.each_key do |option|
+    [[:add], [:init], [:usage], %i[create type]]
+      .each do |set|
+      set.each { |o| conflicts o, option unless set.any? option }
+    end
+  end
+
+  conflicts :last, :first
+  conflicts :print, :print_path, :delete, :edit, :view
+end
+
+$given = opts.keys
+             .filter { |o| o =~ /given/ }
+             .map { |s| s.to_s[0..(-7)].to_sym }
+
+def given?(option)
+  $given.any? option
+end
+
+if $given == [:init]
+  err "Yornal repository already exists" if Dir.exist? [$yornalPath, ".git"].join("/")
+
+  mkdir $yornalPath
+  Dir.chdir $yornalPath
+  system "find . -type d -exec rm -rf {} 2> /dev/null"
+  git(:init)
+  File.open($dotyornal, "w") { |f| f.print "{}" }
+  git(:add, $dotyornal)
+  git(:commit, "-m 'Create yornal repository'")
+  die
+end
+
+if Dir.exist? $yornalPath
+  Dir.chdir $yornalPath
+
+  Dir.exist?(".git") or
+    err "Yornal repository not set up for version control. See --init"
+
+  File.exist?($dotyornal) or
+    err ".yornal file does not exist. Manually create it."
+else
+  puts "Yornal repository does not exist."
+  puts "Use --init for repository creation."
+  die
+end
+
+if $given == [:usage]
+  die do
+    $options[opts[:usage].to_sym]
+      .when(Hash) do |hash|
+      puts Format.examples(opts[:usage], hash)
+    end
+      .default do
+      opts[:usage] == "all" or err("unrecognized flag '#{opts[:usage]}'")
+      $options.each do |option, hash|
+        Format.examples(option.to_s.gsub("_", "-"), hash)
+              .when(String) do |x|
+          puts x
+          puts
+        end
+      end
+    end
+  end
+end
+
+if [[:create], %i[create type]].any? { |x| x.union($given) == $given.sort }
+  die do
+    Parse.yornalType(opts[:type])
+         .when(Array) do |type|
+      Yornal.create(opts[:create], type[0])
+    end
+      .default { err "invalid type '#{opts[:type]}'" }
+  end
+end
+
+$yornalName = ARGV[0]
+(Yornal.report and die) if $given.empty? && !$yornalName
+$yornalName or err "yornal name must be given, see --usage"
+Yornal.list.keys.any? $yornalName or err "yornal '#{$yornalName}' does not exist"
+$yornal = Yornal.new($yornalName)
+
+($yornal.edit and die) if $given.empty?
+
+if $given == [:add]
+  die do
+    add = Format.monthswap(opts[:add])
+    Validate.entryLiteral(add)
+    $yornal.edit(editor, Time.new(*add.split("/")))
+  end
+end
+
+if [%i[delete yes], [:delete]].any? { |x| x.union($given) == $given.sort }
+  Yornal.delete($yornalName, !opts[:yes]) and die
+end
+
+$query = Format.monthswap(opts[:query])
+Validate.queryFlag $query
+
+$entries = $yornal.entries($query)
+
+if given?(:first) || given?(:last)
+  method = given?(:first) ? :first : :last
+  type, seconds = Parse.lastFirstFlag(opts[method])
+  $entries = [$yornal.send(method, type, seconds, $entries)].flatten
+end
+
+$entries.filter! { |e| e.contains? opts[:match] } if given?(:match)
+$entries.filter! { |e| e.matches? opts[:regex] } if given?(:regex)
+
+die if $entries.empty?
+
+%i[print print_path].each { |p| opts[p] = Format.special(opts[p]) }
+
+%i[print print_path delete edit view]
+  .intersection($given).empty?
+  .when(false) do
+  given?(:print) and $entries.each { |e| e.printout(opts[:print]) }
+  given?(:print_path) and
+    $entries.each { |e| e.printpath(opts[:print_path], opts[:full_path]) }
+  given?(:delete) and $entries.each { |e| e.delete(!opts[:yes]) }
+  given?(:edit) and $yornal.edit(editor, Parse.editFlag(opts[:edit], $entries))
+  given?(:view) and $yornal.edit(pager, Parse.entrySpec(opts[:view], $entries))
+  die
+end
+
+if $entries.size == 1 && !given?(:query)
+  $entries.pop.edit
+else
+  $entries.each { |e| e.printpath(opts[:print_path], opts[:full_path]) }
+end

data/lib/entry.rb

@@ -0,0 +1,67 @@
+class Entry
+  include Comparable
+  attr_reader :date, :yornal # pseudo date, yornal (obj or name)
+
+  def <=>(other)
+    to_t <=> (other.is_a?(Entry) ? other.to_t : other)
+  end
+
+  def self.fromPath(path)
+    path[$yornalPath.size..].stlip("/")
+      .partition { |x| x =~ /^\d+$/ }
+      .map { |a| a.join("/") }
+      .then { |date, yornal| Entry.new date, yornal }
+  end
+
+  def initialize(date, yornal)
+    @date = date.is_a?(Time) ? date.to_a[..5].drop_while { |i| i == 0 }.reverse.join("/") : date
+    @yornal = yornal.is_a?(Yornal) ? yornal : Yornal.new(yornal)
+  end
+
+  def path
+    [$yornalPath, name].jomp("/")
+  end
+
+  def name
+    [@yornal.name, @date].jomp("/")
+  end
+
+  def to_t
+    Time.new(*@date.split("/"))
+  end
+
+  def contains?(word)
+    File.read(path) =~ Regexp.new(word, :i)
+  end
+
+  def matches?(regex)
+    File.read(path) =~ Regexp.new(regex)
+  rescue RegexpError
+    err "Malformed regexp"
+  end
+
+  def edit(editor = editor(), action = :Modify, ignore = nil)
+    digest = SHA256.digest(File.read(path))
+    system "#{editor} #{path}"
+    return if ignore || digest == SHA256.digest(File.read(path))
+
+    git(:add, path)
+    git(:commit, "-m '#{action} #{@yornal.name} entry #{@date}'")
+  end
+
+  def delete(ask = true)
+    pre = "You are about to delete yornal entry '#{name}'."
+    question = "Are you sure you want to delete it?"
+    git(:rm, "#{path}") if !ask || yes_or_no?(question, pre)
+  end
+
+  def printout(delimiter = "\n\n")
+    $stdout.print File.read(path)
+    $stdout.print delimiter
+  end
+
+  def printpath(delimiter = "\n", fullpath)
+    $stdout.print(fullpath ? path : name)
+    $stdout.print delimiter
+  end
+end

data/lib/format.rb

@@ -0,0 +1,33 @@
+class Format
+  def self.examples(option, hash)
+    return if hash[:examples].nil?
+
+    hash[:examples]
+      .then { |x| x.is_a?(String) ? [x] : x }
+      .map { |e| (" " * 2) + e }
+      .unshift("--#{option} examples:")
+      .join("\n")
+  end
+
+  def self.syntax(syntax)
+    [syntax].flatten.join("\n")
+  end
+
+  def self.monthswap(string)
+    string = string.downcase
+
+    %w[ january february march april
+        may june july august september
+        october november december
+    ].map { |m| [m, m[0..2]].map { |x| Regexp.new(x) } }
+      .zip(1..) do |names, i|
+      names.each { |n| string.gsub!(n, i.to_s) }
+    end
+
+    string
+  end
+
+  def self.special(x)
+    eval "\"#{x}\""
+  end
+end

data/lib/misc.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+def yes_or_no?(question, pre = nil, post = nil)
+  puts pre if pre
+  loop do
+    print "#{question} (yes|no): "
+    answer = $stdin.gets&.chomp&.downcase
+    die 1 if answer.nil?
+    if %w[yes y no n].any?(answer) || answer.empty?
+      puts post if post
+      return %w[yes y].any?(answer)
+    else
+      puts "Please enter 'yes', 'y', 'n', or 'no'."
+    end
+  end
+end
+
+def die(status = 0)
+  yield if block_given?
+  exit(status)
+end
+
+def err(message, *args)
+  $stderr.printf "Error: #{message} \n", *args
+  die 1
+end
+
+def yornal_depth(dir)
+  return 0 unless File.directory? dir
+
+  Dir.children(dir)
+     .delete_if { |i| i =~ /\D/ } # remove nested yornals
+     .map { |i| 1 + yornal_depth([dir, i].join("/")) }.max or 1
+end
+
+def tree(dir)
+  return [dir] if !(File.directory? dir) || dir =~ /\.git/
+
+  Dir.children(dir).map { |f| tree [dir, f].join("/") }.flatten
+end
+
+def defbin(x, fallback: [])
+  define_method(x) do
+    binaries = fallback
+    path = ENV["PATH"].split(":")
+    ENV[x.to_s.upcase] or
+      binaries.find { |b| path.any? { |p| File.exist? "#{p}/#{b}" } } or "cat"
+  end
+end
+
+defbin(:editor, fallback: %w[nvim vim vi emacs zile nano code])
+defbin(:pager, fallback: %w[less more])
+
+def mkdir(path)
+  system "mkdir -p #{path} > /dev/null" or
+    err("could not create directory '%s'", path)
+end
+
+def touch(path)
+  spath = path.split "/"
+  mkdir(spath[..-2].join("/")) if spath.size > 1
+  File.open(path, "w") { }
+end
+
+# wrapper for git call
+def git(*command)
+  system command.insert(0, "git").join(" ")
+end

data/lib/options.rb

@@ -0,0 +1,177 @@
+$options = {
+  last: {
+    default: "1",
+    syntax: <<~SYNTAX,
+      [$n | timeSpan[±timeSpan]*]
+        where $j, $n ∈ NaturalNumber
+        and timeSpan ::= [$j.]dateAttr
+        and dateAttr ::= y[ear] | m[on[th]] | w[eek]
+                      | d[ay] | h[our] | min[ute]
+    SYNTAX
+
+    examples: <<~EXAMPLES,
+      # selects the last entry in foo
+      yorn foo --last
+      # all the entries in foo in the past 3 years
+      yorn foo --last 3.year
+      # last 4 entries in bar yornal
+      yorn bar --last 4
+      # all the entries in qux in the past 2 month + 3 days
+      yorn qux --last 3.day+2.mon
+      # default action for multiple entries is to print entry paths
+    EXAMPLES
+  },
+
+  first: {
+    default: "1",
+    syntax: <<~SYNTAX,
+      [$n | timeSpan[±timeSpan]*]
+        where $j, $n ∈ NaturalNumber
+        and timeSpan ::= [$j.]dateAttr
+        and dateAttr ::= y[ear] | m[on[th]] | w[eek]
+                      | d[ay] | h[our] | min[ute]
+    SYNTAX
+
+    examples: <<~EXAMPLES,
+      # select first 5 entries in baz
+      yorn baz --first 5
+      # select entries in the period between the first
+      # entry in pom and 2 months after the entry
+      # very similiar to --last
+      yorn pom --first 2.mon
+    EXAMPLES
+  },
+
+  query: {
+    default: "@",
+    syntax: <<~SYNTAX,
+      $year[/$month[/$day[/$hour[/$minute]]]]
+        where $year,$month,$day,$hour and $minute
+        ::= int[,(int | int-int)]* | "@"
+        $month can be any month name as well
+    SYNTAX
+
+    examples: <<~EXAMPLES,
+      # select all entries in the 'ter' yornal (default/automatic)
+      yorn ter -q
+      # select all entries in any year where the month is august
+      yorn hue --query @/aug
+      # selects all entries even though day was specified
+      # because querying only cares about yornal set fields
+      # i.e. only the two @'s are looked at in this case
+      yorn monthlyJournal -q @/@/1
+    EXAMPLES
+  },
+
+  edit: {
+    default: "tail",
+    syntax: <<~SYNTAX,
+      loc[±$n | ±$k[±$i.dateAttr]*]
+        where $n, $k, $i ∈ NaturalNumber
+          and loc ::= [tail] | h[ead] | m[id[dle]]
+          and dateAttr ::= y[ear] | m[on[th]]
+                        | w[eek] | d[ay]
+                        | h[our] | min[ute]
+    SYNTAX
+
+    examples: <<~EXAMPLES,
+      # get entries from last year, edit the third from last entry
+      yorn yup -l y -e t-2
+      # error, as there is nothing after tail
+      yorn jan -e tail+1
+      # get all entries in hex yornal
+      # edit entry 1.5 months before the fourth entry
+      # entry won't exist, so will be created, and will be new first entry
+      yorn hex -e head+3-2.month+15.day
+    EXAMPLES
+  },
+
+  view: {
+    default: "tail",
+    syntax: <<~SYNTAX,
+      location[±$n]*
+        where location ::= [tail] | h[ead] | m[id[dle]]
+          and $n ∈ NaturalNumber
+    SYNTAX
+
+    examples: <<~EXAMPLES,
+      # view last entry in foo
+      yorn foo -v
+      # view second entry in foo
+      yorn foo --view head+1
+      # view third from last entry in foo
+      yorn foo -v t-1-1
+    EXAMPLES
+  },
+
+  add: {
+    syntax: <<~SYNTAX,
+      $year[/$month[/$day[/$hour[/$minute]]]]
+        where all ∈ NaturalNumber
+        and $month =~ month name
+    SYNTAX
+
+    examples: <<~EXAMPLES,
+      # adds 2022 entry to yearYornal, ignores fields not applicable
+      yorn yearYornal -a 2022/aug/20
+    EXAMPLES
+  },
+
+  match: {
+    syntax: "$word",
+    examples: <<~EXAMPLES,
+      # select entries in last 12 years
+      # that have the word "money" in it  }
+      yorn foo -l 12.y -m money
+      # case insensitive
+    EXAMPLES
+  },
+
+  regex: {
+    syntax: "$regex",
+    examples: <<~EXAMPLES,
+      # select entries that have integers
+      yorn foo -q @ -r "^\\d+$"
+    EXAMPLES
+  },
+
+  create: {
+    syntax: "$yornalname",
+    examples: <<~EXAMPLES,
+      # create box yornal named foo
+      yorn -c foo
+      # create yearly yornal named foo/bar
+      yorn -c foo/bar -t year
+      # create minute yornal named qux
+      yorn -c qux -t min
+    EXAMPLES
+  },
+
+  type: {
+    default: "box",
+    syntax: <<~SYNTAX,
+      y[ear] | m[on[th]] | d[ay] |
+      h[our] | min[ute]  | s[econd] | box
+    SYNTAX
+  },
+
+  print: {
+    default: '\\n\\n\\n\\n',
+    syntax: "$delimiter",
+    examples: <<~EXAMPLES,
+      # select all entries and print them without a delimiter
+      yorn foo -q @ -p ''
+    EXAMPLES
+  },
+
+  print_path: {
+    default: '\\n',
+    short: :P,
+    syntax: "$delimiter",
+    examples: <<~EXAMPLES,
+      # select last 3 entries and print paths"
+      # --print-path not needed as its default action"
+      yorn foo -l 3 --print-path
+    EXAMPLES
+  },
+}

data/lib/parse.rb

@@ -0,0 +1,88 @@
+class Parse
+  @@timeFields = [
+    [:week, "w", "week"],
+    [:second, "s", "second"],
+    [:year, "y", "year"],
+    [:month, "m", "mon", "month"],
+    [:day, "d", "day"],
+    [:hour, "h", "hour"],
+    [:minute, "min", "minute"],
+  ]
+
+  def self.entrySpecBase(argument, entries)
+    location, *operands = argument.split(/[+-]/)
+    ops = argument.scan(/[+-]/)
+
+    { ["", "t", "tail"] => proc { |a, n| a[a.size - 1 + n] },
+     %w[h head] => proc { |a, n| a[n] },
+     %w[m mid middle] => proc { |a, n| a[(a.size / 2) + n] } }.find { |k, _v| k.any? location }
+      .default { err "undefined location '#{location}'" }
+      .then do |_, locator|
+      return locator[entries, 0].to_t if operands.empty?
+
+      yield location, operands, ops, locator
+    end
+  end
+
+  def self.editFlag(argument, entries) # Time
+    Parse.entrySpecBase(argument, entries) do |*vars|
+      location, operands, ops, locator = vars
+
+      expr = operands.take_while(&:integer?).zip(ops).map(&:reverse)
+      ops = ops[expr.size..]
+      operands = operands[expr.size..]
+
+      arg = (eval expr.join) || 0
+      op = ops.shift
+      anchor = locator[entries, arg]
+      anchor or err("entry #{location}#{arg.to_ss} does not exist")
+
+      operands.map { |x| Parse.timeLiteral x }
+              .zip(ops).join
+              .then { |time| anchor.to_t + (op == "+" ? 1 : -1) * (eval(time) || 0) }
+    end
+  end
+
+  def self.entrySpec(argument, entries) # Time
+    Parse.entrySpecBase(argument, entries) do |*vars|
+      _, operands, ops, locator = vars
+
+      operands.all?(&:integer?) or err("invalid argument '#{argument}'")
+      (operands.size == ops.size) or err("invalid expression")
+      arg = (eval ops.zip(operands).join) || 0
+
+      locator[entries, arg].to_t
+    end
+  end
+
+  def self.lastFirstFlag(argument) # [Symbol, Integer]
+    return [:entry, argument.to_i] if argument.integer?
+
+    @@timeFields
+      .find { |_, *forms| forms.any? argument }
+      .when(Array) { argument = "1.#{argument}" }
+
+    operands = argument.split(/[+-]/)
+    ops = argument.scan(/[+-]/)
+
+    operands
+      .map { |x| Parse.timeLiteral x }
+      .zip(ops).join
+      .then { |r| [:time, eval(r)] }
+  end
+
+  def self.timeLiteral(x) # Integer
+    x =~ /\d+\.[a-z]+/ or err("malformed time spec '#{x}'")
+    n, field = x.split(".")
+
+    @@timeFields
+      .find { |_m, *forms| forms.any? field }
+      .tap { |_| _ or err "undefined time field '#{field}'" }
+      .slice(0).then { |m| n.to_i.send(m) }
+  end
+
+  def self.yornalType(type)
+    (@@timeFields[2..] + [[:box, "x", "box"]])
+      .find { |_, *forms| forms.any? type }
+  end
+end

data/lib/stdlib.rb

@@ -0,0 +1,49 @@
+class Integer
+  def to_ss
+    sign = self < 0 ? "-" : "+"
+    "#{sign}#{abs}"
+  end
+end
+
+class Time
+  def minute
+    min
+  end
+
+  def box
+    ""
+  end
+
+  def path(x)
+    # only first 5 elements are relevant (m,h,d,mon,y)
+    to_a[..5].reverse.take([0, DEPTH[x] - 1].max).join("/")
+  end
+end
+
+class String
+  def lstrip_by(chars)
+    gsub(Regexp.new("^[#{chars}]+"), "")
+  end
+
+  def rstrip_by(chars)
+    gsub(Regexp.new("[#{chars}]+$"), "")
+  end
+
+  def strip_by(chars)
+    lstrip_by(chars).rstrip_by(chars)
+  end
+
+  def stlip(c)
+    strip_by(c).split(c)
+  end
+
+  def integer?
+    self =~ /^\d+$/
+  end
+end
+
+class Array
+  def jomp(x)
+    join(x).chomp(x)
+  end
+end

data/lib/validate.rb

@@ -0,0 +1,21 @@
+class Validate
+  def self.queryFlag(query)
+    query =~ %r{//} and err "consecutive / in query"
+    query.split("/")
+         .tap { |x| (x.size > 0) or err "empty query" }
+         .each do |n|
+      n.split(",").each do |n|
+        unless (n =~ /^\d+(-\d+)?$/) || (n == "@")
+          err "malformed --query component '#{n}'"
+        end
+      end
+    end
+  end
+
+  def self.entryLiteral(argument)
+    fields = argument.split("/")
+    fields.all?(&:integer?) or err "malformed entry literal"
+    (fields.size <= 6) or err "only 6 datetime fields can be specified max"
+    fields.map(&:to_i).all? { |i| i >= 0 } or err "negative numbers not allowed"
+  end
+end

data/lib/yornal.rb

@@ -0,0 +1,140 @@
+class Yornal
+  attr_reader :name, :type
+
+  ## class methods
+
+  def self.dotYornalEdit(message, &block)
+    File.write(
+      $dotyornal,
+      Yornal.list.tap(&block)
+    )
+
+    git(:add, $dotyornal)
+    git(:commit, "-m '#{message}'")
+  end
+
+  def self.create(name, type)
+    { /^\./ => "begin with a dot",
+     %r{^/} => "begin with /",
+     %r{/$} => "end with /",
+     /\^/ => "contain ^",
+     %r{//} => "contain consecutive /",
+     /\.git/ => "contain '.git'",
+     /^git$/ => "be 'git'",
+     /^\d+$/ => "be digits only",
+     %r{[^/._A-za-z0-9-]} => "have chars not in [a-z], [0-9] or [/_-.]" }.each do |regex, message|
+      err "name cannot #{message}" if name =~ regex
+    end
+
+    err "yornal '#{name}' already exists" if Yornal.list.find { |n, _| n == name }
+
+    [$yornalPath, name]
+      .jomp("/").tap(&method(type == :box ? :touch : :mkdir))
+      .then { |f| git(:add, f) if type == :box }
+
+    message = "Create #{type} yornal '#{name}'"
+    Yornal.dotYornalEdit(message) { |h| h[name] = type }
+  end
+
+  def self.delete(name, ask = true)
+    Yornal.list.any? { |n, _| n == name } or err "'#{name}' yornal doesn't exist"
+    pre = "You are about to delete yornal '#{name}'."
+    question = "Are you sure you want to delete it?"
+
+    if !ask || yes_or_no?(question, pre)
+      Yornal.new(name).entries.each { |e| e.delete(ask = false) }
+      message = "Delete #{name} yornal"
+      Yornal.dotYornalEdit(message) do |h|
+        h.delete name
+      end
+
+      system "rm -rf #{name} 2> /dev/null"
+    end
+  end
+
+  def self.list
+    eval(File.read($dotyornal)).assert(Hash)
+  rescue Exception
+    err "Malformed .yornal file"
+  end
+
+  def self.report
+    spacing = nil
+    countSpacing = nil
+    Yornal.list.keys
+          .map { |y| [y, Yornal.new(y).entries.size] }
+          .tap do |ycs|
+      die { puts "No yornals available. Create one with --create" } if ycs.empty?
+      spacing = (ycs + [["yornal"]]).map(&:first).map(&:size).max + 1
+      countSpacing = ycs.map(&:last).map(&:to_s).map(&:size).max
+      printf "%-#{spacing}s %-#{countSpacing}s  type\n", "yornal", "#"
+    end.each do |y, c|
+      printf "%-#{spacing}s %-#{countSpacing}d  %s\n", y, c, Yornal.new(y).type
+    end
+  end
+
+  ## instance methods
+
+  def initialize(name)
+    @name = name
+    @type = Yornal.list[name]
+  end
+
+  def path
+    $yornalPath + "/" + @name
+  end
+
+  def edit(editor = editor(), time = Time.now, ignore = nil)
+    entryParent = [path, time.path(@type)].jomp("/")
+    mkdir(entryParent) unless @type == :box
+    entry = [entryParent, time.send(@type).to_s].jomp("/")
+
+    if File.exist? entry
+      Entry.fromPath(entry).edit(editor, :Modify, ignore)
+    else
+      system "touch #{entry}"
+      Entry.fromPath(entry).edit(editor, :Create, ignore)
+      File.delete entry if File.size(entry) == 0
+    end
+  end
+
+  def entries(query = "@")
+    self.query(query).map { |p| Entry.fromPath p }.sort
+  end
+
+  # e.g. pattern: @/@/8, 2022/09/@ ; depends on yornal type (depth)
+  def query(pattern)
+    dateStructure = %i[year month day hour min]
+    datehash = ->(x) { x.zip(dateStructure).to_h.flip }
+
+    tree(path).filter do |path|
+      entry = path[$yornalPath.size + @name.size + 1..]
+      unless entry.split("/").join =~ /\D/ # remove nested yornals
+        entryHash = datehash.call(entry.stlip("/"))
+        patternHash = datehash.call(pattern.downcase.stlip("/"))
+
+        patternHash.map do |k, v|
+          !entryHash[k] or (v == "@") or
+            v.split(",").map do |x|
+              l, r = x.split("-")
+              (l..(r or l)) # ranges work for integer strings
+            end.any? { |range| range.include? entryHash[k] }
+        end.all? true
+      end
+    end
+  end
+
+  def first(x, n = 1, from = entries)
+    return from[..(n - 1)] if x == :entry
+
+    t = from[0].to_t
+    from.filter { |e| e < (t + n) }
+  end
+
+  def last(x, n = 1, from = entries)
+    return from[(-n)..] if x == :entry
+
+    t = Time.now
+    from.filter { |e| e > (t - n) }
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: yorn
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- emanrdesu
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+- !ruby/object:Gem::Dependency
+  name: emanlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+description: A command-line journal management tool that uses git for version control.
+email: janitor@waifu.club
+executables:
+- yorn
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/yorn
+- lib/entry.rb
+- lib/format.rb
+- lib/misc.rb
+- lib/options.rb
+- lib/parse.rb
+- lib/stdlib.rb
+- lib/validate.rb
+- lib/yornal.rb
+homepage: https://github.com/emanrdesu/yorn
+licenses:
+- GPL-3.0-only
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A program for managing journals (yornals).
+test_files: []