aniview 3.2.1 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35841bf12f2ea102c4989e8ce4834fb71677720e
-  data.tar.gz: 59a991c9ab06d540d15eca688e90ba4aa2af5a78
+  metadata.gz: cfe4f80430aec7a3a6eba43f9aef247d4e3d0f83
+  data.tar.gz: 422406a201ee35b9144d31963e2ae9fb5c3f6ac7
 SHA512:
-  metadata.gz: c52b3272b6a5fc92f4c2e01ed56939c8f309ba669cabd751ddcb1e4a2b5e54bed48755dff119bbfeff2d97c63c717ecbaa62932a14f6bd6e142093be2920cef8
-  data.tar.gz: cd05a2b6c9ebcf1ee532987e665136bd82d36b192cba2bbd98060cfdf4a4f1ff37556153810b6a9e41d4ed67a33604acf52d80a45dd14e7cf7a11102139c4d20
+  metadata.gz: 80196869ac0dfee147601ec706a588f795f61d7a5cc22c4b721dab295299a154d5a674afd11623616d7b22592af5e47ba2df46ef26cced60099470a1b920255d
+  data.tar.gz: 1eae0bc73e999fb61e2e7f3fe1ce27ae4f1b916c01e21c31ebf165e2b811454d46af891247c382f9361726f98048efd115edf5cd4d929b95a349ee2e1b0ac291

data/README.md

@@ -1,26 +1,25 @@
 # aniview
-command line media library viewer
+command line media library viewer powered by [zashoku](https://github.com/zashoku/zashoku)
 
-![screenshot](https://raw.githubusercontent.com/annacrombie/aniview/master/screenshot.png)
+![screenshot](screenshot.png)
+
+## Note
+This software is still in development and is pretty buggy
 
 ## features
 + well optimized, aniview consues very little resources
 + keeps track of which episodes you have watched, even on removable drives
-+ ability to set up subscriptions to automatically torrent new episodes of shows as they become available
 + real time updating library as files are added / removed
 + fully customizeable display with format strings
-+ client / server model with daemon process that keeps your shows up to date
++ client / server model, with persistent daemon and multiple simultaneous connections.
+ - run aniview server on some computer and connect with a different one to use aniview like a remote
 
 ## installation
 First ensure that all the requirements are satisfied
 
 ### requirements
-+ ruby 2.4.0
-+ ffmpeg
++ ffmpeg with ffprobe
 + an up to date version of [mpv](https://mpv.io/installation/)
-+ Deluge*
-
-* Only required to use the torrent feature
 
 ### install using rubygems
 `gem install aniview`

data/bin/aniview

@@ -1,14 +1,22 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-begin
-  require_relative '../lib/aniview' if File.exist?(File.join(File.dirname(__FILE__), '../lib/aniview.rb'))
-rescue LoadError
-  require 'aniview'
+module Zashoku
+  AppConf = {
+    app: {
+      root: File.expand_path('../', __dir__),
+      name: 'aniview',
+      modules: {
+        viewer: %w[AnimeIO Mpv],
+        daemon: %w[AnimeIO Mpv]
+      },
+      save_config: true,
+      save_history: true,
+      persistent_daemon: true
+    }
+  }
 end
 
-unless defined? Aniview
-  puts "cant find aniview library" 
-  exit 
-end
+require File.join(Dir.home, 'github/zashoku/zashoku/lib/zashoku')
 
-Aniview::main(ARGV)
+Zashoku.main(ARGV)

data/config/view.yml

@@ -0,0 +1,3 @@
+---
+format:
+  statusline: " %F@ ########%t/########%e #####%p "

data/lib/aniview.rb

@@ -1,62 +1,3 @@
-require_relative 'aniview/util/error'
-require_relative 'application'
-require_relative 'daemon'
-
-# Main namespace for Aniview and all its classes
 module Aniview
-
-  self::Version = "3.2.1"
-
-  def self.show_help
-    puts "aniview"
-    puts "-h : show this message"
-    puts "-d <command> : send a command to the daemon"
-    puts "    help     : show help"
-    puts "    start    : start the daemon"
-    puts "    stop     : stop the daemon"
-    puts "    info     : show daemon info"
-    puts "    up?      : check if the daemon is up"
-    puts "    nani     : ###"
-    puts "    items    : check the daemon's items"
-  end
-
-  # initializes either the application or the daemon with given arguments
-  # @param      argv  an array of arguments, if -d is supplied, the remaining
-  #                   arguments will be passed on to the daemon
-  #
-  # @return     nil
-  #
-  def self.main argv
-
-    main_class = nil
-    daemonize  = false
-
-    argv.each { |arg|
-      case arg
-      when "-d"
-        argv.delete_at(0)
-        daemonize = true
-        main_class = Aniview::Daemon.new(argv)
-      when "-h"
-        self.show_help
-        exit
-      else
-        puts "unknown argument #{arg}"
-        self.show_help
-        exit
-      end
-    }
-    
-    main_class = Aniview::Application.new if main_class == nil
-
-    if daemonize
-      process = fork do
-        main_class.run
-      end
-      Process.detach(process)
-    else
-      main_class.run
-    end
-  end
-
+  Version = [5, 1, 0].freeze
 end

data/modules/animeio/README.md

@@ -0,0 +1,2 @@
+# zashoku-animeio
+media indexer

data/modules/animeio/config/daemon.yml

@@ -0,0 +1,4 @@
+---
+anime_locations: '~/anime/:/Volumes/JEJ/anime/'
+avs_files:
+  create?: true

data/modules/animeio/config/view.yml

@@ -0,0 +1,22 @@
+---
+keymaps:
+  global:
+    "x": change_view animeio
+  animeio:
+    10: remote::mpv watch $selected_item
+    Z: remote::animeio watched! $selected_item
+    z: remote::animeio unwatch
+    u: remote::animeio unwatch $selected_item
+title:
+    animeio: animeio
+format:
+  animeio:
+    title: " %t@ ##%w/##%c #####%Q ########%D #######%S "
+    parent: " %t@ ##%w/##%c #####%Q ########%D #######%S "
+    child: "  %w %t@ ########%D #######%S "
+
+animeio:
+  icons:
+    watched: ✓
+    unwatched: " "
+    partially: p

data/modules/animeio/lib/animeio.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Zashoku
+  module AnimeIO
+    extend Zashoku::Module
+
+    Version = [1, 0, 0].freeze
+    Root    = File.expand_path('../', __dir__)
+
+    EXTENSIONS    = %w[mkv avi mp4].freeze
+    WATCH_LOG_TAG = '♪'
+
+    autoload :AnimeIO, File.join(Root, 'lib/animeio/animeio')
+    autoload :AnimeIOView, File.join(Root, 'lib/animeio/animeio_view')
+
+    def self.view
+      AnimeIOView.new
+    end
+
+    def self.controller
+      AnimeIO.new
+    end
+  end
+end

data/modules/animeio/lib/animeio/anime_indexer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Zashoku
+  module AnimeIO
+    class AnimeIndexer
+      EMPTY_PARAMS = { watched: false, watched_on: 0 }.freeze
+      AVS_FILE = '.avs.yml'
+
+      attr_accessor :avs, :force, :indexed
+
+      def initialize
+        @made_changes = false
+        @avs = {}
+        @force = false
+        @indexed = {}
+      end
+
+      def made_changes?
+        @made_changes
+      end
+
+      def made_changes!
+        @made_changes = true
+      end
+
+      def update_avs(file)
+        obj = indexed[file]
+        dir = File.dirname(File.dirname(obj.path))
+        @avs = load_avs(File.join(dir, AVS_FILE))
+        @avs[file] ||= {}
+        @avs[file][:watched]    = obj.watched?
+        @avs[file][:watched_on] = obj.watched_on
+        write_avs(File.join(dir, AVS_FILE))
+      end
+
+      def load_avs(file)
+        File.exist?(file) ? YAML.load(File.open(file, 'r', &:read)) : {}
+      end
+
+      def write_avs(file)
+        return unless Zashoku.conf.get(%w[avs_files create?])
+        File.open(file, 'w') { |f| f.puts YAML.dump(@avs) }
+      end
+
+      def glob_files(dir)
+        Dir.glob("#{dir}*/*.{#{Zashoku::AnimeIO::EXTENSIONS.join(',')}}")
+      end
+
+      def index_files(files)
+        files.map do |file|
+          Zashoku.logger.debug "indexing #{file}"
+
+          @avs[file] = EMPTY_PARAMS.dup unless avs.key?(file)
+
+          if indexed&.key?(file)
+            @avs[file][:watched]    = indexed[file].watched?
+            @avs[file][:watched_on] = indexed[file].watched_on
+          end
+
+          {
+            file =>
+              # we have already indexed this file
+              # get its seen data
+              if indexed&.key?(file) && File::Stat.new(file).mtime <= indexed[file].last_modified
+                indexed[file]
+              else
+                made_changes!
+                AnimeFile.new(file, @avs[file])
+              end
+          }
+        end.compact.reduce(:merge) || {}
+      end
+
+      def index_dirs(dirs)
+        dirs.map do |dir|
+          next unless File.exist? dir
+          @avs = load_avs(File.join(dir, AVS_FILE))
+
+          i = index_files(glob_files(dir))
+
+          write_avs(File.join(dir, AVS_FILE))
+
+          i
+        end.reduce(:merge)
+      end
+
+      def index(dirs)
+        @made_changes = false
+        indexed_ = index_dirs(dirs)
+
+        made_changes! if indexed_.length != indexed.length
+
+        @indexed = indexed_
+      end
+    end
+  end
+end

data/modules/animeio/lib/animeio/animefile.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'streamio-ffmpeg'
+require 'date'
+
+module Zashoku
+  module AnimeIO
+    class AnimeFile < Zashoku::Item
+      include Zashoku::Util
+
+      EMPTY_ATTR = {
+        't' => 'empty',
+        'd' => 0,
+        'D' => '0',
+        's' => 0,
+        'S' => '0',
+        'r' => 0x0,
+        'a' => 'n.a.',
+        'v' => '',
+        'l' => '',
+        'f' => '',
+        'b' => '',
+      }.freeze
+
+      attr_accessor :last_modified, :accessible, :path, :watched_on, :attr
+
+      def initialize(path, attr = {})
+        @watched    = attr['watched'] || false
+        @watched_on = attr['watched_on'] || 0
+        @path       = path
+
+        begin
+          @last_modified = File::Stat.new(path).mtime
+        rescue Errno::ENOENT
+          @last_modified = '0'
+        end
+
+        @attr = (@path != 'empty') ? probe_file : EMPTY_ATTR
+      end
+
+      def attr
+        @attr.merge({
+          'w' => watched? ? Zashoku.conf.get(%w[animeio icons watched]) : Zashoku.conf.get(%w[animeio icons unwatched])
+        })
+      end
+
+      def probe_file
+        mov = FFMPEG::Movie.new(@path)
+        {
+          't' => pretty_string,
+          'd' => mov.duration,
+          'D' => Zashoku::Formatter.duration(mov.duration),
+          's' => mov.size,
+          'S' => Zashoku::Formatter.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',
+        }
+      end
+
+      def title
+        @attr['t']
+      end
+
+      def watched?
+        @watched
+      end
+
+      def watched!
+        @watched_on = DateTime.now.strftime('%Q')
+        @attr['w']  = 'x'
+        @watched    = true
+      end
+
+      def unwatch
+        @watched   = false
+      end
+
+      def pretty_string
+        @string || @string = Zashoku::Formatter.media_file(path)
+      end
+
+      def to_s
+        path
+      end
+    end
+  end
+end

data/modules/animeio/lib/animeio/animeio.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'fileutils'
+require 'observer'
+require 'listen'
+require 'benchmark'
+
+require_relative 'animefile'
+require_relative 'animeseries'
+require_relative 'anime_indexer'
+# require_relative '../../util/util'
+# require_relative '../../util/folder_listen'
+
+module Zashoku
+  module AnimeIO
+    class AnimeIO < Zashoku::Controller
+      include Zashoku::Util
+      include Observable
+
+      PLAYLIST = '/tmp/zashoku_list.m3u'
+
+      def initialize
+        @empty_hash        = make_empty_hash
+        @dir_last_modified = {}
+        @made_changes      = true
+        @indexer           = AnimeIndexer.new
+        load
+        # p ref_changed!(verbose: false)
+        listen
+        index
+        # Zashoku.conf.add_observer(self, :pref_changed!)
+      end
+
+      def index
+        @indexer.index(dirs)
+        changed!('items') if @indexer.made_changes?
+      end
+
+      def indexed
+        @indexer.indexed
+      end
+
+      def changed!(e)
+        save
+        changed
+        notify_observers(sender: 'animeio', event: e)
+      end
+
+      def pref_changed!
+        @indexer.index(dirs)
+        changed! if @indexer.changed?
+        relisten
+      end
+
+      def listen
+        @listener = Listen.to(*dirs, only: /\.mkv$/) do |mod, add, del|
+          a = @indexer.index_files(add + mod)
+          indexed.merge!(a).reject! { |p| del.include? p }
+          changed!('items')
+        end
+        @listener.start
+      end
+
+      def animefile_changed!
+        return unless @mpvbridge.what_changed[:local_anime]
+        changed!
+      end
+
+      def dirs
+        Zashoku.conf.get(['anime_locations']).split(':').collect do |dir|
+          parsed_dir = Zashoku.conf.parse_dir(dir)
+          parsed_dir if File.exist?(parsed_dir)
+        end.compact
+      end
+
+      def make_empty_hash
+        af = AnimeFile.new('empty')
+        { AnimeSeries.new('empty', [af]) => [af] }
+      end
+
+      # returns the parent directory of a file
+      def parent(file)
+        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 to_h(arr)
+        keys = {}
+        hash = {}
+
+        arr.sort_by(&:title).each do |file|
+          if keys.key?(parent(file.path))
+            key = keys[parent(file.path)]
+          else
+            key = AnimeSeries.new(parent(file.path))
+            keys[parent(file.path)] = key
+            hash[key] = []
+          end
+
+          hash[key] << file
+          key << file
+        end
+        hash.sort_by { |j| j[0].title }.to_h
+      end
+
+      # return the difference of getAired and getWatched
+      def unwatched
+        to_h(indexed.reject { |_f, a| a.watched? }.values)
+      end
+
+      # return an AnimeFile array of all mkvs in any dir specified in
+      # $pref["dirs"]
+      def items
+        to_h(indexed.values)
+      end
+
+      def log_watched(file)
+        file = Zashoku.conf.parse_dir(Zashoku.WATCH_LOG_TAG('watch_log'))
+        open(file, 'a') do |f|
+          f.puts "#{`date`.chomp} ./#{File.basename(file)} #{WATCH_LOG_TAG}"
+        end
+      end
+
+      def watched!(file)
+        return if indexed[file].watched?
+        indexed[file].watched!
+        changed!('items')
+        @indexer.update_avs(file)
+      end
+
+      def recently_watched
+        indexed.map { |k, v| { v.watched_on => k } if v.watched? }.compact
+      end
+
+      def unwatch(path = nil)
+        path =
+          if indexed[path]&.watched?
+            path
+          elsif !path
+            r = recently_watched
+            r.empty? ? nil : r.sort_by { |h| h.keys.first }.reverse[0].values[0]
+          else
+            nil
+          end
+
+        return unless path
+        indexed[path].unwatch
+        changed!('items')
+        @indexer.update_avs(path)
+      end
+
+      def watch(file)
+        Zashoku.command(mod: 'mpv', meth: :play, args: file)
+      end
+
+      def watch_list(files)
+        File.open(PLAYLIST, 'w') { |f| files.each { |i| f.puts i.path } }
+
+        Zashoku.command(mod: 'mpv', meth: :play, args: PLAYLIST)
+      end
+
+      def save
+        Zashoku.conf.set(['local_anime'], Util.encode_object(indexed))
+      end
+
+      def load
+        raw = Zashoku.conf.get(['local_anime'])
+        @indexer.indexed =
+          raw.class == String ? Util.decode_object(raw) : {}
+      end
+    end
+  end
+end