x2c 0.1

data/x2c/plug/config.rb

@@ -0,0 +1,90 @@
+# Copyright by Daniel Waeber, see the LICENSE file for details
+
+module Xmms
+    # The Config Class is used as an interface to the configuration of the deamon
+    # use config.subtree to show value, or config.subfield = <val> to set it
+    # normal you start to browse the config by calling the config method on the client,
+    # afterwords you can just go into subtrees by typing there name and get back with
+    # the parent config
+    class Config
+        attr_reader :root
+        def initialize root=nil
+            @root=root
+        end
+        def configs
+            xmms.configval_list.reject do |k,v|
+                @root && !(k.to_s =~ /^#{@root}/)
+            end
+        end
+        def subs
+            configs.map{|k,v| k.to_s.sub(/^#{@root}\./,'')}
+        end
+        def keys
+            subs.reject{|s| s.include?('.')}
+        end
+        def subtrees
+            subs.map{|s| s.include?('.') && s.split('.').first}.compact.uniq
+        end
+        def join *keys
+            "#{@root ? @root+'.' : ''}#{keys.join('.')}"
+        end
+
+        def [] key
+            if keys.include?(key.to_s)
+                xmms.configval_get(join(key))
+            else
+                Xmms::Config.new(join(key))
+            end
+        end
+        def []= key, val
+            puts "    #{join(key)}"
+            xmms.configval_set(join(key), val.to_s)
+        end
+        def parent
+            r=@root.split('.')[0..-2] if @root
+            Xmms::Config.new(r && !r.empty? && r.join('.'))
+        end
+
+        alias_method :__respond_to?, :respond_to?
+        alias_method :__methods, :methods
+        def respond_to? id
+            __respond_to?(id) || (subtrees+keys+keys.map{|k| "#{k}="}).include?(id.to_s)
+        end
+        def methods
+            __methods + subtrees + keys + keys.map{|k| "#{k}="}
+        end
+        def method_missing id,*args
+            if id.to_s[-1] == ?=
+                id = id.to_s[0..-2]
+                self[id] = args.first.to_s
+            else
+                self[id]
+            end
+        end
+
+        include Format rescue nil
+        include Prompting rescue nil
+        def format idt='    '
+            (subtrees.map{|s| s ? "#{s} ->" : "parent <-"} + 
+                keys.map{|k| "#{k} = '#{self[k]}'"}.sort).format(idt)
+        end
+    end
+    class Client
+        # the config plugin just adds the config method. 
+        # with the help of the remember plugin, you will get a nice interface to the config
+        module Config
+            # returns a config object. it will show its subtrees and key-value paris
+            # if you have the remember module, you can simply walk deeper into the tree:
+            #   >> config
+            #   >> output
+            # afterwrods you can set values. beacause key=value would set local variables, use something like this
+            #   >> last.buffersize = 1337
+            #   >> last['buffersize']= 1337
+            #   >> config.output.buffersize = 1337
+            def config
+                Xmms::Config.new
+            end
+        end
+        include Config
+    end
+end

data/x2c/plug/daemon.rb

@@ -0,0 +1,72 @@
+# Copyright by Daniel Waeber, see the LICENSE file for details
+module Xmms
+    class Client
+        module Daemon
+            Options['start-daemon' => [true, 'start the daemon, if x2c can\'t connect'],
+                    'auto-daemon' => [false, 'force to start daemon']]
+            attr_reader :log
+            # called berfore before starting daemon
+            def pre_daemon; end
+            # called after connected to stated daemon
+            def post_daemon(path); end
+            # called when deamon dies
+            def dead_daemon; end
+            # starts the daemon
+            def start_daemon
+                puts "...  starting deamon"
+                @log = Array.new
+                path = 'unix:///tmp/xmms-ipc'
+                client = Thread.current
+                Xmms.save_call{pre_daemon}
+                daemon = Thread.new do
+                    File.popen('echo & setsid xmms2d 2>&1 &','r') do |f|
+                        begin
+                            path = f.each_line do |l|
+                                @log.push l.chomp!
+                                break $1 if l =~ /IPC listening on '(.*)'/
+                            end
+                        ensure
+                            client.wakeup
+                        end
+                        f.each_line do |l|
+                            if @log.length > 40
+                                @log.pop
+                            end
+                            @log.push l.chomp!
+                        end
+                        puts "\n...  deamon stoped running"
+                        daemon = false
+                        Xmms.call_save{dead_daemon}
+                    end
+                end
+                sleep
+                begin
+                    handled_connect(path)
+                    Xmms.save_call{post_daemon(path) if daemon}
+                    puts "...  connected #{path}"
+                rescue ClientError => e
+                    puts "\n...  #{path}: #{e}"
+                    exit 1
+                end
+            end
+            def connect; end
+        end
+        include Daemon
+        def connect path=Options['xmms-path']
+            if Options['auto-daemon']
+                start_daemon
+            else
+                begin
+                    handled_connect(path)
+                rescue ClientError => e
+                    if Options['start-daemon']
+                        start_daemon
+                    else
+                        puts "\n...  #{path}: #{e}"
+                        exit 1
+                    end
+                end
+            end
+        end
+    end
+end

data/x2c/plug/format.rb

@@ -0,0 +1,251 @@
+# Copyright by Daniel Waeber, see the LICENSE file for details
+
+# Definitions for the formtion of common xmms classes
+# It will try to show visaul nice resuals for the command line client
+# The output will get improved if the client.rb module is loaded
+# by giving the modules acces to a the xmms function
+module Xmms
+    # The format module is used to show results in a cool way.
+    # you can overwright the format method to get a custom autoput
+    module Format
+        def to_s
+            ' '+format
+        end
+        def inspect
+            ' '+format
+        end
+        def format idt='    '
+            "<#{self.class}:#{self.object_id}>"
+        end
+    end
+    class ::Object
+        def format idt='    '
+            to_s
+        end
+    end
+    class ::String
+        def inspect; ' '+format end
+        def format idt='    '
+            self.gsub(/\n/,"\n"+idt)
+        end
+    end
+    class ::NilClass
+        def inspect; ' kk' end
+    end
+    class ::Array
+        include Format
+        def to_s; ' '+format end
+        def inspect; ' '+format end
+        def format idt='    '
+            self.map{|v| v.format(idt)}.join("\n"+idt)
+        end
+    end
+    class ::Hash
+        include Format
+        def to_s; ' '+format end
+        def inspect; ' '+format end
+        def format idt='    '
+            keys = Hash.new
+            max = self.keys.map do |k| 
+                keys[k] = k.format(idt)
+                keys[k].length
+            end.max
+            self.to_a.map do |k,v| 
+                keys[k] + ' ' * (max-keys[k].length) + " => " + v.format(idt+' '*(max))
+            end.format(idt)
+        end
+    end
+
+    class Result
+        alias_forward :to_s, :val
+        alias_forward :inspect, :val
+        alias_forward :format, :val
+    end
+    class Collection
+        class Query
+            include Format
+            def format idt='    '
+                idt=idt.sub(/  /,'!!')
+                "Medialib-Query-Constructor-Class based on \n"+
+                "#{idt+'  '}#{@base.format(idt+'  ')}\n"+
+                "#{idt}waiting for a specification of the field #{@field.format(idt)}"
+            end
+        end
+        class Attributes
+            include Format
+            def format idt='    '
+                self.map do |k,v|
+                    "#{k}:#{v}"
+                end.join(' ')
+            end
+            def field_string
+                field.to_a.join(":")
+            end
+        end
+
+        include Format
+        # you don't want to change this, but you could
+        def format ident='    '
+            self.tree_inject(self.name || 'collection',0) do |a,d,c|
+                idt = ident+"  "*(d+1)
+                a + "\n" + ident + "  "*d + case c.type
+                when Collection::TYPE_IDLIST        ; ": "+Songlist.new(idlist).to_s
+                when Collection::TYPE_REFERENCE     ; c.operands.empty? ? "[ universe ]" : ">>"
+                when Collection::TYPE_COMPLEMENT    ; "!"
+                when Collection::TYPE_INTERSECTION  ; "&"
+                when Collection::TYPE_UNION         ; "|"
+                when Collection::TYPE_EQUALS        ; "= #{c.attributes.field_string}"
+                when Collection::TYPE_MATCH         ; "~ #{c.attributes.field_string}"
+                when Collection::TYPE_GREATER       ; "> #{c.attributes.field_string}"
+                when Collection::TYPE_SMALLER       ; "< #{c.attributes.field_string}"
+                when Collection::TYPE_HAS           ; "E #{c.attributes.field_string}"
+                when Collection::TYPE_QUEUE         ; "] #{c.attributes.format}\n#{idt}"+Songlist.new(idlist).to_s
+                when Collection::TYPE_PARTYSHUFFLE  ;
+                    q = (c["upcomming"]||c["size"]||10).to_i
+                    p = (c["position"].to_i||0).to_i
+                    p = 0 if p=1
+                    "% #{p}+#{q} " + Songlist.new(idlist).to_s
+                end
+            end
+        end
+    end
+
+    class Playlist
+        include Format
+        def format idt='    '
+            head = begin collection.format(idt)
+                   rescue Client::DisconnectedError; "" end
+
+            now = begin; current_pos.val 
+                  rescue Result::ValueError; -1 end
+            pos = -1
+            h = entries.format_hash
+            head + "\n" + entries.map do |i|
+                idt[0..4] = (((pos+=1)==now ? '>%3i' : '%4i') % pos)
+                idt + h[i.to_i]
+            end.join("\n")
+        end
+    end
+    class PropDict
+        include Format
+        def inspect; ' '+format end
+        def to_s; ' '+format end
+        def format idt=nil
+            to_h.format
+        end
+    end
+    class Client
+        include Format
+        # overwrite this method in config.rb to cusotmize the status line
+        def format idt='    '
+            p = case playback_status.val
+            when PLAY   ; '>>'
+            when PAUSE  ; '||'
+            when STOP   ; '[]'
+            else        ; "<#{s.to_s}>"
+            end rescue "<error in clientstatus: #{$!}>"
+            id = begin
+                playback_current_id.val 
+            rescue Result::ValueError 
+                -1
+            end
+            t = playback_playtime/1000
+
+            r = "%i#{t>600 ? '':':'}%02i" % [t/60,t%60]
+            i = "%9i" % id
+            i[0..r.length-1] = r
+            "#{i} #{p}"
+        end
+    end
+
+    class Song
+        include Format
+        # overwrite this method in config.rb to cusotmize list output
+        def self.format info, max=nil
+            return self.class.name unless max
+            # get info and length info
+            id,dur,art,ttl,alb,tnr,rate = [:id,:duration,:artist,:title,:album,:tracknr,:rating].map{|f| info[f]}
+            aspace,lspace,skip = [:artist,:tilum, :album].map{|f| max[f]}
+            # format for    title     (album tr)
+            tnr = tnr ? "%3i" % tnr+')' : ')   '
+            alb = alb ? '('+alb+tnr : ''
+            # scale it up, at least to fill 80 chars
+            lspace+= 7 unless skip == 0
+            if aspace + lspace < 55
+                aspace = [20,55-lspace].min if aspace < 20
+                lspace = 55 - aspace 
+            end
+            lspace-= alb.length 
+            # put it all in the string
+            "%5i %#{aspace}s - %-#{lspace}s%s%7s  %s" % [id,art,ttl,alb,dur.format,rate]
+        end
+        def format idt='    '
+            Songlist.new(xmms.playlist.entries.val.map{|v| v.to_i} + [@id]).format_hash[@id].format(idt)
+        end
+    end
+    class Songlist
+        include Format
+        def to_s
+            state = nil
+            fst = -1
+            @ids.inject('') do |acc,snd|
+                acc += if(fst+1==snd)
+                    state ? "" : (state="..")
+                else
+                    (state ? (state=nil;fst.to_s) : '') + ':' + snd.to_s
+                end
+                fst = snd; acc
+            end + (state ? @ids.last.to_s : '')+": => #{@ids.length}"
+        end
+        def info_hash
+            info = xmms.coll_query_info(collection,
+                ['id','artist','title','album','duration','tracknr','date','genre',
+                 'mine','url','comment','rating','vote_count']).val
+            max = Hash.new(0)
+            ids = Hash.new
+            info.reverse!.map! do |h|
+                id = h[:id]
+                next nil if ids[id]
+                ids[id] = true
+                # guess some values, to extract all the info
+                url = File.basename(h[:url]).split('-',2).map{|s| s.gsub(/\+/,' ').gsub(/\.\w{3,5}/,'')}
+                h[:artist]  ||= url.first
+                h[:title]   ||= url.last
+                h[:rating]    = "#{h[:rating]||'-'}/#{h[:vote_count]||0}"
+                h[:duration]  = h[:duration] ? Duration.new(h[:duration]) : Duration.new(0)
+                h[:arlum] = h[:artist].to_s + h[:album].to_s
+                h[:tilum] = h[:title].to_s  + h[:album].to_s
+                h.each_pair do |field,val|
+                    val.replace(val.gsub(/\(.*\)/,'').gsub(/^ | $/,'')) if val.is_a?(String)
+                    length = val ? val.to_s.length : 0
+                    max[field] = length if length > max[field]
+                end
+            end.compact!
+            return info,max
+        end
+        def format_hash
+            info, max = info_hash
+            ret = Hash.new
+            info.each do |h|
+                ret[h[:id]] = Song.format h,max
+            end
+            ret
+        end
+        def format idt=nil
+            if idt 
+                to_s
+            else
+                idt = '    '
+                h = format_hash
+                @ids.map{|i| h[i]}.join("\n#{idt}") + "\n#{idt}=>  "+to_s
+            end
+        end
+    end
+    class Duration
+        include Format
+        def format idt='    '
+            d = @val/1000
+            "%i:%02i" % [d/60, d%60]
+        end
+    end
+end

data/x2c/plug/help.rb

@@ -0,0 +1,240 @@
+# This is based on the magic_help.rb file form tow.
+# neither I found any Licnece nor contact to the writer,
+# but hopefully I'm allowed to use it. all credit goes to him,
+# whoever he is. The only thing I got is this website:
+# http://taw.chaosforge.org/magic_help/
+
+require 'irb'
+require 'irb/extend-command'
+require 'rdoc/ri/ri_driver'
+
+module IRB::ExtendCommandBundle # :nodoc:
+    @ALIASES.delete_if{|a| a == [:help, :irb_help, NO_OVERRIDE]}
+end
+
+module Help
+    class Xmms::Client
+        # Help will show you autogenerated ri help on Functions and objects.
+        # It can be called with either a block, an Object or a String argument.
+        # Wenn called with an Object, it will show help on the objects Class.
+        # Strings arguments are simply look up inside the ri System.
+        # If you call it with a block, it will try to give you docomentation
+        # about what the block does. Here are some examples for that:
+        #
+        #  >> help  skip                   => help on Xmms::Result     
+        #  >> help 'skip'                  => help on Xmms::Client#skip
+        #  >> help {skip}                  => help on Xmms::Client#skip
+        #
+        #  >> help 'artist'                => help on Xmms::PropDict#artist
+        #  >> help {artist}                => help on Xmms::Collection::method_missing
+        #
+        #  >> help 'Chains'                => no help
+        #  >> help  Chains                 => help on Xmms::Client::Chains
+        #  >> help {Chains}                => help on Xmms::Client::Chains
+        #
+        #  >> help  Collection::Chains     => help on Xmms::Collection::Chains
+        #  >> help 'Collection::Chains'    => no help
+        #  >> help {Collection::Chains}    => help on Xmms::Collection::Chains
+        #
+        # So, most often you want to use {}, because it the help on what would be done.
+        def help *args, &block
+            Help.help *args, &block
+        end
+    end
+
+
+
+    argv = ::ARGV.dup
+    ::ARGV.clear
+    begin
+        ENV['RI'] = "--format plain --no-pager
+            --doc-dir #{File.join(Xmms::X2C_ROOT,'doc')} --system --gems --site"
+        @@ri = RiDriver.new
+    rescue
+        puts $!
+        ENV['RI'] = "--format plain --no-pager --system --gems --site"
+        @@ri = RiDriver.new
+    end
+    ::ARGV<< argv
+    ::ARGV.flatten!
+
+    def self.irb_help topic
+        begin
+            @@ri.get_info_for topic
+        rescue RiError => e
+            puts "!!  #{e}"
+            puts "!!    either you help query is not accessable"
+            puts "!!    or perhaps you have to generate the doc in you install dir"
+            puts "!!"
+        end
+        topic
+    end
+    def self.help_hacks(m, res=nil)
+        if res and m == "Kernel#method_missing"
+            m = res unless res =~ /\A(?:.*)(?:\#|::|\.)method_missing\Z/
+        elsif res and (m =~ /\A(.*)\#new\Z/ or m =~ /\A(.*)::new\Z/)
+            cls = $1
+            if res =~ /\A(.*)(::|\.)new\Z/
+                cls_requested, k = $1, $2
+                m = "#{cls_requested}::new" unless cls == cls_requested
+            end
+        end
+        if m =~ /\AKernel(\#|::|\.)([^\#\:\.]+)\Z/
+            k, mn = $1, $2
+            exceptions = ["singleton_method_added", "remove_instance_variable", "singleton_method_removed", "singleton_method_undefined"]
+            correctly_located_docs = Kernel.private_instance_methods - exceptions
+            unless correctly_located_docs.include?(mn)
+                m = "Object#{k}#{mn}"
+            end
+        end
+                
+        m
+    end
+
+
+    @@ignore ||= Hash.new
+    def self.ignore klass, hash
+        @@ignore[klass] = (@@ignore[klass] || Hash.new).merge hash
+    end
+
+    def Help.match? chain, klass, func
+        return nil unless chain
+        return chain[klass][func] if(chain[klass] and chain[klass][func])
+        klass.included_modules.find do |k| 
+            if(chain[k] and chain[k][func])
+                break chain[k][func] 
+            end
+        end or
+        klass.class == Module && chain.keys.find do |k|
+            if(k.include?(klass) and chain[k][func])
+                break chain[k][func] 
+            end
+        end
+    end
+    def Help.trace_help
+        skipstack = []
+        chainstack = []
+        argument_error = nil
+        catch(:magic_help_topic) do
+            set_trace_func proc{ |event, file, line, id, binding, klass|
+                id = id.to_sym
+                case event
+                when /return/
+                    # wait till we get out of error handling and return topic of error-throwing function
+                    if argument_error && !skipstack.last
+                        argument_error = nil
+                        throw(:magic_help_topic,[klass,id])
+                    end
+                    while skipstack.last == [klass,id]
+                        skipstack.pop
+                    end
+                    while chainstack.last and chainstack.last[0,1] == [klass,id]
+                        chainstack.pop
+                    end
+                when /call/
+                    match = Help.match?(chainstack.last && chainstack.last.last, klass, id) ||
+                            Help.match?(@@ignore, klass, id)
+                    if match
+                        case match
+                        when :skip
+                        when :over
+                            skipstack.push [klass,id]
+                        when Hash
+                            chainstack.push [klass,id,{klass => match}]
+                        end
+                    elsif [klass,id] == [Kernel,:send]
+                    elsif [klass,id] == [Kernel,:set_trace_func]
+                    elsif [klass,id] == [Class,:new]
+                        # skip argument errors
+                        if eval("self", binding) == ArgumentError
+                            argument_error = true 
+                            skipstack.push [klass,id]
+                        end
+                    elsif skipstack.last
+                    else
+                        throw(:magic_help_topic,[klass,id])
+                    end
+                end
+            }
+            begin
+                yield
+            ensure
+                set_trace_func nil
+            end
+        end
+    end
+
+    def self.help(*args,&block)
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" if args.size > 1
+        raise ArgumentError, "help cannot take both arguments and block" if args.size > 0 and block_given?
+
+        if block
+            res_mm = trace_help(&block)
+            query = if res_mm.is_a?(Array) and 
+                        res_mm.length == 2 and
+                        res_mm.first.is_a?(Module) and
+                        res_mm.last.is_a?(Symbol)
+                klass, meth = *res_mm
+                if(klass.to_s == 'NameError::message')
+                    query='this function'
+                else
+                    help_hacks("#{klass}##{meth}")
+                end
+            else
+                if res_mm.is_a?(Module)
+                    res_mm.to_s
+                else
+                    res_mm.class.to_s
+                end
+            end
+            return irb_help(query)
+        elsif !args.empty?
+            res = args[0]
+        else
+            res = "Xmms::Client#help"
+        end
+
+        query = case res
+        when Module
+            res.to_s
+        when UnboundMethod, Method
+            help_method_extract(res)
+        when /\A(.*)(#|::|\.)(.*)\Z/
+            cp, k, m = $1, $2, $3
+            begin
+                c = cp.split(/::/).inject(Object){|c, path_elem| c.const_get(path_elem) }
+                case k
+                when "#"
+                    m = c.instance_method(m)
+                    m = help_method_extract(m)
+                when "::"
+                    m = c.method(m)
+                    m = help_method_extract(m)
+                    m = m.sub(/\#/, "::") if c == Class && m == "Class#new"
+                when "."
+                    begin
+                        m = c.instance_method(m)
+                    rescue NameError
+                        m = c.method(m)
+                    end
+                    m = help_method_extract(m)
+                end
+                help_hacks(m, res)
+            rescue NameError
+                res
+            end
+        when String
+            res
+        else
+            res.class.to_s
+        end
+        irb_help query
+    end
+
+    def self.help_method_extract(m) # :nodoc:
+        unless m.inspect =~ %r[\A#<(?:Unbound)?Method: (.*?)>\Z]
+            raise "Cannot parse result of #{m.class}#inspect: #{m.inspect}"
+        end
+        $1.sub(/\A.*?\((.*?)\)(.*)\Z/){ "#{$1}#{$2}" }.sub(/\./, "::").sub(/#<Class:(.*?)>#/) { "#{$1}::" }
+    end
+end