rwdschedule 0.96 → 0.97

data/extras/playlist

@@ -0,0 +1,186 @@
+#!ruby
+
+# --- Playlist class ---
+#
+# Author:	Magnus Engstr�m
+# Email:		magnus@gisab.se
+# File:		playlist
+#
+# Description
+# -----------
+# The Playlist class handles everything a playlist should be able to manage.
+# Shuffle it, unshuffle it, wrap it if desired, add new songs, find songs and
+# so on. Cool huh? :)
+# ----------------------
+
+class Playlist
+  # create_from_file() creates a playlist from a file and returns either a Playlist instance or -1 in case of error
+  # This function should be used instead of the ::new, because this one
+  # returns -1 on file read errors, which the ::new doesn't.
+  def Playlist::create_from_file(filename)
+	 # Check that the file is readable
+	 if(FileTest::readable_real?(filename))
+		new(filename) # Return the Playlist class instance
+	 else
+		-1 # Return -1 on error
+	 end
+  end
+
+  # initialize reads the playlist from a file and returns the Playlist instance 
+  def initialize(filename)
+
+	 @filename	= filename		# Store the filename for later use
+	 @playlist	= Array::new()	# This hash contains the whole playlist
+	 @index		= 0				# Playlist's current position
+	 @wrap		= false			# Don't repeat the list as default
+
+	 # Parse these fields, separated with double pipes (||) (songname, artist, album, year, comment, tracknum, genre_id, genre)
+	 File::foreach(filename) { |line| # Iterate through every line in the file
+		foo = line.split(/\|\|/)
+		@playlist << { "filename" => foo[0], "songname" => foo[1], "artist" => foo[2], "album" => foo[3], "year" => foo[4], "comment" => foo[5], "tracknum" => foo[6], "genre_id" => foo[7], "genre" => foo[8] } # Add a hash to the @playlist array with all values found in the playlist file
+	 }
+	 
+  end
+
+  def insert(song, placement = 0)
+	 # Check song information
+	 return -1 if(song.type != Hash)
+	 song = { "filename" => song["filename"], "songname" => song["songname"], "artist" => song["artist"], "album" => song["album"], "year" => song["year"], "comment" => song["comment"], "tracknum" => song["tracknum"], "genre_id" => song["genre_id"], "genre" => song["genre"] }
+	 
+	 # Check minimum and maximum values
+	 placement = 0 if(placement < 0)
+	 placement = @playlist.length() if(placement > @playlist.length() )
+
+	 # Retrieve the two parts of the split playlist
+	 first		= @playlist[0...placement]
+	 second		= @playlist[placement...@playlist.length()]
+	 
+	 # Put it together again
+	 @playlist	= Array::new()
+	 @playlist	= first
+	 @playlist	<< song
+	 @playlist.concat(second)
+
+  end
+
+  def remove(placement = 0)
+	 # Check boundaries
+	 placement = 0 if(placement < 0)
+	 placement = @playlist.length()-1 if( placement >= @playlist.length() )
+
+	 # Delete the item
+	 @playlist.delete_at(placement)
+  end
+
+  def find(search_string, case_insensitive = false, fields = ["songname", "filename"])
+	 case_insensitive = nil if(case_insensitive == false)
+
+	 results	= Array::new()
+	 regex	= Regexp::new(search_string, case_insensitive) # The regex that will be matched
+
+	 # Iterate through the playlist to find one or more matching songs
+	 @playlist.length().times { |index|
+		# Iterate through the user supplied list of fields to be searched
+		fields.each { |field|
+		  # Make sure this is a hash, so we don't go and crash, or make someone's dog sick :)
+		  if(@playlist[index].type == Hash)
+			 results << index if( regex.match(@playlist[index][field]) && !(results.include?(index)) ) # If it matches, and if it doesn't already is in the results. We don't want duplicates :)
+		  end
+		}
+	 }
+
+	 results # Return the results
+
+  end
+
+  def shuffle()
+	 # Iterate through the playlist
+	 ( 0...@playlist.length() ).each { |i|
+	  	j = rand @playlist.length() # Grab a random value between 0 and @playlist.length()
+
+		# Maintain index
+		if(@index == j)
+		  @index = i 
+		elsif(@index == i)
+		  @index = j
+		end
+
+	  	@playlist[i], @playlist[j] = @playlist[j], @playlist[i]
+	 }
+  end
+
+  def re_read()
+	 # Maintain index
+	 current_filename = @playlist[@index]["filename"]
+
+	 # Create a new playlist array
+	 @playlist	= Array::new()
+	 @index		= 0
+	 foo_index	= 0 # Just to keep the count while adding all songs to the @playlist
+
+	 # Parse these fields, separated with double pipes (||) (songname, artist, album, year, comment, tracknum, genre_id, genre)
+	 # Iterate through every line in the file
+	 File::foreach(@filename) { |line|
+		foo = line.split(/\|\|/) # Separate the fields with double pipes (||)
+		@playlist << { "filename" => foo[0], "songname" => foo[1], "artist" => foo[2], "album" => foo[3], "year" => foo[4], "comment" => foo[5], "tracknum" => foo[6], "genre_id" => foo[7], "genre" => foo[8] } # Add a hash to the @playlist array with all values found in the playlist file
+
+		# Maintain index
+		@index = foo_index if(foo[0] == current_filename)
+		foo_index += 1
+	 }
+	 
+  end
+
+  def next()
+	 # Increase the counter and return -1 if the playlist went to far, and wrap isn't true
+	 @index += 1
+	 if( @index >= @playlist.length() )
+		if(@wrap)
+		  @index = 0
+		else
+		  @index -= 1
+		  -1 # Return an error
+		end
+	 else
+		@index
+	 end
+  end
+
+  def prev()
+	 # Decrease the counter and return -1 if the playlist went to far, and wrap isn't true
+	 @index -= 1
+	 if( @index < 0 )
+		if(@wrap)
+		  @index = @playlist.length() -1
+		else
+		  @index += 1
+		  -1 # Return an error
+		end
+	 else
+		@index
+	 end
+  end
+
+  def song_info(index = @index)
+	 @playlist[index]
+  end
+
+  def goto(index = 0)
+	 if( index >= 0 && index < @playlist.length() )
+		@index = index
+	 else
+		return -1
+	 end
+  end
+
+  def length()
+	 @playlist.length()
+  end
+
+  def each()
+	 @playlist.each { |song| yield(song) }
+  end
+
+  attr_reader	:wrap, :index, :filename
+  attr_writer	:wrap
+end

data/extras/rconftool.rb

@@ -0,0 +1,380 @@
+#!/usr/local/bin/ruby -w
+
+# Copyright (c) 2005 Brian Candler
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+##########################################################################
+# rconftool is a reimplementation of Sam Varshavchik's sysconftool in Ruby.
+# See http://www.courier-mta.org/sysconftool/ for details of the original.
+# Its purpose is to keep configuration files "fresh" when upgrading an
+# application from one version to another, ensuring that all necessary
+# settings are present and obsolete ones removed.
+# 
+# rconftool can be called as a library function or from the command line. It
+# can also install groups of files recursively from one directory tree into
+# another.
+##########################################################################
+
+require 'fileutils'
+
+module Rconftool
+  VERSION = "0.1"
+  class NoVersionLine < RuntimeError; end
+
+  # This module function installs a single source (.dist) file to a target
+  # location, having first merged in any compatible settings from the
+  # target file if it existed previously [if it does not exist, any settings
+  # from 'oldfile' are used instead]
+  #
+  # If the distfile is not in sysconftool format (i.e. doesn't have a
+  # ##VERSION: header within the first 20 lines), then for safety it is only
+  # installed if the target file does not already exist. No attempt at data
+  # merging is made in that case.
+
+  def self.install(distfile, targetfile=nil, oldfile=nil, opt={})
+    debug = opt[:debug] || $stdout
+
+    targetfile ||= distfile
+    if opt[:strip_regexp]
+      targetfile = targetfile.sub(opt[:strip_regexp], '')
+      oldfile    = oldfile.sub(opt[:strip_regexp], '') if oldfile
+    end
+    if opt[:add_suffix]
+      targetfile = targetfile + opt[:add_suffix]
+      oldfile    = oldfile + opt[:add_suffix] if oldfile
+    end
+    raise Errno::EEXIST, "#{distfile}: dist and target filenames are the same" if distfile == targetfile
+
+    # Read in the source (.dist) file
+    begin
+      src = ConfigFile.new(distfile)
+    rescue NoVersionLine
+      # Fallback behaviour when installing a file which is not in sysconftool
+      # format: we install the file only if it doesn't already exist
+      if File.exist?(targetfile)
+        debug << "#{targetfile}: already exists, skipping\n"
+        return
+      end
+      return if opt[:noclobber]
+      copyfrom = (oldfile and File.exist?(oldfile)) ? oldfile : distfile
+      if File.symlink?(copyfrom)
+        File.symlink(File.readlink(copyfrom), targetfile)
+        debug << "#{targetfile}: symlink copied from #{copyfrom}\n"
+      else
+        FileUtils.cp copyfrom, targetfile, :preserve=>true
+        debug << "#{targetfile}: copied from #{copyfrom}\n"
+      end
+      return
+    end
+
+    # OK, so we have a sysconftool file to install. Read in the existing
+    # target file, or if that does not exist, the oldfile
+    begin
+      old = ConfigFile.new
+      old.read(targetfile)
+    rescue NoVersionLine
+      # That's OK; the old target will be renamed to .bak
+    rescue Errno::ENOENT
+      begin
+        target_missing = true
+        old.read(oldfile) if oldfile
+      rescue Errno::ENOENT, NoVersionLine
+      end
+    end
+
+    # Same VERSION? No merge is required
+    if src.version == old.version and not opt[:force]
+      if target_missing
+        FileUtils.cp oldfile, targetfile, :preserve=>true
+        debug << "#{targetfile}: same VERSION, copied from #{oldfile}\n"
+        return
+      end
+      debug << "#{targetfile}: same VERSION, no change\n"
+      return
+    end
+
+    # Merge in old settings (note: any settings which are in targetfile but
+    # not in distfile will be silently dropped)
+    debug << "#{targetfile}:\n"
+    src.settings[1..-1].each do |src_setting|
+      name = src_setting.name
+      old_setting = old[name]
+      unless old_setting
+        debug << "  #{name}: new\n"
+        next
+      end
+      if old_setting.version == src_setting.version
+        debug << "  #{name}: unchanged\n"
+        src_setting.add_comment("\n DEFAULT SETTING from #{distfile}:\n")
+        src_setting.add_comment(src_setting.content)
+        src_setting.content = old_setting.content
+        next
+      end
+      # Otherwise, must install updated setting and comment out
+      # the current setting for reference
+      debug << "  #{name}: UPDATED\n"
+      src_setting.add_comment("\n Previous setting (inserted by rconftool):\n\n")
+      src_setting.add_comment(old_setting.content)
+    end
+
+    return if opt[:noclobber]
+
+    # Write out the new file and carry forward permissions
+    begin
+      tempfile = targetfile+".new#{$$}"
+      src.write(tempfile)
+      st = File.stat(distfile)
+      begin
+        File.chown(st.uid, st.gid, tempfile)
+      rescue Errno::EPERM
+      end
+      File.chmod(st.mode, tempfile)
+      File.rename(targetfile, targetfile+".bak") unless target_missing
+      File.rename(tempfile, targetfile)
+    rescue
+      File.delete(tempfile) rescue nil
+      raise
+    end
+  end
+
+  HEADER_ID = '__header__'
+
+  # Object to represent a single setting
+
+  class Setting
+    attr_reader :name, :version
+    attr_accessor :content
+
+    def initialize(name, version)
+      @name = name.gsub(/\s+/,'')
+      @version = version.gsub(/s+/,'')
+      @comment = ""
+      @content = ""
+      @in_content = false
+    end
+    def <<(str)
+      @in_content = true unless /\A#/ =~ str
+      if @in_content
+        @content << str
+      else
+        @comment << str
+      end
+    end
+    # Add text to 'comment' portion of setting, prefixing each line with '#'
+    def add_comment(str)
+      @comment << str.gsub(/^/,'#')
+    end
+    def to_s
+      return "#{@comment}#{@content}" if @name == HEADER_ID
+      return "##NAME: #{@name}:#{@version}\n#{@comment}#{@content}"
+    end
+  end # class Setting
+
+  # Object to represent an entire configuration file. It consists of
+  # an array of Setting objects, with the first one having a special name
+  # (__header__). We also keep a hash of setting name => setting object
+  # to enable us to find a particular setting quickly.
+
+  class ConfigFile
+    attr_reader :version, :settings
+
+    def initialize(filename=nil)
+      read(filename) if filename
+    end
+
+    # fetch a setting by name
+    def [](item)
+      @settings_hash[item]
+    end
+
+    def read(filename)
+      @version = nil
+      curr_setting = Setting.new(HEADER_ID,'')
+      @settings = [curr_setting]
+      @settings_hash = {}
+
+      File.open(filename) do |f|
+        # VERSION header must occur within first 20 lines
+        20.times do
+          line = f.gets
+          break unless line
+          curr_setting << line
+          if line =~ /\A##VERSION:/
+            @version = line
+            break
+          end
+        end
+        raise NoVersionLine, "#{filename}: No VERSION line found" unless @version
+
+        while line = f.gets
+          unless line =~ /\A##NAME:(.*):(.*)/
+            curr_setting << line
+            next
+          end
+          curr_setting = Setting.new($1,$2)
+          @settings << curr_setting
+          @settings_hash[curr_setting.name] = curr_setting
+        end
+      end
+    end
+
+    def write(filename)
+      File.open(filename,"w") do |f|
+        @settings.each do |s|
+          f << s.to_s
+        end
+      end
+    end
+  end # class ConfigFile
+
+  # Yield directory contents recursively, without doing chdir(). Note
+  # that yielded pathnames are relative to the base directory given;
+  # so that, for example, you can simulate 'cp -r /foo/bar/ /baz/' by
+  #   recurse_dir("/foo/bar") { |n| copy("/foo/bar/"+n,"/baz/"+n) unless 
+  #                                      File.directory?("/foo/bar/"+n) }
+  # Current behaviour is that if a directory is a symlink, we follow it.
+  # (Perhaps the block we yield should return true/false?)
+
+  def self.recurse_dir(base)
+    base = base+File::SEPARATOR unless base[-1,1] == File::SEPARATOR
+    dirs = ['']
+    while dir = dirs.pop
+      yield dir unless dir == ''
+      Dir.foreach(base+dir) do |n|
+        next if n == '.' || n == '..'
+        target = dir + n
+        if File.directory?(base+target)
+          dirs << target+File::SEPARATOR
+          next
+        end
+        yield target
+      end
+    end
+  end
+
+  class Processor
+    attr_reader :o
+
+    # Parse command-line options and set the @o options hash
+
+    def initialize(argv=nil)
+      require 'optparse'
+
+      @o = { :strip_regexp => /\.dist\z/ }
+      return unless argv
+      opts = OptionParser.new do |opts|
+        opts.banner = "rconftool version #{VERSION}"
+        opts.separator "Usage: #{$0} [options]"
+        opts.separator ""
+        opts.separator "Specific options:"
+
+        opts.on("-n", "--noclobber", "Dummy run") do
+          @o[:noclobber] = true
+        end
+        opts.on("-f", "--force", "Update files even if VERSION is same") do
+          @o[:force] = true
+        end
+        opts.on("-q", "--quiet", "No progress reporting") do
+          @o[:debug] = ""
+        end
+        opts.on("--targetdir DIR", "Where to write merged config files") do |dir|
+          @o[:targetdir] = dir
+        end
+        opts.on("--olddir DIR", "If file does not exist in targetdir,",
+                "try to merge from here") do |dir|
+          @o[:olddir] = dir
+        end
+        opts.on("--[no-]recursive", "Traverse directories recursively") do |v|
+          @o[:recursive] = v
+        end
+        opts.on("--strip-suffix FOO", "Remove suffix FOO from target filenames",
+		"(default .dist)") do |suffix|
+          @o[:strip_regexp] = /#{Regexp.escape(suffix)}\z/
+        end
+        opts.on("-a", "--add-suffix FOO", "Add suffix FOO to target filenames") do |suffix|
+          @o[:add_suffix] = suffix
+        end
+
+        opts.on_tail("-?", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+      opts.parse!(argv)
+    end
+
+    # Process a list of files, [src1,src2,...]. If recursive mode has been
+    # enabled, then subdirectories of destdir are created as necessary
+    # when 'src' is a directory, and the mode/ownership of these newly
+    # created directories is copied from the original.
+
+    def run(files)
+      done_work = false
+      files.each do |f|
+        if not File.directory?(f)
+          dst = old = nil
+          dst = @o[:targetdir] + File::SEPARATOR + File.basename(f) if @o[:targetdir]
+          old = @o[:olddir]    + File::SEPARATOR + File.basename(f) if @o[:olddir]
+          Rconftool::install(f, dst, old, @o)
+        elsif not @o[:recursive]
+          raise Errno::EISDIR, "#{f} (not copied). Need --recursive?"
+        else
+          Rconftool::recurse_dir(f) do |nf|
+            src = f + File::SEPARATOR + nf
+            dst = old = nil
+            dst = @o[:targetdir] + File::SEPARATOR + nf if @o[:targetdir]
+            old = @o[:olddir]    + File::SEPARATOR + nf if @o[:olddir]
+            if File.directory?(src)
+              if dst and not File.directory?(dst)
+                orig = File.stat(src)
+                Dir.mkdir(dst, orig.mode)
+                begin
+                  File.chown(orig.uid, orig.gid, dst)
+                rescue Errno::EPERM
+                end
+              end
+            else
+              Rconftool::install(src, dst, old, @o)
+            end
+          end
+        end
+        done_work = true
+      end
+      unless done_work
+        $stderr.puts "Usage: #{$0} [options] src1 src2 ...\n"+
+                     "Try #{$0} --help for more information\n"
+        exit 1
+      end
+    end
+  end # class Processor
+
+end # module Rconftool
+
+# Run from command line?
+if __FILE__ == $0
+
+  begin
+    s = Rconftool::Processor.new(ARGV)
+    s.run(ARGV)
+  rescue Exception => e
+    $stderr.puts "#{$0}: #{e}"
+  end
+
+end

data/extras/showHelp

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+
+# --- showHelp ----
+#
+# Author:	Magnus Engstr�m
+# Email:		magnus@gisab.se
+# File:		showHelp
+#
+# Description
+# -----------
+# This function
+# print the help
+# message on STDOUT
+# -----------------
+
+def showHelp()
+	 STDOUT.puts("MaGnuX Mp3 Management server - Ruby Edition v0.2a\n-------------------------------------------------\n\n--help\t\t\tShow this message\n--debug on\t\tShow some debug data\n--configfile file\tSelect configuration file\n--daemon, -D (yes*|no)\tGo to background on startup\n\n")
+end

data/gui/tinkerbackwindows/superant.com.rwdschedulebackwindow/67viewconfiguration.rwd

@@ -26,7 +26,17 @@ $rwdguivar=
       <row> <p align=\"right\">7:</p>  <text size=70 name=\"a_schconfigline7\"/> </row>
       <row> <p align=\"right\">8:</p>  <text size=70 name=\"a_schconfigline8\"/> </row>
       <row> <p align=\"right\">9:</p>  <text size=70 name=\"a_schconfigline9\"/> </row>
-
+ <row> <p align=\"right\">10:</p>  <text size=70 name=\"a_schconfigline10\"/> </row>
+<row> <p align=\"right\">11:</p>  <text size=70 name=\"a_schconfigline11\"/> </row>
+     
+    <row> <p align=\"right\">12:</p>  <text size=70 name=\"a_schconfigline12\"/> </row>
+      <row> <p align=\"right\">13:</p>  <text size=70 name=\"a_schconfigline13\"/> </row>
+      <row> <p align=\"right\">14:</p>  <text size=70 name=\"a_schconfigline14\"/> </row>
+      <row> <p align=\"right\">15:</p>  <text size=70 name=\"a_schconfigline15\"/> </row>
+      <row> <p align=\"right\">16:</p>  <text size=70 name=\"a_schconfigline16\"/> </row>
+      <row> <p align=\"right\">17:</p>  <text size=70 name=\"a_schconfigline17\"/> </row>
+      <row> <p align=\"right\">18:</p>  <text size=70 name=\"a_schconfigline18\"/> </row>
+      
     </table>
     <p>%extraschconfigdatadisplay%</p>
     <p>