docfolio 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 99d2c5789c65b55841fd11b71cfb29448e1ea722
+  data.tar.gz: d4221138fa97f72c806a8aaabd04f3881f0e4c76
+SHA512:
+  metadata.gz: f6afcea04d4231186c8ac92f138637f75fa447073668603d83fbc9f285771d68e5fb83b7872d3466710a742751018063e52d8c4cfe389d69cd9a84fadb3e8bea
+  data.tar.gz: 27134b0e2c0d9151a33716307325fc8076a8994056776bef3c4abd197ce355e0e4d6e769a1d1d0373e7c61ed37bca1f2eb71062525ca1dddef86bb266c8e9a6b

data/lib/docfolio.rb

@@ -0,0 +1,2 @@
+require_relative 'docfolio/docfolio.rb'
+Docfolio.new.print_logs

data/lib/docfolio/date_format.rb

@@ -0,0 +1,81 @@
+# convert the date from 'dd-Oct-yy' to seconds past UNIX epoc
+# accepts dd_Mmm-yy  dd-Mmmmmmm-yy  dd-MMM-yy and other similar
+module DateFormat
+  # Extracts a date in seconds past UNIX epoc from a string date. The result
+  # can be used for other date operations. Converts from dd-mmm-yy and similar
+  # formats as commonly found in csv files
+  class DateExtractor
+    def format_date(date)
+      day, month, year = components(date)
+      begin
+        Time.new(year, month, day).to_i
+      rescue ArgumentError => e
+        print_argument_error_msg(e)
+        return nil
+      rescue => e
+        raise e
+      end
+    end
+
+    private
+
+    def print_argument_error_msg(e)
+      puts "\n#{e.to_s.upcase}"
+      puts "date  : #{date.inspect}"
+      puts "day   : #{day}"
+      puts "month : #{month}"
+      puts "year  : #{year}"
+      puts e.backtrace
+    end
+
+    # splits date into is component day month and time
+    def components(date)
+      date = date.split('-')
+      day = date[0].to_i
+      month = convert_month_to_number(date[1])
+      year = date[2].to_i
+      if year < 100 # no century
+        year > Time.now.year % 1000 ? century = 1900 : century = 2000
+        year += century
+      end
+      [day, month, year]
+    end
+
+    MONTHS = {
+      'jan' => 1,
+      'feb' => 2,
+      'mar' => 3,
+      'apr' => 4,
+      'may' => 5,
+      'jun' => 6,
+      'jul' => 7,
+      'aug' => 8,
+      'sep' => 9,
+      'oct' => 10,
+      'nov' => 11,
+      'dec' => 12,
+      'january' => 1,
+      'february' => 2,
+      'march' => 3,
+      'april' => 4,
+      'june' => 6,
+      'july' => 7,
+      'august' => 8,
+      'september' => 9,
+      'october' => 10,
+      'november' => 11,
+      'december' => 12,
+      'sept' => 9
+    }
+
+    def convert_month_to_number(month)
+      return month.to_i if month.to_i > 0 # already a number
+      month = month.downcase
+      MONTHS[month]
+    end
+  end
+
+  def format_date(date)
+    DateExtractor.new.format_date(date)
+  end
+end

data/lib/docfolio/docfolio.rb

@@ -0,0 +1,74 @@
+require_relative 'learning_diary.rb'
+# require 'stringio'
+require_relative 'views/collater_console_view.rb'
+
+# collection class for Learning Diarys / logs
+class Logs
+  include Enumerable
+
+  # iterates through every file in the data directory and parses with
+  #  LearningDiary
+  def initialize(loading_logs = true)
+    @logs = []
+    if loading_logs
+      log_files_dir.each do |log_file_name|
+        @logs << LearningDiary.new(log_file_name)
+      end
+    end
+  end
+
+  # Adds either a file to logs or a directory to logs
+  # @param [String] file_or_directory A string containing the name of a
+  #  file or directory
+  def add(file_or_directory)
+    log_directory(file_or_directory) if File.directory?(file_or_directory)
+    log_file(file_or_directory) if File.file?(file_or_directory)
+  end
+
+  def each(&block)
+    @logs.each { |p| block.call(p) }
+  end
+
+  private
+
+  # Adds a file to logs
+  # @param [String] file A string containing the name of a file
+  def log_file(file)
+    @logs << LearningDiary.new(file)
+  end
+
+  # Adds a directory to logs
+  # @param [String] dir A string containing the name of a directory
+  def log_directory(dir)
+    Dir[dir + '/**/*.txt'].each { |file| log_file(file) }
+  end
+
+  # @return [Array] An array of strings. Each string is a 
+  #   relative file path for every .txt file under the data directory
+  def log_files_dir
+    Dir['./docfolio/data/**/*.txt']
+  end
+end
+
+# controller class for the diaries/logs collection
+class Docfolio
+  def initialize
+    @logs = Logs.new
+    @view = CollaterConsoleView.new
+  end
+
+  # Creates a portfolio
+  # @param [String] portfolio_file_or_directory A portfolio file or a
+  #  name of a directory containing portfolio files including files
+  #  within subdirectories.
+  def self.create(portfolio_file_or_directory)
+    logs = Logs.new(false)
+    logs.add(portfolio_file_or_directory)
+    CollaterConsoleView.new.print_logs(logs)
+    true
+  end
+
+  def print_logs
+    @view.print_logs(@logs)
+  end
+end

data/lib/docfolio/learning_diary.rb

@@ -0,0 +1,87 @@
+require_relative 'date_format.rb'
+require_relative 'paragraph.rb'
+require_relative 'views/diary_console_view.rb'
+
+# collection class for paragraphs
+# synonym 'Topic' 'Learning Diary'
+class LearningDiary
+  include Enumerable
+
+  attr_reader :paragraphs
+
+  # @param [String] file name of a text file containing text in docfile DSL
+  def initialize(file)
+    # preparation
+    # @todo extract to an initialize_vars function, as in the paragraph class
+    Paragraph.reset
+    @console_view = DiaryConsoleView.new
+    @paragraphs = []
+    @standard_credits_array = []
+    @impact_credits_array = []
+
+    # read the whole txt file in one go
+    f = File.read(file, encoding: 'UTF-8')
+
+    # iterates through each paragraph
+    f.split(/\n/).each do |p|
+      next if p == '' # ignore if paragraph empty
+      @paragraphs << Paragraph.new(p) #
+    end
+    calc_standard_credits
+    calc_impact_credits
+  end
+
+  def each(&block)
+    @paragraphs.each { |p| block.call(p) }
+  end
+
+  def [](index)
+    @paragraphs[index]
+  end
+
+  def standard_credits_total
+    @standard_credits_array.reduce(0) { |a, e| a + e[2] }
+  end
+
+  def standard_credits
+    @standard_credits_array
+  end
+
+  def impact_credits_total
+    @impact_credits_array.reduce(0) { |a, e| a + e[2] }
+  end
+
+  def credits_total
+    impact_credits_total + standard_credits_total
+  end
+
+  def impact_credits
+    @impact_credits_array
+  end
+
+  private
+
+  def calc_standard_credits
+    @paragraphs.each do |p|
+      next unless p.creditable?
+      start     = p.start_time
+      finish    = p.end_time
+      duration  = p.period
+      @standard_credits_array << [start, finish, duration] unless duration == 0
+    end
+    @standard_credits_array.uniq!
+  end
+
+  def calc_impact_credits
+
+    @paragraphs.each do |p|
+      next unless p.impact_creditable?
+      # p p
+      start     = p.start_time
+      finish    = p.end_time
+      duration  = p.period
+      @impact_credits_array << [start, finish, duration] unless duration == 0
+    end
+    @impact_credits_array.uniq!
+  end
+end

data/lib/docfolio/paragraph.rb

@@ -0,0 +1,270 @@
+require_relative 'tags.rb'
+
+# @param [Array] time_array updated start and end times in hours and minutes
+# @param [Array] times_and_dates current start and end times and date
+# @return [Array] returns the new times_and_dates array for use going forwards
+module MyTime
+  # processes new times and dates with current times and dates
+  class TimeProcesser
+    include Tags
+    
+    # Takes class start end times and dates as Time objects and amends the
+    # times, advancing the date if the start time has crossed midnight.
+    # @param [Array] current_times_and_dates An array containing the 
+    #  Paragraph class instance variables for the start time, end time
+    #  and date (day)
+    # @param [Array] new_times An array containing the from hour, from min, 
+    #  to hour, to min
+    # @return [Array] The updated Paragraph class instance variables for the 
+    #  start time, end time and date.
+    def process_times(new_times, current_times_and_dates)
+      @start_time, @end_time, @date = current_times_and_dates
+      f_hour, f_min, t_hour, t_min = new_times
+      if (has f_hour) && to_st_tme(f_hour, f_min)
+        t_hour  = f_hour
+        t_min   = f_min
+      end
+      to_end_time(t_hour, t_min) if has t_hour
+      [@start_time, @end_time, @date]
+    end
+
+    private
+    
+
+    # @param [Number] f_hour From hours
+    # @param [Number] f_min From minutes
+    # @return [Boolean] if has a start time and no end time return true else 
+    #  set start time and return false (the nil for the last assignment of 
+    #  start_t)
+    def to_st_tme(f_hour, f_min)
+      # treat the time as an end time if there is a start time and no end time
+      has(@start_time) && (!has @end_time) ? true : start_t(f_hour, f_min)
+    end
+
+    def to_end_time(t_hour, t_min)
+      # extract_time_object simply adds hours and mins to date
+      @end_time = extract_time_object(t_hour, t_min, @date)
+      # if end_time before start_time, assume it is the following day
+      @end_time += a_day if @end_time < @start_time
+    end
+
+    # Adds hours and mins to date (Time). Then adds a day if the start time is 
+    # before the end time. Finally, makes end time nil
+    # @todo why advance the start time by a day if before the end time?
+    # @todo why make end_time nil?
+    def start_t(hour, min)
+      # extract_time_object simply adds hours and mins to date
+      @start_time = extract_time_object(hour, min, @date)
+
+      # advance start time by one day if the start time is before the end_time
+      @start_time += a_day if (has @end_time) && @start_time < @end_time
+      @end_time = nil
+    end
+
+    # Improves readability of boolean condition statements. Is used from Time 
+    # objects and integer hour component, but it works for any object
+    # @param [Object] time_date_component Any object
+    # @return [Boolean] true if the parameter is not nil
+    def has(time_date_component)
+      !time_date_component.nil?
+    end
+
+    # returns one day in seconds and adds a day to the @date
+    def a_day
+      @date.nil? ? fail('needs date') : @date += 86_400
+      86_400
+    end
+  end
+
+  # Takes class start end times and dates as Time objects and amends the
+  # times, advancing the date if the start time has crossed midnight.
+  # @param [Array] times_and_dates An array containing the Paragraph class 
+  #  instance variables for the start time, end time and date (day)
+  # @param [Array] time_array An array containing the from hour, from min, 
+  #  to hour, to min
+  def process_times(time_array, times_and_dates)
+    TimeProcesser.new.process_times(time_array, times_and_dates)
+  end
+end
+
+# Used by LearningDiary
+# Initialized with plain text, will parse and hold tagged content
+# Can keep track of time, section and id information from previous paragraphs
+# using class instance variables
+class Paragraph
+  include Enumerable
+  include MyTime
+
+  private
+
+  include Tags
+
+  public
+
+  attr_reader :id, :tags
+
+  # instance start time and instance end time
+  attr_accessor :start_time, :end_time
+
+  # initialize class date, start and class end time class instance variables
+  @cst = @cet = @date = nil
+  @section = @id = 0 # :TITLE
+
+  class << self
+    # class starttime and class end time
+    attr_accessor :st, :et, :date, :section, :id
+  end
+
+  # @param [String] p a single paragraph from a text file. 
+  def initialize(p)
+    # preparation
+    initialize_vars
+
+    # Extract the date and time from a paragraph if it contains date and time 
+    # info. Removes the date and time from the paragraph puts whats left into 
+    # rest_of_str. Puts the to hour, to min, from hour and from min into the 
+    # time array. Puts the date into Paragraph.date as a Time object.
+    #
+    # Paragraph.date is a class instance variable that holds the date to apply
+    # to this and subsequent paragraphs. It is initialized to nil when the 
+    # program starts and reset to nil when reset is called (which it is called 
+    # by the LearningDiary when initializing to parse a new file, called by
+    # the Collater when iterating through each text file)
+    #
+    # The extract_date function is from the Tag module
+    rest_of_str, time_array, Paragraph.date = extract_date(p, Paragraph.date)
+
+    # if a date or time has been found (and extracted)
+    if rest_of_str != p
+      # transer class start and end times to those of this paragraph, reset 
+      # section to :NOTE
+      note_time
+
+      # Takes the current class instance times and dates and newly extracted 
+      # paragraph dates from this paragraph, follows a set of rules to 
+      # determine what the class instant times and dates should become
+      assign_class_dates process_times(time_array, class_dates)
+      
+      # tranfser class start and end times to those of this paragraph, reset 
+      # section to :NOTE
+      note_time
+    end
+
+    # if a new date or time has not been found then return
+    # @todo should this be in an else statement? 
+    return if rest_of_str == ''
+
+    tags_extracted?(rest_of_str) ? note_time : tag_section(rest_of_str)
+  end
+
+  # returns true if any tags are of type tag
+  # @param [Array] tag An array of tags
+  def tag?(tag)
+    @tags.each { |t| return true if t[0] == tag }
+    false
+  end
+
+  # resets the class variables so that a new file can be parsed
+  # is called by LearningDiary when preparing to parse a new txt file
+  def self.reset
+    Paragraph.date = Paragraph.st = Paragraph.et = nil
+    Paragraph.section = Paragraph.id = 0 # :TITLE
+  end
+
+  # @todo should this be private?
+  def initialize_vars
+    @date_specified = @end_time_specified = @start_time_specified = false
+    @start_time = @end_time = nil
+    @tags = []
+    @id = Paragraph.id
+    Paragraph.id += 1
+  end
+
+  # each on paragraph iterates through the tags
+  def each(&block)
+    @tags.each { |t| block.call(t) }
+  end
+
+  def [](index)
+    tags[index]
+  end
+
+  # true is the paragraph contains a tag that can earn credit
+  def creditable?
+    @tags.each { |t| return true if CREDITABLE.include?(t[0]) }
+    false
+  end
+
+  # true is the paragraph contains a tag that can earn impact credit
+  def impact_creditable?
+    @tags.each { |t| return true if t[0] == :I }
+    false
+  end
+
+  def period
+    return 0 if @end_time.nil? || @start_time.nil?
+    (@end_time - @start_time).to_i / 60
+  end
+
+  def latest_time
+    return @end_time unless @end_time.nil?
+    return @start_time unless @start_time.nil?
+    nil
+  end
+
+  private
+
+  TAG = 0
+  CONTENT = 1
+
+  def assign_class_dates(array)
+    Paragraph.st, Paragraph.et, Paragraph.date = array
+  end
+
+  # @return [Array] An array containing the class instant variables for the 
+  #  start time, end time and the date. 
+  def class_dates
+    [Paragraph.st, Paragraph.et, Paragraph.date]
+  end
+
+  def tags_extracted?(str)
+    (@tags.count) < (@tags += extract_tags(str)).count
+  end
+
+  def tag_section(str)
+    tag_it(SECTIONS[Paragraph.section], str)
+  end
+
+  def content(tag, str = '')
+    @tags.each { |t| str << t[CONTENT] + ' ' if t[TAG] == tag }
+    str
+  end
+
+  def next_section
+    Paragraph.section += 1 unless Paragraph.section == (SECTIONS.count - 1)
+  end
+
+  def tag_it(tag, p)
+    @tags << [tag, p]
+    next_section if Paragraph.section == 0 # :TITLE
+  end
+
+  def method_missing(n, *args, &block)
+    if args[0].nil? # tag getter
+      ALL_TAGS.include?(n) ? content(n) : super(n, *args, &block)
+    else # section setter
+      SECTIONS.include?(n) ? tag_it(n, args[0]) : super(n, *args, &block)
+    end
+  end
+
+
+  # @todo this function does two things, split it up
+  # Sets the section to a simple :NOTE and transfers the class times to the 
+  # instance times.
+  # new untagged sections should be of :NOTE (2)
+  def note_time
+    Paragraph.section = 2 #:NOTE
+    @start_time = Paragraph.st
+    @end_time = Paragraph.et
+  end
+end

data/lib/docfolio/tags.rb

@@ -0,0 +1,158 @@
+require_relative 'date_format.rb'
+require 'English'
+
+# handles extraction of tagged or other significant content
+module Tags
+  # interface:  extract_date, extract_tags
+  TAGS = [:LP, :R, :DEN, :NOTE, :I] # recognized in text
+  CREDITABLE = [:LP, :R, :I] # can earn cpd credit
+  SECTIONS = [:TITLE, :INTRO, :NOTE] # assumed from position in document
+  SPECIAL = [:DATE] # internal tags with no meaning from content or position
+  ALL_TAGS = SECTIONS + TAGS + SPECIAL
+
+  # extracts and formats tags and pertaining text from a plain text paragraph
+  class TagFriend
+    include DateFormat
+
+    # @todo move function to one of the date or time handling classes
+    # The $LAST_MATCH_INFO global is equivalent to Rexexp.last_match and 
+    # returns a MatchData object. This can be used as an array, where indices
+    # 1 - n are the matched backreferences of the last successful match
+    # @param [String] paragraph_text a paragraph from a DSL text file
+    # @param [Time] date of this paragraph. May be nil if not known.
+    # @return [Array<String, Array, Time>] Array of values to be returned
+    # [String return value] 'paragraph_text' the same paragraph that was passed to the function but without the matched date character if there were any.
+    # [Array return value] 'time_array' array of 4 integer representing the hours and minutes of the from and to times
+    # [Time return value] 'date' the date in (day month year) of this paragraph taken from the matched date_regex if there was one. Will be nil if there was no match and if the date passed to the function was also nil.
+    def extract_date(paragraph_text, date)
+      time_array = []
+
+      # if text contains a date match
+      if date_regex =~ paragraph_text 
+        # $' (or $POSTMATCH), contains the characters after the match position
+        paragraph_text = $' 
+
+        # strip whitespace if any remaining match or set to empty string 
+        # if no match. If there is just white space after the match then
+        # this is truncated to an empty string
+        paragraph_text.nil? ? paragraph_text = '' : paragraph_text.strip!
+        
+        # extracts the 'from' and 'to' times from the last match above. the 
+        # time_array contains from_hour, from_min, to_hour, to_min, the
+        # date parameter is updated if the match found a new date
+        time_array, date = date_from_globals($LAST_MATCH_INFO, date)
+      end
+      [paragraph_text, time_array, date]
+    end
+
+    def extract_tags(paragraph_text)
+      tag_regex =~ paragraph_text ? extract_tag(paragraph_text) : []
+    end
+
+    private
+
+    # @todo move function to one of the date or time handling classes
+    # returns a date from the 26 globals returned by date_regex
+    # @param [MatchData] glob_a the MatchData object return when the date_regex
+    #  was matched to the paragraph
+    # @param [Time] date the date of the paragraph; may be nil if not known
+    # @return [Array] array of 4 integer representing the 
+    #  hours and minutes of the from and to times
+    # @return [Time] 'date' the date (day month year) of this paragraph
+    def date_from_globals(glob_a, date)
+      from_hour = glob([1, 23], glob_a)
+      from_min  = glob([2, 24], glob_a)
+      to_hour   = glob([3, 25], glob_a)
+      to_min    = glob([4, 26], glob_a)
+      day       = glob([5, 8, 12, 14, 17, 21], glob_a)
+      month     = glob([6, 9, 11, 15, 18, 20], glob_a)
+      year      = glob([7, 10, 13, 16, 19, 22], glob_a)
+      date = Time.at(format_date("#{day}-#{month}-#{year}")) unless day.nil?
+      [[from_hour, from_min, to_hour, to_min], date]
+    end
+
+    # @todo move function to one of the date or time handling classes
+    # Returns a regular expression to be used to match dates and times of 
+    # the paragraph.
+    # @return [Regex] a regular expression to use to match dates and times
+    #  in the paragraph
+    def date_regex
+      dy      = /(?<day>\d{1,2})/
+      mt      = /(?<month>\w+)/
+      yr      = /(?<year>\d{2,4})/
+      time    = /(?<hour>\d{1,2}):(?<min>\d{2})/
+      period  = /#{time}( ?(?:-|to) ?#{time})?/
+      date1   = %r{#{dy}/#{dy}/#{yr}}     # d/m/y
+      date2   = /#{dy},? #{mt},? #{yr}/   # d Month Year
+      date3   = /#{mt},? #{dy},? #{yr}/   # Month d Year
+      date    = /#{date1}|#{date2}|#{date3}/
+      /^(#{period} ?#{date}?|#{date} ?#{period}?)/
+    end
+
+    # @todo would str be better with join?
+    # Creates a regex that can be used to match for tags that are recognized 
+    # as part of the DSL, currently :LP, :R, :DEN, :NOTE and :I
+    def tag_regex
+      str = ''
+      TAGS.each do |t|
+        str << "#{t}|"
+      end
+      str.gsub!(/\|$/, '')
+      /\b(#{str}): ?/
+    end
+
+    # Extracts a particular parameter from the MatchData object return when the
+    # paragraph was matched with the date regex. Treats the MatchData
+    # as an array, iterating through each index represented in the i_a
+    # array to find and return a value if there is one. 
+    # @param [Array] i_a Array of integers representing positions to test in 
+    #  array glob_a
+    # @param [MatchData] glob_a Array of matched backreferences of the last
+    #  successful regular expression match
+    # @return the first element in MatchData that is not nil. Returns
+    #  nil if there are no elements in MatchData at the indices in i_a that 
+    #  are not nil. 
+    def glob(i_a, glob_a)
+      i_a.each { |n| return glob_a[n] unless glob_a[n].nil? }
+      nil
+    end
+
+    def preface_with_note(a)
+      str = a[0].strip
+      str == '' ? [] : [[:NOTE, str]]
+    end
+
+    def tags_array(a)
+      tags = []
+      tag_count = (a.count - 1) / 2
+      1.upto(tag_count) do |i|
+        tag = a[(i * 2) - 1].to_sym
+        content = a[i * 2].strip
+        tags << [tag, content]
+      end
+      tags
+    end
+
+    def extract_tag(paragraph_text)
+      a = paragraph_text.split(tag_regex)
+      preface_with_note(a) + tags_array(a)
+    end
+  end
+
+  # @param [Time] from time to which hours and minutes are added
+  # @param [Number] hour hours to add to from
+  # @param [Number] min minutes to add to from
+  # @return [Time] the result of hours and minutes after from
+  def extract_time_object(hour, min, from)
+    seconds = (hour.to_i * 3600) + (min.to_i * 60)
+    Time.at(from.to_i + seconds)
+  end
+
+  def extract_tags(paragraph_text)
+    TagFriend.new.extract_tags(paragraph_text)
+  end
+
+  def extract_date(paragraph_text, date)
+    TagFriend.new.extract_date(paragraph_text, date)
+  end
+end

data/lib/docfolio/views/collater_console_view.rb

@@ -0,0 +1,14 @@
+# Collates information from different logs and can output collated information
+# for use in appraisals.
+class CollaterConsoleView < ConsoleView
+  def print_logs(diaries)
+    diary_console_view = DiaryConsoleView.new
+    diaries.each do |diary|
+      str = diary_console_view.output(diary)
+      unless str == ''
+        puts str
+        puts "\n#{'=' * OUTPUT_WIDTH}\n\n"
+      end
+    end
+  end
+end

data/lib/docfolio/views/diary_console_view.rb

@@ -0,0 +1,228 @@
+require 'colorize'
+require_relative 'view.rb'
+
+# A console view class for the Learning Diary
+class DiaryConsoleView < ConsoleView
+  def initialize(diary = nil)
+    return if diary.nil?
+    @paragraphs = diary.paragraphs
+    @credits = diary.standard_credits
+    @credits_total = diary.standard_credits_total
+    @impact = diary.impact_credits
+    @impact_total = diary.impact_credits_total
+    @total = diary.credits_total
+  end
+
+  def output(diary = nil)
+    initialize(diary)
+    output_str
+  end
+
+  private
+
+  def output_str
+    str = ''
+    str += section_str('TITLE', content(:TITLE))
+    str += section_str('INTRODUCTION', content(:INTRO))
+    str += learning_str
+    str += credits_str
+    str
+  end
+
+  def learning_str(str = '')
+    str += section_str('LEARNING POINTS', content(:LP), true)
+    str += section_str('REFLECTION', reflection, true)
+    str += section_str('IMPACT', impact)
+    str += section_str('FURTHER STUDY', content(:DEN), true)
+    str += section_str('OTHER NOTES', content(:NOTE))
+    str
+  end
+
+  def credits_str(str = '')
+    str += section_str('CREDITS BREAKDOWN', credits_breakdown(@credits))
+    str += mins2hour(@credits_total) + "\n" unless @credits_total == 0
+    str += section_str('IMPACT BREAKDOWN', credits_breakdown(@impact))
+    str += mins2hour(@impact_total) + "\n" unless @impact_total == 0
+    str += section_str('TOTAL CREDITS CLAIMED', credits_total(@total))
+    str
+  end
+
+  def credits_total(total)
+    return '' if total == 0
+    total_line + mins2hour(total)
+  end
+
+  def content(tag)
+    arr = []
+    @paragraphs.each do |p|
+      if block_given? # yields the whole paragraph for further processing
+        arr = yield p if p.tag?(tag)
+      else # strip tag texts to an array of one text element per tag
+        text = p.send(tag).strip
+        arr << text unless text == ''
+      end
+    end
+    arr
+  end
+
+  def credits_breakdown(credits_array)
+    return '' if credits_array.empty?
+    str = ''
+    credit_count = credits_array.count - 1
+    0.upto(credit_count) do |i|
+      prev_credit, credit = elements(credits_array, i)
+      str << take_credit(prev_credit, credit, i)
+    end
+    str + sub_total_line
+  end
+
+  def reflection
+    arr = []
+    content(:R) do |p|
+      arr += reflections(p)
+    end
+    arr
+  end
+
+  def impact
+    arr = []
+    old_cr = []
+    date = ''
+    content(:I) { |p| old_cr = credit_line(p); break }
+    statement_a = []
+    content(:I) do |p|
+      date = strftime(p.start_time, '%e-%b-%y').underline
+      sta = impact_statement(p)
+      cr = credit_line(p)
+      if cr != old_cr # group claims of the same time/credit
+        arr << statement_line(date, statement_a, old_cr)
+        statement_a = []
+        statement_a << add_impact_statement(sta)
+        old_cr = cr
+        next
+      end
+      statement_a << add_impact_statement(sta)
+    end
+    line = statement_line(date, statement_a, old_cr)
+    arr << line unless line.nil?
+    arr
+  end
+
+  # @param [Array] e element - statement array from #impact_statement(paragraph) in
+  #  the form [has_info?(Boolean), text(String)]
+  def add_impact_statement(e)
+    if e[0] == false
+      impact_err(e[1])
+    else
+      "\n\n#{e[1]}\n\n"
+    end
+  end
+
+  def statement_line(date, statement_a, old_cr)
+    return if statement_a.empty?
+    statement = statement_a.join
+    "\n#{date}#{statement}#{old_cr}".gsub(/\n\n\n\n/, "\n\n")
+  end
+
+  # @[param] p paragraph
+  def credit_line(p)
+    st = p.start_time
+    fin = p.end_time
+    amount = ((fin - st) / 60).to_i
+    cr = "Impact Credit Claimed: #{amount} mins"
+    cr += ' based on an original period of study and reflection from'
+    cr + " #{print_date_and_time(st)} to #{end_time(st, fin)}\n"
+  end
+
+  def impact_statement(paragraph)
+    arr = []
+    ref = rm_colour(reflections(paragraph).join(' '))
+    paragraph.each { |tag| arr << tag[1] if tag[0] == :I }
+    sta = arr.join(' ')
+    ref == '' ? [false, sta] : [true, "#{ref}\n\n#{sta}"]
+  end
+
+  def impact_err(sta)
+    ret = "#{sta}" + " Warning - this impact statement does"\
+    " not pertain to any learning points or reflection.".colorize(:red)
+    "\n\n#{ret}\n\n"
+  end
+
+  # @param [Array] paragraph A paragraph containing one or more reflections.
+  #  The paragraph is an array of tags of the form [tag symbol, string]
+  # @return an array of reflections
+  # The reflection text is returned with preceeding learning points formatted
+  #  in a different style. A learning point is attached to the reflection
+  #  if it preceeds the reflection, is in the same paragraph and there are
+  #  no other intervening reflections in the same paragraph i.e. Within the
+  #  same paragraph, a reflection will take the preceeding LPs and then leave
+  #  subsequent LPs which will be picked up by a subsequent reflection if
+  #  there is one. Such successive reflections, within the same paragraph, can
+  #  be placed in order and in context when reported.
+  def reflections(paragraph)
+    arr = []
+    lp = ''
+    paragraph.each do |tag|
+      if tag[0] == :R
+        arr << (lp + tag[1].colorize(:green))
+        lp = ''
+      end
+      lp += (tag[1] + ' ').colorize(:light_black) if tag[0] == :LP
+    end
+    arr
+  end
+
+  def on_same_day?(time1, time2)
+    one_day = 60 * 60 * 24
+    (time1.to_i / one_day).to_i == (time2.to_i / one_day).to_i
+  end
+
+  # @return [Array] The previous and current elements in the array
+  def elements(a, i)
+    i > 0 ? [a[i - 1], a[i]] : [[], a[i]]
+  end
+
+  def strftime(t, format)
+    t.strftime(format)
+  end
+
+  def print_just_time(t)
+    strftime(t, '%H:%M')
+  end
+
+  def print_date_and_time(t)
+    strftime(t, '%e-%b-%y %H:%M')
+  end
+
+  def print_time_and_date(t)
+    strftime(t, '%H:%M (%-e-%b)')
+  end
+
+  def start_time(cr, prev_cr, i)
+    if i == 0 # first line always has the full date and time
+      print_date_and_time(cr)
+    else
+      on_same_day?(cr, prev_cr) ? print_just_time(cr) : print_date_and_time(cr)
+    end
+  end
+
+  def end_time(st, fin)
+    on_same_day?(st, fin) ? print_just_time(fin) : print_time_and_date(fin)
+  end
+
+  def credit_period(prev_credit, credit, i)
+    str = start_time(credit[0], prev_credit[0], i).rjust(16)
+    str << ' - '
+    str << end_time(credit[0], credit[1]).ljust(16)
+  end
+
+  def credit_amount(amount)
+    str = "#{amount}".rjust(4)
+    str << " mins\n"
+  end
+
+  def take_credit(prev_credit, credit, i)
+    str =  credit_period(prev_credit, credit, i)
+    str << credit_amount(credit[2])
+  end
+end

data/lib/docfolio/views/view.rb

@@ -0,0 +1,91 @@
+# parent view class
+class View
+  protected
+
+  def rm_colour(str)
+    str.gsub(/\e.*?m/, '')
+  end
+end
+
+class ConsoleView < View
+  protected
+
+  OUTPUT_WIDTH = 80
+
+  def print_array_section(title, body, list)
+    return '' if body.empty?
+    if list
+      to_console("#{title}") + "\n\n" +
+      to_console("• #{body.join("\n\n• ")}\n\n", 2, 4)
+    else
+      to_console("#{title}") +
+      to_console("#{body.join}\n\n")
+    end
+  end
+
+  def section_str(title, body = nil, list = false)
+    return '' if body.nil?
+    case body
+    when Array
+      return '' if body.empty?
+      print_array_section(title, body, list)
+    when String
+      return '' if body.strip == ''
+      "#{title}\n\n#{body}"
+    end
+  end
+
+  def line(char)
+    ' ' * 27 + char * 18 + "\n"
+  end
+
+  def sub_total_line
+    line('─')
+  end
+
+  def total_line
+    line('═')
+  end
+
+  def mins2hour(mins)
+    hours = (mins.to_r / 60).to_i
+    mins -= hours * 60
+    hours == 1 ? h_str = 'hour' : h_str = 'hours'
+    mins == 1 ? m_str = 'min' : m_str = 'mins'
+    "#{hours}".rjust(30) + " #{h_str}".ljust(6) +
+    "#{mins.to_i}".rjust(3) + " #{m_str}\n"
+  end
+
+  # prints the word to the console
+  def word2console(word, x_pos, margin)
+    str = ''
+    length = 1 + rm_colour(word).length
+    if x_pos + length >= OUTPUT_WIDTH
+      str += "\n" + (' ' * margin)
+      x_pos = margin + length
+    else
+      x_pos += length
+    end
+    str != '' ? debug = true : debug = false
+    str += word
+    [x_pos, str]
+  end
+
+  def to_console(str, first_line_margin = 0, margin = 0)
+    return_str = ''
+    str.each_line do |line|
+      if line == "\n"
+        return_str += "\n\n"
+        next
+      end
+      return_str += ' ' * first_line_margin
+      x_pos = first_line_margin
+      words = line.split(' ')
+      words.each do |word|
+        x_pos, this_str = word2console(word, x_pos, margin)
+        return_str += this_str + ' '
+      end
+    end
+    return_str
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: docfolio
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Nick Bulmer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-10 00:00:00.000000000 Z
+dependencies: []
+description: A domain specific language to aid recording of a personal learning portfolio
+  for UK General Practitioners.
+email: n.bulmer@live.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/docfolio.rb
+- lib/docfolio/date_format.rb
+- lib/docfolio/docfolio.rb
+- lib/docfolio/learning_diary.rb
+- lib/docfolio/paragraph.rb
+- lib/docfolio/tags.rb
+- lib/docfolio/views/collater_console_view.rb
+- lib/docfolio/views/diary_console_view.rb
+- lib/docfolio/views/view.rb
+homepage: https://github.com/nickbulmer/docfolio
+licenses:
+- GNU
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A DSL for GP CPD
+test_files: []
+has_rdoc: