versed 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 59b8a64d63d661969146d5667b97061c8f9950dd
+  data.tar.gz: f4cb1bf662a0724638ccb34c4cbd38ec6260807a
+SHA512:
+  metadata.gz: a854a6542ab4e8ac84675091b70f9f49b126c3d4cbd1303b5ef840b16abd97cda7e891c4c4ecf6b7aa17d454418c248f2be027c457087376b8118fe1d7bea4b4
+  data.tar.gz: cb427eac5343b99ee7510221d239dc4541a6e88ac582e3402c1bb49e7753258cf3c3e55846031cfe8f1527b0fd3c158dd0b341f0c93b5405b62526d5692967d8

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Chris Knadler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# Versed
+
+Versed turns monthly activity logs into a clean visualization of your progress
+against your monthly goals.
+
+## Install
+
+```
+$ gem install versed
+```
+
+## Usage
+
+```
+$ versed -h
+usage: versed [-h] [--version]
+       versed <schedule> <log> [output_path]
+
+    -h, --help                       Print usage information
+        --version                    Print version
+
+Versed takes in a schedule and weekly log (as YAML files) and outputs a
+visualization of time spent this week (in an HTML page).
+```
+
+## Input
+
+```
+# schedule.yaml
+
+Sunday:
+  Task 1: 60 # time in minutes
+
+Monday:
+  Task 1: 60
+  Task 2: 120
+
+Tuesday:
+  Task 2: 60
+  Task 3: 30
+
+Wednesday:
+  Task 1: 30
+  Task 3: 30
+
+Friday:
+  Task 4: 60
+
+```
+
+```
+# log.yaml
+#
+# Note: A log is expected to only contain entries from a single month.
+
+2016.11.01:
+  Task 1: 45
+
+2016.11.02:
+  Task 4: 75
+
+2016.11.03:
+  Task 1: 15
+
+2016.11.04:
+  Task 1: 15
+  Task 3: 60
+
+...
+```
+
+## Output
+
+Versed outputs an HTML page that visualizes the conformance of your logged
+activities to your schedule.
+
+![screen one](assets/screen_one.png)
+![screen two](assets/screen_two.png)
+
+## License
+
+MIT.

data/bin/versed

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "versed/version"
+require "versed/generator"
+
+###
+# help text
+###
+
+BANNER = <<END
+usage: versed [-h] [--version]
+       versed <schedule> <log> [output_path]
+
+END
+
+DESC = <<END
+
+Versed takes in a schedule and weekly log (as YAML files) and outputs a
+visualization of time spent this week (in an HTML page).
+
+See https://github.com/cknadler/versed for more details.
+
+END
+
+###
+# option parsing
+###
+
+opts = OptionParser.new do |o|
+  o.banner = BANNER
+
+  # other
+  o.on("-h", "--help", "Print usage information") do
+    puts o
+    exit
+  end
+  o.on("--version", "Print version") do
+    puts Versed::VERSION
+    exit
+  end
+
+  o.separator DESC
+end
+
+begin
+  opts.parse!
+rescue OptionParser::InvalidOption => e
+  puts e
+  puts opts
+  exit 1
+end
+
+if ARGV.size < 2
+  puts opts
+  puts "Too few arguments." unless ARGV.empty?
+  exit 1
+end
+
+###
+# run
+###
+
+Versed::Generator.run(ARGV[0], ARGV[1], ARGV[2])

data/lib/versed/category.rb

@@ -0,0 +1,44 @@
+require "versed/task"
+
+module Versed
+  class Category
+    attr_reader :id, :tasks
+
+    def initialize(id, date_range)
+      @id = id
+      @tasks = []
+      date_range.each { |date| @tasks << Task.new(id, date) }
+    end
+
+    def incomplete?
+      total_min_incomplete > 0
+    end
+
+    def total_min_scheduled
+      scheduled = 0
+      @tasks.each do |task|
+        next unless task.time_scheduled
+        scheduled += task.time_scheduled
+      end
+      scheduled
+    end
+
+    def total_min_logged
+      logged = 0
+      @tasks.each do |task|
+        next unless task.time_spent
+        logged += task.time_spent
+      end
+      logged
+    end
+
+    def total_min_incomplete
+      incomplete = total_min_scheduled - total_min_logged
+      incomplete >= 0 ? incomplete : 0
+    end
+
+    def percent_incomplete
+      ((total_min_incomplete / total_min_scheduled.to_f) * 100).round(1)
+    end
+  end
+end

data/lib/versed/day.rb

@@ -0,0 +1,47 @@
+require "versed/task"
+
+module Versed
+  class Day
+    attr_reader :date, :tasks
+
+    def initialize(date)
+      @date = date
+      @tasks = []
+    end
+
+    def active?
+      @tasks.each { |t| return true if t.time_spent? }
+      false
+    end
+
+    def time_on_schedule
+      time = 0
+      @tasks.each do |task|
+        next unless task.time_spent? && task.time_scheduled?
+        if task.time_scheduled < task.time_spent
+          time += task.time_scheduled
+        else
+          time += task.time_spent
+        end
+      end
+      time
+    end
+
+    def time_off_schedule
+      time = 0
+      @tasks.each do |task|
+        next unless task.time_spent
+        if !task.time_scheduled
+          time += task.time_spent
+        elsif task.time_scheduled < task.time_spent
+          time += task.time_spent - task.time_scheduled
+        end
+      end
+      time
+    end
+
+    def time_scheduled
+      @tasks.collect { |t| t.time_scheduled? ? t.time_scheduled : 0 }.reduce(0, :+)
+    end
+  end
+end

data/lib/versed/generator.rb

@@ -0,0 +1,62 @@
+require "mustache"
+require "versed/reader"
+require "versed/schedule"
+require "versed/schedule_view"
+
+module Versed
+  module Generator
+
+    # The CLI entry point for the Versed program. Parses the input files, parses
+    # the content into task objects, generates the visualization HTML and
+    # converts the HTML to a PDF.
+    def self.run(schedule_path, log_path, output_path)
+      # read in input
+      raw_schedule = Versed::Reader.read(schedule_path)
+      raw_log = Versed::Reader.read(log_path)
+
+      # determine date range
+      origin = Date.parse(raw_log.keys[0])
+      start_date = Date.new(origin.year, origin.month, 1)
+      end_date = Date.new(origin.year, origin.month, -1)
+      date_range = start_date..end_date
+      validate_log(raw_log, date_range)
+
+      # map model and view model
+      schedule = Versed::Schedule.new(raw_schedule, raw_log, date_range)
+      schedule_view = Versed::ScheduleView.new(schedule)
+
+      # make HTML page
+      templates_path = File.expand_path(File.join(__FILE__, "../../../templates"))
+      Mustache.template_path = templates_path
+      main_template_path = File.join(templates_path, "page.mustache")
+      html = Mustache.render(IO.read(main_template_path), schedule_view.to_hash)
+
+      # determine output path
+      output_path = Dir.pwd unless output_path
+      output_path = File.expand_path(output_path)
+      if File.directory?(output_path)
+        file_name = schedule.days[0].date.strftime("%Y-%m.html")
+        output_path = File.join(output_path, file_name)
+      end
+
+      # output
+      file = File.open(output_path, "w")
+      file << html
+      file.close
+    end
+
+    private
+
+    def self.validate_log(raw_log, date_range)
+      raw_log.keys.each do |raw_day|
+        day = Date.parse(raw_day)
+        unless date_range.include?(day)
+          puts "Days from multiple months present."
+          puts "#{day} not present in #{date_range}"
+          puts "Ensure log only contains days from one calendar month."
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/versed/reader.rb

@@ -0,0 +1,22 @@
+require 'yaml'
+
+module Versed
+  module Reader
+
+    # Reads YAML from a file
+    # @param path [String] The path to the file
+    # @return [Hash] The parsed YAML file
+    def self.read(path)
+      begin
+        return YAML.load(IO.read(path))
+      rescue YAML::Error => e
+        puts "Encountered an error reading YAML from #{path}"
+        puts e.message
+        exit 1
+      rescue StandardError => e
+        puts e.message
+        exit 1
+      end
+    end
+  end
+end

data/lib/versed/schedule.rb

@@ -0,0 +1,98 @@
+require "versed/category"
+require "versed/day"
+
+module Versed
+  class Schedule
+    attr_reader :days, :categories
+
+    def initialize(raw_schedule, raw_log, date_range)
+      @date_range = date_range
+      map_categories(raw_schedule, raw_log)
+      map_days
+      map_time_scheduled(raw_schedule)
+      map_time_spent(raw_log)
+    end
+
+    def categories
+      @categories.values
+    end
+
+    # Returns an array of incomplete tasks. This array is sorted first by
+    # percentage incomplete, then by total number of minutes incomplete.
+    def incomplete_tasks
+      # TODO: refactor with reject
+      incomplete = []
+      categories.each { |c| incomplete << c if c.incomplete? }
+      incomplete.sort_by { |c| [-c.percent_incomplete, -c.total_min_incomplete] }
+    end
+
+    private
+
+    def map_categories(raw_schedule, raw_log)
+      @categories = {}
+      (category_ids(raw_schedule) + category_ids(raw_log)).uniq.sort.each do |id|
+        @categories[id] = Versed::Category.new(id, @date_range)
+      end
+    end
+
+    def map_days
+      @days = []
+      @date_range.each { |d| @days << Day.new(d) }
+
+      # map category tasks to days
+      categories.each do |category|
+        category.tasks.each_with_index do |task, index|
+          @days[index].tasks << task
+        end
+      end
+    end
+
+    def map_time_scheduled(raw_schedule)
+      @days.each_with_index do |day, day_id|
+        schedule_day = raw_schedule[Date::DAYNAMES[day.date.wday]]
+        next unless schedule_day
+
+        schedule_day.each do |scheduled_task_name, time_scheduled|
+          category = lookup_category(scheduled_task_name)
+          category.tasks[day_id].time_scheduled = time_scheduled
+        end
+      end
+    end
+
+    def map_time_spent(raw_log)
+      raw_log.each do |day, tasks|
+        day_id = Date.parse(day).mday - 1
+
+        tasks.each do |log_task_name, time_spent|
+          category = lookup_category(log_task_name)
+          assert(category, "Any category here should have been in the log or schedule.")
+          category.tasks[day_id].time_spent = time_spent
+        end
+      end
+    end
+
+    # Finds the category object for the given category id
+    # @param id [String] A category id
+    # @return [Category] The category object matching the id
+    def lookup_category(id)
+      category = @categories[id]
+      unless category
+        puts "Unrecognized category id: #{id}"
+        exit 1
+      end
+      category
+    end
+
+
+    # Finds all unique category ids in a log or a schedule
+    # @param entries [Hash] A parsed log or schedule
+    # @return [Array, String] Unique category ids
+    def category_ids(entries)
+      category_ids = []
+      entries.each do |day, tasks|
+        category_ids += tasks.keys
+      end
+      category_ids.uniq
+    end
+  end
+end

data/lib/versed/schedule_view.rb

@@ -0,0 +1,181 @@
+require "versed/schedule"
+
+module Versed
+  class ScheduleView
+
+    DAYS_PER_ROW = 8
+
+    def initialize(schedule)
+      @schedule = schedule
+    end
+
+    def to_hash
+      hash = {
+        "sections" => [],
+        "metadata" => metadata,
+        "incomplete_tasks" => incomplete_tasks
+      }
+
+      # fill in days
+      section = nil
+      @schedule.days.each_with_index do |day, day_id|
+        if day_id % DAYS_PER_ROW == 0
+          section = {
+            "days" => [],
+            "categories" => []
+          }
+          hash["sections"] << section
+        end
+
+        section["days"] << day.date.strftime("%m.%d")
+      end
+
+      # determine row date ranges
+      day_ranges = []
+      day_max = @schedule.days.size - 1
+      start_date = 0
+      while start_date <= day_max
+        end_date = [start_date + DAYS_PER_ROW - 1, day_max].min
+        day_ranges << (start_date..end_date)
+        start_date = end_date + 1
+      end
+
+      # fill in categories and tasks
+      @schedule.categories.each do |category|
+        day_ranges.each_with_index do |range, section_index|
+          hash["sections"][section_index]["categories"] << category_hash(category, range)
+        end
+      end
+
+      # create header
+      origin = @schedule.days.first.date
+      hash["header"] = "#{Date::MONTHNAMES[origin.month]} #{origin.year}"
+      hash["sub_header"] = "Generated on #{Date.today}"
+
+      hash
+    end
+
+    private
+
+    ###
+    # model hashes
+    ###
+
+    def category_hash(category, day_range)
+      hash = {
+        "id" => category.id,
+        "tasks" => []
+      }
+
+      category.tasks[day_range].each do |task|
+        hash["tasks"] << task.to_hash
+      end
+
+      hash
+    end
+
+    ###
+    # metadata
+    ###
+
+    def metadata
+      [
+        {
+          "id" => "Days Active",
+          "value" => "#{days_active} (#{days_active_percent}%)"
+        },
+        {
+          "id" => "Time Logged",
+          "value" => "#{total_min_logged} min (#{total_hr_logged} hr)"
+        },
+        {
+          "id" => "Time Logged Per Day",
+          "value" => "#{min_logged_per_day} min (#{hr_logged_per_day} hr)"
+        },
+        {
+          "id" => "Completed",
+          "value" => "#{total_min_logged_on_schedule} / #{total_min_scheduled} (#{completed_percent}%)"
+        },
+        {
+          "id" => "Off Schedule",
+          "value" => "#{total_min_logged_off_schedule} / #{total_min_logged} (#{off_schedule_percent}%)"
+        }
+      ]
+    end
+
+    def days_past
+      @days_past ||= @schedule.days.reject { |day| day.date >= Date.today }
+    end
+
+    def days_active
+      days_past.count { |d| d.active? }
+    end
+
+    def days_active_percent
+      percent(days_active, days_past.size)
+    end
+
+    def total_min_logged
+      total_min_logged_on_schedule + total_min_logged_off_schedule
+    end
+
+    def total_min_logged_on_schedule
+      days_past.collect { |d| d.time_on_schedule }.reduce(0, :+)
+    end
+
+    def total_min_logged_off_schedule
+      days_past.collect { |d| d.time_off_schedule }.reduce(0, :+)
+    end
+
+    def total_hr_logged
+      divide(total_min_logged, 60)
+    end
+
+    def min_logged_per_day
+      divide(total_min_logged, days_past.size)
+    end
+
+    def hr_logged_per_day
+      divide(min_logged_per_day, 60)
+    end
+
+    def total_min_scheduled
+      days_past.collect { |d| d.time_scheduled }.reduce(0, :+)
+    end
+
+    def completed_percent
+      percent(total_min_logged_on_schedule, total_min_scheduled)
+    end
+
+    def off_schedule_percent
+      percent(total_min_logged_off_schedule, total_min_logged)
+    end
+
+    ###
+    # Incompmlete Tasks
+    ###
+
+    def incomplete_tasks
+      top_tasks = []
+      @schedule.incomplete_tasks.each do |category|
+        hash = {}
+        hash["id"] = category.id
+        hash["value"] = "#{category.total_min_logged} / #{category.total_min_scheduled} (-#{category.percent_incomplete}%)"
+        top_tasks << hash
+      end
+      top_tasks
+    end
+
+    ###
+    # General
+    ###
+
+    def percent(a, b)
+      ((a / b.to_f) * 100).round(1)
+    end
+
+    def divide(a, b)
+      (a / b.to_f).round(1)
+    end
+  end
+end

data/lib/versed/task.rb

@@ -0,0 +1,55 @@
+module Versed
+  class Task
+    attr_accessor :category_id, :time_spent, :time_scheduled, :date
+
+    def initialize(category_id, date)
+      @category_id = category_id
+      @date = date
+    end
+
+    def to_hash
+      {
+        "time_spent" => self.time_spent.to_s,
+        "time_scheduled" => self.time_scheduled.to_s,
+        "style" => style
+      }
+    end
+
+    def time_spent
+      Date.today > self.date ? @time_spent : nil
+    end
+
+    def time_scheduled
+      Date.today > self.date ? @time_scheduled : nil
+    end
+
+    def time_spent?
+      self.time_spent && self.time_spent > 0
+    end
+
+    def time_scheduled?
+      self.time_scheduled && self.time_scheduled > 0
+    end
+
+    private
+
+    DANGER_STYLE = "danger"
+    WARN_STYLE = "warning"
+    SUCCESS_STYLE = "success"
+    ACTIVE_STYLE = "active"
+
+    def style
+      return ACTIVE_STYLE if self.date >= Date.today
+
+      return unless self.time_scheduled && self.time_scheduled > 0
+
+      if !self.time_spent || self.time_spent <= 0
+        return DANGER_STYLE
+      elsif self.time_spent < self.time_scheduled
+        return WARN_STYLE
+      else
+        return SUCCESS_STYLE
+      end
+    end
+  end
+end

data/lib/versed/version.rb

@@ -0,0 +1,3 @@
+module Versed
+    VERSION = "0.1.0"
+end

data/templates/incomplete_table.mustache

@@ -0,0 +1,10 @@
+<h4>Incomplete Tasks</h4>
+
+<table class="table table-bordered table-condensed">
+    {{#incomplete_tasks}}
+    <tr>
+        <th scope="row" class="active">{{id}}</th>
+        <td>{{value}}</td>
+    </tr>
+    {{/incomplete_tasks}}
+</table>

data/templates/meta_table.mustache

@@ -0,0 +1,14 @@
+<table class="table table-bordered table-condensed">
+    <thead>
+        <tr class="active">
+            {{#metadata}}
+            <th>{{id}}</th>
+            {{/metadata}}
+        </tr>
+    <thead/>
+    <tr>
+        {{#metadata}}
+        <td>{{value}}</td>
+        {{/metadata}}
+    </tr>
+</table>

data/templates/page.mustache

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <!-- bootstrap cdn ref -->
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
+</head>
+
+<h1>{{header}}</h1>
+
+<p><em>{{sub_header}}</em></p>
+
+{{> week_table}}
+
+{{> meta_table}}
+
+{{> incomplete_table}}
+
+</html>

data/templates/week_table.mustache

@@ -0,0 +1,21 @@
+{{#sections}}
+<table class="table table-bordered table-condensed">
+	<thead>
+		<tr class="active">
+			<th></th>
+			{{#days}}
+			<th>{{.}}</th>
+			{{/days}}
+		</tr>
+	</thead>
+
+  {{#categories}}
+  <tr>
+    <th scope="row" class="active">{{id}}</th>
+    {{#tasks}}
+    <td class="{{style}}">{{time_spent}}</td>
+    {{/tasks}}
+  </tr>
+  {{/categories}}
+</table>
+{{/sections}}

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: versed
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Knadler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Versed helps you visualize your progress against your scheduled weekly
+  routine.
+email: takeshi91k@gmail.com
+executables:
+- versed
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- LICENSE
+- README.md
+- bin/versed
+- lib/versed/category.rb
+- lib/versed/day.rb
+- lib/versed/generator.rb
+- lib/versed/reader.rb
+- lib/versed/schedule.rb
+- lib/versed/schedule_view.rb
+- lib/versed/task.rb
+- lib/versed/version.rb
+- templates/incomplete_table.mustache
+- templates/meta_table.mustache
+- templates/page.mustache
+- templates/week_table.mustache
+homepage: https://github.com/cknadler/versed
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Visualize routine adherence and track progress
+test_files: []