random-set 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ad4d2dc9bcb1b5ae42bae76fbbe5cae3c29a4df
-  data.tar.gz: 51912ae6cdc5572a07e0ee431cab8caaba93910c
+  metadata.gz: de80dcedc3dbdcc3bbe1257059617cbda64f2c7a
+  data.tar.gz: 13005ce042de59de432963a064e481952bfe8e97
 SHA512:
-  metadata.gz: b70d391565cc6a1ee4e4b51af0a3d78e59e518d55e38642c08c4bd83392900cf2f3a39a92ff85014f2840b082d07ddc8d7526423a21b51a1addbe9b1ab773535
-  data.tar.gz: bf473e2f91d385005447da3e79f1bc00bc1955b4f80b76424f61b30d81afcc7a279fb06a977a3be534463ea4a5a654cd25a94961a73895802b0fb1b00c44b7e3
+  metadata.gz: a6eb17de0c6ec5c0409f8a726c1cc55d9457d00409ef0f26026080a705d05ead885f5d2b8db3a59371bef0880b51d81407238ecbf4fc571b5a06aa6c0a716fab
+  data.tar.gz: 8e6d39b2dabb9d73f64c8b12fb08304f781495703b6584caaad002e23eae29c04e45b408e1f8da9fcd96a92bb7ec5404e6ad8941848181e99af0a5aaed389e7c

data/.travis.yml

@@ -0,0 +1,6 @@
+script: bundle exec rake
+rvm:
+  - 2.0.0
+branches:
+  only:
+    - master

data/Gemfile.lock

@@ -1,12 +1,26 @@
 PATH
   remote: .
   specs:
-    random_set (0.0.1)
+    random-set (1.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    diff-lcs (1.2.5)
+    multi_json (1.8.2)
     rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
 
 PLATFORMS
   ruby
@@ -14,4 +28,6 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.3)
   rake
-  random_set!
+  random-set!
+  rspec
+  simplecov

data/README.md

@@ -7,6 +7,8 @@ Conversely, if an array is given, the output is an array of arrays.
 Each item in the given template corresponds to an attribute of each item in the result
 set, and specifies how its data should be generated.
 
+[<img src="https://secure.travis-ci.org/yoazt/random-set.png?branch=master" alt="Build Status" />](http://travis-ci.org/yoazt/random-set)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -54,7 +56,7 @@ If you have only infinitely sized templates, you need to specify a count:
 The following templates are supported:
 
 * Anything with an `each` method that returns an Enumerator.
-* Procs or lambdas. One argument is passed: the number of the current iteration.
+* Procs or lambdas. One (optional) argument is passed: the number of the current iteration.
 * An instance of any class that has a `next` method. If this class also has a `count` method,
   it is considered a fixed-size template.
 

data/lib/random_set/template.rb

@@ -1,77 +1,92 @@
 module RandomSet
 
-  # A template for the random set.
-  # @api internal
+  # @api private
   class Template
 
-    def initialize(templates)
-      @hash       = templates.is_a?(Hash)
-      @generators = resolve_generators(templates)
-    end
-
-    def hash?
-      @hash
-    end
+    ######
+    # Initialization & attributes
 
-    def resolve_generators(templates)
-      hash = {}
-
-      process = proc do |key, template|
-        hash[key] = create_generator(template)
+      def initialize(templates)
+        @hash       = templates.is_a?(Hash)
+        @generators = resolve_generators(templates)
       end
 
-      if hash?
-        templates.each &process
-      else
-        templates.each_with_index { |template, index| process[index, template] }
+      def hash?
+        @hash
       end
 
-      hash
-    end
+      attr_reader :generators
 
-    def create_generator(template)
-      case template
-      when nil then nil
-      when ->(t){ t.respond_to?(:next) } then template
-      when ->(t){ t.respond_to?(:each) } then template.each
-      when Proc then CustomGenerator.new(template)
-      else raise UnsupportedTemplate, "cannot create a generator for a template of class #{template.class}"
+      def count
+        max = nil
+        generators.each do |_key, generator|
+          next unless generator && generator.respond_to?(:count)
+          max = [ max.to_i, generator.count ].max
+        end
+        max
       end
-    end
 
-    attr_reader :generators
+    ######
+    # Generation
+
+      def generate(count = self.count)
+        raise CannotInferCount, "no count was specified or could be inferred" unless count
 
-    # Gives a count for the items in this template. If no count can be inferred, +nil+ is returned.
-    def count
-      max = nil
-      generators.each do |_key, generator|
-        next unless generator && generator.respond_to?(:count)
-        max = [ max.to_i, generator.count ].max
+        data = []
+        count.times.each { data << generate_next(data) }
+        data
       end
-      max
-    end
 
-    def generate(count = self.count)
-      raise CannotInferCount, "no count was specified or could be inferred" unless count
+    ######
+    # Support
 
-      data = []
-      count.times.each { data << generate_next(data) }
-      data
-    end
+      private
+
+      def resolve_generators(templates)
+        hash = {}
+
+        process = proc do |key, template|
+          hash[key] = create_generator(template)
+        end
+
+        if hash?
+          templates.each &process
+        else
+          templates.each_with_index { |template, index| process[index, template] }
+        end
+
+        hash
+      end
+
+      def create_generator(template)
+        case template
+        when nil then nil
+        when ->(t){ t.respond_to?(:next) } then template
+        when ->(t){ t.respond_to?(:each) } then template.each
+        when Proc then CustomGenerator.new(template)
+        else raise UnsupportedTemplate, "cannot create a generator for a template of class #{template.class}"
+        end
+      end
 
-    def generate_next(data)
-      item = hash? ? {} : []
-      generators.each do |key, generator|
-        begin
-          item[key] = generator.try(:next)
-        rescue StopIteration
-          # If some enumerator came to the end, we just leave the rest of the keys blank.
-          item[key] = nil
+      def generate_next(data)
+        item = hash? ? {} : []
+        generators.each do |key, generator|
+          begin
+            item[key] = generator ? generator.next : nil
+          rescue StopIteration
+            # If some enumerator came to the end, we just leave the rest of the keys blank.
+            item[key] = nil
+          end
         end
+        item
       end
-      item
+
     end
 
+  ######
+  # CustomGenerator class
+
+    # @api private
     class CustomGenerator
 
       def initialize(block)
@@ -82,13 +97,15 @@ module RandomSet
       attr_reader :block
 
       def next
-        block.call @iteration
+        if block.arity == 1
+          block.call @iteration
+        else
+          block.call
+        end
       ensure
         @iteration += 1
       end
 
     end
 
-  end
-
 end

data/lib/random_set/version.rb

@@ -1,3 +1,3 @@
 module RandomSet
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/random-set.gemspec

@@ -20,4 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
 end

data/spec/generation_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe "RandomSet generation" do
+
+  context "specifying an empty template" do
+
+    it "should require a count" do
+      expect{ RandomSet.generate([]) }.to raise_error(RandomSet::CannotInferCount)
+    end
+
+    it "should output X empty records" do
+      data = RandomSet.generate(5, [])
+
+      expect(data).to have(5).items
+      expect(data[0]).to be_empty
+      expect(data[1]).to be_empty
+      expect(data[2]).to be_empty
+      expect(data[3]).to be_empty
+      expect(data[4]).to be_empty
+    end
+
+  end
+
+  context "specifying a hash template" do
+
+    it "should output a list of hashes" do
+      expect(RandomSet.generate(5, {})).to eql([ {}, {}, {}, {}, {} ])
+    end
+
+    it "should fill in key-by-key" do
+      expect(RandomSet.generate(2, { :name => -> { 'Test' }, :age => (1..2) })).to eql([
+        { :name => 'Test', :age => 1 },
+        { :name => 'Test', :age => 2 }
+      ])
+    end
+
+  end
+
+  context "specifying an array template" do
+
+    it "should output a list of arrays" do
+      expect(RandomSet.generate(5, [])).to eql([ [], [], [], [], [] ])
+    end
+
+    it "should fill in index by index" do
+      expect(RandomSet.generate(2, [ -> { 'Test' }, (1..2) ])).to eql([
+        ['Test', 1], ['Test', 2]
+      ])
+    end
+
+  end
+
+  describe 'full example' do
+
+    let(:custom_generator1) do
+      Class.new do
+        def initialize
+          @iteration = 0
+        end
+        def next
+          "Iteration #{@iteration}"
+        ensure
+          @iteration += 1
+        end
+      end.new
+    end
+
+    let :custom_generator2 do
+      Class.new do
+        def next; 'Same' end
+        def count; 3 end
+      end.new
+    end
+
+    it "should infer the count from all generators that support counts" do
+      data = RandomSet.generate([custom_generator1, custom_generator2])
+      expect(data).to have(3).items
+    end
+
+    it "should generate ranges, arrays, procs, and custom generators" do
+      data = RandomSet.generate(5, [ custom_generator1, (1..10), [1,2,3], ->(n) { "Item #{n}" } ])
+      expect(data).to eql([
+        ['Iteration 0', 1, 1,   'Item 0'],
+        ['Iteration 1', 2, 2,   'Item 1'],
+        ['Iteration 2', 3, 3,   'Item 2'],
+        ['Iteration 3', 4, nil, 'Item 3'],
+        ['Iteration 4', 5, nil, 'Item 4']
+      ])
+    end
+
+
+  end
+
+
+end

data/spec/random_set/template_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+include RandomSet
+
+describe Template do
+
+  let(:template) { Template.new([]) }
+
+  describe '#hash?' do
+    it "should be true if the passed in argument was a hash" do
+      expect(Template.new({})).to be_hash
+    end
+    it "should be false if anything else was passed in" do
+      expect(Template.new([])).not_to be_hash
+    end
+  end
+
+  describe '#generators' do
+
+    it "should be a hash, regardless of the template's input" do
+      expect(Template.new({}).generators).to be_a(Hash)
+      expect(Template.new([]).generators).to be_a(Hash)
+    end
+
+    it "should contain a resolved generator for each item in the templates" do
+      item1 = (1..5)
+      item2 = ->{}
+
+      generators = Template.new([item1, item2]).generators
+      expect(generators).to have(2).items
+      expect(generators[0]).to be_a(Enumerator)
+      expect(generators[1]).to be_a(CustomGenerator)
+    end
+
+    it "should contain a resolved generator for each item in the templates" do
+      item1 = (1..5)
+      item2 = ->{}
+
+      generators = Template.new(:item1 => item1, :item2 => item2).generators
+      expect(generators).to have(2).items
+      expect(generators[:item1]).to be_a(Enumerator)
+      expect(generators[:item2]).to be_a(CustomGenerator)
+    end
+
+  end
+
+  describe '#count' do
+    it "should be the maximum count for all generators that return a count" do
+      generator1 = double(:count => 2, :next => nil)
+      generator2 = double(:count => 5, :next => nil)
+      generator3 = double(:next => nil)
+      template = Template.new([generator1, generator2, generator3])
+      expect(template.count).to eql(5)
+    end
+
+    it "should return nil if no generators had a count method" do
+      generator1 = double(:next => nil)
+      generator2 = double(:next => nil)
+      generator3 = double(:next => nil)
+      template = Template.new([generator1, generator2, generator3])
+      expect(template.count).to be_nil
+    end
+  end
+
+  describe '#generate' do
+    let(:template) { Template.new([]) }
+
+    it "should raise an error if no count was provided, and no count could be inferred" do
+      expect(template).to receive(:count).and_return(nil)
+      expect{ template.generate }.to raise_error(CannotInferCount, 'no count was specified or could be inferred')
+    end
+
+    it "should output <template.count> records if no count is specified" do
+      expect(template).to receive(:count).and_return(5)
+      expect(template.generate).to have(5).items
+    end
+
+    it "should output <count> records if a count is specified" do
+      allow(template).to receive(:count).and_return(5)
+      expect(template.generate(10)).to have(10).items
+    end
+
+    # Other generation examples in the integration specs.
+  end
+
+  describe 'generator resolution' do
+
+    it "should resolve a range to its enumerator" do
+      generator = Template.new([ (1..5) ]).generators[0]
+      expect(generator).to be_a(Enumerator)
+      expect(generator.map { |i| i }).to eql([1,2,3,4,5])
+    end
+
+    it "should resolve an array to its enumerator" do
+      generator = Template.new([ [1,2,3] ]).generators[0]
+      expect(generator).to be_a(Enumerator)
+      expect(generator.map { |i| i }).to eql([1,2,3])
+    end
+
+    it "should resolve a block into a CustomGenerator" do
+      block = ->{}
+      generator = Template.new([ block ]).generators[0]
+      expect(generator).to be_a(CustomGenerator)
+      expect(generator.block).to be(block)
+    end
+
+    it "should resolve anything with an 'each' method to the result of that method" do
+      enumerator = double()
+      generator = Template.new([ double(:each => enumerator) ]).generators[0]
+      expect(generator).to be(enumerator)
+    end
+
+    it "should resolve anything with a 'next' method to itself" do
+      generator = double(:next => nil)
+      expect(Template.new([ generator ]).generators[0]).to be(generator)
+    end
+
+    it "should raise an error for something else" do
+      expect{ Template.new([ Object.new ]) }
+        .to raise_error(UnsupportedTemplate, "cannot create a generator for a template of class Object")
+    end
+
+  end
+
+
+end

data/spec/random_set_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe RandomSet do
+
+  describe '.generate' do
+
+    it "should require a template argument" do
+      expect{ RandomSet.generate }
+        .to raise_error(ArgumentError, "template required")
+    end
+
+    it "should not accept more than two arguments" do
+      expect{ RandomSet.generate :one, :two, :template }
+        .to raise_error(ArgumentError, "too many arguments (1..2 expected)")
+    end
+
+    it "should create a template from the last argument and call its generate with the rest of the arguments" do
+      template = double(:template)
+      expect(RandomSet::Template).to receive(:new).with(:template).and_return(template)
+
+      result = double(:result)
+      expect(template).to receive(:generate).with(10).and_return(result)
+      expect(RandomSet.generate 10, :template).to be(result)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "spec/"
+  add_filter "gaussian*" # cannot really test randomizers
+end
+
+require 'random-set'
+require 'rspec/autorun'
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |config|
+    config.syntax = :expect
+  end
+end
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: random-set
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Joost Lubach
@@ -38,6 +38,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Generates a series of data based on a template.
 email:
 - joost@yoazt.com
@@ -48,6 +76,7 @@ files:
 - .gitignore
 - .ruby-gemset
 - .ruby-version
+- .travis.yml
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -60,6 +89,10 @@ files:
 - lib/random_set/template.rb
 - lib/random_set/version.rb
 - random-set.gemspec
+- spec/generation_spec.rb
+- spec/random_set/template_spec.rb
+- spec/random_set_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -84,5 +117,9 @@ rubygems_version: 2.1.4
 signing_key: 
 specification_version: 4
 summary: Generates a series of data based on a template.
-test_files: []
+test_files:
+- spec/generation_spec.rb
+- spec/random_set/template_spec.rb
+- spec/random_set_spec.rb
+- spec/spec_helper.rb
 has_rdoc: