listlace 0.0.9 → 0.1.0

data/lib/listlace/models/playlist_item.rb

@@ -1,6 +0,0 @@
-module Listlace
-  class PlaylistItem < ActiveRecord::Base
-    belongs_to :playlist
-    belongs_to :track
-  end
-end

data/lib/listlace/models/track.rb

@@ -1,21 +0,0 @@
-module Listlace
-  class Track < ActiveRecord::Base
-    has_many :playlist_items
-    has_many :playlists, through: :playlist_items
-
-    validates :location, presence: true, uniqueness: true
-
-    before_create { |track| track.date_added = Time.now }
-    before_save { |track| track.date_modified = Time.now }
-
-    def increment_skip_count
-      increment! :skip_count
-      update_column :skip_date, Time.now
-    end
-
-    def increment_play_count
-      increment! :play_count
-      update_column :play_date, Time.now
-    end
-  end
-end

data/lib/listlace/player.rb

@@ -1,249 +0,0 @@
-module Listlace
-  # This is the music box. It plays playlists. It contains a queue, which is
-  # just a playlist. To tell it what to play, you add one or more playlists to
-  # the queue, then start playing using the start method.
-  #
-  # Playback commands like pause, resume, seek, and so on are delegated to the
-  # SinglePlayer, which takes care of playing each individual song.
-  #
-  # Each method that performs an action is like a button on a physical media
-  # player: you can press the buttons even if they aren't applicable to the
-  # current state of the player. If that's the case, the methods wil return
-  # false. Otherwise, they'll return a truthy value.
-  class Player
-    DEFAULT_SINGLE_PLAYER = SinglePlayers::MPlayer
-
-    attr_reader :current_track, :current_track_index, :repeat_mode
-
-    def initialize
-      @single_player = DEFAULT_SINGLE_PLAYER.new
-      @queue = []
-      @current_track = nil
-      @current_track_index = nil
-      @playlist_paused = false
-      @started = false
-      @repeat_mode = false
-    end
-
-    def queue(playlist = nil)
-      if playlist.is_a? Array
-        playlist = playlist.dup
-        playlist.map! { |track| track.is_a?(String) ? SimpleTrack.new(track) : track }
-        playlist.select! { |track| track.respond_to? :location }
-        if @queue.empty?
-          @queue = playlist
-        else
-          @queue += playlist
-        end
-      end
-      @queue.dup
-    end
-
-    def clear
-      stop
-      @queue.clear
-      true
-    end
-
-    def empty?
-      @queue.empty?
-    end
-
-    def playlist_paused?
-      @playlist_paused
-    end
-
-    def paused?
-      playlist_paused? or @single_player.paused?
-    end
-
-    def started?
-      @started
-    end
-
-    def start
-      unless empty?
-        @started = true
-        @playlist_paused = false
-        @current_track = @queue.first
-        @current_track_index = 0
-        play_track @current_track
-        true
-      else
-        false
-      end
-    end
-
-    def stop
-      @single_player.stop
-      @current_track = nil
-      @current_track_index = nil
-      @playlist_paused = false
-      @started = false
-      true
-    end
-
-    def pause
-      @single_player.pause
-    end
-
-    def resume
-      if playlist_paused?
-        play_track @current_track
-        @playlist_paused = false
-        true
-      else
-        @single_player.resume
-      end
-    end
-
-    def repeat(one_or_all_or_off)
-      case one_or_all_or_off
-      when :one
-        @repeat_mode = :one
-      when :all
-        @repeat_mode = :all
-      when :off
-        @repeat_mode = false
-      end
-      true
-    end
-
-    def restart
-      change_track(0)
-    end
-
-    def back(n = 1)
-      change_track(-n)
-    end
-
-    def skip(n = 1)
-      if @current_track.respond_to?(:increment_skip_count)
-        @current_track.increment_skip_count
-      end
-      change_track(n)
-    end
-
-    def seek(where)
-      if playlist_paused?
-        resume
-        pause
-        seek where
-      else
-        case where
-        when Integer
-          @single_player.seek(where, :relative)
-        when Range
-          seconds = where.begin * 60 + where.end
-          @single_player.seek(seconds * 1000, :absolute)
-        when String
-          @single_player.seek(Listlace.parse_time(where), :absolute)
-        when Hash
-          if where[:abs]
-            if where[:abs].is_a? Integer
-              @single_player.seek(where[:abs], :absolute)
-            else
-              seek(where[:abs])
-            end
-          elsif where[:percent]
-            @single_player.seek(where[:percent], :percent)
-          end
-        end
-      end
-    end
-
-    def speed
-      @single_player.speed || 1.0
-    end
-
-    def speed=(new_speed)
-      @single_player.speed = new_speed
-    end
-
-    def mute
-      @single_player.mute
-    end
-
-    def unmute
-      @single_player.unmute
-    end
-
-    def volume
-      @single_player.volume
-    end
-
-    def volume=(new_volume)
-      @single_player.volume = new_volume
-    end
-
-    def shuffle
-      if started?
-        @queue.shuffle_except! @current_track
-        @current_track_index = 0
-      else
-        @queue.shuffle!
-      end
-      true
-    end
-
-    def sort(&by)
-      @queue.sort! &by
-      if started?
-        @current_track_index = @queue.index(@current_track)
-      end
-      true
-    end
-
-    def current_time
-      @single_player.current_time || 0
-    end
-
-    def total_time
-      @single_player.total_time
-    end
-
-    private
-
-    def change_track(by = 1, options = {})
-      if started?
-        if options[:auto] && @current_track.respond_to?(:increment_play_count)
-          @current_track.increment_play_count
-        end
-        @current_track_index += by
-        if options[:auto] && @repeat_mode
-          case @repeat_mode
-          when :one
-            @current_track_index -= by
-          when :all
-            if @current_track_index >= @queue.length
-              @current_track_index = 0
-            end
-          end
-        end
-        @current_track = @queue[@current_track_index]
-        if @current_track && @current_track_index >= 0
-          if @single_player.paused?
-            @single_player.stop
-            @playlist_paused = true
-          elsif not playlist_paused?
-            play_track @current_track
-          end
-        else
-          stop
-        end
-        true
-      else
-        false
-      end
-    end
-
-    def play_track(track)
-      @single_player.play(track) do
-        change_track(1, auto: true)
-        ActiveRecord::Base.connection.close if defined?(ActiveRecord)
-      end
-      @playlist_paused = false
-      true
-    end
-  end
-end

data/lib/listlace/simple_track.rb

@@ -1,13 +0,0 @@
-module Listlace
-  # The bare minimum needed to represent a track. This is used by the Player and
-  # SinglePlayer, in case they get passed a String containing a path to an audio
-  # file. That way, users don't have to worry about creating track objects, if
-  # they want.
-  class SimpleTrack
-    attr_accessor :location
-
-    def initialize(location = nil)
-      @location = location
-    end
-  end
-end

data/lib/listlace/single_player.rb

@@ -1,129 +0,0 @@
-module Listlace
-  # A SinglePlayer takes care of playing a single track, and controlling the
-  # playback with commands like pause, resume, seek, and so on. It typically
-  # starts an external audio player process to do this job. This class is an
-  # interface that is to be implemented for different audio players. Then the
-  # user can choose which SinglePlayer to use based on what audio players they
-  # have installed.
-  #
-  # All methods that perform an action should return false if the action isn't
-  # applicable, and return a truthy value otherwise.
-  class SinglePlayer
-    # Returns true if a track is currently loaded, i.e. either playing or
-    # paused.
-    def active?
-      raise NotImplementedError
-    end
-
-    # Returns true if a track is loaded and is paused.
-    def paused?
-      raise NotImplementedError
-    end
-
-    # Get the current track object which was passed to the play method.
-    def track
-      raise NotImplementedError
-    end
-
-    # Get the title of the current track. First tries to call the title method on
-    # the current track, if that doesn't work it tries to get the title from the
-    # metadata of the audio file, and if that doesn't work it uses the filename.
-    def track_title
-      raise NotImplementedError
-    end
-
-    # Begin playing a track. The track should be either a String representing a
-    # path to an audio file, or an object responding to #location. The &on_end
-    # callback will be called when the track is finished playing.
-    def play(track, &on_end)
-      raise NotImplementedError
-    end
-
-    # Stop playback. Typically quits the external audio player process.
-    def stop
-      raise NotImplementedError
-    end
-
-    # Pauses playback.
-    def pause
-      raise NotImplementedError
-    end
-
-    # Resumes playback.
-    def resume
-      raise NotImplementedError
-    end
-
-    # Seek to a particular position in the track. Different types can be
-    # supported, such as absolute, relative, or percent. All times are specified
-    # in milliseconds. A NotImplementedError is raised when a certain type isn't
-    # supported.
-    def seek(where, type = :absolute)
-      case type
-      when :absolute
-        raise NotImplementedError
-      when :relative
-        raise NotImplementedError
-      when :percent
-        raise NotImplementedError
-      else
-        raise NotImplementedError
-      end
-    end
-
-    # Gets the current playback speed. The speed is a multiplier. For example,
-    # double speed is 2 and half-speed is 0.5. Normal speed is 1.
-    def speed
-      raise NotImplementedError
-    end
-
-    # Sets the playback speed. The speed is a multiplier. For example, for
-    # double speed you'd set it to 2 and for half-speed you'd set it to 0.5. And
-    # for normal speed: 1.
-    def speed=(new_speed)
-      raise NotImplementedError
-    end
-
-    # Returns true if audio is muted.
-    def muted?
-      raise NotImplementedError
-    end
-
-    # Mutes the audio player.
-    def mute
-      raise NotImplementedError
-    end
-
-    # Unmutes the audio player.
-    def unmute
-      raise NotImplementedError
-    end
-
-    # Get the current volume as a percentage.
-    def volume
-      raise NotImplementedError
-    end
-
-    # Set the volume as a percentage. The player is automatically unmuted.
-    def volume=(new_volume)
-      raise NotImplementedError
-    end
-
-    # Returns the current time into the song, in milliseconds.
-    def current_time
-      raise NotImplementedError
-    end
-
-    # Returns the length of the current track, in milliseconds.
-    def total_time
-      raise NotImplementedError
-    end
-
-    # Get metadata for the current track from the audio player. Returns a Hash
-    # with keys like :artist and :album. Values should be Strings, or nil if the
-    # value is blank.
-    def metadata
-      raise NotImplementedError
-    end
-  end
-end

data/lib/listlace/single_players/mplayer.rb

@@ -1,255 +0,0 @@
-module Listlace
-  module SinglePlayers
-    # This is the SinglePlayer implementation for mplayer. It requires mplayer
-    # to be in your $PATH. It uses open4 to start up and communicate with the
-    # mplayer process, and mplayer's slave protocol to issue commands to mplayer.
-    class MPlayer < SinglePlayer
-      # Create a new MPlayer. The mplayer process is only started when the #play
-      # method is called to start playing a song. The process quits when the
-      # song ends. Even though a new process is started for each song, the
-      # MPlayer object keeps track of the volume, speed, and mute properties and
-      # sets these properties when a new song is played.
-      def initialize
-        @paused = false
-        @muted = false
-        @volume = 50
-        @speed = 1.0
-        @track = nil
-      end
-
-      def active?
-        not @track.nil?
-      end
-
-      def paused?
-        @paused
-      end
-
-      def track
-        @track
-      end
-
-      def track_title
-        if active?
-          if @track.respond_to? :title
-            @track.title
-          elsif title = metadata[:title]
-            title
-          else
-            _command "get_file_name", expect_answer: /^ANS_FILENAME='(.+)'$/
-          end
-        else
-          false
-        end
-      end
-
-      def play(track, &on_end)
-        # Make sure we're only playing one song at any one time.
-        _quit
-
-        # If a path to an audio file passed as the track, wrap it in a SimpleTrack.
-        track = SimpleTrack.new(track) if track.is_a? String
-
-        # The track object must respond to #location to be a track.
-        if not track.respond_to? :location
-          raise ArgumentError, "got a #{track.class} instead of a track"
-        end
-
-        if File.exists? track.location
-          # Run the mplayer process in slave mode, passing it the location of
-          # the track's audio file.
-          cmd = ["mplayer", "-slave", "-quiet", track.location]
-          @pid, @stdin, @stdout, @stderr = Open4.popen4(*cmd)
-
-          # This should skip past mplayer's initial lines of output so we can
-          # start reading its replies to our commands.
-          until @stdout.gets["playback"]
-          end
-
-          @paused = false
-          @track = track
-
-          # Persist the previous speed, volume, and mute properties into this
-          # process.
-          self.speed = @speed
-          self.volume = @volume
-          mute if @muted
-
-          # Start a thread that waits for the mplayer process to end, then calls
-          # the end of song callback. If the #quit method is called, this thread
-          # will be killed if it's still waiting for the process to end.
-          @quit_hook_active = false
-          @quit_hook = Thread.new do
-            Process.wait(@pid)
-            @quit_hook_active = true
-            @paused = false
-            @track = nil
-            on_end.call
-          end
-
-          true
-        else
-          false
-        end
-      end
-
-      def stop
-        _quit
-      end
-
-      def pause
-        if not @paused
-          @paused = true
-          _command "pause"
-        else
-          false
-        end
-      end
-
-      def resume
-        if @paused
-          @paused = false
-          _command "pause"
-        else
-          false
-        end
-      end
-
-      def seek(where, type = :absolute)
-        # mplayer talks seconds, not milliseconds.
-        seconds = where.to_f / 1_000
-        case type
-        when :absolute
-          _command "seek #{seconds} 2", expect_answer: true
-        when :relative
-          _command "seek #{seconds} 0", expect_answer: true
-        when :percent
-          _command "seek #{where} 1", expect_answer: true
-        else
-          raise NotImplementedError
-        end
-      end
-
-      def speed
-        @speed
-      end
-
-      def speed=(new_speed)
-        @speed = new_speed.to_f
-        answer = _command "speed_set #{@speed}", expect_answer: true
-        !!answer
-      end
-
-      def muted?
-        @muted
-      end
-
-      def mute
-        @muted = true
-        answer = _command "mute 1", expect_answer: true
-        !!answer
-      end
-
-      def unmute
-        @muted = false
-        answer = _command "mute 0", expect_answer: true
-        !!answer
-      end
-
-      def volume
-        @volume
-      end
-
-      def volume=(new_volume)
-        @muted = false
-        @volume = new_volume.to_f
-        answer = _command "volume #{@volume} 1", expect_answer: true
-        !!answer
-      end
-
-      def current_time
-        answer = _command "get_time_pos", expect_answer: /^ANS_TIME_POSITION=([0-9.]+)$/
-        answer ? (answer.to_f * 1000).to_i : false
-      end
-
-      def total_time
-        answer = _command "get_time_length", expect_answer: /^ANS_LENGTH=([0-9.]+)$/
-        answer ? (answer.to_f * 1000).to_i : false
-      end
-
-      def metadata
-        properties = %w(album artist comment genre title track year)
-        properties.inject({}) do |hash, property|
-          answer = _command "get_meta_#{property}", expect_answer: /^ANS_META_#{property.upcase}='(.+)'$/
-          hash[property.to_sym] = answer || nil
-          hash
-        end
-      end
-
-      private
-
-      # Issue a command to mplayer through the slave protocol. False is returned
-      # if the process is dead (not playing anything).
-      #
-      # If :expect_answer option is set to true, this will wait for a legible
-      # answer back from mplayer, and send it as a return value. If :expect_answer
-      # is set to a Regexp, the answer mplayer gives back will be matched to that
-      # Regexp and the first match will be returned. If there are no matches, nil
-      # will be returned.
-      def _command(cmd, options = {})
-        if _alive? and active?
-          # If the player is paused, prefix the command with "pausing ".
-          # Otherwise it unpauses when it runs a command. The only exception to
-          # this is when the "pause" command itself is issued.
-          if paused? and cmd != "pause"
-            cmd = "pausing #{cmd}"
-          end
-
-          # Send the command to mplayer.
-          @stdin.puts cmd
-
-          if options[:expect_answer]
-            # Read lines of output from mplayer until we get an actual message.
-            answer = "\n"
-            while answer == "\n"
-              answer = @stdout.gets.sub("\e[A\r\e[K", "")
-              answer = "\n" if options[:expect_answer].is_a?(Regexp) && answer !~ options[:expect_answer]
-            end
-
-            if options[:expect_answer].is_a? Regexp
-              matches = answer.match(options[:expect_answer])
-              answer = matches && matches[1]
-            end
-
-            answer
-          else
-            true
-          end
-        else
-          false
-        end
-      end
-
-      # Quit the mplayer process, stopping playback. The end of song callback
-      # will not be called if this method is called.
-      def _quit
-        if _alive?
-          @quit_hook.kill unless @quit_hook_active
-          _command "quit"
-          @paused = false
-          @track = nil
-        end
-        true
-      end
-
-      # Check if the mplayer process is still around.
-      def _alive?
-        return false if @pid.nil?
-        Process.getpgid(@pid)
-        true
-      rescue Errno::ESRCH
-        false
-      end
-    end
-  end
-end

data/lib/listlace/time_helper.rb

@@ -1,34 +0,0 @@
-module Listlace
-  # Helper method to format a number of milliseconds as a string like
-  # "1:03:56.555". The only option is :include_milliseconds, true by default. If
-  # false, milliseconds won't be included in the formatted string.
-  def self.format_time(milliseconds, options = {})
-    ms = milliseconds % 1000
-    seconds = (milliseconds / 1000) % 60
-    minutes = (milliseconds / 60000) % 60
-    hours = milliseconds / 3600000
-
-    if ms.zero? || options[:include_milliseconds] == false
-      ms_string = ""
-    else
-      ms_string = ".%03d" % [ms]
-    end
-
-    if hours > 0
-      "%d:%02d:%02d%s" % [hours, minutes, seconds, ms_string]
-    else
-      "%d:%02d%s" % [minutes, seconds, ms_string]
-    end
-  end
-
-  # Helper method to parse a string like "1:03:56.555" and return the number of
-  # milliseconds that time length represents.
-  def self.parse_time(string)
-    parts = string.split(":").map(&:to_f)
-    parts = [0] + parts if parts.length == 2
-    hours, minutes, seconds = parts
-    seconds = hours * 3600 + minutes * 60 + seconds
-    milliseconds = seconds * 1000
-    milliseconds.to_i
-  end
-end