soundcloud9000 0.1.0

data/lib/soundcloud9000/download_thread.rb

@@ -0,0 +1,51 @@
+require 'net/https'
+require_relative 'events'
+
+module Soundcloud9000
+  class DownloadThread
+    attr_reader :events, :url, :progress, :total, :file
+
+    def initialize(url, filename)
+      @events = Events.new
+      @url = URI.parse(url)
+      @file = File.open(filename, "w")
+      @progress = 0
+      start!
+    end
+
+    def log(s)
+      Soundcloud9000::Application.logger.debug("DownloadThread #{s}")
+    end
+
+    def start!
+      Thread.start do
+        begin
+          log :start
+
+          http = Net::HTTP.new(url.host, url.port)
+          http.use_ssl = true
+
+          http.request(Net::HTTP::Get.new(url.request_uri)) do |res|
+            log "response: #{res.code}"
+            raise res.body if res.code != '200'
+
+            @total = res.header['Content-Length'].to_i
+
+            res.read_body do |chunk|
+              @progress += chunk.size
+              @file << chunk
+              @file.close if @progress == @total
+            end
+          end
+        rescue => e
+          log e.message
+        end
+      end
+
+      sleep 0.1 while @total.nil?
+      sleep 0.1
+
+      self
+    end
+  end
+end

data/lib/soundcloud9000/events.rb

@@ -0,0 +1,17 @@
+module Soundcloud9000
+  class Events
+    def initialize
+      @handlers = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def on(event, &block)
+      @handlers[event] << block
+    end
+
+    def trigger(event, *args)
+      @handlers[event].each do |handler|
+        handler.call(*args)
+      end
+    end
+  end
+end

data/lib/soundcloud9000/models/collection.rb

@@ -0,0 +1,42 @@
+require_relative '../events'
+
+module Soundcloud9000
+  module Models
+    # stores the tracks displayed in the track controller
+    class Collection
+      include Enumerable
+      attr_reader :events, :rows, :page
+
+      def initialize(client)
+        @client = client
+        @events = Events.new
+        clear
+      end
+
+      def [](*args)
+        @rows[*args]
+      end
+
+      def clear
+        @page = 0
+        @rows = []
+        @loaded = false
+      end
+
+      def each(&block)
+        @rows.each(&block)
+      end
+
+      def replace(rows)
+        clear
+        @rows = rows
+        events.trigger(:replace)
+      end
+
+      def append(rows)
+        @rows += rows
+        events.trigger(:append)
+      end
+    end
+  end
+end

data/lib/soundcloud9000/models/player.rb

@@ -0,0 +1,138 @@
+require 'audite'
+require_relative '../download_thread'
+
+module Soundcloud9000
+  module Models
+    # responsible for drawing and updating the player above tracklist
+    class Player
+      attr_reader :track, :events
+
+      def initialize
+        @track = nil
+        @events = Events.new
+        @folder = File.expand_path('~/.soundcloud9000')
+        @seek_speed = {}
+        @seek_time = {}
+        create_player
+
+        Dir.mkdir(@folder) unless File.exist?(@folder)
+      end
+
+      def create_player
+        @player = Audite.new
+        @player.events.on(:position_change) do
+          events.trigger(:progress)
+        end
+
+        @player.events.on(:complete) do
+          events.trigger(:complete)
+        end
+      end
+
+      def play(track, location)
+        log :play, track.id
+        @track = track
+        load(track, location)
+        start
+      end
+
+      def play_progress
+        seconds_played / duration
+      end
+
+      def duration
+        @track.duration.to_f / 1000
+      end
+
+      def title
+        [@track.title, @track.user.username].join(' - ')
+      end
+
+      def length_in_seconds
+        mpg = Mpg123.new(@file)
+        mpg.length * mpg.tpf / mpg.spf
+      end
+
+      def load(track, location)
+        @file = "#{@folder}/#{track.id}.mp3"
+
+        if !File.exist?(@file) || track.duration / 1000 > length_in_seconds * 0.95
+          File.unlink(@file) rescue nil
+          @download = DownloadThread.new(location, @file)
+        else
+          @download = nil
+        end
+
+        @player.load(@file)
+      end
+
+      def log(*args)
+        Soundcloud9000::Application.logger.debug 'Player: ' + args.join(' ')
+      end
+
+      def level
+        @player.level
+      end
+
+      def seconds_played
+        @player.position
+      end
+
+      def download_progress
+        @download ? @download.progress / @download.total.to_f : 1
+      end
+
+      def playing?
+        @player.active
+      end
+
+      def seek_speed(direction)
+        if @seek_time[direction] && Time.now - @seek_time[direction] < 0.5
+          @seek_speed[direction] *= 1.05
+        else
+          @seek_speed[direction] = 1
+        end
+
+        @seek_time[direction] =  Time.now
+        @seek_speed[direction]
+      end
+
+      # change song position
+      def seek_position(position)
+        position *= 0.1
+        relative_position = position * duration
+        if relative_position < seconds_played
+          difference = seconds_played - relative_position
+          @player.rewind(difference)
+        elsif download_progress > (relative_position / duration) && relative_position > seconds_played
+          log download_progress
+          difference = relative_position - seconds_played
+          @player.forward(difference)
+        end
+      end
+
+      def rewind
+        @player.rewind(seek_speed(:rewind))
+      end
+
+      def forward
+        seconds = seek_speed(:forward)
+
+        seek_percentage = (seconds + seconds_played) / duration
+        @player.forward(seconds) if seek_percentage < download_progress
+      end
+
+      def stop
+        @player.stop_stream
+      end
+
+      def start
+        @player.start_stream
+      end
+
+      def toggle
+        @player.toggle
+      end
+    end
+  end
+end

data/lib/soundcloud9000/models/playlist.rb

@@ -0,0 +1,22 @@
+module Soundcloud9000
+  module Models
+    # stores information on a playlist or set from soundcloud
+    class Playlist
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def id
+        @hash['id']
+      end
+
+      def title
+        @hash['title']
+      end
+
+      def uri
+        @hash['uri']
+      end
+    end
+  end
+end

data/lib/soundcloud9000/models/track.rb

@@ -0,0 +1,56 @@
+require_relative 'user'
+
+module Soundcloud9000
+  module Models
+    # stores information for each track that hits the player
+    class Track
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def id
+        @hash['id']
+      end
+
+      def title
+        @hash['title']
+      end
+
+      def url
+        @hash['permalink_url']
+      end
+
+      def user
+        @user ||= User.new(@hash['user'])
+      end
+
+      def username
+        user.username
+      end
+
+      def duration
+        @hash['duration']
+      end
+
+      def length
+        TimeHelper.duration(duration)
+      end
+
+      def plays
+        @hash['playback_count']
+      end
+
+      def likes
+        @hash['favoritings_count']
+      end
+
+      def comments
+        @hash['comments']
+      end
+
+      def stream_url
+        @hash['stream_url']
+      end
+    end
+  end
+end

data/lib/soundcloud9000/models/track_collection.rb

@@ -0,0 +1,71 @@
+require_relative 'collection'
+require_relative 'track'
+require_relative 'playlist'
+
+module Soundcloud9000
+  module Models
+    # This model deals with the different types of tracklists that populate
+    # the tracklist section
+    class TrackCollection < Collection
+      DEFAULT_LIMIT = 50
+
+      attr_reader :limit
+      attr_accessor :collection_to_load, :user, :playlist
+
+      def initialize(client)
+        super
+        @limit = DEFAULT_LIMIT
+        @collection_to_load = :recent
+      end
+
+      def size
+        @rows.size
+      end
+
+      def clear_and_replace
+        clear
+        load_more
+        events.trigger(:replace)
+      end
+
+      def load
+        clear
+        load_more
+      end
+
+      def load_more
+        unless @loaded
+          tracks = send(@collection_to_load.to_s + '_tracks')
+          @loaded = true if tracks.empty?
+          append tracks.map { |hash| Track.new hash }
+          @page += 1
+        end
+      end
+
+      def favorites_tracks
+        return [] if @client.current_user.nil?
+        @client.get(@client.current_user.uri + '/favorites', offset: @limit * @page, limit: @limit)
+      end
+
+      def recent_tracks
+        @client.get('/tracks', offset: @page * limit, limit: @limit)
+      end
+
+      def user_tracks
+        return [] if @client.current_user.nil?
+        user_tracks = @client.get(@client.current_user.uri + '/tracks', offset: @limit * @page, limit: @limit)
+        if user_tracks.empty?
+          UI::Input.error("'#{@client.current_user.username}' has not authored any tracks. Use f to switch to their favorites, or s to switch to their playlists.")
+          return []
+        else
+          return user_tracks
+        end
+      end
+
+      def playlist_tracks
+        return [] if @playlist.nil?
+        @client.get(@playlist.uri + '/tracks', offset: @limit * @page, limit: @limit)
+      end
+    end
+  end
+end

data/lib/soundcloud9000/models/user.rb

@@ -0,0 +1,26 @@
+module Soundcloud9000
+  module Models
+    # stores information on the current user we are looking at
+    class User
+      def initialize(hash)
+        @hash = hash
+      end
+
+      def id
+        @hash['id']
+      end
+
+      def username
+        @hash['username']
+      end
+
+      def uri
+        @hash['uri']
+      end
+
+      def permalink
+        @hash['permalink']
+      end
+    end
+  end
+end

data/lib/soundcloud9000/time_helper.rb

@@ -0,0 +1,23 @@
+require 'time'
+
+module Soundcloud9000
+  # handles proper time display
+  # TODO: make this better looking or find an alternative
+  module TimeHelper
+    HOUR    = 1000 * 60 * 60
+    MINUTE  = 1000 * 60
+    SECONDS = 1000
+
+    def self.duration(milliseconds)
+      parts = [
+        milliseconds / 1000 / 60 / 60,      # hours
+        milliseconds / 1000 / 60 % 60,      # minutes
+        milliseconds / 1000 % 60,           # seconds
+      ]
+
+      parts.shift if parts.first.zero?
+
+      [parts.first, *parts[1..-1].map { |part| format('%02d', part) }].join('.')
+    end
+  end
+end