mo2tex 1.0.0

data/lib/mo2tex/course_helper.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Mo2tex
+
+	module CourseHelper
+
+		def normalize_title(t)
+			return t.gsub(/_/, ' ')
+		end
+
+	end
+
+#	class Course
+
+#		include CourseHelper
+
+#		attr :title, :hours, :type, :students, :start
+
+#		def initialize(title, desc)
+#			@title = normalize_title(title)
+#			@hours = desc['ore']
+#			@type  = desc['tipologia']
+#			@students = desc['studenti']
+#			@start = DateTime.parse(desc['inizio'].to_s)
+#		end
+
+#		def generate(cal)
+#			result = latex_title
+#			evs = cal.lookup(self.title)
+#			raise UnknownCourse, "#{self.title}" unless evs
+#			tot_nlessons = self.total_number_of_lessons(evs)
+#			nless = 0
+#			evs.each do
+#				|ev|
+#				ev.repeat do
+#					|sev, title|
+#					nless += 1
+#					result += (sev.to_latex + " & Lezione n.#{nless}/#{tot_nlessons}\\\\\n")
+#					break if nless > tot_nlessons
+#				end
+#			end
+#			return result
+#		end
+
+#		def total_course_dur_in_seconds
+#			return self.academic_hours * 3600
+#		end
+
+#		def total_number_of_lessons(evs)
+#			tot = 0
+#			nless = 0
+#			evs.each do
+#				|ev|
+#				ev.repeat do
+#					|sev, title|
+#					tot += sev.dur
+#					nless += 1
+#					break if tot > self.total_course_dur_in_seconds
+#				end
+#			end
+#			return nless
+#		end
+
+#		class <<self
+
+#			def create(title, desc)
+#				result = nil
+#				case desc['tipologia']
+#					when 'collettiva'
+#						result = CollectiveCourse.new(title, desc)
+#					when 'individuale'
+#						result = IndividualCourse.new(title, desc)
+#					else
+#						raise UnknownCourseType, "Unknown type #{desc['tipologia']}"
+#				end
+#				return result
+#			end
+
+#		end
+
+#		def num_students
+#			return self.students.size
+#		end
+
+#		def total_hours
+#			raise PureVirtualMethodCalled, 'Course#total_hours'
+#		end
+
+#		def academic_hours
+#			return self.total_hours
+#		end
+
+#	private
+
+#		def latex_title
+#			return "\\multicolumn{3}{\\bfseries #{self.title}}\\\\\n"
+#		end
+
+#	end
+
+#	class CollectiveCourse < Course
+
+#		def total_hours
+#			return self.hours
+#		end
+
+#	end
+
+#	class IndividualCourse < Course
+
+#		def total_hours
+#			return self.hours * self.num_students
+#		end
+
+#		def academic_hours
+#			return (self.total_hours * 0.75)
+#		end
+
+#	end
+
+end

data/lib/mo2tex/datetime_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mo2tex
+
+  module DateTimeHelper
+
+    def datetime_create(day, t)
+      raise DayIsNotDateTime, "#{day}" unless day.class == DateTime
+      raise TimeIsNotString,  "#{t}"   unless t.class == String
+      (hours, minutes) = t.split(':').map { |n| n.to_i }
+      result = DateTime.new(day.year, day.month, day.day, hours, minutes, 0)
+      return result
+    end
+
+    module ClassMethods
+
+      def self.extend(base)
+          base.extend ClassMethods
+      end
+
+	    def first_midnight
+	      return DateTime.new(0, 1, 1, 0, 0, 0)
+	    end
+
+    end
+
+  end
+
+end

data/lib/mo2tex/day_schedule.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Mo2tex
+
+  class SlotBase
+
+    include DateTimeHelper
+
+    attr_reader   :day
+    attr_accessor :dtstart, :dtend
+
+    def initialize(day, ts, te)
+      @day    = day
+      self.dtstart = ts
+      self.dtend   = te
+    end
+
+    def dtstart=(ts)
+      @dtstart = common_equal(ts)
+    end
+
+    def dtend=(te)
+      @dtend   = common_equal(te)
+    end
+
+    def color
+      raise PureVirtualMethodCalled, "#{self.class}#color"
+    end
+
+    def title
+      raise PureVirtualMethodCalled, "#{self.class}#title"
+    end
+
+  private
+
+    def common_equal(t)
+      result = t if t.is_a?(DateTime)
+      result = datetime_create(self.day, t) if t.is_a?(String)
+      return result
+    end
+
+  end
+
+  class FreeSlot < SlotBase
+
+    def title
+        return "FREE"
+    end
+
+    def color
+      return "\"red\""
+    end
+
+  end
+
+  class LunchBreak < SlotBase
+
+    def title
+        return "Pranzo"
+    end
+
+    def color
+      return "\"grey50\""
+    end
+
+  end
+
+  class DaySchedule
+
+    include DateTimeHelper
+
+    attr_reader :day, :tstart, :tend, :lbtstart, :lbtend, :dtstart, :dtend, :lbdtstart, :lbdtend, :lnumber, :wday
+    attr_reader :slots
+    attr_accessor :dirty
+
+    def initialize(day, ln, wd, conf)
+      raise DayIsNotDateTime, "#{day}" unless day.is_a?(DateTime)
+      raise ArgumentError, "#{conf}" unless conf.is_a?(Hash)
+      @day     = day # should be a DateTime with the d/m/y
+      @wday    = wd
+      @tstart  = conf[self.wday]['orario'][0]
+      @tend    = conf[self.wday]['orario'][1]
+      @lbtstart = conf[self.wday]['pausa'][0]
+      @lbtend   = conf[self.wday]['pausa'][1]
+      @dtstart = datetime_create(self.day, self.tstart)
+      @dtend   = datetime_create(self.day, self.tend)
+      @lbdtstart = datetime_create(self.day, self.lbtstart)
+      @lbdtend   = datetime_create(self.day, self.lbtend)
+      @lnumber = ln
+      @slots = []
+      self.dirty  = false
+      calculate_free_slots
+    end
+
+    def dirty?
+      return self.dirty
+    end
+
+    def <<(event)
+      return unless this_slot?(event)
+      self.slots << event
+      self.dirty = true
+    end
+
+    def calculate_free_slots
+      if self.slots.empty?
+        self.slots << LunchBreak.new(self.day, self.lbdtstart, self.lbdtend)
+      else
+        bsorted = self.slots.sort { |a, b| a.dtstart <=> b.dtstart }
+        tstart = self.dtstart
+        bsorted.each do
+          |ev|
+          self.slots << FreeSlot.new(self.day, tstart, ev.dtstart) if (ev.dtstart.round_to_ymdhm > tstart.round_to_ymdhm)
+          tstart = ev.dtend
+        end
+        self.slots << FreeSlot.new(self.day, tstart, self.dtend) if (tstart.round_to_ymdhm < self.dtend.round_to_ymdhm)
+      end
+      self.slots.sort! { |a, b| a.dtstart <=> b.dtstart }
+      self.dirty = false
+      return self.slots
+    end
+
+    def each_slot(&block)
+      self.calculate_free_slots if self.dirty?
+      self.slots.sort! { |a, b| a.dtstart <=> b.dtstart }
+      self.slots.each { |slot| yield(slot) } if block_given?
+    end
+
+    def this_slot?(ev)
+      return (ev.dtstart.day_only >= self.dtstart.day_only && ev.dtend.day_only <= self.dtend.day_only)
+    end
+
+  end
+
+end

data/lib/mo2tex/event.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'icalendar'
+
+module Mo2tex
+
+	class Event 
+
+		attr_reader :dtstart, :dtend, :lnumber, :ltot, :title, :desc, :loc, :online
+
+		def initialize(ls, le, ln, lt, t, desc, loc, online)
+      @dtstart = DateTime.parse(ls.to_s)
+      @dtend   = DateTime.parse(le.to_s)
+      @lnumber = ln
+      @ltot    = lt
+      @title   = t
+      @desc    = desc
+      @loc     = loc
+      @online  = online
+		end
+
+    def to_s
+      return self.title + ' ' + self.dtstart.strftime("%d/%m/%Y %H:%M") + '-' + self.dtend.strftime("%H:%M") + ' ' + self.lnumber.to_s + '/' + self.ltot.to_s
+    end
+
+    def to_ical(ical)
+      ical.event do
+        |e|
+        e.dtstart = self.dtstart
+        e.dtend   = self.dtend
+        e.summary = self.title
+        e.description = self.desc
+        e.location = self.loc
+        e.ip_class = 'PUBLIC'
+        if is_online?
+          e.location = 'Microsoft Teams Meeting'
+          e.description += <<EOR
+\n_____________________________________________________________
+ ___________________\nMicrosoft Teams Need help?<https://aka.ms/JoinTeamsMe
+ eting?omkt=en-US>\nJoin the meeting now<https://teams.microsoft.com/l/meet
+ up-join/19%3ameeting_MWZlZDdkZmMtNjRkNi00M2U3LTgwMzUtMjkwNGQ1YTY3N2I4%40th
+ read.v2/0?context=%7b%22Tid%22%3a%2276c57fd2-8d47-4cb5-a7a2-83c2cd0c3565%2
+ 2%2c%22Oid%22%3a%22a29bd7f0-b99d-4031-8cf5-fabe578a7d05%22%7d>\nMeeting ID
+ : 358 935 834 932\nPasscode: 9wNLge\n________________________________\nFor
+  organizers: Meeting options<https://teams.microsoft.com/meetingOptions/?o
+ rganizerId=a29bd7f0-b99d-4031-8cf5-fabe578a7d05&tenantId=76c57fd2-8d47-4cb
+ 5-a7a2-83c2cd0c3565&threadId=19_meeting_MWZlZDdkZmMtNjRkNi00M2U3LTgwMzUtMj
+ kwNGQ1YTY3N2I4@thread.v2&messageId=0&language=en-US>\n____________________
+ ____________________________________________________________\n
+EOR
+        end
+      end
+      return ical
+    end
+
+    def color
+      return "\"green\""
+    end
+
+    private
+
+      def is_online?
+        result = false
+        self.online.each do
+          |d|
+          dt = DateTime.parse(d.to_s)
+          if self.dtstart.year == dt.year && self.dtstart.month == dt.month && self.dtstart.day == dt.day
+            result = true
+            break
+          end
+        end
+        return result
+      end
+
+	end
+
+end

data/lib/mo2tex/exceptions.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+
+module Mo2tex
+
+		class UnknownCourse < Error; end
+		class UnknownCourseType < Error; end
+	  class UnknownRepetition < Error; end
+		class PureVirtuaMethodCalled < Error; end
+    class DateOutOfRange < Error; end
+    class UnexistentWeekDay < Error; end
+    class UnknownCourseFrequency < Error; end
+    class WrongWeekDay < Error; end
+    class DayIsNotDateTime < Error; end
+    class TimeIsNotString < Error; end
+    class NotAPicContainer < Error; end
+    class GenerationError < Error; end
+    class NotEnoughLessons < GenerationError; end
+    class EventsNotGenerated < GenerationError; end
+
+end

data/lib/mo2tex/exclude_date.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Mo2tex
+
+  class ExcludeBase
+
+    attr_reader :start_period, :end_period
+
+    def initialize(sp, ep)
+      @start_period = DateTime.parse(sp.to_s)
+      @end_period   = DateTime.parse(ep.to_s)
+    end
+
+    def skip?(d)
+      dt = DateTime.parse(d.to_s)
+      return true unless within_period?(dt)
+      return does_it_skip?(dt)
+    end
+
+  protected
+
+    def does_it_skip?(d)
+      raise PureVirtualMethodCalled, 'ExcludeBase#skip'
+    end
+
+    def within_period?(d)
+      return (d >= self.start_period && d <= self.end_period)
+    end
+
+  end
+
+  class ExcludeDate < ExcludeBase
+
+    attr_reader :date
+
+    def initialize(d, sd, ed)
+      super(sd, ed)
+      @date = DateTime.parse(d.to_s)
+      raise DateOutOfRange, self.date.to_s unless within_period?(self.date)
+    end
+
+    def does_it_skip?(d)
+      return d == self.date
+    end
+
+  end
+
+  class ExcludeDates < ExcludeBase
+
+    attr_reader :start_date, :end_date
+
+    def initialize(sd, ed, sp, ep)
+      super(sp, ep)
+      @start_date = DateTime.parse(sd.to_s)
+      @end_date   = DateTime.parse(ed.to_s)
+      raise DateOutOfRange, self.start_date.to_s unless within_period?(self.start_date)
+      raise DateOutOfRange, self.end_date.to_s unless within_period?(self.end_date)
+    end
+
+    def does_it_skip?(d)
+      return (d >= self.start_date && d <= self.end_date)
+    end
+
+  end
+
+end

data/lib/mo2tex/exclusion_manager.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Mo2tex
+
+  class ExclusionManager
+
+    attr_reader :excluded, :start_period, :end_period
+
+    def initialize(exl_array, sp, ep)
+      @start_period = DateTime.parse(sp.to_s)
+      @end_period = DateTime.parse(ep.to_s)
+      @excluded = parse(exl_array)
+    end
+
+    def skip?(d)
+      result = false
+      self.excluded.each { |ed| result |= ed.skip?(d) }
+      return result
+    end
+
+    def out_of_range?(d)
+      dt = DateTime.parse(d.to_s)
+      return (dt < self.start_period || dt > self.end_period)
+    end
+
+    def empty?
+      return self.excluded.empty?
+    end
+
+    def <<(dts)
+      arg = dts.is_a?(Array) ? dts : [ dts ]
+      result = parse(arg)
+      self.excluded.concat(result)
+    end
+
+  private
+
+    def parse(excl_array)
+      result = []
+      excl_array.each do
+        |el|
+        case el
+          when String
+            (sd, ed) = el.split(/-/).map { |n| n.to_i }
+            result << ExcludeDates.new(sd, ed, self.start_period, self.end_period)
+          when Integer
+            result << ExcludeDate.new(el, self.start_period, self.end_period)
+          else
+            raise ArgumentError, "#{el} not recognized"
+        end
+      end
+      return result
+    end
+
+  end
+
+end

data/lib/mo2tex/extensions/date_time.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'date'
+
+class DateTime
+
+  def hm_to_s
+    result = sprintf("%02d:%02d", self.hour, self.minute)
+    return result
+  end
+
+  ITWDAYS = [ 'domenica', 'lunedì', 'martedì', 'mercoledì', 'giovedì', 'venerdì', 'sabato', ]
+
+  def to_it_wday
+    result = ITWDAYS[self.wday]
+    raise UnexistentWeekDay, wd.to_s unless result
+    return result
+  end
+
+  def to_it_roff_wday
+    return to_it_wday.sub(/ì/, "\\(`i")
+  end
+
+  def day_only
+    return self.to_date.to_datetime
+  end
+
+  def round_to_ymdhm
+    result = DateTime.new(self.year, self.month, self.day, self.hour, self.min, 0, 0)
+    return result
+  end
+
+  class << self
+
+    FIRST_MIDNIGHT = DateTime.new(0, 1, 1, 0, 0, 0, 0)
+
+    def first_midnight
+      return FIRST_MIDNIGHT
+    end
+
+    def dayfrac_to_dt(frac)
+      return first_midnight + frac.to_r
+    end
+
+    def dayfrac_to_hm(frac)
+      dt = dayfrac_to_dt(frac)
+      return [dt.hour, dt.minute]
+    end
+
+    def dayfrac_to_hms(frac)
+      return dayfrac_to_dt(frac).hm_to_s
+    end
+
+    def dayfrac_to_dur(frac)
+      return ((frac.to_r*24)*10).round/10.0
+    end
+
+    def from_it_wday(wday)
+      result = ITWDAYS.index(wday)
+      raise UnexistentWeekDay, wday unless result
+      return result
+    end
+
+  end
+
+end

data/lib/mo2tex/latex.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Mo2tex
+
+	DEFAULT_LTDIR = File.expand_path(File.join(['..']*3, 'config', 'templates', 'latex'), __FILE__)
+
+	class Latex
+
+		attr_reader :school, :header, :trailer, :body, :total_hours_done
+
+		def initialize(s)
+      @total_hours_done = 0
+		  @school = s
+			@header = read_header
+			@trailer = read_trailer
+			@body = read_body
+		end
+
+		def generate
+			result = self.header
+			result += self.body.result(binding)
+			result += self.trailer
+		end
+
+		def table_body
+      result = ''
+      head = proc { |title| "\\hline\n\\multicolumn{3}{|l|}{\\bfseries #{title}}\\\\\n\\hline\n" }
+      tail = proc { |sctot| "\\multicolumn{2}{l}{Totale ore corso:} & \\hfill#{sctot.round.to_i}\\\\\n & & \\\\\n" }
+			@total_hours_done, result = self.school.generate(head, tail) do
+        |title, nol, ev|
+        sprintf("%s & %s--%s & Lezione n.%02d/%02d\\\\\n", ev.dtstart.strftime("%d/%m/%Y"),
+                                                           ev.dtstart.strftime("%H:%M"),
+                                                           ev.dtend.strftime("%H:%M"),
+                                                           ev.lnumber, ev.ltot)
+      end
+      @total_hours_done = @total_hours_done.round.to_i
+      return result
+		end
+
+	private
+
+		def read_header
+			return read('header.tex')
+		end
+
+		def read_trailer
+			return read('trailer.tex')
+		end
+
+		def read_body
+			template = read('body.tex.erb')
+			return ERB.new(template)
+		end
+
+		def read(what)
+			result = nil
+			tdir ||= DEFAULT_LTDIR
+			File.open(File.join(tdir, what)) { |fh| result = fh.readlines.join }
+			return result
+		end
+
+	end
+
+end

data/lib/mo2tex/main.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Mo2tex
+
+  module CommonParts
+
+    def m2common(args, io = STDOUT, &block)
+      raise ArgumentError, "Usage: #{File.basename($0)} <config file>" unless args.size > 0
+      school = School.new(args[0])
+      result = yield(school)
+      io.puts(result)
+      return result
+    end
+
+  end
+
+  class << self
+
+    include CommonParts
+
+    #
+    # +m2latex+: produces a LaTeX file from a configuration
+    #
+    def m2latex(args, io = STDOUT)
+      text = m2common(args, io) do
+        |school|
+        latex = Latex.new(school)
+        return latex.generate
+      end
+      return text
+    end
+
+    #
+    # +m2ical+: produces an iCal file from a configuration
+    #
+    def m2ical(args, io = STDOUT)
+      ical = m2common(args, io) do
+        |school|
+        ical = school.cal.create_icalendar(school)
+        return ical.to_ical
+      end
+      return ical
+    end
+
+    #
+    # +m2pic+: produces a pic file from a configuration
+    #
+    def m2pic(args, io = STDOUT)
+      text = m2common(args, io) do
+        |school|
+        pic = Pic::Writer.new(school)
+        return pic.generate
+      end
+      return text
+    end
+  end
+
+end