aniview 3.2.1 → 5.1.0

data/lib/aniview/interface/subscription/subscription.rb

@@ -1,123 +0,0 @@
-require 'simple-rss'
-require 'open-uri'
-
-require_relative "../schedule/scheduleitem"
-require_relative '../bridge'
-
-module Aniview
-  module Interface
-    class Subscription < Bridge
-
-      include Observable
-
-    	def initialize pref, schedule, delugec, client
-        @c = client
-    		@pref = pref
-        @schedule = schedule
-        @delugec = delugec
-        #SimpleRSS.feed_tags << :"torrent:magnetURI"
-        #&lt;![CDATA[
-    	end
-    
-      def log s
-        puts "#{Time.now.to_s} [subscription] " + s
-      end
-    
-      def checkDaemon
-        if @c.server?
-          "daemon up"
-        else
-          "daemon down"
-        end
-      end
-    
-      def getLastChecked
-        @c.lastchecked
-      end
-
-      def getNextCheck
-        @c.sendMsg "nextcheck"
-      end
-    
-      def syncMatches
-        @schedule.mergeItems @c.getItems
-      end
-    
-    	def updateFeed
-        begin
-          SimpleRSS.item_tags << :"torrent:magnetURI"
-    		  @rss = SimpleRSS.parse open(@pref.get("rss_feed")["url"])
-    
-        rescue SocketError
-          @rss = nil
-        end
-    	end
-    
-      def feed
-        @rss
-      end
-    
-    	def match regexp, verbose=false
-        re = Regexp.new regexp
-        matches = []
-    		@rss.items.each{ |item|
-          #log "-> checking against #{item[:title]}" if verbose
-          re.match item[:title] { matches << item }
-    		}
-        return matches
-    	end
-    
-      def matchAll (verbose: false)
-        updateFeed if @rss == nil
-        return [] if @rss == nil
-    
-        log "matching all" if verbose
-    
-        total_matches = 0
-        @schedule.schedule.each { |subs|
-          log "matching #{subs.attributes["r"]}" if verbose
-          matches = match subs.attributes["r"], verbose
-          log "found #{matches.length} matches"  if verbose
-          #log "#{matches}"  if verbose
-    
-          if matches.length >= 1
-    
-            downloaddir = @pref.parseDir(subs.attributes["p"]) + "/"
-            newfile = downloaddir + matches[0][:title]
-    
-            next if File.exist? newfile
-            log "attempting to downloading file" if verbose
-            log "set download dir to #{newfile}" if verbose
-            log "#{matches[0].link}" if verbose
-            s = @delugec.addTorrent matches[0].link, @pref.parseDir(subs.attributes["p"]), verbose: true
-            log "adding torrent, status #{s}" if verbose
-            subs.setSeen if s
-            @schedule.save
-            total_matches+=1
-          end
-        }
-        log "match complete, #{total_matches} found" if verbose
-        return total_matches
-      end
-    
-      def forceMatch
-        @mthread = Thread.new do
-          updateFeed
-          matchAll
-        end
-      end
-    
-      def items
-        @schedule.items
-      end
-    
-      def editItem loc, newval
-        @schedule.schedule[loc].setRegexp newval
-        @schedule.save
-        changed
-        notify_observers
-      end
-    end
-  end
-end
-

data/lib/aniview/util/error.rb

@@ -1,9 +0,0 @@
-module Aniview
-  module Error
-    class InvalidPref < StandardError
-      def initialize(msg="Your preferences file is invalid")
-        super
-      end
-    end
-  end
-end

data/lib/aniview/util/folder_listen.rb

@@ -1,53 +0,0 @@
-# watch for changes in a folder's existance
-
-module Aniview
-  module Util
-    module FolderListen
-
-      def self.to(dirs, &block)
-        Listener.new(dirs, &block)
-      end
-
-      ##
-      ## @brief      Similar to Listen gem but uses polling and is only intended
-      ##             to be used on a small number of files. the Listen gem
-      ##             wouldn't support watching an individual FOLDER to see if
-      ##             the folder went away so this is that!
-      ##
-      class Listener
-        def initialize(dirs, &block)
-          @dirs           = dirs
-          @block          = block
-          @sleep_duration = 1
-          @dir_hash       = dir_hash
-        end
-
-        def dir_hash
-          @dirs.map { |dir| [dir, File.exist?(dir)]}.to_h
-        end
-
-        def changed?
-          @dir_hash != dir_hash
-        end
-
-        def stop
-          @listen_thread.exit if @listen_thread
-        end
-
-        def start
-          Thread.abort_on_exception = true
-          @listen_thread = Thread.new do
-            while true
-              if changed?
-                @block.call
-                @dir_hash = dir_hash
-              end
-              sleep 1
-            end
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/aniview/util/term.rb

@@ -1,44 +0,0 @@
-module Aniview
-  module Util
-    class Term
-
-      def initialize
-        @tput=Hash[
-          "smcup" => %x(tput smcup),
-          "rmcup" => %x(tput rmcup),
-          "civis" => %x(tput civis),
-          "cnorm" => %x(tput cnorm),
-          "el1" => "\e[2K",
-          "bold" => %x(tput bold),
-          "nobold" => %x(tput sgr0),
-        ]
-      end
-
-      def save;        print @tput["smcup"];  return self; end
-      def restore;     print @tput["rmcup"];  return self; end
-      def hide_cursor; print @tput["civis"];  return self; end
-      def show_cursor; print @tput["cnorm"];  return self; end
-      def clear_line;  print @tput["el1"];    return self; end
-      def echo_off;    %x(stty -echo);        return self; end
-      def echo_on;     %x(stty echo);         return self; end
-      def clear;       print "\033[2J";       return self; end
-      def bold;        print @tput["bold"];   return self; end
-      def nobold;      print @tput["nobold"]; return self; end
-
-      def cols;        return HighLine::SystemExtensions.terminal_size[0]; end
-      def rows;        return HighLine::SystemExtensions.terminal_size[1]; end
-
-      def self.cols;        return HighLine::SystemExtensions.terminal_size[0]; end
-      def self.rows;        return HighLine::SystemExtensions.terminal_size[1]; end
-
-      def getKey
-        return STDIN.getch.gsub("\r", "enter").gsub(" ", "space").gsub("A", "up").gsub("B", "down").gsub("C", "right").gsub("D", "left").gsub("\e", "skip").gsub("[", "skip")
-      end
-
-      def reset
-        self.restore.show_cursor.echo_on
-      end
-
-    end
-  end
-end

data/lib/aniview/util/util.rb

@@ -1,167 +0,0 @@
-require 'base64'
-require 'readline'
-
-module Aniview
-  module Util
-    def self.readline(term, prompt = "", default = "")
-      term.bold.echo_on
-      print "\033[" + String(term.rows) + ";1H" + Aniview::View::Color.white
-      term.show_cursor
-      Readline.completion_append_character = ""
-      Readline.pre_input_hook = -> do
-        Readline.insert_text "#{default}"
-        Readline.redisplay
-        Readline.pre_input_hook = nil
-      end
-      input = Readline.readline(prompt, false)
-      term.hide_cursor.nobold.echo_off.clear
-      return input
-    end
-
-    def self.error_message(message)
-      #use statusline to show error messages
-      print "\e[#{Term.rows - 1};1H\e[31m #{message}\e[K"
-    end
-
-    def self.format_duration v
-      hours = Integer((v-(v%3600))/3600)
-      minutes = Integer( ((v-(v%60))/60) - (hours * 60))
-      seconds = Integer(v%60)
-      seconds = "0" + String(seconds) if seconds < 10
-      if hours < 1 and minutes < 1
-        "0:#{seconds}"
-      else
-        if hours < 1
-          return "#{String(minutes)}:#{String(seconds)}"
-        else
-          minutes = "0" + String(minutes) if minutes < 10
-          return "#{String(hours)}:#{String(minutes)}:#{String(seconds)}"
-        end
-      end
-    end
-    
-    def self.format_size s
-      fs = Float(s)
-  
-      bytecount = {
-        "TB" => 1000000000000.0,
-        "GB" => 1000000000.0,
-        "MB" => 1000000.0,
-        "KB" => 1000.0,
-        "B"  => 1.0,
-      }
-      r = "TB"
-      r = "GB" if s < bytecount["TB"]
-      r = "MB" if s < bytecount["GB"]
-      r = "KB" if s < bytecount["KB"]
-  
-      return String( Float(fs/bytecount[r] * 10.0 ).round / 10.0 ) + r
-    end
-  
-    def self.format_progress p
-      return "#{Integer(p)}.#{Integer(p * 10.0) % 10}"
-    end
-  
-    def self.parse_format string, d, cols
-      le = "\e[K\n"
-  
-      pstr = []
-      add_to = ""
-      buffer_char = []
-  
-      mode = "char"
-  
-      padding_collected = 0
-  
-      string.split('').each { |c|
-  
-        if mode == "e"
-          add_to += String(c)
-          mode = "char"
-        
-        elsif c == '%'
-          mode = "%"
-        
-        elsif c == '$'
-          mode = "$"
-        
-        elsif c == '@'
-          pstr << add_to
-          add_to = ""
-          mode = "@"
-        
-        elsif c == "#"
-          padding_collected += 1
-        
-        elsif c == "\\"
-          mode = "e"
-        
-        elsif mode == "@"
-          buffer_char << c
-          mode = "char"
-        
-        elsif mode == "%"
-          addstr = d.key?(c) ? String(d[c]) : ""
-          padding = padding_collected > addstr.length ? " " * (padding_collected - addstr.length) : ""
-          addstr = padding + addstr
-          add_to += addstr
-          mode = "char"
-          padding_collected = 0
-  
-        else
-          add_to += c
-        
-        end
-      }
-      pstr << add_to
-  
-      buffer_char << " " if buffer_char.length == 0
-  
-      midstr = ""
-      tl = 0
-      pstr.each{ |s| tl += s.length }
-      buffer_space = 0
-      buffer_space = (cols - tl) / (pstr.length - 1) if pstr.length > 1
-  
-      addl_space = (cols - tl) % pstr.length
-  
-      pstr.each_with_index{ |str, i|
-        break if i == pstr.length - 1
-        buffer_ = ""
-        buffer_ = buffer_char[i] * buffer_space if buffer_space >= 0
-  
-        midstr += str + buffer_
-      }
-      midstr += pstr[pstr.length - 1]
-  
-      return midstr[0..cols-1]
-    end
-
-    def self.encode_object d
-      Base64.strict_encode64(Marshal.dump d)
-    end
-  
-    def self.decode_object e
-      begin
-        Marshal.load(Base64.decode64(e))
-      rescue ArgumentError
-        {}
-      rescue TypeError
-        {}
-      end
-    end
-
-    def self.mounted_filesystem? dir
-      %x(mount).split("\n").map { |l| 
-        mounted = /on (.*?) /.match(l)[1]
-        if mounted == "/"
-          false
-        else
-          dir.split("/").zip(mounted.split("/")).reduce(true) { |m,v|
-            m and (v[0] == v[1] or v[1] == nil)
-          }
-        end
-      }.reduce { |a,b| a or b}
-    end
-  end
-end

data/lib/aniview/view/aiomenu.rb

@@ -1,69 +0,0 @@
-require_relative 'menu'
-require_relative '../util/util'
-
-module Aniview
-  module View
-    class AioMenu < Menu
-      include Aniview::Util
-
-      def refresh_attributes
-        if @items.length > 0
-          unformatted_P = sum_attribute("p") / @items.length
-        else
-          unformatted_P = 0
-        end
-
-        if sum_attribute("d") > 0
-          unformatted_Q = sum_attribute("W") * 100.0 / sum_attribute("d")
-        else
-          unformatted_Q = 0
-        end
-        @attributes = {
-          "t" => @attributes["t"],
-          "D" => Util.format_duration(sum_attribute("d")),
-          "S" => Util.format_size(sum_attribute("s")),
-          "P" => Util.format_progress(unformatted_P),
-          "Q" => Util.format_progress(unformatted_Q),
-          "c" => sum_attribute("c"),
-          "w" => sum_attribute("w")
-        }
-      end
-
-      def sum_attribute k
-        @items.inject(0) { |mem, c| mem += c[0].attr[k] }
-      end
-
-      def customControl(key, sel)
-        return if @items == {}
-        path = @items.values[sel["out"]][sel["in"]].path
-
-        empty = path == "empty"
-    
-        if key == @pref.get("keybindings")["menu_nav_expand"]
-          expand(sel["out"])
-        elsif key == "r"
-          refresh
-        elsif key == "enter" and not empty
-
-          if sel["in_expanded"]  
-            @interface.watch(@items.values[sel["out"]][sel["in"]])
-            @interface.logWatched(path)
-          else
-            @interface.watch_list(@items.values[sel["out"]])
-          end
-        elsif key == @pref.get("keybindings")["anime_set_watched"] and not empty
-          @interface.addWatched(path)
-        elsif key == @pref.get("keybindings")["anime_undo_set_watched"]
-          @interface.rmWatched
-        elsif key == @pref.get("keybindings")["anime_set_unwatched"] and not empty
-          @interface.rmWatched(path)
-          moveCursor("down")
-        end
-
-        changed
-        notify_observers
-      end
-    end
-  end
-end
-