ektoplayer 0.1.0

data/lib/ektoplayer/controllers/browser.rb

@@ -0,0 +1,47 @@
+require 'curses'
+
+require_relative 'controller'
+
+module Ektoplayer
+   module Controllers
+      class Browser < Controller
+         def initialize(view, browser, view_operations, operations)
+            super(view)
+            view.attach(browser)
+
+            register = view_operations.with_register('browser.')
+
+            %w(up down page_up page_down top bottom
+               search_up search_down search_next search_prev).
+               each { |op| register.(op, &view.method(op)) }
+
+            register.(:enter) do
+               operations.send(:'browser.enter', view.selected)
+            end
+
+            register.(:add_to_playlist) do
+               #if tracks = browser.tracks(view.selected)
+               operations.send(:'browser.add_to_playlist', view.selected)
+               #end
+            end
+
+            # TODO: mouse?
+            view.mouse.on(65536) do view.scroll_up(3) end
+            view.mouse.on(2097152) do view.scroll_down(3) end
+
+            view.mouse.on(Curses::BUTTON1_DOUBLE_CLICKED) do |mevent|
+               view.select_from_cursorpos(mevent.y)
+               view_operations.send(:'browser.enter')
+            end
+
+            [Curses::BUTTON1_CLICKED, Curses::BUTTON2_CLICKED, Curses::BUTTON3_CLICKED].
+               each do |button|
+               view.mouse.on(button) do |mevent|
+                  view.select_from_cursorpos(mevent.y)
+               end
+            end
+         end
+      end
+   end
+end
+

data/lib/ektoplayer/controllers/controller.rb

@@ -0,0 +1,9 @@
+module Ektoplayer
+   module Controllers
+      class Controller
+         def initialize(view)
+            @view = view
+         end
+      end
+   end
+end

data/lib/ektoplayer/controllers/help.rb

@@ -0,0 +1,21 @@
+require 'curses'
+
+require_relative 'controller'
+
+module Ektoplayer
+   module Controllers
+      class Help < Controller
+         def initialize(view, view_operations)
+            super(view)
+            register = view_operations.with_register('help.')
+            %w(up down page_up page_down top bottom).
+               each { |op| register.(op, &view.method(op)) }
+
+            # TODO: mouse?
+            view.mouse.on(65536)   { view.page_up   }
+            view.mouse.on(2097152) { view.page_down }
+         end
+      end
+   end
+end
+

data/lib/ektoplayer/controllers/info.rb

@@ -0,0 +1,22 @@
+require 'curses'
+
+require_relative 'controller'
+
+module Ektoplayer
+   module Controllers
+      class Info < Controller
+         def initialize(view, playlist, trackloader, database, view_operations)
+            super(view)
+            view.attach(playlist, trackloader, database)
+            register = view_operations.with_register('info.')
+            %w(up down page_up page_down top bottom).
+               each { |op| register.(op, &view.method(op)) }
+
+            # TODO: mouse?
+            view.mouse.on(65536)   { view.page_up   }
+            view.mouse.on(2097152) { view.page_down }
+         end
+      end
+   end
+end
+

data/lib/ektoplayer/controllers/mainwindow.rb

@@ -0,0 +1,40 @@
+require_relative 'controller'
+
+module Ektoplayer
+   module Controllers
+      class MainWindow < Controller
+         def initialize(view, view_operations)
+            super(view)
+            ops = view_operations
+            ops.reg('splash.show')   { view.tabs.selected=(view.splash)   }
+            ops.reg('playlist.show') { view.tabs.selected=(view.playlist) }
+            ops.reg('browser.show')  { view.tabs.selected=(view.browser)  }
+            ops.reg('info.show')     { view.tabs.selected=(view.info)     }
+            ops.reg('help.show')     { view.tabs.selected=(view.help)     }
+            ops.reg('tabs.next')     { view.tabs.next                     }
+            ops.reg('tabs.prev')     { view.tabs.prev                     }
+
+            ops.reg('playinginfo.toggle') do
+               view.with_lock do
+                  view.playinginfo.visible=(!view.playinginfo.visible?)
+                  view.want_layout
+               end
+            end
+
+            ops.reg('progressbar.toggle') do
+               view.with_lock do
+                  view.progressbar.visible=(!view.progressbar.visible?)
+                  view.want_layout
+               end
+            end
+
+            ops.reg('volumemeter.toggle') do
+               view.with_lock do
+                  view.volumemeter.visible=(!view.volumemeter.visible?)
+                  view.want_layout
+               end
+            end
+         end
+      end
+   end
+end

data/lib/ektoplayer/controllers/playlist.rb

@@ -0,0 +1,60 @@
+require_relative 'controller'
+require_relative '../bindings'
+
+module Ektoplayer
+   module Controllers
+      class Playlist < Controller
+         def initialize(view, playlist, view_operations, operations)
+            super(view)
+            view.attach(playlist)
+
+            register = view_operations.with_register('playlist.')
+            %w(up down page_up page_down top bottom
+               search_up search_down search_next search_prev).
+               each { |op| register.(op, &@view.method(op)) }
+
+            register.(:play) do
+               operations.send(:'playlist.play', view.selected)
+            end
+
+            register.(:reload) do
+               operations.send(:'playlist.reload', view.selected)
+            end
+
+            register.(:download_album) do
+               operations.send(:'playlist.download_album', view.selected)
+            end
+
+            register.(:delete) do
+               old_cursor, old_selected = view.cursor, view.selected
+               operations.send(:'playlist.delete', old_selected)
+               view.selected=(old_selected)
+               view.force_cursorpos(old_cursor)
+            end
+
+            register.(:goto_current) do
+               if index = playlist.current_playing
+                  view.selected=(index)
+                  view.center()
+               end
+            end
+
+            # TODO: mouse?
+            view.mouse.on(65536) do view.scroll_up(3) end
+            view.mouse.on(2097152) do view.scroll_down(3) end
+
+            [Curses::BUTTON1_CLICKED, Curses::BUTTON2_CLICKED, Curses::BUTTON3_CLICKED].
+               each do |button|
+               view.mouse.on(button) do |mevent|
+                  view.select_from_cursorpos(mevent.y)
+               end
+            end
+
+            view.mouse.on(Curses::BUTTON1_DOUBLE_CLICKED) do |mevent|
+               view.select_from_cursorpos(mevent.y)
+               view_operations.send('playlist.play')
+            end
+         end
+      end
+   end
+end

data/lib/ektoplayer/database.rb

@@ -0,0 +1,199 @@
+require 'sqlite3'
+require_relative 'events'
+
+module Ektoplayer 
+   class Database
+      SELECT_ARCHIVES = %q[
+         SELECT archive_url, archive_type
+         FROM   archive_urls
+         JOIN   tracks AS t ON t.album_url = archive_urls.album_url
+         WHERE  t.url = ?
+      ].squeeze(' ').freeze
+
+      SELECT = %q[
+      SELECT
+         %{SELECT_COLUMNS}
+      FROM (
+         SELECT DISTINCT
+            t.url             AS url,
+            t.album_url       AS album_url,
+            t.title           AS title,
+            t.artist          AS artist,
+            t.remix           AS remix,
+            t.number          AS number,
+            t.bpm             AS bpm,
+
+            a.artist          AS album_artist,
+            a.title           AS album,
+            a.released_by     AS released_by,
+            a.released_by_url AS released_by_url,
+            a.posted_by       AS posted_by,
+            a.posted_by_url   AS posted_by_url,
+            a.cover_url       AS cover_url,
+            a.category        AS category,
+            a.description     AS description,
+            a.date            AS date,
+            a.rating          AS rating,
+            a.votes           AS votes,
+            a.download_count  AS download_count,
+
+            a_s.style         AS style,
+
+            (
+               SELECT GROUP_CONCAT(style)
+               FROM  albums_styles
+               WHERE albums_styles.album_url = t.album_url
+            ) AS styles
+         FROM
+            tracks AS t
+
+         JOIN albums        AS a   ON a.url = t.album_url
+         JOIN albums_styles AS a_s ON a.url = a_s.album_url
+      )
+
+      WHERE 1  %{WHERE}
+      GROUP BY %{GROUP_BY}
+      ORDER BY %{ORDER_BY}
+      %{LIMIT} ].squeeze(' ').freeze
+
+      attr_reader :db, :events
+
+      def initialize(db_file)
+         @db = SQLite3::Database.new db_file
+         @db.results_as_hash = true
+         @events = Events.new(:changed)
+         create_tables
+      end
+
+      private def create_tables
+         @db.execute_batch %q{
+         CREATE TABLE IF NOT EXISTS albums (
+            url              TEXT   NOT NULL,
+            title            TEXT   NOT NULL,
+            artist           TEXT,  
+            released_by      TEXT,  
+            released_by_url  TEXT,  
+            posted_by        TEXT,  
+            posted_by_url    TEXT,  
+            cover_url        TEXT,  
+            category         TEXT,  
+            description      TEXT,  
+            date             DATE,  
+            rating           FLOAT  NOT NULL DEFAULT -1,  
+            votes            INT    NOT NULL DEFAULT 0,
+            download_count   INT    NOT NULL DEFAULT 0,
+            PRIMARY KEY (url)
+         );
+         CREATE TABLE IF NOT EXISTS tracks (
+            url              TEXT   NOT NULL,
+            album_url        TEXT   NOT NULL REFERENCES albums(url),
+            title            TEXT   NOT NULL,
+            artist           TEXT   NOT NULL,
+            remix            TEXT,
+            number           INT    NOT NULL,
+            bpm              INT,
+            PRIMARY KEY (url)
+         );
+         CREATE TABLE IF NOT EXISTS styles (
+            style            TEXT   NOT NULL,
+            url              TEXT   NOT NULL,
+            PRIMARY KEY (style)
+         );
+         CREATE TABLE IF NOT EXISTS archive_urls (
+            album_url        TEXT   NOT NULL REFERENCES albums(url),
+            archive_url      TEXT   NOT NULL,
+            archive_type     TEXT   NOT NULL,
+            PRIMARY KEY (album_url, archive_url)
+         );
+         CREATE TABLE IF NOT EXISTS albums_styles (
+            album_url        TEXT   NOT NULL REFERENCES albums(url),
+            style            TEXT   NOT NULL REFERENCES styles(style),
+            PRIMARY KEY (album_url, style)
+         );} 
+      end
+
+      private def drop_tables
+         %w(albums_styles archive_urls styles tracks albums).
+            each { |t| @db.execute("DROP TABLE IF EXISTS #{t}") }
+      end
+
+      def insert_into(table, hash, mode: :insert)
+         cols   = ?( + (hash.keys * ?,) + ?)
+         values = ?( + (([??] * hash.size) * ?,) + ?)
+         q = @db.prepare "#{mode} INTO #{table} #{cols} VALUES #{values}"
+         q.bind_params(hash.values)
+         q.execute
+         @events.trigger(:changed)
+      rescue
+         Application.log(self, hash, $!)
+      end
+
+      def replace_into(table, hash)
+         insert_into(table, hash, mode: :replace)
+      end
+
+      def execute(query, params=nil)
+         stm = @db.prepare query
+         stm.bind_params(*params) if params
+         stm.execute.to_a
+      rescue
+         Application.log(self, $!)
+      end
+
+      def select(
+         columns: ?*,
+         filters: [],
+         group_by: 'url',
+         order_by: 'album, number',
+         limit: nil
+      )
+         where_clauses, where_params = [], []
+              
+         filters.each do |filter|
+            where_clauses << "AND #{filter[:tag]} #{filter[:operator]} ?"
+            where_params  << filter[:value]
+         end
+
+         if order_by.is_a?Array
+            fail ArgumentError, 'order_by is empty' if order_by.empty?
+            order_by = order_by.join(?,)
+         else
+            fail ArgumentError, 'order_by is empty' if order_by.empty?
+         end
+
+         if group_by.is_a?Array
+            fail ArgumentError, 'group_by is empty' if group_by.empty?
+            group_by = group_by.join(?,)
+         else
+            fail ArgumentError, 'group_by is empty' if group_by.empty?
+         end
+
+         limit = "LIMIT #{limit}" if limit
+
+         stm = @db.prepare SELECT % {
+            SELECT_COLUMNS: columns,
+            WHERE:          where_clauses.join(' '),
+            GROUP_BY:       group_by,
+            ORDER_BY:       order_by,
+            LIMIT:          limit
+         }
+
+         stm.bind_params(*where_params)
+         stm.execute.to_a
+      rescue
+         Application.log(self, $!)
+      end
+
+      def get_archives(url)
+         execute(SELECT_ARCHIVES, [url])
+      end
+
+      def track_count
+         @db.execute('SELECT COUNT(*) FROM tracks')[0][0]
+      end
+
+      def album_count
+         @db.execute('SELECT COUNT(*) FROM albums')[0][0]
+      end
+   end
+end

data/lib/ektoplayer/events.rb

@@ -0,0 +1,56 @@
+# Event class
+class Events
+   # Create a new events object
+   def initialize(*known_events)
+      @on_all = []
+
+      if known_events.empty?
+         @map = {}
+         auto_create
+      else
+         @map = known_events.map { |e| [e, []] }.to_h
+         no_auto_create
+      end
+   end
+
+   # Disables auto creation of non existent events
+   def no_auto_create 
+      @map.default_proc = proc { |h,k| fail KeyError, "Unknown event: #{k}" }
+   end
+
+   # Enables auto creation of non existent events
+   def auto_create
+      @map.default_proc = proc { |h,k| h[k] = [] }
+   end
+
+   # Registers a new event
+   def register(*events)
+      events.each { |event| @map[event] = [] }
+   end
+   alias :reg :register
+   
+   # Register hook for event
+   def on(event, &block)
+      fail ArgumentError unless block
+      @map[event] << block
+   end
+
+   def on_multi(*events, &block)
+      events.each { |event| on(event, &block) }
+   end
+
+   # Forward all events to +block(event, *args)+
+   def on_all(&block)
+      fail ArgumentError unless block
+      @on_all << block
+   end
+
+   # Trigger event
+   def trigger(event, *args)
+      @on_all.each { |callback| callback.(event, *args) }
+
+      if @map.key?(event)
+         @map[event].each { |callback| callback.call(*args) }
+      end
+   end
+end