listlace 0.0.5 → 0.0.6

data/lib/listlace/commands/queue.rb

@@ -1,52 +0,0 @@
-module Listlace
-  # The queue command. Simply appends tracks to the queue. It creates a playlist
-  # with the arguments you give it, so anything you can pass to the playlist()
-  # method you can pass to this. It returns the queue, so you can use this
-  # method as an accessor by not passing any arguments.
-  def q(*args)
-    $player.queue playlist(*args)
-    $player.queue
-  end
-
-  # Clears the queue.
-  def clear
-    $player.clear
-    puts "Queue cleared."
-  end
-
-  # Shuffles the queue, keeping the current track at the top.
-  def shuffle
-    $player.shuffle
-    puts "Shuffled."
-  end
-
-  # Sorts the queue by a list of fields and directions in the form of a symbol,
-  # or uses the proc given to it, which should take two Tracks and return -1, 0,
-  # or 1.
-  def sort(by = :artist_asc_album_asc_track_number_asc, &proc)
-    if proc
-      $player.sort(&proc)
-    else
-      $player.sort do |a, b|
-        result = 0
-        by.to_s.scan(/([a-z_]+?)_(asc|desc)(?:_|$)/).each do |column, direction|
-          a_value = a.send(column)
-          b_value = b.send(column)
-          a_value = a_value.downcase if a_value.respond_to? :downcase
-          b_value = b_value.downcase if b_value.respond_to? :downcase
-          dir = (direction == "desc") ? -1 : 1
-          if a_value != b_value
-            if a_value.nil? || b_value.nil?
-              result = dir
-            else
-              result = (a_value <=> b_value) * dir
-            end
-            break
-          end
-        end
-        result
-      end
-    end
-    puts "Sorted."
-  end
-end

data/lib/listlace/commands/selectors.rb

@@ -1,186 +0,0 @@
-module Listlace
-  STRING_SELECTORS = %w(name artist composer album album_artist genre comments location)
-  INTEGER_SELECTORS = %w(disc_number disc_count track_number track_count year bit_rate sample_rate play_count skip_count rating)
-
-  STRING_SELECTORS.each do |column|
-    define_method(column) do |*args|
-      options = args.last.is_a?(Hash) ? args.pop : {}
-
-      playlists = args.map { |query| string_selector(column, query, options) }
-      playlist *playlists
-    end
-  end
-
-  INTEGER_SELECTORS.each do |column|
-    define_method(column) do |*args|
-      playlists = args.map { |arg| integer_selector(column, arg) }
-      playlist *playlists
-    end
-  end
-
-  # rename the "name" selector to "song"
-  alias_method :song, :name
-  remove_method :name
-
-  # The length selector is an integer selector for the length of a track. A
-  # plain integer given to it represents the number of seconds. It can also take
-  # a String in the format "1:23", to represent 83 seconds, for example. These
-  # can be part of a Range, as usual: "1:23".."2:05", for example.
-  def length(*args)
-    normalize = lambda do |value|
-      case value
-      when String
-        Track.parse_time(value)
-      when Integer
-        value * 1000
-      when Range
-        (normalize.(value.begin))..(normalize.(value.end))
-      end
-    end
-
-    playlists = args.map do |arg|
-      if arg.is_a? Hash
-        key = arg.keys.first
-        arg[key] = normalize.(arg[key])
-      else
-        arg = normalize.(arg)
-      end
-
-      # If they want tracks of length "0:05", for example, we need to look for
-      # tracks that are from 5000 to 5999 milliseconds long.
-      if arg.is_a? Integer
-        arg = (arg)..(arg + 999)
-      end
-
-      integer_selector(:total_time, arg)
-    end
-
-    playlist *playlists
-  end
-
-  # Makes a playlist out of tracks that match the string query on the given
-  # column. It's SQL underneath, so you can use % and _ as wildcards in the
-  # query. By default, % wildcards are inserted on the left and right of your
-  # query. Use the :match option to change this:
-  #
-  #   :match => :middle   "%query%"   (default)
-  #   :match => :left     "query%"
-  #   :match => :right    "%query"
-  #   :match => :exact    "query"
-  #
-  # This method shouldn't have to be used directly. Many convenient methods are
-  # generated for you, one for each string field you may want to select on.
-  # These are: artist, composer, album, album_artist, genre, comments, location.
-  # For example:
-  #
-  #   artist :muse, match: :exact #=> playlist (108 tracks)
-  #   composer :rachmanino #=> playlist (33 tracks)
-  #
-  # To match the name of a track, use song:
-  #
-  #   song "frontier psychiatrist" #=> playlist (1 track)
-  #
-  def string_selector(column, query, options = {})
-    options[:match] ||= :middle
-
-    query = {
-      exact: "#{query}",
-      left: "#{query}%",
-      right: "%#{query}",
-      middle: "%#{query}%"
-    }[options[:match]]
-
-    tracks = Track.arel_table
-    PlaylistArray.new(Track.where(tracks[column].matches(query)).all)
-  end
-
-  # Makes a playlist out of tracks that satisfy certain conditions on the given
-  # integer column. You can pass an exact value to check for equality, a range,
-  # or a hash that specifies greater-than and less-than options like this:
-  #
-  #   integer_selector :year, greater_than: 2000 #=> playlist (3555 tracks)
-  #
-  # The possible operators, with their shortcuts, are:
-  #
-  #   :greater_than / :gt
-  #   :less_than / :lt
-  #   :greater_than_or_equal / :gte
-  #   :less_than_or_equal / :lte
-  #   :not_equal / :ne
-  #
-  # Note: You can only use one of these operators at a time. If you want a
-  # range, use a Range.
-  #
-  # This method shouldn't have to be used directly. Many convenient methods are
-  # generated for you, one for each integer field you may want to select on.
-  # These are: disc_number, disc_count, track_number, track_count, year,
-  # bit_rate, sample_rate, play_count, skip_count, rating, length. Length is
-  # special, it can take any of the time formats that the seek command can. For
-  # example:
-  #
-  #   year 2010..2012 #=> playlist (1060 tracks)
-  #   length gt: "4:00" #=> playlist (2543 tracks)
-  #
-  def integer_selector(column, value_or_options)
-    if value_or_options.is_a? Hash
-      operator = {
-        greater_than: ">",
-        gt: ">",
-        less_than: "<",
-        lt: "<",
-        greater_than_or_equal: ">=",
-        gte: ">=",
-        less_than_or_equal: "<=",
-        lte: "<=",
-        not_equal: "<>",
-        ne: "<>"
-      }[value_or_options.keys.first]
-      tracks = Track.where("tracks.#{column} #{operator} ?", value_or_options.values.first)
-      PlaylistArray.new(tracks.all)
-    else
-      tracks = Track.arel_table
-      PlaylistArray.new(Track.where(column => value_or_options).all)
-    end
-  end
-
-  # Creates or looks up a playlist. You can pass any number of multiple types of
-  # objects to make a playlist:
-  #
-  #   Track: Makes a playlist with one track
-  #   ActiveRecord::Relation: Makes a playlist out of the resulting Track or Playlist records
-  #   Symbol or String: Tries to retrieve a saved playlist with the given name.
-  #     If it can't find one, it creates a new one.
-  #
-  # You can also pass in the results of a selector. In this way you can create a
-  # playlist out of many smaller pieces.
-  #
-  # If given no arguments, it returns a blank playlist.
-  #
-  def playlist(*args)
-    args.map do |object|
-      case object
-      when Track
-        PlaylistArray.new([object])
-      when Playlist
-        PlaylistArray.new([object.tracks.all], object.name)
-      when PlaylistArray
-        object
-      when Array
-        playlist *object
-      when ActiveRecord::Relation
-        if object.table.name == "tracks"
-          PlaylistArray.new([object.all])
-        elsif object.table.name == "playlists"
-          playlist *object.all
-        end
-      when Symbol, String
-        playlists = Playlist.arel_table
-        if playlist = Playlist.where(playlists[:name].matches(object.to_s)).first
-          PlaylistArray.new(playlist)
-        else
-          PlaylistArray.new([], object)
-        end
-      end
-    end.inject(:+)
-  end
-end

data/lib/listlace/database.rb

@@ -1,74 +0,0 @@
-module Listlace
-  module Database
-    extend self
-
-    ADAPTER = "sqlite3"
-    PATH = "#{Listlace::DIR}/library.sqlite3"
-
-    def connect
-      ActiveRecord::Base.establish_connection(adapter: ADAPTER, database: PATH)
-    end
-
-    def exists?
-      File.exists? PATH
-    end
-
-    def delete
-      FileUtils.rm PATH
-    end
-
-    def wipe
-      delete
-      connect
-      generate_schema
-    end
-
-    def generate_schema
-      ActiveRecord::Schema.define do
-        create_table :tracks do |t|
-          t.integer :original_id
-          t.string :name
-          t.string :artist
-          t.string :composer
-          t.string :album
-          t.string :album_artist
-          t.string :genre
-          t.string :kind
-          t.integer :size
-          t.integer :total_time
-          t.integer :disc_number
-          t.integer :disc_count
-          t.integer :track_number
-          t.integer :track_count
-          t.integer :year
-          t.datetime :date_modified
-          t.datetime :date_added
-          t.integer :bit_rate
-          t.integer :sample_rate
-          t.text :comments
-          t.integer :play_count
-          t.integer :play_date
-          t.datetime :play_date_utc
-          t.integer :skip_count
-          t.datetime :skip_date
-          t.integer :rating
-          t.integer :album_rating
-          t.boolean :album_rating_computed
-          t.string :location
-        end
-
-        create_table :playlists do |t|
-          t.string :name
-          t.datetime :created_at
-          t.datetime :updated_at
-        end
-
-        create_table :playlist_items do |t|
-          t.references :playlist, null: false
-          t.references :track, null: false
-          t.integer :position
-        end
-      end
-    end
-  end
-end

data/lib/listlace/mplayer.rb

@@ -1,51 +0,0 @@
-module Listlace
-  # This is a simple MPlayer wrapper, it just handles opening the MPlayer
-  # process, hooking into when mplayer exits (when the song is done), and
-  # issuing commands through the slave protocol.
-  class MPlayer
-    def initialize(track, &on_quit)
-      cmd = "/usr/bin/mplayer -slave -quiet #{Shellwords.shellescape(track.location)}"
-      @pid, @stdin, @stdout, @stderr = Open4.popen4(cmd)
-      @paused = false
-      @extra_lines = 0
-
-      until @stdout.gets["playback"]
-      end
-
-      @quit_hook_active = false
-      @quit_hook = Thread.new do
-        Process.wait(@pid)
-        @quit_hook_active = true
-        on_quit.call
-      end
-    end
-
-    def command(cmd, options = {})
-      if cmd == "pause"
-        @paused = !@paused
-      elsif @paused
-        cmd = "pausing #{cmd}"
-      end
-
-      @stdin.puts cmd
-
-      if options[:expect_answer]
-        answer = "\n"
-        answer = @stdout.gets.sub("\e[A\r\e[K", "") while answer == "\n"
-        answer
-      end
-    end
-
-    def quit
-      @quit_hook.kill unless @quit_hook_active
-      command "quit" if alive?
-    end
-
-    def alive?
-      Process.getpgid(@pid)
-      true
-    rescue Errno::ESRCH
-      false
-    end
-  end
-end

data/lib/listlace/playlist_array.rb

@@ -1,82 +0,0 @@
-module Listlace
-  class PlaylistArray < Array
-    attr_accessor :name, :model
-
-    def initialize(tracks_or_playlist = [], name = :playlist)
-      if tracks_or_playlist.is_a? Playlist
-        replace tracks_or_playlist.tracks.to_a
-        @name = tracks_or_playlist.name
-        @model = tracks_or_playlist
-      else
-        replace tracks_or_playlist.to_a
-        @name = name.to_s
-        @model = nil
-      end
-    end
-
-    def save(name = nil)
-      if @model
-        @model.playlist_items.destroy_all
-        @model.name = @name = name if name
-      else
-        @name = name if name
-        @model = Playlist.new(name: @name)
-      end
-
-      if @model.save
-        each.with_index do |track, i|
-          item = PlaylistItem.new(position: i)
-          item.playlist = @model
-          item.track = track
-          item.save!
-        end
-        @model
-      else
-        false
-      end
-    end
-
-    def <<(other)
-      if other.is_a? Track
-        super
-      else
-        other.each do |track|
-          self << track
-        end
-      end
-    end
-
-    def +(other)
-      result = self.dup
-      result << Listlace.playlist(other)
-      result
-    end
-
-    def &(other)
-      replace super
-    end
-
-    def shuffle_except(track)
-      ary = dup
-      dup.shuffle_except! track
-      dup
-    end
-
-    def shuffle_except!(track)
-      replace([track] + (self - [track]).shuffle)
-    end
-
-    def to_s
-      "%s (%d track%s)" % [@name || "playlist", length, ("s" if length != 1)]
-    end
-
-    def inspect
-      to_s
-    end
-
-    # override pry
-    def pretty_inspect
-      inspect
-    end
-  end
-end