listlace 0.0.9 → 0.1.0

data/lib/listlace/commands/player_commands.rb

@@ -1,194 +0,0 @@
-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.speed = 1
-              status
-            end
-          else
-            if player.empty?
-              puts "Nothing to play."
-            else
-              player.start
-              status
-            end
-          end
-        else
-          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)
-        player.back(n)
-        if player.started?
-          status
-        else
-          puts "End of queue."
-        end
-      end
-
-      # Go directly to the next song in the queue.
-      def skip(n = 1)
-        player.skip(n)
-        if player.started?
-          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.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?
-              title = player.current_track.title
-              artist = player.current_track.artist
-              time = Listlace.format_time(player.current_time, include_milliseconds: false)
-              total_time = Listlace.format_time(player.total_time, include_milliseconds: false)
-              paused = player.paused? ? "|| " : ""
-              speed = player.speed
-              speed = speed != 1 ? "#{TIMES_SYMBOL}#{speed} " : ""
-              puts "%s - %s (%s / %s) %s%s" % [title, 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/core_ext/array.rb

@@ -1,58 +0,0 @@
-class Array
-  attr_accessor :name
-
-  # Check if this array is a playlist. It's a playlist if it has
-  # a name attribute set or consists entirely of Track instances.
-  def playlist?
-    if @name || all? { |x| x.is_a? Listlace::Track }
-      @name ||= ""
-      true
-    else
-      false
-    end
-  end
-
-  # Returns a new array that is shuffled, but with elem at the top.
-  # This is how playlists that are currently playing are shuffled.
-  # The currently playing track goes to the top, the rest of the
-  # tracks are shuffled.
-  def shuffle_except(elem)
-    ary = dup
-    dup.shuffle_except! elem
-    dup
-  end
-
-  # Like shuffle_except, but shuffles in-place.
-  def shuffle_except!(elem)
-    if i = index(elem)
-      delete_at(i)
-      shuffle!
-      unshift(elem)
-    else
-      shuffle!
-    end
-  end
-
-  # Override to_s to check if the array is a playlist, and format
-  # it accordingly.
-  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
-
-  # Override inspect for nice pry output.
-  alias _original_inspect inspect
-  def inspect
-    playlist? ? to_s : _original_inspect
-  end
-
-  # Override pretty_inspect for nice pry output.
-  alias _original_pretty_inspect pretty_inspect
-  def pretty_inspect
-    playlist? ? inspect : _original_pretty_inspect
-  end
-end

data/lib/listlace/library/database.rb

@@ -1,84 +0,0 @@
-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 :title
-            t.string :artist
-            t.string :composer
-            t.string :album
-            t.string :album_artist
-            t.string :genre
-            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, null: false
-            t.datetime :date_added, null: false
-            t.integer :bit_rate
-            t.integer :sample_rate
-            t.text :comments
-            t.integer :play_count, null: false, default: 0
-            t.datetime :play_date
-            t.integer :skip_count, null: false, default: 0
-            t.datetime :skip_date
-            t.integer :rating, null: false, default: 0
-            t.string :location, null: false
-          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

data/lib/listlace/library/selectors.rb

@@ -1,199 +0,0 @@
-module Listlace
-  class Library
-    module Selectors
-      STRING_SELECTORS = %w(title 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
-
-      # Selects all the tracks in the library.
-      def all
-        playlist library.tracks
-      end
-
-      # Selects no tracks, returning an empty playlist.
-      def none
-        playlist
-      end
-
-      # 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
-            Listlace.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: title, artist, composer, album, album_artist, genre, comments,
-      # location. For example:
-      #
-      #   artist :muse, match: :exact #=> playlist (108 tracks)
-      #   composer :rachmanino #=> playlist (33 tracks)
-      #
-      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 << [] if args.empty?
-        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

@@ -1,160 +0,0 @@
-module Listlace
-  class Library
-    class FileNotFoundError < ArgumentError; end
-
-    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
-
-    def save_playlist(playlist)
-      playlist_table = playlists.arel_table
-      if model = playlists.where(playlist_table[:name].matches(playlist.name)).first
-        model.playlist_items.destroy_all
-      else
-        model = 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
-
-    def add_track(path, options = {})
-      metadata = options.dup
-      if File.exists?(path)
-        TagLib::FileRef.open(path) do |file|
-          if tag = file.tag
-            metadata[:album] ||= tag.album
-            metadata[:artist] ||= tag.artist
-            metadata[:comments] ||= tag.comment
-            metadata[:genre] ||= tag.genre
-            metadata[:title] ||= tag.title
-            metadata[:track_number] ||= tag.track unless tag.track.zero?
-            metadata[:year] ||= tag.year unless tag.year.zero?
-          end
-
-          if prop = file.audio_properties
-            metadata[:bit_rate] = prop.bitrate
-            metadata[:sample_rate] = prop.sample_rate
-            metadata[:total_time] = prop.length * 1000
-          end
-
-          if metadata[:title].nil? or metadata[:title].empty?
-            metadata[:title] = File.basename(path, ".*")
-          end
-
-          metadata[:location] = File.expand_path(path)
-
-          track = Track.new(metadata)
-          track.save && track
-        end
-      else
-        raise FileNotFoundError, "File '%s' doesn't exist." % [path]
-      end
-    end
-
-    def import(from, path, options = {})
-      logger = options[:logger]
-      if not File.exists?(path)
-        raise FileNotFoundError, "File '%s' doesn't exist." % [path]
-      elsif from == :itunes
-        logger.("Parsing XML...") if logger
-        data = Plist::parse_xml(path)
-
-        logger.("Importing #{data['Tracks'].length} tracks...") if logger
-        num_tracks = 0
-        whitelist = tracks.new.attributes.keys
-        data["Tracks"].each do |track_id, row|
-          if row["Kind"] !~ /audio/
-            logger.("[skipping non-audio file]") if logger
-            next
-          end
-
-          # 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".
-          row["Title"] = row.delete("Name")
-          row["Play Date"] = row.delete("Play Date UTC")
-          row["Original ID"] = row.delete("Track ID")
-          attributes = row.inject({}) do |acc, (key, value)|
-            attribute = key.gsub(" ", "").underscore
-            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 = tracks.new(attributes)
-          if track.save
-            num_tracks += 1
-          end
-        end
-        logger.("Imported #{num_tracks} tracks successfully.") if logger
-
-        logger.("Importing #{data['Playlists'].length} playlists...") if logger
-        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
-            logger.("[skipping \"#{playlist.name}\" playlist]") if logger
-          else
-            playlist_data["Playlist Items"].map(&:values).flatten.each do |original_id|
-              playlist << tracks.where(original_id: original_id).first
-            end
-            playlist.compact!
-            save_playlist playlist
-            num_playlists += 1
-          end
-        end
-        logger.("Imported #{num_playlists} playlists successfully.") if logger
-      end
-    end
-  end
-end

data/lib/listlace/models/playlist.rb

@@ -1,6 +0,0 @@
-module Listlace
-  class Playlist < ActiveRecord::Base
-    has_many :playlist_items
-    has_many :tracks, through: :playlist_items, order: "playlist_items.position ASC"
-  end
-end