mediakit 0.0.6 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7435ac359f8e6bd85841a8e6d9aa40b4f9984250
-  data.tar.gz: f73d0dcf7d9b077eaf702b46844a5f255ca5f94f
+  metadata.gz: 575608c79c6aefb71acac345ee3216f2ce8291d6
+  data.tar.gz: 0fdf5b24e11a8b2f9218a1e63b3b9473ca2a0884
 SHA512:
-  metadata.gz: 991f5cf8db3564fe37f20a61601318bbf120cf0e66100402850adac03b4cc429fb78ed09ce67cca7e02cfad5c53f3c3da504806c39fb75217e10ffe11a48b520
-  data.tar.gz: 66356ffb1faccd86054c39f5680356bc3fadf9e606e3054dd2eb4680e9ebf2a36fa65ff7f8bee8bc69887d31ec6824e9c3adbf312f82c86c032f81e4d07570d4
+  metadata.gz: f79fbba7a247c1fc51b31c906e96b98cc28331e7a6cd68e6eb76a93dba763384966c0f2ec1fab2afde66da7e5d71398d5dd6a4527cedc135fcb190391e44e60e
+  data.tar.gz: 24e596222c852222c8a1fd5366b2225c1e0360524975fb4f7539ef2c3ed79bd520f4f83103bdc9abf15bf55aff7670e490aaa250a8b2186b0a2573d9f2ac2634

data/README.md

@@ -1,6 +1,6 @@
 # Mediakit
 
-[![Build Status](https://travis-ci.org/ainame/mediakit.svg)](https://travis-ci.org/ainame/mediakit)
+[![Circle CI](https://circleci.com/gh/ainame/mediakit/tree/master.svg?style=svg)](https://circleci.com/gh/ainame/mediakit/tree/master)
 
 mediakit is the libraries for ffmpeg and sox backed media manipulation something.
 I've design this library for following purpose.
@@ -12,11 +12,14 @@ I've design this library for following purpose.
 
 Currently you can use low-level inteface of mediakit!
 
-* [x] low-level interface for ffmpeg
-* [*] low-level interface's basic feature
-  * [*] nice setting
-  * [*] read timeout setting
-  * [*] shell escape for security
+* [ ] low-level interface
+  * [x] execute command for ffmpeg
+  * [x] unit testing supports (fake driver)
+  * [x] nice command setting
+  * [x] read timeout setting
+  * [x] shell escape for security
+  * [ ] logger support
+  * [ ] ffmpeg instropection (support formats, codecs, encoders, decoders..)
 * [ ] high-level interface for ffmpeg
 * [ ] low-level interface for sox
 * [ ] high-level interface for sox
@@ -53,7 +56,7 @@ This is a little bore interface for constructing options,
 but can pass certain it.
 
 ```rb
-driver = Mediakit::Drivers::FFmpeg.new(timeout: 30, nice: 0)
+driver = Mediakit::Drivers::FFmpeg.new()
 ffmpeg = Mediakit::FFmpeg.new(driver)
 
 options = Mediakit::FFmpeg::Options.new(
@@ -75,9 +78,52 @@ options = Mediakit::FFmpeg::Options.new(
   ),
 )
 puts "$ #{ffmpeg.command(options)}"
-puts ffmpeg.run(options)
+puts ffmpeg.run(options, timeout: 30, nice: 0)
 ```
 
+#### Drivers
+
+mediakit has two drivers for execute command. First, Popen Driver is implemented by Open3#popen3 that is main driver. Second, FakeDriver is the fake object for unit-testing.
+
+##### Driver Usage
+
+instatiate
+
+```ruby
+default_driver = Mediakit::Drivers::FFmpeg.new # default is popen driver
+driver = Mediakit::Drivers::FFmpeg.new(:popen) # explicitly use popen driver
+fake_driver = Mediakit::Drivers::FFmpeg.new(:fake) # fake driver
+```
+
+testing
+
+```ruby
+# setup
+fake_driver = Mediakit::Drivers::FFmpeg.new(:fake)
+fake_driver.output = 'output'
+fake_driver.error_output = 'error_output'
+fake_driver.exit_status = true
+ffmpeg = Mediakit::FFmpeg.new(fake_driver)
+
+# excursie
+options = Mediakit::FFmpeg::Options.new(
+  Mediakit::FFmpeg::Options::GlobalOption.new(
+    'version' => true,
+  ),
+}
+out, err, exit_status = ffmpeg.run(options)
+
+# verify
+assert_equal(fake_driver.last_command, 'ffmpeg -version')
+assert_equal(out, 'output')
+assert_equal(err, 'error_output')
+assert_equal(exit_status, true)
+
+# teardown
+fake_driver.reset
+```
+
+
 ### High Level Interface
 
 TBD

data/circle.yml

@@ -0,0 +1,38 @@
+machine:
+  ruby:
+    version: 2.2.2
+dependencies:
+  cache_directories:
+    - "~/ffmpeg_build"
+  pre:
+    - >
+        FFMPEG_DIR="$HOME/ffmpeg_build";
+        FFMPEG_VERSION="2.6.3";
+        if [ ! -d "$FFMPEG_DIR" ]; then
+        mkdir "$FFMPEG_DIR" &&
+        cd "$FFMPEG_DIR" &&
+        mkdir ffmpeg &&
+        mkdir fdkaac &&
+        mkdir src &&
+        cd src &&
+        wget https://downloads.sourceforge.net/project/opencore-amr/fdk-aac/fdk-aac-0.1.4.tar.gz &&
+        tar xfz fdk-aac-0.1.4.tar.gz &&
+        cd fdk-aac-0.1.4 &&
+        autoreconf -fvi &&
+        ./configure --prefix="$FFMPEG_DIR/fdkaac" --disable-shared &&
+        sudo make install &&
+        cd "$FFMPEG_DIR" &&
+        wget "http://ffmpeg.org/releases/ffmpeg-$FFMPEG_VERSION.tar.bz2" &&
+        tar -xjpf "ffmpeg-$FFMPEG_VERSION.tar.bz2" &&
+        cd "ffmpeg-$FFMPEG_VERSION" &&
+        ./configure
+        --extra-cflags="-I$FFMPEG_DIR/fdkaac/include"
+        --extra-ldflags="-L$FFMPEG_DIR/fdkaac/lib"
+        --enable-gpl
+        --enable-nonfree
+        --enable-libfaac
+        --enable-libmp3lame
+        --enable-libfdk-aac &&
+        sudo make install;
+        fi;
+        cd "$FFMPEG_DIR/ffmpeg-$FFMPEG_VERSION" && sudo make install

data/lib/mediakit/drivers.rb

@@ -30,12 +30,12 @@ module Mediakit
       # @overload run(*args, options)
       #   @param [Array] args arguments for command
       #   @option [Hash] options run options
-      # @return [Bool] stdout output
+      # @return [String] stdout output
       def run(*args)
-        options = (args.last && args.last.kind_of?(Hash)) ? args.pop : {}
+        options, rest_args = parse_options(args.dup)
+        runner = Mediakit::Utils::ProcessRunner.new(options)
         begin
-          runner = Mediakit::Utils::ProcessRunner.new(options)
-          stdout, stderr, exit_status = runner.run(bin, *args)
+          stdout, stderr, exit_status = runner.run(bin, *rest_args)
           raise(FailError, stderr) unless exit_status
           stdout
         rescue Mediakit::Utils::ProcessRunner::CommandNotFoundError => e
@@ -51,18 +51,35 @@ module Mediakit
       #   @param args [Array] arguments for command
       # @return [String] command
       def command(*args)
-        escaped_args = Mediakit::Utils::ShellEscape.escape(*args)
-        "#{bin} #{escaped_args}"
+        options, rest_args = parse_options(args.dup)
+        runner = Mediakit::Utils::ProcessRunner.new(options)
+        runner.build_command(bin, *rest_args)
+      end
+
+      def parse_options(args)
+        options = (args.last && args.last.kind_of?(Hash)) ? args.pop : {}
+        [options, args]
       end
     end
 
-    class FakeDriver < Base
-      def run(args = '')
-        true
+    class FakeDriver < PopenDriver
+      attr_accessor(:last_command, :output, :error_output, :exit_status)
+
+      # fake driver for testing
+      #
+      # @overload run(args)
+      #   @param [String] args string argument for command
+      # @overload run(*args, options)
+      #   @param [Array] args arguments for command
+      #   @option [Hash] options run options
+      # @return [String] stdout output
+      def run(*args)
+        @last_command = command(*args)
+        [(output || ''), (error_output || ''), (exit_status || true)]
       end
 
-      def command(args = '')
-        bin + args
+      def reset
+        @last_command, @output, @error_output, @exit_status = nil
       end
     end
 

data/lib/mediakit/ffmpeg.rb

@@ -1,34 +1,44 @@
 require 'mediakit/drivers'
 require 'mediakit/ffmpeg/options'
-require 'mediakit/ffmpeg/introspection'
 
 module Mediakit
   class FFmpeg
-    include Introspection
     class FFmpegError < StandardError; end
 
+    attr_accessor(:codecs, :formats, :decoders, :encoders)
 
     def initialize(driver)
       @driver = driver
+      @codecs, @formats, @decoders, @encoders = [], [], [], []
     end
 
     # execute runners with options object
     #
     # @param [Mediakit::Runners::FFmpeg::Options] options options to create CLI argument
-    def run(options)
+    def run(options, driver_options = {})
       args = options.compose
-      execute(args)
+      @driver.run(args, driver_options)
     end
 
-    def command(options)
+    def command(options, driver_options = {})
       args = options.compose
-      @driver.command(args)
+      @driver.command(args, driver_options)
     end
 
-    private
+    Codec = Struct.new(:name, :desc, :type, :decode, :encode, :decoders, :encoders, :intra_frame, :lossy, :lossless) do |klass|
+      def to_s; name; end
+    end
+
+    Format = Struct.new(:name, :desc, :demuxing, :muxing) do |klass|
+      def to_s; name; end
+    end
+
+    Encoder = Struct.new(:name, :desc, :type, :frame_level, :slice_level, :experimental, :horizon_band, :direct_rendering_method) do |klass|
+      def to_s; name; end
+    end
 
-    def execute(args = '')
-      @driver.run(args)
+    Decoder = Struct.new(:name, :desc, :type, :frame_level, :slice_level, :experimental, :horizon_band, :direct_rendering_method) do |klass|
+      def to_s; name; end
     end
   end
 end

data/lib/mediakit/initializers/ffmpeg.rb

@@ -0,0 +1,211 @@
+require 'active_support/core_ext/string/inflections'
+
+module Mediakit
+  module Initializers
+    class FFmpeg
+      class Base
+        attr_reader :items
+
+        def initialize(command)
+          @command = command
+        end
+
+        def call
+          @command.send(item_type).concat(parse_items)
+        end
+
+        def item_type
+          raise(NotImplementedError)
+        end
+
+        def raw_items
+          raise(NotImplementedError)
+        end
+
+        def create_item(line)
+          raise(NotImplementedError)
+        end
+
+        def parse_items
+          items = []
+          raw_items.each do |line|
+            chomped_text = line.chomp
+            item = create_item(chomped_text)
+            items << item if item
+          end
+          items
+        end
+      end
+
+      class CodecInitializer < Base
+        DELIMITER_FOR_CODECS = "\n -------\n".freeze
+        SUPPORT_PATTERN = /(?<support>(?<decode>[D.])(?<encode>[E.])(?<type>[VAS.])(?<intra_frame>[I.])(?<lossy>[L.])(?<lossless>[S.]))/.freeze
+        DESCRIPTION_PATTERN = /.*?( \(decoders: (?<decoders>.+?) \)| \(encoders: (?<encoders>.+?) \))*/.freeze
+        PATTERN = /\A\s*#{SUPPORT_PATTERN}\s+(?<name>\w+)\s+(?<desc>(#{DESCRIPTION_PATTERN}))\z/.freeze
+
+        def item_type
+          'codecs'
+        end
+
+        def raw_items
+          options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('codecs' => true))
+          output, _, _ = @command.run(options)
+          return [] if output.nil? || output.empty?
+          output.split(DELIMITER_FOR_CODECS)[1].each_line.to_a
+        end
+
+        def create_item(line)
+          match = line.match(PATTERN)
+          if match
+            type = case match[:type]
+                   when "A"
+                     :audio
+                   when "V"
+                     :video
+                   when "S"
+                     :subtitle
+                   else
+                     :unknown
+                   end
+            decode = match[:decode] != '.'
+            encode = match[:encode] != '.'
+            decoders = match[:decoders] ? match[:decoders].split(' ') : (decode ? [match[:name]] : nil)
+            encoders = match[:encoders] ? match[:encoders].split(' ') : (encode ? [match[:name]] : nil)
+            intra_frame = match[:intra_frame] != '.'
+            lossy = match[:lossy] != '.'
+            lossless = match[:lossless] != '.'
+
+            Mediakit::FFmpeg::Codec.new(match[:name], match[:desc], type, decode, encode, decoders, encoders, intra_frame, lossy, lossless)
+          end
+        end
+      end
+
+      class FormatInitializer < Base
+        DELIMITER_FOR_FORMATS = "\n --\n".freeze
+        SUPPORT_PATTERN = /(?<support>(?<demuxing>[D.\s])(?<muxing>[E.\s]))/.freeze
+        PATTERN = /\A\s*#{SUPPORT_PATTERN}\s+(?<name>\w+)\s+(?<desc>.+)\z/.freeze
+
+        def item_type
+          'formats'
+        end
+
+        def raw_items
+          options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('formats' => true))
+          output, _, _ = @command.run(options)
+          return [] if output.nil? || output.empty?
+          output.split(DELIMITER_FOR_FORMATS)[1].each_line.to_a
+        end
+
+        def create_item(line)
+          match = line.match(PATTERN)
+          if match
+            demuxing = match[:demuxing] == 'D'
+            muxing = match[:muxing] == 'E'
+
+            Mediakit::FFmpeg::Format.new(match[:name], match[:desc], demuxing, muxing)
+          end
+        end
+      end
+
+      class DecoderInitializer < Base
+        DELIMITER_FOR_CODER = "\n ------\n".freeze
+        # Encoders:
+        # V..... = Video
+        # A..... = Audio
+        # S..... = Subtitle
+        # .F.... = Frame-level multithreading
+        # ..S... = Slice-level multithreading
+        # ...X.. = Codec is experimental
+        # ....B. = Supports draw_horiz_band
+        # .....D = Supports direct rendering method 1
+        # ------
+        SUPPORT_PATTERN =  /(?<support>(?<type>[VAS.])(?<frame_level>[F.])(?<slice_level>[S.])(?<experimental>[X.])(?<horizon_band>[B.])(?<direct_rendering_method>[D.]))/.freeze
+        PATTERN =  /\A\s*#{SUPPORT_PATTERN}\s+(?<name>\w+)\s+(?<desc>.+)\z/.freeze
+
+        def item_type
+          'decoders'
+        end
+
+        def raw_items
+          options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('decoders' => true))
+          output, _, _ = @command.run(options)
+          return [] if output.nil? || output.empty?
+          output.split(DELIMITER_FOR_CODER)[1].each_line.to_a
+        end
+
+        def create_item(line)
+          match =  line.match(PATTERN)
+          if match
+            type =  case match[:type]
+                    when 'V'
+                      :video
+                    when 'A'
+                      :audio
+                    when 'S'
+                      :subtitle
+                    else
+                      :unknown
+                    end
+            frame_leval =  match[:frame_level] !=  '.'
+            slice_leval =  match[:slice_level] !=  '.'
+            experimental =  match[:experimental] !=  '.'
+            horizon_band =  match[:horizon_band] !=  '.'
+            direct_rendering_method =  match[:direct_rendering_method] !=  '.'
+
+            Mediakit::FFmpeg::Decoder.new(match[:name], match[:desc], type, frame_leval, slice_leval, experimental, horizon_band, direct_rendering_method)
+          end
+        end
+      end
+
+      class EncoderInitializer < Base
+        DELIMITER_FOR_CODER = "\n ------\n".freeze
+        # Encoders:
+        # V..... = Video
+        # A..... = Audio
+        # S..... = Subtitle
+        # .F.... = Frame-level multithreading
+        # ..S... = Slice-level multithreading
+        # ...X.. = Codec is experimental
+        # ....B. = Supports draw_horiz_band
+        # .....D = Supports direct rendering method 1
+        # ------
+        SUPPORT_PATTERN =  /(?<support>(?<type>[VAS.])(?<frame_level>[F.])(?<slice_level>[S.])(?<experimental>[X.])(?<horizon_band>[B.])(?<direct_rendering_method>[D.]))/.freeze
+        PATTERN =  /\A\s*#{SUPPORT_PATTERN}\s+(?<name>\w+)\s+(?<desc>.+)\z/.freeze
+
+        def item_type
+          'encoders'
+        end
+
+        def raw_items
+          options = Mediakit::FFmpeg::Options.new(Mediakit::FFmpeg::Options::GlobalOption.new('encoders' => true))
+          output, _, _ = @command.run(options)
+          return [] if output.nil? || output.empty?
+          output.split(DELIMITER_FOR_CODER)[1].each_line.to_a
+        end
+
+        def create_item(line)
+          match =  line.match(PATTERN)
+          if match
+            type =  case match[:type]
+                    when 'V'
+                      :video
+                    when 'A'
+                      :audio
+                    when 'S'
+                      :subtitle
+                    else
+                      :unknown
+                    end
+            frame_level =  match[:frame_level] !=  '.'
+            slice_level =  match[:slice_level] !=  '.'
+            experimental =  match[:experimental] !=  '.'
+            horizon_band =  match[:horizon_band] !=  '.'
+            direct_rendering_method =  match[:direct_rendering_method] !=  '.'
+
+            Mediakit::FFmpeg::Encoder.new(match[:name], match[:desc], type, frame_level, slice_level, experimental, horizon_band, direct_rendering_method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mediakit/initializers.rb

@@ -0,0 +1,5 @@
+module Mediakit
+  module Initializers
+    require 'mediakit/initializers/ffmpeg'
+  end
+end

data/lib/mediakit/utils/process_runner.rb

@@ -14,7 +14,7 @@ module Mediakit
 
       DEFAULT_READ_TIMEOUT_INTERVAL = 30
 
-      def initialize(timeout: DEFAULT_READ_TIMEOUT_INTERVAL, nice: 0)
+      def initialize(timeout: nil, nice: 0)
         @timeout = timeout
         @nice = nice
       end
@@ -30,7 +30,6 @@ module Mediakit
       # @return exit_status [Boolean] is succeeded
       def run(bin, *args)
         command = build_command(bin, *args)
-        exit_status = nil
         begin
           stdin, stdout, stderr, wait_thread = Open3.popen3(command)
           stdin.close
@@ -54,22 +53,19 @@ module Mediakit
 
       def wait_with_timeout(stdout, stderr, wait_thread)
         begin
-          loop = Coolio::Loop.new
-          timer, out_watcher, err_watcher = setup_watchers(loop, stdout, stderr)
-          loop_thread = Thread.new { loop.run }
+          setup_watchers(stdout, stderr)
+          loop_thread = Thread.new { run_loop }
           wait_thread.join
           exit_status = (wait_thread.value.exitstatus == 0)
         rescue Timeout::Error => error
           force_kill_process(wait_thread.pid)
           raise(error)
         ensure
-          out_watcher.close if out_watcher && !out_watcher.closed?
-          err_watcher.close if err_watcher && !err_watcher.closed?
-          timer.detach if timer && timer.attached?
+          teardown_watchers
           loop_thread.join if loop_thread
         end
 
-        [out_watcher.data, err_watcher.data,exit_status]
+        [@out_watcher.data, @err_watcher.data, exit_status]
       end
 
       def build_command(bin, *args)
@@ -86,15 +82,31 @@ module Mediakit
         "#{bin} #{escaped_args}"
       end
 
-      def setup_watchers(loop, stdout, stderr)
-        timer = TimeoutTimer.new(@timeout, Thread.current)
-        timer.attach(loop)
-        out_watcher = IOWatcher.new(stdout) { timer.update }
-        out_watcher.attach(loop)
-        err_watcher = IOWatcher.new(stderr) { timer.update }
-        err_watcher.attach(loop)
+      def setup_watchers(stdout, stderr)
+        @timer = TimeoutTimer.new(@timeout, Thread.current)
+        @out_watcher = IOWatcher.new(stdout) { @timer.update }
+        @err_watcher = IOWatcher.new(stderr) { @timer.update }
 
-        [timer, out_watcher, err_watcher]
+        @loop = Coolio::Loop.new
+        @out_watcher.attach(@loop)
+        @err_watcher.attach(@loop)
+        @timer.attach(@loop)
+      end
+
+      def run_loop
+        @loop.run
+      rescue => e
+        # workaround for ambiguous RuntimeError
+        # TODO: replace logger method
+        warn(e.message)
+        warn(e.backtrace)
+      end
+
+      def teardown_watchers
+        @loop.watchers.each { |w| w.detach  if w.attached? }
+        @out_watcher.close if @out_watcher && !@out_watcher.closed?
+        @err_watcher.close if @err_watcher && !@err_watcher.closed?
+        @loop.stop if @loop.has_active_watchers?
       end
 
       def force_kill_process(pid)
@@ -116,6 +128,10 @@ module Mediakit
           @data << data
           @block.call(self)
         end
+
+        def on_close
+          @block = nil
+        end
       end
 
       class TimeoutTimer < Coolio::TimerWatcher

data/lib/mediakit/version.rb

@@ -1,3 +1,3 @@
 module Mediakit
-  VERSION = "0.0.6"
+  VERSION = "0.0.9"
 end

data/lib/mediakit.rb

@@ -4,4 +4,5 @@ module Mediakit
   require 'mediakit/drivers'
   require 'mediakit/ffmpeg'
   require 'mediakit/ffprobe'
+  require 'mediakit/initializers'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mediakit
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.9
 platform: ruby
 authors:
 - ainame
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-24 00:00:00.000000000 Z
+date: 2015-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -104,28 +104,25 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
+- circle.yml
 - lib/mediakit.rb
 - lib/mediakit/drivers.rb
 - lib/mediakit/ffmpeg.rb
-- lib/mediakit/ffmpeg/introspection.rb
 - lib/mediakit/ffmpeg/options.rb
 - lib/mediakit/ffprobe.rb
+- lib/mediakit/initializers.rb
+- lib/mediakit/initializers/ffmpeg.rb
 - lib/mediakit/utils/process_runner.rb
 - lib/mediakit/utils/shell_escape.rb
 - lib/mediakit/version.rb
 - mediakit.gemspec
 - sample/configure.rb
 - sample/raw_crop.rb
-- templates/codec.rb.erb
-- templates/decoder.rb.erb
-- templates/encoder.rb.erb
-- templates/format.rb.erb
 homepage: https://github.com/ainame/mediakit
 licenses: []
 metadata: {}

data/.travis.yml

@@ -1,8 +0,0 @@
-language: ruby
-cache:
-  bundler: true
-rvm:
-  - 2.2.0
-before_install:
-  - bundler --version
-  - gem --version

data/lib/mediakit/ffmpeg/introspection.rb

@@ -1,29 +0,0 @@
-module Mediakit
-  class FFmpeg
-    module Introspection
-      DELIMITER_FOR_CODECS  = "\n -------\n".freeze
-      DELIMITER_FOR_FORMATS = "\n --\n".freeze
-      DELIMITER_FOR_CODER   = "\n ------\n".freeze
-
-      def codecs
-        @codecs ||= run(global_options('codecs')).split(DELIMITER_FOR_CODECS)[1].each_line.to_a
-      end
-
-      def formats
-        @formats ||= run(global_options('formats')).split(DELIMITER_FOR_FORMATS)[1].each_line.to_a
-      end
-
-      def decoders
-        @decoders ||= run(global_options('decoders')).split(DELIMITER_FOR_CODER)[1].each_line.to_a
-      end
-
-      def encoders
-        @encoders ||= run(global_options('encoders')).split(DELIMITER_FOR_CODER)[1].each_line.to_a
-      end
-
-      def global_options(flag)
-        Options.new(Options::GlobalOption.new(flag => true))
-      end
-    end
-  end
-end

data/templates/codec.rb.erb

@@ -1,33 +0,0 @@
-module Mediakit
-  module Codecs
-    module Video
-      <% @items.select{|x| x.type == :video }.each do |item| %>
-      class Codec<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-        def encoders; <%= item.encoders.inspect %>; end
-        def decoders; <%= item.decoders.inspect %>; end
-      end
-      <% end %>
-    end
-
-    module Audio
-      <% @items.select{|x| x.type == :audio }.each do |item| %>
-      class Codec<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-        def encoders; <%= item.encoders.inspect %>; end
-        def decoders; <%= item.decoders.inspect %>; end
-      end
-      <% end %>
-    end
-
-    module Subtitle
-      <% @items.select{|x| x.type == :subtitle }.each do |item| %>
-      class Codec<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-        def encoders; <%= item.encoders.inspect %>; end
-        def decoders; <%= item.decoders.inspect %>; end
-      end
-      <% end %>
-    end
-  end
-end

data/templates/decoder.rb.erb

@@ -1,27 +0,0 @@
-module Mediakit
-  module Decoders
-    module Video
-      <% @items.select{|x| x.type == :video }.each do |item| %>
-      class Decoder<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-      end
-      <% end %>
-    end
-
-    module Audio
-      <% @items.select{|x| x.type == :audio }.each do |item| %>
-      class Decoder<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-      end
-      <% end %>
-    end
-
-    module Subtitle
-      <% @items.select{|x| x.type == :subtitle }.each do |item| %>
-      class Decoder<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-      end
-      <% end %>
-    end
-  end
-end

data/templates/encoder.rb.erb

@@ -1,27 +0,0 @@
-module Mediakit
-  module Encoders
-    module Video
-      <% @items.select{|x| x.type == :video }.each do |item| %>
-      class Encoder<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-      end
-      <% end %>
-    end
-
-    module Audio
-      <% @items.select{|x| x.type == :audio }.each do |item| %>
-      class Encoder<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-      end
-      <% end %>
-    end
-
-    module Subtitle
-      <% @items.select{|x| x.type == :subtitle }.each do |item| %>
-      class Encoder<%= item.name.classify %>
-        def name; '<%= item.name %>' end
-      end
-      <% end %>
-    end
-  end
-end

data/templates/format.rb.erb

@@ -1,9 +0,0 @@
-module Mediakit
-  module Formats
-    <% @items.each do |item| %>
-    class Format<%= item.name.classify %>
-      def name; '<%= item.name %>' end
-    end
-    <% end %>
-  end
-end