listlace 0.0.5 → 0.0.6

data/lib/listlace/library/selectors.rb

@@ -0,0 +1,196 @@
+module Listlace
+  class Library
+    module Selectors
+      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 = library.tracks.arel_table
+        library.tracks.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]
+          library.tracks.where("tracks.#{column} #{operator} ?", value_or_options.values.first).all
+        else
+          library.tracks.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
+            [object]
+          when Playlist
+            pl = [object.tracks.all]
+            pl.name = object.name
+            pl
+          when Array
+            if object.playlist?
+              object
+            else
+              playlist *object
+            end
+          when ActiveRecord::Relation
+            if object.table.name == "tracks"
+              object.all
+            elsif object.table.name == "playlists"
+              playlist *object.all
+            end
+          when Symbol, String
+            playlists = library.playlists.arel_table
+            if playlist = library.playlists.where(playlists[:name].matches(object.to_s)).first
+              pl = playlist.tracks.all
+              pl.name = playlist.name
+              pl
+            else
+              pl = []
+              pl.name = object
+              pl
+            end
+          end
+        end.inject(:+)
+      end
+    end
+  end
+end

data/lib/listlace/library.rb

@@ -0,0 +1,41 @@
+require "listlace/library/database"
+require "listlace/library/selectors"
+
+module Listlace
+  class Library
+    def initialize(options = {})
+      options[:db_path] ||= "library"
+      options[:db_adapter] ||= "sqlite3"
+
+      unless File.exists? Listlace::DIR
+        FileUtils.mkdir_p Listlace::DIR
+      end
+
+      @db_path = options[:db_path]
+      @db_path = "#{Listlace::DIR}/#{@db_path}" unless @db_path.include? "/"
+      @db_path = "#{@db_path}.sqlite3" unless @db_path =~ /\.sqlite3$/
+
+      @db_adapter = options[:db_adapter]
+
+      Database.disconnect if Database.connected?
+      Database.connect(@db_adapter, @db_path)
+      Database.generate_schema unless Database.exists?(@db_path)
+    end
+
+    def tracks
+      Track.scoped
+    end
+
+    def playlists
+      Playlist.scoped
+    end
+
+    def size
+      tracks.length
+    end
+
+    def wipe
+      Database.wipe(@db_adapter, @db_path)
+    end
+  end
+end

data/lib/listlace/models.rb

@@ -0,0 +1,3 @@
+require "listlace/models/track"
+require "listlace/models/playlist"
+require "listlace/models/playlist_item"

data/lib/listlace/player/mplayer.rb

@@ -0,0 +1,53 @@
+module Listlace
+  class Player
+    # 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
+end

data/lib/listlace/player.rb

@@ -1,3 +1,5 @@
+require "listlace/player/mplayer"
+
 module Listlace
   # This is the music box. It contains a queue, which is an array of tracks. It
   # then plays these tracks sequentially. The buttons for play, pause, next,
@@ -7,7 +9,8 @@ module Listlace
 
     def initialize
       @mplayer = nil
-      @queue = PlaylistArray.new([], :queue)
+      @queue = []
+      @queue.name = :queue
       @current_track = nil
       @current_track_index = nil
       @paused = false
@@ -16,13 +19,21 @@ module Listlace
     end
 
     def queue(playlist = nil)
-      @queue << playlist if playlist
+      if playlist.is_a? Array
+        if @queue.empty? && playlist.name && !playlist.name.empty?
+          @queue = playlist.dup
+        else
+          @queue += playlist
+          @queue.name = :queue
+        end
+      end
       @queue.dup
     end
 
     def clear
       stop
       @queue.clear
+      @queue.name = :queue
     end
 
     def empty?
@@ -93,6 +104,8 @@ module Listlace
     end
 
     def skip(n = 1)
+      @current_track.increment! :skip_count
+      @current_track.update_column :skip_date, Time.now
       change_track(n)
     end
 
@@ -159,6 +172,10 @@ module Listlace
     private
 
     def change_track(by = 1, options = {})
+      if options[:auto]
+        @current_track.increment! :play_count
+        @current_track.update_column :play_date_utc, Time.now
+      end
       @current_track_index += by
       if options[:auto] && @repeat_mode
         case @repeat_mode

data/lib/listlace.rb

@@ -1,37 +1,22 @@
-module Listlace
-  extend self
-
-  DIR = ENV["LISTLACE_DIR"] || (ENV["HOME"] + "/.listlace")
-  PROMPT = [proc { ">> " }, proc { " | " }]
-  PRINT = proc do |output, value|
-    unless value.nil?
-      Pry::DEFAULT_PRINT.call(output, value)
-    end
-  end
-end
-
 require "open4"
 require "shellwords"
 require "active_record"
 require "fileutils"
+require "plist"
+require "active_support/core_ext/string"
 
-require "listlace/database"
+require "listlace/array_ext"
+require "listlace/library"
 require "listlace/player"
-require "listlace/mplayer"
-require "listlace/playlist_array"
-
-require "listlace/models/track"
-require "listlace/models/playlist"
-require "listlace/models/playlist_item"
+require "listlace/commands"
+require "listlace/models"
 
-require "listlace/commands/library"
-require "listlace/commands/playback"
-require "listlace/commands/selectors"
-require "listlace/commands/volume"
-require "listlace/commands/queue"
+module Listlace
+  extend Listlace::Library::Selectors
 
-$player = Listlace::Player.new
+  class << self
+    attr_accessor :library, :player
+  end
 
-at_exit do
-  Listlace.stop
+  DIR = ENV["LISTLACE_DIR"] || (ENV["HOME"] + "/.listlace")
 end

data/listlace.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = "listlace"
-  s.version = "0.0.5"
-  s.date = "2012-08-26"
+  s.version = "0.0.6"
+  s.date = "2012-08-31"
   s.summary = "A music player in a REPL."
   s.description = "Listlace is a music player which is interacted with through a Ruby REPL."
   s.author = "Jeremy Ruten"
@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.requirements << "mplayer"
   s.executables << "listlace"
 
-  s.files = ["Gemfile", "Gemfile.lock", "LICENSE", "listlace.gemspec", "README"]
+  s.files = ["Gemfile", "Gemfile.lock", "LICENSE", "listlace.gemspec", "README.md", "README.old"]
   s.files += ["bin/listlace"]
   s.files += Dir["lib/**/*.rb"]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: listlace
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-26 00:00:00.000000000 Z
+date: 2012-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -134,20 +134,22 @@ files:
 - Gemfile.lock
 - LICENSE
 - listlace.gemspec
-- README
+- README.md
+- README.old
 - bin/listlace
-- lib/listlace/commands/library.rb
-- lib/listlace/commands/playback.rb
-- lib/listlace/commands/queue.rb
-- lib/listlace/commands/selectors.rb
-- lib/listlace/commands/volume.rb
-- lib/listlace/database.rb
+- lib/listlace/array_ext.rb
+- lib/listlace/commands/library_commands.rb
+- lib/listlace/commands/player_commands.rb
+- lib/listlace/commands.rb
+- lib/listlace/library/database.rb
+- lib/listlace/library/selectors.rb
+- lib/listlace/library.rb
 - lib/listlace/models/playlist.rb
 - lib/listlace/models/playlist_item.rb
 - lib/listlace/models/track.rb
-- lib/listlace/mplayer.rb
+- lib/listlace/models.rb
+- lib/listlace/player/mplayer.rb
 - lib/listlace/player.rb
-- lib/listlace/playlist_array.rb
 - lib/listlace.rb
 homepage: http://github.com/yjerem/listlace
 licenses:

data/lib/listlace/commands/library.rb

@@ -1,85 +0,0 @@
-require "plist"
-require "active_support/core_ext/string"
-
-module Listlace
-  # Imports the music library from another program. Currently only iTunes is
-  # supported.
-  def import(from, path)
-    if not File.exists?(path)
-      puts "File '%s' doesn't exist." % [path]
-    elsif from == :itunes
-      puts "Parsing XML..."
-      data = Plist::parse_xml(path)
-
-      puts "Importing #{data['Tracks'].length} tracks..."
-      num_tracks = 0
-      whitelist = Track.new.attributes.keys
-      data["Tracks"].each do |track_id, row|
-        # row already contains a hash of attributes almost ready to be passed to
-        # ActiveRecord. We just need to modify the keys, e.g. change "Play Count"
-        # to "play_count".
-        attributes = row.inject({}) do |acc, (key, value)|
-          attribute = key.gsub(" ", "").underscore
-          attribute = "original_id" if attribute == "track_id"
-          acc[attribute] = value if whitelist.include? attribute
-          acc
-        end
-
-        # change iTunes' URL-style locations into simple paths
-        if attributes["location"] && attributes["location"] =~ /^file:\/\//
-          attributes["location"].sub! /^file:\/\/localhost/, ""
-
-          # CGI::unescape changes plus signs to spaces. This is a work around to
-          # keep the plus signs.
-          attributes["location"].gsub! "+", "%2B"
-
-          attributes["location"] = CGI::unescape(attributes["location"])
-        end
-
-        track = Track.new(attributes)
-
-        if track.kind =~ /audio/
-          if track.save
-            num_tracks += 1
-          end
-        else
-          puts "[skipping non-audio file]"
-        end
-      end
-      puts "Imported #{num_tracks} tracks successfully."
-
-      puts "Importing #{data['Playlists'].length} playlists..."
-      num_playlists = 0
-      data["Playlists"].each do |playlist_data|
-        playlist = Playlist.new(name: playlist_data["Name"])
-
-        if ["Library", "Music", "Movies", "TV Shows", "iTunes DJ"].include? playlist.name
-          puts "[skipping \"#{playlist.name}\" playlist]"
-        else
-          if playlist.save
-            playlist_data["Playlist Items"].map(&:values).flatten.each.with_index do |track_id, i|
-              playlist_item = PlaylistItem.new(position: i)
-              playlist_item.playlist = playlist
-              if playlist_item.track = Track.where(original_id: track_id).first
-                playlist_item.save!
-              end
-            end
-            num_playlists += 1
-          end
-        end
-      end
-      puts "Imported #{num_playlists} playlists successfully."
-    end
-  end
-
-  # Wipes the database. With no arguments, it just asks "Are you sure?" without
-  # doing anything. To actually wipe the database, pass :yes_im_sure.
-  def wipe_library(are_you_sure = :nope)
-    if are_you_sure == :yes_im_sure
-      Database.wipe
-      puts "Library wiped."
-    else
-      puts "Are you sure? If you are, then type: wipe_library :yes_im_sure"
-    end
-  end
-end

data/lib/listlace/commands/playback.rb

@@ -1,137 +0,0 @@
-module Listlace
-  REPEAT_SYMBOL = "\u221E"
-  TIMES_SYMBOL = "\u00D7"
-
-  # The play command. With no arguments, it either resumes playback or starts
-  # playing the queue. With arguments, it replaces the queue with the given
-  # tracks and starts playing.
-  def p(*tracks)
-    if tracks.empty?
-      if $player.paused?
-        $player.resume
-        status
-      elsif $player.started?
-        if $player.speed == 1
-          $player.pause
-          status
-        else
-          $player.set_speed 1
-          status
-        end
-      else
-        if $player.empty?
-          puts "Nothing to play."
-        else
-          $player.start
-          status
-        end
-      end
-    else
-      $player.stop
-      $player.clear
-      q *tracks
-      p
-    end
-  end
-
-  # Stops playback. The queue is still intact, but goes back to the beginning
-  # when playback is started again.
-  def stop
-    $player.stop
-    puts "Stopped."
-  end
-
-  # Start the current track from the beginning.
-  def restart
-    $player.restart
-    status
-  end
-
-  # Go back one song in the queue.
-  def back(n = 1)
-    if $player.back(n)
-      status
-    else
-      puts "End of queue."
-    end
-  end
-
-  # Go directly to the next song in the queue.
-  def skip(n = 1)
-    if $player.skip(n)
-      status
-    else
-      puts "End of queue."
-    end
-  end
-
-  # Seek to a particular position in the current track. If given an integer, it
-  # will seek that many seconds forward or backward. If given a Range, it will
-  # seek to that specific time, the first number in the Range representing the
-  # minutes, the second number representing the seconds. You can also pass a
-  # String like "1:23:45" to do the same thing. To seek to an absolute time in
-  # seconds, do it like "seek(abs: 40)". To seek to a percentage, do something
-  # like "seek(percent: 75)".
-  def seek(where)
-    $player.seek(where)
-    status
-  end
-
-  # Fast-forward at a particular speed. Induces the chipmunk effect, which I
-  # find agreeable. Call p to go back to normal. You can also pass a value
-  # smaller than one to slow down.
-  def ff(speed = 2)
-    $player.set_speed(speed)
-    status
-  end
-
-  # Pass :all to start playing from the top of the queue when it gets to the
-  # end. Pass :one to repeat the current track.
-  def repeat(one_or_all = :all)
-    $player.repeat one_or_all
-    status
-  end
-
-  # Turn off the repeat mode set by the repeat command.
-  def norepeat
-    $player.repeat :off
-    status
-  end
-
-  # Show various information about the status of the player. The information it
-  # shows depends on what status types you pass:
-  #
-  #   :playlist - Shows the playlist that is currently playing
-  #   :playing - Shows the current track
-  #
-  def status(*types)
-    types = [:playlist, :playing] if types.empty?
-    types.each do |type|
-      case type
-      when :playlist
-        if $player.started?
-        track_number = $player.current_track_index + 1
-          num_tracks = q.length
-          repeat_one = $player.repeat_mode == :one ? REPEAT_SYMBOL : ""
-          repeat_all = $player.repeat_mode == :all ? REPEAT_SYMBOL : ""
-          puts "Playlist: %s (%d%s / %d%s)" % [q.name, track_number, repeat_one, num_tracks, repeat_all]
-        else
-          puts "Playlist: %s" % [q]
-        end
-      when :playing
-        if $player.started?
-          name = $player.current_track.name
-          artist = $player.current_track.artist
-          time = $player.formatted_current_time
-          total_time = $player.current_track.formatted_total_time
-          paused = $player.paused? ? "|| " : ""
-          speed = $player.speed != 1 ? "#{TIMES_SYMBOL}#{$player.speed} " : ""
-          puts "%s - %s (%s / %s) %s%s" % [name, artist, time, total_time, paused, speed]
-        else
-          puts "Stopped."
-        end
-      end
-    end
-    nil
-  end
-end