dummy_log_generator 0.0.4 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38e90f1ce32f540d7c61384166fdfd4ff9f96848
-  data.tar.gz: c12675bd60344e5f33781f02147462867a30a87e
+  metadata.gz: 6a76a35eb0df876125713ea8afd7d3128368e73b
+  data.tar.gz: e97dc9abc1fff91fcb1e4c6b5b8179b9c25cf596
 SHA512:
-  metadata.gz: fdc71004c1590c96b72db467ac142da5482711171f0706c5236951489d865a8ce5656a4e3c85b4af819d86149168c705ac830ce95644395992c61ae17ad04e32
-  data.tar.gz: 638c8ac586c1e18e72dee2143053657619092dfb6f679ff995d9f7b776a0357965757d452735c75e3e45194fc46be9f5f425adb9436217e05b67ac5a4d9dcf00
+  metadata.gz: 65200ca5573a8f275ee1dfd1c5869ce30d1e5840737ff55eefc5c45d90c0d9b7c2729976274e6d8a549183c6337d29c3484e2bbf9f4b1aa84e407752f9bd586a
+  data.tar.gz: 15921096adbdd0d1214a7a6afb0b9d29a74b5be39da3af8b4a0b01918597c671d903d044658fa98f7dfeca88289d7ad05e9efc9e007294e2392f4cf0cf2c4cab

data/.gitignore

@@ -23,4 +23,6 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
-tmp
+dummy_log_generator.pid
+dummy_log_generator.log
+

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+### 0.1.0
+
+Enhancement:
+
+  * Support to output into a file (`output` option)
+  * No dependency on active_support
+  * Speed-up (Proc-based evaluation)
+  * Support parallel (`workers` option)
+
 ### 0.0.4
 
 Enhancement:

data/README.md

@@ -27,6 +27,7 @@ Sample configuration is as follows:
 ```ruby
 # dummy_log_generator.conf
 configure 'sample' do
+  output dummy.log
   rate 500
   delimiter "\t"
   labeled true
@@ -40,7 +41,7 @@ configure 'sample' do
 end 
 ```
 
-Running dummy_log_generator outputs like
+Running dummy_log_generator outputs to `dummy.log` like
 
 ```
 id:422  time:[2013-11-19 02:34:58]  level:INFO  method:POST uri:/api/v1/textdata  reqtime:3.9726677258569842  foobar:LFK6XV1N
@@ -52,6 +53,10 @@ id:424  time:[2013-11-19 02:34:58]  level:WARN  method:POST uri:/api/v1/textdata
 
 Following parameters for configuration is available
 
+* output
+
+    Specify a filename to output, or IO object (STDOUT, STDERR)
+
 * rate
 
     Specify how many messages to generate per second. Default: 500 msgs / sec
@@ -88,10 +93,6 @@ You can specify following data types to your `field` parameters:
 
 * :string
 
-  * :format
-
-    You can specify a format of string  as `%s`. 
-
   * :any
 
     You can specify an array of strings, then the generator picks one from them randomly
@@ -143,9 +144,6 @@ There is a [fluent-plugin-dummydata-producer](https://github.com/tagomoris/fluen
 ## ToDO
 
 1. write tests
-2. make it slim (remove active_support, etc)
-3. outputs to a file (currently, outputs to STDOUT)
-4. speed up (evaluate fields at only starting up)
 
 ## Contributing
 

data/dummy_log_generator.conf

@@ -1,8 +1,9 @@
 configure 'sample' do
+  # output "dummy_log_generator.log"
   rate 500
   delimiter "\t"
   labeled true
-  field :id, type: :integer, countup: true
+  field :id, type: :integer, countup: true, format: "%04d"
   field :time, type: :datetime, format: "[%Y-%m-%d %H:%M:%S]", random: false
   field :level, type: :string, any: %w[DEBUG INFO WARN ERROR]
   field :method, type: :string, any: %w[GET POST PUT]

data/dummy_log_generator.gemspec

@@ -20,8 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "thor"
   spec.add_dependency "serverengine"
-  spec.add_dependency "active_support"
-  spec.add_dependency "i18n"
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"

data/lib/dummy_log_generator.rb

@@ -1,8 +1,6 @@
-require 'logger'
 require "dummy_log_generator/version"
 require "dummy_log_generator/error"
+require "dummy_log_generator/setting"
 require "dummy_log_generator/generator"
-require "dummy_log_generator/formatter"
 require "dummy_log_generator/worker"
 require "dummy_log_generator/dsl"
-

data/lib/dummy_log_generator/cli.rb

@@ -1,39 +1,39 @@
 require 'thor'
 require 'dummy_log_generator'
-require 'active_support/core_ext'
+require 'ext/hash/keys'
+require 'ext/hash/except'
 
 module DummyLogGenerator
   class CLI < Thor
-    class_option :config, :aliases => ["-c"], :type => :string, :default => 'dummy_log_generator.conf'
+    # options for serverengine
+    class_option :pid_path, :aliases => ["-p"], :type => :string, :default => 'dummy_log_generator.pid'
     default_command :start
 
     def initialize(args = [], opts = [], config = {})
       super(args, opts, config)
-
-      @options = @options.dup # avoid frozen
-      if options[:config] && File.exists?(options[:config])
-        dsl = instance_eval(File.read(options[:config]), options[:config])
-        @options[:generator] = dsl.generator
-        @options[:formatter] = dsl.formatter
-        @options[:rate]      = dsl.config.rate
-      end
     end
 
     desc "start", "Start a dummy_log_generator"
-    option :require,     :aliases => ["-r"], :type => :string
+    option :config,      :aliases => ["-c"], :type => :string, :default => 'dummy_log_generator.conf'
+    # options for serverengine
     option :daemonize,   :aliases => ["-d"], :type => :boolean
-    option :module_name, :aliases => ["-m"], :type => :string, :default => 'DummyLogGenerator::Worker'
-    # options for dummy_log_generator
-    option :rate,        :aliases => ["-i"], :type => :numeric
+    option :workers,     :aliases => ["-w"], :type => :numeric
+    option :worker_type,                     :type => :string, :default => 'process'
     def start
-      opts = @options.symbolize_keys.except(:require, :config, :module_name)
+      @options = @options.dup # avoid frozen
+      if options[:config] && File.exists?(options[:config])
+        dsl = instance_eval(File.read(options[:config]), options[:config])
+        @options[:setting] = dsl.setting
+        # options for serverengine
+        @options[:workers] ||= dsl.setting.workers
+      end
 
-      se = ServerEngine.create(nil, @options["module_name"].constantize, opts)
+      opts = @options.symbolize_keys.except(:config)
+      se = ServerEngine.create(nil, DummyLogGenerator::Worker, opts)
       se.run
     end
 
     desc "stop", "Stops a dummy_log_generator"
-    option :pid_path,    :aliases => ["-p"], :type => :string
     def stop
       pid = File.read(@options["pid_path"]).to_i
 
@@ -46,7 +46,6 @@ module DummyLogGenerator
     end
 
     desc "graceful_stop", "Gracefully stops a dummy_log_generator"
-    option :pid_path,    :aliases => ["-p"], :type => :string
     def graceful_stop
       pid = File.read(@options["pid_path"]).to_i
 
@@ -59,7 +58,6 @@ module DummyLogGenerator
     end
 
     desc "restart", "Restarts a dummy_log_generator"
-    option :pid_path,    :aliases => ["-p"], :type => :string
     def restart
       pid = File.read(@options["pid_path"]).to_i
 
@@ -72,7 +70,6 @@ module DummyLogGenerator
     end
 
     desc "graceful_restart", "Graceful restarts a dummy_log_generator"
-    option :pid_path,    :aliases => ["-p"], :type => :string
     def graceful_restart
       pid = File.read(@options["pid_path"]).to_i
 

data/lib/dummy_log_generator/dsl.rb

@@ -1,39 +1,33 @@
-module DummyLogGenerator
-  class Config
-    attr_accessor :rate
-
-    def initiaize
-      @rate = 500
-    end
-  end
-end
-
 module DummyLogGenerator
   class Dsl
-    attr_reader :generator
-    attr_reader :formatter
-    attr_reader :config
+    attr_reader :setting
 
     def initialize
-      @generator = Generator.new
-      @formatter = Formatter.new
-      @config = Config.new
+      @setting = Setting.new
     end
 
     def rate(rate)
-      config.rate = rate
+      setting.rate = rate
+    end
+
+    def output(output)
+      setting.output = output
     end
 
     def field(name, opts)
-      generator.fields[name] = opts
+      setting.fields[name] = opts
     end
 
     def delimiter(delimiter)
-      formatter.delimiter = delimiter
+      setting.delimiter = delimiter
     end
 
     def labeled(labeled)
-      formatter.labeled = labeled
+      setting.labeled = labeled
+    end
+
+    def workers(workers)
+      setting.workers = workers
     end
   end
 end

data/lib/dummy_log_generator/generator.rb

@@ -1,35 +1,45 @@
 module DummyLogGenerator
   class Generator
-    attr_accessor :fields
-    attr_reader :rand
+    def initialize(setting)
+      prepare_format_proc(setting.labeled, setting.delimiter)
+      prepare_field_procs(setting.fields)
+    end
 
-    def initialize
-      @fields = {}
-      @rand = ::DummyLogGenerator::Random.new
+    def prepare_format_proc(labeled, delimiter)
+      @format_proc =
+        if labeled
+          Proc.new {|fields| fields.map {|key, val| "#{key}:#{val}" }.join(delimiter) }
+        else
+          Proc.new {|fields| fields.values.join(delimiter) }
+        end
     end
 
-    def generate(prev_data = {})
-      data = {}
+    def prepare_field_procs(fields)
+      rand = ::DummyLogGenerator::Random.new
+      @field_procs = {}
       fields.each do |key, opts|
         opts = opts.dup
         type = opts.delete(:type)
-        opts[:prev] = prev_data[key]
-        data[key] = case type
-                    when :datetime
-                      rand.datetime(opts)
-                    when :string
-                      rand.string(opts)
-                    when :integer
-                      rand.integer(opts)
-                    when :float
-                      rand.float(opts)
-                    else
-                      raise ConfigError.new(type)
-                    end
+        if rand.respond_to?(type)
+          @field_procs[key] = rand.send(type, opts)
+        else
+          raise ConfigError.new(type)
+        end
+      end
+    end
+
+    def generate(prev_data = {})
+      data = {}
+      @field_procs.each do |key, proc|
+        prev = prev_data[key] || -1
+        data[key] = proc.call(prev)
       end
       data
     end
-    alias_method :gen, :generate
+
+    def format(fields)
+      @format_proc.call(fields)
+    end
   end
 
   class Random
@@ -38,59 +48,82 @@ module DummyLogGenerator
       @chars = ('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a # no symbols and multi-bytes for now
     end
 
-    def string(format: nil, length: 8, any: nil, prev: nil, value: nil)
-      string = if value
-                 value.to_s
-               elsif any
-                 self.any(any)
-               else
-                 Array.new(length){@chars[rand(@chars.size-1)]}.join
-               end
-      format ? sprintf(format, string) : string
+    def string(length: 8, any: nil, value: nil)
+      if value
+        string = value.to_s
+        Proc.new { string }
+      elsif any
+        Proc.new { self.any(any) }
+      else
+        Proc.new { Array.new(length){@chars[rand(@chars.size-1)]}.join }
+      end
     end
 
-    def integer(format: nil, range: nil, countup: false, prev: nil, value: nil)
-      integer = if value
-                  value.to_i
-                elsif range
-                  self.range(range)
-                elsif countup
-                  prev ||= -1
-                  prev.to_i + 1
-                else
-                  rand(0..2,147,483,647)
-                end
-      format ? sprintf(format, integer) : integer
+    def integer(format: nil, range: nil, countup: false, value: nil)
+      if format
+        if value
+          integer = sprintf(format, value.to_i)
+          Proc.new { integer }
+        elsif range
+          Proc.new { sprintf(format, self.range(range)) }
+        elsif countup
+          Proc.new {|prev| sprintf(format, prev.to_i + 1) }
+        else
+          Proc.new { sprintf(format, rand(0..2,147,483,647)) }
+        end
+      else
+        if value
+          integer = value.to_i
+          Proc.new { integer }
+        elsif range
+          Proc.new { self.range(range) }
+        elsif countup
+          Proc.new {|prev| prev + 1 }
+        else
+          Proc.new { rand(0..2,147,483,647) }
+        end
+      end
     end
 
-    def float(format: nil, range: nil, prev: nil, value: nil)
-      float = if value
-                value.to_f
-              elsif range
-                self.range(range)
-              else
-                r = rand(1..358)
-                r * Math.cos(r) # cheat
-              end
-      format ? sprintf(format, float) : float
+    def float(format: nil, range: nil, value: nil)
+      if format
+        if value
+          float = value.to_f
+          Proc.new { sprintf(format, float) }
+        elsif range
+          Proc.new { sprintf(format, self.range(range)) }
+        else
+          Proc.new { r = rand(1..358); sprintf(format, r * Math.cos(r)) }
+        end
+      else
+        if value
+          float = value.to_f
+          Proc.new { float }
+        elsif range
+          Proc.new { self.range(range) }
+        else
+          Proc.new { r = rand(1..358); r * Math.cos(r) }
+        end
+      end
     end
 
-    def datetime(format: "%Y-%m-%d %H:%M:%S.%3N", random: false, prev: nil, value: nil)
-      time = if value
-               value
-             elsif random
-               y = rand(1970..2037);
-               m = rand(1..12);
-               d = rand(1..27);
-               h = rand(0..23);
-               min = rand(0..59);
-               s = rand(0..59);
-               usec = rand(0..999999);
-               Time.local(y, m, d, h, min, s, usec)
-             else
-               Time.now
-             end
-      time.strftime(format)
+    def datetime(format: "%Y-%m-%d %H:%M:%S.%3N", random: false, value: nil)
+      if value
+        Proc.new { value.sprintf(format) }
+      elsif random
+        Proc.new {
+          y = rand(1970..2037);
+          m = rand(1..12);
+          d = rand(1..27);
+          h = rand(0..23);
+          min = rand(0..59);
+          s = rand(0..59);
+          usec = rand(0..999999);
+          Time.local(y, m, d, h, min, s, usec)
+        }
+      else
+        Proc.new { Time.now }
+      end
     end
 
     def range(range)

data/lib/dummy_log_generator/setting.rb

@@ -0,0 +1,14 @@
+module DummyLogGenerator
+  class Setting
+    attr_accessor :rate, :output, :labeled, :delimiter, :fields, :workers
+
+    def initialize
+      @rate = 500
+      @output = STDOUT
+      @labeled = true
+      @delimiter = "\t"
+      @fields = {}
+      @workers = 1
+    end
+  end
+end

data/lib/dummy_log_generator/version.rb

@@ -1,3 +1,3 @@
 module DummyLogGenerator
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/lib/dummy_log_generator/worker.rb

@@ -7,9 +7,16 @@ module DummyLogGenerator
     end
 
     def reload
-      @rate = config[:rate]
-      @formatter = config[:formatter]
-      @generator = config[:generator]
+      @generator = Generator.new(config[:setting])
+      @rate = config[:setting].rate
+
+      output = config[:setting].output
+      if output.respond_to?(:write) and output.respond_to?(:close)
+        @output = output
+      else
+        @output = open(output, (File::WRONLY | File::APPEND | File::CREAT))
+        @output.sync = true
+      end
     end
 
     # thanks! ref. https://github.com/tagomoris/fluent-plugin-dummydata-producer/blob/a550fd4424f71cd9227e138c3c89f600ba40a0d5/lib/fluent/plugin/in_dummydata_producer.rb#L63
@@ -25,7 +32,7 @@ module DummyLogGenerator
             # ToDo: what if generation is slower than I/O?
             # We may should generate data and output in parallel
             prev_data = @generator.generate(prev_data)
-            STDOUT.puts @formatter.format(prev_data)
+            @output.write "#{@generator.format(prev_data)}\n"
           end
           rate_count += batch_num
           sleep 0.1
@@ -35,6 +42,8 @@ module DummyLogGenerator
           sleep 0.04
         end
       end
+    ensure
+      @output.close
     end
 
     def stop

data/lib/ext/hash/except.rb

@@ -0,0 +1,15 @@
+class Hash
+  # Return a hash that includes everything but the given keys. This is useful for
+  # limiting a set of parameters to everything but a few known toggles:
+  #
+  #   @person.update(params[:person].except(:admin))
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/lib/ext/hash/keys.rb

@@ -0,0 +1,138 @@
+class Hash
+  # Return a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def transform_keys
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+.
+  def transform_keys!
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!{ |key| key.to_s }
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options,  :symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match <tt>*valid_keys</tt>, raising ArgumentError
+  # on a mismatch. Note that keys are NOT treated indifferently, meaning if you
+  # use strings for keys but assert symbols as keys, this will fail.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: name"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      raise ArgumentError.new("Unknown key: #{k}") unless valid_keys.include?(k)
+    end
+  end
+
+  # Return a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+end

data/lib/ext/hash/slice.rb

@@ -0,0 +1,42 @@
+class Hash
+  # Slice a hash to include only the given keys. This is useful for
+  # limiting an options hash to valid keys before passing to a method:
+  #
+  #   def search(criteria = {})
+  #     criteria.assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.slice(:mass, :velocity, :time))
+  #
+  # If you have an array of keys you want to limit to, you should splat them:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.slice(*valid_keys))
+  def slice(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end
+
+  # Replaces the hash with only the given keys.
+  # Returns a hash containing the removed key/value pairs.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
+  #   # => {:c=>3, :d=>4}
+  def slice!(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    hash.default      = default
+    hash.default_proc = default_proc if default_proc
+    replace(hash)
+    omit
+  end
+
+  # Removes and returns the key/value pairs matching the given keys.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
+  def extract!(*keys)
+    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dummy_log_generator
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors:
 - sonots
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-18 00:00:00.000000000 Z
+date: 2013-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -38,34 +38,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: active_support
-  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: i18n
-  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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -158,10 +130,13 @@ files:
 - lib/dummy_log_generator/cli.rb
 - lib/dummy_log_generator/dsl.rb
 - lib/dummy_log_generator/error.rb
-- lib/dummy_log_generator/formatter.rb
 - lib/dummy_log_generator/generator.rb
+- lib/dummy_log_generator/setting.rb
 - lib/dummy_log_generator/version.rb
 - lib/dummy_log_generator/worker.rb
+- lib/ext/hash/except.rb
+- lib/ext/hash/keys.rb
+- lib/ext/hash/slice.rb
 homepage: https://github.com/sonots/dummy_log_generator
 licenses:
 - MIT

data/lib/dummy_log_generator/formatter.rb

@@ -1,18 +0,0 @@
-module DummyLogGenerator
-  class Formatter
-    attr_accessor :labeled, :delimiter
-
-    def initialize
-      @labeled = true
-      @delimiter = "\t"
-    end
-
-    def format(fields)
-      if labeled
-        fields.map {|key, val| "#{key}:#{val}" }.join(delimiter)
-      else
-        fields.values.join(delimiter)
-      end
-    end
-  end
-end