sapis 0.1.0 → 0.2.0

data/lib/sapis/graphing_helper.rb

@@ -19,7 +19,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 =end
 
 module GraphingHelper
-
   require 'gruff'
   require 'tempfile'
 
@@ -33,41 +32,41 @@ module GraphingHelper
   # 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 ]
+  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 ]
+    labels = source_data.shift[0...-1]
 
-    source_data.each { | row | row[ row.size - 1 ] = Date.strptime( row.last ) unless row.last.is_a?( Date ) }
+    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
+    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 )
+    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 |
+    source_data.each do |row|
       day = row.last
 
-      labels.each_with_index do | label, i |
-        output_data[ label ][ day - min_day ] = row[ i ]
+      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.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 = output_data.map { |label, values| [label, values] }
+    days        = (min_day..max_day).to_a
 
-    [ output_data, days ]
+    [output_data, days]
   end
 
   # Transpose from format:
@@ -77,45 +76,45 @@ module GraphingHelper
   #   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 ) }
+  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 )
+    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
+      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
+    labels = source_data.map { |row| row.first }.uniq
 
-    output_data = labels.inject( {} ) do | current_output_data, label |
-      current_output_data[ label ] = []
+    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 ]
+    days.each do |day|
+      labels_values = data_by_day_by_label[day]
 
-      labels.each do | label |
-        value = labels_values[ label ]
-        output_data[ label ] << value
+      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 = output_data.map { |label, values| [label, values] }
 
-    [ output_data, days ]
+    [output_data, days]
   end
 
   # Ouput a line graph, optionally to a file.
@@ -125,12 +124,12 @@ module GraphingHelper
   # 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     ]
+  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 ) }
+    data.each { |label_data| graph.data(*label_data) }
 
     graph.labels = {
       0             => days.first.to_s,
@@ -138,16 +137,16 @@ module GraphingHelper
     }
 
     if out_file
-      graph.write( out_file )
+      graph.write(out_file)
     else
-      Tempfile.open( 'tracking_graph' ) do | f |
+      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 }`
+        `#{images_display_app} #{f.path}`
       end
     end
   end
@@ -158,29 +157,29 @@ module GraphingHelper
   #  :separator    default: '|'
   #  :align        hash { <field> => :left }. makes sense only if the first row is the headers.
   #
-  def self.format_as_table( rows, options={} )
+  def self.format_as_table(rows, options={})
     return "" if rows.empty?
 
-    separator = options[ :separator ] || '|'
-    align     = options[ :align     ] || {}
+    separator = options[:separator] || '|'
+    align     = options[:align] || {}
 
     max_field_sizes   = nil
     alignment_symbols = nil
 
-    rows.each_with_index do | row, row_num |
+    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 }
+        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 ]
+        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
+    template = separator + max_field_sizes.zip(alignment_symbols).map { |size, alignment_symbol| " %#{alignment_symbol}#{size}s #{separator}" }.join
 
-    rows.inject( "" ) do | buffer, row |
+    rows.inject("") do |buffer, row|
       buffer << template % row << "\n"
     end
   end
@@ -194,9 +193,7 @@ module GraphingHelper
     when /darwin/
       'open -W'
     else
-      raise "Unsupported platform: #{ RUBY_PLATFORM }"
+      raise "Unsupported platform: #{RUBY_PLATFORM}"
     end
   end
-
 end
-

data/lib/sapis/interactions_helper.rb

@@ -19,11 +19,10 @@ 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 = '*' }
+  def self.secure_ask(question='Insert password: ')
+    HighLine.new.ask(question) { |q| q.echo = '*' }
   end
 
   # Asks a question, optionally using a default.
@@ -32,10 +31,10 @@ module InteractionsHelper
   #
   #  <header> [default]?
   #
-  def self.ask_entry( header, default=nil )
+  def self.ask_entry(header, default=nil)
     while true
-      print "#{ header }"
-      print " [#{ default }]" if default
+      print "#{header}"
+      print " [#{default}]" if default
       print "? "
 
       answer = STDIN.gets.chomp
@@ -67,32 +66,32 @@ module InteractionsHelper
   #                        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={} )
+  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 ]
+    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 )
+    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 )
+    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
+      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 }
+      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 ) }
+      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
@@ -102,20 +101,20 @@ module InteractionsHelper
     end
 
     while true
-      puts "#{ header }:"
+      puts "#{header}:"
 
-      entries.each do | point, entry |
-        print " #{ point }"
+      entries.each do |point, entry|
+        print " #{point}"
         print default.to_s == entry ? '*' : ')'
-        puts " #{ entry }"
+        puts " #{entry}"
       end
 
       answer = STDIN.gets.chomp
 
       if answer == '' && default
         break default
-      elsif entries.has_key?( answer )
-        break entries[ answer ]
+      elsif entries.has_key?(answer)
+        break entries[answer]
       end
     end
   end
@@ -124,13 +123,13 @@ module InteractionsHelper
   #
   #   header: entry_a,entry_b [default]?
   #
-  def self.ask_entries_in_line( header, entries, default=nil )
+  def self.ask_entries_in_line(header, entries, default=nil)
     while true
-      print "#{ header }: "
+      print "#{header}: "
 
-      print entries.join( ',' )
+      print entries.join(',')
 
-      print " [#{ default }]" if default
+      print " [#{default}]" if default
 
       print "? "
 
@@ -138,11 +137,9 @@ module InteractionsHelper
 
       if answer == '' && default
         break default
-      elsif entries.include?( answer )
+      elsif entries.include?(answer)
         break answer
       end
     end
   end
-
 end
-

data/lib/sapis/multimedia_helper.rb

@@ -22,38 +22,37 @@ require_relative 'system_helper'
 require_relative 'bash_helper'
 
 module MultimediaHelper
-
   include SystemHelper, BashHelper
 
-  RHYTHMBOX_PLAYLISTS_FILE = File.expand_path( '.local/share/rhythmbox/playlists.xml', '~' )
-  BANSHEE_DATA_FILE        = File.expand_path( '.config/banshee-1/banshee.db', '~' )
-  AUDIO_FILES_EXTENSIONS   = [ 'm4a', 'mp3' ]
+  RHYTHMBOX_PLAYLISTS_FILE = File.expand_path('.local/share/rhythmbox/playlists.xml', '~')
+  BANSHEE_DATA_FILE        = File.expand_path('.config/banshee-1/banshee.db', '~')
+  AUDIO_FILES_EXTENSIONS   = ['m4a', 'mp3']
 
-  def image_format( image_data )
-    if image_data.start_with?( 'GIF8' )
+  def image_format(image_data)
+    if image_data.start_with?('GIF8')
       'gif'
-    elsif image_data.start_with?( "\xFF\xD8\xFF\xE0" )
+    elsif image_data.start_with?("\xFF\xD8\xFF\xE0")
       'jpg'
     else
       raise "Unrecognized picture format."
     end
   end
 
-  def play_audio_file( filename )
-    filename = File.expand_path( filename )
+  def play_audio_file(filename)
+    filename = File.expand_path(filename)
 
     if SystemHelper.mac?
       simple_bash_execute 'afplay', filename
     else
-      simple_bash_execute "gst-launch-1.0 playbin -q", "uri=file://#{ filename }"
+      simple_bash_execute "gst-launch-1.0 playbin -q", "uri=file://#{filename}"
     end
   end
 
-  def normalize_songs( *files )
+  def normalize_songs(*files)
     files.flatten!
 
-    mp3_files = files.select { | file | file =~ /\.mp3$/i }
-    mp4_files = files.select { | file | file =~ /\.m4a$/i }
+    mp3_files = files.select { |file| file =~ /\.mp3$/i }
+    mp4_files = files.select { |file| file =~ /\.m4a$/i }
 
     raise "xxx!" if mp3_files.size + mp4_files.size != files.size
 
@@ -68,80 +67,80 @@ module MultimediaHelper
 
   # Works on a single folder - no recursion.
   #
-  def normalize_album( directory, extension )
+  def normalize_album(directory, extension)
     case extension
     when 'm4a'
       program   = 'aacgain'
     when 'mp3'
       program   = 'mp3gain'
     else
-      raise "Unsupported extension: #{ extension }"
+      raise "Unsupported extension: #{extension}"
     end
 
-    files         = Dir.glob( File.join( directory, "*.#{ extension }" ) )
-    encoded_files = encode_bash_filenames( *files )
+    files         = Dir.glob(File.join(directory, "*.#{extension}"))
+    encoded_files = encode_bash_filenames(*files)
 
     # The m.f. popen3 hangs when normalizing, possibly because aacgain rewrites to screen because of the counter
     # F**K F**K
     #
     # Regardless, aacgain appears to be broken, as if an error happens, it still exits successfully.
     #
-    safe_execute "#{ program } -a -k " + encoded_files + " 2> /dev/null"
+    safe_execute "#{program} -a -k " + encoded_files + " 2> /dev/null"
   end
 
-  def encode_alac_to_m4a( file )
+  def encode_alac_to_m4a(file)
     temp_file = file + ".wav"
 
     simple_bash_execute "ffmpeg -i", file, temp_file
 
-    File.delete( file )
+    File.delete(file)
 
     simple_bash_execute "neroAacEnc -q 0.5", "-if", temp_file, "-of", file
 
-    File.delete( temp_file )
+    File.delete(temp_file)
   end
 
   # Sorts files by name
   #
-  def create_m3u_playlist( files_or_pattern, basedir, output )
+  def create_m3u_playlist(files_or_pattern, basedir, output)
     case files_or_pattern
     when Array
       files = files_or_pattern
       # do nothing
     when String
-      files = Dir.glob( files_or_pattern )
+      files = Dir.glob(files_or_pattern)
     else
-      raise "ziokann!! #{ files_or_pattern }"
+      raise "ziokann!! #{files_or_pattern}"
     end
 
     buffer = "#EXTM3U" << "\n"
 
-    files.sort.each do | file |
-      duration = get_audio_file_duration( file )
-      song_name = File.basename( file ).sub( /\.\w+$/, '' )
+    files.sort.each do |file|
+      duration = get_audio_file_duration(file)
+      song_name = File.basename(file).sub(/\.\w+$/, '')
 
-      buffer << "#EXTINF:#{ duration },#{ song_name }" << "\n"
+      buffer << "#EXTINF:#{duration},#{song_name}" << "\n"
 
-      file_relative_path = File.join( basedir, File.basename( file ) )
+      file_relative_path = File.join(basedir, File.basename(file))
 
       buffer << file_relative_path << "\n"
     end
 
-    IO.write( output, buffer )
+    IO.write(output, buffer)
   end
 
-  def get_audio_file_duration( file )
+  def get_audio_file_duration(file)
     case file
     when /.mp3$/
-      duration = safe_execute( "mp3info -p '%S' " + encode_bash_filenames( file ) )
+      duration = safe_execute("mp3info -p '%S' " + encode_bash_filenames(file))
     when /.m4a$/
      # f#!$ing faad writes only to stderr
      #
-      raw_result = safe_execute( 'faad -i ' + encode_bash_filenames( file ) + " 2>&1" )
+      raw_result = safe_execute('faad -i ' + encode_bash_filenames(file) + " 2>&1")
 
-      duration = raw_result[ /(\d+)\.\d+ secs/, 1 ] || raise( "z.k.!!" )
+      duration = raw_result[/(\d+)\.\d+ secs/, 1] || raise("z.k.!!")
     else
-      raise "ziokann!!! #{ file }"
+      raise "ziokann!!! #{file}"
     end
 
     duration.to_i
@@ -149,79 +148,79 @@ module MultimediaHelper
 
   # :directories           single entry or array
   #
-  def add_playlists_to_rhythmbox( directories, options={} )
+  def add_playlists_to_rhythmbox(directories, options={})
     require 'rexml/document'
     require 'uri'
 
-    directories = [ directories ] if ! directories.is_a?( Array )
+    directories = [directories] if !directories.is_a?(Array)
 
-    raw_xml  = IO.read( RHYTHMBOX_PLAYLISTS_FILE )
-    xml_doc  = REXML::Document.new( raw_xml )
+    raw_xml  = IO.read(RHYTHMBOX_PLAYLISTS_FILE)
+    xml_doc  = REXML::Document.new(raw_xml)
     xml_root = xml_doc.elements.first
 
-    directories.each do | directory |
-      puts "Adding #{ directory }..."
+    directories.each do |directory|
+      puts "Adding #{directory}..."
 
-      playlist_name = File.basename( directory )
-      filenames     = AUDIO_FILES_EXTENSIONS.map { | extension | Dir.glob( File.join( directory, "*.#{ extension }" ) ) }.flatten.sort
+      playlist_name = File.basename(directory)
+      filenames     = AUDIO_FILES_EXTENSIONS.map { |extension| Dir.glob(File.join(directory, "*.#{extension}")) }.flatten.sort
 
-      if xml_root.elements.any? { | xml_element | xml_element.attributes[ 'name' ] == playlist_name }
+      if xml_root.elements.any? { |xml_element| xml_element.attributes['name'] == playlist_name }
         puts ">>> playlist already existent!"
       else
-        playlist_node = xml_root.add_element( 'playlist', 'name' => playlist_name, 'type' => 'static' )
+        playlist_node = xml_root.add_element('playlist', 'name' => playlist_name, 'type' => 'static')
 
         filenames.sort!
 
-        filenames.each do | filename |
-          entry_node       = playlist_node.add_element( 'location' )
-          encoded_filename = URI.encode( File.expand_path( filename ) )
+        filenames.each do |filename|
+          entry_node       = playlist_node.add_element('location')
+          encoded_filename = URI.encode(File.expand_path(filename))
           entry_node.text  = "file://" + encoded_filename
         end
       end
     end
 
-    buffer = format_xml_playlist_for_rhythmbox( xml_doc )
+    buffer = format_xml_playlist_for_rhythmbox(xml_doc)
 
-    IO.write( RHYTHMBOX_PLAYLISTS_FILE, buffer )
+    IO.write(RHYTHMBOX_PLAYLISTS_FILE, buffer)
   end
 
   # :directories           single entry or array
   #
-  def add_playlists_to_banshee( directories, options={} )
+  def add_playlists_to_banshee(directories, options={})
     require 'uri'
 
-    directories = [ directories ] if ! directories.is_a?( Array )
+    directories = [directories] if !directories.is_a?(Array)
 
-    db_layer = SQLiteLayer.new( BANSHEE_DATA_FILE )
+    db_layer = SQLiteLayer.new(BANSHEE_DATA_FILE)
 
     primary_source_id_music = 1
 
     db_layer.transaction do
-      directories.each do | directory |
-        puts "Adding #{ directory }..."
+      directories.each do |directory|
+        puts "Adding #{directory}..."
 
-        playlist_name = File.basename( directory )
+        playlist_name = File.basename(directory)
 
         insertion_values = {
           :PrimarySourceID => primary_source_id_music,
           :Name            => playlist_name,
         }
 
-        playlist_id = db_layer.insert_values( 'CorePlaylists', insertion_values )
+        playlist_id = db_layer.insert_values('CorePlaylists', insertion_values)
 
-        filenames = AUDIO_FILES_EXTENSIONS.map { | extension | Dir.glob( File.join( directory, "*.#{ extension }" ) ) }.flatten.sort
+        filenames = AUDIO_FILES_EXTENSIONS.map { |extension| Dir.glob(File.join(directory, "*.#{extension}")) }.flatten.sort
 
-        filenames.each do | filename |
-          puts " - #{ filename }"
+        filenames.each do |filename|
+          puts " - #{filename}"
 
-          track_id = banshee_find_track_id( filename, db_layer ) || banshee_add_playlist_entry( filename, db_layer, primary_source_id_music )
+          track_id = banshee_find_track_id(filename, db_layer) || banshee_add_playlist_entry(filename, db_layer, primary_source_id_music)
 
           insertion_values = {
             :PlaylistID => playlist_id,
             :TrackID    => track_id,
           }
 
-          db_layer.insert_values( 'CorePlaylistEntries', insertion_values )
+          db_layer.insert_values('CorePlaylistEntries', insertion_values)
         end
       end
     end
@@ -229,16 +228,16 @@ module MultimediaHelper
 
   private
 
-  def banshee_find_track_id( filename, db_layer )
-    uri_filename   = "file://" + URI.encode( File.expand_path( filename ) )
+  def banshee_find_track_id(filename, db_layer)
+    uri_filename   = "file://" + URI.encode(File.expand_path(filename))
 
-    db_layer.select_value( "SELECT TrackID FROM CoreTracks WHERE Uri = ?", uri_filename )
+    db_layer.select_value("SELECT TrackID FROM CoreTracks WHERE Uri = ?", uri_filename)
   end
 
-  def banshee_add_playlist_entry( filename, db_layer, primary_source_id_music )
-    uri_filename   = "file://" + URI.encode( File.expand_path( filename ) )
-    title          = File.basename( filename ).sub( /\.\w+$/, '' )
-    straight_title = "'" + title.gsub( "'", "''" ) + "'"
+  def banshee_add_playlist_entry(filename, db_layer, primary_source_id_music)
+    uri_filename   = "file://" + URI.encode(File.expand_path(filename))
+    title          = File.basename(filename).sub(/\.\w+$/, '')
+    straight_title = "'" + title.gsub("'", "''") + "'"
     timestamp      = Time.now.to_i
 
     insertion_values = {
@@ -262,20 +261,18 @@ module MultimediaHelper
       :TitleLowered    => straight_title.downcase,
     }
 
-    db_layer.insert_values( 'CoreTracks', insertion_values, :straight_insert => straight_insert_values )
+    db_layer.insert_values('CoreTracks', insertion_values, :straight_insert => straight_insert_values)
   end
 
-  def format_xml_playlist_for_rhythmbox( xml_doc )
+  def format_xml_playlist_for_rhythmbox(xml_doc)
     buffer        = ""
     xml_formatter = REXML::Formatters::Pretty.new
 
     xml_formatter.compact = true
     xml_formatter.width   = 16384   # avoid introducing f*ing spaces inside <location> elements, which are not compatible with RhythmBox
 
-    xml_formatter.write( xml_doc, buffer )
+    xml_formatter.write(xml_doc, buffer)
 
     buffer
    end
-
 end
-