ektoplayer 0.1.0

data/lib/ektoplayer/operations/browser.rb

@@ -0,0 +1,19 @@
+module Ektoplayer
+   module Operations
+      class Browser
+         # Operations for +Model::Browser+:
+         # +enter+::             see
+         # +back+::              see
+         # +add_to_playlist+::   see
+         def initialize(operations, browser, playlist)
+            register = operations.with_register('browser.')
+            register.(:enter,  &browser.method(:enter))
+            register.(:back,   &browser.method(:back))
+            register.(:add_to_playlist) do |index|
+               tracks = browser.tracks(index)
+               playlist.add(*tracks)
+            end
+         end
+      end
+   end
+end

data/lib/ektoplayer/operations/operations.rb

@@ -0,0 +1,26 @@
+module Ektoplayer
+   module Operations
+      # Operations
+      # Since every operation is implemented excactly once
+      # we don't use an Event object.
+      #
+      # Since doing a "class.send()" is faster than "hash[command].call()"
+      # we implement the operations using an object instead of a hash.
+      #
+      class Operations
+         # Register a new command
+         def register(name, &block)
+            self.define_singleton_method(name, &block)
+         end
+         alias :reg :register
+
+         # Helper for registering multiple commands
+         def with_register(prefix='', &block)
+            reg_func = proc { |name, &blk| register("#{prefix}#{name}", &blk) }
+            block.(reg_func) if block
+            reg_func 
+         end
+      end
+   end
+end
+

data/lib/ektoplayer/operations/player.rb

@@ -0,0 +1,11 @@
+module Ektoplayer
+   module Operations
+      class Player
+         def initialize(operations, player)
+            register = operations.with_register('player.')
+            %w(play stop pause toggle forward backward).
+               each { |op| register.(op, &player.method(op)) }
+         end
+      end
+   end
+end

data/lib/ektoplayer/operations/playlist.rb

@@ -0,0 +1,67 @@
+module Ektoplayer
+   module Operations
+      class Playlist
+         def initialize(operations, playlist, player, trackloader)
+            @playlist, @player, @trackloader = playlist, player, trackloader
+            register = operations.with_register('playlist.')
+
+            register.(:clear,   &@playlist.method(:clear))
+            register.(:delete,  &@playlist.method(:delete))
+
+            %w(play reload play_next play_prev download_album).each do |operation|
+               register.(operation, &self.method(operation))
+            end
+         end
+
+         def download_album(index)
+            return unless track = @playlist[index]
+            Thread.new do
+               @trackloader.download_album(track['url'])
+            end
+         end
+
+         def reload(index)
+            return unless track = @playlist[index]
+            Thread.new do
+               @trackloader.get_track_file(track['url'], reload: true)
+            end
+         end
+
+         def play(index)
+            return unless track = @playlist[index]
+            Thread.new do
+               @playlist.current_playing=(index)
+               @player.play(@trackloader.get_track_file(track['url']))
+            end
+         end
+
+         def play_next
+            return if @playlist.empty? or !@playlist.current_playing 
+            index = (@playlist.current_playing + 1) % @playlist.size
+            play(index)
+         end
+
+         def play_prev
+            return if @playlist.empty? or !@playlist.current_playing 
+
+            if @playlist.current_playing == 0
+               play(@playlist.size - 1)
+            else
+               play(@playlist.current_playing - 1)
+            end
+         end
+
+         private def get_next_pos
+            return unless index = @playlist.current_playing
+
+            if @playlist.repeat_mode == :track
+               return index
+            elsif index + 1 >= @playlist.size
+               return 0 if @playlist.repeat_mode == :playlist
+            else
+               return index  + 1
+            end
+         end
+      end
+   end
+end

data/lib/ektoplayer/theme.rb

@@ -0,0 +1,102 @@
+require_relative 'ui/colors'
+
+module Ektoplayer
+   class Theme
+      attr_reader :current
+
+      def initialize
+         @current = 0
+         @theme = {
+            0   => { default: [-1, -1].freeze,
+               'url':                     [-1, -1, :underline      ].freeze},
+            8   => { default: [-1, -1].freeze,
+               'url':                     [:magenta, -1, :underline].freeze,
+
+               'info.head':               [:blue, -1, :bold        ].freeze,
+               'info.tag':                [:blue                   ].freeze,
+               'info.value':              [:magenta                ].freeze,
+               'info.description':        [:blue                   ].freeze,
+               'info.download.file':      [:blue                   ].freeze,
+               'info.download.percent':   [:magenta, -1            ].freeze,
+               'info.download.error':     [:red                    ].freeze,
+
+               'progressbar.progress':    [:blue                   ].freeze,
+               'progressbar.rest':        [:black                  ].freeze,
+
+               'volumemeter.level':       [:magenta                ].freeze,
+               'volumemeter.rest':        [:black                  ].freeze,
+
+               'tabs':                    [:none                   ].freeze,
+               'tab_selected':            [:blue                   ].freeze,
+
+               'list.item_even':          [:blue                   ].freeze,
+               'list.item_odd':           [:blue                   ].freeze,
+
+               'playinginfo.position':    [:magenta                ].freeze,
+               'playinginfo.state':       [:cyan                   ].freeze,
+
+               'help.widget_name':        [:blue, -1, :bold        ].freeze,
+               'help.key_name':           [:blue                   ].freeze,
+               'help.command_name':       [:magenta                ].freeze,
+               'help.command_desc':       [:yellow                 ].freeze},
+            256 => { default: [-1, -1].freeze,
+               'url':                     [97,  -1, :underline     ].freeze,
+
+               'info.head':               [32, -1, :bold           ].freeze,
+               'info.tag':                [74                      ].freeze,
+               'info.value':              [67                      ].freeze,
+               'info.description':        [67                      ].freeze,
+               'info.download.file':      [75                      ].freeze,
+               'info.download.percent':   [68                      ].freeze,
+               'info.download.error':     [:red                    ].freeze,
+
+               'progressbar.progress':    [23                      ].freeze,
+               'progressbar.rest':        [236                     ].freeze,
+
+               'volumemeter.level':       [:magenta                ].freeze,
+               'volumemeter.rest':        [236                     ].freeze,
+
+               'tabs':                    [250                     ].freeze,
+               'tab_selected':            [75                      ].freeze,
+
+               'list.item_even':          [:blue                   ].freeze,
+               'list.item_odd':           [25                      ].freeze,
+
+               'help.widget_name':        [33                      ].freeze,
+               'help.key_name':           [75                      ].freeze,
+               'help.command_name':       [68                      ].freeze,
+               'help.command_desc':       [29                      ].freeze}
+         }.freeze
+      end
+
+      def color(name, *defs, theme: 8)
+         @theme[theme][name.to_sym] = defs.freeze
+      end
+
+      def color_mono(*args)  color(*args, theme: 0)     end
+      def color_256(*args)   color(*args, theme: 256)   end
+
+      def get(theme_def)     UI::Colors.get(theme_def)  end
+      alias :[] :get
+
+      def use_colors(colors)
+         fail ArgumentError unless @theme[colors]
+         @current = colors
+
+         UI::Colors.reset
+         @theme.values.map(&:keys).flatten.each do |name|
+            defs ||= @theme[256][name] if @current == 256
+            defs ||= @theme[8][name]   if @current >= 8
+            defs ||= @theme[0][name]
+
+            unless defs
+               defs ||= @theme[256][:default] if @current == 256
+               defs ||= @theme[8][:default]   if @current >= 8
+               defs ||= @theme[0][:default]
+            end
+
+            UI::Colors.set(name, *defs)
+         end
+      end
+   end
+end

data/lib/ektoplayer/trackloader.rb

@@ -0,0 +1,146 @@
+require 'fileutils'
+require 'net/https'
+require 'uri'
+
+require_relative 'events'
+require_relative 'common'
+
+module Ektoplayer
+   class Trackloader
+      attr_reader :downloads
+
+      def initialize(database)
+         @downloads = []
+         @database = database
+      end
+
+      def get_track_infos(url)
+         r = @database.select(filters: [{tag: :url, operator: :==, value: url}])[0]
+
+         r.update(
+            @database.get_archives(url).select {|_|_['archive_type'] == 'MP3'}[0]
+         )
+
+         r['archive_filename'] = URI.unescape(File.basename(URI.parse(r['archive_url']).path))
+         r['archive_basename'] = File.basename(r['archive_filename'], '.zip')
+         r['album_path'] = File.join(Config[:archive_dir], r['archive_basename'])
+         r
+      end
+
+      def download_album(url)
+         track_info = get_track_infos(url)
+         return if File.exists? track_info['album_path']
+
+         archive_file = File.join(Config[:download_dir], track_info['archive_filename'])
+         return if File.exists? archive_file
+
+         dl = DownloadThread.new(track_info['archive_url'], archive_file)
+
+         if Config[:auto_extract_to_archive_dir]
+            dl.events.on(:completed) do 
+               begin
+                  extract_dir = track_info['album_path']
+                  FileUtils::mkdir_p(extract_dir)
+                  Common::extract_zip(archive_file, extract_dir)
+                  FileUtils::rm(archive_file) if Config[:delete_after_extraction]
+               rescue
+                  Application.log(self, "extraction of '#{archive_file}' to '#{extract_dir}' failed:", $!)
+               end
+            end
+         end
+
+         dl.events.on(:failed) do |reason|
+            Application.log(self, dl.file, dl.url, reason)
+            FileUtils::rm(dl.file) rescue nil
+         end
+
+         @download << dl.start!
+      end
+
+      def get_track_file(url, reload: false)
+         begin
+            track_info = get_track_infos(url)
+            album_files = Dir.glob(File.join(track_info['album_path'], '*.mp3'))
+            track_file = album_files.sort[track_info['number']]
+            return track_file if track_file
+         rescue
+            Application.log(self, 'could not load track from archive_dir:', $!)
+         end
+
+         url_obj    = URI.parse(url)
+         basename   = File.basename(url_obj.path)
+         cache_file = File.join(Config[:cache_dir], basename)
+         temp_file  = File.join(Config[:temp_dir], basename)
+
+         (File.delete(cache_file) rescue nil) if reload
+         (File.delete(temp_file)  rescue nil) if reload
+
+         return cache_file if File.file?(cache_file)
+         return temp_file  if File.file?(temp_file)
+
+         dl = DownloadThread.new(url, temp_file)
+
+         if Config[:use_cache]
+            dl.events.on(:completed) do 
+               begin FileUtils::mv(temp_file, cache_file)
+               rescue
+                  Application.log(self, 'mv failed', temp_file, cache_file, $!)
+               end
+            end
+         end
+
+         dl.events.on(:failed) do |reason|
+            Application.log(self, dl.file, dl.url, reason)
+            FileUtils::rm(dl.file) rescue nil
+         end
+
+         @downloads << dl.start!
+
+         return temp_file
+      end
+   end
+
+   class DownloadThread
+      attr_reader :events, :url, :progress, :total, :file, :filename, :error
+
+      def initialize(url, filename)
+         @events   = Events.new(:completed, :failed, :progress)
+         @url      = URI.parse(url)
+         @filename = filename
+         @file     = File.open(filename, ?w)
+         @progress = 0
+         @error    = nil
+      end
+
+      def start!
+         Thread.new do
+            begin
+               http = Net::HTTP.new(@url.host, @url.port)
+
+               http.request(Net::HTTP::Get.new(@url.request_uri)) do |res|
+                  fail res.body unless res.code == '200'
+
+                  @total = res.header['Content-Length'].to_i
+
+                  res.read_body do |chunk|
+                     @progress += chunk.size
+                     @events.trigger(:progress, @progress)
+                     @file << chunk
+                  end
+               end
+
+               fail 'filesize mismatch' if @progress != @total
+               @events.trigger(:completed)
+            rescue
+               @events.trigger(:failed, (@error = $!))
+            ensure
+               @file.close
+            end
+         end
+
+         sleep 0.1 while @total.nil?
+         sleep 0.1
+         self
+      end
+   end
+end

data/lib/ektoplayer/ui.rb

@@ -0,0 +1,404 @@
+require 'curses'
+require 'readline'
+require 'io/console'
+
+require_relative 'ui/colors'
+require_relative 'events'
+
+module UI
+   class WidgetSizeError < Exception; end
+
+   class Canvas
+      extend Curses
+
+      def self.size
+         UI::Size.new(height: Curses.lines, width: Curses.cols)
+      end
+
+      def self.cursor
+         UI::Point.new(y: Curses.cury, x: Curses.curx)
+      end
+
+      def self.pos
+         UI::Point.new
+      end
+
+      def self.start
+         @@widget = nil
+
+         %w(init_screen crmode noecho start_color use_default_colors).
+            each {|_|Curses.send(_)}
+         Curses.mousemask(Curses::ALL_MOUSE_EVENTS)
+         Curses.stdscr.keypad(true)
+         [UI::Colors, UI::Input].each(&:start)
+
+         self.enable_resize_detection
+      end
+
+      def self.enable_resize_detection
+         @@winch_mutex ||= Mutex.new
+         @@winch_cond  ||= ConditionVariable.new
+
+         Signal.trap('WINCH') { @@winch_cond.signal }
+
+         @@winch_thread ||= Thread.new do
+            loop do
+               @@winch_mutex.synchronize do
+                  @@winch_cond.wait(@@winch_mutex)
+                  self.on_winch
+               end
+            end
+         end
+      end
+
+      def self.widget;      @@widget                   end
+      def self.widget=(w)   @@widget = w               end
+      def self.stop;        Curses.close_screen        end
+      def self.visible?;    true                       end
+      def self.inivsibile?; false                      end
+
+      def self.on_winch
+         h, w = IO.console.winsize()
+         Curses.resizeterm(h, w)
+         Curses.refresh
+         @@widget.size=(Size.new(height: h, width: w)) if @@widget
+      rescue UI::WidgetSizeError
+         Curses.clear
+         Curses.addstr('terminal too small!')
+         Curses.refresh
+      end
+
+      def self.sub(cls, **opts)
+         @@widget ||= (widget = cls.new(parent: self, **opts))
+         widget
+      end
+
+      def self.getch(timeout=-1)
+         Curses.stdscr.timeout=(timeout)
+         UI::Input::KEYMAP_WORKAROUND[Curses.stdscr.getch]
+      end
+      
+      def self.update_screen(force_redraw=false)
+         @@updating ||= Mutex.new
+
+         if @@updating.try_lock
+            if force_redraw
+               Curses.clear
+               Curses.refresh
+            end
+
+            begin
+               @@widget.display(true, force_redraw) if @@widget and (@@mode ||= :curses) == :curses
+            rescue UI::WidgetSizeError
+               Curses.clear
+               Curses.addstr('terminal too small!')
+            end
+
+            Curses.doupdate
+            @@updating.unlock
+         end
+      end
+
+      def self.run
+         self.start
+         return yield
+      ensure
+         self.stop
+      end
+   end
+
+   class Input
+      KEYMAP_WORKAROUND = {
+         13  => Curses::KEY_ENTER,
+         127 => Curses::KEY_BACKSPACE
+      }
+      KEYMAP_WORKAROUND.default_proc = proc { |h,k| k }
+      KEYMAP_WORKAROUND.freeze
+
+      def self.start
+         @@mode = :curses
+         Readline.input, @@readline_in_write = IO.pipe
+         Readline.output = File.open(File::NULL, ?w)
+      end
+
+      #def self.getch(timeout=-1)
+      #   KEYMAP_WORKAROUND[@@widget.getch(timeout)]
+      #end
+
+      def self.start_loop
+         @@readline_mutex ||= Mutex.new
+         @@readline_cond  ||= ConditionVariable.new
+
+         loop do
+            if @@mode == :curses
+               Curses.curs_set(0)
+               Curses.nonl
+
+               while @@mode == :curses
+                  UI::Canvas.widget.win.keypad=(true)
+                  c = KEYMAP_WORKAROUND[UI::Canvas.widget.win.getch1]
+
+                  if c == Curses::KEY_MOUSE
+                     if c = Curses.getmouse
+                        UI::Canvas.widget.mouse_click(c)
+                     end
+                  elsif c # (not nil)
+                     UI::Canvas.widget.key_press(c.is_a?(Integer) ? c : c.to_sym)
+                  end
+               end
+            else
+               Curses.curs_set(1)
+               Curses.nl
+
+               while @@mode == :readline
+                  win = UI::Canvas.widget.win
+                  win.keypad=(false)
+                  c = win.getch1
+
+                  if c == 10 or c == 4
+                     @@readline_thread.kill rescue nil
+                     @@mode = :curses
+                  else
+                     @@readline_in_write.write(c.chr)
+
+                     if c == 27 # pass 3-character escape sequence
+                        if c = win.getch1(1)
+                           @@readline_in_write.write(c.chr)
+                           if c = win.getch1(1)
+                              @@readline_in_write.write(c.chr)
+                           end
+                        end
+                     end
+                  end
+
+                  @@readline_cond.signal
+               end
+            end
+         end
+      end
+
+      def self.readline(pos, size, prompt: '', add_hist: false)
+         @@mode = :readline
+
+         Readline.set_screen_size(size.height, size.width)
+         @@readline_thread ||= Thread.new do
+            begin
+               window = Curses::Window.new(size.height, size.width, pos.y, pos.x)
+               rl_thread = Thread.new { Readline.delete_text; Readline.readline }
+
+               while rl_thread.alive?
+                  buffer = "#{prompt}#{Readline.line_buffer}"
+                  window.erase
+                  window << buffer[(buffer.size - size.width).clamp(0, buffer.size)..-1]
+                  window.cursor=(Point.new(x: Readline.point + prompt.size, y: 0))
+                  window.refresh
+                  @@readline_mutex.synchronize { @@readline_cond.wait(@@readline_mutex, 0.3) }
+               end
+            ensure
+               rl_thread.kill
+               window.clear
+               yield Readline.line_buffer
+               @@mode = :curses
+               @@readline_thread = nil
+               Canvas.update_screen(true)
+            end
+         end
+      end
+   end
+
+   class Output
+      def self.error
+         fail NotImplementedError
+      end
+   end
+
+   class Point
+      attr_accessor :x, :y
+
+      def initialize(x: 0, y: 0)
+         @x, @y = x, y
+      end
+
+      def update(x: nil, y: nil)
+         Point.new(x: (x or @x), y: (y or @y))
+      end
+
+      def calc(x: 0, y: 0)
+         Point.new(x: @x + x, y: @y + y)
+      end
+
+      def >=(p)  @x >= p.x and @y >= p.y     end
+      def <=(p)  @x <= p.x and @y <= p.y     end
+      def ==(p)  @x == p.x and @y == p.y     end
+      def to_s;  "[(Point) x=#{x}, y=#{y}]"  end
+   end
+
+   class Size
+      attr_accessor :width, :height
+
+      def initialize(width: 0, height: 0)
+         @width, @height = width, height
+      end
+
+      def update(width: nil, height: nil)
+         Size.new(width: (width or @width), height: (height or @height))
+      end
+
+      def calc(height: 0, width: 0)
+         Size.new(height: @height + height, width: @width + width)
+      end
+
+      def ==(s)  s.height == @height and s.width == @width    end
+      def to_s;  "[(Size) height=#{height}, width=#{width}]"  end
+   end
+   
+   # We want to change the mouse coordinates as we pass the mouse event
+   # through the widgets. The attributes of Curses::MouseEvent are
+   # readonly, therefore we need to carry out our own MouseEvent class.
+   class FakeMouseEvent
+      attr_accessor :x, :y, :z, :bstate
+
+      def initialize(mouse_event=nil)
+         if mouse_event
+            from_mouse_event!(mouse_event)
+         else
+            @x, @y, @z, @bstate = 0, 0, 0, Curses::BUTTON1_CLICKED
+         end
+      end
+
+      def from_mouse_event!(m)
+         @x, @y, @z, @bstate = m.x, m.y, m.z, m.bstate
+      end
+
+      def update!(x: nil, y: nil, z: nil, bstate: nil)
+         @x, @y, @z = (x or @x), (y or @y), (z or @z)
+         @bstate = (bstate or @bstate)
+      end
+
+      def pos
+         Point.new(x: @x, y: @y)
+      end
+
+      def to_fake
+         FakeMouseEvent.new(self)
+      end
+
+      def to_s
+         name = Curses.constants.
+            select { |c| c =~ /^BUTTON_/ }.
+            select { |c| Curses.const_get(c) & @bstate > 0 }[0]
+         name ||= @button
+         "[(FakeMouseEvent) button=#{name}, x=#{x}, y=#{y}, z=#{z}]"
+      end
+   end
+
+   class MouseEvents < Events
+      def on(mouse_event, &block)
+         return on_all(&block) if mouse_event == Curses::ALL_MOUSE_EVENTS
+         super(mouse_event, &block)
+      end
+
+      def trigger(mouse_event)
+         super(mouse_event.bstate, mouse_event)
+      end
+   end
+
+   class MouseSectionEvents
+      def initialize
+         @events = []
+      end
+
+      def clear
+         @events.clear
+      end
+
+      def add(mouse_section_event)
+         @events << mouse_section_event
+      end
+
+      def trigger(mevent)
+         @events.each { |e| e.trigger(mevent) }
+      end
+   end
+
+   class MouseSectionEvent
+      def initialize(start=nil, stop=nil)
+         @start_pos, @stop_pos, @events = start, stop, MouseEvents.new
+      end
+
+      def on(button, &block); @events.on(button, &block)  end
+
+      def trigger(mevent)
+         return unless mevent.pos >= @start_pos and mevent.pos <= @stop_pos
+         @events.trigger(mevent)
+      end
+   end
+end
+
+module Curses
+   class Window
+      alias :height :maxy
+      alias :width  :maxx
+      alias :clear_line :clrtoeol
+
+      def cursor;  UI::Point.new(y: cury, x: curx)           end
+      def pos;     UI::Point.new(y: begy, x: begx)           end
+      def size;    UI::Size.new(height: maxy, width: maxx)   end
+
+      def cursor=(new)
+         setpos(new.y, new.x) # or fail "Could not set cursor: #{new} #{size}"
+      end
+
+      def pos=(new)
+         move(new.y, new.x)
+      end
+
+      def size=(new)
+         resize(new.height, new.width) or fail "Could not resize: #{new}"
+      end
+
+      def with_attr(attr)
+         attron(attr); yield; attroff(attr)
+      end
+
+      def getch1(timeout=-1)
+         self.timeout=(timeout)
+         getch
+      end
+
+      def on_line(n)       setpos(n, curx)                        ;self;end
+      def on_column(n)     setpos(cury, n)                        ;self;end
+      def next_line;       setpos(cury + 1, 0)                    ;self;end
+      def mv_left(n)       setpos(cury, curx - 1)                 ;self;end
+      def line_start(l=0)  setpos(l, 0)                           ;self;end
+      def from_left(size)  setpos(cury, size)                     ;self;end
+      def from_right(size) setpos(cury, (maxx - size))            ;self;end
+      def center(size)     setpos(cury, (maxx / 2) - (size / 2))  ;self;end
+
+      def center_string(string)
+         center(string.size)
+         addstr(string)
+      self end
+
+      def insert_top
+         setpos(0, 0)
+         insertln
+      self end
+
+      def append_bottom
+         setpos(0, 0)
+         deleteln
+         setpos(maxy - 1, 0)
+      self end
+   end
+
+   class MouseEvent
+      def pos
+         UI::Point.new(x: x, y: y)
+      end
+
+      def to_fake
+         UI::FakeMouseEvent.new(self)
+      end
+   end
+end