faked_csv 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56102a797c421e299e8ba038c686b6c513015b96
+  data.tar.gz: fba1e160834bd6f27d90896c258e9e30b2c588f8
+SHA512:
+  metadata.gz: 53d314f1d7eeffb899dfe8c17629aa8245c98e19e22e4455f02b1508d28953f1bd7ee35c8989dbe85740765172223ac8d955e97c40202f4787f54a04a271d0cf
+  data.tar.gz: 4704171816ab7dbd1751b72099ea51b8dccf92c543de2c679ca0cc6fc80edf9c47e0797aed507e78c4473f10c3f539bdac01d00cac9c849be9cc3146c7a65f83

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in faked_csv.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Jianan Lu
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,199 @@
+# Faking CSV data made easy
+
+faked_csv, using the awesome [Faker](https://github.com/stympy/faker) gem, helps you to generate CSV file with fake random data in your specified way. You may find it particularly useful in testing something out.
+
+## Installation
+
+```
+gem install faked_csv
+```
+
+Test your installation by running the following command in your terminal/console:
+
+```
+faked_csv --version
+```
+
+You can also install the gem using bundler.
+
+The gem is developed and tested under Ruby 2.1.
+
+## Usage
+
+For each faked CSV file, you first create a `<name>.csv.json` file that contains the configuration of how you want to generate the faked data, as hinted by the name, in `json` format.
+
+## Example
+
+A simple example `.csv.json` file looks like the following. Noted, JSON file doesn't support inline comment, so the below example is only for illustration. You can use the `example.csv.json` file in the root folder of the source code as a boilerplate. More details on the configuration file are in later section.
+
+```
+{
+  "rows": 200, <- how many rows in the generated CSV
+  "fields": [  <- a list of fields/columns in the generated CSV
+    {
+      "name": "ID",        <- field/column name
+      "type": "rand:char", <- type/format of the field
+      "length": 5          <- 5 characters random word
+    },
+    {
+      "name": "First Name",
+      "type": "fixed",     <- values will only come from the below list
+      "values": ["Peter", "Tom", "Jane", "Tony", "Steve", "John"]
+    },
+    {
+      "name": "Last Name",
+      "type": "faker:name:last_name", <- via Faker::Name.last_name method
+      "inject": ["Lu", "Smith"]       <- "must-have" values
+    },
+    {
+      "name": "City",
+      "type": "faker:address:city", <- via Faker::Address.city method
+      "rotate": "rows/5"            <- rows/5 (=>200/5 =>40) unique values
+                                       (and only these values) will appear
+    },
+    {
+      "name": "State",
+      "type": "faker:address:state_abbr",
+      "rotate": 10,    <- both rotate and inject? will make sure 10 unique 
+                          values (including "CA") appear
+      "inject": ["CA"]
+    },
+    {
+      "name": "Age",
+      "type": "rand:int",
+      "range": [10, 80] <- range (including boundaries) for random integers
+    },
+    {
+      "name": "Height",
+      "type": "rand:float",
+      "range": [150, 190],  <- range for random floats
+      "inject": [200, 210], <- "must-have" values. can be any format
+      "rotate": 20,         <- 20 unique values (including injects)
+      "precision": 2        <- precision of the float numbers
+    }
+  ]
+}
+```
+
+With the `<name>.csv.json` file, now you can generate a random CSV by invoking the following command:
+
+```
+faked_csv -i example.csv.json -o example.csv
+```
+
+The output CSV looks something like:
+
+```
+ID,First Name,Last Name,City,State,Age,Height
+iW00K,Jane,Bosco,Lake Dandreland,ME,61,170.57
+BzxTl,Steve,Smith,Uniqueside,PA,35,152.93
+vobj8,Tony,Auer,Tressiestad,MS,63,160.86
+X78RS,Steve,Cole,Port Zellachester,OH,72,159.84
+0YpWG,John,Lu,East Vernaview,OH,18,200
+4JaoZ,Peter,Simonis,Wernerchester,HI,25,161.64
+hP48C,Tom,Lu,Uniqueside,ME,45,161.64
+WDQpb,John,Casper,East Felicityshire,OH,41,170.57
+wyPwB,Jane,Johns,Maggiehaven,CA,16,180.42
+VCtYR,Peter,Jast,Schadenberg,ME,41,161.64
+1VYOs,John,Daniel,Port Zellachester,HI,34,200
+V7pg9,Tom,Mayert,Schadenberg,OH,71,152.93
+SmE9w,Jane,Lu,Stephanchester,HI,25,176.95
+ALyok,Tom,Smith,Ryanchester,PA,70,176.95
+fgE5v,Peter,Bailey,Bednarstad,PA,67,170.24
+eBIIM,Peter,Haley,East Vernaview,MS,65,161.64
+5sv4L,Peter,Prosacco,Uniqueside,PA,50,178.25
+a48IS,Peter,Marvin,Kossview,OH,63,200
+9mLcZ,John,VonRueden,East Vernaview,PA,20,174.24
+N8ysZ,Tony,Barrows,Wernerchester,HI,62,159.84
+PxsfA,John,Lind,East Vernaview,OH,21,182.45
+lKM33,Steve,Bosco,South Reese,OH,75,176.95
+HR9H5,Jane,Torp,Tressiestad,PA,23,170.57
+JTRCw,Steve,Hermann,Kunzefort,MS,43,152.93
+Wndzb,Tony,McGlynn,Lake Dandreland,CA,52,160.86
+ksmvF,Peter,Rutherford,Josiannetown,PA,12,184.08
+cfsBG,Peter,Lebsack,Port Zellachester,OH,43,182.45
+7ISEJ,Steve,Altenwerth,Stephanchester,HI,13,159.84
+Letb8,John,Frami,South Reese,HI,65,170.57
+......
+```
+
+## CLI Options
+
+`-i` to specify the input json configuration file. If omitted, the program will try to find `./faked.csv.json` by default. You can also specify a remote URL of the configuration file.
+
+```
+faked_csv -i http://goo.gl/xDtkJs -o remote.csv
+```
+
+`-o` to specify the output CSV file path. If omitted, the program will print the data to stdout.
+
+## More details on configuration file
+
+`rows` to specify how many rows you want to generate in the output CSV file.
+
+`fields` to specify the list of all fields of the generated CSV file.
+
+```
+{
+    "rows": 1000,
+    "fields": [
+        ...
+    ]
+}
+```
+
+For each field, two attributes are required:
+
+`name` to specify the column display name.
+
+`type` to sepcify the format of the data in this column.
+
+Optional attributes help finer control the generated output.
+
+`inject` to specify a list of values that must appear in this column. this is useful when you want to specifically inject some special values into your final CSV. The inject values can be in the same or different format as the type of this column.
+
+`rotate` to specify the number of unique values that will be used in this column. This number will include the number of items you put into `inject` list.
+
+```
+"type": "faker:address:state_abbr",
+"inject": ["CA", "HI"],
+"rotate": 10
+```
+
+In the above example, totally 10 states will be considered in the generation process. 2 of them are given by you, i.e. CA and HI; 8 of them will be faked by calling Faker::Address.state_abbr() method. If you specify `rows` to be greater than 10, some values will be repeated, meaning only 10 unique values will appear and these 10 values are ensured to appear at least once. If you specify `rows` less than 10, only `rows` number of unique values will appear; and your `inject` values will have higher priority, meaning if `rows` is 2, then only CA and HI will appear in the final output.
+
+### Supported types
+
+#### rand:int and rand:float
+
+Random integers/floats. The following attributes are available:
+
+`range` to specify the minimum and maximum value that will be generated.
+
+```
+"range": [10, 100] <- the min=10 and max=100. 10 and 100 are included.
+```
+
+If it's `rand:float`, you can specify `precision` attribute to indicate the digit(s) you want to keep for each of the data.
+
+#### rand:char
+
+Random characters. Only A-Z, a-z and 0-9 will be considered as characters.
+
+`length` to specify how many characters in each of the generated data, e.g. 15 will give you something like `9mLcZHR9H5V7pg9`. This is particularly useful if you want to mimic something like item ID, access token etc.
+
+#### faker:[class]:[method]
+
+This indicates you want to use one of the methods from Faker gem. You can find the list of all methods from [Faker gem's documentation](http://rubydoc.info/github/stympy/faker). Each method is a class name and a method name. Example, `Faker::Internet.url` can be mapped to `faker:internet:url` as a field type in the configuration. As current version, we don't support parameters into the faker method. Future version will add such support.
+
+#### fixed
+
+This indicates you only want to use the provided values in the output. Use `values` as a list to provide the values you want to use. They will be randomly picked independently each time; so no guarantee that every value in the list will be used. If you use `fixed` type, `inject` and `rotate` will be ignored.
+
+## Contributing
+
+1. Fork it ( https://github.com/jiananlu/faked_csv/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/faked_csv

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'faked_csv/cli'
+FakedCSV::CLI.start(ARGV)

data/example.csv.json

@@ -0,0 +1,44 @@
+{
+  "rows": 200,
+  "fields": [
+    {
+      "name": "ID",
+      "type": "rand:char",
+      "length": 5
+    },
+    {
+      "name": "First Name",
+      "type": "fixed",
+      "values": ["Peter", "Tom", "Jane", "Tony", "Steve", "John"]
+    },
+    {
+      "name": "Last Name",
+      "type": "faker:name:last_name",
+      "inject": ["Lu", "Smith"]
+    },
+    {
+      "name": "City",
+      "type": "faker:address:city",
+      "rotate": "rows/5"
+    },
+    {
+      "name": "State",
+      "type": "faker:address:state_abbr",
+      "rotate": 10,
+      "inject": ["CA"]
+    },
+    {
+      "name": "Age",
+      "type": "rand:int",
+      "range": [10, 80]
+    },
+    {
+      "name": "Height",
+      "type": "rand:float",
+      "range": [150, 190],
+      "inject": [200, 210],
+      "rotate": 20,
+      "precision": 2
+    }
+  ]
+}

data/faked_csv.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'faked_csv/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "faked_csv"
+  spec.version       = FakedCSV::VERSION
+  spec.authors       = ["Jianan Lu"]
+  spec.email         = ["jianan.lu@salesforce.com"]
+  spec.summary       = %q{Generate faked CSV data in the specified way.}
+  spec.description   = %q{Makes generating CSV file with faked, random data easy to do.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.3"
+  spec.add_development_dependency "rspec", "~> 2.14"
+  spec.add_development_dependency "cucumber", "~> 1.3"
+  spec.add_development_dependency "aruba", "~> 0.5"
+  spec.add_development_dependency "byebug", "~> 3.1"
+
+  spec.add_dependency "faker", "~> 1.3"
+  spec.add_dependency "json", "~> 1.8"
+  spec.add_dependency "open_uri_redirections", "~> 0.1"
+end

data/features/faked_csv.feature

@@ -0,0 +1,28 @@
+Feature: faked_csv CLI program
+
+Scenario: Show help message
+    When I run `faked_csv -h`
+    Then the output should contain "Usage: faked_csv -i <input.csv.json> -o <output.csv>"
+
+Scenario: Show version
+    When I run `faked_csv --version`
+    Then the output should contain "version:"
+
+Scenario: Generate basic csv
+    When I run `faked_csv -i ../../spec/data/basic.csv.json -o output.csv`
+    Then the output should contain exactly ""
+    And the file "output.csv" should contain "ID,First Name,Last Name,City,State,Age,Height"
+
+Scenario: Generate basic csv and print to stdout
+    When I run `faked_csv -i ../../spec/data/basic.csv.json`
+    Then the output should contain "ID,First Name,Last Name,City,State,Age,Height"
+
+Scenario: Find no default files
+    When I run `faked_csv`
+    Then the output should contain "error openning the input source: No such file or directory"
+    And the output should contain "./faked.csv.json"
+
+Scenario: Getting from HTTP
+    When I run `faked_csv -i http://goo.gl/xDtkJs -o remote.csv`
+    Then the output should contain exactly ""
+    And the file "remote.csv" should contain "ID,First Name,Last Name,City,State,Age,Height"

data/features/support/setup.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/lib/faked_csv.rb

@@ -0,0 +1,9 @@
+require "faked_csv/version"
+require "faked_csv/config"
+require "faked_csv/fakerer"
+require "faked_csv/generator"
+require "faked_csv/printer"
+require "faked_csv/cli"
+
+module FakedCSV
+end

data/lib/faked_csv/cli.rb

@@ -0,0 +1,65 @@
+require 'optparse'
+require 'json'
+require 'open-uri'
+require 'open_uri_redirections'
+require 'faked_csv'
+
+module FakedCSV
+    class CLI
+        def self.start(args)
+            options = {}
+            OptionParser.new do |opts|
+                opts.banner = "Usage: faked_csv -i <input.csv.json> -o <output.csv>"
+                opts.on("-i", "--input JSON", "input path to json configuration file. default: ./faked.csv.json") do |input|
+                    options[:input] = input
+                end
+                opts.on("-o", "--output CSV", "output path to csv file. if omit, print to STDOUT") do |output|
+                    options[:output] = output
+                end
+                opts.on("-v", "--version", "print version message") do
+                    puts "version: #{VERSION}"
+                    return
+                end
+            end.parse!(args)
+
+            options[:input] = './faked.csv.json' unless options.has_key? :input
+
+            json = nil
+            begin
+                if options[:input] =~ /^http/
+                    # remote resouce
+                    open(options[:input], allow_redirections: :all) do |f|
+                        arr = []
+                        f.each_line {|line| arr << line}
+                        json = arr.join("\n")
+                    end
+                else
+                    # normal file
+                    json = File.read options[:input]
+                end
+            rescue Exception=>e
+                puts "error openning the input source: #{e.to_s}"
+                exit 1
+            end
+
+            generator = FakedCSV::Generator.new FakedCSV::Config.new JSON.parse json
+            generator.generate
+            printer = FakedCSV::Printer.new(generator.headers, generator.rows)
+            s = printer.print
+
+            unless options.has_key? :output
+                puts s
+                return
+            end
+
+            begin
+                File.open options[:output], 'w' do |f|
+                    f.write s
+                end
+            rescue Exception=>e
+                puts "error writing to csv file: #{e.to_s}"
+                exit 2
+            end
+        end
+    end
+end

data/lib/faked_csv/config.rb

@@ -0,0 +1,111 @@
+module FakedCSV
+    class Config
+        attr_reader :config, :fields, :row_count
+
+        def initialize(config)
+            @config = config
+        end
+
+        def fields
+            parse if @fields.nil? # parse first if not parsed yet
+            @fields
+        end
+
+        def headers
+            fields.map{|f| f[:name]}
+        end
+
+        # prepare the json config and generate the fields
+        def parse
+            if @config["rows"].nil? || @config["rows"].to_i < 0
+                @row_count = 100 # default value
+            else
+                @row_count = @config["rows"].to_i
+            end
+
+            @fields = []
+            if @config["fields"].nil? || @config["fields"].empty?
+                raise "need 'fields' in the config file and at least 1 field in it"
+            end
+
+            @config["fields"].each do |cfg|
+                field = {}
+
+                if cfg["name"].nil?
+                    raise "field needs a name"
+                end
+                field[:name] = cfg["name"].to_s
+
+                if cfg["type"].nil? || cfg["type"].empty?
+                    raise "field needs a type"
+                end
+                field[:type] = cfg["type"].to_s
+
+                unless cfg["inject"].nil? || cfg["inject"].empty? || !cfg["inject"].kind_of?(Array)
+                    field[:inject] = cfg["inject"].uniq # get rid of duplicates
+                end
+
+                unless cfg["rotate"].nil?
+                    field[:rotate] = _validate_rotate cfg["rotate"]
+                end
+
+                case field[:type]
+                when /rand:int/i
+                    field[:type] = :rand_int
+                    if cfg["range"].nil?
+                        # no range specified? use the default range: [0, 100]
+                        field[:min], field[:max] = 0, 100
+                    else
+                        field[:min], field[:max] = _min_max cfg["range"]
+                    end
+                when /rand:float/i
+                    field[:type] = :rand_float
+                    if cfg["range"].nil?
+                        # no range specified? use the default range: [0, 1]
+                        field[:min], field[:max] = 0, 1
+                    else
+                        field[:min], field[:max] = _min_max cfg["range"]
+                    end
+                    field[:precision] = cfg["precision"].nil? ? 1 : cfg["precision"].to_i
+                when /rand:char/i
+                    field[:type] = :rand_char
+                    field[:length] = cfg["length"].nil? ? 10 : cfg["length"]
+                when /fixed/i
+                    field[:type] = :fixed
+                    raise "need values for fixed type" if cfg["values"].nil?
+                    field[:values] = cfg["values"]
+                when /faker:\S+/i
+                    field[:type] = cfg["type"]
+                else
+                    raise "unsupported type: #{field[:type]}. supported types: #{_supported_types}"
+                end
+
+                fields << field
+            end
+        end
+
+        def _supported_types
+            ['rand:int', 'rand:float', 'rand:char', 'fixed', 'faker:<class>:<method>'].join ", "
+        end
+
+        def _min_max(range)
+            unless range.kind_of?(Array) && range.size == 2
+                raise "invalid range. should be like: [0, 100]"
+            end
+            if range[0] >= range[1]
+                raise "invalid range. 1st is >= 2nd"
+            end
+            return range[0], range[1]
+        end
+
+        def _validate_rotate(rotate)
+            if rotate.to_s.include? "rows/"
+                div = rotate.split("/")[1].to_i
+                r = @row_count / div
+            else
+                r = rotate.to_i
+            end
+            return r > @row_count ? @row_count : r
+        end
+    end
+end

data/lib/faked_csv/fakerer.rb

@@ -0,0 +1,31 @@
+require 'faker'
+
+# skip validation of locales
+I18n.enforce_available_locales = false
+
+module FakedCSV
+    class Fakerer
+        attr_reader :type
+        def initialize(type)
+            @type = type
+            faker, class_name, @method = @type.split ':'
+            begin
+                @class = Kernel.const_get("Faker::#{_camelize class_name}")
+            rescue
+                raise "unsupported faker class: #{class_name}"
+            end
+        end
+
+        def fake
+            begin
+                @class.send @method
+            rescue
+                raise "unsupported faker method: #{@method}"
+            end
+        end
+
+        def _camelize(str)
+            str.split('_').map {|w| w.capitalize}.join
+        end
+    end
+end

data/lib/faked_csv/generator.rb

@@ -0,0 +1,170 @@
+module FakedCSV
+    class Generator
+        attr_reader :config, :rows
+
+        def initialize(config)
+            @config = config
+        end
+
+        def headers
+            @config.headers
+        end
+
+        def rows
+            return @rows unless @rows.nil?
+            @rows = []
+            (0...@config.row_count).each do |r|
+                row = []
+                @config.fields.each do |field|
+                    row << field[:data][r]
+                end
+                @rows << row
+            end
+            @rows
+        end
+
+        def generate
+            prepare_values
+
+            @config.fields.each do |field|
+                field[:data] = []
+
+                # let's get some data!
+                if field[:rotate].nil? || field[:type] == :fixed
+                    # not rotating? or fixed values? generate random value each time
+                    @config.row_count.times do
+                        field[:data] << _random_value(field)
+                    end
+
+                    # inject user values if given and not fixed type
+                    unless field[:type] == :fixed || field[:inject].nil?
+                        _random_inject(field[:data], field[:inject])
+                    end
+                else
+                    # rotating? pick from prepared values
+                    _random_distribution(@config.row_count, field[:values].size) do |i, j|
+                        field[:data][i] = field[:values][j]
+                    end
+                end
+            end
+        end
+
+        def prepare_values
+            @config.fields.each do |field|
+                # if it's fixed values or no rotate
+                # we don't want to prepare values for this field
+                if field[:type] == :fixed || field[:rotate].nil?
+                    next
+                end
+
+                # we don't have enough integers for the rotate
+                if field[:type] == :rand_int && field[:rotate] > field[:max] - field[:min] + 1
+                    raise "rotate should not be greater than the size of the range"
+                end
+
+                values = {}
+                # let's first inject all user values if given
+                unless field[:inject].nil?
+                    field[:inject].each do |inj|
+                        values[inj] = true
+                        # truncate more inject values if we go over the rows count
+                        break if values.size == @config.row_count
+                    end
+                end
+                # then generate as many data as we need
+                _loop do
+                    # we want to get <rotate> unique values. stop when we got enough
+                    break if values.size >= field[:rotate]
+                    v = _random_value(field)
+                    values[v] = true
+                end
+                field[:values] = values.keys
+            end
+        end
+
+        def _random_distribution(total, parts)
+            raise "parts has to be greater than 0" unless parts > 0
+            raise "parts should not be greater than total" if total < parts
+            cuts = {}
+            _loop do
+                break if cuts.size == parts - 1
+                cuts[rand(total - 1)] = true
+            end
+            arr = []
+            part_index = 0
+            (0...total).each do |i|
+                arr << part_index
+                part_index += 1 if cuts.has_key? i
+            end
+            arr.shuffle.each_with_index do |v, i|
+                yield(i, v)
+            end
+        end
+
+        # inject <injects> into <values>
+        def _random_inject(values, injects)
+            used_indexes = {}
+            count = injects.size > values.size ? values.size : injects.size
+            (0...count).each do |i|
+                inj = injects[i]
+                times_inject = rand(values.size / injects.size / 10)
+                times_inject = 1 if times_inject < 1
+                times_inject.times do
+                    rand_index = rand(values.size)
+                    _loop do
+                        break unless used_indexes.has_key? rand_index
+                        rand_index = rand(values.size)
+                    end
+                    used_indexes[rand_index] = true
+                    values[rand_index] = inj
+                end
+            end
+        end
+
+        def _random_value(field)
+            case field[:type]
+            when :rand_int
+                return Generator.rand_int field[:min], field[:max]
+            when :rand_float
+                return Generator.rand_float field[:min], field[:max], field[:precision]
+            when :rand_char
+                return Generator.rand_char field[:length]
+            when :fixed
+                return field[:values].sample
+            else # faker
+                return Generator.fake field[:type]
+            end
+        end
+
+        def _loop
+            max_attempts = 1000_000_000_000
+            i = 0
+            (0...max_attempts).each do |j|
+                yield
+                i += 1
+            end
+            raise "max attempts reached" if i == max_attempts
+        end
+
+        ## individual random generators
+
+        def self.rand_char(length)
+            o = [('a'..'z'), ('A'..'Z'), (0..9)].map { |i| i.to_a }.flatten
+            string = (0...length).map { o[rand(o.length)] }.join
+        end
+
+        def self.rand_int(min, max)
+            raise "min > max" if min > max
+            min + rand(max - min + 1)
+        end
+
+        def self.rand_float(min, max, precision)
+            raise "min > max" if min > max
+            (rand * (max - min) + min).round(precision)
+        end
+
+        def self.fake(type)
+            Fakerer.new(type).fake
+        end
+    end
+end

data/lib/faked_csv/printer.rb

@@ -0,0 +1,16 @@
+module FakedCSV
+    class Printer
+        def initialize(headers, rows)
+            @headers = headers
+            @rows = rows
+        end
+
+        def print
+            s = @headers.join(',') + "\n"
+            @rows.each do |row|
+                s += row.join(',') + "\n"
+            end
+            s
+        end
+    end
+end

data/lib/faked_csv/version.rb

@@ -0,0 +1,3 @@
+module FakedCSV
+  VERSION = "0.1.1"
+end

data/spec/config_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe FakedCSV::Config do
+    it "parses the basic json config" do
+        json = JSON.parse File.read 'spec/data/basic.csv.json'
+        config = FakedCSV::Config.new json
+        config.config["rows"].should == 200
+        config.parse
+        config.row_count.should == 200
+        config.fields.should == [
+            {:name=>"ID", :type=>:rand_char, :length=>5},
+            {:name=>"First Name", :type=>:fixed, :values=>["Peter", "Tom", "Jane", "Tony", "Steve", "John"]},
+            {:name=>"Last Name", :type=>"faker:name:last_name", :inject=>["Lu", "Smith"]},
+            {:name=>"City", :type=>"faker:address:city", :rotate=>40},
+            {:name=>"State", :type=>"faker:address:state_abbr", :inject=>["CA"], :rotate=>10},
+            {:name=>"Age", :type=>:rand_int, :min=>10, :max=>80},
+            {:name=>"Height", :type=>:rand_float, :inject=>[200, 210], :rotate=>20, :min=>150, :max=>190, :precision=>2}
+        ]
+    end
+
+    it "provides fields headers" do
+        json = JSON.parse File.read 'spec/data/basic.csv.json'
+        config = FakedCSV::Config.new json
+        config.headers.should == ["ID", "First Name", "Last Name", "City", "State", "Age", "Height"]
+    end
+end

data/spec/data/basic.csv.json

@@ -0,0 +1,44 @@
+{
+  "rows": 200,
+  "fields": [
+    {
+      "name": "ID",
+      "type": "rand:char",
+      "length": 5
+    },
+    {
+      "name": "First Name",
+      "type": "fixed",
+      "values": ["Peter", "Tom", "Jane", "Tony", "Steve", "John"]
+    },
+    {
+      "name": "Last Name",
+      "type": "faker:name:last_name",
+      "inject": ["Lu", "Smith"]
+    },
+    {
+      "name": "City",
+      "type": "faker:address:city",
+      "rotate": "rows/5"
+    },
+    {
+      "name": "State",
+      "type": "faker:address:state_abbr",
+      "rotate": 10,
+      "inject": ["CA"]
+    },
+    {
+      "name": "Age",
+      "type": "rand:int",
+      "range": [10, 80]
+    },
+    {
+      "name": "Height",
+      "type": "rand:float",
+      "range": [150, 190],
+      "inject": [200, 210],
+      "rotate": 20,
+      "precision": 2
+    }
+  ]
+}

data/spec/data/inject.csv.json

@@ -0,0 +1,10 @@
+{
+  "rows": 10,
+  "fields": [
+    {
+      "name": "inject without rotate",
+      "type": "faker:name:first_name",
+      "inject": ["aa", "bb"]
+    }
+ ]
+}

data/spec/data/rotate.csv.json

@@ -0,0 +1,36 @@
+{
+  "rows": 10,
+  "fields": [
+    {
+      "name": "faker no rotate",
+      "type": "faker:name:first_name"
+    },
+    {
+      "name": "faker with rotate",
+      "type": "faker:name:first_name",
+      "rotate": 10
+    },
+    {
+      "name": "faker with rotate and inject",
+      "type": "faker:name:first_name",
+      "rotate": 10,
+      "inject": ["aaa", "bbb"]
+    },
+
+    {
+      "name": "rand int no rotate",
+      "type": "rand:int"
+    },
+    {
+      "name": "rand int with rotate",
+      "type": "rand:int",
+      "rotate": 10
+    },
+    {
+      "name": "rand int with rotate and inject",
+      "type": "rand:int",
+      "rotate": 10,
+      "inject": [11, 12, 13]
+    }
+ ]
+}

data/spec/fakerer_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe FakedCSV::Fakerer do
+    it "validates input type" do
+        FakedCSV::Fakerer.new("faker:name:last_name").fake.size.should > 1
+    end
+
+    it "invalidates input type: class" do
+        raised = false
+        begin
+            f = FakedCSV::Fakerer.new("faker:name1:last_name")
+        rescue
+            raised = true
+        end
+        raise "not raised invalid faker class" unless raised
+    end
+
+    it "invalidates input type: method" do
+        raised = false
+        f = FakedCSV::Fakerer.new("faker:name:last_name1")
+        begin
+            f.fake_single
+        rescue
+            raised = true
+        end
+        raise "not raised invalid faker method" unless raised
+    end
+end

data/spec/generator_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+describe FakedCSV::Generator do
+    it "generates rand char" do
+        FakedCSV::Generator.rand_char(1).size.should == 1
+        FakedCSV::Generator.rand_char(10).size.should == 10
+        FakedCSV::Generator.rand_char(100).size.should == 100
+    end
+
+    it "generates rand int" do
+        1000.times do
+            i = FakedCSV::Generator.rand_int(0, 10)
+            i.should <= 10
+            i.should >= 0
+        end
+        FakedCSV::Generator.rand_int(0, 0).should == 0
+        raised = false
+        begin
+            FakedCSV::Generator.rand_int(1, 0).should == 0
+        rescue
+            raised = true
+        end
+        raise "not raised the min > max exception" unless raised
+        1000.times do
+            i = FakedCSV::Generator.rand_int(-10, 0)
+            i.should <= 0
+            i.should >= -10
+        end
+    end
+
+    it "generates rand float" do
+        1000.times do
+            i = FakedCSV::Generator.rand_float(0, 10, 2)
+            i.should <= 10
+            i.should >= 0
+        end
+        FakedCSV::Generator.rand_float(0, 0, 0).should == 0
+        raised = false
+        begin
+            FakedCSV::Generator.rand_float(1, 0, 2).should == 0
+        rescue
+            raised = true
+        end
+        raise "not raised the min > max exception" unless raised
+        1000.times do
+            i = FakedCSV::Generator.rand_float(-10, 0, 10)
+            i.should <= 0
+            i.should >= -10
+        end
+    end
+
+    it "generates faker data" do
+        FakedCSV::Generator.fake("faker:name:last_name").size.should > 1
+    end
+
+    it "prepare values for rotate fields" do
+        generator = FakedCSV::Generator.new FakedCSV::Config.new JSON.parse File.read 'spec/data/rotate.csv.json'
+        generator.prepare_values
+        f = generator.config.fields
+        f[0].should == {:name=>"faker no rotate", :type=>"faker:name:first_name"}
+        f[1][:rotate].should == 10
+        f[1][:values].size.should == 10
+        f[2][:rotate].should == 10
+        f[2][:values].size.should == 10
+        f[2][:inject].should == ["aaa", "bbb"]
+        f[3].should == {:name=>"rand int no rotate", :type=>:rand_int, :min=>0, :max=>100}
+        f[4][:rotate].should == 10
+        f[4][:values].size.should == 10
+        f[5][:rotate].should == 10
+        f[5][:values].size.should == 10
+        f[5][:inject].should == [11, 12, 13]
+    end
+
+    it "generates random data" do
+        generator = FakedCSV::Generator.new FakedCSV::Config.new JSON.parse File.read 'spec/data/rotate.csv.json'
+        generator.generate
+        f = generator.config.fields
+        f[0][:data].size.should == 10
+        f[1][:data].size.should == 10
+        f[1][:data].each do |d|
+            f[1][:values].include?(d).should == true
+        end
+        f[2][:data].each do |d|
+            (f[2][:values].include?(d) || f[2][:values].include?(d)).should == true
+        end
+        f[3][:data].size.should == 10
+        f[4][:data].size.should == 10
+        f[4][:data].each do |d|
+            f[4][:values].include?(d).should == true
+        end
+        f[5][:data].each do |d|
+            (f[5][:values].include?(d) || f[5][:values].include?(d)).should == true
+        end
+    end
+
+    it "generates random data from basic csv" do
+        generator = FakedCSV::Generator.new FakedCSV::Config.new JSON.parse File.read 'spec/data/basic.csv.json'
+        generator.generate
+        f = generator.config.fields
+        f.each{|ff| ff[:data].size.should == 200}
+        f[0][:data].each{|d|d.size.should == 5}
+        f[1][:data].each do |d|
+            f[1][:values].include?(d).should == true
+        end
+        f[1][:data].uniq.size.should == f[1][:values].size
+        f[2][:inject].each do |inj|
+            f[2][:data].include?(inj).should == true
+        end
+        f[3][:data].uniq.size.should == 40
+        f[4][:data].uniq.size.should == 10
+        f[4][:data].include?("CA").should == true
+        f[5][:data].each do |d|
+            d.kind_of?(Integer).should == true
+            (d >= 10 && d <= 80).should == true
+        end
+        f[6][:data].uniq.size.should == 20
+        f[6][:data].include?(200).should == true
+        f[6][:data].include?(210).should == true
+        f[6][:data].each do |d|
+            ((d >= 150 && d <= 190) || d == 200 || d == 210).should == true
+        end
+    end
+
+    it "provides data as rows" do
+        generator = FakedCSV::Generator.new FakedCSV::Config.new JSON.parse File.read 'spec/data/rotate.csv.json'
+        generator.generate
+        rows = generator.rows
+        rows.size.should == 10
+        rows.each do |row|
+            row.size.should == 6
+        end
+    end
+
+    it "handles inject without rotate" do
+        generator = FakedCSV::Generator.new FakedCSV::Config.new JSON.parse File.read 'spec/data/inject.csv.json'
+        generator.generate
+        generator.config.fields[0][:data].include?("aa").should == true
+        generator.config.fields[0][:data].include?("bb").should == true
+    end
+end

data/spec/printer_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe FakedCSV::Printer do
+    it "returns csv as string" do
+        generator = FakedCSV::Generator.new FakedCSV::Config.new JSON.parse File.read 'spec/data/rotate.csv.json'
+        generator.generate
+        printer = FakedCSV::Printer.new(generator.headers, generator.rows)
+        s = printer.print
+        s.include?("faker no rotate,").should == true
+        s.include?(",rand int with rotate and inject").should == true
+        s.include?("13").should == true
+        s.include?("aaa").should == true
+        s.include?("bbb").should == true
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'byebug'
+require 'json'
+require 'faked_csv'
+

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification
+name: faked_csv
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Jianan Lu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: open_uri_redirections
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: Makes generating CSV file with faked, random data easy to do.
+email:
+- jianan.lu@salesforce.com
+executables:
+- faked_csv
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/faked_csv
+- example.csv.json
+- faked_csv.gemspec
+- features/faked_csv.feature
+- features/support/setup.rb
+- lib/faked_csv.rb
+- lib/faked_csv/cli.rb
+- lib/faked_csv/config.rb
+- lib/faked_csv/fakerer.rb
+- lib/faked_csv/generator.rb
+- lib/faked_csv/printer.rb
+- lib/faked_csv/version.rb
+- spec/config_spec.rb
+- spec/data/basic.csv.json
+- spec/data/inject.csv.json
+- spec/data/rotate.csv.json
+- spec/fakerer_spec.rb
+- spec/generator_spec.rb
+- spec/printer_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Generate faked CSV data in the specified way.
+test_files:
+- features/faked_csv.feature
+- features/support/setup.rb
+- spec/config_spec.rb
+- spec/data/basic.csv.json
+- spec/data/inject.csv.json
+- spec/data/rotate.csv.json
+- spec/fakerer_spec.rb
+- spec/generator_spec.rb
+- spec/printer_spec.rb
+- spec/spec_helper.rb