pokedex-terminal 0.2.3 → 0.2.4

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/Rakefile

@@ -0,0 +1,26 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rubygems'
+require 'rake'
+
+require 'rspec/core/rake_task'
+
+desc "Run RSpec"
+RSpec::Core::RakeTask.new do |t|
+  t.verbose = false
+end
+
+desc "Run specs for all test cases"
+task :spec_all do 
+  system "rake spec"
+end
+
+# task :spec_all do
+#   %w[active_record data_mapper mongoid].each do |model_adapter|
+#     puts "MODEL_ADAPTER = #{model_adapter}"
+#     system "rake spec MODEL_ADAPTER=#{model_adapter}"
+#   end
+# end
+
+task :default => :spec

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/lib/extensions/hash.rb

@@ -0,0 +1,7 @@
+# the following extension for class Hash is needed (from Facets of Ruby library):
+
+class Hash
+  def self.zip(keys,values) # from Facets of Ruby library
+    (keys.zip(values)).to_h
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/lib/smarter_csv.rb

@@ -0,0 +1,4 @@
+require 'csv'
+require "smarter_csv/version"
+require "extensions/hash.rb"
+require "smarter_csv/smarter_csv.rb"

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/lib/smarter_csv/smarter_csv.rb

@@ -0,0 +1,305 @@
+module SmarterCSV
+  class SmarterCSVException < StandardError; end
+  class HeaderSizeMismatch < SmarterCSVException; end
+  class IncorrectOption < SmarterCSVException; end
+  class DuplicateHeaders < SmarterCSVException; end
+  class MissingHeaders < SmarterCSVException; end
+
+
+  def SmarterCSV.process(input, options={}, &block)   # first parameter: filename or input object with readline method
+    default_options = {:col_sep => ',' , :row_sep => $/ , :quote_char => '"', :force_simple_split => false , :verbose => false ,
+      :remove_empty_values => true, :remove_zero_values => false , :remove_values_matching => nil , :remove_empty_hashes => true , :strip_whitespace => true,
+      :convert_values_to_numeric => true, :strip_chars_from_headers => nil , :user_provided_headers => nil , :headers_in_file => true,
+      :comment_regexp => /\A#/, :chunk_size => nil , :key_mapping_hash => nil , :downcase_header => true, :strings_as_keys => false, :file_encoding => 'utf-8',
+      :remove_unmapped_keys => false, :keep_original_headers => false, :value_converters => nil, :skip_lines => nil, :force_utf8 => false, :invalid_byte_sequence => '',
+      :auto_row_sep_chars => 500, :required_headers => nil
+    }
+    options = default_options.merge(options)
+    options[:invalid_byte_sequence] = '' if options[:invalid_byte_sequence].nil?
+    csv_options = options.select{|k,v| [:col_sep, :row_sep, :quote_char].include?(k)} # options.slice(:col_sep, :row_sep, :quote_char)
+    headerA = []
+    result = []
+    old_row_sep = $/
+    file_line_count = 0
+    csv_line_count = 0
+    has_rails = !! defined?(Rails)
+    begin
+      f = input.respond_to?(:readline) ? input : File.open(input, "r:#{options[:file_encoding]}")
+
+      if (options[:force_utf8] || options[:file_encoding] =~ /utf-8/i) && ( f.respond_to?(:external_encoding) && f.external_encoding != Encoding.find('UTF-8') || f.respond_to?(:encoding) && f.encoding != Encoding.find('UTF-8') )
+        puts 'WARNING: you are trying to process UTF-8 input, but did not open the input with "b:utf-8" option. See README file "NOTES about File Encodings".'
+      end
+
+      if options[:row_sep] == :auto
+        options[:row_sep] = line_ending = SmarterCSV.guess_line_ending( f, options )
+        f.rewind
+      end
+      $/ = options[:row_sep]
+
+      if options[:skip_lines].to_i > 0
+        options[:skip_lines].to_i.times{f.readline}
+      end
+
+      if options[:headers_in_file]        # extract the header line
+        # process the header line in the CSV file..
+        # the first line of a CSV file contains the header .. it might be commented out, so we need to read it anyhow
+        header = f.readline
+        header = header.force_encoding('utf-8').encode('utf-8', invalid: :replace, undef: :replace, replace: options[:invalid_byte_sequence]) if options[:force_utf8] || options[:file_encoding] !~ /utf-8/i
+        header = header.sub(options[:comment_regexp],'').chomp(options[:row_sep])
+
+        file_line_count += 1
+        csv_line_count += 1
+        header = header.gsub(options[:strip_chars_from_headers], '') if options[:strip_chars_from_headers]
+
+        if (header =~ %r{#{options[:quote_char]}}) and (! options[:force_simple_split])
+          file_headerA = begin
+            CSV.parse( header, csv_options ).flatten.collect!{|x| x.nil? ? '' : x} # to deal with nil values from CSV.parse
+          rescue CSV::MalformedCSVError => e
+            raise $!, "#{$!} [SmarterCSV: csv line #{csv_line_count}]", $!.backtrace
+          end
+        else
+          file_headerA =  header.split(options[:col_sep])
+        end
+        file_headerA.map!{|x| x.gsub(%r/#{options[:quote_char]}/,'') }
+        file_headerA.map!{|x| x.strip}  if options[:strip_whitespace]
+        unless options[:keep_original_headers]
+          file_headerA.map!{|x| x.gsub(/\s+|-+/,'_')}
+          file_headerA.map!{|x| x.downcase }   if options[:downcase_header]
+        end
+
+        file_header_size = file_headerA.size
+      else
+        raise SmarterCSV::IncorrectOption , "ERROR: If :headers_in_file is set to false, you have to provide :user_provided_headers" if options[:user_provided_headers].nil?
+      end
+      if options[:user_provided_headers] && options[:user_provided_headers].class == Array && ! options[:user_provided_headers].empty?
+        # use user-provided headers
+        headerA = options[:user_provided_headers]
+        if defined?(file_header_size) && ! file_header_size.nil?
+          if headerA.size != file_header_size
+            raise SmarterCSV::HeaderSizeMismatch , "ERROR: :user_provided_headers defines #{headerA.size} headers !=  CSV-file #{input} has #{file_header_size} headers"
+          else
+            # we could print out the mapping of file_headerA to headerA here
+          end
+        end
+      else
+        headerA = file_headerA
+      end
+      headerA.map!{|x| x.to_sym } unless options[:strings_as_keys] || options[:keep_original_headers]
+
+      unless options[:user_provided_headers] # wouldn't make sense to re-map user provided headers
+        key_mappingH = options[:key_mapping]
+
+        # do some key mapping on the keys in the file header
+        #   if you want to completely delete a key, then map it to nil or to ''
+        if ! key_mappingH.nil? && key_mappingH.class == Hash && key_mappingH.keys.size > 0
+          headerA.map!{|x| key_mappingH.has_key?(x) ? (key_mappingH[x].nil? ? nil : key_mappingH[x].to_sym) : (options[:remove_unmapped_keys] ? nil : x)}
+        end
+      end
+
+      # header_validations
+      duplicate_headers = []
+      headerA.compact.each do |k|
+        duplicate_headers << k if headerA.select{|x| x == k}.size > 1
+      end
+      raise SmarterCSV::DuplicateHeaders , "ERROR: duplicate headers: #{duplicate_headers.join(',')}" unless duplicate_headers.empty?
+
+      if options[:required_headers] && options[:required_headers].is_a?(Array)
+        missing_headers = []
+        options[:required_headers].each do |k|
+          missing_headers << k unless headerA.include?(k)
+        end
+        raise SmarterCSV::MissingHeaders , "ERROR: missing headers: #{missing_headers.join(',')}" unless missing_headers.empty?
+      end
+
+      # in case we use chunking.. we'll need to set it up..
+      if ! options[:chunk_size].nil? && options[:chunk_size].to_i > 0
+        use_chunks = true
+        chunk_size = options[:chunk_size].to_i
+        chunk_count = 0
+        chunk = []
+      else
+        use_chunks = false
+      end
+
+      # now on to processing all the rest of the lines in the CSV file:
+      while ! f.eof?    # we can't use f.readlines() here, because this would read the whole file into memory at once, and eof => true
+        line = f.readline  # read one line.. this uses the input_record_separator $/ which we set previously!
+
+        # replace invalid byte sequence in UTF-8 with question mark to avoid errors
+        line = line.force_encoding('utf-8').encode('utf-8', invalid: :replace, undef: :replace, replace: options[:invalid_byte_sequence]) if options[:force_utf8] || options[:file_encoding] !~ /utf-8/i
+
+        file_line_count += 1
+        csv_line_count += 1
+        print "processing file line %10d, csv line %10d\r" % [file_line_count, csv_line_count] if options[:verbose]
+        next  if  line =~ options[:comment_regexp]  # ignore all comment lines if there are any
+
+        # cater for the quoted csv data containing the row separator carriage return character
+        # in which case the row data will be split across multiple lines (see the sample content in spec/fixtures/carriage_returns_rn.csv)
+        # by detecting the existence of an uneven number of quote characters
+        multiline = line.count(options[:quote_char])%2 == 1
+        while line.count(options[:quote_char])%2 == 1
+          next_line = f.readline
+          next_line = next_line.force_encoding('utf-8').encode('utf-8', invalid: :replace, undef: :replace, replace: options[:invalid_byte_sequence]) if options[:force_utf8] || options[:file_encoding] !~ /utf-8/i
+          line += next_line
+          file_line_count += 1
+        end
+        print "\nline contains uneven number of quote chars so including content through file line %d\n" % file_line_count if options[:verbose] && multiline
+
+        line.chomp!    # will use $/ which is set to options[:col_sep]
+
+        if (line =~ %r{#{options[:quote_char]}}) and (! options[:force_simple_split])
+          dataA = begin
+            CSV.parse( line, csv_options ).flatten.collect!{|x| x.nil? ? '' : x} # to deal with nil values from CSV.parse
+          rescue CSV::MalformedCSVError => e
+            raise $!, "#{$!} [SmarterCSV: csv line #{csv_line_count}]", $!.backtrace
+          end
+        else
+          dataA =  line.split(options[:col_sep])
+        end
+####     dataA.map!{|x| x.gsub(%r/#{options[:quote_char]}/,'') }  # this is actually not a good idea as a default
+        dataA.map!{|x| x.strip}  if options[:strip_whitespace]
+        hash = Hash.zip(headerA,dataA)  # from Facets of Ruby library
+        # make sure we delete any key/value pairs from the hash, which the user wanted to delete:
+        # Note: Ruby < 1.9 doesn't allow empty symbol literals!
+        hash.delete(nil); hash.delete('');
+        if RUBY_VERSION.to_f > 1.8
+          eval('hash.delete(:"")')
+        end
+
+        # remove empty values using the same regexp as used by the rails blank? method
+        # which caters for double \n and \r\n characters such as "1\r\n\r\n2" whereas the original check (v =~ /^\s*$/) does not
+        if options[:remove_empty_values]
+          if has_rails
+            hash.delete_if{|k,v| v.blank?}
+          else
+            hash.delete_if{|k,v| v.nil? || v !~ /[^[:space:]]/}
+          end
+        end
+
+        hash.delete_if{|k,v| ! v.nil? && v =~ /^(\d+|\d+\.\d+)$/ && v.to_f == 0} if options[:remove_zero_values]   # values are typically Strings!
+        hash.delete_if{|k,v| v =~ options[:remove_values_matching]} if options[:remove_values_matching]
+        if options[:convert_values_to_numeric]
+          hash.each do |k,v|
+            # deal with the :only / :except options to :convert_values_to_numeric
+            next if SmarterCSV.only_or_except_limit_execution( options, :convert_values_to_numeric , k )
+
+            # convert if it's a numeric value:
+            case v
+            when /^[+-]?\d+\.\d+$/
+              hash[k] = v.to_f
+            when /^[+-]?\d+$/
+              hash[k] = v.to_i
+            end
+          end
+        end
+
+        if options[:value_converters]
+          hash.each do |k,v|
+            converter = options[:value_converters][k]
+            next unless converter
+            hash[k] = converter.convert(v)
+          end
+        end
+
+        next if hash.empty? if options[:remove_empty_hashes]
+
+        if use_chunks
+          chunk << hash  # append temp result to chunk
+
+          if chunk.size >= chunk_size || f.eof?   # if chunk if full, or EOF reached
+            # do something with the chunk
+            if block_given?
+              yield chunk  # do something with the hashes in the chunk in the block
+            else
+              result << chunk  # not sure yet, why anybody would want to do this without a block
+            end
+            chunk_count += 1
+            chunk = []  # initialize for next chunk of data
+          else
+
+            # the last chunk may contain partial data, which also needs to be returned (BUG / ISSUE-18)
+
+          end
+
+          # while a chunk is being filled up we don't need to do anything else here
+
+        else # no chunk handling
+          if block_given?
+            yield [hash]  # do something with the hash in the block (better to use chunking here)
+          else
+            result << hash
+          end
+        end
+      end
+
+      # print new line to retain last processing line message
+      print "\n" if options[:verbose]
+
+      # last chunk:
+      if ! chunk.nil? && chunk.size > 0
+        # do something with the chunk
+        if block_given?
+          yield chunk  # do something with the hashes in the chunk in the block
+        else
+          result << chunk  # not sure yet, why anybody would want to do this without a block
+        end
+        chunk_count += 1
+        chunk = []  # initialize for next chunk of data
+      end
+    ensure
+      $/ = old_row_sep   # make sure this stupid global variable is always reset to it's previous value after we're done!
+      f.close if f.respond_to?(:close)
+    end
+    if block_given?
+      return chunk_count  # when we do processing through a block we only care how many chunks we processed
+    else
+      return result # returns either an Array of Hashes, or an Array of Arrays of Hashes (if in chunked mode)
+    end
+  end
+
+  private
+  # acts as a road-block to limit processing when iterating over all k/v pairs of a CSV-hash:
+
+  def self.only_or_except_limit_execution( options, option_name, key )
+    if options[option_name].is_a?(Hash)
+      if options[option_name].has_key?( :except )
+        return true if Array( options[ option_name ][:except] ).include?(key)
+      elsif options[ option_name ].has_key?(:only)
+        return true unless Array( options[ option_name ][:only] ).include?(key)
+      end
+    end
+    return false
+  end
+
+  # limitation: this currently reads the whole file in before making a decision
+  def self.guess_line_ending( filehandle, options )
+    counts = {"\n" => 0 , "\r" => 0, "\r\n" => 0}
+    quoted_char = false
+
+    # count how many of the pre-defined line-endings we find
+    # ignoring those contained within quote characters
+    last_char = nil
+    lines = 0
+    filehandle.each_char do |c|
+      quoted_char = !quoted_char if c == options[:quote_char]
+      next if quoted_char
+
+      if last_char == "\r"
+        if c == "\n"
+          counts["\r\n"] +=  1
+        else
+          counts["\r"] += 1  # \r are counted after they appeared, we might
+        end
+      elsif c == "\n"
+        counts["\n"] += 1
+      end
+      last_char = c
+      lines += 1
+      break if options[:auto_row_sep_chars] && options[:auto_row_sep_chars] > 0 && lines >= options[:auto_row_sep_chars]
+    end
+    counts["\r"] += 1 if last_char == "\r"
+    # find the key/value pair with the largest counter:
+    k,_ = counts.max_by{|_,v| v}
+    return k                    # the most frequent one is it
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/lib/smarter_csv/version.rb

@@ -0,0 +1,3 @@
+module SmarterCSV
+  VERSION = "1.2.6"
+end

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/smarter_csv.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/smarter_csv/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tilo Sloboda\n"]
+  gem.email         = ["tilo.sloboda@gmail.com\n"]
+  gem.description   = %q{Ruby Gem for smarter importing of CSV Files as Array(s) of Hashes, with optional features for processing large files in parallel, embedded comments, unusual field- and record-separators, flexible mapping of CSV-headers to Hash-keys}
+  gem.summary       = %q{Ruby Gem for smarter importing of CSV Files (and CSV-like files), with lots of optional features, e.g. chunked processing for huge CSV files}
+  gem.homepage      = "https://github.com/tilo/smarter_csv"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "smarter_csv"
+  gem.require_paths = ["lib"]
+  gem.requirements  = ['csv'] # for CSV.parse() only needed in case we have quoted fields
+  gem.version       = SmarterCSV::VERSION
+  gem.licenses      = ['MIT','GPL-2']
+  gem.add_development_dependency "rspec"
+#  gem.add_development_dependency "guard-rspec"
+end

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/spec/fixtures/basic.csv

@@ -0,0 +1,8 @@
+First Name,Last Name,Dogs,Cats,Birds,Fish
+Dan,McAllister,2,0,,
+Lucy,Laweless,,5,0,
+,,,,,
+Miles,O'Brian,0,0,0,21
+Nancy,Homes,2,0,1, 
+Hernán,Curaçon,3,0,0,
+,,,,,

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/spec/fixtures/binary.csv

@@ -0,0 +1 @@
+#timestamp
item_id
parent_id
name#some comments here#these can be multiple comments in the header section#even more comments here1381388409
10
1
Thing 11381388409
11
1
Thing 21381388409
12
1
Thing 31381388409
1

Parent 11381388409
2

Parent 21381388409
20
2
Thing 41381388409
21
2
Thing 51381388409
22
2
Thing 6

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/spec/fixtures/carriage_returns_n.csv

@@ -0,0 +1,18 @@
+Name,Street,City
+Anfield,Anfield Road,Liverpool
+"Highbury
+Highbury House",75 Drayton Park,London
+Old Trafford,"Sir Matt 
+Busby Way",Manchester
+St. James' Park,,"Newcastle-upon-tyne 
+Tyne and Wear"
+"White Hart Lane
+(The Lane)","Bill Nicholson Way 
+748 High Rd","Tottenham
+London"
+Stamford Bridge,"Fulham Road
+London",
+"Etihad Stadium
+Rowsley St
+Manchester",,
+Goodison,Goodison Road,Liverpool

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/spec/fixtures/carriage_returns_quoted.csv

@@ -0,0 +1,3 @@
+Band,Members,Albums
+New Order,"Bernard Sumner
+Led Zeppelin,"Jimmy Page

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/spec/fixtures/carriage_returns_r.csv

@@ -0,0 +1 @@
+Name,Street,City

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/spec/fixtures/carriage_returns_rn.csv

@@ -0,0 +1,18 @@
+Name,Street,City
+Anfield,Anfield Road,Liverpool
+"Highbury
+Highbury House",75 Drayton Park,London
+Old Trafford,"Sir Matt 
+Busby Way",Manchester
+St. James' Park,,"Newcastle-upon-tyne 
+Tyne and Wear"
+"White Hart Lane
+(The Lane)","Bill Nicholson Way 
+748 High Rd","Tottenham
+London"
+Stamford Bridge,"Fulham Road
+London",
+"Etihad Stadium
+Rowsley St
+Manchester",,
+Goodison,Goodison Road,Liverpool

data/vendor/bundle/ruby/2.7.0/gems/smarter_csv-1.2.6/spec/fixtures/chunk_cornercase.csv

@@ -0,0 +1,10 @@
+a,b,c
+1,2,3
+,,
+4,5,6
+7,8,9
+,,
+10,11,12
+,,
+13,14,15
+,,