moc 2.5.0

data/README.md

@@ -0,0 +1,3 @@
+moc - Ruby controller
+======================
+This is just a simple library to control [moc](http://moc.daper.net/).

data/bin/mocp.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env ruby
+require 'moc'
+require 'optparse'
+
+options = {}
+
+OptionParser.new do |o|
+end.parse!

data/lib/moc/controller/player.rb

@@ -0,0 +1,121 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; class Controller
+
+class Player
+	class Queue
+		include Enumerable
+
+		attr_reader :controller
+
+		def initialize (controller)
+			@controller = controller
+		end
+
+		# add an item to the queue
+		def add (file)
+			controller.send_command :queue_add
+			controller.send_string File.realpath(File.expand_path(file))
+
+			self
+		end
+
+		# remove an item from the queue
+		def remove (file)
+			controller.send_command :queue_del
+			controller.send_string File.realpath(File.expand_path(file))
+
+			self
+		end
+
+		# swap two items
+		def move (from, to)
+			self
+		end
+
+		# clear the queue
+		def clear
+			controller.send_command :queue_clear
+
+			self
+		end
+
+		# iterate over the queued items
+		def each (&block)
+			controller.send_command :get_queue
+			controller.wait_for     :data
+
+			until (item = controller.read_item).nil?
+				block.call(item)
+			end
+		end
+	end
+
+	attr_reader :controller
+
+	def initialize (controller)
+		@controller = controller
+	end
+
+	def play
+		controller.send_command :unpause
+	end
+
+	# pause the current song
+	def pause
+		controller.send_command :pause
+	end
+
+	# unpause the current song
+	def unpause
+		controller.send_command :unpause
+	end
+
+	# stop the current song
+	def stop
+		controller.send_command :stop
+	end
+
+	# go to the next song in the playlist
+	def next
+		controller.send_command :next
+	end
+
+	# go to the previous song in the playlist
+	def prev
+		controller.send_command :prev
+	end
+
+	# change the volume
+	def volume (volume)
+		controller.send_command :set_mixer
+		controller.send_integer volume
+	end
+
+	# seek to the passed second
+	def seek (second)
+		controller.send_command :seek
+		controller.send_integer second
+	end
+
+	# jump to the passed second
+	def jump_to (second)
+		controller.send_command :jump_to
+		controller.send_integer second
+	end
+
+	# return the queue
+	def queue
+		@queue ||= Queue.new(controller)
+	end
+end
+
+end; end

data/lib/moc/controller/playlist.rb

@@ -0,0 +1,42 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; class Controller
+
+class Playlist
+	class Item < Struct.new(:file, :title_tags, :tags, :mtime)
+		attr_reader :controller
+
+		def initialize (controller)
+			@controller = controller
+			
+			if (file = controller.read_string).empty?
+				@nil = true
+			else
+				@nil = false
+
+				super(
+					file,
+					controller.read_string,
+					controller.read_tags,
+					controller.read_time
+				)
+			end
+		end
+
+		def nil?
+			@nil
+		end
+	end
+end
+
+Move = Struct.new(:from, :to)
+
+end; end

data/lib/moc/controller/status.rb

@@ -0,0 +1,103 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; class Controller
+
+class Status
+	class Song
+		attr_reader :controller
+
+		def initialize (controller)
+			@controller = controller
+		end
+
+		def channels
+			controller.send_command :get_channels
+			controller.get_integer
+		end
+
+		def rate
+			controller.send_command :get_rate
+			controller.get_integer
+		end
+
+		def bitrate
+			controller.send_command :get_bitrate
+			controller.get_integer
+		end
+		
+		def average_bitrate
+			controller.send_command :get_avg_bitrate
+			controller.get_integer
+		end
+
+		def time
+			controller.send_command :get_ctime
+			controller.get_integer
+		end
+
+		def file
+			controller.send_command :get_sname
+			controller.get_string
+		end
+
+		def tags
+			path = file
+
+			controller.send_command :get_file_tags
+			controller.send_string  path
+			controller.send_integer 0x01 | 0x02
+
+			controller.wait_for(:file_tags).tags
+		end
+
+		%w[title artist album track].each {|name|
+			define_method name do
+				tags.send name
+			end
+		}
+
+		def inspect
+			"#<#{self.class.name}: track=#{track} title=#{title} artist=#{artist} album=#{album} channels=#{channels} bitrate=#{bitrate}(#{average_bitrate}) position=#{time}>"
+		end
+	end
+
+	attr_reader :controller
+
+	def initialize (controller)
+		@controller = controller
+	end
+
+	def == (other)
+		state == other
+	end
+
+	def state
+		controller.send_command :get_state
+		controller.get_state
+	end
+
+	def volume
+		controller.send_command :get_mixer
+		controller.get_integer
+	end
+
+	def song
+		return if self == :stop
+
+		Song.new(controller)
+	end
+
+	def to_sym
+		state.to_sym
+	end
+end
+
+end; end

data/lib/moc/controller/tags.rb

@@ -0,0 +1,33 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; class Controller
+
+class Tags < Struct.new(:title, :artist, :album, :track, :time)
+	attr_reader :controller
+
+	def initialize (controller)
+		@controller = controller
+
+		super(
+			controller.read_string,
+			controller.read_string,
+			controller.read_string,
+			controller.read_integer,
+			controller.read_integer
+		)
+
+		controller.read_integer
+	end
+end
+
+FileTags = Struct.new(:file, :tags)
+
+end; end

data/lib/moc/controller/toggle.rb

@@ -0,0 +1,149 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; class Controller
+
+class Toggle
+	attr_reader :controller
+
+	def initialize (controller)
+		@controller = controller
+	end
+
+	# toggle the named item
+	def toggle (name)
+		controller.send_command :get_option
+		controller.send_string  name
+
+		value = !controller.get_integer.zero?
+
+		controller.send_command :set_option
+		controller.send_string  name
+		controller.send_integer value ? 0 : 1
+
+		self
+	end
+
+	# activate the named item
+	def on (name)
+		controller.send_command :set_option
+		controller.send_string  name
+		controller.send_integer 1
+
+		self
+	end
+
+	# deactivate the named item
+	def off (name)
+		controller.send_command :set_option
+		controller.send_string  name
+		controller.send_integer 0
+
+		self
+	end
+
+	# check if an item is active
+	def on? (name)
+		controller.send_command :get_option
+		controller.send_string  name
+
+		!controller.get_integer.zero?
+	end
+
+	# toggle the repeat status
+	def repeat
+		toggle :Repeat
+	end
+
+	# enable repeat
+	def repeat!
+		on :Repeat
+	end
+
+	# disable repeat
+	def no_repeat!
+		off :Repeat
+	end
+
+	# check if repeat is enabled
+	def repeat?
+		on? :Repeat
+	end
+
+	# toggle the shuffle status
+	def shuffle
+		toggle :Shuffle
+	end
+
+	# enable shuffle
+	def shuffle!
+		on :Shuffle
+	end
+
+	# disable shuffle
+	def no_shuffle!
+		off :Shuffle
+	end
+
+	# check if shuffle is enabled
+	def shuffle?
+		on? :Shuffle
+	end
+
+	# toggle the auto next status
+	def auto_next
+		toggle :AutoNext
+	end
+
+	# enable auto next
+	def auto_next!
+		on :AutoNext
+	end
+
+	# disable auto next
+	def no_auto_next!
+		off :AutoNext
+	end
+
+	# check if auto next is enabled
+	def auto_next?
+		on? :AutoNext
+	end
+
+	# toggle the pause status
+	def pause
+		controller.send_command :get_state
+		controller.send_command controller.get_state == :pause ? :unpause : :pause
+
+		self
+	end
+
+	# toggle mixer channel
+	def mixer_channel
+		controller.send_command :toggle_mixer_channel
+	end
+
+	# toggle soft mixer
+	def soft_mixer
+		controller.send_command :toggle_softmixer
+	end
+
+	# toggle equalizer
+	def equalizer
+		controller.send_command :toggle_equalizer
+	end
+
+	# toggle mono
+	def mono
+		controller.send_command :toggle_mono
+	end
+end
+
+end; end

data/lib/moc/controller.rb

@@ -0,0 +1,183 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'socket'
+
+require 'moc/protocol'
+
+require 'moc/controller/toggle'
+require 'moc/controller/player'
+require 'moc/controller/status'
+require 'moc/controller/tags'
+require 'moc/controller/playlist'
+
+module Moc
+
+# This is the main class to manage moc.
+#
+# The class also acts as a UNIXSocket if needed.
+class Controller
+	def self.symbol_to_code (sym)
+		return Commands[sym.to_sym.upcase]
+	end
+
+	attr_reader :path
+
+	def initialize (path = '~/.moc/socket2')
+		@path   = File.expand_path(path)
+		@socket = UNIXSocket.new(@path)
+		
+		@events = Hash.new { |h, k| h[k] = [] }
+	end
+
+	def respond_to_missing? (id, include_private = false)
+		@socket.respond_to? id, include_private
+	end
+
+	def method_missing (id, *args, &block)
+		if @socket.respond_to? id
+			return @socket.__send__ id, *args, &block
+		end
+
+		super
+	end
+
+	def send (object)
+		write object.pack
+	end
+
+	def send_command (command)
+		send(command.is_a?(Protocol::Command) ? command : Protocol::Command.new(command))
+	end
+
+	def send_integer (int)
+		send Protocol::Integer.new(int.to_i)
+	end
+
+	def send_time (time)
+		send Protocol::Time.at(time.to_i)
+	end
+
+	def send_string (string)
+		send Protocol::String.new(string.to_s)
+	end
+
+	def read_string
+		Protocol::String.read(@socket)
+	end
+
+	def read_integer
+		Protocol::Integer.read(@socket)
+	end
+
+	def read_time
+		Protocol::Time.read(@socket)
+	end
+
+	def read_event
+		Protocol::Event.read(@socket).tap {|event|
+			event.data = case event.to_sym
+				when :PLIST_ADD, :QUEUE_ADD
+					get_item
+				
+				when :PLIST_DEL, :QUEUE_DEL, :STATUS_MSG
+					get_string
+
+				when :FILE_TAGS
+					FileTags.new(read_string, read_tags)
+
+				when :PLIST_MOVE, :QUEUE_MOVE
+					Move.new(read_string, read_string)
+			end
+		}
+	end
+
+	def read_state
+		Protocol::State.read(@socket)
+	end
+
+	def read_item
+		Playlist::Item.new(self)
+	end
+
+	def read_tags
+		Tags.new(self)
+	end
+
+	%w[string integer time event state].each {|name|
+		define_method "get_#{name}" do
+			wait_for :data
+
+			__send__ "read_#{name}"
+		end
+	}
+
+	def on (event = nil, &block)
+		@events[event ? nil : event.to_sym.upcase] << block
+	end
+
+	def fire (event)
+		name = event.to_sym
+
+		@events[nil].each {|block|
+			block.call(event)
+		}
+
+		@events[name].each {|block|
+			block.call(event)
+		}
+	end
+
+	private :fire
+
+	def loop
+		while event = read_event
+			fire event
+		end
+	end
+
+	def wait_for (name)
+		while (event = read_event) != name
+			fire event
+		end
+
+		event
+	end
+
+	def active?
+		send_command :ping
+
+		read_event == :pong
+	rescue
+		false
+	end
+
+	def quit
+		send_command :quit
+	end
+
+	def toggle
+		@toggle ||= Toggle.new(self)
+	end
+
+	def player
+		@player ||= Player.new(self)
+	end
+
+	def status
+		@status ||= Status.new(self)
+	end
+
+	def inspect
+		"#<#{self.class.name}: #{@path}>"
+	end
+end
+
+end

data/lib/moc/protocol/command.rb

@@ -0,0 +1,76 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; module Protocol
+
+class Command < Symbol
+	def self.codes
+		@codes ||= {
+			PLAY:                   0x00,
+			LIST_CLEAR:             0x01,
+			LIST_ADD:               0x02,
+			STOP:                   0x04,
+			PAUSE:                  0x05,
+			UNPAUSE:                0x06,
+			SET_OPTION:             0x07,
+			GET_OPTION:             0x08,
+			GET_CTIME:              0x0d,
+			GET_SNAME:              0x0f,
+			NEXT:                   0x10,
+			QUIT:                   0x11,
+			SEEK:                   0x12,
+			GET_STATE:              0x13,
+			DISCONNECT:             0x15,
+			GET_BITRATE:            0x16,
+			GET_RATE:               0x17,
+			GET_CHANNELS:           0x18,
+			PING:                   0x19,
+			GET_MIXER:              0x1a,
+			SET_MIXER:              0x1b,
+			DELETE:                 0x1c,
+			SEND_EVENTS:            0x1d,
+			GET_ERROR:              0x1e,
+			PREV:                   0x20,
+			SEND_PLIST:             0x21,
+			GET_PLIST:              0x22,
+			CAN_SEND_PLIST:         0x23,
+			CLI_PLIST_ADD:          0x24,
+			CLI_PLIST_DEL:          0x25,
+			CLI_PLIST_CLEAR:        0x26,
+			GET_SERIAL:             0x27,
+			PLIST_SET_SERIAL:       0x28,
+			LOCK:                   0x29,
+			UNLOCK:                 0x2a,
+			PLIST_GET_SERIAL:       0x2b,
+			GET_TAGS:               0x2c,
+			TOGGLE_MIXER_CHANNEL:   0x2d,
+			GET_MIXER_CHANNEL_NAME: 0x2e,
+			GET_FILE_TAGS:          0x2f,
+			ABORT_TAGS_REQUESTS:    0x30,
+			CLI_PLIST_MOVE:         0x31,
+			LIST_MOVE:              0x32,
+			GET_AVG_BITRATE:        0x33,
+			TOGGLE_SOFTMIXER:       0x34,
+			TOGGLE_EQUALIZER:       0x35,
+			EQUALIZER_REFRESH:      0x36,
+			EQUALIZER_PREV:         0x37,
+			EQUALIZER_NEXT:         0x38,
+			TOGGLE_MAKE_MONO:       0x39,
+			JUMP_TO:                0x3a,
+			QUEUE_ADD:              0x3b,
+			QUEUE_DEL:              0x3c,
+			QUEUE_MOVE:             0x3d,
+			QUEUE_CLEAR:            0x3e,
+			GET_QUEUE:              0x3f
+		}
+	end
+end
+
+end; end

data/lib/moc/protocol/event.rb

@@ -0,0 +1,63 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; module Protocol
+
+class Event < Symbol
+	def self.codes
+		@codes ||= {
+			STATE:        0x01,
+			CTIME:        0x02,
+			SRV_ERROR:    0x04,
+			BUSY:         0x05,
+			DATA:         0x06,
+			BITRATE:      0x07,
+			RATE:         0x08,
+			CHANNELS:     0x09,
+			EXIT:         0x0a,
+			PONG:         0x0b,
+			OPTIONS:      0x0c,
+			SEND_PLIST:   0x0d,
+			TAGS:         0x0e,
+			STATUS_MSG:   0x0f,
+			MIXER_CHANGE: 0x10,
+			FILE_TAGS:    0x11,
+			AVG_BITRATE:  0x12,
+			AUDIO_START:  0x13,
+			AUDIO_STOP:   0x14,
+
+			PLIST_ADD:   0x50,
+			PLIST_DEL:   0x51,
+			PLIST_MOVE:  0x52,
+			PLIST_CLEAR: 0x53,
+
+			QUEUE_ADD:   0x54,
+			QUEUE_DEL:   0x55,
+			QUEUE_MOVE:  0x56,
+			QUEUE_CLEAR: 0x57
+		}
+	end
+
+	attr_accessor :data
+
+	def respond_to_missing? (id, include_private = false)
+		data.respond_to?(id, include_private)
+	end
+
+	def method_missing (id, *args, &block)
+		if data.respond_to? id
+			return data.__send__ id, *args, &block
+		end
+
+		super
+	end
+end
+
+end; end

data/lib/moc/protocol/integer.rb

@@ -0,0 +1,41 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; module Protocol
+
+class Integer < BasicObject
+	extend Type
+
+	def self.read (io)
+		new(io.read(4).unpack('l').first)
+	end
+
+	def initialize (value)
+		@internal = value
+	end
+
+	def respond_to_missing? (id, include_private = false)
+		@internal.respond_to? id, include_private
+	end
+
+	def method_missing (id, *args, &block)
+		if @internal.respond_to? id
+			return @internal.__send__ id, *args, &block
+		end
+
+		super
+	end
+
+	def pack
+		[self].pack('l')
+	end
+end
+
+end; end

data/lib/moc/protocol/state.rb

@@ -0,0 +1,23 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; module Protocol
+
+class State < Symbol
+	def self.codes
+		@codes ||= {
+			PLAY:  0x01,
+			STOP:  0x02,
+			PAUSE: 0x03
+		}
+	end
+end
+
+end; end

data/lib/moc/protocol/string.rb

@@ -0,0 +1,28 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; module Protocol
+
+class String < ::String
+	extend Type
+
+	def self.read (io)
+		length = Integer.read(io)
+		string = io.read(length)
+
+		new(string)
+	end
+
+	def pack
+		Integer.new(length).pack << self
+	end
+end
+
+end; end

data/lib/moc/protocol/symbol.rb

@@ -0,0 +1,63 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; module Protocol
+
+class Symbol
+	extend Type
+
+	def self.read (io)
+		new(Integer.read(io))
+	end
+
+	def self.codes
+		raise 'no code specification'
+	end
+
+	def initialize (value)
+		@internal = value.respond_to?(:to_i) ? self.class.codes.key(value.to_i) : value.to_sym.upcase
+
+		unless @internal && self.class.codes.member?(@internal)
+			raise ArgumentError, 'invalid symbol'
+		end
+	end
+
+	def == (value)
+		return true if super
+
+		return true if value.respond_to?(:to_i) && to_i == value.to_i
+
+		return true if value.respond_to?(:to_sym) && to_sym == value.to_sym.upcase
+
+		false
+	end
+
+	def to_i
+		self.class.codes[to_sym]
+	end
+
+	def to_sym
+		@internal
+	end
+
+	def to_s
+		to_sym.to_s
+	end
+
+	def inspect
+		"#<#{self.class.name}: #{to_s}>"
+	end
+
+	def pack
+		Integer.new(to_i).pack
+	end
+end
+
+end; end

data/lib/moc/protocol/time.rb

@@ -0,0 +1,21 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc; module Protocol
+
+class Time < ::Time
+	extend Type
+
+	def self.read (io)
+		at Integer.read(io)
+	end
+end
+
+end; end

data/lib/moc/protocol.rb

@@ -0,0 +1,33 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'stringio'
+
+module Moc; module Protocol
+
+module Type
+	def read (io)
+		raise 'no read has been implemented'
+	end
+
+	def unpack (text)
+		read(StringIO.new(text))
+	end
+end
+
+end; end
+
+require 'moc/protocol/integer'
+require 'moc/protocol/time'
+require 'moc/protocol/string'
+require 'moc/protocol/symbol'
+require 'moc/protocol/command'
+require 'moc/protocol/event'
+require 'moc/protocol/state'

data/lib/moc/version.rb

@@ -0,0 +1,15 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Moc
+	def self.version
+		'2.5.0'
+	end
+end

data/lib/moc.rb

@@ -0,0 +1,12 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'moc/controller'
+require 'moc/version'

data/moc.gemspec

@@ -0,0 +1,16 @@
+Kernel.load 'lib/moc/version.rb'
+
+Gem::Specification.new {|s|
+	s.name         = 'moc'
+	s.version      = Moc.version
+	s.author       = 'meh.'
+	s.email        = 'meh@paranoici.org'
+	s.homepage     = 'http://github.com/meh/ruby-moc'
+	s.platform     = Gem::Platform::RUBY
+	s.summary      = 'moc controller library.'
+
+	s.files         = `git ls-files`.split("\n")
+	s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.require_paths = ['lib']
+}

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: moc
+version: !ruby/object:Gem::Version
+  version: 2.5.0
+  prerelease: 
+platform: ruby
+authors:
+- meh.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-20 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: meh@paranoici.org
+executables:
+- mocp.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/mocp.rb
+- lib/moc.rb
+- lib/moc/controller.rb
+- lib/moc/controller/player.rb
+- lib/moc/controller/playlist.rb
+- lib/moc/controller/status.rb
+- lib/moc/controller/tags.rb
+- lib/moc/controller/toggle.rb
+- lib/moc/protocol.rb
+- lib/moc/protocol/command.rb
+- lib/moc/protocol/event.rb
+- lib/moc/protocol/integer.rb
+- lib/moc/protocol/state.rb
+- lib/moc/protocol/string.rb
+- lib/moc/protocol/symbol.rb
+- lib/moc/protocol/time.rb
+- lib/moc/version.rb
+- moc.gemspec
+homepage: http://github.com/meh/ruby-moc
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: moc controller library.
+test_files: []