listlace 0.0.5 → 0.0.6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    listlace (0.0.4)
+    listlace (0.0.5)
       activerecord
       activesupport
       open4

data/README.md

@@ -0,0 +1,53 @@
+# Listlace
+
+Listlace is a music player that does Ruby. Here's how it works:
+
+First add your music library.
+
+    >> add "/path/to/Music"
+    1067 songs added.
+
+...Or import your iTunes library.
+
+    >> import :itunes, "/path/to/iTunes/iTunes Music Library.xml"
+
+Once your library is in place, start grouping your songs into playlists.
+
+    >> save artist("muse"), :muse
+    => muse (108 tracks)
+
+Finally, go ahead and play your playlists.
+
+    >> p :muse
+    Playlist: muse (108 tracks)
+    Blackout - Muse (0:00 / 4:22)
+
+## Install
+
+It's a gem, so do this:
+
+    $ gem install listlace
+
+You also need mplayer in your $PATH, if you want to atually play your music.
+
+## Usage
+
+The gem gives you an executable, so do this:
+
+    $ listlace
+    Hello, you have 0 songs.
+    >>
+
+Now you're ready to play.
+
+## Library
+
+...
+
+## Playlists
+
+...
+
+## The Player
+
+...

data/bin/listlace

@@ -4,17 +4,22 @@ require "bundler/setup"
 require "pry"
 require "listlace"
 
-unless File.exists? Listlace::DIR
-  FileUtils.mkdir_p Listlace::DIR
-end
+ActiveRecord::Migration.verbose = false
+
+Listlace.extend Listlace::Commands::LibraryCommands
+Listlace.extend Listlace::Commands::PlayerCommands
 
-Listlace::Database.connect
-Listlace::Database.generate_schema unless Listlace::Database.exists?
+Listlace.library = Listlace::Library.new
+Listlace.player = Listlace::Player.new
 
-puts "Hello, you have #{Listlace::Track.count} songs."
+puts "Hello, you have #{Listlace.library.size} songs."
+
+at_exit do
+  Listlace.player.stop
+end
 
 Listlace.pry(
   quiet: true,
-  prompt: Listlace::PROMPT,
-  print: Listlace::PRINT
+  prompt: [proc { ">> " }, proc { " | " }],
+  print: proc { |output, value| Pry::DEFAULT_PRINT.call(output, value) unless value.nil? }
 )

data/lib/listlace/array_ext.rb

@@ -0,0 +1,41 @@
+class Array
+  attr_accessor :name
+
+  def playlist?
+    if @name || all? { |x| x.is_a? Listlace::Track }
+      @name ||= ""
+      true
+    else
+      false
+    end
+  end
+
+  def shuffle_except(elem)
+    ary = dup
+    dup.shuffle_except! elem
+    dup
+  end
+
+  def shuffle_except!(elem)
+    replace([elem] + (self - [elem]).shuffle)
+  end
+
+  alias _original_to_s to_s
+  def to_s
+    if playlist?
+      "%s (%d track%s)" % [@name || "playlist", length, ("s" if length != 1)]
+    else
+      _original_to_s
+    end
+  end
+
+  alias _original_inspect inspect
+  def inspect
+    playlist? ? to_s : _original_inspect
+  end
+
+  alias _original_pretty_inspect pretty_inspect
+  def pretty_inspect
+    playlist? ? inspect : _original_pretty_inspect
+  end
+end

data/lib/listlace/commands/library_commands.rb

@@ -0,0 +1,101 @@
+module Listlace
+  module Commands
+    module LibraryCommands
+      def save(playlist, name = nil)
+        playlist.name = name if name
+        if model = library.playlists.where(name: playlist.name).first
+          model.playlist_items.destroy_all
+        else
+          model = library.playlists.new(name: playlist.name)
+          model.save!
+        end
+
+        playlist.each.with_index do |track, i|
+          item = PlaylistItem.new(position: i)
+          item.playlist = model
+          item.track = track
+          item.save!
+        end
+        playlist
+      end
+
+      # 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 = library.tracks.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 = library.tracks.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.name = playlist_data["Name"]
+
+            if ["Library", "Music", "Movies", "TV Shows", "iTunes DJ"].include? playlist.name
+              puts "[skipping \"#{playlist.name}\" playlist]"
+            else
+              playlist_data["Playlist Items"].map(&:values).flatten.each do |original_id|
+                playlist << library.tracks.where(original_id: original_id).first
+              end
+              playlist.compact!
+              save playlist
+              num_playlists += 1
+            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
+          library.wipe
+          puts "Library wiped."
+        else
+          puts "Are you sure? If you are, then type: wipe_library :yes_im_sure"
+        end
+      end
+    end
+  end
+end

data/lib/listlace/commands/player_commands.rb

@@ -0,0 +1,192 @@
+module Listlace
+  module Commands
+    module PlayerCommands
+      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
+
+      # 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
+  end
+end

data/lib/listlace/commands.rb

@@ -0,0 +1,7 @@
+require "listlace/commands/library_commands"
+require "listlace/commands/player_commands"
+
+module Listlace
+  module Commands
+  end
+end

data/lib/listlace/library/database.rb

@@ -0,0 +1,89 @@
+module Listlace
+  class Library
+    module Database
+      extend self
+
+      def connect(adapter, path)
+        ActiveRecord::Base.establish_connection(adapter: adapter, database: path)
+      end
+
+      def disconnect
+        ActiveRecord::Base.remove_connection
+      end
+
+      def exists?(path)
+        File.exists? path
+      end
+
+      def delete(path)
+        FileUtils.rm path
+      end
+
+      def connected?
+        ActiveRecord::Base.connected?
+      end
+
+      def connected_to?(path)
+        if ActiveRecord::Base.connected?
+          File.expand_path(path) == File.expand_path(ActiveRecord::Base.connection_config[:database])
+        else
+          false
+        end
+      end
+
+      def wipe(adapter, path)
+        delete(path)
+        connect(adapter, path)
+        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
+end