ehbrs-tools 0.3.1 → 0.5.0

data/lib/ehbrs/vg/wii/game_file.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/custom_format'
+require 'ehbrs/vg/wii/wit/parsers/dump'
+require 'ehbrs/vg/wii/wit/path'
+require 'pathname'
+
+module Ehbrs
+  module Vg
+    module Wii
+      class GameFile < ::Pathname
+        enable_simple_cache
+
+        FORMAT = ::EacRubyUtils::CustomFormat.new(
+          b: :basename,
+          d: :dirname,
+          e: :extname,
+          i: :id6,
+          n: :disc_name,
+          t: :database_title,
+          T: :disc_type
+        )
+
+        def database_title
+          properties.fetch('DB title')
+        end
+
+        def disc_name
+          properties.fetch('Disc name')
+        end
+
+        def disc_type
+          properties.fetch('File & disc type/type')
+        end
+
+        def format(string)
+          FORMAT.format(string).with(self)
+        end
+
+        def id6
+          properties.fetch('Disc & part IDs/disc')
+        end
+
+        def valid?
+          properties.present?
+        end
+
+        def wit_path
+          ::Ehbrs::Vg::Wii::Wit::Path.new(disc_type, self)
+        end
+
+        private
+
+        def properties_uncached
+          r = ::Ehbrs::Executables.wit.command.append(['dump', to_s]).execute
+          return nil unless r.fetch(:exit_code).zero?
+
+          ::Ehbrs::Vg::Wii::Wit::Parsers::Dump.new(r.fetch(:stdout)).properties
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/vg/wii/wit.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Ehbrs
+  module Vg
+    module Wii
+      module Wit
+        require_sub __FILE__
+      end
+    end
+  end
+end

data/lib/ehbrs/vg/wii/wit/image_format.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs/executables'
+require 'ehbrs/vg/wii/wit/parsers/info'
+
+module Ehbrs
+  module Vg
+    module Wii
+      module Wit
+        class ImageFormat
+          class << self
+            SECTION_NAME_PATTERN = /\A#{::Regexp.quote('IMAGE-FORMAT:')}(.+)\z/.freeze
+
+            enable_simple_cache
+
+            def by_name(name)
+              all.find { |i| i.name.downcase == name.to_s.downcase } ||
+                raise(::ArgumentError, "Image not found with name \"#{name.to_s.downcase}\"" \
+                  " (Available: #{all.map(&:name).join(', ')})")
+            end
+
+            private
+
+            def all_uncached
+              ::Ehbrs::Vg::Wii::Wit::Parsers::Info.new(info_output).images.map do |_label, data|
+                new(
+                  *%w[name info option].map { |k| data.fetch(k) },
+                  *%w[extensions attributes].map { |k| data.fetch(k).to_s.split(/\s+/) }
+                )
+              end
+            end
+
+            def info_output
+              ::Ehbrs::Executables.wit.command
+                                  .append(%w[info image-format --sections])
+                                  .execute!
+            end
+          end
+
+          common_constructor :name, :description, :option, :extensions, :attributes
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/vg/wii/wit/parsers/dump.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Ehbrs
+  module Vg
+    module Wii
+      module Wit
+        module Parsers
+          class Dump
+            enable_simple_cache
+            common_constructor :output
+
+            FILE_DISC_TYPE_PATTERN = %r{\A(\S+)/(\S+)\s+&\s+(\S+)\z}.freeze
+
+            private
+
+            def properties_uncached
+              r = {}
+              output.each_line do |line|
+                dump_output_line_to_hash(line).if_present { |v| r.merge!(v) }
+              end
+              r
+            end
+
+            def dump_output_line_to_hash(line)
+              m = /\A\s*([^:]+):\s+(.+)\z/.match(line.strip)
+              return nil unless m
+
+              parse_attribute(m[1].strip, m[2].strip)
+            end
+
+            def line_method_parser(label)
+              "parse_#{label}".parameterize.underscore
+            end
+
+            def parse_attribute(label, value)
+              method = line_method_parser(label)
+              return { label => value } unless respond_to?(method, true)
+
+              send(method, value).map { |k, v| ["#{label}/#{k}", v] }.to_h
+            end
+
+            def parse_file_disc_type(value)
+              FILE_DISC_TYPE_PATTERN
+                .match(value)
+                .if_present { |m| { type: m[1], platform_acronym: m[2], platform_name: m[3] } }
+                .if_blank { raise "\"#{FILE_DISC_TYPE_PATTERN}\" does not match \"#{value}\"" }
+            end
+
+            def parse_disc_part_ids(value)
+              value.split(',').map(&:strip).map do |v|
+                r = v.split('=')
+                [r[0].strip, r[1].strip]
+              end.to_h
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/vg/wii/wit/parsers/info.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'ehbrs/executables'
+require 'fileutils'
+require 'inifile'
+
+module Ehbrs
+  module Vg
+    module Wii
+      module Wit
+        module Parsers
+          class Info
+            SECTION_NAME_PATTERN = /\A#{::Regexp.quote('IMAGE-FORMAT:')}(.+)\z/.freeze
+
+            enable_simple_cache
+            common_constructor :output
+
+            private
+
+            def images_uncached
+              ini = ::IniFile.new(content: output)
+              r = {}
+              ini.sections.each do |section_name|
+                image_section_name = parse_image_section_name(section_name)
+                r[image_section_name] = ini[section_name] if image_section_name.present?
+              end
+              r
+            end
+
+            def parse_image_section_name(section_name)
+              SECTION_NAME_PATTERN.match(section_name).if_present { |m| m[1] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/vg/wii/wit/path.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Ehbrs
+  module Vg
+    module Wii
+      module Wit
+        class Path
+          WIT_PATH_PATTERN = /\A(?:([a-z0-9]+):)?(.+)\z/i.freeze
+
+          class << self
+            def assert(source)
+              source = parse(source) unless source.is_a?(self)
+              source
+            end
+
+            def parse(path)
+              WIT_PATH_PATTERN
+                .match(path)
+                .if_present { |m| new(m[1], m[2]) }
+                .if_blank { raise "\"#{WIT_PATH_PATTERN}\" does not match \"#{path}\"" }
+            end
+          end
+
+          common_constructor :type, :path do
+            self.type = type.to_s.upcase
+            self.path = ::Pathname.new(path.to_s)
+          end
+
+          def change?(other)
+            type_change?(other) || path_change?(other)
+          end
+
+          def path_change?(other)
+            path.expand_path.to_s != other.path.expand_path.to_s
+          end
+
+          def to_s
+            r = path.to_s
+            r = "#{type.to_s.upcase}:#{r}" if type.present?
+            r
+          end
+
+          def type_change?(other)
+            return false if other.type.blank?
+            return true if type.blank?
+
+            type != other.type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ehbrs/videos/unsupported/search.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/filesystem_traverser'
+require 'eac_ruby_utils/fs/traversable'
 require 'eac_ruby_utils/core_ext'
 require 'ehbrs/videos/unsupported/file'
 
@@ -8,7 +8,9 @@ module Ehbrs
   module Videos
     module Unsupported
       class Search
+        include ::EacRubyUtils::Fs::Traversable
         enable_console_speaker
+        enable_simple_cache
 
         VALID_EXTENSIONS = %w[.avi .mp4 .mkv .m4v].freeze
 
@@ -21,22 +23,23 @@ module Ehbrs
           run
         end
 
+        def traverser_recursive
+          true
+        end
+
+        def traverser_sort
+          true
+        end
+
         private
 
         def run
           start_banner
-          traverser = ::EacRubyUtils::FilesystemTraverser.new
-          traverser.recursive = true
-          traverser.check_file = method(:check_file)
-          traverser.check_path(@root)
+          traverser_check_path(@root)
           end_banner
         end
 
-        def recursive?
-          true
-        end
-
-        def check_file(file)
+        def traverser_check_file(file)
           @files += 1
           check_video(file) if video_file?(file)
         end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils.rb

@@ -1,24 +1,6 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  require 'eac_ruby_utils/arguments_consumer'
-  require 'eac_ruby_utils/by_reference'
-  require 'eac_ruby_utils/configs'
-  require 'eac_ruby_utils/console'
-  require 'eac_ruby_utils/contextualizable'
-  require 'eac_ruby_utils/core_ext'
-  require 'eac_ruby_utils/envs'
-  require 'eac_ruby_utils/filesystem_cache'
-  require 'eac_ruby_utils/filesystem_traverser'
-  require 'eac_ruby_utils/fs_cache'
-  require 'eac_ruby_utils/listable'
-  require 'eac_ruby_utils/options_consumer'
-  require 'eac_ruby_utils/settings_provider'
-  require 'eac_ruby_utils/patch'
-  require 'eac_ruby_utils/patches'
-  require 'eac_ruby_utils/paths_hash'
   require 'eac_ruby_utils/require_sub'
-  require 'eac_ruby_utils/rspec'
-  require 'eac_ruby_utils/simple_cache'
-  require 'eac_ruby_utils/yaml'
+  ::EacRubyUtils.require_sub __FILE__
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/by_reference.rb

@@ -7,7 +7,7 @@ module EacRubyUtils
     end
 
     def method_missing(method_name, *arguments, &block)
-      return object.send(method_name, *arguments) if object.respond_to?(method_name)
+      return object.send(method_name, *arguments, &block) if object.respond_to?(method_name)
 
       super
     end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/custom_format.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  # A formatter like [String.sprintf].
+  class CustomFormat
+    TYPE_PATTERN = /[a-zA-Z]/.freeze
+    SEQUENCE_PATTERN = /(?<!%)%(#{TYPE_PATTERN})/.freeze
+
+    attr_reader :mapping
+
+    def initialize(mapping)
+      @mapping = mapping.map { |k, v| [k.to_sym, v] }.to_h.freeze
+    end
+
+    def format(string)
+      ::EacRubyUtils::CustomFormat::String.new(self, string)
+    end
+
+    class String
+      attr_reader :format, :string
+
+      def initialize(format, string)
+        @format = format
+        @string = string
+      end
+
+      def mapping
+        @mapping ||= format.mapping.select do |k, _v|
+          sequences.include?(k)
+        end
+      end
+
+      def sequences
+        @sequences ||= string.scan(SEQUENCE_PATTERN).map(&:first).uniq.map(&:to_sym)
+      end
+
+      def source_object_value(object, method)
+        return object.send(method) if object.respond_to?(method)
+        return object[method] if object.respond_to?('[]')
+
+        raise ::ArgumentError, "Methods \"#{method}\" or \"[]\" not found for #{object}"
+      end
+
+      def with(source_object)
+        r = string
+        mapping.each do |key, method|
+          r = r.gsub(/%#{::Regexp.quote(key)}/, source_object_value(source_object, method).to_s)
+        end
+        r.gsub('%%', '%')
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/command.rb

@@ -4,6 +4,7 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'eac_ruby_utils/console/speaker'
 require 'eac_ruby_utils/envs/command/extra_options'
 require 'eac_ruby_utils/envs/process'
+require 'eac_ruby_utils/envs/spawn'
 require 'pp'
 require 'shellwords'
 
@@ -69,6 +70,12 @@ module EacRubyUtils
         r
       end
 
+      def spawn(options = {})
+        c = command(options)
+        puts "SPAWN: #{c}".light_red if debug?
+        ::EacRubyUtils::Envs::Spawn.new(c)
+      end
+
       def system!(options = {})
         return if system(options)