dxmms2 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0558d7e7c3d2afdfce8c3cda5a5d462b19fb1e2
+  data.tar.gz: 717ae54b84456c746f9486f3c5703776250c7ae1
+SHA512:
+  metadata.gz: abe3d53027584aa876d6114c529e1820fa91d92e8499afed04cb143167f030ce8c94f1ea60a5cf550375a517d6a8419e0b45fe4bf0fc1896dce0c2e00797bef4
+  data.tar.gz: 54e52c04408e46a6da49a815ee1d819d53f4091759d418154dea49efb61725d3e75e0b2b7fb288a2a6fe30ce20782c81db33771b4da3f4c49ab7154289172638

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Makefile

@@ -0,0 +1,6 @@
+
+gem:: dxmms2.gemspec
+	gem build $<
+
+install::
+	gem install --user dxmms2-*.gem

data/README.md

@@ -0,0 +1,7 @@
+# dxmms2
+*a dmenu shell for xmms2*
+
+Setting the dmenu width in dxmms2 requires the patch provided in this repo. The 
+patch hasn't been tested--application may require manual effort.
+
+  ![dxmms2 screenie](dxmms2.png)

data/bin/dxmms2

@@ -0,0 +1,668 @@
+#!/usr/bin/env ruby
+require 'dmenu'
+require 'xmms2_utils'
+require 'stringio'
+require 'uri'
+require 'socket'
+require 'set'
+
+begin
+    require 'glib2'
+    $GLIB=true
+rescue
+    $GLIB=false
+end
+
+##########################
+# simple xmms2 script    #
+# for dmenu              #
+##########################
+
+$xc = Xmms::client("dxmms2")
+
+$COMMAND_SIG = "@"
+# default configs {{{
+$SCREEN_WIDTH=Integer(ENV.fetch('DXMMS2_MENU_WIDTH', 600))
+$FONT_WIDTH=Integer(ENV.fetch('DXMMS2_FONT_WIDTH', 13)) #in pixels)
+$BG_COLOR=ENV.fetch('DMENU_BG_COLOR', '#000000')
+$FG_COLOR=ENV.fetch('DMENU_FG_COLOR', '#dc322f')
+$SEL_BG_COLOR=ENV.fetch('DMENU_SEL_BG_COLOR', $FG_COLOR)
+$SEL_FG_COLOR=ENV.fetch('DMENU_SEL_FG_COLOR', $BG_COLOR)
+if $GLIB
+    fallback = ENV.fetch('HOME', '/')
+    xdg_dir = GLib.get_user_special_dir(GLib::USER_DIRECTORY_MUSIC)
+    if !xdg_dir.nil?
+        fallback = xdg_dir
+    end
+    $MUSIC_DIRECTORY = ENV.fetch('DXMMS2_MUSIC_DIRECTORY', fallback)
+end
+
+$FONT = ENV.fetch('DMENU_FONT', 'Noto Sans Mono CJK JP Regular')
+$FONT = $FONT + ':pixelsize=' + $FONT_WIDTH.to_s
+$LIST_ENTRIES_PER_PAGE = 15
+$LINE_HEIGHT=10
+# }}}
+
+#if [ -e $CONFIG ] ; then
+    #source $CONFIG
+#fi
+class Integer
+    def ms_to_time_string
+        minutes=(self / 60000)
+        seconds=(self % 60000) / 1000
+        "%d:%02d" % [minutes, seconds]
+    end
+end
+
+def time_string_to_ms(str)
+    res = 0
+    s = 1
+    for n in str.split(":").reverse do
+        s = 60 * s
+        res = res + s * (n.to_i)
+    end
+    return res.to_i
+end
+
+def my_dmenu (entries, prompt='dxmms2', height=entries.count, width=$SCREEN_WIDTH)
+    height = [height, 20].min
+    Dmenu::dmenu(entries, prompt, height, width,
+          $FG_COLOR,
+          $BG_COLOR,
+          $SEL_FG_COLOR,
+          $SEL_BG_COLOR,
+          $FONT,
+          $LINE_HEIGHT)
+end
+
+def playlists_prompt(&call_back)
+    playlists = $xc.playlist_list.wait.value
+    playlists = playlists.delete_if {|s| s.start_with?("_")}
+    selected = my_dmenu(playlists)
+    if !call_back.nil?
+        if !selected.empty?
+            call_back.call(selected)
+        end
+    end
+    selected
+end
+
+def pl_list(start=nil,nentries=nil,prompt="Track: ",plname=nil)
+    pl = plname.nil? ? $xc.playlist : $xc.playlist(plname)
+    entries = pl.entries.wait.value
+    current = pl.current_pos.wait.value
+    cur = current.nil? ? 0 : current[:position]
+    start = start.nil? ? cur : start
+    list_ids(entries,prompt,start,nentries)
+end
+
+def list_ids(entries, prompt, start=0, nentries=nil, commands=nil)
+    # XXX: Create a list object to pass to user-supplied commands
+    #      list object allows for setting list start, page size, list content,
+    #      whether to redisplay the list, and maybe other things
+    morestring,endstring,startstring,backstring =
+        %w[more end start back].map{|w| $COMMAND_SIG + w}
+    if commands.nil?
+        commands = Hash.new
+    end
+
+    c1 = Hash.new
+    commands.each do |k,v|
+        c1[$COMMAND_SIG + k] = v
+    end
+    listing=1
+    nentries = (nentries.nil? ? $LIST_ENTRIES_PER_PAGE : nentries)
+    pos = nil
+    list_start = start
+    while ( listing == 1 ) do
+        start_clamped = false
+        end_clamped = false
+        items = Array.new
+
+        #clamps start
+        (list_start <= 0) and (list_start = 0 ; start_clamped = true)
+
+        list_end = list_start + nentries
+
+        #clamps end
+        (list_end > entries.length) and (list_end = entries.length ; end_clamped = true)
+
+
+        nw = list_end.to_s.length
+        i = list_start
+
+        items += xmms2_ids_to_display_list_strings(entries[list_start..list_end]).map do |string|
+            string = "#{i.to_s.rjust(nw)}. #{string}"
+            i += 1
+            string
+        end
+
+        if not start_clamped
+            items << backstring
+            items << startstring
+        end
+
+        if not end_clamped
+            items << endstring
+            items << morestring
+        end
+
+        c1.keys.each do |d|
+            items << d
+        end
+
+        choice = my_dmenu(items, prompt, items.length).gsub(/^\s+|\s+$/, "")
+        pos = choice[/^-?\d+|#{$COMMAND_SIG}[a-zA-Z0-9\-_.]+/]
+
+        case pos
+        when backstring
+            list_start -= nentries
+        when morestring
+            list_start += nentries
+        when endstring
+            list_start = entries.length - nentries
+        when startstring
+            list_start = 0
+        when *(c1.keys)
+            f = c1[pos]
+            f.call(entries)
+            pos = nil
+            listing = 0
+        else
+            listing = 0
+        end
+    end
+
+    if pos.nil?
+        return nil
+    end
+
+    pos = pos.to_i
+    if pos < 0
+        entries.length + pos
+    else
+        pos
+    end
+end
+
+def xmms2_ids_to_display_list_strings(ids, fields=%w[artist title url duration])
+    ids.map do |id|
+        my_info = $xc.extract_medialib_info(id, *fields)
+        artist_part = my_info[:artist]
+        some_title = (my_info[:title] or File.basename(my_info[:url]))
+        duration = my_info[:duration].to_i.ms_to_time_string
+        "#{artist_part}|||#{some_title} [#{duration}]"
+    end
+end
+
+def get_usertags(id)
+    info = $xc.extract_medialib_info(id, :usertags)
+    if info.has_key?(:usertags)
+        info[:usertags].lines.to_a
+    else
+        []
+    end
+end
+
+def set_tags(id, tags)
+    $xc.medialib_entry_property_set(id, :usertags, tags.map{|x| x.chomp}.uniq.join("\n")).wait
+end
+
+def tag_track(id, tag)
+    tags = get_usertags(id) << tag.chomp
+    set_tags(id, tags)
+end
+
+def untag_track(id, tag)
+    tags = get_usertags(id).reject{|x|x==tag}
+    set_tags(id, tags)
+end
+
+def tag_menu(ids, previous_tags)
+    tag_file = File.join(Xmms::userconfdir, 'usertags')
+    all_tags = File.new(tag_file,File::CREAT).to_a
+
+    previous_tags = previous_tags.map{|x| x.chomp}
+
+    tag_list = previous_tags.map{|k| "!" + k} + all_tags
+    tag_list.map!{|x| x.chomp}
+
+    tag = my_dmenu(tag_list, "Add/delete a tag")
+    if (!tag.empty?)
+        Thread.new do
+            if (tag[0] == "!")
+                ids.each do |id|
+                    untag_track(id, tag[1..-1])
+                end
+            else
+                ids.each do |id|
+                    tag_track(id, tag)
+                end
+            end
+        end
+
+
+        if (tag[0] != "!")
+            all_tags << tag + "\n"
+            all_tags.uniq!
+        end
+        File.open(tag_file, "w") do |file|
+            all_tags.each do |t|
+                file.write(t)
+            end
+        end
+        tag
+    else
+        nil
+    end
+end
+
+def get_album_info(id, *fields)
+    get_collection_info(get_album_collection(id), *fields)
+end
+
+def get_collection_info(coll, *fields)
+    data = $xc.coll_query_info(coll, fields).wait.value
+    data.map do |infos|
+        res = Hash.new
+        fields = fields.map! {|f| f.to_sym }
+        fields.each do |field|
+            values = infos[field]
+            if not values.nil?
+                my_value = values
+                if field == :url
+                    my_value = Xmms::decode_xmms2_url(my_value)
+                end
+                res[field] = my_value.to_s.force_encoding("utf-8")
+            end
+        end
+        res
+    end
+end
+
+def get_album_ids(id)
+    album_coll = get_album_collection(id)
+    $xc.coll_query_ids(album_coll).wait.value
+end
+
+def get_album_collection(id)
+    album_name = $xc.extract_medialib_info(id, :album)[:album]
+    match_collection('album', album_name)
+end
+
+def match_collection(field, pattern, base_coll=nil)
+    coll = Xmms::Collection.new(Xmms::Collection::TYPE_MATCH)
+    if !coll.nil?
+        coll.operands << base_coll
+    else
+        coll.operands << Xmms::Collection.universe
+    end
+    coll.attributes["field"] = field
+    coll.attributes["value"] = pattern
+    coll
+end
+
+# The idea of this is that if I like a song around the middle of the track, I think it's a
+# really good song and it's probably new since I had to listen halfway through to decide
+# I liked it. I also consider that there may be an over-eagerness in my reaction early in
+# a track, so I penalize that. Lastly, for me, if I like the track near the end, I'm only
+# sort-of listening to it or only like it enough to appreciate it as a whole, but can't
+# say much for it in parts.
+#
+# This should only be used additively with past `likes'
+def track_appreciation_factor(playtime, track_duration)
+    k = [0, [playtime, track_duration].min].max.to_f / track_duration - 0.5
+    l = 1.0 - k.abs
+    l
+end
+
+$commands=%w<toggle list +fav +fav-album
+tag tag-album prev next stop repeat-playlist
+info change-playlist remove-playlist show-playlist
+clear edit-album-metadata edit-metadata remove shuffle search
+repeat-track repeat-off shutdown seek add>
+
+
+def current_pl
+    $xc.playlist
+end
+
+def play_new_track(xc, pos=false)
+    if pos
+        xc.playlist_set_next(pos).wait
+    end
+    xc.playback_tickle.wait
+    xc.playback_stop.wait
+    xc.playback_start.wait
+end
+
+def edit_metadata(urls)
+    prefix = "file://"
+    plen = prefix.length
+    urls = urls.select do |x|
+        x.start_with?(prefix)
+    end.map do |x|
+        x[plen..-1]
+    end
+    files = urls.map{|x|"\"#{x}\""}.join(" ")
+    `picard #{ files }`
+end
+
+while true do
+    command = my_dmenu($commands).chomp
+    case command
+        # NOTE: The *break statements* in here are for the *while loop*
+        #       not for the switch
+    when "list"
+        pos = pl_list(nil, nil, "Play Track:")
+        if not pos.nil?
+            puts "moving to positon #{pos}"
+            play_new_track($xc, pos)
+        end
+        break
+    when "add"
+        d = Dir.new($MUSIC_DIRECTORY)
+        add_dir = $COMMAND_SIG + 'add-dir'
+        while !d.nil?
+            entries = d.entries.map do |x|
+                if Dir.exist?(File.join(d, x))
+                    x + '/'
+                else
+                    x
+                end
+            end
+            choice = my_dmenu(entries.sort << add_dir, "Add entries", d.entries.length)
+            path = File.join(d, choice)
+            if choice.empty?
+                d = nil
+            elsif choice == add_dir
+                begin
+                    current_pl.radd("file://" + d.path).wait
+                ensure
+                    d = nil
+                end
+            else
+                if Dir.exists?(path)
+                    if choice != '.'
+                        d = Dir.new(path)
+                    end
+                elsif File.exists?(path)
+                    begin
+                        $stderr.puts "Adding " + path
+                        current_pl.add_entry("file://"+path).wait
+                    ensure
+                        d = nil
+                    end
+                else
+                    begin
+                        $stderr.puts "Got a result we couldn't handle: "+choice.to_s
+                    ensure
+                        d = nil
+                    end
+                end
+            end
+        end
+        break
+    when "info"
+        entries = current_pl.entries.wait.value
+        if not entries.nil?
+            pos = pl_list(nil,nil,"Track Info:")
+            if pos.nil?
+                break
+            end
+            id = entries[pos]
+            info = $xc.extract_medialib_info(id, *%w<artist title album tracknr favorite timesplayed url date duration laststarted added usertags comment>)
+            info = Hash[info.map { |k,v|
+                k = k.to_s
+                if %w<duration>.include?(k)
+                    v = [v.to_i.ms_to_time_string, v]
+                elsif %w<laststarted added lmod>.include?(k)
+                    v = [Time.at(v.to_i).strftime("%F"), v]
+                elsif k == "usertags"
+                    v = [v.gsub(%r{\n}, ", ")]
+                else
+                    v = [v]
+                end
+                [k,v]
+            }]
+            while true
+                field = my_dmenu(info.map {|k,v| "#{k} |||#{v[0]}"}, "Info", info.size)
+                if field.empty?
+                    break
+                else
+                    field = field[/^[^ ]+/]
+                    values = info[field]
+                    if values.length > 1
+                        value = my_dmenu(values.map{ |v| v.to_s }, "Version?")
+                    else
+                        value = values[0]
+                    end
+                    operation = my_dmenu(%w<copy full-display back>, value)
+                    case operation
+                    when "copy"
+                        `echo '#{value}' | xsel --clipboard -i`
+                        break
+                    when "full-display"
+                        `echo '#{value}' | zenity --text-info`
+                        break
+                    when "back"
+                    else
+                        break
+                    end
+                end
+            end
+        end
+        break
+    when "search"
+        fields = ["artist", "title", "genre", "album", "date", "url"]
+        def add(ids)
+            ids.each do |z|
+                current_pl.add_entry(z).wait
+            end
+        end
+
+        def new_playlist(title, ids)
+            pl_coll = Xmms::Collection.new(Xmms::Collection::TYPE_IDLIST)
+            pl_coll.idlist = ids
+            if !title.empty?
+                $xc.coll_save(pl_coll, title, Xmms::Collection::NS_PLAYLISTS).wait
+            end
+        end
+
+        def new_playlist_prompt(ids)
+            new_playlist(my_dmenu([], "Playlist name"), ids)
+        end
+
+        def edit_ids_metadata(ids)
+            edit_metadata(ids.map{ |id| $xc.extract_medialib_info(id, "url")[:url] })
+        end
+
+        current_collection = Xmms::Collection.universe # TODO: Support searching multiple fields as in xmmsfs
+        refine = false
+        cs = {
+            'add' => proc { |k| add(k) },
+            'edit-metadata' => proc { |k| edit_ids_metadata(k) },
+            'new-playlist' => proc { |k| new_playlist_prompt(k) },
+            'refine' => proc { |k| refine=true }
+        }
+
+        while true
+            field = my_dmenu(fields, prompt="Field")
+            if field.empty?
+                break
+            end
+            field_sym = field.to_sym
+            options = Set.new(get_collection_info(current_collection, field).map{|x| x.fetch(field_sym, "UNDEF")}).to_a.sort
+
+            lists = [options]
+            search_string = ""
+            # XXX: Save and display past searches
+            begin
+                lists.each_with_index do |x, i|
+                    search_string = my_dmenu(x, prompt="Search string (#{i}/#{lists.length})", [x.length, 20].min)
+                    break
+                end
+            rescue Exception
+                lists = lists.inject(Array.new){ |g, x| g + [x[0..(x.length/2 - 1)], x[x.length/2..-1]]}
+                retry
+            end
+
+            if !options.include?(search_string)
+                search_string.gsub!(" ","*")
+            elsif field == 'url'
+                search_string = Xmms::encode_url(search_string)
+            end
+
+            if search_string.empty?
+                break
+            end
+            search_string = "*#{search_string}*"
+            puts search_string
+            coll = match_collection(field, search_string, current_collection)
+            d = $xc.coll_query_ids(coll,"artist,album,tracknr").wait.value
+            d = d.reverse
+            pos = list_ids(d, prompt="Results", 0, $LIST_ENTRIES_PER_PAGE, cs)
+
+            # Make the playlist collection
+            new_playlist('search-result-list', d)
+
+            # add the entry and load the playlist
+            if !pos.nil?
+                pl = $xc.playlist('search-result-list')
+                pl.load.wait
+                play_new_track($xc, pos)
+                break
+            end
+
+            if refine
+                current_collection = coll
+            else
+                current_collection = Xmms::Collection.universe
+            end
+        end
+
+        break
+    when "remove"
+        while true
+            pos = pl_list(nil,nil,"Remove entry:")
+            if pos.nil?
+                break
+            else
+                current_pl.remove_entry(pos).wait
+            end
+        end
+        break
+    when "+fav"
+        begin
+            id = $xc.playback_current_id.wait.value
+            p = $xc.playback_playtime.wait.value
+            data = $xc.extract_medialib_info(id, :favorite, :duration)
+            old_favorite = data[:favorite].to_f
+            duration = data[:duration].to_i
+            appreciation = track_appreciation_factor(p, duration)
+            $xc.medialib_entry_property_set(id, :favorite, (old_favorite+appreciation).to_s).wait
+        end
+        break
+    when "+fav-album"
+        id = $xc.playback_current_id.wait.value
+        get_album_ids(id).each do |al_id|
+            old_favorite = $xc.extract_medialib_info(al_id, :favorite)[:favorite].to_f
+            $xc.medialib_entry_property_set(al_id, :favorite, old_favorite+1).wait
+        end
+        break
+    when "tag"
+        # TODO: refcount the tags in the tag file so they get removed
+        # when no file is tagged with them
+
+        id = $xc.playback_current_id.wait.value
+        while tag_menu([id], get_usertags(id))
+        end
+
+        break
+    when "edit-metadata"
+        id = $xc.playback_current_id.wait.value
+        url = $xc.extract_medialib_info(id, "url")[:url]
+        edit_metadata([url])
+        break
+    when "edit-album-metadata"
+        id = $xc.playback_current_id.wait.value
+        urls = get_album_info(id, "url").map{|x| x[:url]}
+        edit_metadata(urls)
+        break
+    when "tag-album"
+        begin
+            id = $xc.playback_current_id.wait.value
+            album_ids = get_album_ids(id)
+            while tag_menu(album_ids, [])
+            end
+        rescue => e
+            puts e
+        end
+
+        break
+    when "change-playlist"
+        begin
+             playlists_prompt do |selected|
+                $xc.playlist(selected).load.wait
+             end
+        end
+        break
+    when "remove-playlist"
+        begin
+             playlists_prompt do |selected|
+                $xc.playlist(selected).remove.wait
+             end
+        end
+        break
+    when "show-playlist"
+        begin
+            playlists_prompt do |selected|
+                pl_list(nil,nil,prompt=selected, plname=selected)
+            end
+        end
+        break
+    when %r{repeat-(off|track|playlist)}
+        case command.split(%r{-})[1]
+        when "off"
+            $xc.config_set_value('playlist.repeat_one', "0").wait
+            $xc.config_set_value('playlist.repeat_all', "0").wait
+        when "track"
+            $xc.config_set_value('playlist.repeat_one', "1").wait
+            $xc.config_set_value('playlist.repeat_all', "0").wait
+        when "playlist"
+            $xc.config_set_value('playlist.repeat_one', "0").wait
+            $xc.config_set_value('playlist.repeat_all', "1").wait
+        end
+        break
+    when "shuffle"
+        $xc.shuffle_by(current_pl, :artist)
+        #current_pl.shuffle.wait
+        break
+    when "shutdown"
+        $xc.quit.wait
+        break
+    when "seek"
+        print $xc.playback_playtime.wait.value
+        id = $xc.playback_current_id.wait.value
+        info = $xc.extract_medialib_info(id, :duration)
+        dur = info[:duration].to_i
+        interval_size = dur / 10
+        times = []
+        times << ["start",  0]
+        Range.new(0,dur).step(interval_size).each do |x|
+            times << [x.ms_to_time_string, x]
+        end
+        times << ["end", dur]
+        seek_location = my_dmenu(times.map{|x| x[0]}).to_s
+        # FIXME: This math is clearly janky. Sadly I have actual work to do.
+        seek = 20 * time_string_to_ms(seek_location)
+        puts $xc.playback_seek_ms(seek).wait.value
+        $stdout.flush
+        break
+    else
+        if not command.empty?
+            `xmms2 #{command}`
+        end
+        break
+    end
+end

data/dxmms2.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "dxmms2"
+  spec.version       = "1.0.0"
+  spec.authors       = ["Mark Watts"]
+  spec.email         = ["wattsmark2015@gmail.com"]
+  spec.summary       = %q{A client for working with xmms2}
+  spec.description   = File.new("./README.md").read()
+  spec.homepage      = "http://github.com/mwatts15/xmms2-stuff"
+  spec.license       = "MPL-2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["."]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "glib2", "~> 3.1.0"
+  spec.add_runtime_dependency "xmms2_utils", "~> 0.1.2"
+  spec.add_runtime_dependency "markw-dmenu", "~> 1.0.0"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: dxmms2
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mark Watts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: glib2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: xmms2_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+- !ruby/object:Gem::Dependency
+  name: markw-dmenu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: "# dxmms2\n*a dmenu shell for xmms2*\n\nSetting the dmenu width in dxmms2
+  requires the patch provided in this repo. The \npatch hasn't been tested--application
+  may require manual effort.\n\n  ![dxmms2 screenie](dxmms2.png)\n"
+email:
+- wattsmark2015@gmail.com
+executables:
+- dxmms2
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Makefile
+- README.md
+- bin/dxmms2
+- dxmms2.gemspec
+- dxmms2.png
+homepage: http://github.com/mwatts15/xmms2-stuff
+licenses:
+- MPL-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- "."
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A client for working with xmms2
+test_files: []