journal-cli 1.0.4

data/README.md

@@ -0,0 +1,127 @@
+
+A CLI for journaling to structured data, Markdown, and Day One
+
+## Description
+
+The `journal` command reads a journal definition and provides command line prompts to fill it out. The results are stored in a JSON database for each journal, and can optionally output to Markdown (individual files per entry, daily digest, or one large file for the journal).
+
+## Installation
+
+First, you need [Gum](https://github.com/charmbracelet/gum) installed. The easiest way is with [Homebrew](https://brew.sh/):
+
+```
+$ brew install gum
+```
+
+Use RubyGems to install journal:
+
+```
+$ gem install journal-cli
+```
+
+If you run into errors, try running with the `--user-install` flag:
+
+```
+$ gem install --user-install journal-cli
+```
+
+> I've noticed lately with `asdf` that I have to run `asdf reshim` after installing gems containing binaries.
+
+If you want to use Day One with journal, you'll need to [install the Day One CLI](https://dayoneapp.com/guides/tips-and-tutorials/command-line-interface-cli/).
+
+## Configuration
+
+A config must be created at `~/.config/journal/journals.yaml`:
+
+```
+$ mkdir -p ~/.config/journal
+$ touch ~/.config/journal/journals.yaml
+```
+
+This file contains a YAML definition of your journal. Each journal gets a top-level key, which is what you'll specify it with on the command line. It gets a few settings, and then you define sections containing questions.
+
+### Weather
+
+You can include weather data automatically by setting a question type to 'weather'. In order for this to work, you'll need to define `zip` and `weather_api` keys. `zip` is just your zip code, and `weather_api` is a key from WeatherAPI.com. Sign up [here](https://www.weatherapi.com/) for a free plan, and then visit the [profile page](https://www.weatherapi.com/my/) to see your API key at the top.
+
+### Journal configuration
+
+Edit the file at `~/.config/journal/journals.yaml` following this structure:
+
+```yaml
+daily: # journal key, will be used on the command line as `journal daily`
+  dayone: true # Enable or disable Day One integration
+  journal: Journal # Day One journal to add to (if using Day One integration)
+  markdown: daily # Type of Markdown file to create, false to skip (can be daily, individual, or digest)
+  title: Daily Journal # Title for every entry, date will be appended where needed
+  sections: # Required key
+    - title: null # The title for the section. If null, no section header will be created
+      key: journal # The key for the data collected, must be one word, alphanumeric characters and _ only
+      questions: # Required key
+        - prompt: How are you feeling? # The question to ask
+          key: journal # alphanumeric characters and _ only, will be nested in section key
+          type: multiline # The type of entry expected (numeric, string, or multiline)
+```
+
+Keys must be alphanumeric characters and `_` (underscore) only. Titles and questions can be anything, but if they contain a colon (:), you'll need to quote the string.
+
+A more complex configuration file can contain multiple journals with multiple questions defined:
+
+```yaml
+zip: 55987 # Your zip code for weather integration
+weather_api: XXXXXXXXXXXX # Your weatherapi.com API key
+journals: # required key
+  mood: # name of the journal
+    journal: Mood Journal # Optional, Day One journal to add to
+    tags: [checkin] # Optional, array of tags to add to Day One entries
+    markdown: individual # Can be daily or individual, any other value will create a single file
+    dayone: true # true to log entries to Day One, false to skip
+    title: "Mood checkin %M" # The title of the entry. Use %M to insert AM or PM
+    sections: # required key
+      - title: Weather # Title of the section (will create template sections in Day One)
+        key: weather # the key to use in the structured data, will contain all of the answers
+        questions: # required key
+          - prompt: Current weather # The prompt shown on the command line, will also become a header in the journal entries (Markdown, Day One)
+            key: weather.forecast # if a key contains a dot, it will create nested data, e.g. `{ 'weather': { 'forecast': data } }`
+            type: weather # Set this to weather for weather data
+      - title: Health # New section
+        key: health 
+        questions:
+          - prompt: Health rating
+            key: health.rating
+            type: numeric # type can be numeric, string, or multiline
+            min: 1 # Only need min/max definitions on numeric types (defaults 1-5)
+            max: 5
+          - prompt: Health notes
+            key: health.notes
+            type: multiline
+      - title: Journal # New section
+        key: journal
+        questions:
+          - prompt: Daily notes
+            key: notes
+            type: multiline
+  daily: # New journal
+    journal: Journal
+    markdown: daily
+    dayone: true
+    title: Daily Journal
+    sections:
+      - title: null
+        key: journal
+        questions:
+          - prompt: How are you feeling?
+            key: journal
+            type: multiline
+```
+
+A journal must contain a `sections` key, and each section must contain a `questions` key with an array of questions. Each question must (at minimum) have a `prompt`, `key`, and `type`.
+
+## Usage
+
+Once your configuration file is set up, you can just run `journal JOURNAL_KEY` to begin prompting for the answers to the configured questions. 
+
+Answers will always be written to `~/.local/share/journal/[KEY].json` (where [KEY] is the journal key, one data file for each journal). If you've specified `daily` or `individual` Markdown formats, entries will be written to Markdown files in `~/.local/share/journal/entries/[KEY]`, either in a `%Y-%m-%d.md` file (daily), or in timestamped individual files. If `digest` is specified for the `markdown` key, a single file will be created at `~/.local/share/journal/[KEY].md`.
+
+At present there's no tool for querying the dataset created. You just need to parse the JSON and use your language of choice to extract the data. Numeric entries are stored as numbers, and every entry is timestamped, so you should be able to do some advanced analysis once you have enough data.
+

data/README.rdoc

@@ -0,0 +1,6 @@
+= Journal
+
+A command line tool for journaling to JSON, Markdown, and Day One.
+
+
+

data/Rakefile

@@ -0,0 +1,85 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+require 'standard/rake'
+require 'yard'
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb", "bin/**/*")
+  rd.title = 'Journal'
+end
+
+YARD::Rake::YardocTask.new do |t|
+ t.files = ['lib/na/*.rb']
+ t.options = ['--markup-provider=redcarpet', '--markup=markdown', '--no-private', '-p', 'yard_templates']
+ # t.stats_options = ['--list-undoc']
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--pattern {spec,lib}/**/*_spec.rb"
+end
+
+task default: %i[test]
+
+desc 'Alias for build'
+task :package => :build
+
+task test: "spec"
+task lint: "standard"
+task format: "standard:fix"
+
+desc "Open an interactive ruby console"
+task :console do
+  require "irb"
+  require "bundler/setup"
+  require "journal-cli"
+  ARGV.clear
+  IRB.start
+end
+
+desc 'Development version check'
+task :ver do
+  gver = `git ver`
+  cver = IO.read(File.join(File.dirname(__FILE__), 'CHANGELOG.md')).match(/^#+ (\d+\.\d+\.\d+(\w+)?)/)[1]
+  res = `grep VERSION lib/journal-cli/version.rb`
+  version = res.match(/VERSION *= *['"](\d+\.\d+\.\d+(\w+)?)/)[1]
+  puts "git tag: #{gver}"
+  puts "version.rb: #{version}"
+  puts "changelog: #{cver}"
+end
+
+desc 'Changelog version check'
+task :cver do
+  puts IO.read(File.join(File.dirname(__FILE__), 'CHANGELOG.md')).match(/^#+ (\d+\.\d+\.\d+(\w+)?)/)[1]
+end
+
+desc 'Bump incremental version number'
+task :bump, :type do |_, args|
+  args.with_defaults(type: 'inc')
+  version_file = 'lib/journal-cli/version.rb'
+  content = IO.read(version_file)
+  content.sub!(/VERSION = '(?<major>\d+)\.(?<minor>\d+)\.(?<inc>\d+)(?<pre>\S+)?'/) do
+    m = Regexp.last_match
+    major = m['major'].to_i
+    minor = m['minor'].to_i
+    inc = m['inc'].to_i
+    pre = m['pre']
+
+    case args[:type]
+    when /^maj/
+      major += 1
+      minor = 0
+      inc = 0
+    when /^min/
+      minor += 1
+      inc = 0
+    else
+      inc += 1
+    end
+
+    $stdout.puts "At version #{major}.#{minor}.#{inc}#{pre}"
+    "VERSION = '#{major}.#{minor}.#{inc}#{pre}'"
+  end
+  File.open(version_file, 'w+') { |f| f.puts content }
+end

data/bin/journal

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+require 'journal-cli'
+
+raise ArgumentError, 'no journal specified' if ARGV.count.zero?
+
+case ARGV[0]
+when /(-v|--version)/
+  puts "journal v#{Journal::VERSION}"
+  Process.exit 0
+when /(help|-h|--help)/
+  puts "journal v#{Journal::VERSION}"
+  puts
+  puts 'Usage: journal [type] [date]'
+  puts
+  puts 'Available journal types:'
+  config = Journal::Checkin.new
+  puts(config.config['journals'].keys.map { |k| "- #{k}" })
+  Process.exit 0
+end
+
+journal = ARGV.shift
+
+date = if ARGV.length.positive?
+         Chronic.parse(ARGV.join(' '), future: false)
+       else
+         Time.now
+       end
+checkin = Journal::Checkin.new
+checkin.start(journal, date)
+checkin.go

data/lib/journal-cli/checkin.rb

@@ -0,0 +1,262 @@
+module Journal
+  # Main class
+  class Checkin
+    attr_reader :key, :date, :data, :config, :journal, :title, :output
+
+    def initialize
+      config = File.expand_path('~/.config/journal/journals.yaml')
+      raise StandardError, 'No journals configured' unless File.exist?(config)
+
+      @config = YAML.load(IO.read(config))
+    end
+
+    def start(journal, date)
+      @key = journal
+      @output = []
+      @date = date
+
+      raise StandardError, "No journal with key #{@key} found" unless @config['journals'].key? @key
+
+      @journal = @config['journals'][@key]
+
+      @data = {}
+      meridian = @date.hour < 13 ? 'AM' : 'PM'
+      @title = @journal['title'].sub(/%M/, meridian)
+    end
+
+    def title(string)
+      @output << "\n## #{string}\n" unless string.nil?
+    end
+
+    def header(string)
+      @output << "\n##### #{string}\n" unless string.nil?
+    end
+
+    def section(string)
+      @output << "\n###### #{string}\n" unless string.nil?
+    end
+
+    def newline
+      @output << "\n"
+    end
+
+    def hr
+      @output << "\n---\n"
+    end
+
+    def ask_question(q)
+      res = case q['type']
+            when /^(int|num)/i
+              min = q['min'] || 1
+              max = q['max'] || 5
+              get_number(q['prompt'], min: min, max: max)
+            when /^(text|string|line)/i
+              puts q['prompt']
+              add_prompt = q['secondary_prompt'] || nil
+              get_line(q['prompt'], add_prompt: add_prompt)
+            when /^(weather|forecast)/i
+              Weather.new(@config['weather_api'], @config['zip'])
+            when /^multi/
+              puts q['prompt']
+              add_prompt = q['secondary_prompt'] || nil
+              get_lines(q['prompt'], add_prompt: add_prompt)
+            end
+
+      res
+    end
+
+    def go
+      results = Data.new(@journal['questions'])
+      @journal['sections'].each do |s|
+        results[s['key']] = {
+          title: s['title'],
+          answers: {}
+        }
+
+        s['questions'].each do |q|
+          if q['key'] =~ /\./
+            res = results[s['key']][:answers]
+            keys = q['key'].split(/\./)
+            keys.each_with_index do |key, i|
+              next if i == keys.count - 1
+
+              res[key] = {} unless res.key?(key)
+              res = res[key]
+            end
+
+            res[keys.last] = ask_question(q)
+          else
+            results[s['key']][:answers][q['key']] = ask_question(q)
+          end
+        end
+      end
+
+      @data = results
+
+      if @journal['dayone']
+        cmd = ['dayone2']
+        cmd << %(-j "#{@journal['journal']}") if @journal.key?('journal')
+        cmd << %(-t #{@journal['tags'].join(' ')}) if @journal.key?('tags')
+        cmd << %(-date "#{@date.strftime('%Y-%m-%d %I:%M %p')}")
+        `echo #{Shellwords.escape(to_markdown)} | #{cmd.join(' ')} -- new`
+      end
+
+      if @journal['markdown']
+        if @journal['markdown'] =~ /^da(y|ily)/
+          dir = File.expand_path("~/.local/share/journal/entries/#{@key}")
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+          filename = "#{@date.strftime('%Y-%m-%d')}.md"
+          target = File.join(dir, filename)
+          if File.exist? target
+            File.open(target, 'a') { |f| f.puts to_markdown(yaml: false, title: true, date: false, time: true) }
+          else
+            File.open(target, 'w') { |f| f.puts to_markdown(yaml: true, title: true, date: false, time: true) }
+          end
+        elsif @journal['markdown'] =~ /^(ind|separate)/
+          dir = File.expand_path("~/.local/share/journal/entries/#{@key}")
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+          filename = @date.strftime('%Y-%m-%d_%H:%M.md')
+          File.open(File.join(dir, filename), 'w') { |f| f.puts to_markdown(yaml: true, title: true) }
+        else
+          dir = File.expand_path('~/.local/share/journal/entries/')
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+          filename = "#{@key}.md"
+          File.open(File.join(dir, filename), 'a') do |f|
+            f.puts
+            f.puts "## #{@title} #{@date.strftime('%x %X')}"
+            f.puts
+            f.puts to_markdown(yaml: false, title: false)
+          end
+        end
+      end
+
+      save_data
+    end
+
+    def print_answer(prompt, type, key, data)
+      case type
+      when /^(weather|forecast)/
+        header prompt
+        @output << data[key].to_markdown
+        hr
+      when /^(int|num)/
+        @output << "#{prompt}: #{data[key]}  " unless data[key].nil?
+      else
+        unless data[key].strip.empty?
+          header prompt
+          @output << data[key]
+        end
+        hr
+      end
+    end
+
+    def to_markdown(yaml: false, title: false, date: false, time: false)
+      @output = []
+
+      if yaml
+        @output << <<~EOYAML
+          ---
+          title: #{@title}
+          date: #{@date.strftime('%x %X')}
+          ---
+
+        EOYAML
+      end
+
+      if title
+        if date || time
+          fmt = ''
+          fmt += '%x' if date
+          fmt += '%X' if time
+          title "#{@title} #{@date.strftime(fmt)}"
+        else
+          title @title
+        end
+      end
+
+      @journal['sections'].each do |s|
+        section s['title']
+
+        s['questions'].each do |q|
+          if q['key'] =~ /\./
+            res = @data[s['key']][:answers].dup
+            keys = q['key'].split(/\./)
+            keys.each_with_index do |key, i|
+              next if i == keys.count - 1
+
+              res = res[key]
+            end
+            print_answer(q['prompt'], q['type'], keys.last, res)
+          else
+            print_answer(q['prompt'], q['type'], q['key'], @data[s['key']][:answers])
+          end
+        end
+      end
+
+      @output.join("\n")
+    end
+
+    def save_data
+      db = File.expand_path("~/.local/share/journal/#{@key}.json")
+      data = if File.exist?(db)
+               JSON.parse(IO.read(db))
+             else
+               []
+             end
+      date = @date.utc
+      output = {}
+
+      @data.each do |k, v|
+        v[:answers].each do |q, a|
+          if a.is_a? Hash
+            output[q] = {}
+            a.each do |key, value|
+              output[q][key] = case value.class.to_s
+                      when /Weather/
+                        { 'high' => value.data[:high], 'low' => value.data[:low], 'condition' => value.data[:condition] }
+                      else
+                        value
+                      end
+            end
+          else
+            output[q] = a
+          end
+        end
+      end
+      data << { 'date' => date, 'data' => output }
+      File.open(db, 'w') { |f| f.puts JSON.pretty_generate(data) }
+    end
+
+    def get_number(prompt, min: 1, max: 5)
+      puts "#{prompt} (#{min}-#{max})"
+      res = `gum input --placeholder "#{prompt} (#{min}-#{max})"`.strip
+      return nil if res.strip.empty?
+
+      res = res.to_i
+
+      res = get_number(prompt, min: min, max: max) if res < min || res > max
+      res
+    end
+
+    def get_line(prompt, add_prompt: nil)
+      output = []
+      puts prompt
+      line = `gum input --placeholder "#{prompt} (blank to end editing)"`
+      return output.join("\n") if line =~ /^ *$/
+
+      output << line
+      output << get_line(add_prompt, add_prompt: add_prompt) if add_prompt
+      output.join("\n")
+    end
+
+    def get_lines(prompt, add_prompt: nil)
+      output = []
+      line = `gum write --placeholder "#{prompt}" --width 80 --char-limit 0`
+      return output.join("\n") if line.strip.empty?
+
+      output << line
+      output << get_lines(add_prompt, add_prompt: add_prompt) if add_prompt
+      output.join("\n")
+    end
+  end
+end

data/lib/journal-cli/data.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Journal
+  # Data handler
+  class Data < Hash
+    attr_reader :questions
+
+    def initialize(questions)
+      @questions = questions
+      super
+    end
+
+    def to_data
+      output = {}
+      @questions.each do |q|
+        output[q['key']] = self[q['key']]
+      end
+      output
+    end
+  end
+end

data/lib/journal-cli/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Journal
+  VERSION = '1.0.4'
+end

data/lib/journal-cli/weather.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Journal
+  class Weather
+    attr_reader :data
+
+    def initialize(api, zip)
+      res = `curl -SsL 'http://api.weatherapi.com/v1/forecast.json?key=#{api}&q=#{zip}&aqi=no'`
+      data = JSON.parse(res)
+
+      raise StandardError, 'invalid JSON response' if data.nil?
+
+      raise StandardError, 'missing conditions' unless data['current']
+
+      curr_temp = data['current']['temp_f']
+      curr_condition = data['current']['condition']['text']
+
+      raise StandardError, 'mising forecast' unless data['forecast']
+
+      forecast = data['forecast']['forecastday'][0]
+
+      day = forecast['date']
+      high = forecast['day']['maxtemp_f']
+      low = forecast['day']['mintemp_f']
+      condition = forecast['day']['condition']['text']
+
+      hours = forecast['hour']
+      temps = [
+        { temp: hours[8]['temp_f'], condition: hours[8]['condition']['text'] },
+        { temp: hours[10]['temp_f'], condition: hours[10]['condition']['text'] },
+        { temp: hours[12]['temp_f'], condition: hours[12]['condition']['text'] },
+        { temp: hours[14]['temp_f'], condition: hours[14]['condition']['text'] },
+        { temp: hours[16]['temp_f'], condition: hours[16]['condition']['text'] },
+        { temp: hours[18]['temp_f'], condition: hours[18]['condition']['text'] },
+        { temp: hours[19]['temp_f'], condition: hours[20]['condition']['text'] }
+      ]
+
+      @data = {
+        day: day,
+        high: high,
+        low: low,
+        temp: curr_temp,
+        condition: condition,
+        current_condition: curr_condition,
+        temps: temps
+      }
+    end
+
+    def to_data
+      {
+        high: high,
+        low: low,
+        condition: curr_condition
+      }
+    end
+
+    def to_markdown
+      output = []
+
+      output << "Forecast for #{@data[:day]}: #{@data[:condition]} #{@data[:high]}/#{@data[:low]}  "
+      output << "Currently: #{@data[:temp]} and #{@data[:current_condition]}"
+      output << ''
+
+      # Hours
+      hours_text = %w[8am 10am 12pm 2pm 4pm 6pm 8pm]
+      step_out = ['|']
+      @data[:temps].each_with_index do |_h, i|
+        width = @data[:temps][i][:condition].length + 1
+        step_out << format("%#{width}s |", hours_text[i])
+      end
+
+      output << step_out.join('')
+
+      # table separator
+      step_out = ['|']
+      @data[:temps].each do |temp|
+        width = temp[:condition].length + 1
+        step_out << "#{'-' * width}-|"
+      end
+
+      output << step_out.join('')
+
+      # Conditions
+      step_out = ['|']
+      @data[:temps].each do |temp|
+        step_out << format(' %s |', temp[:condition])
+      end
+
+      output << step_out.join('')
+
+      # Temps
+      step_out = ['|']
+      @data[:temps].each do |temp|
+        width = temp[:condition].length + 1
+        step_out << format("%#{width}s |", temp[:temp])
+      end
+
+      output << step_out.join('')
+
+      output.join("\n")
+    end
+  end
+end

data/lib/journal-cli.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'shellwords'
+require 'json'
+require 'yaml'
+require 'chronic'
+require 'fileutils'
+
+require_relative "journal-cli/version"
+require_relative "journal-cli/data"
+require_relative "journal-cli/weather"
+require_relative "journal-cli/checkin"