ektoplayer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f7e3bffc50021abf9f3c8384db4c81952abb036
+  data.tar.gz: a7d7612d2175422b4e1f59d01e6c3992915bbb6c
+SHA512:
+  metadata.gz: 788048c6464ae80c0d1d1ef2d0a85a307787ab8d8b7116cb4f2bf934223087238d5eb2af9ce48973899a248daee415aca40a23cf3a63c80d2554ab5a8fd7c8a7
+  data.tar.gz: 16bb67c65cd1b0b6c530d4f6e74f36b32d3a727e44125c8ba29c1b5e1d467362ec36d5b81ceb7a6ce5aa223d4cedd6accd8ea354b2f871d765fd581c1b82cd1a

data/README.md

@@ -0,0 +1,49 @@
+# Ektoplayer
+
+Ektoplayer is a console audio player for [ektplazm.com](http://www.ektoplazm.com).
+
+![Screenshot 2017-03-16](http://pixelbanane.de/yafu/118231024/ekto1.png)
+![Screenshot 2017-03-16](http://pixelbanane.de/yafu/324630271/ekto2.png)
+
+## Requirements
+
+  * Ruby (1.9)
+  * Portaudio (19)
+  * Mpg123 (1.14)
+  * Sqlite3 
+
+## Installation
+
+Assuming you have Ruby/Rubygems installed, you need portaudio and mpg123 as
+library to compile the native extensions.
+
+### Arch Linux
+
+    pacman -S portaudio mpg123 ncurses ruby sqlite
+    gem install ektoplayer
+
+### Debian / Ubuntu (not yet tested)
+
+    apt-get install portaudio19-dev libmpg123-dev libncurses-dev ruby1.9.1-dev sqlite-??
+    gem install ektoplayer
+
+## Features
+
+  * Listen to ektoplazm tracks
+  * Download whole albums
+  * Browse database by tags
+  * Vi keybindings (`hjkl`, `^d`, `^u`, `/`, `?`, `n`, `N`, `:`, ...)
+  * Mouse is supported
+  * Supports 256/16/mono colors
+  * Local sound file cache and download archive
+  * Highly configurable
+
+## Authors
+
+  * [Benjamin Abendroth](https://github.com/braph)
+
+## See also
+
+  * Ektoplayer was inspired by [Soundcloud2000](https://github.com/grobie/soundcloud2000) and [ncmpcpp](https://github.com/arybczak/ncmpcpp)
+  * It uses [Audite](https://github.com/georgi/audite) as playback engine and [Nokogiri](http://www.nokogiri.org/) for parsing HTML
+

data/bin/ektoplayer

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../lib', File.dirname(__FILE__))
+$LOAD_PATH.unshift(lib) if File.directory?(lib)
+
+require 'ektoplayer'
+Ektoplayer::Ektoplayer.start

data/lib/ektoplayer.rb

@@ -0,0 +1,10 @@
+require_relative 'ektoplayer/application'
+
+module Ektoplayer 
+   class Ektoplayer
+      def Ektoplayer.start
+         app = Application.new
+         app.run
+      end
+   end
+end

data/lib/ektoplayer/application.rb

@@ -0,0 +1,148 @@
+require 'fileutils'
+require 'date'
+
+{  '.'            => %w(config theme bindings client common ui),
+   'views'        => %w(mainwindow),
+   'models'       => %w(player browser playlist database trackloader),
+   'operations'   => %w(operations player browser playlist),
+   'controllers'  => %w(mainwindow browser playlist info help)
+}.each { |d,files| files.each { |f| require_relative "#{d}/#{f}" } }
+
+module Ektoplayer
+   class Application
+      VERSION = '0.1'.freeze
+      GITHUB_URL = 'https://github.com/braph/ektoplayer'.freeze
+      EKTOPLAZM_URL = 'http://www.ektoplazm.com'.freeze
+
+      CONFIG_DIR  = File.join(Dir.home, '.config', 'ektoplayer').freeze
+      CONFIG_FILE = File.join(CONFIG_DIR, 'ektoplayer.rc').freeze
+
+      def self.log(from, *msgs)
+         func = caller[0][/`.*'/][1..-2]
+         from = from.class unless from.is_a?String
+         $stderr.puts("#{DateTime.now.rfc3339} #{from}.#{func}: " + msgs.join(' '))
+
+         if e = msgs.select { |m| m.kind_of?Exception }[0] 
+            $stderr.puts "#{e.backtrace.first}: #{e.message} (#{e.class})", e.backtrace.drop(1).map{|s| "\t#{s}"}
+         end
+         $stderr.flush
+      end
+
+      def self.open_log(file)
+         $stderr.reopen(file, ?a)
+         $stderr.sync=(true)
+      end
+
+      def run
+         #Thread.abort_on_exception=(true)
+
+         # make each configuration object globally accessible as a singleton
+         [Config, Bindings, Theme].each { |c| Common::mksingleton(c) }
+
+         if File.file? Config::CONFIG_FILE
+            Config.parse(Config::CONFIG_FILE, Bindings, Theme) rescue (
+               fail "Config: #{$!}"
+            )
+         end
+
+         FileUtils::mkdir_p Config::CONFIG_DIR rescue (
+            fail "Could not create config dir: #{$!}"
+         )
+
+         Application.open_log(Config[:log_file])
+
+         if Config[:use_cache]
+            unless File.directory? Config[:cache_dir]
+               FileUtils::mkdir Config[:cache_dir] rescue (
+                  fail "Could not create cache dir: #{$!}"
+               )
+            end
+         end
+
+         [:temp_dir, :download_dir, :archive_dir].each do |key|
+            unless File.directory? Config[key]
+               FileUtils::mkdir Config[key] rescue (
+                  fail "Could not create #{key}: #{$!}"
+               )
+            end
+         end
+
+         UI::Canvas.run do
+            if Config[:use_colors] == :auto
+               Theme.use_colors(ENV['TERM'] =~ /256/ ? 256 : 8)
+            else
+               Theme.use_colors(Config[:use_colors])
+            end
+
+            client = Client.new
+
+            # ... models ...
+            player      = Models::Player.new(client)
+            browser     = Models::Browser.new(client)
+            playlist    = Models::Playlist.new
+            database    = Models::Database.new(client)
+            trackloader = Models::Trackloader.new(client)
+
+            # ... operations ...
+            operations = Operations::Operations.new
+            operations.register(:quit,    &method(:exit))
+            operations.register(:reload,  &browser.method(:reload))
+            operations.register(:update,  &database.method(:update))
+            operations.register(:refresh) { UI::Canvas.on_winch; UI::Canvas.update_screen(true) }
+            Operations::Player.new(operations, player)
+            Operations::Browser.new(operations, browser, playlist)
+            Operations::Playlist.new(operations, playlist, player, trackloader)
+
+            # ... views ...
+            main_w = UI::Canvas.sub(Views::MainWindow)
+
+            # next operations may take some time, espacially the ones
+            # using the database (browser), so we put this inside a thread
+            Thread.new do
+               # ... controllers ...
+               view_ops = Operations::Operations.new
+               Controllers::MainWindow.new(main_w, view_ops)
+               Controllers::Browser.new(main_w.browser, browser, view_ops, operations)
+               Controllers::Playlist.new(main_w.playlist, playlist, view_ops, operations)
+               Controllers::Help.new(main_w.help, view_ops)
+               Controllers::Info.new(main_w.info, playlist, trackloader, database, view_ops)
+               main_w.progressbar.attach(player)
+               main_w.volumemeter.attach(player)
+               main_w.playinginfo.attach(playlist, player)
+
+               # ... events ...
+               database.events.on(:update_finished, &browser.method(:reload ))
+               player.events.on(:stop) do |reason|
+                  operations.send(:'playlist.play_next') if reason == :track_completed
+               end
+
+               # ... bindings ...
+               Bindings.bind_view(:global, main_w, view_ops, operations)
+               %w(splash playlist browser info help).each do |w|
+                  Bindings.bind_view(w, main_w.send(w), view_ops, operations)
+               end
+
+               player.stop
+
+               # If database is empty, start an initial update
+               if browser.tracks(0).size < 1
+                  operations.send(:update)
+               elsif (c = Config[:small_update_pages]) > 0
+                  operations.send(:update, pages: c)
+               end
+
+               if (n = Config[:playlist_load_newest]) > 0
+                  r = client.database.select(order_by: 'date', limit: n)
+                  playlist.add(*r)
+               end
+            end
+
+            UI::Canvas.update_screen
+            UI::Input.start_loop
+         end
+      rescue
+         puts "Error: #{e}"
+         Application.log(self, $!)
+      end
+   end
+end

data/lib/ektoplayer/bindings.rb

@@ -0,0 +1,230 @@
+require 'set'
+require 'curses'
+
+module Ektoplayer
+   # Keybinding storage.
+   #
+   # Provides access for changing keybinds (with collision detection):
+   #   bind(), unbind()
+   #
+   # Provides binding these keys to widgets
+   #   bind_section_to_widget(), bind_to_widget()
+   #
+   class Bindings
+      attr_reader :bindings, :commands
+
+      def register(command, description)
+         @commands[command.to_sym] = description.freeze
+      end
+      alias :reg :register
+
+      def initialize
+         @commands = {}
+
+         reg 'quit',    'Quit the program'
+         reg 'refresh', 'Refresh the screen'
+         reg 'reload',  'Apply database changes to browser'
+         reg 'update',  'Start a database update'
+
+         reg 'player.stop',               'Stop playing'
+         reg 'player.toggle',             'Toggle play/pause'
+         reg 'player.forward',            'Seek forward'
+         reg 'player.backward',           'Seek backward'
+
+         reg 'tabs.next',                 'Select next tab'
+         reg 'tabs.prev',                 'Select previous tab'
+
+         reg 'browser.enter',             'Enter selected directory'
+         reg 'browser.add_to_playlist',   'Add tracks under cursor to playlist'
+         reg 'browser.back',              'Change to parent directory'
+
+         reg 'playinginfo.toggle',        'Toggle playinginfo visibility'
+         reg 'progressbar.toggle',        'Toggle progressbar visibility'
+         reg 'volumemeter.toggle',        'Toggle volumemeter visibility'
+
+         reg 'playlist.goto_current',     'Go to current playing track'
+         reg 'playlist.clear',            'Delete all items in playlist'
+         reg 'playlist.delete',           'Delete selected track from playlist'
+         reg 'playlist.download_album',   'Download album archive for selected track'
+         reg 'playlist.play',             'Play selected track'
+         reg 'playlist.reload',           'Force redownload of selected track'
+         reg 'playlist.play_next',        'Play next track in playlist'
+         reg 'playlist.play_prev',        'Play previous track in playlist'
+
+         %w(info help browser playlist splash).each do |w|
+            reg("#{w}.show", "Show #{w}")
+         end
+
+         {      up: 'Move cursor up',      down: 'Move cursor down',
+           page_up: 'Scroll page up', page_down: 'Scroll page down',
+               top: 'Move to top',       bottom: 'Move to bottom'
+         }.each do |cmd, desc|
+            %w(browser info help playlist).each { |w| reg("#{w}.#{cmd}", desc) }
+         end
+
+         { search_up: 'Start search upwards',     search_next: 'Goto next search result',
+           search_down: 'Start search downwards', search_prev: 'Goto previous search result'
+         }.each do |cmd, desc|
+            %w(browser playlist).each { |w| reg("#{w}.#{cmd}", desc) }
+         end
+
+         @bindings = {
+            global: {
+               'splash.show':             [?`, ?^                         ],
+               'playlist.show':           [?1                             ],
+               'browser.show':            [?2                             ],
+               'info.show':               [?3                             ],
+               'help.show':               [?4                             ],
+
+               'playinginfo.toggle':      [         Curses::KEY_F2        ],
+               'progressbar.toggle':      [         Curses::KEY_F3        ],
+               'volumemeter.toggle':      [         Curses::KEY_F4        ],
+
+               'player.forward':          [?f,      Curses::KEY_RIGHT     ],
+               'player.backward':         [?b,      Curses::KEY_LEFT      ],
+               'player.stop':             [?s                             ],
+               'player.toggle':           [?p                             ],
+
+               'playlist.play_next':      [?>                             ],
+               'playlist.play_prev':      [?<                             ],
+
+               'tabs.next':               [?l                             ],
+               'tabs.prev':               [?h                             ],
+
+               quit:                      [?q                             ],
+               refresh:                   ['^l'                           ],
+               reload:                    ['^r'                           ],
+               update:                    [?U                             ]},
+            playlist: {
+               # movement
+               'playlist.top':            [?g,      Curses::KEY_HOME      ],
+               'playlist.bottom':         [?G,      Curses::KEY_END       ],
+               'playlist.up':             [?k,      Curses::KEY_UP        ],
+               'playlist.down':           [?j,      Curses::KEY_DOWN      ],
+               'playlist.page_down':      ['^d',    Curses::KEY_NPAGE     ],
+               'playlist.page_up':        ['^u',    Curses::KEY_PPAGE     ],
+               # search
+               'playlist.search_next':    [?n                             ],
+               'playlist.search_prev':    [?N                             ],
+               'playlist.search_up':      [??                             ],
+               'playlist.search_down':    [?/                             ],
+               # playlist
+               'playlist.play':           [         Curses::KEY_ENTER     ],
+               'playlist.download_album': [?$                             ],
+               'playlist.reload':         [?r                             ],
+               'playlist.goto_current':   [?o                             ],
+               'playlist.clear':          [?c                             ],
+               'playlist.delete':         [?d                             ],
+               # other
+               'player.toggle':           [' '                            ]},
+            browser: {
+               # movement
+               'browser.top':             [?g,      Curses::KEY_HOME      ],
+               'browser.bottom':          [?G,      Curses::KEY_END       ],
+               'browser.up':              [?k,      Curses::KEY_UP        ],
+               'browser.down':            [?j,      Curses::KEY_DOWN      ],
+               'browser.page_up':         ['^u',    Curses::KEY_PPAGE     ],
+               'browser.page_down':       ['^d',    Curses::KEY_NPAGE     ],
+               # search
+               'browser.search_next':     [?n                             ],
+               'browser.search_prev':     [?N                             ],
+               'browser.search_up':       [??                             ],
+               'browser.search_down':     [?/                             ],
+               # browser
+               'browser.add_to_playlist': [' ', ?a                        ],
+               'browser.enter':           [?E,      Curses::KEY_ENTER     ],
+               'browser.back':            [?b,      Curses::KEY_BACKSPACE ]},
+            help: {
+               'help.top':                [?g,      Curses::KEY_HOME      ],
+               'help.bottom':             [?G,      Curses::KEY_END       ],
+               'help.up':                 [?k,      Curses::KEY_UP        ],
+               'help.down':               [?j,      Curses::KEY_DOWN      ],
+               'help.page_up':            ['^u',    Curses::KEY_PPAGE     ],
+               'help.page_down':          ['^d',    Curses::KEY_NPAGE     ]},
+            info: {
+               'info.top':                [?g,      Curses::KEY_HOME      ],
+               'info.bottom':             [?G,      Curses::KEY_END       ],
+               'info.up':                 [?k,      Curses::KEY_UP        ],
+               'info.down':               [?j,      Curses::KEY_DOWN      ],
+               'info.page_up':            ['^u',    Curses::KEY_PPAGE     ],
+               'info.page_down':          ['^d',    Curses::KEY_NPAGE     ]},
+            splash: {}
+         }
+
+         @bindings.default_proc = proc { |h,k| fail "Unknown widget #{k}" }
+         @bindings.each do |widget, hash|
+            hash.default_proc = proc { |h,k| h[k] = {} }
+            hash.values.each do |keys|
+               keys.map! { |key| parse_key(key) }
+            end
+         end
+      end
+
+      def keyname(key)
+         return 'SPACE'  if key.to_s == ' '
+         return key.to_s if key.is_a? Symbol
+
+         name = Curses.keyname(key)
+         if name.start_with? 'KEY_'
+            name.sub('KEY_', '').sub(/\((\d+)\)/, '\1')
+         else
+            name
+         end
+      end
+
+      def parse_key(key)
+         if key.is_a? Integer
+            key
+         elsif key.size == 1
+            key.to_sym
+         elsif key.size == 2 and key.start_with?(?^)
+            Curses.const_get("KEY_CTRL_#{key[1].upcase}")
+         else
+            key = key.upcase.tr(?-, ?_)
+            key = "KEY_#{key}" unless key.start_with?('KEY_')
+            Curses.const_get(key)
+         end
+      rescue NameError
+         fail "Unknown key: #{key}"
+      end
+
+      def bind(widget, key, command)
+         widget, command = widget.to_sym, command.to_sym
+         fail "Unknown command #{command}" unless COMMANDS.include? command
+
+         @bindings[widget][command].delete parse_key(key)
+         @bindings[widget][command] << parse_key(key)
+         check_collisions
+      end
+
+      def unbind(widget, key)
+         @bindings[widget.to_sym].each do |command, keys|
+            keys.delete( (parsed_key ||= parse_key(k)) )
+         end
+      end
+
+      def bind_view(section, view, view_operations, operations)
+         @bindings[section.to_sym].each do |command, keys|
+            keys.each do |key|
+               meth = view_operations.method(command) rescue operations.method(command)
+               view.keys.on(key, &meth)
+            end
+         end
+      end
+
+      private def check_collisions
+         global_keys = @bindings[:global].values.flatten
+         global_keys.each do |k|
+            fail "Double binding in 'global': #{k}" if global_keys.count(k) > 1
+         end
+
+         @bindings.each_pair do |widget, commands|
+            widget_keys = commands.values.flatten
+            widget_keys.each do |k|
+               fail "Double binding in '#{widget}': #{k}"        if widget_keys.count(k) > 1
+               fail "Double binding in 'global/#{widget}': #{k}" if global_keys.include? k
+            end
+         end
+      end
+   end
+end