ektoplayer 0.1.0

data/lib/ektoplayer/browsepage.rb

@@ -0,0 +1,138 @@
+#!/bin/ruby
+
+require 'nokogiri'
+require 'base64'
+require 'scanf'
+require 'open-uri'
+
+module Ektoplayer
+   class BrowsePage
+      ALBUM_KEYS = %w(url title artist date category styles cover_url description
+                      download_count released_by released_by_url posted_by posted_by_url
+                      archive_urls rating votes tracks).map(&:to_sym).freeze
+
+      TRACK_KEYS = %w(url album_url number title remix artist bpm).map(&:to_sym).freeze
+
+      attr_reader :albums, :page_urls, :current_page_index
+
+      def self.parse(src)
+         BrowsePage.new(src)
+      end
+
+      def styles;             @@styles or []    end
+      def first_page_url;    @page_urls[0]    end
+      def last_page_url;     @page_urls[-1]   end
+      def current_page_url;  @page_urls[@current_page_index] end
+
+      def prev_page_url
+         @page_urls[@current_page_index - 1] if @current_page_index > 0
+      end
+
+      def next_page_url
+         @page_urls[@current_page_index + 1] if @current_page_index + 1 < @page_urls.size
+      end
+
+      def initialize(src)
+         doc = Nokogiri::HTML(open(src))
+         @albums = []
+
+         @page_urls = []
+         doc.css('.wp-pagenavi option').each_with_index do |option, i|
+            @current_page_index = i if option[:selected]
+            @page_urls << option[:value]
+         end
+
+         @@styles ||= begin
+            doc.xpath('//a[contains(@href, "http") and contains(@href, "/style/")]').map do |a|
+               [ a.text, a[:href] ]
+            end.to_h
+         end
+
+         doc.xpath('//div[starts-with(@id, "post-")]').each do |post|
+            album = { tracks: [] }
+            album[:date] = post.at_css('.d').text        rescue nil
+            album[:category] = post.at_css('.c a').text  rescue nil
+
+            album[:styles] = []
+            post.css('.style a').map do |a|
+               @@styles[a.text] = a[:href]
+               album[:styles] << a.text
+            end
+
+            album[:cover_url] = post.at_css('.cover')[:src]   rescue nil
+            album[:description] = post.at_css(?p).to_html     rescue ''
+            album[:download_count] = post.at_css('.dc strong').text.delete(?,).to_i rescue 0
+
+            post.css('h1 a').each do |a|
+               album[:title] = a.text
+               album[:url] = a[:href]
+            end 
+
+            post.xpath('.//a[@rel="tag"]').each do |a|
+               album[:released_by] = a.text
+               album[:released_by_url] = a[:href]
+            end
+
+            post.xpath('.//a[@rel="author external"]').each do |a|
+               album[:posted_by] = a.text
+               album[:posted_by_url] = a[:href]
+            end
+
+            album[:archive_urls] = post.css('.dll a').map do |a|
+               [ a.text.split[0] , a[:href] ]
+            end.to_h
+
+            begin
+               post.at_css('.postmetadata .d').
+                  text.scanf('Rated %f%% with %d votes').
+                  each_slice(2) { |r,v| album[:rating], album[:votes] = r, v }
+            rescue
+               album[:rating], album[:votes] = 0, 0
+            end
+
+            begin
+               base64_tracklist = post.at_css(:script).text.scan(/soundFile:"(.*)"/)[0][0]
+               tracklist_urls = Base64.decode64(base64_tracklist).split(?,)
+            rescue
+               # Sometimes there are no tracks:
+               # http://www.ektoplazm.com/free-music/dj-basilisk-the-colours-of-ektoplazm
+               tracklist_urls = []
+            end
+
+            post.css('.tl').each do |album_track_list|
+               track = nil
+               album_track_list.css(:span).each do |ti|
+                  case ti[:class]
+                  when ?n 
+                     album[:tracks] << track if track and track[:url]
+                     track = { url: tracklist_urls.shift }
+                     track[:number] = ti.text.to_i
+                  when ?t then track[:title]  = ti.text
+                  when ?a then track[:artist] = ti.text
+                  when ?r then track[:remix]  = ti.text
+                  when ?d then track[:bpm]    = ti.text.scan(/\d+/)[0].to_i rescue nil
+                  end
+               end
+
+               album[:tracks] << track if track and track[:url]
+            end
+
+            # extract artist name out ouf album title, set missing artist on album tracks
+            unless album[:tracks].all? { |t| t.key?(:artist) }
+               if album[:title].include?' – '
+                  album[:artist], album[:title] = album[:title].split(' – ', 2)
+                  album[:tracks].each { |t| t[:artist] ||= album[:artist] }
+               else
+                  album[:tracks].each { |t| t[:artist] ||= 'Unknown Artist' }
+               end
+            end
+
+            @albums << album
+         end
+
+         Application.log(self, "completed; #{src} #{@albums.size} albums found")
+      rescue
+         Application.log(self, src, $!)
+      end
+   end
+end

data/lib/ektoplayer/client.rb

@@ -0,0 +1,18 @@
+require 'fileutils'
+
+require_relative 'database'
+require_relative 'trackloader'
+
+module Ektoplayer
+   class Client
+      attr_reader :database
+      attr_reader :trackloader
+
+      def initialize
+         db_file = Config.get(:database_file)
+         FileUtils::touch(db_file) unless File.file? db_file
+         @database = Database.new(db_file)
+         @trackloader = Trackloader.new(@database)
+      end
+   end
+end

data/lib/ektoplayer/common.rb

@@ -0,0 +1,91 @@
+require 'zip'
+
+class Object
+   alias :frz :freeze
+end
+
+class Dir
+   def Dir.size(path)
+      Dir.glob(File.join(path, '**', ?*)).map { |f| File.size(f) }.sum
+   end
+end
+
+class String
+   def chunks(n)
+      return [self] if n < 1
+
+      if (chunk_size = self.size / n) < 1
+         return [self]
+      end
+
+      (n - 1).times.map do |i|
+         self.slice((chunk_size * i)..(chunk_size * (i + 1) - 1))
+      end + [
+         self.slice((chunk_size * (n-1))..-1)
+      ]
+   end
+end
+
+module Common
+   def self.open_url_extern(url)
+      if url =~ /\.(jpe?g|png)$/i
+         Common.open_image_extern(url)
+      else
+         fork { exec('xdg-open', url) }
+      end
+   end
+
+   def self.open_image_extern(url)
+      fork do
+         exec('feh', url) rescue (
+            exec('display', url) rescue (
+               exec('xdg-open', url)
+            )
+         )
+      end
+   end
+
+   def self.extract_zip(zip_file, dest)
+      Zip::File.open(zip_file) do |zip_obj|
+         zip_obj.each do |f|
+            f.extract(File.join(dest, f.name))
+         end
+      end
+   end
+
+   def self.with_hash_zip(keys, values)
+      hash = {}
+
+      keys.size.times do |i|
+         hash[keys[i]] = values[i]
+      end
+
+      yield hash
+
+      keys.clear << hash.keys
+      values.clear << hash.values
+   end
+
+   def self.to_time(secs)
+      return '00:00' unless secs or secs == 0
+      "%0.2d:%0.2d" % [(secs / 60), (secs % 60)]
+   end
+
+   def self.mksingleton(cls)
+      unless cls.singleton_methods.include? :_get_instance
+         cls.define_singleton_method(:_get_instance) do
+            unless cls.class_variable_defined? :@@_class_instance
+               cls.class_variable_set :@@_class_instance, cls.new
+            end
+
+            cls.class_variable_get :@@_class_instance
+         end
+
+         (cls.instance_methods - Object.instance_methods).each do |method|
+            cls.define_singleton_method(method) do |*args|
+               cls._get_instance.send(method, *args)
+            end
+         end
+      end
+   end
+end

data/lib/ektoplayer/config.rb

@@ -0,0 +1,247 @@
+require 'shellwords'
+require 'nokogiri'
+
+module Ektoplayer
+   class ColumnFormat
+      def self.parse_column_format(format)
+         self.parse_simple_format(format).
+            select { |f| f[:tag] != 'text' }.
+            map do |fmt|
+            fmt[:size]    = fmt[:size].to_i      if fmt[:size]
+            fmt[:rel]     = fmt[:rel].to_i       if fmt[:rel]
+            fmt[:justify] = fmt[:justify].to_sym if fmt[:justify]
+
+            begin
+               fail 'Missing size= or rel=' if (!fmt[:size] and !fmt[:rel])
+               fail 'size= and rel= are mutually exclusive' if (fmt[:size] and fmt[:rel])
+            rescue 
+               fail "column: #{fmt[:tag]}: #{$!}"
+            end
+
+            fmt
+         end
+      end
+
+      def self.parse_simple_format(format)
+         self._parse_markup(format).map do |fmt|
+            attrs = []
+            attrs << :bold      if fmt[:bold]
+            attrs << :blink     if fmt[:blink]
+            attrs << :standout  if fmt[:standout]
+            attrs << :underline if fmt[:underline]
+            fmt[:curses_attrs] = [ (fmt[:fg] and fmt[:fg].to_sym), (fmt[:bg] and fmt[:bg].to_sym), *attrs]
+            fmt
+         end
+      end
+
+      def self._parse_markup(format)
+         Nokogiri::XML("<f>#{format}</f>").first_element_child.
+            children.map do |fmt|
+               fmt1 = fmt.attributes.map do |name,a|
+                  [name.to_sym, a.value]
+               end.to_h.update(tag: fmt.name)
+               fmt1[:text] = fmt.text if fmt1[:tag] == 'text'
+               fmt1
+         end
+      end
+   end
+
+   class Config
+      CONFIG_DIR  = File.join(Dir.home, '.config', 'ektoplayer').freeze
+      CONFIG_FILE = File.join(CONFIG_DIR, 'ektoplayer.rc').freeze
+
+      DEFAULT_PLAYLIST_FORMAT = (
+         '<number size="3" fg="magenta" />' +
+         '<artist rel="33" fg="blue"    />' +
+         '<album  rel="33" fg="red"     />' +
+         '<title  rel="33" fg="yellow"  />' +
+         '<styles rel="20" fg="cyan"    />' +
+         '<bpm    size="4" fg="green" justify="right" />').freeze
+
+      DEFAULT_PLAYINGINFO_FORMAT1 =
+         '<text fg="black">──┤ </text><title bold="on" fg="yellow" /><text fg="black"> ├──</text>'.freeze
+
+      DEFAULT_PLAYINGINFO_FORMAT2 = 
+         '<artist bold="on" fg="blue" /><text> - </text><album bold="on" fg="red" /><text> (</text><date fg="cyan" /><text>)</text>'.freeze
+
+      def register(key, description, default, method=nil)
+         @doc[key.to_sym] = description.squeeze(' ').freeze
+
+         if method
+            @cast[key.to_sym]    = method if method
+            @options[key.to_sym] = method.(default).freeze
+         else
+            @options[key.to_sym] = default.freeze
+         end
+      end
+      alias :reg :register
+
+      def initialize
+         @options = Hash.new { |h,k| fail "Unknown option #{k}" }
+         @doc, @cast = {}, {}
+
+         reg :database_file, 'File to store metadata',
+            File.join(CONFIG_DIR, 'meta.db'),
+            File.method(:expand_path)
+
+         reg :log_file, 'Log file',
+            File.join(CONFIG_DIR, 'ektoplayer.log'),
+            File.method(:expand_path)
+
+         reg :temp_dir, %{Where to temporary store mp3 files. Directory will be created 
+                          if it does not exist (parent directories will NOT be created},
+            '/tmp/.ektoplazm',
+            File.method(:expand_path)
+
+         reg :cache_dir,
+            'Directory for storing mp3 files',
+            File.join(Dir.home, '.cache', 'ektoplayer'),
+            File.method(:expand_path)
+
+         reg :archive_dir,
+            'Where to search for downloaded MP3 archives',
+            File.join(CONFIG_DIR, 'archives'),
+            File.method(:expand_path)
+
+         reg :download_dir,
+            'Where to store downloaded MP3 archives', '/tmp',
+            File.method(:expand_path)
+
+         reg :auto_extract_to_archive_dir,
+            %{Enable/disable automatic extraction of downloaded MP3
+             archives from download_dir to archive_dir}, true
+
+         reg :delete_after_extraction,
+            %{In combination with auto_extract_to_archive_dir:
+             Delete zip archive after successful extraction}, true
+
+         reg :playlist_load_newest,
+            %{How many tracks from database should be added to
+              the playlist on application start}, 100
+
+         reg :use_cache,
+            'Enable/disable local mp3 cache', true
+
+         reg :small_update_pages,
+            'How many pages should be fetched after start', 5
+
+         reg :use_colors,
+            'Choose color capabilities. auto|mono|8|256', 'auto',
+            lambda { |v| 
+               { 'auto' => :auto, 'mono' => 0,
+                 '8' => 8, '256' => 256 }[v] or fail 'invalid value'
+            }
+
+         reg :threads,
+            'Number of donwload threads during database update',
+            20, lambda { |v| fail if Integer(v) < 1; Integer(v) }
+
+         reg 'browser.format', 'Format of browser columns',
+            DEFAULT_PLAYLIST_FORMAT, ColumnFormat.method(:parse_column_format)
+
+         reg 'playlist.format', 'Format of playlist columns',
+            DEFAULT_PLAYLIST_FORMAT, ColumnFormat.method(:parse_column_format)
+
+         # - Progressbar
+         reg 'progressbar.display',
+            'Enable/disable progressbar', true
+
+         reg 'progressbar.download_char',
+            'Character used for displaying download progress', ?-
+
+         reg 'progressbar.progress_char',
+            'Character used for displaying playing progress',  '─'
+
+         reg 'progressbar.rest_char',
+            'Character used for the rest of the line', '─'
+
+         # - Volumemeter
+         reg 'volumemeter.display',
+            'Enable/disable volumemeter', true
+
+         reg 'volumemeter.level_char',
+            'Character used for displaying volume level', '·'
+
+         reg 'volumemeter.rest_char',
+            'Character used for the rest of the line', '·'
+
+         # - Playinginfo
+         reg 'playinginfo.display',
+            'Enable/display playinginfo', true
+
+         reg 'playinginfo.format1',
+             'Format of first line in playinginfo', DEFAULT_PLAYINGINFO_FORMAT1,
+             ColumnFormat.method(:parse_simple_format)
+
+         reg 'playinginfo.format2',
+             'Format of second line in playinginfo', DEFAULT_PLAYINGINFO_FORMAT2,
+             ColumnFormat.method(:parse_simple_format)
+
+         # - Tabs
+         reg 'tabs.show_tabbar',
+            'Enable/disable tabbar', true
+
+         reg 'tabs.widgets', 'Specify widget order of tabbar (left to right)',
+            'splash,playlist,browser,info,help',
+            lambda { |v| v.split(/\s*,\s*/).map(&:to_sym) }
+
+         reg 'main.widgets', 'Specify widgets to show (up to down)',
+            'playinginfo,progressbar,tabs,volumemeter',
+            lambda { |v| v.split(/\s*,\s*/).map(&:to_sym) }
+      end
+
+      def get(key)  @options[key]  end
+      def [](key)   @options[key]  end
+
+      def set(option, value)
+         option = option.to_sym
+         current_value = get(option)
+
+         if cast = @cast[option]
+            @options[option] = cast.call(value)
+         else
+            if current_value.is_a?Integer
+               @options[option] = Integer(value)
+            elsif current_value.is_a?Float
+               @options[option] = Float(value)
+            elsif current_value.is_a?TrueClass or current_value.is_a?FalseClass
+               fail 'invalid bool' unless %w(true false).include? value
+               @options[option] = (value == 'true')
+            else
+               @options[option] = value
+            end
+         end
+
+         @options[option].freeze
+      rescue
+         fail "Invalid value '#{value}' for '#{option}': #{$!}"
+      end
+
+      def parse(file, bindings, theme)
+         callbacks = {
+           'set':        self.method(:set),
+           'bind':       bindings.method(:bind),
+           'unbind':     bindings.method(:unbind),
+           'color':      theme.method(:color),
+           'color_256':  theme.method(:color_256),
+           'color_mono': theme.method(:color_mono)
+         }
+         callbacks.default_proc = proc { |h,k| fail "unknown command: #{k}" }
+         callbacks.freeze
+
+         open(file, ?r).readlines.each do |line|
+            line.chomp!
+            next if line.empty? or line.start_with?(?#)
+            command, *args = line.shellsplit
+
+            begin
+               cb = callbacks[command.to_sym]
+               fail "missing arguments for #{command}" if args.size != cb.arity
+               cb.call(*args)
+            rescue
+               fail "#{file}:#{$.}: #{$!}"
+            end
+         end
+      end
+   end
+end