honey_format 0.12.0 → 0.13.0

data/exe/honey_format

@@ -4,65 +4,26 @@
 require 'bundler/setup' if ENV['HONEY_FORMAT_GEM_DEV']
 require 'honey_format'
 
-input_path = ARGV.first
-
-columns = nil
-output_path = nil
-delimiter = ','
-header_only = false
-
-require 'optparse'
-
-OptionParser.new do |parser|
-  parser.banner = "Usage: honey_format [file.csv] [options]"
-  parser.default_argv = ARGV
-
-  parser.on("--csv=input.csv", String, "CSV file") do |value|
-    input_path = value
-  end
-
-  parser.on("--[no-]only-header=[output.csv]", "Print only the header") do |value|
-    header_only = value
-  end
-
-  parser.on("--columns=id,name", Array, "Select columns.") do |value|
-    columns = value
-  end
-
-  parser.on("--output=output.csv", String, "CSV output (STDOUT otherwise)") do |value|
-    output_path = value
-  end
-
-  parser.on("--delimiter=,", String, "CSV delimiter (default: ,)") do |value|
-    delimiter = value
-  end
-
-  parser.on("-h", "--help", "How to use") do
-    puts parser
-    exit
-  end
-
-  parser.on_tail('--version', 'Show version') do
-    puts "HoneyFormat version #{HoneyFormat::VERSION}"
-    exit
-  end
-
-  # No argument, shows at tail. This will print an options summary.
-  parser.on_tail("-h", "--help", "Show this message") do
-    puts parser
-    exit
-  end
-end.parse!
-
-csv = HoneyFormat::CSV.new(File.read(input_path), delimiter: delimiter)
-if header_only
-  puts csv.columns.join(',')
-  exit
-end
-
-csv_string = csv.to_csv(columns: columns&.map(&:to_sym))
-if output_path
-  File.write(output_path, csv_string)
+require 'honey_format/cli/cli'
+
+cli = HoneyFormat::CLI.new
+options = cli.options
+
+input_path = options[:input_path] || raise(ArgumentError, 'input path required')
+csv_input = File.read(input_path)
+csv = HoneyFormat::CSV.new(csv_input, delimiter: options[:delimiter])
+
+csv_part = if options[:header_only]
+             csv.header
+           elsif options[:rows_only]
+             csv.rows
+           else
+             csv
+           end
+
+csv_string = csv_part.to_csv(columns: options[:columns])
+if path = options[:output_path]
+  File.write(path, csv_string)
 else
   puts csv_string
 end

data/honey_format.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Jacob Burenstam']
   spec.email         = ['burenstam@gmail.com']
 
-  spec.summary       = 'Convert CSV to objects.'
-  spec.description   = 'Convert CSV to an array of objects with with ease. Create objects for each row with methods matching the column names. No dependencies other than Ruby stdlib.'
+  spec.summary       = 'Makes working with CSVs as smooth as honey.'
+  spec.description   = 'Proper objects for CSV headers and rows, convert column values, filter columns and rows, small(-ish) perfomance overhead, no dependencies other than Ruby stdlib.'
   spec.homepage      = 'https://github.com/buren/honey_format'
   spec.license       = 'MIT'
 

data/lib/honey_format.rb

@@ -1,9 +1,40 @@
 require 'honey_format/version'
+require 'honey_format/configuration'
 require 'honey_format/errors'
+require 'honey_format/value_converter'
 require 'honey_format/csv'
 
+
 # Main module for HoneyFormat
 module HoneyFormat
   # CSV alias
   HoneyCSV = CSV
+
+  # Configure HoneyFormat
+  # @yield [configuration] the configuration
+  # @yieldparam [Configuration] current configuration
+  # @return [Configuration] current configuration
+  def self.configure
+    @configuration ||= Configuration.new
+    yield(@configuration) if block_given?
+    @configuration
+  end
+
+  # Returns the current configuration
+  # @return [Configuration] current configuration
+  def self.config
+    configure
+  end
+
+  # Returns the configured header converter
+  # @return [#call] the current header converter
+  def self.header_converter
+    config.header_converter
+  end
+
+  # Returns the configured value converter
+  # @return [#call] the current value converter
+  def self.value_converter
+    config.converter
+  end
 end

data/lib/honey_format/cli/benchmark_cli.rb

@@ -0,0 +1,124 @@
+require 'optparse'
+require 'honey_format/cli/result_writer'
+
+module HoneyFormat
+  # Benchmark CLI
+  # @attr_reader [Hash] options from command line arguments
+  # @attr_reader [CLIResultWriter] writer the CLI result writer
+  class BenchmarkCLI
+    # CSV default test data location
+    CSV_TEST_DATA_URL = 'https://gist.github.com/buren/b669dd82fa37e37672da2cab33c8a830/raw/54ba14a698941ff61f3b854b66df0a7782c79c85/csv_1000_rows.csv'
+    # CSV default test data cache location
+    CSV_TEST_DATA_CACHE_PATH = '/tmp/honey-format-benchmark-test.csv'
+
+    attr_reader :writer, :options
+
+    # Instantiate the CLI
+    # @param writer [CLIResultWriter] the result writer to use
+    def initialize(writer: CLIResultWriter.new)
+      @used_input_path = nil
+      @writer = writer
+      @options = parse_options(argv: ARGV)
+      writer.verbose = true if @options[:verbose]
+    end
+
+    # Returns the expected runtime in seconds
+    # @param report_count [Integer] number of reports in benchmark
+    # @return [Integer] expected runtime in seconds
+    def expected_runtime_seconds(report_count:)
+      runs = report_count * options[:lines_multipliers].length
+      warmup_time_seconds = runs * options[:benchmark_warmup]
+      bench_time_seconds = runs * options[:benchmark_time]
+
+      warmup_time_seconds + bench_time_seconds
+    end
+
+    # Return the input path used for the benchmark
+    # @return [String] the input path (URL or filepath)
+    def used_input_path
+      options[:input_path] || @used_input_path
+    end
+
+    # Download or fetch the default benchmark file from cache
+    # @return [String] CSV file as a string
+    def fetch_default_benchmark_csv
+      cache_path = CSV_TEST_DATA_CACHE_PATH
+
+      if File.exists?(cache_path)
+        writer.puts "Cache file found at #{cache_path}.", verbose: true
+        @used_input_path = cache_path
+        return File.read(cache_path)
+      end
+
+      writer.print 'Downloading test data file from GitHub..', verbose: true
+      require 'open-uri'
+      open(CSV_TEST_DATA_URL).read.tap do |csv|
+        @used_input_path = CSV_TEST_DATA_URL
+        writer.puts 'done!', verbose: true
+        File.write(cache_path, csv)
+        writer.puts "Wrote cache file to #{cache_path}..", verbose: true
+      end
+    end
+
+    # Parse command line arguments and return options
+    # @param [Array<String>] argv the command lines arguments
+    # @return [Hash] the command line options
+    def parse_options(argv:)
+      input_path = nil
+      benchmark_time = 30
+      benchmark_warmup = 5
+      lines_multipliers = [1]
+      verbose = false
+
+      OptionParser.new do |parser|
+        parser.banner = "Usage: bin/benchmark [file.csv] [options]"
+        parser.default_argv = ARGV
+
+        parser.on("--csv=[file1.csv]", String, "CSV file(s)") do |value|
+          input_path = value
+        end
+
+        parser.on("--[no-]verbose", "Verbose output") do |value|
+          verbose = value
+        end
+
+        parser.on("--lines-multipliers=[1,10,50]", Array, "Multiply the rows in the CSV file (default: 1)") do |value|
+          lines_multipliers = value.map do |v|
+            Integer(v).tap do |int|
+              unless int >= 1
+                raise(ArgumentError, '--lines-multiplier must be 1 or greater')
+              end
+            end
+          end
+        end
+
+        parser.on("--time=[30]", String, "Benchmark time (default: 30)") do |value|
+          benchmark_time = Integer(value)
+        end
+
+        parser.on("--warmup=[30]", String, "Benchmark warmup (default: 30)") do |value|
+          benchmark_warmup = Integer(value)
+        end
+
+        parser.on("-h", "--help", "How to use") do
+          puts parser
+          exit
+        end
+
+        # No argument, shows at tail. This will print an options summary.
+        parser.on_tail("-h", "--help", "Show this message") do
+          puts parser
+          exit
+        end
+      end.parse!
+
+      {
+        input_path: input_path,
+        benchmark_time: benchmark_time,
+        benchmark_warmup: benchmark_warmup,
+        lines_multipliers: lines_multipliers,
+        verbose: verbose,
+      }
+    end
+  end
+end

data/lib/honey_format/cli/cli.rb

@@ -0,0 +1,81 @@
+require 'optparse'
+
+module HoneyFormat
+  # Main CLI
+  # @attr_reader [Hash] options from command line arguments
+  class CLI
+    attr_reader :options
+
+    # Instantiate the CLI
+    # @return [CLI] the CLI
+    def initialize
+      @options = parse_options(argv: ARGV)
+    end
+
+    # Parse command line arguments and return options
+    # @param [Array<String>] argv the command lines arguments
+    # @return [Hash] the command line options
+    def parse_options(argv:)
+      input_path = argv.first
+      columns = nil
+      output_path = nil
+      delimiter = ','
+      header_only = false
+      rows_only = false
+
+      OptionParser.new do |parser|
+        parser.banner = "Usage: honey_format [file.csv] [options]"
+        parser.default_argv = ARGV
+
+        parser.on("--csv=input.csv", String, "CSV file") do |value|
+          input_path = value
+        end
+
+        parser.on("--columns=id,name", Array, "Select columns") do |value|
+          columns = value&.map(&:to_sym)
+        end
+
+        parser.on("--output=output.csv", String, "CSV output (STDOUT otherwise)") do |value|
+          output_path = value
+        end
+
+        parser.on("--delimiter=,", String, "CSV delimiter (default: ,)") do |value|
+          delimiter = value
+        end
+
+        parser.on("--[no-]header-only", "Print only the header") do |value|
+          header_only = value
+        end
+
+        parser.on("--[no-]rows-only", "Print only the rows") do |value|
+          rows_only = value
+        end
+
+        parser.on("-h", "--help", "How to use") do
+          puts parser
+          exit
+        end
+
+        parser.on_tail('--version', 'Show version') do
+          puts "HoneyFormat version #{HoneyFormat::VERSION}"
+          exit
+        end
+
+        # No argument, shows at tail. This will print an options summary.
+        parser.on_tail("-h", "--help", "Show this message") do
+          puts parser
+          exit
+        end
+      end.parse!
+
+      {
+        input_path: input_path,
+        columns: columns,
+        output_path: output_path,
+        delimiter: delimiter,
+        header_only: header_only,
+        rows_only: rows_only,
+      }
+    end
+  end
+end

data/lib/honey_format/cli/result_writer.rb

@@ -0,0 +1,38 @@
+module HoneyFormat
+  # CLI result writer handles command output
+  # @attr_reader [true, false] verbose the writer mode
+  class CLIResultWriter
+    attr_accessor :verbose
+
+    # Instantiate the result writer
+    # @param verbose [true, false] mode (default: false)
+    # @return [CLIResultWriter] the result writer
+    def initialize(verbose: false)
+      @verbose = verbose
+    end
+
+    # Return if verbose mode is true/false
+    # @return [true, false]
+    def verbose?
+      @verbose
+    end
+
+    # Print the string
+    # @param [String] string to print
+    # @param verbose [true, false] mode (default: false)
+    def print(string, verbose: false)
+      return if !verbose? && verbose
+
+      Kernel.print(string)
+    end
+
+    # Puts the string
+    # @param [String] string to puts
+    # @param verbose [true, false] mode (default: false)
+    def puts(string, verbose: false)
+      return if !verbose? && verbose
+
+      Kernel.puts(string)
+    end
+  end
+end

data/lib/honey_format/configuration.rb

@@ -0,0 +1,26 @@
+module HoneyFormat
+  # Holds HoneyFormat configuration
+  # @attr_reader [#call] header_converter the configured header converter
+  # @attr_reader [#call] converter the configured value converter
+  # @attr_writer [#call] header_converter to use
+  # @attr_writer [#call] converter the value converter to use
+  class Configuration
+    attr_accessor :header_converter, :converter
+
+    # Instantiate configuration
+    def initialize
+      @converter = ValueConverter.new
+      @header_converter = @converter[:header_column]
+    end
+
+    # Set the header converter
+    # @param [Symbol, #call] converter for registered value converter or object that responds to #call
+    # @return [#call] the header converter
+    def header_converter=(converter)
+      if converter.is_a?(Symbol)
+        return @header_converter = @converter[converter]
+      end
+      @header_converter = converter
+    end
+  end
+end

data/lib/honey_format/csv.rb

@@ -1,72 +1,69 @@
 require 'csv'
 
-require 'honey_format/rows'
-require 'honey_format/header'
+require 'honey_format/matrix'
+# require 'honey_format/rows'
+# require 'honey_format/header'
 
 module HoneyFormat
   # Represents CSV.
-  class CSV
+  class CSV < Matrix
     # Instantiate CSV.
     # @return [CSV] a new instance of CSV.
     # @param [String] csv the CSV string
-    # @param [String] delimiter the CSV delimiter
+    # @param [String] delimiter the CSV column delimiter
+    # @param [String, Symbol] row_delimiter the CSV row delimiter (default: :auto)
+    # @param [String] quote_character the CSV quote character (default: ")
     # @param [Array<String>] header optional argument that represents CSV header, required if the CSV file lacks a header row.
-    # @param [Array<Symbol>] valid_columns array of symbols representing valid columns, if empty all will be considered valid.
     # @param [#call] header_converter converts header columns.
     # @param [#call] row_builder will be called for each parsed row.
+    # @param type_map [Hash] map of column_name => type conversion to perform.
     # @raise [HeaderError] super class of errors raised when there is a CSV header error.
     # @raise [MissingHeaderError] raised when header is missing (empty or nil).
     # @raise [MissingHeaderColumnError] raised when header column is missing.
-    # @raise [UnknownHeaderColumnError] raised when column is not in valid list.
     # @raise [RowError] super class of errors raised when there is a row error.
     # @raise [EmptyRowColumnsError] raised when row columns are empty.
     # @raise [InvalidRowLengthError] raised when row has more columns than header columns.
-    def initialize(csv, delimiter: ',', header: nil, valid_columns: [], header_converter: ConvertHeaderValue, row_builder: nil)
-      csv = ::CSV.parse(csv, col_sep: delimiter)
-      header_row = header || csv.shift
-      @header = Header.new(header_row, valid: valid_columns, converter: header_converter)
-      @rows = Rows.new(csv, columns, builder: row_builder)
-    end
-
-    # Original CSV header
-    # @return [Array<String>] of strings for sanitized header.
-    def header
-      @header.original
-    end
-
-    # CSV columns converted from the original CSV header
-    # @return [Array<Symbol>] of column identifiers.
-    def columns
-      @header.to_a
-    end
-
-    # @return [Array] of rows.
-    def rows
-      @rows
-    end
-
-    # @yield [row] The given block will be passed for every row.
-    # @yieldparam [Row] row in the CSV.
-    # @return [Enumerator] If no block is given, an enumerator object will be returned.
-    def each_row
-      return rows.each unless block_given?
-
-      rows.each { |row| yield(row) }
-    end
-
-    # Convert CSV object as CSV-string.
-    # @param columns [Array<Symbol>, Set<Symbol>, NilClass] the columns to output, nil means all columns (default: nil)
-    # @yield [row] The given block will be passed for every row - return truthy if you want the row to be included in the output
-    # @yieldparam [Row] row
-    # @return [String] CSV-string representation.
-    # @example with selected columns
-    #   csv.to_csv(columns: [:id, :country])
-    # @example with selected rows
-    #   csv.to_csv { |row| row.country == 'Sweden' }
-    # @example with both selected columns and rows
-    #   csv.to_csv(columns: [:id, :country]) { |row| row.country == 'Sweden' }
-    def to_csv(columns: nil, &block)
-      @header.to_csv(columns: columns) + @rows.to_csv(columns: columns, &block)
+    # @example
+    #   csv = HoneyFormat::CSV.new(csv_string)
+    # @example With custom delimiter
+    #   csv = HoneyFormat::CSV.new(csv_string, delimiter: ';')
+    # @example With custom header converter
+    #   converter = proc { |v| v == 'name' ? 'first_name' : v }
+    #   csv = HoneyFormat::CSV.new("name,id", header_converter: converter)
+    #   csv.columns # => [:first_name, :id]
+    # @example Handle errors
+    #   begin
+    #     csv = HoneyFormat::CSV.new(csv_string)
+    #   rescue HoneyFormat::HeaderError => e
+    #     puts "header error: #{e.class}, #{e.message}"
+    #   rescue HoneyFormat::RowError => e
+    #     puts "row error: #{e.class}, #{e.message}"
+    #   end
+    # @see Matrix#new
+    def initialize(
+      csv,
+      delimiter: ',',
+      row_delimiter: :auto,
+      quote_character: '"',
+      header: nil,
+      header_converter: HoneyFormat.header_converter,
+      row_builder: nil,
+      type_map: {}
+    )
+      csv = ::CSV.parse(
+        csv,
+        col_sep: delimiter,
+        row_sep: row_delimiter,
+        quote_char: quote_character,
+        skip_blanks: true
+      )
+      super(
+        csv,
+        header: header,
+        header_converter: header_converter,
+        row_builder: row_builder,
+        type_map: type_map
+      )
     end
   end
 end