quick-sampler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 58a28eb8cda1b35a7cfde8b6c7c118e3a6373b17
+  data.tar.gz: 655c8fb5860814fbf19f7fedf8573e2d310cbcc4
+SHA512:
+  metadata.gz: a31df65d1b884a650988a248af0c324a5aad89df9dd5295e85b44b9a3a841ed6effde069088cf5368e846eba23b764ab19d163d3788d8ec1f2879eec903069c8
+  data.tar.gz: 4e5ae84816f4e748c3c184775cb5de4e6c34e1cda267081f6d08d20201ec4a1c53811fff2d31ce1f7a55433ff1eb2a70a47452e28a7a7cad43541da51cd7ea0e

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.2

data/.yardopts

@@ -0,0 +1,2 @@
+--markup-provider=redcarpet
+--markup=markdown

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 de Praktijk Index B.V.
+
+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,151 @@
+# Quick Sampler
+
+Composable samplers of data: describe your randomness and watch it blend.
+
+Quick Sampler is DSL for describing and sampling random data influenced by
+Haskell/Erlang's [QuickCheck][1] generators by Koen Claessen and John Hughes, 
+[rantly][2] gem by Howard Yeh, [theft][3] gem by Shawn Anderson, Jessica Kerr's 
+[generatron][4] gem, her [Property-Based Testing for Better Code talk][5] and 
+the rest of the cause-and-effect chain [all the way][6] to [big bang][7].
+
+[1]: http://www.cse.chalmers.se/~rjmh/QuickCheck/
+[2]: https://github.com/hayeah/rantly
+[3]: https://github.com/shawn42/theft
+[4]: https://github.com/jessitron/generatron/
+[5]: http://www.windycityrails.org/videos/2014/#14
+[6]: http://en.wikipedia.org/wiki/Turtles_all_the_way_down
+[7]: http://en.wikipedia.org/wiki/Unmoved_mover
+
+## Sampler vs Generator
+
+**Sampler** is the same as **generator** in other randomness frameworks, but
+tries to suggest an expanded understanding of what it can be used for.
+Ordinarily one would *sample* a source of randomness, but one could just as
+well *sample* some "real" data at random and pass it on, verbatim or randomly
+transmuted. 
+
+The term is supposed to suggest "the way of truth" view of
+unchanging reality that Parmenides described in his *On Nature* in fifth
+century BCE. To see what he meant back when Socrates was a young man - fix your
+random seed and watch your "generators" repeat themselves. Smoke that,
+Heraclitus.
+
+<img src="https://cloud.githubusercontent.com/assets/64227/6993106/512cc778-daea-11e4-82dc-01cc8ef958fa.jpg"  height="200px">
+
+## Usage
+
+The main entry point is {Quick::Sampler.compile}. The method takes sampler
+definition as block and returns a "compiled" sampler:
+
+```
+pry> sampler = Quick::Sampler.compile { integer }
+=> #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007f295f9b2af0>:each>>
+pry> sampler.first(5)
+=> [1763573971376409386, -1692192782152475313, -3665498119514965288, 0, 0]
+```
+
+So, the truth is out: a sampler is a lazy enumerator (and by extension - Enumerable).
+But [will it blend?][8]
+
+[8]: https://github.com/jessitron/gerald#gerald
+
+```irb
+pry> sampler2 = Quick::Sampler.compile { config(upper_bound: 5).string(:lower) }
+=> #<Enumerator::Lazy: #<Enumerator: #<Enumerator::Generator:0x007f295fd88058>:each>>
+pry> sampler2.zip(sampler).first(5).to_h
+=> {"bjm"=>-4027257104748747508,
+ "bcrs"=>-540067903901761386,
+ "wqfn"=>2107130696606126069,
+ "disw"=>2495326937126240758,
+ "rglv"=>2235767748081203791}
+```
+
+Hell yeah, it blends.
+
+### Compile
+
+The aim of "compilation" is to deliver us from typing / reading the namespaces
+in sampler definitions. Consider, for example:
+
+```ruby
+Quick::Sampler.compile do
+  one_of_weighted integer => 10,
+                  boolean => 1,
+                  vector_of(5, integer) => 5
+end
+```
+
+(**Rosetta stone:** `one_of_weighted` is what in Haskell QuickCheck is known as `frequency`)
+
+vs hypothetic alternative:
+
+```ruby
+Generators.one_of_weighted Generators.integer => 10,
+                           Generators.boolean => 1,
+                           Generators.vector_of(5, Generators.integer) => 5
+```
+
+### Sampler configuration
+
+Some sampling parameters can be passed as arguments to a sampler function (like
+character class `:lower` in the example above). Others - that affect multiple
+sub-samplers in a definition - may be injected with a call to `config(...)` (like
+`upper_bound` above).
+
+(**Rosetta stone:** `upper_bound` is what in Haskell QuickCheck is known as `size`)
+
+### Sampler composability
+
+The composition using Enumerable API as demonstrated above is pretty flexible and familiar to a
+ruby developer.
+
+Some less "linear" shapes of data on the other hand are better
+expressed by the Quick Sampler DSL within the sampler definition:
+
+**TODO** replace with a real life example of a complex sampler.
+
+```ruby
+cities_sampler = Quick::Sampler.compile do
+  send_to City, :build, name: string(:lower),
+    state: pick_from(State.all),
+    population: pick_from(1_000..10_000_000)
+end
+
+cities = cities_sampler.first(100)
+cities.each &:save!
+
+travellers_sampler = Quick::Sampler.compile do
+  send_to Person, :build,
+    name: string(:lower),
+    born_in: pick_from(cities),
+    lives_in: pick_from(cities),
+    visited: list_of(pick_from(cities))
+end
+
+travellers = travellers_sampler.first(1000)
+travellers.each &:save!
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'quick-sampler'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quick-sampler
+
+## Contributing
+
+1. Fork it ( https://github.com/praktijkindex/quick-sampler/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,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require "yard"
+YARD::Rake::YardocTask.new

data/lib/quick/sampler/autoload.rb

@@ -0,0 +1,2 @@
+require "active_support/dependencies"
+ActiveSupport::Dependencies.autoload_paths << File.expand_path("../../..", __FILE__)

data/lib/quick/sampler/base.rb

@@ -0,0 +1,96 @@
+require "delegate"
+
+module Quick
+  module Sampler
+    # A sampler base class, delegating most work to the underlying lazy enumerator.
+    #
+    # ### Readable #inspect
+    #
+    # One superficial extra that {Sampler::Base} provides is a description attribute
+    # which is returned by `#inspect`. This can help keep test output readable.
+    #
+    # ### Shrinking
+    #
+    # Sampler::Base also provides an {#shrink api for shrinking} failed inputs.
+    #
+    # From {http://stackoverflow.com/a/16970029/538534 stackoverflow discussion}
+    # of shrinking (follow the link for an example) in the original QuickCheck:
+    #
+    # > When QuickCheck finds an input that violates a property, it will first
+    # try to find smaller inputs that also violate the property, in order to
+    # give the developer a better message about the nature of the failure.
+    #
+    # > What it means to be „small“ of course depends on the datatype in
+    # question; to QuickCheck it is anything that comes out from from the
+    # shrink function.
+    #
+    class Base < DelegateClass(Enumerator::Lazy)
+      attr_accessor :description
+
+      # @api private
+      # Not supposed to be used directly, use {Quick::Sampler.compile} instead.
+      #
+      # @param [Enumerator, Enumerator::Lazy, #call] source source of data.
+      #   Non-lazy `Enumerator` will be lazyfied, and anything `call`able will be
+      #   wrapped into a lazy enumerator.
+      # @param [String] description sampler description to be returned by #inspect
+      def initialize source, description: "Quick Sampler"
+        @description = description
+        super(source_to_lazy(source))
+      end
+
+      # @return [String] sampler description, so test output is readable
+      def inspect
+        description
+      end
+
+      # A very preliminary API for QuickCheck-like input shrinking.
+      # A sampler is responsible for shrinking its failed samples.
+      #
+      # @example Detecting and then shrinking failing examples:
+      #
+      #   # Generate random input data
+      #   all_inputs = sampler.first(100)
+      #
+      #   # Find failures (by rejecting inputs satisfying the property)
+      #   failed_inputs = all_inputs.reject{ |input| property(input) }
+      #
+      #   # Shrink failed inputs, continue shrinking as long as property does not hold
+      #   shrunk_inputs = sampler.shrink(failed_inputs) {|input| !property(input)}
+      #
+      #
+      # @param [Enumerable] samples input samples that failed the preoperty
+      #
+      # @yieldparam [<Sample>] sample shrunk value to check the property again. If
+      #   property holds, the value will be discarded, and the one it was shrunk
+      #   from will be added to the set of "minimal" failing examples.
+      #
+      # @yieldreturn [Boolean] `true` to keep on shrinking, meaning *"property still fails for
+      #   shrunken value, try to shrink more"*
+      #
+      # @return [Array] "minimal" samples that failed to satisfy the property under test
+      def shrink samples, &block
+        Quick::Sampler::Shrink.while(samples, &block)
+      end
+
+      private
+
+      def source_to_lazy source
+        case source
+        when Enumerator::Lazy
+          source
+        when Enumerator
+          source.lazy
+        when ->(i) { i.respond_to? :call }
+          Enumerator.new do |recipient|
+            loop do
+              recipient << source.call
+            end
+          end.lazy
+        else
+          raise "Don't know how to make a sampler from #{source.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/quick/sampler/config.rb

@@ -0,0 +1,25 @@
+require "active_support/configurable"
+require "active_support/concern"
+
+module Quick
+  module Sampler
+    module Config
+      extend ActiveSupport::Concern
+      include ActiveSupport::Configurable
+
+      included do
+        config_accessor(:max_iterations) { 1000 }
+        config_accessor(:upper_bound) { 25 }
+      end
+
+      def config options = :none_given
+        if options == :none_given
+          super()
+        else
+          config.merge!(options)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/quick/sampler/dsl/character_class.rb

@@ -0,0 +1,41 @@
+module Quick
+  module Sampler
+    #@!visibility private
+    module DSL::CharacterClass
+      class << self
+
+        def expand *class_names
+          class_names
+            .map { |name| definitions[name] }
+            .compact
+            .flat_map { |definition|
+              case definition
+              when String
+                definition.chars
+              when Range
+                definition.to_a
+              when Array
+                expand(*definition)
+              end
+            }.to_a
+        end
+
+        private
+
+        def definitions
+          {
+            lower: "a".."z",
+            upper: "A".."Z",
+            alpha: [:lower, :upper],
+            digits: "0".."9",
+            alnum: [:alpha, :digits],
+            punctuation: %q[~`!@#$%^&*()_-+={}|\\:;"'<,>.?/],
+            whitespace: " \t\n",
+            printable: [:alnum, :punctuation, :whitespace]
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/quick/sampler/dsl/fluidiom.rb

@@ -0,0 +1,49 @@
+require "delegate"
+
+module Quick
+  module Sampler
+    # A Quick::Sampler wrapper providing a fluid DSL that can be used in a sampler definition
+    # passed to {Quick::Sampler.compile}.
+    class DSL::Fluidiom < SimpleDelegator
+      # SimpleDelegator so that it can unwrap the "original" sampler with `#__getobj__`
+      include Quick::Sampler::Config
+
+      # @api private
+      # wraps a `sampler` into a `Fluidiom` instance so it has extra methods while
+      # inside the block passed to {Quick::Sampler.compile}
+      def initialize sampler, _config = {}
+        sampler = Base.new(sampler) unless sampler.is_a? Base
+        super(sampler)
+        config.merge! _config
+      end
+
+      # @return [Quick::Sampler]
+      #   the unwrapped original sampler
+      def unwrap
+        __getobj__
+      end
+
+      # @return [Quick::Sampler]
+      #   wrapped sampler that starts out with the same config as this one
+      def spawn sampler
+        self.class.new(sampler, config)
+      end
+
+      # spawn a filtering sampler
+      #
+      # The produced sampler honors the config variable `max_iterations` and stops
+      # iterating when that many original values are tested.
+      #
+      # @return [Quick::Sampler]
+      #   a sampler that filter through only samples that satisfy the
+      #   predicate given as block
+      # @yieldparam [Anything] sample
+      #   a sampled value to be tested
+      # @yieldreturn [Boolean]
+      #   `true` to pass the value through
+      def such_that &predicate
+        spawn(unwrap.take(max_iterations).select(&predicate))
+      end
+    end
+  end
+end

data/lib/quick/sampler/dsl/simple_combinators.rb

@@ -0,0 +1,135 @@
+module Quick
+  module Sampler
+    # DSL methods that allow to combine samplers in various ways.
+    #
+    # ### Recursive samplers
+    #
+    # Some of the combinators are recursive: given a nested structure of Arrays and Hashes
+    # containing samplers and non-sampler values they would produce an analogous structure
+    # where samplers are replaced by their `#next` value.
+    module DSL::SimpleCombinators
+
+      # @return [Quick::Sampler]
+      #   a sampler producing values from the range or array
+      def pick_from source
+        case source
+        when Range
+          feed { rand(source) }
+        when Array
+          feed { source.sample }
+        end
+      end
+
+      # @return [Quick::Sampler]
+      #   a sampler that recursively samples on of the arguments at random
+      def one_of *args
+        feed { recursive_sample(args.sample) }
+      end
+
+      # @return [Quick::Sampler]
+      #   a sampler that recursively samples on of the expressions at random, with
+      #   likelyhood of picking one of the expressions depends on its weight.
+      def one_of_weighted expression_weights
+        total_weight, expressions = expression_weights
+          .reduce([0, {}]) { |(total_weight, expressions), (expression, weight)|
+            total_weight += weight
+            [total_weight, expressions.merge(total_weight => expression)]
+          }
+
+        feed {
+          dice = rand * total_weight
+          weight_class = expressions.keys.find{|w| dice < w}
+          recursive_sample(expressions[weight_class])
+        }
+      end
+
+      # Sampler of uniform arrays
+      #
+      # This sampler honors `upper_bound` config variable and samples Arrays of up to
+      # that many elements.
+      #
+      # **Rosetta stone** the single argument version corresponds to QuickCheck's `listOf`.
+      # Passing `non_empty: true` turns it into QuickCheck's `listOf1`.
+      #
+      # @return [Quick::Sampler]
+      #   a sampler that produces arrays of values sampled from its argument
+      # @param [Quick::Sampler] sampler
+      #   a sampler to sample array elements from
+      # @param [Boolean] non_empty
+      #   pass true to never produce empty arrays
+      def list_of sampler, non_empty: false
+        lower_bound = non_empty ? 1 : 0
+        feed { sampler.first(rand(lower_bound..upper_bound)) }
+      end
+
+      # Sampler of uniform fixed length arrays
+      #
+      # **Rosetta stone** this sampler corresponds to QuickCheck's `vectorOf`.
+      #
+      # @return [Quick::Sampler]
+      #   a sampler that produces arrays of `length` of values sampled from `sampler`
+      # @param [Integer] length
+      #   sample array length
+      # @param [Quick::Sampler] sampler
+      #   a sampler to sample array elements from
+      def vector_of length, sampler
+        feed { sampler.take(length).force }
+      end
+
+      # Sampler of arbitrary nested structures made up of `Array`s, `Hash`es, `Quick::Sampler`s and
+      # non-sampler values
+      #
+      # @param [Array] args
+      #   a template structure
+      # @return [Quick::Sampler]
+      #   a recursive sampler
+      def list_like *args
+        feed { args.map { |arg| recursive_sample(arg) } }
+      end
+
+      # Sampler of arbitrary message send ("method call") results
+      #
+      # @overload send_to recipient, message, *args
+      #   @param [Object, Quick::Sampler<Object>] recipient
+      #     message recipient or a sampler producing recipients
+      #   @param [Symbol, Quick::Sampler<Symbol>] message
+      #     message to send or a sampler producing messages
+      #   @param [Array] args
+      #     argument list that may contain samplers producing arguments
+      #
+      # @overload send_to sampler
+      #   @param [Quick::Sampler<[Object, Symbol, *Anything]>] sampler
+      #     a sampler producing the message send details
+      #
+      # @return [Quick::Sampler]
+      #   a sampler of dynamically generated message send results
+      def send_to *args
+        call_sampler = if args.count > 1
+                         list_like *args
+                       else
+                         args.first
+                       end
+        feed {
+          object, message, *args = call_sampler.next
+          object.send( message, *args )
+        }
+      end
+
+      private
+
+      def recursive_sample value
+        case value
+        when Quick::Sampler
+          value.next
+        when Hash
+          value.map{ |key, value| [key, recursive_sample(value)] }.to_h
+        when Array
+          value.map{ |value| recursive_sample(value) }
+        else
+          value
+        end
+      end
+
+    end
+  end
+end

data/lib/quick/sampler/dsl/simple_values.rb

@@ -0,0 +1,97 @@
+module Quick
+  module Sampler
+    # Samplers of simple values to form the basis of the sampled data structure.
+    #
+    # ### Note from the future
+    #
+    # In the future simple values are sampled from other excellent Gems from behind a
+    # composable Quick Sampler API. In the mean time this is possible at the cost of
+    # readablity:
+    #
+    # @example Faker integration
+    #
+    #   Quick::Sampler.compile description: "email address" do
+    #     feed { Faker::Internet.email }
+    #   end
+    module DSL::SimpleValues
+
+      # @!volatile
+      #
+      # Degenerate constant sampler. Will probably be superseeded by
+      # a cleaner smarter syntax as I get a better hang of it.
+      #
+      # @return [Quick::Sampler<Anything>] a sampler of constant value
+      # @param [Anything] const
+      #   the value to keep on sampling
+      def const const
+        feed { const }
+      end
+
+      # Degenerate sampler of zeros. Like {#const} this will probably
+      # go away soon.
+      #
+      # @return [Quick::Sampler<0>] a sampler of zeros
+      def zero
+        const 0
+      end
+
+      FixnumRange = -(2**(0.size * 8 -2))..(2**(0.size * 8 -2) -1)
+      private_constant :FixnumRange
+
+      # Samples random fixnums (smaller integers that can be handled quickly by
+      # the CPU itself)
+      #
+      # @return [Quick::Sampler<Fixnum>] a sampler of fixnums
+      def fixnum
+        pick_from(FixnumRange)
+      end
+
+      # @return [Quick::Sampler<Fixnum>] a sampler of negative fixnums
+      def negative_fixnum
+        pick_from(FixnumRange.min..-1)
+      end
+
+      # @return [Quick::Sampler<Fixnum>] a sampler of positive fixnums
+      def positive_fixnum
+        pick_from(1..FixnumRange.max)
+      end
+
+      # A sampler of integers prefering smaller ones
+      #
+      # It will however sample a large one (from the Fixnum range) occasionally.
+      #
+      # @return [Quick::Sampler<Fixnum>] a sampler of integers
+      def integer
+        one_of_weighted(fixnum => 5,
+                        pick_from(-1_000_000_000..1_000_000_000) => 7,
+                        pick_from(-1000..1000) => 9,
+                        pick_from(-100..100) => 11,
+                        pick_from(-20..20) => 17)
+      end
+
+      alias_method :negative_integer, :negative_fixnum
+      alias_method :positive_integer, :positive_fixnum
+
+      # @return [Quick::Sampler<Boolean>] a sampler of `true` and `false` values
+      def boolean
+        pick_from([true, false])
+      end
+
+      # This sampler honors `upper_bound` config variable.
+      #
+      # The sampler will produce strings of random (between 0 and `upper_bound`) length
+      # made up of characters belonging to supplied named classes.
+      #
+      # @returns [Quick::Sampler<String>] random `String` sampler
+      # @param [Array<Symbol>] classes
+      #   Character classes to pick from.
+      # @todo document character classes
+      def string *classes
+        classes = [:printable] if classes.empty?
+        repertoire = DSL::CharacterClass.expand(*classes)
+        feed { repertoire.sample(rand(upper_bound)).join }
+      end
+
+    end
+  end
+end

data/lib/quick/sampler/dsl.rb

@@ -0,0 +1,71 @@
+module Quick
+  module Sampler
+    # A domain specific method for sampler definitions.
+    #
+    # Instance methods of this class are available as barewords inside a
+    # sampler definition supplied as a block to {Quick::Sampler.compile}.
+    #
+    # Methods that produce a sampler actually wrap it in a {Fluidiom} instance
+    # that adds a fluid API to the sampler. This wrapping is stripped off from
+    # the sampler returned by {Quick::Sampler.compile} - although I'm still
+    # undesided if that's the right thing to do.
+    #
+    # (Incidentally, {Fluidiom} instances for deeper nested sub-samplers get
+    # leaked from compile at the moment)
+    class DSL
+      include Quick::Sampler::Config
+      include SimpleValues
+      include SimpleCombinators
+
+      # @api private
+      # @param [Binding] binding a context to lookup unknown methods
+      def initialize binding = nil
+        setup_delegation(binding) if binding
+      end
+
+      # @api private
+      # (see Quick::Sampler.compile)
+      def self.compile description: nil, &block
+        new(block.binding).instance_eval(&block).unwrap.tap do |sampler|
+          sampler.description = description
+        end
+      end
+
+      # overloaded to display human readable text in tests output
+      def inspect
+        "Quick Sampler DSL"
+      end
+
+      # Wraps a block into a lazy enumerator which will become sampler.
+      #
+      # I haven't decided yet if this is a private implementation detail
+      # or a powerful albeit confusing DSL verb
+      #
+      # @yieldreturn [<Sample>] a sampled value
+      #
+      def feed &block
+        Fluidiom.new(Base.new(block), config)
+      end
+
+      private
+
+
+      def setup_delegation binding
+        @context = binding.eval("self")
+
+        # this poor man's delegation is because inheriting from SimpleDelegator breaks
+        # autoload for some reason
+
+        # @!visibility private
+        def self.method_missing *args, &block
+          @context.send(*args, &block)
+        end
+
+        # @!visibility private
+        def self.respond_to? *args
+          super || @context.respond_to?(*args)
+        end
+      end
+    end
+  end
+end

data/lib/quick/sampler/shrink/class_methods/while.rb

@@ -0,0 +1,38 @@
+require "set"
+using Quick::Sampler::Shrink::Refinements
+
+module Quick
+  module Sampler
+    module Shrink
+      #@!visibility private
+      module ClassMethods
+        #@!visibility private
+        module While
+          def while values, &block
+            shrunk = Set.new
+            input_size = values.count
+            values = values.reduce(Set.new) { |shrinking, current|
+              report "shrunk: #{shrunk.count}, still shrinking: #{shrinking.count}"
+              shrunk_current = (current.shrink||[])
+                .reject{|candidate| candidate  == current}
+                .select(&block)
+              shrunk << current if shrunk_current.empty?
+              shrinking + shrunk_current
+            } until values.empty?
+            report ""
+            shrunk.to_a
+          end
+
+          def report message
+            width = 80
+            message = "" if message == :clear
+            message = message[0...width]
+            padding = " " * [width - message.length, 0].max
+            print "#{message}#{padding}\r"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/quick/sampler/shrink/refinements.rb

@@ -0,0 +1,42 @@
+module Quick
+  module Sampler
+    module Shrink
+      #@!visibility private
+      module Refinements
+
+        refine ::Object do
+          def shrink
+          end
+        end
+
+        refine ::Integer do
+          def shrink
+            # -1, 0 and 1 can't be shrunken
+            if self > 10
+              [self/2]
+            elsif self > 1
+              [self - 1]
+            elsif self < -1
+              [-self.abs.shrink.first]
+            end
+          end
+        end
+
+        refine ::String do
+          def shrink
+            if length > 1
+              remove_indices = (0...length).to_a
+              remove_indices = remove_indices.sample(1) if length > 9
+              remove_indices.map{|i| remove_by_index(i)}
+            end
+          end
+
+          def remove_by_index index
+            dup.tap{|copy| copy.slice!(index)}
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/quick/sampler/shrink.rb

@@ -0,0 +1,8 @@
+module Quick
+  module Sampler
+    #@!visibility private
+    module Shrink
+      extend ClassMethods::While
+    end
+  end
+end

data/lib/quick/sampler/version.rb

@@ -0,0 +1,5 @@
+module Quick
+  module Sampler
+    VERSION = "0.0.1"
+  end
+end

data/lib/quick/sampler.rb

@@ -0,0 +1,49 @@
+require_relative "sampler/autoload"
+require "active_support/core_ext/module/delegation"
+
+# A prefix module for future Quick Sampler's sister libraries.
+# For now just look at {Quick::Sampler} itself.
+module Quick
+  # A façade module with the main entry point: {.compile}
+  module Sampler
+
+    class << self
+
+      # Main entry point of Quick Sampler. Compiles a definition into a sampler. The
+      # "compilation" is only a metaphor here, since definition - which is given to `compile` as
+      # a block - is simply executed in the context of a fresh {Quick::Sampler::DSL}
+      # instance (where available syntax can be found).
+      #
+      # @example Compile a sampler
+      #   chaos = Quick::Sampler.compile description: "a bit of everything" do
+      #     one_of_weighted integer => 5,
+      #                     boolean => 1,
+      #                     pick_from(-10.0..10.0) => 10,
+      #                     string(:alnum) => 15,
+      #                     feed { Faker::Internet.email } => 3
+      #   end
+      #
+      # @param [String] description sampler description which
+      #   will be returned by `#inspect` as well as `#description`
+      #
+      # @param block sampler definition. Will be `instance_eval`ed in the context of an
+      #   anonymous instance of {Quick::Sampler::DSL}.
+      #
+      # @return [Quick::Sampler] compiled sampler
+      #
+      # @!method compile(description: nil, &block)
+      delegate :compile, to: Quick::Sampler::DSL
+
+      # @api private
+      #
+      # Tests if `obj` is an instance of a known Quick Sampler sub-type.
+      #
+      # @param [Object] obj the object to test
+      # @return [Boolean] true if the object is of a Quick Sampler sub-type
+      def === obj
+        Base === obj || DSL::Fluidiom === obj
+      end
+    end
+  end
+end
+

data/quick-sampler.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "quick/sampler/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "quick-sampler"
+  spec.version       = Quick::Sampler::VERSION
+  spec.authors       = ["Artem Baguinski"]
+  spec.email         = ["abaguinski@depraktijkindex.nl"]
+  spec.summary       = %q{Composable samplers of random data}
+  spec.description   = %q{Describe randomness and watch it blend}
+  spec.homepage      = "https://github.com/praktijkindex/quick-sampler"
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.4"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "redcarpet"
+
+  spec.add_dependency "activesupport"
+end

data/spec/quick/sampler/compile_spec.rb

@@ -0,0 +1,41 @@
+describe Quick::Sampler do
+  specify do
+    expect(Quick::Sampler).to have_method :compile
+  end
+
+  context "given a simple script" do
+    let(:sampler) { Quick::Sampler.compile { const(:it_lives!) } }
+    it "compiles a sampler from a DSL script" do
+      expect(sampler).to be_a Quick::Sampler::Base
+    end
+  end
+
+  context "given a description: option" do
+    let(:sampler) {
+      Quick::Sampler.compile description: "wine sampler" do
+        one_of(:chiraz, :pinot_noir, :riesling)
+      end
+    }
+
+    it "sets description as sampler's description" do
+      expect(sampler.description).to be == "wine sampler"
+    end
+
+    it "makes the sampler to return description when inspected" do
+      expect(sampler.inspect).to be == "wine sampler"
+    end
+  end
+
+  context "given an unbound reference in the script" do
+    let(:external_thing) { 42 }
+    let(:sampler) {
+      Quick::Sampler.compile do
+        const(external_thing)
+      end
+    }
+
+    it "resolves it in the context compile was called in" do
+      expect(sampler.first).to be 42
+    end
+  end
+end

data/spec/quick/sampler/dsl/list_like_spec.rb

@@ -0,0 +1,62 @@
+describe Quick::Sampler::DSL do
+  it { is_expected.to have_method :list_like }
+  let(:dsl) { subject }
+
+  describe "#list_like" do
+    let(:sampled_lists) {
+      dsl.list_like(*args).first(5)
+    }
+    let(:positive_integer) { dsl.positive_integer }
+    let(:negative_integer) { dsl.negative_integer }
+
+    context "given no arguments" do
+      let(:args) { [] }
+      it "repeats empty lists" do
+        expect(sampled_lists).to all match []
+      end
+    end
+
+    context "given only constants" do
+      let(:args) { [1, 2, 3] }
+      it "repeats args as is" do
+        expect(sampled_lists).to all eq args
+      end
+    end
+
+    context "given a list of samplers" do
+      let(:args) { [positive_integer, negative_integer] }
+      it "samples from each sampler" do
+        expect(sampled_lists).to all match [a_value > 0, a_value < 0]
+      end
+    end
+
+    context "given a combination of samplers and constants" do
+      let(:args) { ["text", positive_integer, negative_integer, 3.14159] }
+      it "keeps constants as is, but samples the samplers" do
+        expect(sampled_lists).to all match ["text", a_value > 0, a_value < 0, 3.14159]
+      end
+    end
+
+    context "given a hash with constant keys and values" do
+      let(:args) { [const: 42, another: 666] }
+      it "repeats the hash as is" do
+        expect(sampled_lists).to all match args
+      end
+    end
+
+    context "given a hash with sampler values" do
+      let(:args) { [positive_integer: positive_integer, negative_integer: negative_integer] }
+      it "samples the values" do
+        expect(sampled_lists).to all match [positive_integer: a_value > 0, negative_integer: a_value < 1]
+      end
+    end
+
+    context "given a nested array with samplers" do
+      let(:args) { ["outie", ["innie", positive_integer, negative_integer, 3.14159, option: positive_integer]] }
+      it "recurses into the array" do
+        expect(sampled_lists).to all match ["outie", ["innie", a_value > 0, a_value < 0, 3.14159, option: a_value > 0]]
+      end
+    end
+
+  end
+end

data/spec/quick/sampler/dsl/send_to_spec.rb

@@ -0,0 +1,58 @@
+describe Quick::Sampler::DSL do
+  it { is_expected.to have_method :send_to }
+  let(:dsl) { subject }
+
+  describe "#send_to" do
+    let(:sampled_results) {
+      dsl.send_to(*args).first(5)
+    }
+    let(:two) { double("two", value: 2, string: "two") }
+    let(:three) { double("three", value: 3, string: "three") }
+    before do
+      allow(two).to receive(:times) { |x| 2 * x }
+      allow(three).to receive(:times) { |x| 3 * x }
+    end
+
+    context "given object and method" do
+      let(:args) { [two, :value] }
+      it "samples a method call result" do
+        expect(sampled_results).to all be == 2
+      end
+    end
+
+    context "given object, method and argument" do
+      let(:args) { [two, :times, 3] }
+      it "samples a method call result" do
+        expect(sampled_results).to all be == 6
+      end
+    end
+
+    context "given a sampler as the only argument" do
+      let(:args) { [ dsl.one_of([two, dsl.one_of(:value, :string)], [three, :times, 4]) ] }
+      it "samples the message argument" do
+        expect(sampled_results).to all eq(2).or eq("two").or eq(12)
+      end
+    end
+
+    context "given a sampler as the first argument" do
+      let(:args) { [two, dsl.one_of(:value, :string)] }
+      it "samples the object to send to" do
+        expect(sampled_results).to all eq(2).or eq("two")
+      end
+    end
+
+    context "given a sampler as a second argument" do
+      let(:args) { [dsl.one_of(two, three), :value] }
+      it "samples a message to send" do
+        expect(sampled_results).to all eq(2).or eq(3)
+      end
+    end
+
+    context "given a sampler as third argument" do
+      let(:args) { [two, :times, dsl.one_of(2,3,4)] }
+      it "samples the message argument" do
+        expect(sampled_results).to all eq(4).or eq(6).or eq(8)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "quick/sampler"
+
+RSpec::Matchers.alias_matcher :have_method, :respond_to

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: quick-sampler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Artem Baguinski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: redcarpet
+  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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Describe randomness and watch it blend
+email:
+- abaguinski@depraktijkindex.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/quick/sampler.rb
+- lib/quick/sampler/autoload.rb
+- lib/quick/sampler/base.rb
+- lib/quick/sampler/config.rb
+- lib/quick/sampler/dsl.rb
+- lib/quick/sampler/dsl/character_class.rb
+- lib/quick/sampler/dsl/fluidiom.rb
+- lib/quick/sampler/dsl/simple_combinators.rb
+- lib/quick/sampler/dsl/simple_values.rb
+- lib/quick/sampler/shrink.rb
+- lib/quick/sampler/shrink/class_methods/while.rb
+- lib/quick/sampler/shrink/refinements.rb
+- lib/quick/sampler/version.rb
+- quick-sampler.gemspec
+- spec/quick/sampler/compile_spec.rb
+- spec/quick/sampler/dsl/list_like_spec.rb
+- spec/quick/sampler/dsl/send_to_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/praktijkindex/quick-sampler
+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: Composable samplers of random data
+test_files:
+- spec/quick/sampler/compile_spec.rb
+- spec/quick/sampler/dsl/list_like_spec.rb
+- spec/quick/sampler/dsl/send_to_spec.rb
+- spec/spec_helper.rb
+has_rdoc: