studium 0.10.1

data/lib/studium/base/reset.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'studium/base/reset.rb'
+# =========================================================================== #
+module Studium
+
+class Base
+
+  require 'studium/colours/colours.rb'
+  require 'studium/constants/namespace.rb'
+  require 'studium/base/mode.rb'
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  #
+  # The @runmode variable can be any of these three values:
+  #
+  #   :www
+  #   :gui
+  #   :commandline
+  #
+  # If :commandline is used as its value, then this class may colourize via
+  # the Colours module - otherwise, it may colourize via "websafe" colours
+  # instead (such as the HTML colours).
+  #
+  # Note that :gui means GUI, that is, graphical user interface. These
+  # are traditional "oldschool" desktop applications.
+  # ========================================================================= #
+  def reset
+    # ======================================================================= #
+    # === @namespace
+    # ======================================================================= #
+    @namespace = NAMESPACE
+    # ======================================================================= #
+    # === @be_verbose
+    # ======================================================================= #
+    @be_verbose = true
+    # ======================================================================= #
+    # === @use_opn
+    #
+    # By default we will use opn in the project. The name "opn" stands
+    # short for "output program name".
+    # ======================================================================= #
+    @use_opn = true
+    # ======================================================================= #
+    # === @debug
+    #
+    # The next variable determines whether we will debug or whether we
+    # will not. If @debug is set to true, then we won't make modifications -
+    # instead, we will give debug information to the user.
+    # ======================================================================= #
+    @debug = false
+    # ======================================================================= #
+    # === @use_colours
+    #
+    # The next variable determines whether instances of this class will
+    # make use of colours. By default the value from a toplevel-variable
+    # will be used as default start value. Thus, initially, they have
+    # the same value.
+    # ======================================================================= #
+    @use_colours = ::Studium.use_colours?
+    # ======================================================================= #
+    # === @no_connection_to_the_www
+    #
+    # If true then we have no connection to the WWW.
+    # ======================================================================= #
+    @no_connection_to_the_www = false
+    # ======================================================================= #
+    # Next, determine which "mode" is used, such as www-mode, commandline
+    # mode or similar.
+    # ======================================================================= #
+    set_mode :commandline  # The default mode is commandline.
+  end
+
+end; end

data/lib/studium/base/run.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'studium/base/run.rb'
+# =========================================================================== #
+module Studium
+
+class Base # === Studium::Base
+
+  # ========================================================================= #
+  # === run
+  # ========================================================================= #
+  def run
+  end
+
+end; end

data/lib/studium/base/src_dir_at_home.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'studium/base/src_dir_at_home.rb'
+# =========================================================================== #
+module Studium
+
+class Base # === Studium::Base
+
+  require 'studium/constants/roebe.rb'
+
+  # ========================================================================= #
+  # === ruby_src_dir_at_home?
+  # ========================================================================= #
+  def ruby_src_dir_at_home?
+    Studium.ruby_src_dir_at_home?
+  end
+
+end; end

data/lib/studium/base/time.rb

@@ -0,0 +1,634 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'studium/base/time.rb'
+# =========================================================================== #
+module Studium
+
+class Base # === Studium::Base
+
+  require 'studium/toplevel_methods/time.rb'
+
+  # ========================================================================= #
+  # === COMMON_YEAR_DAYS_IN_MONTH
+  #
+  # This constant has the days per month, for the whole year.
+  #
+  # It will not honour leap years properly, though.
+  # ========================================================================= #
+  COMMON_YEAR_DAYS_IN_MONTH = [
+    nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
+  ]
+
+  # ========================================================================= #
+  # === datum?
+  # ========================================================================= #
+  def datum?
+    Studium.datum? # ← Available in "studium/toplevel_methods/time.rb".
+  end
+
+  # ========================================================================= #
+  # === return_n_days_until_sunday
+  # ========================================================================= #
+  def return_n_days_until_sunday(time_now = Time.now)
+    n_days_difference_from_today_to_this_day(time_now, 'Sunday')
+  end
+
+  # ========================================================================= #
+  # === return_n_days_until_monday
+  # ========================================================================= #
+  def return_n_days_until_monday(time_now = Time.now)
+    n_days_difference_from_today_to_this_day(time_now, 'Monday')
+  end
+
+  # ========================================================================= #
+  # === n_days_difference_from_today_to_this_day
+  #
+  # This method will return a number, which is the amount of days between
+  # weekdays.
+  #
+  # The days are numbered like this:
+  #
+  #    Monday:    1
+  #    Tuesday:   2
+  #    Wednesday: 3
+  #    Thursday:  4
+  #    Friday:    5
+  #    Saturday:  6
+  #    Sunday:    0
+  #
+  # So, how to calculate the time difference to the next day?
+  #
+  # Well, say we have the current day be a Wednesday, and the day that is
+  # to be compared, a Friday. The difference is thus (5 - 3 = 2). If the
+  # current day is a Saturday, and the input-day is a Friday, then
+  # the difference must be 5.
+  #
+  # If we have, for example, "Friday" to "Tuesday", the this method
+  # should return the number 4, because the distance is that: Friday,
+  # Saturday, Sunday and Monday (the start day has to be included, as
+  # lectures can happen on that day still, e. g. if you check early
+  # in the morning, you could still have courses in the evening
+  # slots scheduled).
+  # ========================================================================= #
+  def n_days_difference_from_today_to_this_day(
+      time_now = Time.now,
+      name_of_the_future_day # ← This ought to be a String, such as "Monday".
+    )
+    n_days_difference = 0
+    weekday_as_number = time_now.wday
+    name_of_the_future_day = name_of_the_future_day.dup if name_of_the_future_day.frozen?
+    name_of_the_future_day.strip! # We better strip that input.
+    start_day = Date::DAYNAMES[weekday_as_number]
+    # ======================================================================= #
+    # The next is simply a hardcoded table. We will begin with the
+    # future day.
+    # ======================================================================= #
+    n_days_difference =
+    case start_day
+    when 'Monday'
+      case name_of_the_future_day
+      when 'Tuesday'   then 1
+      when 'Wednesday' then 2
+      when 'Thursday'  then 3
+      when 'Friday'    then 4
+      when 'Saturday'  then 5
+      when 'Sunday'    then 6
+      end
+    when 'Tuesday'
+      case name_of_the_future_day
+      when 'Wednesday' then 1
+      when 'Thursday'  then 2
+      when 'Friday'    then 3
+      when 'Saturday'  then 4
+      when 'Sunday'    then 5
+      when 'Monday'    then 6
+      end
+    when 'Wednesday'
+      case name_of_the_future_day
+      when 'Thursday'  then 1
+      when 'Friday'    then 2
+      when 'Saturday'  then 3
+      when 'Sunday'    then 4
+      when 'Monday'    then 5
+      when 'Tuesday'   then 6
+      end
+    when 'Thursday'
+      case name_of_the_future_day
+      when 'Friday'    then 1
+      when 'Saturday'  then 2
+      when 'Sunday'    then 3
+      when 'Monday'    then 4
+      when 'Tuesday'   then 5
+      when 'Wednesday' then 6
+      end
+    when 'Friday'
+      case name_of_the_future_day
+      when 'Saturday'  then 1
+      when 'Sunday'    then 2
+      when 'Monday'    then 3
+      when 'Tuesday'   then 4
+      when 'Wednesday' then 5
+      when 'Thursday'  then 6
+      end
+    when 'Saturday'
+      case name_of_the_future_day
+      when 'Sunday'    then 1
+      when 'Monday'    then 2
+      when 'Tuesday'   then 3
+      when 'Wednesday' then 4
+      when 'Thursday'  then 5
+      when 'Friday'    then 6
+      end
+    when 'Sunday'
+      case name_of_the_future_day
+      when 'Monday'    then 1
+      when 'Tuesday'   then 2
+      when 'Wednesday' then 3
+      when 'Thursday'  then 4
+      when 'Friday'    then 5
+      when 'Saturday'  then 6
+      end
+    end
+    return n_days_difference
+  end
+
+  # ========================================================================= #
+  # === current_month?
+  #
+  # Show us the current month, as Integer. For example, for April, this
+  # method would return the number 4.
+  # ========================================================================= #
+  def current_month?
+    Time.now.strftime('%m').to_i
+  end; alias month?                           current_month? # === month?
+       alias return_current_month_as_a_number current_month? # === return_current_month_as_a_number
+
+  # ========================================================================= #
+  # === return_current_year
+  #
+  # This method will simply return the current year, as String.
+  # ========================================================================= #
+  def return_current_year
+    Time.now.year.to_s
+  end; alias current_year? return_current_year # === current_year?
+
+  # ========================================================================= #
+  # === this_month_has_n_days?
+  #
+  # This method will return the maximum amount of days in the given
+  # month.
+  # ========================================================================= #
+  def this_month_has_n_days?(
+      this_month,
+      this_year = Time.now.year
+    )
+    this_month = this_month.to_i
+    return 29 if this_month == 2 && Date.gregorian_leap?(this_year)
+    COMMON_YEAR_DAYS_IN_MONTH[this_month] 
+  end
+
+  # ========================================================================= #
+  # === return_month_fitting_to_this_input
+  #
+  # This method will return a number.
+  # ========================================================================= #
+  def return_month_fitting_to_this_input(i)
+    i = i.capitalize
+    if MONTH_NAME_TO_MONTH_NUMBER.has_key? i
+      i = MONTH_NAME_TO_MONTH_NUMBER[i]
+    end
+    i.to_i
+  end
+
+  # ========================================================================= #
+  # === extract_dd_mm_yyyy
+  #
+  # This method can be used to extract the dd.mm.yyyy format from the given
+  # input at hand. It will discard everything else.
+  #
+  # So, for instance, if the input is "15.10.2018, 09:00-18:00" then
+  # this method will return only "15.10.2018".
+  # ========================================================================= #
+  def extract_dd_mm_yyyy(i)
+    i =~ /(\d{1,2}\.\d{1,2}\.\d{4})/ # This will also generate a match.
+    $1.to_s.dup
+  end; alias extract_ddmmyyyy extract_dd_mm_yyyy # === extract_ddmmyyyy
+
+  # ========================================================================= #
+  # === has_year_entry?
+  #
+  # This method will return a Boolean.
+  #
+  # It will return true if the line has a year entry such as '2018'; and
+  # it will return false, otherwise.
+  # ========================================================================= #
+  def has_year_entry?(this_line)
+    this_line =~ /\d{4}/ # If this line has at the least one entry with 4 numbers.
+  end; alias this_line_has_a_year_entry? has_year_entry? # === has_year_entry?
+
+  # ========================================================================= #
+  # === add_proper_year_entry_to_this_line
+  #
+  # This method will add a proper year entry to a line. It will either
+  # append a year entry - or, which may be more useful, try to insert
+  # the year-entry into a position that fits. The latter will make
+  # use of a regex.
+  #
+  # A test string for the latter is the following:
+  #
+  #   "Dienstag   02.10. 11:30-13:00 UZA2 Hörsaal 5 Raum 2Z202 2.OG"
+  #
+  # ========================================================================= #
+  def add_proper_year_entry_to_this_line(line)
+    result = line.dup
+    current_year = Time.now.year
+    use_this_regex = # See: http://rubular.com/r/xV0yNSYhWW
+      /^(.+)(\d{2}\.\d{1,2}\.) (\d{1,2}:\d{1,2}(-| )?\d{1,2}:\d{1,2})(.+)$/
+    if result =~ use_this_regex
+      result.sub!(use_this_regex, '\1\2'+current_year.to_s+', \3\5')
+    else # this here is the simpler case
+      result << current_year # This is the variant that will simply append.
+    end
+    result
+  end
+
+  # ========================================================================= #
+  # === remove_weekday_names_from
+  #
+  # This method will remove Strings such as "Monday" or "Montag" from
+  # the given input argument.
+  # ========================================================================= #
+  def remove_weekday_names_from(i)
+    Studium.remove_weekday_names_from(i)
+  end; alias remove_weekname_from      remove_weekday_names_from # === remove_weekname_from
+       alias remove_weekdays           remove_weekday_names_from # === remove_weekdays
+       alias remove_weekday_names_from remove_weekday_names_from # === remove_weekday_names_from
+       alias remove_weeknames_from     remove_weekday_names_from # === remove_weeknames_from
+       alias remove_weeknames          remove_weekday_names_from # === remove_weeknames
+       alias remove_weekday_name       remove_weekday_names_from # === remove_weekday_name
+
+  # ========================================================================= #
+  # === number_to_month
+  #
+  # This method will convert a number, such as 6, to the corresponding
+  # month entry.
+  # ========================================================================= #
+  def number_to_month(i)
+    array = Date::MONTHNAMES
+    i = i.to_i
+    return array[i]
+  end
+
+  # ========================================================================= #
+  # === translate_dd_mm_yyyy_to_weekday
+  #
+  # This method will return the weekday of a given dd.mm.yyyy date.
+  #
+  # If the given input is, for example, the String '25.02.2019', then
+  # this method will return the String 'Monday'.
+  # ========================================================================= #
+  def translate_dd_mm_yyyy_to_weekday(
+      i = '25.02.2020'
+    )
+    weekday?(i)
+  end; alias translate_dd_mm_yyy_to_weekday translate_dd_mm_yyyy_to_weekday # === translate_dd_mm_yyy_to_weekday
+
+  # ========================================================================= #
+  # === return_name_of_the_weekday
+  #
+  # This method can be used to return an associated weekday to a specific
+  # date, such as '22.02.2018'. The format has to be in dd.mm.yyyy.
+  # ========================================================================= #
+  def return_name_of_the_weekday(
+      i = :today
+    )
+    begin
+      require 'roebe/constants/time.rb'
+    rescue LoadError; end
+    case i
+    # ======================================================================= #
+    # === :today
+    # ======================================================================= #
+    when :today
+      i = Roebe.return_german_weekday(i) if Object.const_defined? :Roebe
+    end
+    if i.include? ','
+      splitted = i.split(',')
+      first = splitted.first
+      if first.count('.') > 1
+        return Roebe.return_german_weekday(first) if Object.const_defined? :Roebe
+      end
+    else
+      return i
+    end
+  end; alias return_weekday return_name_of_the_weekday # === return_weekday
+
+  # ========================================================================= #
+  # === weekday?
+  #
+  # This method will return a String such as "Thursday". Note that the
+  # english name will be returned by default. This can be changed via
+  # the second parameter to this method, which can be either :english
+  # or :german.
+  #
+  # The input to this method should be a number, such as can be obtained
+  # via the method .wday().
+  #
+  # A String can also be passed into this method, in a form like
+  # "dd.mm.yyyy". So, an input String such as "10.03.2018" is
+  # perfectly valid.
+  # ========================================================================= #
+  def weekday?(
+      i                 = Date.today.wday,
+      use_this_language = :english
+    )
+    if i.is_a?(String) and i.include?('.')
+      # ===================================================================== #
+      # In this case here assume an input-String such as "12.03.2018".
+      # ===================================================================== #
+      begin
+        i = Time.parse(i).wday
+      rescue ArgumentError => error
+        pp error
+      end
+    end
+    result = Date::DAYNAMES[i]
+    case use_this_language
+    # ======================================================================= #
+    # === :german
+    # ======================================================================= #
+    when :german,
+         :use_german
+      # ===================================================================== #
+      # In this case we have to translate to the german name.
+      # ===================================================================== #
+      result = ENGLISH_TO_GERMAN_WEEKDAYS[result]
+    end
+    return result
+  end; alias return_name_for_this_day       weekday? # === return_name_for_this_day
+       alias return_weekday_for             weekday? # === return_weekday_for
+       alias return_weekday_of              weekday? # === return_weekday_of
+       alias return_weekday_from_this_input weekday? # === return_weekday_from_this_input
+
+  # ========================================================================= #
+  # === return_german_weekday_of?
+  # ========================================================================= #
+  def return_german_weekday_of?(i)
+    weekday?(i, :german)
+  end
+
+  # ========================================================================= #
+  # === german_date_notation
+  #
+  # Give a Range as input, and it will give us back a String that
+  # shows german date notation, aka DD.MM.YYYY.
+  # ========================================================================= #
+  def german_date_notation(
+      i, use_this_token_as_separator = '-'
+    )
+    # ======================================================================= #
+    # === Handle Range objects next
+    # ======================================================================= #
+    if i.is_a? Range
+      start_date  = i.begin
+      end_date    = i.end
+      start_day   = start_date.day.to_s.rjust(2, '0')
+      start_month = start_date.month.to_s.rjust(2, '0')
+      start_year  = start_date.year.to_s
+      end_day     = end_date.day.to_s.rjust(2, '0')
+      end_month   = end_date.month.to_s.rjust(2, '0')
+      end_year    = end_date.year.to_s
+      i = start_day+'.'+start_month+'.'+start_year+' '+
+          use_this_token_as_separator+' '+
+          end_day+'.'+end_month+'.'+end_year
+    # ======================================================================= #
+    # === Handle Time objects next
+    #
+    # This requires no token.
+    # ======================================================================= #
+    elsif i.is_a? Time
+      i = "#{i.day.to_s.rjust(2, '0')}."\
+          "#{i.month.to_s.rjust(2, '0')}."\
+          "#{i.year.to_s}"
+    end
+    return i
+  end; alias german_notation                german_date_notation # === german_notation
+       alias to_german_date                 german_date_notation # === to_german_date
+       alias german_formatting_for_the_date german_date_notation # === german_formatting_for_the_date
+
+  # ========================================================================= #
+  # === show_todays_date
+  # ========================================================================= #
+  def show_todays_date
+    e 'Today is the '+slateblue(today?)+' ('+lightgreen(weekday?)+')'; e
+  end
+
+  # ========================================================================= #
+  # === day_month_year
+  #
+  # This method will return a dd.mm.yyyy notation.
+  #
+  # If you need to find out whether the given input-day is today, then
+  # use the method called .is_this_day_today?, defined in this file.
+  #
+  # An example for this will be:
+  #
+  #   03.04.2020
+  #
+  # ========================================================================= #
+  def day_month_year(
+      use_this_time = Time.now
+    )
+    if use_this_time.is_a? Time
+      use_this_time.strftime('%d.%m.%Y')
+    else
+      use_this_time
+    end
+  end; alias today?                day_month_year # === today?
+       alias return_day_month_year day_month_year # === return_day_month_year
+       alias dd_mm_yyyy            day_month_year # === dd_mm_yyyy
+       alias return_dd_mm_yyyy     day_month_year # === return_dd_mm_yyyy
+
+  # ========================================================================= #
+  # === is_this_day_today?
+  #
+  # This method will return true or false, depending on whether the given
+  # input is assumed to be the present day or not.
+  #
+  # The method assumes that the input will be a Time object normally.
+  # ========================================================================= #
+  def is_this_day_today?(i = '18.02.2020')
+    dd_mm_yyyy(Time.now) == dd_mm_yyyy(i)
+  end
+
+  # ========================================================================= #
+  # === german_weekday?
+  #
+  # This method will return a german weekday, for the given input. The
+  # input should be the specific wday at hand.
+  # ========================================================================= #
+  def german_weekday?(
+      i = Date.today.wday
+    )
+    weekday?(i, :german)
+  end; alias weekday_at     german_weekday? # === weekday_at
+       alias german_weekday german_weekday? # === german_weekday
+
+  # ========================================================================= #
+  # === return_german_name_for_this_english_month
+  # ========================================================================= #
+  def return_german_name_for_this_english_month(i)
+    array = MONTH_NAME_ALIASES_GERMAN_TO_ENGLISH.invert
+    array[i]
+  end
+
+  # ========================================================================= #
+  # === english_to_german_weekday
+  #
+  # This method will simply convert e. g. "Monday" into "Montag". In other
+  # words: it will convert from the english name for a day into the
+  # german name of that day.
+  # ========================================================================= #
+  def english_to_german_weekday(english_day)
+    ENGLISH_TO_GERMAN_WEEKDAYS[english_day]
+  end
+
+  # ========================================================================= #
+  # === weekdays?
+  #
+  # This method will return all weekdays, as Array, including german
+  # and english names for these weekdays.
+  # ========================================================================= #
+  def weekdays?
+    (
+      ARRAY_GERMAN_WEEKDAYS+
+      HASH_SHORT_TO_LONG_WEEKDAYS.values
+    ).flatten
+  end
+
+  # ========================================================================= #
+  # === german_weekdays?
+  # ========================================================================= #
+  def german_weekdays?
+    ARRAY_GERMAN_WEEKDAYS
+  end
+
+  # ========================================================================= #
+  # === does_this_line_include_a_german_weekday?
+  # ========================================================================= #
+  def does_this_line_include_a_german_weekday?(i)
+    ARRAY_GERMAN_WEEKDAYS.any? {|this_german_weekday|
+      i.include? this_german_weekday
+    }
+  end
+
+  # ========================================================================= #
+  # === remove_leading_weekday_names_from
+  #
+  # Chop away the leading weekday, e. g. "Monday", from the String at hand.
+  # ========================================================================= #
+  def remove_leading_weekday_names_from(i)
+    Studium.remove_leading_weekday_names_from(i)
+  end; alias remove_german_weekdays         remove_leading_weekday_names_from # === remove_german_weekdays
+       alias remove_german_weekdays_from    remove_leading_weekday_names_from # === remove_german_weekdays_from
+       alias remove_leading_weeknames       remove_leading_weekday_names_from # === remove_leading_weeknames
+       alias remove_leading_weekdays        remove_leading_weekday_names_from # === remove_leading_weekdays
+       alias remove_workday_from_this_input remove_leading_weekday_names_from # === remove_workday_from_this_input
+
+  # ========================================================================= #
+  # === return_dd_mm_yy_and_time_from
+  #
+  # This method will return the day, in dd.mm.yyyy format, and the
+  # time on that date. You have to pass in a special object to this
+  # method, such as an instance of class Time - see methods used
+  # such as .day() or .month() and so forth.
+  # ========================================================================= #
+  def return_dd_mm_yy_and_time_from(i)
+    Studium.return_dd_mm_yy_and_time_from(i)
+  end
+
+  # ========================================================================= #
+  # === return_hh_mm_ss_from
+  #
+  # Input to this method may be like this:
+  #
+  #   2020-03-04 00:00:00 +0000
+  #
+  # It will then return the ss:mm:hh notation.
+  # ========================================================================= #
+  def return_hh_mm_ss_from(i)
+    if i.is_a? String
+      i = Time.parse(i)
+    end
+    if i.is_a? Time
+      "#{i.hour.to_s.rjust(2,'0')}:"\
+      "#{i.min.to_s.rjust(2,'0')}:"\
+      "#{i.sec.to_s.rjust(2,'0')}"
+    else
+      e 'Unknown time format.'
+    end
+  end; alias hh_mm_ss return_hh_mm_ss_from # === hh_mm_ss
+
+  # ========================================================================= #
+  # === hh_mm_ss_dd_mm_yyyy
+  # ========================================================================= #
+  def hh_mm_ss_dd_mm_yyyy(i)
+    hh_mm_ss(i)+'-'+dd_mm_yyyy(i)
+  end
+
+  # ========================================================================= #
+  # === return_hour_from_this
+  #
+  # This method will extract the time-format from a String,
+  # such as:
+  #
+  #   "18.02.2020, 17:00-18:00"
+  #   "Dienstag 13.10.2020, 14:30-17:45"
+  #
+  # A String will be returned in this event, holding the start and
+  # stop time - for instance, in the first example it would return
+  # the String "17:00-18:00".
+  #
+  # A String should be given as argument to this method.
+  # ========================================================================= #
+  def return_hour_from_this(i)
+    i.scan(
+      /\d{2}:\d{2}-\d{2}:\d{2}/
+    ).flatten.first.to_s.strip
+  end; alias extract_the_time_from return_hour_from_this # === extract_the_time
+
+  # ========================================================================= #
+  # === sort_these_lecture_names_by_time
+  # ========================================================================= #
+  def sort_these_lecture_names_by_time(
+      array, weekday
+    )
+    _ = main_dataset?
+    array.sort_by {|entry|
+      pointer = _[entry]
+      lva_date = pointer['lva_dates'].select {|entry|
+        entry.include? weekday
+      }
+      lva_date = lva_date.first if lva_date.is_a? Array
+      lva_date = return_hour_from_this(lva_date) # This will be like "08:00-09:45"
+      # ===================================================================== #
+      # However had, we only need the last part, so chop it down.
+      # ===================================================================== #
+      if lva_date.include? '-'
+        lva_date = lva_date.split('-').first
+      end
+      timestamp = Time.parse(lva_date)
+      timestamp # And "return" it here.
+    }
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  x = Studium::Base.new
+  puts x.this_month_has_n_days?('10')
+  puts x.this_month_has_n_days?('11')
+  puts x.this_month_has_n_days?('12')
+end