sapis 0.1.0

data/lib/sapis/generic_helper.rb

@@ -0,0 +1,241 @@
+=begin
+
+<generic_helper.rb> - Part of Sav's APIs.
+Copyright (C) 2011 Saverio Miroddi
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+require 'date'
+
+module GenericHelper
+  def self.do_retry(options={}, &block)
+    max_retries    = options[:max_retries] || 3
+    sleep_interval = options[:sleep      ] || 0
+
+    current_retries = 0
+
+    begin
+      yield
+    rescue
+      current_retries += 1
+
+      if current_retries <= max_retries
+        sleep sleep_interval
+        retry
+      end
+
+      raise
+    end
+  end
+
+  # Trivial version. Can easily be done with a regex.
+  #
+  def self.camelize(string)
+    buffer          = ""
+    capitalize_next = true
+
+    string.chars.each do | char |
+      if char == '_'
+        capitalize_next = true
+      elsif capitalize_next
+        buffer << char.upcase
+        capitalize_next = false
+      else
+        buffer << char
+      end
+    end
+
+    buffer
+  end
+
+  # options:
+  #
+  # :past: [false] the date can be future (supported only by some cases)
+  #
+  # Format:
+  #
+  #   'YYYY-MM-DD', 'YYYYMMDD', 'MMM/DD/YYYY', 'MMM/D(D)', 'D(D)/MMM' (curr. year), 'MMDD' (curr. year)
+  #   'to[day]', 'ye[sterday]', 'mon' (monday), 'tue-' (last tuesday),
+  #   '+3' (today+3), '-2' (today-2)
+  #
+  # Note that the easiest way to pass '-<value>' in bash, is to use '--' (end of options).
+  #
+  def decode_date(encoded_date, future: true)
+    case encoded_date.downcase
+    # YYYY-MM-DD
+    when %r{^(\d\d\d\d)-(\d\d)-(\d\d)$}
+      Date.new($1.to_i, $2.to_i, $3.to_i)
+    # YYYYMMDD
+    when /^(\d\d\d\d)(\d\d)(\d\d)$/
+      Date.new($1.to_i, $2.to_i, $3.to_i)
+    # MMM/DD/YYYY
+    when %r{^(\w{3})/(\d\d)/(\d\d\d\d)$}
+      month_index_for_time = Date.strptime($1, "%b").month
+      Date.new($3.to_i, month_index_for_time, $2.to_i)
+    # MMM/D(D) (+future)
+    when %r{^(\w{3})\/(\d{1,2})$}
+      month_index_for_time = Date.strptime($1, "%b").month
+      Date.new(Date.today.year, month_index_for_time, $2.to_i)
+        .then { !future && it > Date.today ? it << 12 : it }
+    # D(D)/MMM/YYYY
+    when %r{^(\d{1,2})/(\w{3})/(\d\d\d\d)$}
+      month_index_for_time = Date.strptime($2, "%b").month
+      Date.new($3.to_i, month_index_for_time, $1.to_i)
+    # D(D)/MMM
+    when %r{^(\d{1,2})\/(\w{3})$}
+      month_index_for_time = Date.strptime($2, "%b").month
+      Date.new(Date.today.year, month_index_for_time, $1.to_i)
+    # MMDD
+    when /^(\d\d)(\d\d)$/
+      Date.new(Time.now.year, $1.to_i, $2.to_i)
+    when 'to', 'today'
+      Date.today
+    when 'ye', 'yesterday'
+      Date.today - 1
+    when /^(sun|mon|tue|wed|thu|fri|sat)$/
+      diff = (Date.strptime($1, "%a") - Date.today).to_i
+      diff += 7 if diff <= 0
+      Date.today + diff
+    when /^(sun|mon|tue|wed|thu|fri|sat)-$/
+      diff = (Date.strptime($1, "%a") - Date.today).to_i
+      diff -= 7 if diff >= 0
+      Date.today + diff
+    when /^\+(\d+)$/
+      Date.today + $1.to_i
+    when /^-(\d+)$/
+      Date.today - $1.to_i
+    else
+      raise "Unrecognized date: #{ encoded_date }"
+    end
+ end
+
+  # Params:
+  #
+  #   day, start, end
+  #
+  # Format:
+  #
+  #  * DAY:   'YYYY-MM-DD', 'YYYYMMDD', 'MMDD', 'to[day]', 'ye[sterday]', 'thu' (thursday of the current week), 'mon-' (last monday), 'tue+' (next tuesday), 'MMM/DD'
+  #  * START: 'HH', 'HH:MM'
+  #  * END:   '3d', '2h', '45m', 'HH', 'HH:MM'
+  #
+  # Possible combinations:
+  #
+  #  * (nothing)          all today
+  #  * DAY                on the day, for all day
+  #  * DAY,END            from day to end, for all day
+  #  * DAY,START,END      on the day, from start to end
+  #  * START,END          today, from start to end
+  #
+  # Note that the 'current week' starts on Sunday.
+  #==
+  # In the regexes, numbered repetitions ('{n}') are not used for consistency.
+  #
+  # The Date class pretty much sucks. Between the other things, it doesn't accept string
+  # values when instantiating.
+  #
+  def decode_interval(*daytime)
+    current_token = daytime.shift
+
+    if current_token
+      base_day = decode_date(current_token)
+
+      if base_day.nil?
+        base_day = Date.today
+        daytime.unshift(current_token)
+      end
+    else
+      base_day = Date.today
+      daytime.unshift(current_token)
+    end
+
+    raise "Wrong start year format. Non-consumed tokens: #{ daytime }" if base_day.nil?
+
+    current_token = daytime.shift
+
+    # The next token could be both a start (e.g. DAY,START,END) or an END (e.g. DAY,END).
+    # Since we can't rely on character patterns because of the HH:MM case, we rely on the
+    # number of tokens: START can be present only if at this point there are two tokens.
+    #
+    if daytime.size == 1
+      case current_token
+      when /^(\d{1,2})$/
+        start_daytime = Time.local(base_day.year, base_day.month, base_day.day, $1)
+      when /^(\d{1,2}):(\d\d)$/
+        start_daytime = Time.local(base_day.year, base_day.month, base_day.day, $1, $2)
+      else
+        daytime.unshift(current_token)
+      end
+
+      all_day = false
+    else
+      start_daytime = Time.local(base_day.year, base_day.month, base_day.day)
+      all_day = true
+      daytime.unshift(current_token)
+    end
+
+    raise "Wrong start daytime format. Non-consumed tokens: #{ daytime }" if start_daytime.nil?
+
+    current_token = daytime.shift
+
+    if current_token
+      if all_day
+        # Only full days allowed in case of all-day timespan
+        #
+        if current_token =~ /^(\d+)d$/
+          end_daytime = add_days(start_daytime, $1.to_i)
+        else
+          daytime.unshift(current_token)
+        end
+      else
+        case current_token.downcase
+        when /^(\d+)d$/
+          end_daytime = start_daytime + $1.to_i * 24 * 60 * 60
+        when /^(\d+)h$/
+          end_daytime = start_daytime + $1.to_i * 60 * 60
+        when /^(\d+)m$/
+          end_daytime = start_daytime + $1.to_i * 60
+        when /^(\d{1,2})$/
+          end_daytime = Time.local(start_daytime.year, start_daytime.month, start_daytime.day, $1)
+        when /^(\d{1,2}):(\d\d)$/
+          end_daytime = Time.local(start_daytime.year, start_daytime.month, start_daytime.day, $1, $2)
+        else
+          daytime.unshift(current_token)
+        end
+      end
+    else
+      # We're here if none of START/END have been passed; we default to +1 day.
+      # At this point, there are no tokens to unshift
+      #
+      end_daytime = add_days(start_daytime, 1)
+    end
+
+    raise "Wrong end daytime format. Non-consumed tokens: #{ daytime }" if end_daytime.nil?
+
+    raise "Non-consumed tokens found: #{ daytime }" if daytime.size > 0
+
+    [start_daytime, end_daytime, all_day]
+  end
+
+  private
+
+  # Add the given days, ignoring the daylight saving.
+  #
+  def add_days(base_time, days)
+    result_date = Date.new(base_time.year, base_time.month, base_time.day) + days
+    Time.local(result_date.year, result_date.month, result_date.day)
+  end
+end

data/lib/sapis/gnome_helper.rb

@@ -0,0 +1,36 @@
+=begin
+
+<gnome_helper.rb> - Part of Sav's APIs.
+Copyright (C) 2011 Saverio Miroddi
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+require_relative 'bash_helper'
+
+module GnomeHelper
+
+  include BashHelper
+
+  def set_gnome_background( pic_path )
+    simple_bash_execute "gconftool -t string -s /desktop/gnome/background/picture_filename", pic_path
+  end
+
+  def get_gnome_background_filename
+    simple_bash_execute "gconftool -g /desktop/gnome/background/picture_filename"
+  end
+
+end
+

data/lib/sapis/graphing_helper.rb

@@ -0,0 +1,202 @@
+=begin
+
+<graphing_helper.rb> - Part of Sav's APIs.
+Copyright (C) 2011 Saverio Miroddi
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module GraphingHelper
+
+  require 'gruff'
+  require 'tempfile'
+
+  # Transpose from format:
+  #
+  #   label1, labelN, <ignored>
+  #   value,  value,  day1
+  #   value,  value,  day2
+  #
+  # <source_data> is destroyed.
+  # Labels must be unique.
+  # Days can be either a string or a Date.
+  #
+  def self.transpose_data_top_headers( source_data, options={} )
+    fill_missing_days = ! options.has_key?( :fill_missing_days ) || !! options[ :fill_missing_days ]
+
+    labels = source_data.shift[ 0...-1 ]
+
+    source_data.each { | row | row[ row.size - 1 ] = Date.strptime( row.last ) unless row.last.is_a?( Date ) }
+
+    min_day = source_data.map { | row | row.last }.min
+    max_day = source_data.map { | row | row.last }.max
+
+    # Pre-fill the output matrix (hash)
+
+    output_data = labels.inject( {} ) do | current_output_data, label |
+      current_output_data[ label ] = [ nil ] * ( max_day - min_day )
+      current_output_data
+    end
+
+    # Fill the values
+
+    source_data.each do | row |
+      day = row.last
+
+      labels.each_with_index do | label, i |
+        output_data[ label ][ day - min_day ] = row[ i ]
+      end
+    end
+
+    # Apply final manipulations and convert output data to array
+
+    output_data.each { | label, values | values.compact! } if ! fill_missing_days
+
+    output_data = output_data.map { | label, values | [ label, values ] }
+    days        = ( min_day..max_day ).to_a
+
+    [ output_data, days ]
+  end
+
+  # Transpose from format:
+  #
+  #   label1, value,  day1
+  #   labelM, value,  day2
+  #   label1, value,  day3
+  #   labelN, value,  day3
+  #
+  def self.transpose_data_left_headers( source_data )
+    source_data.each { | row | row[ row.size - 1 ] = Date.strptime( row.last ) unless row.last.is_a?( Date ) }
+
+    # Fill a map day => { label => value, ... }
+
+    data_by_day_by_label = {}
+
+    source_data.each do | label, value, day |
+      day = Date.strptime( day ) unless day.is_a?( Date )
+
+      data_by_day_by_label[ day ] ||= {}
+      data_by_day_by_label[ day ][ label ] = value
+    end
+
+    # Convert to tabular form by label
+
+    labels = source_data.map { | row | row.first }.uniq
+
+    output_data = labels.inject( {} ) do | current_output_data, label |
+      current_output_data[ label ] = []
+      current_output_data
+    end
+
+    days = data_by_day_by_label.keys.sort
+
+    days.each do | day |
+      labels_values = data_by_day_by_label[ day ]
+
+      labels.each do | label |
+        value = labels_values[ label ]
+        output_data[ label ] << value
+      end
+    end
+
+    # Apply final manipulations and convert output data to array
+
+    output_data = output_data.map { | label, values | [ label, values ] }
+
+    [ output_data, days ]
+  end
+
+  # Ouput a line graph, optionally to a file.
+  #
+  # Assumes that the row contains the headers.
+  #
+  # options:
+  #  :out_file               output file. if not passed, the graph is displayed live
+  #
+  def self.format_as_line_graph( data, days, options={} )
+    out_file = options[ :out_file     ]
+
+    graph = Gruff::Line.new
+
+    data.each { | label_data | graph.data( *label_data ) }
+
+    graph.labels = {
+      0             => days.first.to_s,
+      days.size - 1 => days.last.to_s,
+    }
+
+    if out_file
+      graph.write( out_file )
+    else
+      Tempfile.open( 'tracking_graph' ) do | f |
+        # Base#write doesn't work because the tempfile doesn't have any extension
+        #
+        rendered_data = graph.to_blob
+        f << rendered_data
+
+        images_display_app = get_images_display_app
+        `#{ images_display_app } #{ f.path }`
+      end
+    end
+  end
+
+  # Assumes that the number of fields for each row is constant.
+  #
+  # options:
+  #  :separator    default: '|'
+  #  :align        hash { <field> => :left }. makes sense only if the first row is the headers.
+  #
+  def self.format_as_table( rows, options={} )
+    return "" if rows.empty?
+
+    separator = options[ :separator ] || '|'
+    align     = options[ :align     ] || {}
+
+    max_field_sizes   = nil
+    alignment_symbols = nil
+
+    rows.each_with_index do | row, row_num |
+      if row_num == 0
+        max_field_sizes   = row.map { | value | value.to_s.size }
+        alignment_symbols = row.map { | value | '-' if align[ value ] == :left }
+      else
+        row.each_with_index do | value, value_pos |
+          max_field_sizes[ value_pos ] = value.to_s.size if value.to_s.size > max_field_sizes[ value_pos ]
+        end
+      end
+    end
+
+    template = separator + max_field_sizes.zip( alignment_symbols ).map { | size, alignment_symbol | " %#{ alignment_symbol }#{ size }s #{ separator }" }.join
+
+    rows.inject( "" ) do | buffer, row |
+      buffer << template % row << "\n"
+    end
+  end
+
+  private
+
+  def self.get_images_display_app
+    case RUBY_PLATFORM
+    when /linux/
+      'eog'
+    when /darwin/
+      'open -W'
+    else
+      raise "Unsupported platform: #{ RUBY_PLATFORM }"
+    end
+  end
+
+end
+

data/lib/sapis/interactions_helper.rb

@@ -0,0 +1,148 @@
+=begin
+
+<interactions_helper.rb> - Part of Sav's APIs.
+Copyright (C) 2011 Saverio Miroddi
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+=end
+
+module InteractionsHelper
+
+  require 'highline/import'
+
+  def self.secure_ask( question='Insert password: ' )
+    HighLine.new.ask( question ) { | q | q.echo = '*' }
+  end
+
+  # Asks a question, optionally using a default.
+  #
+  # Format:
+  #
+  #  <header> [default]?
+  #
+  def self.ask_entry( header, default=nil )
+    while true
+      print "#{ header }"
+      print " [#{ default }]" if default
+      print "? "
+
+      answer = STDIN.gets.chomp
+
+      if answer = '' && default
+        return default
+      elsif answer != ''
+        return answer
+      end
+    end
+  end
+
+  # Displays a numbered (or user-choosen) list of entries, in the format:
+  #
+  #   entry_a) value_a
+  #   entry_b) value_b
+  #
+  # or
+  #
+  #   0) value_a
+  #   1) value_b
+  #
+  # depending on <entries> being respectively a Hash or an Array.
+  #
+  # options:
+  #   :default:            default entry, if the user doesn't choose
+  #   :autochoose_if_one:  [false] automatically choose the entry if it's only one
+  #   :filter_by:          [nil] String (for simplicity), which is matched case-insensitively.
+  #                        If there are more matches and the pattern matches exactly one of
+  #                        them, it's automatically chosen.
+  #
+  def self.ask_entries_with_points( header, entries, options={} )
+    raise ArgumentError.new("No entries passed! [#{header}]") if entries.empty?
+
+    default           = options[ :default ]
+    autochoose_if_one = options[ :autochoose_if_one ]
+    filtering_pattern = options[ :filter_by ]
+
+    raise "Pattern must be a String, Regexp is not supported" if filtering_pattern.is_a?( Regexp )
+
+    # Convert to Hash if it's an array
+    #
+    if entries.is_a?( Array )
+      entries = ( 0 ... entries.size ).zip( entries )
+
+      entries = entries.inject( {} ) do | current_entries, ( i, entry ) |
+        current_entries[ i.to_s ] = entry
+        current_entries
+      end
+    end
+
+    if filtering_pattern
+      exact_matches = entries.select { | _, entry_value | entry_value.downcase == filtering_pattern.downcase }
+
+      return exact_matches.values.first if exact_matches.size == 1
+
+      entries = entries.select { | _, entry_value | entry_value.downcase.include?( filtering_pattern.downcase ) }
+
+      raise ArgumentError.new("No entries after filtering! [#{header}, #{filtering_pattern}]") if entries.empty?
+    end
+
+    if entries.size == 1 && (autochoose_if_one || filtering_pattern)
+      return entries.values.first
+    end
+
+    while true
+      puts "#{ header }:"
+
+      entries.each do | point, entry |
+        print " #{ point }"
+        print default.to_s == entry ? '*' : ')'
+        puts " #{ entry }"
+      end
+
+      answer = STDIN.gets.chomp
+
+      if answer == '' && default
+        break default
+      elsif entries.has_key?( answer )
+        break entries[ answer ]
+      end
+    end
+  end
+
+  # Displays a list of entries, in the format:
+  #
+  #   header: entry_a,entry_b [default]?
+  #
+  def self.ask_entries_in_line( header, entries, default=nil )
+    while true
+      print "#{ header }: "
+
+      print entries.join( ',' )
+
+      print " [#{ default }]" if default
+
+      print "? "
+
+      answer = STDIN.gets.chomp
+
+      if answer == '' && default
+        break default
+      elsif entries.include?( answer )
+        break answer
+      end
+    end
+  end
+
+end
+