kielce 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38341d1480aea6176a4d3d289f543a82c6846464268057cce43704b0c04fe811
+  data.tar.gz: 711eca88ec683a63c017c326ff9169e5c14f8456cc91a499cac68ce77071b79c
+SHA512:
+  metadata.gz: 9359354d455c3e81e46d57f5a59da179137d60c016544cf57887677f67f5da578ccccf2e720a1c007703ddeaab093cd8c1403f417c947775220386722c9311ea
+  data.tar.gz: b62f1d98c6309e32e4b97f26337c4538b8ed6e4b750bd399fc61d925768ce0e4f1b451f3542c40d9d3c92f69afc9807e972d7a177a2611137d2b5bfdd31757d6

data/bin/kielce

@@ -0,0 +1,4 @@
+#! /usr/bin/env ruby
+
+require 'kielce'
+Kielce::run

data/lib/kielce.rb

@@ -0,0 +1,87 @@
+require "optparse"
+
+require "kielce/helpers"
+require "kielce/kielce_data"
+require "kielce/kielce_loader"
+require "kielce/kielce"
+
+##############################################################################################
+#
+# Main (the run method)
+#
+# (c) 2020 Zachary Kurmas
+#
+##############################################################################################
+
+module Kielce
+  VERSION = "2.0.0"
+
+  def self.run
+
+    # TODO:
+    #idea:  If 1 param:  Assume input and stdout
+    #       If 2 params and 2nd param is file, assume input and output
+    #       If 2+ params and 2nd param is dir, then process all files.  Place in output dir.  remove.erb from filename.
+
+    options = {
+      quiet: false,
+    }
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: kielce [options]"
+
+      opts.on("-q", "--[no-]quiet", "Run quietly") do |q|
+        options[:quiet] = q
+      end
+    end.parse!
+
+    $stderr.puts "KielceRB (version #{VERSION})" unless options[:quiet]
+
+    if ARGV.length == 0
+      $stderr.puts "Usage: kielce file_to_process"
+      exit
+    end
+
+    #
+    # Get to work
+    #
+
+    file = ARGV[0]
+    $stderr.puts "Processing #{file}" unless options[:quiet]
+
+    # We use global variables $d and $k to make the data and +Kielce+ objects available to the
+    # ERB template engine.  There was a bit of debate about this decision.  The most popular
+    # alternative was to create a class named +DataContext+ with +data+ and +kielce+ accessors.
+    #
+    # Advantages to using global variables:
+    # (1) The resulting names were short (two characters) and eye-catching (because the first
+    #     character is '$')
+    # (2) It keeps the design simpler by eliminating the need for an additional +DataContext+ class.
+    # (3) Users can create a custom class to use as a context without worring about conforiming to
+    #     any specific interface
+    #
+    # Advantages to using a special +DataContext+ class:
+    # (1) Avoids polluting the global namespace.
+
+    begin
+      context = Object.new
+      $d = KielceLoader.load(file, context: context)
+      $k = Kielce.new(context)
+      result = $k.render(file) 
+      puts result if $k.error_count == 0
+    rescue LoadingError => e
+      $stderr.puts e.message
+      exit 1
+    rescue IncompleteRenderError => e2
+      part2 = e2.source_file.nil? ? "" : "(included from #{e2.source_file})"
+      $stderr.puts "ERROR: Unable to read #{e2.file_name} #{part2}"
+      $stderr.puts "\t(#{e2.source_exception})"
+      exit 1
+    end
+    exit $k.error_count == 0 ? 0 : 1
+  end
+end
+
+# For now, we just require all plugins here.  Should we ever get to the point where there
+# are enough plugins to cause a performance issue, we can do something more clever.
+# require_relative 'kielce_plugins/schedule'

data/lib/kielce/helpers.rb

@@ -0,0 +1,29 @@
+##############################################################################################
+#
+# Helpers
+#
+# (c) 2020 Zachary Kurmas
+#
+##############################################################################################
+
+class ::String
+  def link(text = nil)
+    $k.link(self, text)
+    #%Q(<a href="#{self}">#{text}</a>)
+  end
+end
+
+class ::Hash
+  # Merges two hashes recursively.  Specificaly, if the value of one item in the hash is itself a hash,
+  # merge that nested hash.
+  #
+  # Hash#merge by default returns a new Hash containing the key/value pairs of both hashes.
+  # If a key appears in both "self" and "second", the value in "second" takes precedence.
+  # Alternately, you can specify a block to be called if a key appears in both Hashes.
+  # The "merger" lambda below merges two nested hashes instead of simply choosing the version in 
+  # "second"
+  def deep_merge(second)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge(second, &merger)
+  end
+end

data/lib/kielce/kielce.rb

@@ -0,0 +1,113 @@
+##############################################################################################
+#
+# Kielce
+#
+# Convenience methods available within the ERB templates.
+#
+# (c) 2020 Zachary Kurmas
+#
+##############################################################################################
+
+require "erb"
+
+module Kielce
+  class IncompleteRenderError < StandardError
+    attr_accessor :file_name, :source_file, :source_exception
+
+    def initialize(file_to_load, source, ex)
+      @file_name = file_to_load
+      @source_file = source
+      @source_exception = ex
+    end
+  end
+
+  class Kielce
+    attr_reader :error_count
+    @@render_count = 0
+
+    # Constructor
+    #
+    # @param context default context to use when calling +render+
+    def initialize(context)
+      @data_context = context
+      @error_count = 0
+      @file_stack = []
+    end
+
+    # Generate an +href+ tag.
+    #
+    # This could be a class method.  We make it
+    # an instance method so it can be used using the "$k.link" syntax.
+    def link(url, text_param = nil, code: nil, classes: nil)
+      class_list = classes.nil? ? "" : " class='#{classes}'"
+
+      # Make the text the same as the URL if no text given
+      text = text_param.nil? ? url : text_param
+
+      # use <code> if either (1) user requests it, or (2) no text_param given and no code param given
+      text = "<code>#{text}</code>" if code || (text_param.nil? && code.nil?)
+
+      "<a href='#{url}'#{class_list}>#{text}</a>"
+    end
+
+    # Load +file+ and run ERB.  The binding parameter determines
+    # the context the .erb code runs in.  The context determines
+    # the variables and methods available.  By default, kielce
+    # uses the same context for loading and rendering.  However,
+    # users can override this behavior by providing different contexts
+    #
+    #
+    # @param the file
+    # @param b the binding that the template code runs in.
+    # @return a +String+ containing the rendered contents
+    def render(file, local_variables = {}, b = @data_context.instance_exec { binding })
+
+      local_variables.each_pair do |key, value|
+        b.local_variable_set(key, value)
+      end
+
+      # $stderr.puts "In render: #{b.inspect}"
+      result = "<!--- ERROR -->"
+
+      begin
+        content = File.read(file)
+      rescue Errno::ENOENT => e
+        # TODO Consider using e.backtrace_locations instead of @file_stack
+        # (Question: What exaclty do you want to see if render_relative is called
+        # by a method)
+        raise IncompleteRenderError.new(file, @file_stack.last, e)
+      end
+      @file_stack.push(file)
+
+      # The two nil parameters below are legacy settings that don't
+      # apply to Kielce.  nil is the default value.  We must specify
+      # nil, so we can set the fourth parameter (described below).
+      #
+      # It is possible for code inside an erb file to load and render
+      # another erb template.  In order for such nested calls to work
+      # properly, each call must have a unique variable in which to
+      # store its output.  This parameter is called "eoutvar". (If you
+      # don't specifiy eoutvar and make a nested call, the output
+      # can get messed up.)
+      @@render_count += 1
+
+      begin
+        erb = ERB.new(content, nil, nil, "render_out_#{@@render_count}")
+        erb.filename = file.to_s
+        result = erb.result(b)
+      rescue NoKeyError => e
+        line_num = e.backtrace_locations.select { |i| i.path == file }.first.lineno
+        $stderr.puts "Unrecognized key #{e.name} at #{file}:#{line_num}"
+        @error_count += 1
+      ensure
+        @file_stack.pop
+      end
+      result
+    end
+
+    def render_relative(file, local_variables = {}, b = @data_context.instance_exec { binding })
+      path = Pathname.new(File.absolute_path(@file_stack.last)).dirname
+      render(path.join(file), local_variables, b)
+    end
+  end
+end

data/lib/kielce/kielce_data.rb

@@ -0,0 +1,151 @@
+##############################################################################################
+#
+# KielceData
+#
+# An object representing the data loaded from the various Kielce data files.
+# The files return a Hash:  a set of key-value pairs.
+# +KielceData+ allows users to access the data using the more convenient method syntax (i.e.,
+# $d.itemName instead of $d[:itemName] or $d['itemName])
+# +KielceData+ is a child of +BasicObject+ instead of +Object+ so that there aren't conflicts
+# with methods defined on +Object+ and +Kernel+ (+freeze+, +method+, +trust+, etc. )
+#
+# For convenience, +KielceData+ does provide a few key methods including +is_a+ and +inspect+
+#
+# (c) 2020 Zachary Kurmas
+#
+##############################################################################################
+
+module Kielce
+  class NoKeyError < ::NameError
+  end
+
+  class InvalidKeyError < ::NameError
+  end
+
+  INVALID_KEYS =  [:root, :method_missing, :inspect]
+
+  # Access KielceData instance variables.
+  # (We don't want public accessors on the KielceData object because the name
+  # we choose may potentially conflict with user data.)
+  class KielceDataAnalyzer
+    class << self
+      def root(obj)
+        obj.instance_eval { @xx_kielce_root }
+      end
+
+      def name(obj)
+        obj.instance_eval { @xx_kielce_obj_name }
+      end
+
+      def data(obj)
+        obj.instance_eval { @xx_kielce_data }
+      end
+    end
+  end
+
+  # By extending BasicObject instead of Object, we don't have to worry
+  # about user data conflicting with method names in Object or Kernel
+  #
+  # @xx_kielce_data is the hash passed to the constructor.
+  # @xx_kielce_obj_name is the key that maps to the value.
+  # @xx_kielce_root refers to the root object.  It is used so that lambdas have access to
+  # the data.
+  #
+  # (The strange "xx_kielce_" naming is to avoid conflicts with user-chosen names)
+  class KielceData < BasicObject
+    @@error_output = $stderr
+
+    def self.error_output
+      @@error_output
+    end
+
+    def self.error_output=(val)
+      @@error_output=val
+    end
+
+    def initialize(data, root = nil, obj_name = nil)
+      
+      INVALID_KEYS.each do |key|
+        ::Kernel.send(:raise, InvalidKeyError.new("Invalid Key: #{key} may not be used as a key.", key)) if data.has_key?(key)
+      end
+
+      @xx_kielce_obj_name = obj_name.nil? ? "" : obj_name
+
+      @xx_kielce_data = data
+
+      # Remember, root may be a BasicObject and, therefore, not define .nil
+      @xx_kielce_root = (root == nil) ? self : root
+
+      @xx_kielce_data.each do |key, value|
+        if value.is_a?(::Hash)
+          @xx_kielce_data[key] = ::Kielce::KielceData.new(value, @xx_kielce_root, "#{@xx_kielce_obj_name}#{key}.")
+        end
+      end
+    end
+
+    def root
+      @xx_kielce_root
+    end
+
+    def inspect
+      "KielceData: #{@xx_kielce_obj_name} #{@xx_kielce_data.inspect}"
+    end
+
+    def is_a?(klass)
+      klass == ::Kielce::KielceData
+    end
+
+    # Provides the "magic" that allows users to access data using method syntax.
+    # This method is called whenever a method that doesn't exist is invoked.  It
+    # then looks through the hash for a key with the same name as the method.
+    def method_missing(name, *args, **keyword_args, &block)
+
+      # $stderr.puts "Processing #{name} in #{@xx_kielce_obj_name}"
+
+      # Convert the name to a symbol. (It is probably already a symbol, but the extra .to_sym won't hurt)
+      # Then complian if there isn't a data object by that name.
+      name_sym = name.to_sym
+      full_name = "#{@xx_kielce_obj_name}#{name}"
+      unless @xx_kielce_data.has_key?(name_sym)
+        # The first ("message") parameter is currently unused.  The message can be changed, if desired.
+        ::Kernel.send(:raise, NoKeyError.new("Unrecognized Key: #{full_name}", full_name))
+      end
+
+      # Get the requested data object.
+      # If the object is a lambda, execute the lambda.
+      # Otherwise, just return it.
+      item = @xx_kielce_data[name_sym]
+      if item.is_a?(::Proc)
+        if item.parameters.any? { |i| i.last == :root }
+          @@error_output.puts 'WARNING! Lambda parameter named root shadows instance method root.'
+        end
+
+        #$stderr.puts item.parameters.inspect
+        keyword_params = item.parameters.select { |i| i.first == :keyreq || i.first == :key }
+        num_keyword = keyword_params.size
+        num_args = item.parameters.size - num_keyword
+
+        #$stderr.puts "-----------"
+        #$stderr.puts args.inspect
+        #$stderr.puts keyword_args.inspect
+        #$stderr.puts "Num each: #{num_args} #{num_keyword}"
+
+        if num_args == 0 && num_keyword == 0
+          return instance_exec(&item)
+        elsif num_args > 0 && num_keyword == 0
+          return instance_exec(*args, &item)
+        elsif num_keyword > 0
+          return instance_exec(*args, **keyword_args, &item)
+        else
+          $stderr.puts "FAIL.  Shouldn't get here!"
+        end
+      end
+
+      if args.length != 0 || keyword_args.size != 0
+        @@error_output.puts "WARNING! #{full_name} is not a function and doesn't expect parameters."
+      end
+
+      @xx_kielce_data[name_sym]
+    end
+  end # class
+end # module

data/lib/kielce/kielce_loader.rb

@@ -0,0 +1,144 @@
+##############################################################################################
+#
+# KielceLoader
+#
+# Methods to find and load Kielce data files.
+#
+# (c) 2020 Zachary Kurmas
+#
+##############################################################################################
+
+require 'pathname'
+
+module Kielce
+
+  class LoadingError < StandardError
+  end
+
+  class KielceLoader
+
+    # Load the kielce_data_*.rb files beginning from the directory that contains +start+.
+    #
+    # @param start the name of the file in the directory where the search for data files should begin
+    # @param current the current data object (which may contain data loaded from other files)
+    # @param context the context in which the data files will be executed.
+    # @return a +KielceData+ object containing the collective merged data from all kielce data files.
+    #
+    # Notice that +start+ need not be either a directory or a data file.  Instead we use
+    # +start+'s full pathname to identify the directory where we will begin our search.
+    # We allow +start+ to be any file because, in most cases, it is simply the .erb file
+    # being processed -- thus, it's easiest/cleaner for the user to pass this filename
+    # as a parameter rather than convert it to a starting directory first.
+    #
+    def self.load(start, current: {}, context: Object.new, stop_dir: nil)
+      # File.absolute_path returns a String.  We need a full Pathname object.
+      stop_path = nil
+      stop_path = Pathname.new(File.absolute_path(stop_dir)) unless stop_dir.nil?
+      start_path = Pathname.new(File.absolute_path(start))
+      start_path = start_path.parent unless start_path.directory?
+      KielceData.new(load_directory_raw(start_path, current: current, context: context, stop_dir: stop_path))
+    end
+
+    # loads a kielce_data_*.rb file and returns the file's raw data (the plain Ruby Hash)
+    #
+    # @param file the file to load
+    # @param current the current data object (which may contain data loaded from other files)
+    # @param context the context in which to execute the data file's code
+    # @return the updated data object.
+    #
+    def self.load_file_raw(file, current: {}, context: Object.new)
+      #$stderr.puts "Processing #{file}"
+
+      # (1) Kielce data files are assumed to return a single Hash.
+      # (2) The second parameter to eval, the "binding", is an object
+      #     describing the context the code being evaluated will run in.
+      #     Among other things, this context determines the local variables
+      #     and methods avaiable to the code being evaluated.  In order to
+      #     prevent data files from manipuating this KielceLoader object this 
+      #     method's local variables, we create an empty object and use its 
+      #     binding. Note, however, that the code can still read and set global 
+      #     variables. Users can also provide a different, custom, context object.
+      # (3) To get the correct binding, we need to run the call to +binding+ 
+      #     in the context of an instance method on the context object.
+      #     The "obvious" way to do this is to add a method to the object
+      #     that calls and returns binding.  We decided not to do this for 
+      #     two reasons:  (a) We didn't want to add any methods to the context object
+      #     that may possibly conflict with the names chosen by users in the data
+      #     files, and (b) Object is the default object used for context; but
+      #     in theory, users of the library could chose a different object. We didn't want
+      #     our chosen name to conflict with a method that may already exist on the user's
+      #     chose context object.
+      # (4) The third parameter, +file+, allows Ruby to identify the source of any
+      #     errors encountered during the evaluation process.
+      b = context.instance_eval { binding }
+      data = eval File.read(file), b, file
+      #$stderr.puts "Current is #{current}"
+      #$stderr.puts "Data is #{data}"
+
+      # If the file is empty, or has a nil return, just use an empty hash
+      data = {} if data.nil?
+
+      unless data.is_a?(Hash)
+        raise LoadingError, "ERROR: Data file #{file} did not return a Hash.  It returned #{data.inspect}."
+        # $stderr.puts "ERROR: Datafile #{file} did not return a Hash.  It returned \"#{data.inspect}\"."
+        exit 0
+      end
+
+      # These INVALID_KEYS correspond to methods on the KielceData object.  
+      # These keys would be shadowed by these methods and produce strange errors.
+      # From a design perspective, I would prefer to do this check inside the KielceData class; but,
+      # at that point it's no longer possible to determine which file contained the invalid key.
+      # Thus, but repeating the check here, we can provide a better error message to the user.
+      INVALID_KEYS.each do |key|
+        if data.has_key?(key)
+          raise LoadingError, "ERROR: Data file #{file} uses the key \"#{key}\", which is not allowed."
+          exit 0
+        end
+      end
+
+
+      # The deep_merge method will use the data from +data+ in the event of duplicate keys.
+      # helpers.rb opens the Hash class and adds this method.
+      x = current.deep_merge(data)
+      #$stderr.puts "Post-merge is #{x}"
+      x
+    end
+
+    #
+    # Search +dir+ and all parent directories for kielce data files, load them, and
+    # return the raw Hash containing the collective datqa.
+    #
+    # @param dir the directory to search (as a +Pathname+ object)
+    # @param current the current data object
+    # @param context the context in which to execute the data files' code
+    # @pram stop_dir the last (highest-level) directory to examine (as a +Pathname+ object)
+    # @return the updated "raw" data object (i.e., the raw Hash)
+    def self.load_directory_raw(dir, current: {}, context: Object.new, stop_dir: nil)
+
+      # $stderr.puts "Done yet? #{File.absolute_path(dir)} #{File.absolute_path(stop_dir)}"
+
+      # recurse until you get to either the "stop directory" or the root of the filesystem.
+      # beginning from the root of the file system means that entries "closer" to the
+      # file being processed replace entries higher up in the file system.
+      # unless File.absolute_path(dir) == File.absolute_path(stop_dir) || dir.root?
+      unless (!stop_dir.nil? && (dir.realpath == stop_dir.realpath)) || dir.realpath.root?
+        current = load_directory_raw(dir.parent, current: current, context: context, stop_dir: stop_dir)
+      end
+
+      # By default, process all files fitting the pattern kielce_data*.rb
+      # In addition, look in directories named KielceData for files matching the pattern.
+      # (The use of KielceData directories allows users to gather multiple data files up and
+      # place them "out of sight")
+      # +dir+ is a +pathname+ object.  By placing it in a string interpolation, it is coverted to 
+      # a +String+ using +Pathname#to_s+.  
+      # On occasion, +dir+ may actually be regular file instead of a directory.  In such cases, the
+      # glob below will simply fail to match anything.
+      # QZ001
+      data = Dir.glob("#{dir}/KielceData/kielce_data*.rb") + Dir.glob("#{dir}/kielce_data*.rb")
+      data.each do |file|
+        current = load_file_raw(file, current: current, context: context)
+      end
+      current
+    end
+  end # class
+end # module

data/lib/kielce_plugins/schedule.rb

@@ -0,0 +1,9 @@
+
+require_relative './schedule/schedule'
+require_relative './schedule/assignment'
+
+module KielcePlugins
+  module Schedule
+    VERSION = '0.1'
+  end
+end

data/lib/kielce_plugins/schedule/#schedule.rb#

@@ -0,0 +1,320 @@
+require 'rubyXL'
+require_relative 'assignment'
+
+# https://www.ablebits.com/office-addins-blog/2015/03/11/change-date-format-excel/
+
+module KielcePlugins
+  module Schedule
+
+    class Schedule
+
+      #SCHEDULE_KEYS = [:week, :date, :topics, :notes, :reading, :milestones, :comments]
+      SCHEDULE_KEYS = [:week, :date, :topics, :reading, :milestones, :comments]
+
+      attr_accessor :assignments, :schedule_days
+
+      def initialize(filename)
+        workbook = RubyXL::Parser.parse(filename)
+        @assignments = build_assignments(build_rows(workbook['Assignments'], Assignment::ASSIGNMENT_KEYS))
+        @schedule_days = build_schedule_days(build_rows(workbook['Schedule'], SCHEDULE_KEYS))
+      end
+
+      def transform(value)
+        if value.is_a? String
+          # Replace link markup
+          value.gsub!(/\[\[([^\s]+)(\s+(\S.*)|\s*)\]\]/) do
+            text = $3.nil? ? "<code>#{$1}</code>" : $3
+            "<a href='#{$1}'>#{text}</a>"
+          end
+
+          value.gsub!(/<<(assign|due)\s+(\S.+)>>/) do
+            #$stderr.puts "Found assignment ref #{$1} --- #{$2} -- #{@assignments[$2].inspect}"
+            $stderr.puts "Assignment #{$2} not found" unless @assignments.has_key?($2)
+
+            text = @assignments[$2].title(:full, true)
+            if $1 == 'assign'
+              "Assign #{text}"
+            elsif $1 == 'due'
+              "<b>Due</b> #{text}"
+            else
+              $stderr.puts "Unexpected match #{$1}"
+            end
+          end # end gsub!
+
+          value.gsub!(/{{([^{}:]+):\s*([^{}]+)}}/) do
+              text = $1
+              link_rule = $2
+
+              if (link_rule =~ /(.*)\!(.+)/)
+                method = $1
+                param = $2
+             
+                method = 'default' if method.empty?  
+                #$stderr.puts "Found link rule  =>#{method}<= #{method.empty?} =>#{param}<="
+
+                link = $d.course.notesTemplates.method_missing(method, param)                
+              else
+                link = link_rule
+              end                            
+              "(<a href='#{link}'>#{text}</a>)"
+          end # end gsub
+
+        end # end if value is string
+        value
+      end
+
+      def build_rows(worksheet, keys)
+        # Remove the first (header) row, and any empty rows.
+        # Also, remove any rows after "END"
+        first = true
+        done = false
+        rows = []
+        worksheet.each do |row|
+          done = true if !row.nil? && !row[0].nil? && row[0].value == "END"
+
+          unless first || row.nil? || done
+            rows << row
+          end
+          first = false
+        end
+
+        # For each row, build a Hash describing the row.
+        rows.map do |row|
+          row_hash = { original: {} }
+          keys.each_with_index do |item, index|
+            row_hash[:original][item] = row[index].nil? ? nil : row[index].value
+            row_hash[item] = row[index].nil? ? nil : transform(row[index].value)
+          end
+          row_hash
+        end # end map
+      end
+
+      def build_assignments(rows)
+        assignment_hash = {}
+        rows.each { |row| assignment_hash[row[:id]] = Assignment.new(row) }
+        assignment_hash
+      end
+
+      def build_schedule_days(schedule_rows)
+        array_keys = SCHEDULE_KEYS.slice(2, SCHEDULE_KEYS.length - 2)
+        current_week = nil
+        schedule_days = []
+        schedule_day = nil
+
+        schedule_rows.each do |row|
+
+          # if there is a date, start a new day
+          unless row[:date].nil?
+
+            # push day in progress into array
+            schedule_days << schedule_day unless schedule_day.nil?
+
+            # create a new schedule_day Hash
+            schedule_day = {
+              begin_week: false
+            }
+
+            unless row[:week].nil?
+              current_week = row[:week]
+              schedule_day[:begin_week] = true
+            end
+
+            schedule_day[:week] = current_week
+            schedule_day[:date] = row[:date]
+            array_keys.each { |key| schedule_day[key] = [] }
+          end
+
+          # push non-nil values onto the corresponding array
+         # array_keys.each { |key| schedule_day[key] << row[key] unless row[key].nil? }
+         array_keys.each do |key| 
+          val = row[key]
+
+          # skip any completely empty cells (they produce a value of nil)
+          # Replace a single period with a whitespace.  (Thus producing an empty cell in the table)
+          # Similarly, treat cells beginnign with // as a comment and produce an empty cell in the table)
+          unless row[key].nil? 
+            val = "&nbsp;" if val == '.' || val =~ /^\s*\/\//
+            schedule_day[key] << val 
+          end
+         end
+
+          # Look for assignments / due dates and add information to @assignment objects
+          original_milestones = row[:original][:milestones]
+          if !original_milestones.nil? && original_milestones =~ /<<due\s+(.*)>>/
+            #$stderr.puts "Assignment #{$1} has due date of #{schedule_day[:date].strftime("%a. %-d %b.")}"
+            @assignments[$1].due = schedule_day[:date]
+          end
+          if !original_milestones.nil? && original_milestones =~ /<<assign\s+(.*)>>/
+            #$stderr.puts "Assignment #{$1} has assignment date of #{schedule_day[:date].strftime("%a. %-d %b.")}"
+            unless @assignments.has_key?($1)
+              $stderr.puts "Key #{$1} not found in #{@assignments.keys.inspect}"
+            end
+            @assignments[$1].assigned = schedule_day[:date]
+          end
+        end # end each row
+
+        schedule_days << schedule_day unless schedule_day.nil?
+
+        schedule_days
+      end
+
+      def timeline_table
+        table = []
+        table << <<TABLE
+      <table class='kielceSchedule'>
+       <tr>
+        <th>Week</th>
+        <th>Date</th>
+        <th>Topics</th>
+        <!-- <th>Notes</th> -->
+        <th>Reading</th>
+        <th>Milestones</th>
+       </tr>
+TABLE
+
+        first = true
+        @schedule_days.each do |schedule_day|
+          table << '<tr>'
+
+          if schedule_day[:begin_week]
+            unless first
+              # Add a blank row of horizontal lines
+              table << '<td></td><td></td><td></td><td></td><td></td><td></td></tr>'
+              table << "<tr class='week_end'><td></td><td></td><td></td><td></td><td></td><td></td></tr>"
+              table << '<tr>'
+            end
+            first = false
+            week_value = schedule_day[:week]
+          else
+            week_value = ''
+          end
+
+          table << "  <td class='week_column'>#{week_value}</td>"
+          formatted_date = schedule_day[:date].strftime("%a. %-d %b.")
+          table << "  <td class='date_column'>#{formatted_date}</td>"
+          table << "  <td class='topics_column'>#{schedule_day[:topics].join("<br>")}</td>"
+          # table << "  <td class='topics_column'>#{schedule_day[:notes].join("<br>")}</td>"
+          table << "  <td class='reading_column'>#{schedule_day[:reading].join("<br>")}</td>"
+          table << "  <td class='milestones_column'>#{schedule_day[:milestones].join("<br>")}</td>"
+          table << "</tr>"
+        end
+        table << "</table>"
+        table.join("\n")
+      end
+
+      def timeline_style
+        <<STYLE
+        table.kielceSchedule {
+          border-collapse: separate;
+          border-spacing: 2px;
+        }
+
+        .kielceSchedule tr th {
+          text-align: left;
+        }
+
+        .kielceSchedule tr td {
+          vertical-align: top;
+          padding-right: 10px;
+        }
+
+        .week_column, .date_column {
+          white-space: nowrap;
+        }
+
+        .kielceSchedule tr th, .date_column, .topics_column, .notes_column, .reading_column, .milestones_column, .week_end td {
+          border-bottom: 1px solid;
+        }
+STYLE
+      end
+
+      def timeline_page
+        <<PAGE
+    <html>
+      <head>
+         <style>
+           #{timeline_style}
+         </style>
+      </head>
+      <body>
+           #{timeline_table}
+      </body>
+     </html>
+PAGE
+      end
+
+      def assignment_style
+        <<STYLE
+        .kielceAssignmentTable {
+           border-spacing: 35px 0;
+        }        
+
+        .kielceAssignmentTable tr th {
+          text-align: left;          
+        }
+
+        .kielceAssignmentTable tr td {
+          vertical-align: top;
+        }
+
+        .kielceAssignmentTable_due {
+           white-space:  nowrap;
+        }
+
+        .kielceAssignmentTable_title {
+            white-space: nowrap;
+        }
+
+        .exam {
+            background-color: lightgreen;
+        }
+STYLE
+      end
+
+
+      def assignment_list
+        list = <<TABLE
+    <table class='kielceAssignmentTable'>
+      <tr>
+         <th>Due</th>
+         <th>Name</th>
+         <th>Details</th>
+      </tr>
+TABLE
+
+        by_date = @assignments.values.reject { |item| item.due.nil? || item.type == 'Lab' }.sort_by { |a| a.due }
+        by_date.each do |assignment|
+          list += '  <tr>'
+          list += "    <td class='kielceAssignmentTable_due'>#{assignment.due.strftime("%a. %-d %b.")}</td>\n"
+          list += "    <td class='kielceAssignmentTable_title'>#{assignment.title(:full, true)}</td>\n"
+          list += "    <td class='kielceAssignmentTable_details'>#{assignment.details}</td>\n"
+          list += "  </tr>\n\n"
+        end
+        list += "</table>\n"
+      end
+
+      def lab_list
+        list = <<TABLE
+    <table class='kielceAssignmentTable'>
+      <tr>
+         <th>Date</th>
+         <th>Name</th>
+         <th>Details</th>
+      </tr>
+TABLE
+        assigned_labs = @assignments.values.select { |item| item.type == 'Lab' && !item.assigned.nil? }
+        by_date = assigned_labs.sort { |a, b| a.assigned <=> b.assigned }
+        by_date.each do |assignment|
+          list += '  <tr>'
+          list += "    <td class='kielceAssignmentTable_due'>#{assignment.assigned.strftime("%a. %-d %b.")}</td>\n"
+          list += "    <td class='kielceAssignmentTable_title'>#{assignment.title(:full, true)}</td>\n"
+          list += "    <td class='kielceAssignmentTable_details'>#{assignment.details}</td>\n"
+          list += "  </tr>\n\n"
+        end
+        list += "</table>\n"
+        list
+      end
+  end # end Schedule
+end # module
+end # end KielcePlugins
+#puts Schedule.new(ARGV[0]).timeline_page

data/lib/kielce_plugins/schedule/assignment.rb

@@ -0,0 +1,58 @@
+module KielcePlugins
+  module Schedule
+
+    class Assignment
+
+      ASSIGNMENT_KEYS = [:id, :title, :type, :number, :link, :details]
+
+      SHORT_TYPE = {
+        homework: 'HW',
+        project: 'P',
+        lab: 'L'
+      }
+
+      # create a getter for each key (some getters overridden below)
+      ASSIGNMENT_KEYS.each { |key| attr_reader key }
+
+      attr_accessor :due, :assigned
+
+      def initialize(row)
+        ASSIGNMENT_KEYS.each { |key| instance_variable_set "@#{key.to_s}".to_sym, row[key] }
+      end
+
+      def has_type?
+        !@type.nil?
+      end
+
+      def type
+        @type.to_s
+      end
+
+      def short_type
+        return '' unless has_type?
+        key = @type.downcase.to_sym
+        $stderr.puts "Unknown type #{@type}" unless SHORT_TYPE.has_key?(key)
+        SHORT_TYPE[key]
+      end
+
+      def title(style = :original, linked=false)
+        case style
+        when :original
+          text = @title
+        when :short_type
+          type_num = has_type? ? "#{short_type}#{@number}: " : ''
+          text = "#{type_num}#{@title}"
+        when :full
+          type_string = has_type? ? "#{@type} #{@number}: " : ''
+          text = "#{type_string}#{@title}"
+        else
+          $stderr.puts "Unknown style #{sytle}"
+          text = nil
+        end
+
+        # build a link, if a link provided
+        (linked && !@link.nil?) ?  "<a href='#{@link}'>#{text}</a>" : text
+      end
+    end
+  end
+end

data/lib/kielce_plugins/schedule/schedule.rb

@@ -0,0 +1,320 @@
+require 'rubyXL'
+require_relative 'assignment'
+
+# https://www.ablebits.com/office-addins-blog/2015/03/11/change-date-format-excel/
+
+module KielcePlugins
+  module Schedule
+
+    class Schedule
+
+      #SCHEDULE_KEYS = [:week, :date, :topics, :notes, :reading, :milestones, :comments]
+      SCHEDULE_KEYS = [:week, :date, :topics, :reading, :milestones, :comments]
+
+      attr_accessor :assignments, :schedule_days
+
+      def initialize(filename)
+        workbook = RubyXL::Parser.parse(filename)
+        @assignments = build_assignments(build_rows(workbook['Assignments'], Assignment::ASSIGNMENT_KEYS))
+        @schedule_days = build_schedule_days(build_rows(workbook['Schedule'], SCHEDULE_KEYS))
+      end
+
+      def transform(value)
+        if value.is_a? String
+          # Replace link markup
+          value.gsub!(/\[\[([^\s]+)(\s+(\S.*)|\s*)\]\]/) do
+            text = $3.nil? ? "<code>#{$1}</code>" : $3
+            "<a href='#{$1}'>#{text}</a>"
+          end
+
+          value.gsub!(/<<(assign|due)\s+(\S.+)>>/) do
+            #$stderr.puts "Found assignment ref #{$1} --- #{$2} -- #{@assignments[$2].inspect}"
+            $stderr.puts "Assignment #{$2} not found" unless @assignments.has_key?($2)
+
+            text = @assignments[$2].title(:full, true)
+            if $1 == 'assign'
+              "Assign #{text}"
+            elsif $1 == 'due'
+              "<b>Due</b> #{text}"
+            else
+              $stderr.puts "Unexpected match #{$1}"
+            end
+          end # end gsub!
+
+          value.gsub!(/{{([^{}:]+):\s*([^{}]+)}}/) do
+              text = $1
+              link_rule = $2
+
+              if (link_rule =~ /(.*)\!(.+)/)
+                method = $1
+                param = $2
+             
+                method = 'default' if method.empty?  
+                #$stderr.puts "Found link rule  =>#{method}<= #{method.empty?} =>#{param}<="
+
+                link = $d.course.notesTemplates.method_missing(method, param)                
+              else
+                link = link_rule
+              end                            
+              "(<a href='#{link}'>#{text}</a>)"
+          end # end gsub
+
+        end # end if value is string
+        value
+      end
+
+      def build_rows(worksheet, keys)
+        # Remove the first (header) row, and any empty rows.
+        # Also, remove any rows after "END"
+        first = true
+        done = false
+        rows = []
+        worksheet.each do |row|
+          done = true if !row.nil? && !row[0].nil? && row[0].value == "END"
+
+          unless first || row.nil? || done
+            rows << row
+          end
+          first = false
+        end
+
+        # For each row, build a Hash describing the row.
+        rows.map do |row|
+          row_hash = { original: {} }
+          keys.each_with_index do |item, index|
+            row_hash[:original][item] = row[index].nil? ? nil : row[index].value
+            row_hash[item] = row[index].nil? ? nil : transform(row[index].value)
+          end
+          row_hash
+        end # end map
+      end
+
+      def build_assignments(rows)
+        assignment_hash = {}
+        rows.each { |row| assignment_hash[row[:id]] = Assignment.new(row) }
+        assignment_hash
+      end
+
+      def build_schedule_days(schedule_rows)
+        array_keys = SCHEDULE_KEYS.slice(2, SCHEDULE_KEYS.length - 2)
+        current_week = nil
+        schedule_days = []
+        schedule_day = nil
+
+        schedule_rows.each do |row|
+
+          # if there is a date, start a new day
+          unless row[:date].nil?
+
+            # push day in progress into array
+            schedule_days << schedule_day unless schedule_day.nil?
+
+            # create a new schedule_day Hash
+            schedule_day = {
+              begin_week: false
+            }
+
+            unless row[:week].nil?
+              current_week = row[:week]
+              schedule_day[:begin_week] = true
+            end
+
+            schedule_day[:week] = current_week
+            schedule_day[:date] = row[:date]
+            array_keys.each { |key| schedule_day[key] = [] }
+          end
+
+          # push non-nil values onto the corresponding array
+         # array_keys.each { |key| schedule_day[key] << row[key] unless row[key].nil? }
+         array_keys.each do |key| 
+          val = row[key]
+
+          # skip any completely empty cells (they produce a value of nil)
+          # Replace a single period with a whitespace.  (Thus producing an empty cell in the table)
+          # Similarly, treat cells beginnign with // as a comment and produce an empty cell in the table)
+          unless row[key].nil? 
+            val = "&nbsp;" if val == '.' || val =~ /^\s*\/\//
+            schedule_day[key] << val 
+          end
+         end
+
+          # Look for assignments / due dates and add information to @assignment objects
+          original_milestones = row[:original][:milestones]
+          if !original_milestones.nil? && original_milestones =~ /<<due\s+(.*)>>/
+            #$stderr.puts "Assignment #{$1} has due date of #{schedule_day[:date].strftime("%a. %-d %b.")}"
+            @assignments[$1].due = schedule_day[:date]
+          end
+          if !original_milestones.nil? && original_milestones =~ /<<assign\s+(.*)>>/
+            #$stderr.puts "Assignment #{$1} has assignment date of #{schedule_day[:date].strftime("%a. %-d %b.")}"
+            unless @assignments.has_key?($1)
+              $stderr.puts "Key #{$1} not found in #{@assignments.keys.inspect}"
+            end
+            @assignments[$1].assigned = schedule_day[:date]
+          end
+        end # end each row
+
+        schedule_days << schedule_day unless schedule_day.nil?
+
+        schedule_days
+      end
+
+      def timeline_table
+        table = []
+        table << <<TABLE
+      <table class='kielceSchedule'>
+       <tr>
+        <th>Week</th>
+        <th>Date</th>
+        <th>Topics</th>
+        <!-- <th>Notes</th> -->
+        <th>Reading</th>
+        <th>Milestones</th>
+       </tr>
+TABLE
+
+        first = true
+        @schedule_days.each do |schedule_day|
+          table << '<tr>'
+
+          if schedule_day[:begin_week]
+            unless first
+              # Add a blank row of horizontal lines
+              table << '<td></td><td></td><td></td><td></td><td></td><td></td></tr>'
+              table << "<tr class='week_end'><td></td><td></td><td></td><td></td><td></td><td></td></tr>"
+              table << '<tr>'
+            end
+            first = false
+            week_value = schedule_day[:week]
+          else
+            week_value = ''
+          end
+
+          table << "  <td class='week_column'>#{week_value}</td>"
+          formatted_date = schedule_day[:date].strftime("%a. %-d %b.")
+          table << "  <td class='date_column'>#{formatted_date}</td>"
+          table << "  <td class='topics_column'>#{schedule_day[:topics].join("<br>")}</td>"
+          # table << "  <td class='topics_column'>#{schedule_day[:notes].join("<br>")}</td>"
+          table << "  <td class='reading_column'>#{schedule_day[:reading].join("<br>")}</td>"
+          table << "  <td class='milestones_column'>#{schedule_day[:milestones].join("<br>")}</td>"
+          table << "</tr>"
+        end
+        table << "</table>"
+        table.join("\n")
+      end
+
+      def timeline_style
+        <<STYLE
+        table.kielceSchedule {
+          border-collapse: separate;
+          border-spacing: 2px;
+        }
+
+        .kielceSchedule tr th {
+          text-align: left;
+        }
+
+        .kielceSchedule tr td {
+          vertical-align: top;
+          padding-right: 10px;
+        }
+
+        .week_column, .date_column {
+          white-space: nowrap;
+        }
+
+        .kielceSchedule tr th, .date_column, .topics_column, .notes_column, .reading_column, .milestones_column, .week_end td {
+          border-bottom: 1px solid;
+        }
+STYLE
+      end
+
+      def timeline_page
+        <<PAGE
+    <html>
+      <head>
+         <style>
+           #{timeline_style}
+         </style>
+      </head>
+      <body>
+           #{timeline_table}
+      </body>
+     </html>
+PAGE
+      end
+
+      def assignment_style
+        <<STYLE
+        .kielceAssignmentTable {
+           border-spacing: 35px 0;
+        }        
+
+        .kielceAssignmentTable tr th {
+          text-align: left;          
+        }
+
+        .kielceAssignmentTable tr td {
+          vertical-align: top;
+        }
+
+        .kielceAssignmentTable_due {
+           white-space:  nowrap;
+        }
+
+        .kielceAssignmentTable_title {
+            white-space: nowrap;
+        }
+
+        .exam {
+            background-color: lightgreen;
+        }
+STYLE
+      end
+
+
+      def assignment_list
+        list = <<TABLE
+    <table class='kielceAssignmentTable'>
+      <tr>
+         <th>Due</th>
+         <th>Name</th>
+         <th>Details</th>
+      </tr>
+TABLE
+
+        by_date = @assignments.values.reject { |item| item.due.nil? || item.type == 'Lab' }.sort_by { |a| a.due }
+        by_date.each do |assignment|
+          list += '  <tr>'
+          list += "    <td class='kielceAssignmentTable_due'>#{assignment.due.strftime("%a. %-d %b.")}</td>\n"
+          list += "    <td class='kielceAssignmentTable_title'>#{assignment.title(:full, true)}</td>\n"
+          list += "    <td class='kielceAssignmentTable_details'>#{assignment.details}</td>\n"
+          list += "  </tr>\n\n"
+        end
+        list += "</table>\n"
+      end
+
+      def lab_list
+        list = <<TABLE
+    <table class='kielceAssignmentTable'>
+      <tr>
+         <th>Date</th>
+         <th>Name</th>
+         <th>Details</th>
+      </tr>
+TABLE
+        assigned_labs = @assignments.values.select { |item| item.type == 'Lab' && !item.assigned.nil? }
+        by_date = assigned_labs.sort { |a, b| a.assigned <=> b.assigned }
+        by_date.each do |assignment|
+          list += '  <tr>'
+          list += "    <td class='kielceAssignmentTable_due'>#{assignment.assigned.strftime("%a. %-d %b.")}</td>\n"
+          list += "    <td class='kielceAssignmentTable_title'>#{assignment.title(:full, true)}</td>\n"
+          list += "    <td class='kielceAssignmentTable_details'>#{assignment.details}</td>\n"
+          list += "  </tr>\n\n"
+        end
+        list += "</table>\n"
+        list
+      end
+  end # end Schedule
+end # module
+end # end KielcePlugins
+#puts Schedule.new(ARGV[0]).timeline_page

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: kielce
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Zachary Kurmas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-01-11 00:00:00.000000000 Z
+dependencies: []
+description: 'An ERB-based templating engine for generating course documents. '
+email: 
+executables:
+- kielce
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/kielce
+- lib/kielce.rb
+- lib/kielce/helpers.rb
+- lib/kielce/kielce.rb
+- lib/kielce/kielce_data.rb
+- lib/kielce/kielce_loader.rb
+- lib/kielce_plugins/schedule.rb
+- lib/kielce_plugins/schedule/#schedule.rb#
+- lib/kielce_plugins/schedule/assignment.rb
+- lib/kielce_plugins/schedule/schedule.rb
+homepage: https://github.com/kurmasz/KielceRB
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: An ERB-based templating engine for generating course documents.
+test_files: []