conditional_sample 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66f4bd90cb090564aa82b8fcf2542ee09be6d90e
-  data.tar.gz: d92cfeb38c8587e14a787c22865dd393b1ca953f
+  metadata.gz: b434daa60973a4f9635935c2dbd4c0a8f5fbc326
+  data.tar.gz: d006afa5b840f9d101115b497130316b88f8f6dc
 SHA512:
-  metadata.gz: 4849a931094f7dc5577632fc630216ae22a6c28dd1f9fff08e7aaf8303f52b10a9f13e1ee5495e2a698bcd98adef440e099b7875f37dae760ace83a0db3ae161
-  data.tar.gz: 76a8a68232ec62e2a83e52d23708b669e41d7fcfe009a1e6b09689621fdd021e69a8edfeaa84f1f14955dc1eacc82de7544ba0e7ff8d5f2649fa56f7b4134510
+  metadata.gz: 2d6b55ef238143c688f68ba3c710d3f1a591f6793fdd2fd0870a8d717c36858a37fc9be5ec572a33fd1c0a86e203258e8e4de9ed82ff27adeee69ed17d49ccc5
+  data.tar.gz: 3c649f08e5d88f08af315014eaa58e05d8b1871829ebb63e5e650f32ff9d2c87ea14085e6fd1af70ce52ea9a7826a6c9dd90b5bf1464870473be31f921351029

data/README.md

@@ -3,13 +3,13 @@
 by Paul Thompson - nossidge@gmail.com
 
 This is a Ruby gem that will patch the Array class with a couple of
-nice methods for sampling based on the results of an array of Boolean
-procs. Array is sampled using the procs as conditions that each specific
-array index element must conform to.
+nice methods for sampling based on the results of an array or hash of
+Boolean procs. Array is sampled using the procs as conditions that each
+specific array index element must conform to.
 
 I'm using this primarily for procedural generation, where I have an
-array of possible values and a certain sample I need, or order in which
-I want the values arranged.
+array of possible values and a certain sample I need to extract, or an
+order in which I want the values arranged.
 
 This code was spun off into a gem from my poetry generation project
 https://github.com/nossidge/poefy
@@ -57,11 +57,16 @@ elements from the input array are appended.
 
 This is an array of boolean procs that evaluate true if an element is
 allowed to be placed in that position.
+
 The arguments for each proc are |arr, elem|
 * **arr**  is a reference to the current array that has been built up
            through the recursion chain.
 * **elem** is a reference to the current element being considered.
 
+This can also be a hash. In that case, the key will correspond to
+the element in the output array. Non-Integer keys are ignored, and
+there is no implicit call to #to_i.
+
 
 ### The 'seconds' argument
 
@@ -144,6 +149,43 @@ p shuf_sample  # => [2, 5, 4]
 ```
 
 
+### Condition hash example
+
+```ruby
+# 8 element input array.
+array = [1, 2, 3, 4, 'f', 5, nil, 6]
+
+# Conditions hash.
+# * [3] is the largest Integer key, so the resulting
+#   array will have four elements.
+# * Keys ['1'] and [nil] aren't Integers, so are ignored.
+# * Key [2] is given the default value of:
+#   proc { |arr, elem| true }
+conditions = {
+  1   => proc { |arr, elem| elem.to_i > 1 },
+  3   => proc { |arr, elem| elem.to_i > 5 },
+  0   => proc { |arr, elem| elem == 'f' },
+  '1' => proc { |arr, elem| false },
+  nil => proc { |arr, elem| false }
+}
+
+# These will always return the below output
+# because they are the first values that match.
+permut = array.conditional_permutation(conditions)
+sample = array.conditional_sample(conditions)
+p permut  # => ['f', 2, 1, 6, 3, 4, 5, nil]
+p sample  # => ['f', 2, 1, 6]
+
+# To get a random sample, #shuffle the array first.
+# These results will vary based on the shuffle.
+shuf = array.shuffle
+shuf_permut = shuf.conditional_permutation(conditions)
+shuf_sample = shuf.conditional_sample(conditions)
+p shuf_permut  # => ['f', 3, 5, 6, 2, 1, nil, 4]
+p shuf_sample  # => ['f', 3, 5, 6]
+```
+
+
 ### Random rhyming lines
 
 A really simple way to extract rhyming lines from an input array.

data/lib/conditional_sample.rb

@@ -15,4 +15,26 @@ module ConditionalSample
   #
   Array.include ConditionalSample::MixMe
 
+  ##
+  # Raise an error if an object does not respond to a specific method.
+  #
+  def self.method_assert object, method_name
+    unless object.respond_to?(method_name)
+      raise NoMethodError, "Missing method ##{method_name}"
+    end
+  end
+
+  ##
+  # Convert a hash to array, with key as index.
+  # Fill any missing elements with a default value.
+  #
+  def self.to_conditions_array input, default = nil
+    return input if input.is_a? Array
+
+    # Get a list of all Integer keys.
+    # Use the biggest key, and make an array of that length + 1.
+    keys = input.keys.select { |i| i.is_a? Integer }
+    keys.max.next.times.map  { |i| input[i] || default }
+  end
+
 end

data/lib/conditional_sample/private.rb

@@ -78,7 +78,7 @@ module ConditionalSample
           break if valid
         end
 
-        output.flatten.compact
+        output.flatten
       end
 
       ##
@@ -130,7 +130,7 @@ module ConditionalSample
           break if valid
         end
 
-        output.flatten.compact
+        output.flatten
       end
 
   end

data/lib/conditional_sample/public.rb

@@ -37,11 +37,16 @@ module ConditionalSample
     #
     #    possible output => [1, 3, 4, 5, 2]
     #
-    # Will not work on arrays that contain nil values.
-    #
     def conditional_permutation conditions, seconds = nil
+      ConditionalSample::method_assert(self, 'to_a')
+
+      # Convert the conditions to an array.
+      conditions =
+        ConditionalSample::to_conditions_array(conditions, proc { true })
+
+      # Run the recursion, and rescue after a number of seconds.
       timeout_rescue(seconds, []) do
-        conditional_permutation_recurse(self.to_a, conditions)
+        conditional_permutation_recurse(self.to_a, conditions).tap{ |i| i.pop }
       end
     end
 
@@ -65,11 +70,20 @@ module ConditionalSample
     #
     #    possible output => [1, 5, 3]
     #
-    # Will not work on arrays that contain nil values.
-    #
     def conditional_sample conditions, seconds = nil
+      ConditionalSample::method_assert(self, 'to_a')
+
+      # Would always return [] anyway if there are more conditions than
+      # inputs, this just avoids running the complex recursion code.
+      return [] if conditions.length > self.to_a.length
+
+      # Convert the conditions to an array.
+      conditions =
+        ConditionalSample::to_conditions_array(conditions, proc { true })
+
+      # Run the recursion, and rescue after a number of seconds.
       timeout_rescue(seconds, []) do
-        conditional_sample_recurse(self.to_a, conditions)
+        conditional_sample_recurse(self.to_a, conditions).tap{ |i| i.pop }
       end
     end
 

data/lib/conditional_sample/version.rb

@@ -7,8 +7,8 @@ module ConditionalSample
   # The number of the current version.
   #
   def self.version_number
-    major = 0
-    minor = 1
+    major = 1
+    minor = 0
     tiny  = 0
     pre   = nil
 
@@ -19,6 +19,6 @@ module ConditionalSample
   # The date of the current version.
   #
   def self.version_date
-    '2017-06-27'
+    '2017-06-30'
   end
 end

data/spec/conditional_sample_spec.rb

@@ -13,9 +13,9 @@ describe ConditionalSample, "basic behaviour" do
   let(:numbers) { (1..5).to_a }
   let(:conditions) {
     [
-      proc { |arr, elem| elem < 2},
-      proc { |arr, elem| elem > 4},
-      proc { |arr, elem| elem > 1}
+      proc { |arr, elem| elem.to_i < 2},
+      proc { |arr, elem| elem.to_i > 4},
+      proc { |arr, elem| elem.to_i > 1}
     ]
   }
   let(:output_sample) { [1, 5, 2] }
@@ -40,6 +40,81 @@ describe ConditionalSample, "basic behaviour" do
     expect(result[0]).to be 1
     expect(result[1]).to be 5
   end
+
+  it "should correctly handle nil values" do
+    add_nil_values = numbers.dup
+    10.times do
+      add_nil_values << nil
+      result = add_nil_values.shuffle.conditional_sample(conditions)
+      expect(result.count).to be conditions.count
+      result = add_nil_values.shuffle.conditional_permutation(conditions)
+      expect(result.count).to be add_nil_values.count
+    end
+  end
+
+  it "should correctly handle nil values" do
+    add_nil_values = numbers.dup
+    10.times do
+      add_nil_values << nil
+      result = add_nil_values.shuffle.conditional_sample(conditions)
+      expect(result.count).to be conditions.count
+      result = add_nil_values.shuffle.conditional_permutation(conditions)
+      expect(result.count).to be add_nil_values.count
+    end
+  end
+
+  it "conditional_permutation should correctly handle nil values" do
+    add_nil_values = numbers.dup
+    10.times do
+      add_nil_values << nil
+      result = add_nil_values.shuffle.conditional_sample(conditions)
+      expect(result.count).to be conditions.count
+      result = add_nil_values.shuffle.conditional_permutation(conditions)
+      expect(result.count).to be add_nil_values.count
+    end
+  end
+
+end
+
+################################################################################
+
+describe ConditionalSample, "when conditions.length > array.length" do
+
+  # Input values.
+  let(:array) { [1, 3, 4, "f", 5, 2, nil, 6] }
+  let(:possible) {
+    100.times.map do
+      proc { |arr, elem| true }
+    end
+  }
+  let(:impossible) {
+    100.times.map do
+      proc { |arr, elem| elem.to_i > 1 }
+    end
+  }
+
+  describe "conditional_sample" do
+    it "with procs that are possible, should output []" do
+      result = array.conditional_sample(possible)
+      expect(result).to eq []
+    end
+    it "with procs that are impossible, should output []" do
+      result = array.conditional_sample(impossible)
+      expect(result).to eq []
+    end
+  end
+
+  describe "conditional_permutation" do
+    it "with procs that are possible, should output the array" do
+      result = array.conditional_permutation(possible)
+      expect(result).to eq array
+    end
+    it "with procs that are impossible, should output []" do
+      result = array.conditional_permutation(impossible)
+      expect(result).to eq []
+    end
+  end
+
 end
 
 ################################################################################
@@ -58,39 +133,49 @@ describe ConditionalSample, "mixin behaviour" do
   let(:output_sample) { [1, 5, 2] }
   let(:output_permutation) { [1, 5, 2, 3, 4] }
 
-  it "should correctly work with a Struct implementing #to_a" do
+  it "should correctly work with a Class implementing #to_a" do
 
-    # Attempt to mix in using extend on a Struct instance.
-    struct = Struct.new(:contents) do
+    # Class which includes MixMe and implements #to_a
+    class MixerWith
+      include ConditionalSample::MixMe
+      def initialize value
+        @value = value
+      end
       def to_a
-        contents.to_a
+        @value.to_a
       end
-    end.new numbers
-    struct.extend ConditionalSample::MixMe
+    end
+    mixer = MixerWith.new numbers
 
     # Run the methods, and compare results.
-    result = struct.conditional_sample(conditions)
+    result = mixer.conditional_sample(conditions)
     expect(result).to eq output_sample
 
-    result = struct.conditional_permutation(conditions)
+    result = mixer.conditional_permutation(conditions)
     expect(result).to eq output_permutation
   end
 
-  it "should fail on a Struct not implementing #to_a" do
+  it "should fail on a Class not implementing #to_a" do
 
-    # Attempt to mix in using extend on a Struct instance.
-    struct = Struct.new(:contents).new numbers
-    struct.extend ConditionalSample::MixMe
+    # Class which includes MixMe but doesn't implement #to_a
+    class MixerWithout
+      include ConditionalSample::MixMe
+      def initialize value
+        @value = value
+      end
+    end
+    mixer = MixerWithout.new numbers
 
     # Run the methods, and expect that they will fail.
     expect do
-      struct.conditional_sample(conditions)
+      mixer.conditional_sample(conditions)
     end.to raise_error NoMethodError
 
     expect do
-      struct.conditional_permutation(conditions)
+      mixer.conditional_permutation(conditions)
     end.to raise_error NoMethodError
   end
+
 end
 
 ################################################################################

data/spec/examples_spec.rb

@@ -40,6 +40,39 @@ describe ConditionalSample, "examples" do
 
   ##############################################################################
 
+  it "should output the correct results: Condition hash example" do
+
+    # 8 element input array.
+    array = [1, 2, 3, 4, 'f', 5, nil, 6]
+
+    # 4 element conditions hash.
+    conditions = {
+      1   => proc { |arr, elem| elem.to_i > 1 },
+      3   => proc { |arr, elem| elem.to_i > 5 },
+      0   => proc { |arr, elem| elem == 'f' },
+      '1' => proc { |arr, elem| false },
+      nil => proc { |arr, elem| false }
+    }
+
+    # These will always return the below output
+    # because they are the first values that match.
+    permut = array.conditional_permutation(conditions)
+    sample = array.conditional_sample(conditions)
+    expect(permut).to eq ['f', 2, 1, 6, 3, 4, 5, nil]
+    expect(sample).to eq ['f', 2, 1, 6]
+
+    # To get a random sample, #shuffle the array first.
+    # These results will vary based on the shuffle.
+    srand(37)
+    shuf = array.shuffle
+    shuf_permut = shuf.conditional_permutation(conditions)
+    shuf_sample = shuf.conditional_sample(conditions)
+    expect(shuf_permut).to eq ['f', 3, 5, 6, 2, 1, nil, 4]
+    expect(shuf_sample).to eq ['f', 3, 5, 6]
+  end
+
+  ##############################################################################
+
   it "should output the correct results: Random rhyming lines" do
 
     # Use this gem to get the rhyme of the line's final word.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: conditional_sample
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Paul Thompson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-27 00:00:00.000000000 Z
+date: 2017-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler