make-data 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 822b436591938dd3af1a73598e7be2c8d0589ca2b25c3a2b73174413cc331a15
+  data.tar.gz: db99bcc728248066077b74a5998130a9ab7afcf257f7396888c0752ce5293650
+SHA512:
+  metadata.gz: df86472bfe58e747a6b7d7be25e197d1dc7a1b03a79a59bce7d4ae7bc9a1d44f0cd16e6d2bdde51f738b723bead12a272228dc0475123bc05ea677d21e501eb5
+  data.tar.gz: 07707f19b71282bcc3e98e72260ae6675c6f03c8f615988804927358f026bec72e0e24727365a35f482cb70cf25ee4d0e8d2974e762b7d5afcf663b5268b9090

data/bin/mkdata

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+
+require 'optparse'
+require 'json'
+require_relative '../lib/make_data.rb'
+
+options = {}
+
+OptionParser.new do |parser|
+  parser.on("-n", "--count [COUNT]", OptionParser::DecimalInteger,
+    "How many records to generate") do |count|
+      options[:count] = count
+  end
+
+  parser.on("-f [FORMAT]", "--format [FORMAT]", MakeData::ResultsFormatter.valid_formats,
+    "Format for the generated records") do |format|
+      options[:format] = format
+  end
+
+  parser.on("-d", "--dry", "--dry-run", "Generate a shape, but don't actually generate the samples") do
+    options[:dry] = true
+  end
+
+  parser.on("--ids", "include an auto-incrementing id column") do
+    options[:ids] = true
+  end
+
+  parser.on("--no-ids", "do not include ids") do
+    options[:ids] = false
+  end
+
+  parser.on("-s [FILENAME]", "--shape [FILENAME]", "File path to a json specification for the shape of records to generate") do |filename|
+    options[:shape] = JSON.parse(File.read(filename))
+  end
+end.parse!
+
+MakeData::CLI.new(options).run

data/lib/make_data.rb

@@ -0,0 +1,177 @@
+#! /usr/bin/env ruby
+require 'faker'
+require 'json'
+require 'csv'
+require 'yaml'
+
+module MakeData
+  class FakerFinder
+    attr_accessor :category
+
+    def initialize(category)
+      @category = category
+      raise ArgumentError.new("Invalid Category") unless Faker.const_get(@category)
+    end
+
+    def self.available_categories
+      Faker.constants - [:Config, :VERSION, :Base, :UniqueGenerator]
+    end
+
+    def klass
+      Faker.const_get(@category)
+    end
+
+    def available_methods
+      klass.methods - klass.superclass.methods
+    end
+  end
+
+  class SampleGenerator
+    attr_accessor :shape
+
+    # shape is a mapping from names to [category, method] pairs
+    # so, { name => ['FunnyName', 'name'], location => ['GameOfThrones', 'location'] }
+    def initialize(shape, ids)
+      @shape = shape
+      @ids = ids
+    end
+
+    def self.generate(category_name, method_name)
+      Faker.const_get(category_name).send(method_name.to_sym)
+    end
+
+    def make_one_from_shape
+      @shape.map do |category, (faker_class, method)|
+        [category, self.class.generate(faker_class, method)]
+      end.to_h
+    end
+
+    def generate(count)
+      count.times.map do |id|
+        make_one_from_shape.tap do |sample|
+          # start ids at 1
+          sample[:id] = id + 1 if @ids
+        end
+      end
+    end
+  end
+
+  class ResultsFormatter
+    def initialize(results, format)
+      @results = results
+      @format = format
+    end
+
+    def format_results
+      send(@format.to_sym)
+    end
+
+    def self.valid_formats
+      %w(json csv yaml)
+    end
+
+    def json
+      JSON.generate(@results)
+    end
+
+    def csv
+      CSV.generate do |csv|
+        csv << @results[0].keys # column headers
+        @results.map(&:values).each { |row| csv << row }
+      end
+    end
+
+    def yaml
+      @results.to_yaml
+    end
+  end
+
+  class CLI
+    class InvalidFormatError < StandardError; end
+
+    def initialize(format: nil, ids: true, count: nil, shape: nil, dry: false)
+      @dry = dry
+      @ids = ids
+      @format = @dry ? :json : format
+      @count = count
+      @shape = shape
+    end
+
+    def run
+      @shape ||= get_shape
+      @format ||= get_format
+      @count ||= get_count unless @dry
+      @results = @dry ? @shape : SampleGenerator.new(@shape, @ids).generate(@count)
+      print_results(@results)
+    end
+
+    def print_results(results, format = @format)
+      print ResultsFormatter.new(results, format).format_results
+    end
+
+    def get_format
+      prompt = "What kind of data do you want to generate?"
+      format = choose_among(prompt, ResultsFormatter.valid_formats)
+      unless ResultsFormatter.valid_formats.include?(format)
+        raise InvalidFormatError.new("File needs to be one of #{ResultsFormatter.valid_formats.join(', ')}")
+      end
+      format
+    end
+
+    def puts_in_columns(strings)
+      col_count = `tput cols`.chomp.to_i
+      col_width = strings.max_by { |s| s.length }.length + 2
+      cols = col_count / col_width
+      strings.each_slice(cols) do |row|
+        row.each { |s| print s.to_s.ljust(col_width) }
+        puts
+      end
+    end
+
+    def choose_among(prompt, strings)
+      `echo "#{strings.join("\n")}" | peco --prompt="#{prompt}>"`.chomp
+    end
+
+    def get_category
+      prompt = "What faker category?"
+      choose_among(prompt, FakerFinder.available_categories.map(&:to_s))
+    end
+
+    def get_method(category)
+      prompt = "What method?"
+      choose_among(prompt, FakerFinder.new(category).available_methods.map(&:to_s))
+    end
+
+    def get_shape(shape = {})
+      puts "---"
+      print_results(shape, 'json')
+      puts "\n---"
+      action = choose_among("What do you want to do?", ["Add a key", "Done"])
+      case action
+      when "Done"
+        return shape
+      when "Add a key"
+        updated = add_key(shape)
+        get_shape(updated)
+      end
+    end
+
+    def get_key
+      puts "What key do you want to add?"
+      gets.chomp
+    end
+
+    def add_key(shape)
+      key = get_key
+      cat = get_category
+      method = get_method(cat)
+      shape[key] = [cat, method]
+      shape
+    end
+
+    def get_count
+      puts "How many records?"
+      gets.chomp.to_i
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: make-data
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Rob Cobb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-15 00:00:00.000000000 Z
+dependencies: []
+description: |2+
+    # MakeData
+    A CLI for generating fake json, csv, or yaml data.
+
+    Uses Faker to produce fake data in whatever category you choose.
+
+    ## Quick Start
+    Requires `peco`, so `brew install peco` (or however you get packages)
+
+    ```
+    mkdata
+    ```
+
+    Follow the prompts to select the category, keys, count, and format.
+
+    ## Options
+
+    `-h --help` Shows the help menu
+
+    `-c --category [CATEGORY]` choose a category from Faker. (I can never remember these, so I use the interactive mode. Mostly here so that this could be used without interaction, like in a script)
+
+    `-f --format [FORMAT]` json, csv, or yaml. What format to generate the data in.
+
+    `-a --all` use all the keys from that Faker category.
+
+email: rwcobbjr@gmail.com
+executables:
+- mkdata
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mkdata
+- lib/make_data.rb
+- lib/runner.rb
+homepage: http://rubygems.org/gems/make_data
+licenses:
+- MIT
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Generate fake data interactively!
+test_files: []