logstash-codec-json 2.0.3 → 2.0.4

data/vendor/gems/filesize-0.0.4/CHANGELOG

@@ -1,3 +0,0 @@
-Version 0.0.2 -- 2010-10-04
-* Fixing float handling
-* Use yardoc for documentation

data/vendor/gems/filesize-0.0.4/README.markdown

@@ -1,52 +0,0 @@
-## filesize
-filesize.rb provides a class for easily working with file sizes.
-That means:
-
-* Parsing strings (e.g. "1 GiB") and saving it internally as bytes
-* Handling both SI and binary prefixes
-* Converting from any type and unit to any other (SI to SI, SI to Binary and so on)
-* doing calculations with filesizes (in a smart way, see Usage for more)
-* filesize.rb also provides some default sizes, like the ones of DVDs
-
-## Usage
-### Parsing a string
-```ruby
-Filesize.from("1 GiB")
-# => #<Filesize:0x93c06c8 @bytes=1073741824, @type={:regexp=>/^([\d,.]+)?\s?(?:([kmgtpezy])i)?b$/i, :multiplier=>1024, :presuffix=>"i"}>
-```
-
-### Converting filesizes
-```ruby
-Filesize.from("1 GiB").to_f('KiB') # => 1048576.0
-Filesize.from("1 GiB").to_f('KB')  # => 1073741.824
-Filesize.from("1 GB").to_i         # => 1000000000
-```
-
-### Outputting filesizes
-```ruby
-Filesize.from("12502343 B").to_s('GiB') # => "0.01 GiB"
-Filesize.from("12502343 B").pretty      # => "11.92 MiB"
-```
-
-### Calculating with filesizes
-#### The file size on the left side sets the type
-```ruby
-(Filesize.from("1400 MB")  + Filesize.from("1400 MiB")).pretty # => "2.87 GB"
-(Filesize.from("1400 MiB") + Filesize.from("1400 MB")).pretty  # => "2.67 GiB"
-```
-
-#### Filesizes can also be coerced
-```ruby
-(Filesize.from("1400 MiB") + 1024).pretty # => "1.37 GiB"
-(1024 + Filesize.from("1400 MB")).pretty  # => "1.40 GB"
-```
-
-#### filesize.rb is smart about the return value
-```ruby
-Filesize.from("1400 MiB") / Filesize.from("700 MiB") # => 2.0
-```
-
-#### One can also use predefined sizes
-```ruby
-Filesize::DVD / Filesize::CD # => 6.13566756571429
-```

data/vendor/gems/filesize-0.0.4/filesize.gemspec

@@ -1,19 +0,0 @@
-# -*- encoding: utf-8 -*-
-Gem::Specification.new do |s|
-  s.name = "filesize"
-  s.version = "0.0.4"
-
-  s.authors = ["Dominik Honnef"]
-  s.date = %q{2009-07-26}
-  s.description = "filesize is a small class for handling filesizes with both the SI and binary prefixes, allowing conversion from any size to any other size."
-  s.summary = s.description
-
-  s.email = "dominikh@fork-bomb.org"
-  s.extra_rdoc_files = ["README.markdown", "CHANGELOG", "lib/filesize.rb"]
-  s.files = ["README.markdown", "CHANGELOG", "lib/filesize.rb", "filesize.gemspec"]
-  s.homepage = "http://filesize.rubyforge.org/"
-  s.required_ruby_version = ">= 1.8.6"
-  s.rubyforge_project = "filesize"
-
-  s.add_development_dependency "rspec", "~> 3.0"
-end

data/vendor/gems/filesize-0.0.4/lib/filesize.rb

@@ -1,178 +0,0 @@
-class Filesize
-  TYPE_PREFIXES = {
-    # Unit prefixes used for SI file sizes.
-    SI: %w{k M G T P E Z Y},
-    # Unit prefixes used for binary file sizes.
-    BINARY: %w{Ki Mi Gi Ti Pi Ei Zi Yi}
-  }
-
-  # @deprecated Please use TYPE_PREFIXES[:SI] instead
-  PREFIXES = TYPE_PREFIXES[:SI]
-
-  # Set of rules describing file sizes according to SI units.
-  SI = {
-    :regexp => /^([\d,.]+)?\s?([kmgtpezy]?)b$/i,
-    :multiplier => 1000,
-    :prefixes => TYPE_PREFIXES[:SI],
-    :presuffix => '' # deprecated
-  }
-  # Set of rules describing file sizes according to binary units.
-  BINARY = {
-    :regexp => /^([\d,.]+)?\s?(?:([kmgtpezy])i)?b$/i,
-    :multiplier => 1024,
-    :prefixes => TYPE_PREFIXES[:BINARY],
-    :presuffix => 'i' # deprecated
-  }
-
-  # @param [Number] size A file size, in bytes.
-  # @param [SI, BINARY] type Which type to use for conversions.
-  def initialize(size, type = BINARY)
-    @bytes = size.to_i
-    @type  = type
-  end
-
-  # @return [Number] Returns the size in bytes.
-  def to_i
-    @bytes
-  end
-  alias_method :to_int, :to_i
-
-  # @param [String] unit Which unit to convert to.
-  # @return [Float] Returns the size in a given unit.
-  def to(unit = 'B')
-    to_parts = self.class.parse(unit)
-    prefix   = to_parts[:prefix]
-
-    if prefix == 'B' or prefix.empty?
-      return to_i.to_f
-    end
-
-    to_type = to_parts[:type]
-    size    = @bytes
-
-    pos = (@type[:prefixes].map { |s| s[0].downcase }.index(prefix.downcase) || -1) + 1
-
-    size = size/(to_type[:multiplier].to_f**(pos)) unless pos < 1
-  end
-  alias_method :to_f, :to
-
-  # @param (see #to_f)
-  # @return [String] Same as {#to_f}, but as a string, with the unit appended.
-  # @see #to_f
-  def to_s(unit = 'B')
-    "%.2f %s" % [to(unit).to_f.to_s, unit]
-  end
-
-  # Same as {#to_s} but with an automatic determination of the most
-  # sensible unit.
-  #
-  # @return [String]
-  # @see #to_s
-  def pretty
-    size = @bytes
-    if size < @type[:multiplier]
-      unit = "B"
-    else
-      pos = (Math.log(size) / Math.log(@type[:multiplier])).floor
-      pos = @type[:prefixes].size-1 if pos > @type[:prefixes].size - 1
-
-      unit = @type[:prefixes][pos-1] + "B"
-    end
-
-    to_s(unit)
-  end
-
-  # @return [Filesize]
-  def +(other)
-    self.class.new(@bytes + other.to_i, @type)
-  end
-
-  # @return [Filesize]
-  def -(other)
-    self.class.new(@bytes - other.to_i, @type)
-  end
-
-  # @return [Filesize]
-  def *(other)
-    self.class.new(@bytes * other.to_i, @type)
-  end
-
-  # @return [Filesize]
-  def /(other)
-    result = @bytes / other.to_f
-    if other.is_a? Filesize
-      result
-    else
-      self.class.new(result, @type)
-    end
-  end
-
-  # @return [Boolean]
-  def ==(other)
-    other.is_a?(self.class) && other.to_i == self.to_i
-  end
-
-  # @return [Array<self, other>]
-  # @api private
-  def coerce(other)
-    return self, other
-  end
-
-  class << self
-    # Parses a string, which describes a file size, and returns a
-    # Filesize object.
-    #
-    # @param [String] arg A file size to parse.
-    # @raise [ArgumentError] Raised if the file size cannot be parsed properly.
-    # @return [Filesize]
-    def from(arg)
-      parts  = parse(arg)
-      prefix = parts[:prefix]
-      size   = parts[:size]
-      type   = parts[:type]
-
-      raise ArgumentError, "Unparseable filesize" unless type
-
-      offset = (type[:prefixes].map { |s| s[0].downcase }.index(prefix.downcase) || -1) + 1
-
-      new(size * (type[:multiplier] ** (offset)), type)
-    end
-
-    # @return [Hash<:prefix, :size, :type>]
-    # @api private
-    def parse(string)
-      type = nil
-      # in this order, so we prefer binary :)
-      [BINARY, SI].each { |_type|
-        if string =~ _type[:regexp]
-          type    =  _type
-          break
-        end
-      }
-
-      prefix = $2 || ''
-      size   = ($1 || 0).to_f
-
-      return { :prefix => prefix, :size => size, :type => type}
-    end
-  end
-
-  # The size of a floppy disk
-  Floppy = Filesize.from("1474 KiB")
-  # The size of a CD
-  CD     = Filesize.from("700 MB")
-  # The size of a common DVD
-  DVD_5  = Filesize.from("4.38 GiB")
-  # The same as a DVD 5
-  DVD    = DVD_5
-  # The size of a single-sided dual-layer DVD
-  DVD_9  = Filesize.from("7.92 GiB")
-  # The size of a double-sided single-layer DVD
-  DVD_10 = DVD_5 * 2
-  # The size of a double-sided DVD, combining a DVD-9 and a DVD-5
-  DVD_14 = DVD_9 + DVD_5
-  # The size of a double-sided dual-layer DVD
-  DVD_18 = DVD_14 * 2
-  # The size of a Zip disk
-  ZIP    = Filesize.from("100 MB")
-end

data/vendor/gems/gem_publisher-1.5.0/lib/gem_publisher.rb

@@ -1,28 +0,0 @@
-require "gem_publisher/publisher"
-require "gem_publisher/version"
-
-module GemPublisher
-
-  # Publish a gem based on the supplied gemspec via supplied method, iff this
-  # version has not already been released and tagged in the origin Git
-  # repository.
-  #
-  # Version is derived from the gemspec.
-  #
-  # If a remote tag matching the version already exists, nothing is done.
-  # Otherwise, the gem is built, pushed, and tagged.
-  #
-  # Tags are of the form "v1.2.3" by default, and generated tags follow
-  # this pattern; you can override this by passing in the :tag_prefix option.
-  #
-  # Method should be one of :rubygems or :gemfury, and the requisite
-  # credentials for the corresponding push command line tools must exist.
-  #
-  # Returns the gem file name if a gem was published; nil otherwise. A
-  # CliFacade::Error will be raised if a command fails.
-  #
-  def self.publish_if_updated(gemspec, method=:rubygems, options={})
-    publisher = Publisher.new(gemspec, :tag_prefix => options.delete(:tag_prefix))
-    publisher.publish_if_updated(method, options)
-  end
-end

data/vendor/gems/gem_publisher-1.5.0/lib/gem_publisher/builder.rb

@@ -1,13 +0,0 @@
-require "gem_publisher/cli_facade"
-
-module GemPublisher
-  class Builder
-    def initialize(cli_facade = CliFacade.new)
-      @cli_facade = cli_facade
-    end
-
-    def build(gemspec)
-      @cli_facade.execute("gem", "build", gemspec)[/File:\s+(.+)/, 1]
-    end
-  end
-end

data/vendor/gems/gem_publisher-1.5.0/lib/gem_publisher/cli_facade.rb

@@ -1,17 +0,0 @@
-require "shellwords"
-require "open3"
-
-module GemPublisher
-  class CliFacade
-    Error = Class.new(RuntimeError)
-
-    def execute(*arguments)
-      cmd = Shellwords.join(arguments)
-      stdout_str, stderr_str, status = Open3.capture3(cmd)
-      if status.exitstatus > 0
-        raise Error, [stderr_str, stdout_str].join("\n").strip
-      end
-      stdout_str
-    end
-  end
-end

data/vendor/gems/gem_publisher-1.5.0/lib/gem_publisher/git_remote.rb

@@ -1,26 +0,0 @@
-require "gem_publisher/cli_facade"
-
-module GemPublisher
-  class GitRemote
-    def initialize(name = "origin", cli_facade = CliFacade.new)
-      @remote_name = name
-      @cli_facade  = cli_facade
-    end
-
-    def tags
-      s = git("ls-remote", "--tags", @remote_name)
-      s.scan(%r{refs/tags/(.+)}).map(&:first).reject { |t| t =~ /\^\{\}$/ }
-    end
-
-    def add_tag(tag_name, commit_ish = "HEAD")
-      sha1 = git("rev-parse", commit_ish).chomp
-      git "update-ref", "refs/tags/#{tag_name}", sha1
-      git "push", @remote_name, "tag", tag_name
-    end
-
-  private
-    def git(*args)
-      @cli_facade.execute(*["git"] + args)
-    end
-  end
-end

data/vendor/gems/gem_publisher-1.5.0/lib/gem_publisher/publisher.rb

@@ -1,45 +0,0 @@
-require "gem_publisher/git_remote"
-require "gem_publisher/builder"
-require "gem_publisher/pusher"
-require "rubygems/specification"
-
-module GemPublisher
-  class Publisher
-    attr_accessor :git_remote, :builder, :pusher
-    attr_reader :version
-
-    # Supported options:
-    #   :tag_prefix - use a custom prefix for Git tags (defaults to 'v')
-    def initialize(gemspec, options = {})
-      @gemspec = gemspec
-      @tag_prefix = options[:tag_prefix] || 'v'
-
-      @version = eval(File.read(gemspec), TOPLEVEL_BINDING).version.to_s
-
-      @git_remote = GitRemote.new
-      @builder    = Builder.new
-      @pusher     = Pusher.new
-    end
-
-    # Publish the gem if its version has changed since the last release.
-    #
-    # Supported options:
-    #   :as - specify a shared account to publish the gem (Gemfury only)
-    def publish_if_updated(method, options = {})
-      return if version_released?
-      @builder.build(@gemspec).tap { |gem|
-        tag_prefix = options[:tag_prefix] || 'v'
-        @pusher.push gem, method, options
-        @git_remote.add_tag "#{@tag_prefix}#{@version}"
-      }
-    end
-
-    def version_released?
-      releases = @git_remote.tags.
-        select { |t| t =~ /^#{@tag_prefix}\d+(\.\d+)+/ }.
-        map { |t| t.scan(/\d+/).map(&:to_i) }
-      this_release = @version.split(/\./).map(&:to_i)
-      releases.include?(this_release)
-    end
-  end
-end

data/vendor/gems/gem_publisher-1.5.0/lib/gem_publisher/pusher.rb

@@ -1,26 +0,0 @@
-require "gem_publisher/cli_facade"
-
-module GemPublisher
-  class Pusher
-    def initialize(cli_facade = CliFacade.new)
-      @cli_facade = cli_facade
-    end
-
-    PUSH_METHODS = {
-      "rubygems" => %w[gem push],
-      "gemfury"  => %w[fury push]
-    }
-
-    # Publish the gem.
-    #
-    # Supported options:
-    #   :as - specify a shared account to publish the gem (Gemfury only)
-    def push(gem, method, options = {})
-      push_command = PUSH_METHODS[method.to_s] or raise "Unknown Gem push method #{method.inspect}."
-      push_command += [gem]
-      push_command += ["--as", options[:as]] if options[:as]
-      @cli_facade.execute *push_command
-    end
-  end
-end
-

data/vendor/gems/gem_publisher-1.5.0/lib/gem_publisher/version.rb

@@ -1,3 +0,0 @@
-module GemPublisher
-  VERSION = "1.5.0"
-end

data/vendor/gems/gem_publisher-1.5.0/lib/rubygems_plugin.rb

@@ -1,48 +0,0 @@
-require "rubygems/command_manager"
-require "rubygems/command"
-require "gem_publisher"
-
-class Gem::Commands::PublishCommand < Gem::Command
-  def initialize
-    super "publish", "Automatically publish a gem if the version has been updated"
-
-    defaults.merge! :gem_repository => "rubygems"
-
-    add_option(
-      "-rREPOSITORY", "--repository=REPOSITORY",
-      "Set the gem repository (rubygems or gemfury)",
-      "Default: #{defaults[:gem_repository]}") do |value, options|
-      options[:gem_repository] = value
-    end
-
-    add_option(
-      "-aAS", "--as=AS",
-      "Specify a shared account to publish the gem (gemfury only)"
-    ) do |value, options|
-      options[:as] = value
-    end
-  end
-
-  def usage # :nodoc:
-    "#{program_name} GEMFILE [GEMFILE ...]"
-  end
-
-  def execute
-    options[:args].each do |gemspec|
-      Dir.chdir(File.dirname(gemspec)) do
-        new_opts = {}
-        new_opts[:as] = options[:as] if options[:as]
-
-        gem = GemPublisher.publish_if_updated(File.basename(gemspec), options[:gem_repository], new_opts)
-
-        if gem
-          $stderr.puts "Published #{gem}"
-        else
-          $stderr.puts "Nothing to do for #{gemspec}"
-        end
-      end
-    end
-  end
-end
-
-Gem::CommandManager.instance.register_command :publish