aniview 3.2.1 → 5.1.0

data/lib/aniview/client/aniclient.rb

@@ -1,118 +0,0 @@
-require 'socket'
-require_relative '../util/util'
-
-
-module Aniview
-  module Client
-    class AniClient
-      include Aniview::Util
-      
-      # initializes a new AniClient @
-      #
-      # @param      pref  see preferences
-      #
-      # @return     nil
-      #
-      def initialize(pref)
-        @pref = pref
-      end
-
-      # connects to aniview daemon
-      #
-      # @return     [TCPSocket, false] false if unsuccessful
-      #
-      def connect
-        begin
-          TCPSocket.new 'localhost', @pref.get("daemon")["port"]
-        rescue Errno::ECONNREFUSED
-          return false
-        end
-      end
-    
-      # sends message to aniview daemon
-      #
-      # @param      msg   the message to send
-      #
-      # @return     the daemons response, or "" if there is an error.  If the
-      #             daemon is offline, "offline" is returned
-      #
-      def sendMsg msg
-        begin
-          s = connect
-          return "offline" if s == false
-          s.puts msg
-          r = s.gets.chomp
-          s.close
-          return r
-        rescue Errno::ECONNRESET
-          return ""
-        end
-      end
-    
-      # sends the message "quit" to the daemon
-      # 
-      # see #sendMsg
-      #
-      # @return     "okay"
-      #
-      def stopDaemon
-        sendMsg "quit"
-      end
-    
-      # sends the message "info" to the daemon 
-      # 
-      # see #sendMsg
-      #
-      # @return     daemon info string including uptime and number of loops and
-      #             matches
-      #
-      def info
-        sendMsg "info"
-      end
-    
-      # sends the message "lastchecked" to the daemon
-      # 
-      # see #sendMsg
-      #
-      # @return     string of the last time the daemon checked the rss feed for
-      #             new matches
-      #
-      def lastchecked
-        sendMsg "lastchecked"
-      end
-    
-      # sends the message "items" to the daemon and decodes the serialized
-      # object using Util.decode_object
-      # 
-      # see #sendMsg
-      #
-      # @return     The items.
-      #
-      def getItems
-        Util.decode_object(sendMsg "items")
-      end
-    
-      # sends the message "itemshash" to the daemon
-      # 
-      # see #sendMsg
-      #
-      # @return     item.cereal of all items
-      #
-      def getAllCereal
-        sendMsg "itemshash"
-      end
-    
-      # checks if the server is online (sends message "up?" to the daemon)
-      #
-      # see #sendMsg
-      #
-      # @return     [true, false]
-      #
-      def server?
-        return false unless sendMsg("up?") == "true"
-        return true  
-      end
-    
-    end
-  end
-end

data/lib/aniview/interface/animeio/animefile.rb

@@ -1,93 +0,0 @@
-require 'streamio-ffmpeg'
-require 'date'
-
-require_relative '../../util/util'
-require_relative '../item'
-
-module Aniview
-  module Interface
-    class AnimeFile < Item
-
-      include Aniview::Util
-
-      attr_accessor :last_modified
-      attr_accessor :accessible
-      attr_accessor :path
-
-      def initialize(path_, seen: false, watched_on: 0)
-        @watched    = seen
-        @accessible = true
-        begin
-          @last_modified = File::Stat.new(path_).mtime
-        rescue Errno::ENOENT
-          @last_modified = "0"
-        end
-        @watched_on = watched_on
-        @path       = path_
-
-        @attr = {
-          "t" => "empty",
-          "d" => 0,
-          "D" => "0",
-          "s" => 0,
-          "S" => "0",
-          "r" => 0x0,
-          "a" => "n.a.",
-          "v" => "",
-          "l" => "",
-          "f" => "",
-          "b" => "",
-          "w" => seen? ? "x" : " "
-        }
-    
-        if (@path == "empty")
-        else
-          mov = FFMPEG::Movie.new(@path)
-      
-          @attr = {
-            "t" => self.string,
-            "d" => mov.duration,
-            "D" => Util.format_duration(mov.duration),
-            "s" => mov.size,
-            "S" => Util.format_size(mov.size),
-            "r" => mov.resolution,
-            "a" => mov.audio_codec,
-            "v" => mov.video_codec,
-            "l" => mov.colorspace,
-            "f" => mov.frame_rate,
-            "b" => String(mov.bitrate) + "kb/s",
-            "w" => seen? ? "x" : " "
-          }
-        end
-      end
-
-      def title
-        return @attr["t"]
-      end
-
-      def seen?
-        return @watched
-      end
-    
-      def seenOn
-        return @watched_on
-      end
-    
-      def watch
-        @watched = true
-        @watched_on = DateTime.now.strftime('%Q')
-        @attr["w"] = "x"
-      end
-    
-      def unwatch
-        @watched = false
-        @attr["w"] = " "
-      end
-      
-      def string
-        return (File.basename("#{@path}").gsub(/\s*\[.+?\]\s*/) {}).gsub(/(\.mkv)|(\.avi)|(\.mp4)/, "").gsub("_", " ").gsub(/\s*\(.+?\)\s*/) {}
-      end
-
-    end
-  end
-end

data/lib/aniview/interface/animeio/animeio.rb

@@ -1,321 +0,0 @@
-require 'mkmf'
-require 'fileutils'
-require 'observer'
-require 'listen'
-require 'benchmark'
-
-require_relative 'animefile'
-require_relative 'animeseries'
-require_relative '../../util/util'
-require_relative '../../util/folder_listen'
-require_relative '../bridge'
-
-module Aniview
-  module Interface
-    
-    class AnimeIO < Bridge
-
-      include Aniview::Util
-
-      include Observable
-
-      def initialize(pref, mpvbridge)
-        @pref              = pref
-        @mpvbridge         = mpvbridge
-        @empty_hash        = make_empty_hash
-        @watch_log_tag     = "♪"
-        @dir_last_modified = {}
-        @made_changes      = true
-
-        self.load
-        pref_changed!(verbose: false)
-        #relisten
-
-        @pref.add_observer(self, :pref_changed!)
-        @mpvbridge.add_observer(self, :animefile_changed!)
-        #@@local_anime.each { |key, obj| obj.add_observer(self, :animefile_changed!)}
-      end
-
-      def listen_to_all_dirs
-        #listen to all
-        all_dirs = (@pref.get("anime_locations").split(":")).map { |dir| @pref.parseDir(dir) }
-        @folder_listener = FolderListen.to(all_dirs) { index_anime }
-        @folder_listener.start
-      end
-
-      def relisten
-        cleanup
-
-        listen_to_all_dirs
-
-        return if @anime_dirs == nil or @anime_dirs[0] == "" or @anime_dirs.length == 0
-
-        @listener = Listen.to(*@anime_dirs, only: /\.mkv$/) { index_anime }
-        @listener.start
-      end
-
-      def cleanup
-        @folder_listener.stop unless @folder_listener == nil
-        @listener.stop unless @listener == nil
-      end
-    
-      def make_empty_hash
-        af = AnimeFile.new("empty")
-        {AnimeSeries.new("empty", [af]) => [af]}
-      end
-
-      def save
-        @pref.set "local_anime", Util.encode_object(@@local_anime)
-      end
-      
-      def load
-        raw = @pref.get "local_anime"
-        if not raw == nil and raw.class == String
-          @@local_anime = Util.decode_object raw
-        else
-          @@local_anime = {}
-        end
-      end
-
-      def pref_changed!(verbose: true)
-        new_dirs = (@pref.get("anime_locations").split(":")).collect { |dir|
-          parsed_dir = @pref.parseDir(dir)
-          parsed_dir if File.exist?(parsed_dir)
-        }.compact
-        if new_dirs != @anime_dirs
-          @anime_dirs = new_dirs
-          index_anime(verbose: verbose)
-          relisten
-        end
-      end
-
-      def animefile_changed!
-        return unless @mpvbridge.what_changed[:local_anime]
-        save
-        changed
-        notify_observers
-      end
-
-      ##
-      ## @brief      Indexes anime files up to 1 level deep in specified anime directories
-      ##
-      ## @param      force    The force
-      ## @param      verbose  The verbose
-      ##
-      ## @return     { description_of_the_return_value }
-      ##
-      def index_anime(force: false, verbose: true, very_verbose: false)
-        puts "Indexing anime" if very_verbose
-        Thread.new {
-          ret = {}
-          made_changes = false
-          lal = @@local_anime.length
-
-          @anime_dirs.each_with_index { |dir, i|
-
-            avs_file = dir + "/.avs"
-
-            if File.exist?(avs_file)
-              puts "found avs_data" if very_verbose
-              avs_data = JSON.parse(File.open(avs_file, "r") { |f| f.read })
-            else
-              puts "no avs_data" if very_verbose
-              avs_data = {}
-            end
-
-
-            # check if the directory exists
-            unless File.exist? dir 
-              unless @dir_last_modified[dir] == "check"
-                @dir_last_modified[dir] = "check"
-                made_changes = true
-              end
-              next
-            end
-
-            puts "checking #{dir}" if very_verbose
-
-            # skip indexing a directory if it hasn't been modified since the last
-            # check (disabled because doesn't save to much time)
-            #
-            #dir_mtime = File::Stat.new(dir).mtime
-            #
-            #if @dir_last_modified.key? dir
-            #  if @dir_last_modified[dir] == dir_mtime
-            #    next
-            #  else
-            #    @dir_last_modified[dir] = dir_mtime
-            #  end
-            #else
-            #  @dir_last_modified.merge!(dir => dir_mtime)
-            #end
-
-            # get all files in the directory and in all subfolders of the directory
-            files = Dir.glob("#{dir}*/*.{mkv,avi,mp4}") + Dir.glob("#{dir}/*.{mkv,avi,mp4}")
-
-            files.each_with_index { |file, j|
-              if verbose
-                pct = Util.format_progress ((j + 1) / Float(files.length)) * ( (i + 1) / Float(@anime_dirs.length)) * 100
-                Util.error_message("#{pct}% #{File.basename(file)}") 
-              end
-
-              print "indexing #{file} -> " if very_verbose
-              params = {:seen => false, :watched_on => 0}
-
-              #check if this anime has a stored watched value
-              if avs_data.key?(file)
-                puts "found stored data for this file" if very_verbose
-                params = {
-                  :seen => avs_data[file]["seen"],
-                  :watched_on => avs_data[file]["watched_on"]
-                }
-                puts params if very_verbose
-              else
-                puts "no data on this file" if very_verbose
-                avs_data.merge!({file => params})
-              end
-
-              # we have already indexed this file
-              if @@local_anime != nil and @@local_anime.key?(file)
-                
-                puts "this file is in the index" if very_verbose
-
-                # get its seen data
-                params[:seen]       = @@local_anime[file].seen?
-                params[:watched_on] = @@local_anime[file].seenOn
-                puts params if very_verbose
-                # get its last modifed data
-                last_modified = File::Stat.new(file).mtime
-                # get wether or not it is accessible
-                @@local_anime[file].accessible = true
-
-                # if we arent forcing or the anime hasn't been modified since the
-                # last check, skip it
-                if not force or last_modified == @@local_anime[file].last_modified
-                  puts "unchanged" if very_verbose
-                  ret.merge!(file => @@local_anime[file])
-                  next
-                end
-              end
-
-              #puts "changed!"
-
-              # okay we are making changes to local_anime
-              made_changes = true
-
-              # this is the anime file we are adding
-              ret.merge!(
-                file => AnimeFile.new(file, params)
-              )
-            }
-
-            mavsf = @pref.get("avs_files")["create?"]
-            oimfs = @pref.get("avs_files")["only_on_mounted_fs?"]
-            if mavsf and ((oimfs and Util.mounted_filesystem?(dir)) or not oimfs)
-              File.open(avs_file, "w") { |f| f.puts JSON.generate(avs_data)}
-            end
-          }
-
-          #if @@local_anime != nil
-          #  @@local_anime.merge!(ret)
-          #else
-            @@local_anime = ret
-          #end
-
-          #pruned = {}
-          #@@local_anime.each{ |a|
-          #  pruned.merge!(a[0] => a[1]) if File.exist? a[1].path
-          #}
-          #@@local_anime = pruned
-          made_changes = true if @@local_anime.length != lal
-          if @made_changes
-            self.save 
-            changed 
-            notify_observers
-          end
-          #
-        }
-      end
-    
-      #returns the parent directory of a file
-      def parent(file)
-        return File.basename(File.dirname(file))
-      end
-    
-      #convert an AnimeFile array to a hash structured like
-      #(string)parent => (AnimeFile array)[child0, child1, child2] and return it
-      def makeHash arr
-        #return @empty_hash if arr[0] == nil
-        
-        keys = {}
-        hash = {}
-
-        arr.sort_by {|i| i.title}.each { |file|
-          unless keys.key?(parent file.path)
-            key = AnimeSeries.new parent(file.path)
-            keys.merge! parent(file.path) => key
-            hash.merge! key => []
-          else
-            key = keys[parent file.path]
-          end
-
-          hash[key] << file
-          key << file
-        }
-        hash.sort_by{ |j| j[0].title }.to_h
-      end
-    
-      #return the difference of getAired and getWatched
-      def unwatched
-        makeHash @@local_anime.reject { |f, a| a.seen? }.values
-      end
-    
-      #return an AnimeFile array of all mkvs in any dir specified in $pref["dirs"]
-      def items
-        makeHash @@local_anime.values
-      end
-    
-      def logWatched(file)
-        open(@pref.parseDir(@pref.get("watch_log")), 'a') do |f|
-          f.puts %x(date).chomp + " ./" + File.basename(file) + " " + @watch_log_tag
-        end
-      end
-
-      def addWatched(file)
-        @@local_anime[file].watch
-        save
-        changed
-        notify_observers
-      end
-    
-      def rmWatched(path = "")
-        if @@local_anime.key? path
-          @@local_anime[path].unwatch
-        else
-          r = []
-          @@local_anime.values.each_with_index{ |v, i| r << {Integer(v.seenOn) => @@local_anime.keys[i]} if v.seen? }
-          return if r.length == 0
-          last_watched = (r.sort_by{ |h| h.keys.first}.reverse)[0].values[0]
-          @@local_anime[last_watched].unwatch
-        end
-        save
-        changed
-        notify_observers
-      end
-
-      def watch(file)
-        @mpvbridge.play file
-      end
-
-      def watch_list(files)
-        File.open("/tmp/aniview_list.m3u", "w") { |f|
-          files.each { |file|
-            f.puts file.path
-          }
-        }
-        @mpvbridge.playlist("/tmp/aniview_list.m3u", files.map { |f| [f.path, f] }.to_h)
-      end
-
-    end
-  end
-end