ffprober 0.4.6 → 1.0

data/lib/ffprober/ffmpeg/version.rb

@@ -1,37 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
 module Ffprober
   module Ffmpeg
     class Version
-      VERSION_REGEX = /^(ffprobe|avprobe|ffmpeg) version (\d+)\.?(\d+)\.?(\d+)*/
-      NIGHTLY_REGEX = /^(ffprobe|avprobe|ffmpeg) version (N|git)-/
+      extend T::Sig
+
+      sig { params(ffprobe_exec: T.any(Ffprober::Ffmpeg::Exec, T.untyped)).void }
+      def initialize(ffprobe_exec = Ffprober::Ffmpeg::Exec.new)
+        @ffprobe_exec = ffprobe_exec
+        @version = T.let(nil, T.nilable(Gem::Version))
+        @parse_version = T.let(nil, T.nilable(T::Array[Integer]))
+      end
 
+      VERSION_REGEX = T.let(/^(ffprobe|avprobe|ffmpeg) version (\d+)\.?(\d+)\.?(\d+)*/.freeze, Regexp)
+      NIGHTLY_REGEX = T.let(/^(ffprobe|avprobe|ffmpeg) version (N|git)-/.freeze, Regexp)
+      VERSION_FALLBACK = T.let([0, 0, 0].freeze, T::Array[Integer])
+
+      sig { returns(Gem::Version) }
       def version
-        @version ||= Gem::Version.new(parse_version.join("."))
+        @version ||= Gem::Version.new(parse_version.join('.'))
       end
 
+      sig { returns(T::Boolean) }
       def nightly?
-        !!(ffprobe_version_output =~ NIGHTLY_REGEX)
+        !(ffprobe_version_output =~ NIGHTLY_REGEX).nil?
       end
 
       private
 
+      sig { returns(T::Array[Integer]) }
       def parse_version
-        @parse_version ||= begin
-          ffprobe_version_output.match(VERSION_REGEX) do |match|
-            [match[2].to_i, match[3].to_i, match[4].to_i]
-          end || [0, 0, 0]
-        end
-      end
+        return @parse_version if @parse_version
 
-      def ffprobe_version_output
-        @ffprobe_version_output ||= ffprobe_finder.path.nil? ? "" : `#{ffprobe_finder.path} -version`
+        match_data = ffprobe_version_output.match(VERSION_REGEX)
+
+        @parse_version = if match_data
+                           [match_data[2].to_i, match_data[3].to_i, match_data[4].to_i]
+                         else
+                           VERSION_FALLBACK
+                         end
+
+        @parse_version
       end
 
-      def ffprobe_finder
-        Ffprober::Ffmpeg::Finder
+      sig { returns(String) }
+      def ffprobe_version_output
+        @ffprobe_exec.ffprobe_version_output
       end
 
+      sig { returns(String) }
       def to_s
-        parse_version.join(".")
+        parse_version.join('.')
       end
     end
   end

data/lib/ffprober/ffmpeg/version_validator.rb

@@ -1,27 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
 module Ffprober
   module Ffmpeg
     class VersionValidator
-      MIN_VERSION = Gem::Version.new("0.9.0")
-      MAX_VERSION = Gem::Version.new("2.8.1")
+      extend T::Sig
+
+      MIN_VERSION = T.let(Gem::Version.new('0.9.0'), Gem::Version)
 
+      sig { params(ffmpeg_version: Ffprober::Ffmpeg::Version).void }
       def initialize(ffmpeg_version)
         @ffmpeg_version = ffmpeg_version
       end
 
+      sig { returns(T::Boolean) }
       def valid?
         ffmpeg_version.nightly? || version_requirement_statisfied?
       end
 
       private
 
+      sig { returns(T::Boolean) }
       def version_requirement_statisfied?
-        version = ffmpeg_version.version
-        (MIN_VERSION <= version && version <= MAX_VERSION)
+        MIN_VERSION <= ffmpeg_version.version
       end
 
-      def ffmpeg_version
-        @ffmpeg_version
-      end
+      sig { returns(Ffprober::Ffmpeg::Version) }
+      attr_reader :ffmpeg_version
     end
   end
 end

data/lib/ffprober/ffprobe_version.rb

@@ -1,21 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
 module Ffprober
   class FfprobeVersion
+    extend T::Sig
+
+    sig { returns(T::Boolean) }
+    def self.invalid?
+      !new.valid?
+    end
+
+    sig { returns(T::Boolean) }
     def self.valid?
       new.valid?
+    rescue NoFfprobeFound
+      false
     end
 
+    sig { returns(T::Boolean) }
     def valid?
       validator.valid?
     end
 
-    private
-
-    def validator
-      Ffprober::Ffmpeg::VersionValidator.new(version)
+    sig { returns(Ffprober::Ffmpeg::Version) }
+    def self.version
+      new.version
     end
 
+    sig { returns(Ffprober::Ffmpeg::Version) }
     def version
       Ffprober::Ffmpeg::Version.new
     end
+
+    private
+
+    sig { returns(Ffprober::Ffmpeg::VersionValidator) }
+    def validator
+      Ffprober::Ffmpeg::VersionValidator.new(version)
+    end
   end
 end

data/lib/ffprober/format.rb

@@ -1,3 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
 module Ffprober
   class Format
     include Ffprober::DynamicInitializer

data/lib/ffprober/parser.rb

@@ -1,20 +1,40 @@
-require "shellwords"
+# typed: strict
+# frozen_string_literal: true
 
 module Ffprober
   class Parser
+    extend T::Sig
+
+    sig { params(file_to_parse: String).returns(Ffprober::Wrapper) }
     def self.from_file(file_to_parse)
-      unless FfprobeVersion.valid?
-        fail ArgumentError.new("no or unsupported ffprobe version found. (version: #{Ffprober::Ffmpeg::Version.new})")
-      end
+      check_version
+
+      raise EmptyInput, file_to_parse if File.zero?(file_to_parse)
 
-      file_parser = Ffprober::Parsers::File.new(file_to_parse)
+      file_parser = Parsers::FileParser.new(file_to_parse)
       json_parser = file_parser.load
       Ffprober::Wrapper.new(json_parser.json)
     end
 
+    sig { params(url_to_parse: T.untyped).returns(Ffprober::Wrapper) }
+    def self.from_url(url_to_parse)
+      check_version
+
+      url_parser = Parsers::UrlParser.new(url_to_parse)
+      json_parser = url_parser.load
+      Ffprober::Wrapper.new(json_parser.json)
+    end
+
+    sig { params(json_to_parse: T.untyped).returns(Ffprober::Wrapper) }
     def self.from_json(json_to_parse)
-      json_parser = Ffprober::Parsers::Json.new(json_to_parse)
+      json_parser = Parsers::JsonParser.new(json_to_parse)
       Ffprober::Wrapper.new(json_parser.json)
     end
+
+    sig { returns(NilClass) }
+    def self.check_version
+      msg = "found version: #{FfprobeVersion.version}"
+      raise UnsupportedVersion, msg if FfprobeVersion.invalid?
+    end
   end
 end

data/lib/ffprober/parsers/file.rb

@@ -1,33 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
 module Ffprober
   module Parsers
-    class File
-      def initialize(file_to_parse)
-        unless ::File.exist?(file_to_parse)
-          fail ArgumentError.new("File not found #{file_to_parse}")
-        end
-
-        @file_to_parse = file_to_parse
-      end
-
-      def load
-        json_output = `#{ffprobe_finder.path} #{options} #{Shellwords.escape(@file_to_parse)}`
-        Ffprober::Parsers::Json.new(json_output)
-      end
-
-      private
+    class FileParser
+      extend T::Sig
 
-      def options
-        options = "-v quiet -print_format json -show_format -show_streams"
-        options << " -show_chapters" if ffprobe_version.version >= Gem::Version.new("2.0.0")
-        options
+      sig do
+        params(
+          file_to_parse: String,
+          exec: T.any(Ffprober::Ffmpeg::Exec, T.untyped)
+        ).void
       end
+      def initialize(file_to_parse, exec = Ffprober::Ffmpeg::Exec.new)
+        raise ArgumentError, "File not found #{file_to_parse}" unless ::File.exist?(file_to_parse)
 
-      def ffprobe_version
-        Ffprober::Ffmpeg::Version.new
+        @file_to_parse = file_to_parse
+        @exec = exec
       end
 
-      def ffprobe_finder
-        Ffprober::Ffmpeg::Finder
+      sig { returns(Ffprober::Parsers::JsonParser) }
+      def load
+        JsonParser.new(@exec.json_output(@file_to_parse))
       end
     end
   end

data/lib/ffprober/parsers/json.rb

@@ -1,8 +1,12 @@
+# typed: true
+# frozen_string_literal: true
+
 module Ffprober
   module Parsers
-    class Json
+    class JsonParser
       def initialize(json_to_parse)
-        fail ArgumentError.new("No JSON input data") if json_to_parse.nil?
+        raise ArgumentError, 'No JSON input data' if json_to_parse.nil?
+
         @json_to_parse = json_to_parse
       end
 

data/lib/ffprober/parsers/url.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'uri'
+
+module Ffprober
+  module Parsers
+    class UrlParser
+      VALID_URI_REGEX = /\A#{URI::DEFAULT_PARSER.make_regexp}\z/.freeze
+
+      def initialize(url_to_parse, exec = Ffprober::Ffmpeg::Exec.new)
+        raise ArgumentError, "#{url_to_parse} is not a valid URL" unless valid_url?(url_to_parse)
+
+        @url_to_parse = url_to_parse
+        @exec = exec
+      end
+
+      def load
+        JsonParser.new(@exec.json_output(@url_to_parse))
+      end
+
+      private
+
+      def valid_url?(url)
+        url.gsub(' ', '%20') =~ VALID_URI_REGEX
+      end
+    end
+  end
+end

data/lib/ffprober/stream.rb

@@ -1,3 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
 module Ffprober
   class Stream
     include Ffprober::DynamicInitializer

data/lib/ffprober/subtitle_stream.rb

@@ -1,3 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
 module Ffprober
   class SubtitleStream < Stream
   end

data/lib/ffprober/version.rb

@@ -1,3 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
 module Ffprober
-  VERSION = "0.4.6"
+  VERSION = '1.0'
 end

data/lib/ffprober/video_stream.rb

@@ -1,3 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
 module Ffprober
   class VideoStream < Stream
   end

data/lib/ffprober/wrapper.rb

@@ -1,31 +1,61 @@
+# typed: true
+# frozen_string_literal: true
+
 module Ffprober
   class Wrapper
+    extend T::Sig
+
+    attr_reader :json
+
+    sig { returns(Ffprober::Format) }
+    attr_reader :format
+
+    # rubocop:disable Metrics/AbcSize
+    sig { params(json: T::Hash[T.untyped, T.untyped]).void }
     def initialize(json)
-      @json = json
-    end
+      raise FfprobeError, json[:error] if json[:error]
 
-    def format
-      @format ||= Ffprober::Format.new(json[:format])
+      @json = json
+      @format = T.let(Format.new(json[:format]), Ffprober::Format)
+      @video_streams = T.let(nil, T.nilable(T::Array[Ffprober::VideoStream]))
+      @audio_streams = T.let(nil, T.nilable(T::Array[Ffprober::AudioStream]))
+      @data_streams = T.let(nil, T.nilable(T::Array[Ffprober::DataStream]))
+      @subtitle_streams = T.let(nil, T.nilable(T::Array[Ffprober::SubtitleStream]))
+      @chapters = T.let(nil, T.nilable(T::Array[Ffprober::Chapter]))
     end
+    # rubocop:enable Metrics/AbcSize
 
+    sig { returns(T::Array[Ffprober::VideoStream]) }
     def video_streams
-      @video_streams ||= stream_by_codec("video").map { |data| Ffprober::VideoStream.new(data) }
+      @video_streams ||= stream_by_codec('video').map do |data|
+        VideoStream.new(data)
+      end
     end
 
+    sig { returns(T::Array[Ffprober::AudioStream]) }
     def audio_streams
-      @audio_streams ||= stream_by_codec("audio").map { |data| Ffprober::AudioStream.new(data) }
+      @audio_streams ||= stream_by_codec('audio').map do |data|
+        AudioStream.new(data)
+      end
     end
 
+    sig { returns(T::Array[Ffprober::DataStream]) }
     def data_streams
-      @data_streams ||= stream_by_codec("data").map { |data| Ffprober::DataStream.new(data) }
+      @data_streams ||= stream_by_codec('data').map do |data|
+        DataStream.new(data)
+      end
     end
 
+    sig { returns(T::Array[Ffprober::Chapter]) }
     def chapters
-      @chapters ||= json[:chapters].map { |chapter| Ffprober::Chapter.new(chapter) }
+      @chapters ||= json[:chapters].map { |chapter| Chapter.new(chapter) }
     end
 
+    sig { returns(T::Array[Ffprober::SubtitleStream]) }
     def subtitle_streams
-      @subtitle_streams ||= stream_by_codec("subtitle").map { |stream| Ffprober::SubtitleStream.new(stream) }
+      @subtitle_streams ||= stream_by_codec('subtitle').map do |stream|
+        SubtitleStream.new(stream)
+      end
     end
 
     private
@@ -37,9 +67,5 @@ module Ffprober
     def streams
       json[:streams]
     end
-
-    def json
-      @json
-    end
   end
 end

metadata

@@ -1,43 +1,127 @@
 --- !ruby/object:Gem::Specification
 name: ffprober
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: '1.0'
 platform: ruby
 authors:
 - beanieboi
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2015-11-12 00:00:00.000000000 Z
+date: 2020-11-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '1'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-packaging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0.19'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0.19'
 description: a Ruby wrapper for ffprobe
 email:
 - beanie@benle.de
@@ -45,26 +129,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- ".ruby-version"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
 - Changes.md
 - Gemfile
 - LICENSE
 - README.md
-- Rakefile
-- examples/from_file.rb
 - ffprober.gemspec
 - lib/ffprober.rb
 - lib/ffprober/audio_stream.rb
 - lib/ffprober/chapter.rb
 - lib/ffprober/data_stream.rb
 - lib/ffprober/dynamic_initializer.rb
-- lib/ffprober/errors.rb
+- lib/ffprober/ffmpeg/exec.rb
 - lib/ffprober/ffmpeg/finder.rb
 - lib/ffprober/ffmpeg/version.rb
 - lib/ffprober/ffmpeg/version_validator.rb
@@ -73,6 +150,7 @@ files:
 - lib/ffprober/parser.rb
 - lib/ffprober/parsers/file.rb
 - lib/ffprober/parsers/json.rb
+- lib/ffprober/parsers/url.rb
 - lib/ffprober/stream.rb
 - lib/ffprober/subtitle_stream.rb
 - lib/ffprober/version.rb
@@ -82,13 +160,13 @@ homepage: https://github.com/beanieboi/ffprober
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -97,10 +175,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: a Ruby wrapper for ffprobe (part of ffmpeg)
 test_files: []
-has_rdoc: