mediakit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba4ab75bf6e7d06e4d47117147e26dd2dccdb650
+  data.tar.gz: d4e1e172178d66a94c581696e00235a896567cf0
+SHA512:
+  metadata.gz: 02b9db5afc15386e6398f267513cb5c7b040e540e7f6f677f5b9d9f70d410b49c16a28cea77a3006df674a95ce67d2e5ef8209629ce69e38c16bb52da3acdcb7
+  data.tar.gz: b42d2eb275b21769af3c90e3a8df77220cdd81abe5bc060f10912995ec6d2e0ffa230dba12f43eb34f036373aeacf7575e2e779b4d505f0c7878dd6405fd5b9b

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea
+out.mp4

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mediakit.gemspec
+gemspec

data/README.md

@@ -0,0 +1,96 @@
+# Mediakit
+
+mediakit is the libraries for ffmpeg and sox backed media manipulation something.
+I've design this library for following purpose.
+
+* have low and high level interfaces as you like use
+* easy testing design by separation of concern
+
+## Development Plan
+
+* [x] low-level interface for ffmpeg
+* [ ] high-level interface for ffmpeg
+* [ ] low-level interface for sox
+* [ ] high-level interface for sox
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mediakit'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+$ gem install mediakit
+
+## Requirements
+
+This library behave command wrapper in your script.
+So it need each binary command file.
+
+* latest ffmpeg which have ffprobe command
+
+## Usage
+
+### Low Level Usage
+
+The low level means it's near command line usage.
+This is a little bore interface for constructing options,
+but can pass certain it.
+
+```rb
+driver = Mediakit::Drivers::FFmpeg.new
+ffmpeg = Mediakit::Runners::FFmpeg.new(driver)
+
+options = Mediakit::Runners::FFmpeg::Options.new(
+  Mediakit::Runners::FFmpeg::Options::GlobalOption.new(
+    't' => 100,
+    'y' => true,
+  ),
+  Mediakit::Runners::FFmpeg::Options::InputFileOption.new(
+    options: nil,
+    path:    input,
+  ),
+  Mediakit::Runners::FFmpeg::Options::OutputFileOption.new(
+    options: {
+      'vf' => 'crop=320:320:0:0',
+      'ar' => '44100',
+      'ab' => '128k',
+    },
+    path:    output,
+  ),
+)
+puts "$ ffmpeg #options"
+puts ffmpeg.run(options)
+```
+
+### High Level Usage
+
+TBD
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/mediakit/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## References
+
+* [streamio/streamio-ffmpeg](https://github.com/streamio/streamio-ffmpeg)
+* [ruby-av/av](https://github.com/ruby-av/av)
+* [Xuggler](http://www.xuggle.com/xuggler/)
+* [PHP-FFMpeg/PHP-FFMpeg](https://github.com/PHP-FFMpeg/PHP-FFMpeg)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mediakit"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mediakit/drivers.rb

@@ -0,0 +1,138 @@
+require 'shellwords'
+require 'mediakit/utils/popen_helper'
+
+module Mediakit
+  module Drivers
+    class DriverError < StandardError; end
+    class ConfigurationError < DriverError; end
+
+    class Base
+      attr_reader(:bin)
+      def initialize(bin)
+        @bin = bin
+      end
+
+      def run(*args)
+        raise(NotImplementedError)
+      end
+
+      def command(*args)
+        raise(NotImplementedError)
+      end
+    end
+
+    class PopenDriver < Base
+      # execute command and return result
+      #
+      # @overload run(args)
+      #   @param args [String] arguments for command
+      # @overload run(*args)
+      #   @param args [Array] arguments for command
+      # @return result [Bool] runners result
+      def run(*args)
+        begin
+          escaped_args = Mediakit::Utils::PopenHelper.escape(*args)
+          Mediakit::Utils::PopenHelper.run(bin, escaped_args)
+        rescue Mediakit::Utils::PopenHelper::CommandNotFoundError => e
+          raise(ConfigurationError, "cant' find bin in #{bin}.")
+        rescue => e
+          raise(DriverError, "#{self.class} catch error with command(#{Mediakit::Utils::PopenHelper.command(bin,escaped_args)}) - #{e.message}, #{e.backtrace.join("\n")}")
+        end
+      end
+
+      # return command to execute
+      #
+      # @overload run(args)
+      #   @param args [String] arguments for command
+      # @overload run(*args)
+      #   @param args [Array] arguments for command
+      # @return result [String] runners to execute
+      def command(*args)
+        escaped_args = Mediakit::Utils::PopenHelper.escape(*args)
+        "#{bin} #{escaped_args}"
+      end
+    end
+
+    class CocaineDriver < Base
+      # execute command and return result
+      #
+      # @overload run(args)
+      #   @param args [String] arguments for command
+      # @overload run(*args)
+      #   @param args [Array] arguments for command
+      # @return result [Bool] runners result
+      def run(args = '')
+        begin
+          # Force escape args string on here,
+          # because this design can't use Cocaine::CommandLine's safety solution.
+          escaped_args = Mediakit::Utils::PopenHelper.escape(args.dup)
+          command_line = Cocaine::CommandLine.new(bin, escaped_args, swallow_stderr: true)
+          command_line.run
+        rescue => e
+          raise(DriverError, "#{self.class} catch error with runners [$ #{command_line.command}] - #{e.message}, #{e.backtrace.join("\n")}")
+        end
+      end
+
+      # return command to execute
+      #
+      # @overload run(args)
+      #   @param args [String] arguments for command
+      # @overload run(*args)
+      #   @param args [Array] arguments for command
+      # @return result [String] runners to execute
+      def command(args = '')
+        Cocaine::CommandLine.new(bin, args).command
+      end
+    end
+
+    class FakeDriver < Base
+      def run(args = '')
+        true
+      end
+
+      def command(args = '')
+        bin + args
+      end
+    end
+
+    class AbstractFactory
+      class << self
+        attr_accessor(:bin_path)
+
+        def configure(&block)
+          yield(self)
+        end
+
+        def name
+          self.to_s.downcase.split('::').last
+        end
+
+        def bin
+          bin_path || name
+        end
+
+        def new(type = :popen)
+          case type.to_sym
+          when :popen
+            PopenDriver.new(bin)
+          when :cocaine
+            CocaineDriver.new(bin)
+          when :fake
+            FakeDriver.new(bin)
+          else
+            raise(ArgumentError)
+          end
+        end
+      end
+    end
+
+    class FFmpeg < AbstractFactory
+    end
+
+    class FFprobe < AbstractFactory
+    end
+
+    class Sox < AbstractFactory
+    end
+  end
+end

data/lib/mediakit/ffmpeg/options.rb

@@ -0,0 +1,236 @@
+require 'active_support/ordered_hash'
+
+module Mediakit
+  class FFmpeg
+    # presentation of ffmpeg runners option
+    #
+    # SYNOPSIS
+    # ffmpeg [global_options] {[input_file_options] -i input_file} ... {[output_file_options] output_file} ...
+    #
+    class Options
+      attr_reader(:global, :inputs, :output)
+      # constructor
+      #
+      # @option args [Mediakit::FFmpeg::Options::GlobalOption]
+      # @option args [Array<Mediakit::FFmpeg::Options::InputFileOption>] array object Mediakit::FFmpeg::Options::InputOption
+      # @option args [Mediakit::FFmpeg::Options::OutputFileOption]
+      def initialize(*args)
+        @global, @inputs, @output = nil, [], nil
+        args.each do |option|
+          add_option(option)
+        end
+      end
+
+      def add_option(option)
+        return if option.nil?
+        case option
+        when GlobalOption
+          set_global(option)
+        when InputFileOption
+          add_input(option)
+        when OutputFileOption
+          set_output(option)
+        else
+          raise(ArgumentError)
+        end
+      end
+
+      def compose
+        composed_string = ''
+        composed_string << "#{global}" if global
+        composed_string << " #{inputs.map(&:compose).join(' ')}" if inputs && !inputs.empty?
+        composed_string << " #{output}" if output
+        composed_string
+      end
+
+      alias_method :to_s, :compose
+
+      private
+
+      def set_global(global)
+        @global = global
+      end
+
+      def add_input(input)
+        @inputs.push(input)
+      end
+
+      def set_output(output)
+        @output = output
+      end
+
+      # Base class for Options
+      class OrderedHash < ActiveSupport::OrderedHash
+        # initializer
+        #
+        # @param options [Hash] initial option values
+        def initialize(options = {})
+          options.each { |key, value| raise_if_invalid_arg_error(key, value) } if options
+          self.merge!(options) if options && options.kind_of?(Hash)
+        end
+
+        def []=(key, value)
+          raise_if_invalid_arg_error(key, value)
+          super
+        end
+
+        def compose
+          self.map { |key, value| struct_option(key, value) }.compact.join(' ')
+        end
+
+        def to_s
+          compose
+        end
+
+        protected
+
+        def raise_if_invalid_arg_error(key, value)
+          raise(ArgumentError, "#{self.class} can't accept nil value with key(#{key}).") if value.nil?
+        end
+
+        def struct_option(key, value)
+          case value
+          when TrueClass, FalseClass
+            value ? "-#{key}" : nil
+          else
+            "-#{key} #{value}"
+          end
+        end
+      end
+
+      class GlobalOption < OrderedHash
+      end
+
+      class OptionPathPair
+        attr_reader(:options, :path)
+
+        def initialize(options:, path:)
+          @options = options
+          @path    = path
+        end
+
+        def compose
+          raise(NotImplementedError)
+        end
+
+        def to_s
+          compose
+        end
+      end
+
+      class InputFileOption < OptionPathPair
+        # @param options [Hash] input options
+        # @param path [String] input file path
+        def initialize(options:, path:)
+          ordered_hash = OrderedHash.new(options)
+          super(options: ordered_hash, path: path)
+        end
+
+        def compose
+          "#{options} -i #{path}"
+        end
+      end
+
+      class OutputFileOption < OptionPathPair
+        # @param options [Hash] output options
+        # @param path [String] output file path
+        def initialize(options:, path:)
+          ordered_hash = OrderedHash.new(options)
+          super(options: ordered_hash, path: path)
+        end
+
+        def compose
+          "#{options} #{path}"
+        end
+      end
+
+      class InputFileOptionCollection
+        attr_reader(:input_file_options)
+
+        # @param *input_file_options [Mediakit::FFmpeg::InputFileOptions]
+        def initialize(*input_file_options)
+          @options = input_file_options
+        end
+
+        def empty?
+          @options.empty?
+        end
+
+        def compose
+          @options.map(&:compose).join(' ')
+        end
+
+        alias_method :to_s, :compose
+      end
+
+      # see https://www.ffmpeg.org/ffmpeg.html#Stream-specifiers-1
+      class StreamSpecifier
+        attr_reader(:stream_index, :stream_type, :program_id, :metadata_tag_key, :metadata_tag_value, :usable)
+        STREAM_TYPES = ['v', 'a', 's'].freeze
+
+        def initialize(stream_index: nil, stream_type: nil, program_id: nil, metadata_tag_key: nil, metadata_tag_value: nil, usable: nil)
+          raise(ArgumentError, "invalid args stream_type = #{stream_type}") if stream_type && !STREAM_TYPES.include?(stream_type)
+          @stream_index       = stream_index
+          @stream_type        = stream_type
+          @program_id         = program_id
+          @metadata_tag_key   = metadata_tag_key
+          @metadata_tag_value = metadata_tag_value
+          @usable             = usable
+        end
+
+        def to_s
+          case
+          when stream_index?, stream_type?
+            stream_specifier
+          when program?
+            program_specifier
+          when meta?
+            metadata_specifier
+          when usable?
+            usable_specifier
+          else
+            raise(RuntimeError)
+          end
+        end
+
+        private
+
+        def stream_specifier
+          [stream_type, stream_index].compact.join(':')
+        end
+
+        def program_specifier
+          ["p:#{program_id}", stream_index].compact.join(':')
+        end
+
+        def metadata_specifier
+          [metadata_tag_key, metadata_tag_value].compact.join(':')
+        end
+
+        def usable_specifier
+          'u'
+        end
+
+        def stream_index?
+          !stream_index.nil?
+        end
+
+        def stream_type?
+          !stream_type.nil?
+        end
+
+        def meta?
+          !metadata_tag_key.nil?
+        end
+
+        def program?
+          !program_id.nil?
+        end
+
+        def usable?
+          !usable.nil?
+        end
+      end
+    end
+  end
+end

data/lib/mediakit/ffmpeg.rb

@@ -0,0 +1,64 @@
+require 'mediakit/ffmpeg/options'
+require 'mediakit/drivers'
+
+module Mediakit
+  class FFmpeg
+    class FFmpegError < StandardError;
+    end
+
+    DELIMITER_FOR_CODECS  = "\n -------\n".freeze
+    DELIMITER_FOR_FORMATS = "\n --\n".freeze
+    DELIMITER_FOR_CODER   = "\n ------\n".freeze
+
+    def initialize(driver)
+      @driver = driver
+    end
+
+    # execute runners with options object
+    #
+    # @param options [Mediakit::Runners::FFmpeg::Options] options object to create CLI argument
+    def run(options)
+      args = options.compose
+      execute(args)
+    end
+
+    def command(options)
+      args = options.compose
+      @driver.command(args)
+    end
+
+    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
+
+    private
+
+    def execute(args = '')
+      begin
+        @driver.run(args)
+      rescue Drivers::DriverError => e
+        raise(FFmpegError, "#catch driver's error - #{e.message}, #{e.backtrace.join("\n")}")
+      end
+    end
+
+    def global_options(flag)
+      Mediakit::FFmpeg::Options.new(
+        Mediakit::FFmpeg::Options::GlobalOptions.new(
+          flag => true,
+        ),
+      )
+    end
+  end
+end

data/lib/mediakit/ffprobe.rb

@@ -0,0 +1,32 @@
+module Mediakit
+  class FFprobe
+    attr_reader(:driver)
+
+    class FFprobeError < StandardError;
+    end
+
+    def initialize(driver)
+      @driver = driver
+    end
+
+    def execute(args = '')
+      begin
+        driver.run(args)
+      rescue => e
+        raise(FFprobeError, "#{self.class} catch error - #{e.message}, #{e.backtrace.join("\n")}")
+      end
+    end
+
+    def get_json(path)
+      args = "#{default_show_options} -print_format json #{path}"
+      execute(args)
+    end
+
+    def default_show_options
+      [
+        '-show_streams',
+        '-show_format'
+      ].join(' ')
+    end
+  end
+end

data/lib/mediakit/utils/popen_helper.rb

@@ -0,0 +1,68 @@
+require 'shellwords'
+require 'open3'
+
+module Mediakit
+  module Utils
+    module PopenHelper
+
+      class CommandNotFoundError < StandardError;
+      end
+
+      # @overload run(command, *args)
+      #   @param command [String]
+      #   @param args [Array] args as array for safety shellescape
+      # @overload run(command, args)
+      #   @param command [String] command name
+      #   @param args [Array] args as string
+      # @return out [String] stdout of command
+      # @return err [String] stderr of command
+      # @return exit_status [Boolean] is succeeded
+      def run(bin, *args)
+        command = command(bin, *args)
+
+        out, err, exit_status = nil
+        begin
+          Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+            stdin.close
+            out         = stdout.read
+            err         = stderr.read
+            exit_status = (wait_thr.value.exitstatus == 0)
+          end
+        rescue Errno::ENOENT => e
+          raise(CommandNotFoundError, "Can't find command - #{command}, #{e.meessage}")
+        end
+
+        [out, err, exit_status]
+      end
+
+      module_function(:run)
+
+      def command(bin, *args)
+        escaped_args = escape(*args)
+        "#{bin} #{escaped_args}"
+      end
+
+      module_function(:command)
+
+      def escape(*args)
+        case args.size
+        when 1
+          _escape_with_split(args[0])
+        else
+          Shellwords.join(args.map { |x| Shellwords.escape(x) })
+        end
+      end
+
+      module_function(:escape)
+
+      def _escape_with_split(string)
+        splits = Shellwords.split(string)
+        splits = splits.map { |x| Shellwords.escape(x) }
+        splits.join(' ')
+      end
+
+      module_function(:_escape_with_split)
+
+    end
+  end
+end

data/lib/mediakit/version.rb

@@ -0,0 +1,3 @@
+module Mediakit
+  VERSION = "0.0.1"
+end

data/lib/mediakit.rb

@@ -0,0 +1,7 @@
+require "mediakit/version"
+
+module Mediakit
+  require 'mediakit/drivers'
+  require 'mediakit/ffmpeg'
+  require 'mediakit/ffprobe'
+end

data/mediakit.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mediakit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mediakit"
+  spec.version       = Mediakit::VERSION
+  spec.authors       = ["ainame"]
+  spec.email         = ["s.namai.09@gmail.com"]
+
+  spec.summary       = 'mediakit is the libraries for ffmpeg and sox backed media manipulation something.'
+  spec.description   = <<EOS
+mediakit is the libraries for ffmpeg and sox backed media manipulation something.
+you can create complex manipulation for media as a ruby code.
+EOS
+
+  spec.homepage      = "https://github.com/ainame/mediakit"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "cocaine", "~> 0.5.7"
+  spec.add_runtime_dependency "activesupport", "~> 4"
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "ruby-debug-ide", "~> 0.4"
+end

data/sample/raw_crop.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mediakit"
+require 'pry'
+
+def transcode_option(input, output)
+  options = Mediakit::FFmpeg::Options.new(
+    Mediakit::FFmpeg::Options::GlobalOption.new(
+      't' => 100,
+      'y' => true,
+    ),
+    Mediakit::FFmpeg::Options::InputFileOption.new(
+      options: nil,
+      path:    input,
+    ),
+    Mediakit::FFmpeg::Options::InputFileOption.new(
+      options: nil,
+      path:    input,
+    ),
+    Mediakit::FFmpeg::Options::OutputFileOption.new(
+      options: {
+        'vf' => 'crop=320:320:0:0',
+        'ar' => '44100',
+        'ab' => '128k',
+      },
+      path:    output,
+    ),
+  )
+end
+
+root        = File.expand_path(File.join(File.dirname(__FILE__), '../'))
+input_path  = File.expand_path(File.join(root, 'test/fixtures/sample1.mp4'))
+output_path = File.expand_path(File.join(root, 'out.mp4'))
+driver      = Mediakit::Drivers::FFmpeg.new
+ffmpeg      = Mediakit::FFmpeg.new(driver)
+options     = transcode_option(input_path, output_path)
+puts "$ #{ffmpeg.command(options)}"
+puts ffmpeg.run(options)

data/templates/codec.rb.erb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,27 @@
+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

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

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: mediakit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ainame
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cocaine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.7
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: ruby-debug-ide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: |
+  mediakit is the libraries for ffmpeg and sox backed media manipulation something.
+  you can create complex manipulation for media as a ruby code.
+email:
+- s.namai.09@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mediakit.rb
+- lib/mediakit/drivers.rb
+- lib/mediakit/ffmpeg.rb
+- lib/mediakit/ffmpeg/options.rb
+- lib/mediakit/ffprobe.rb
+- lib/mediakit/utils/popen_helper.rb
+- lib/mediakit/version.rb
+- mediakit.gemspec
+- 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: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: mediakit is the libraries for ffmpeg and sox backed media manipulation something.
+test_files: []