duplo 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ced13192f8a77859809d3f5152405b8b8277d422
-  data.tar.gz: 82096e9fd70ffb4a938ace1f83cf69bbd5a1cd38
+  metadata.gz: 0d02593bee25e38b9368df7f965717035db59579
+  data.tar.gz: af814995e2b547a0d85f3ba5cf02b95962b8088b
 SHA512:
-  metadata.gz: 81567d7e7c0185dde4fcb4982a56fd09c2fd65093ef0ce0487ec908b8fe2dec9f78210ce81a125e19b31e1139de89b934ff63b34fb147c19c1893d1edadda908
-  data.tar.gz: 32845ca94f81a928a665353c463320e7ac991c4ebe90e00f84f7e30fbb0f882be8f3245c7cf4e293bf9a6689a82f73dfe8035bafc552b61475ba25be78ed1a21
+  metadata.gz: cc9294e2222a29169114d39483d8f624f7507cf0523af3ddbc9961f288ba5331db8107d7101a2cff067ffeca08978f10e8773f2121e0fc94b972ff12e89d76f4
+  data.tar.gz: 84bfb768ff5d817cf694b9f7914baa2dc77589f72d0e1232ee9bb9bde8d36355e8669817832ea87937e6cb6182a64ad8d2e22fb35c99c848263385960679e021

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Duplo changelog
 
+### 0.1.2 (2015-08-30)
+
+* Yield integers for vector entries instead of arrays
+* Drop `#abc`
+
 ### 0.1.1 (2015-05-09)
 
 * Provide `#respond_to_missing?`

data/README.md

@@ -4,22 +4,16 @@ Duplo
 [![Gem Version](https://badge.fury.io/rb/duplo.svg)](https://rubygems.org/gems/duplo)
 [![Build Status](https://travis-ci.org/topalovic/duplo.svg?branch=master)](https://travis-ci.org/topalovic/duplo)
 
-Generate nested collections with minimum effort.
+A tiny Ruby DSL for generating collections.
 
-```
- .-===============-.
- | ( ) ( ) ( ) ( ) |
- | ( ) ( ) ( ) ( ) |
- '-----------------' ndt.
-```
+<img src="https://cloud.githubusercontent.com/assets/626128/7639329/545932e6-fa7b-11e4-84b0-a64c9e23c9df.png" width="100">
 
 
 ## Usage
 
-Let's say you like matrices (bear with me), but not rolling them out
-by hand or writing nested loops to populate them. Or you might need a
-few nested hashes to test something real quick in the console, but
-generating them can be a royal PITA.
+Let's say you like matrices (bear with me) but not rolling them out by
+hand. Or say you need to generate some data samples quickly in the
+console but writing nested loops is not really your idea of fun.
 
 So how about this:
 
@@ -27,126 +21,134 @@ So how about this:
 require "duplo"
 include Duplo
 
-a3a4
-# => [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
+a4a8
+#=> [[0, 1, 2, 3, 4, 5, 6, 7],
+#    [0, 1, 2, 3, 4, 5, 6, 7],
+#    [0, 1, 2, 3, 4, 5, 6, 7],
+#    [0, 1, 2, 3, 4, 5, 6, 7]]
 ```
 
-Bam. A 3x4 matrix.
+Bam. A 4x8 matrix.
 
-Want it random? Sure. Pass it a block to populate the entries:
+Want it randomized? Just pass it a block to populate the entries:
 
 ```ruby
-a3a4 { rand -5..5 }
-# => [[1, 9, 8, 3], [3, 0, -1, -2], [2, 0, 5, -7]]
-a3a4 { rand }
-# => [[0.6222777300676433,  0.5613390139342668,  0.37293736375203324, 0.7319666374054961],
-#     [0.3798588109025701,  0.33483069318178915, 0.8779112502970073,  0.22476545143154103],
-#     [0.37651300630626683, 0.5035024403835663,  0.8237420938739567,  0.7611012983149591]]
+a4a8 { rand 10 }
+#=> [[5, 1, 2, 7, 8, 9, 6, 1],
+#    [7, 6, 6, 0, 7, 1, 0, 8],
+#    [9, 3, 8, 7, 6, 4, 4, 5],
+#    [3, 0, 9, 0, 7, 3, 8, 9]]
 ```
 
-Accessing the current entry path is easy peasy. Have an identity
-matrix:
+This works too:
 
 ```ruby
-I4 = a4a4 { |i, j| i == j ? 1 : 0  }
-# => [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+Duplo.a4a8
 ```
 
-Have I mentioned that you can go up to an arbitrary number of
-dimensions?
+so including the module is optional. The gem works its magic through
+`method_missing` so it won't stomp on existing names either way.
+
+
+### Entry path
+
+Populating the entries is easy peasy. Here, have an identity matrix:
 
 ```ruby
-a3a3a2 { |i,j,k| [i,j,k].join(":") }
-# => [[["0:0:0", "0:0:1"], ["0:1:0", "0:1:1"], ["0:2:0", "0:2:1"]],
-#     [["1:0:0", "1:0:1"], ["1:1:0", "1:1:1"], ["1:2:0", "1:2:1"]],
-#     [["2:0:0", "2:0:1"], ["2:1:0", "2:1:1"], ["2:2:0", "2:2:1"]]]
+I5 = a5a5 { |i, j| i == j ? 1 : 0 }
+#=> [[1, 0, 0, 0, 0],
+#    [0, 1, 0, 0, 0],
+#    [0, 0, 1, 0, 0],
+#    [0, 0, 0, 1, 0],
+#    [0, 0, 0, 0, 1]
 ```
 
-Heads up, it might get a bit sluggish with higher dims due to the
-recursive approach under the hood.
-
-Now how 'bout them Hashes:
+If plain old matrices bore you, you can do simple vectors:
 
 ```ruby
-h3h2h2 { |path| "I'm a #{path.join}" }
-# => {0=>{0=>{0=>"I'm a 000", 1=>"I'm a 001"}, 1=>{0=>"I'm a 010", 1=>"I'm a 011"}},
-#     1=>{0=>{0=>"I'm a 100", 1=>"I'm a 101"}, 1=>{0=>"I'm a 110", 1=>"I'm a 111"}},
-#     2=>{0=>{0=>"I'm a 200", 1=>"I'm a 201"}, 1=>{0=>"I'm a 210", 1=>"I'm a 211"}}}
+a10 { |i| i ** 2 }
+#=> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 ```
 
-You can also use `s` for Sets, and mix and match collection types to
-your little heart's desire:
+or arbitrary tensors:
 
 ```ruby
-ah2s3 { abc.sample(2).join }
-# => [{0=>#<Set: {"kx", "by", "fi"}>, 1=>#<Set: {"uz", "ow", "tx"}>},
-#     {0=>#<Set: {"tp", "ch", "ba"}>, 1=>#<Set: {"nu", "mn", "ve"}>},
-#     {0=>#<Set: {"nc", "dh", "dc"}>, 1=>#<Set: {"le", "ks", "th"}>},
-#     {0=>#<Set: {"ca", "xj", "lm"}>, 1=>#<Set: {"hg", "xg", "rz"}>},
-#     {0=>#<Set: {"oq", "vb", "ed"}>, 1=>#<Set: {"gq", "px", "sv"}>}]
+a4a11a2a3 { |path| path.join(":") }
+#=> [[[["0:0:0:0", "0:0:0:1", "0:0:0:2"],
+#      ["0:0:1:0", "0:0:1:1", "0:0:1:2"]],
+#      . . .
+#      ["3:10:1:0", "3:10:1:1", "3:10:1:2"]]]]
 ```
 
-You get the picture. If you're *really* bored, you can spell those out
-loud:
+The last example also shows how to use the full entry path without
+destructuring.
+
+
+### Other toys
+
+In addition to `a`rrays, you can build `h`ashes and `s`ets, and mix
+and match collection types to your heart's desire:
 
 ```ruby
-Duplo.spell "ah2s0"
-# => "5-element Array containing 2-element Hashes containing empty Sets"
+sa2h3 { rand 100 }
+#=> #<Set: {[{0=>11, 1=>47, 2=>48}, {0=>3,  1=>71, 2=>57}],
+#           [{0=>97, 1=>9,  2=>43}, {0=>90, 1=>30, 2=>62}],
+#           [{0=>87, 1=>56, 2=>23}, {0=>24, 1=>16, 2=>63}],
+#           [{0=>6,  1=>12, 2=>57}, {0=>44, 1=>3,  2=>74}],
+#           [{0=>52, 1=>92, 2=>12}, {0=>93, 1=>32, 2=>1}]}>
 ```
 
-Note that I've omitted a dim for the root array in that last
-example. It defaults to 5, so `as2h` means the same thing as
-`a5s2h5`. You can easily change it like this:
+Let's spell that out:
 
 ```ruby
-Duplo.default_size = 3
+Duplo.spell "sa2h3"
+#=> "5-element Set containing 2-element Arrays containing 3-element Hashes"
 ```
 
-Also, I sneaked in a cute little `abc` method that returns the
-alphabet as an array (as seen in the last example).
+Note that I've omitted size for the root collection there. It defaults
+to 5, so `aaa` yields the same result as `a5a5a5`. Set your preferred
+default like this:
 
+```ruby
+Duplo.default_size = 10
+```
 
-## Installation
 
-You know the drill.
+### Dynamic dimensions
 
-Add this line to your application's Gemfile, presumably in the
-"development" or "test" group:
+If you want to supply dimensions dynamically, this should do the trick:
 
 ```ruby
-gem "duplo"
+m, n = 3, 4
+toy = "a#{m}a#{n}"
+
+Duplo.build(toy) { rand }
 ```
 
-or install it yourself as:
 
-```console
-$ gem install duplo
-```
+## Installation
 
-It's not really necessary to include the module, you can use it
-directly:
+Add this line to your application's Gemfile:
 
 ```ruby
-Duplo.a2a2
+gem "duplo"
 ```
 
-If you do include it, don't worry about monkey patching - the gem
-works its magic by utilizing `method_missing`, so there should be no
-name clashes.
+or install it yourself as:
 
-My personal preference is to drop this in `.pryrc` (or `.irbrc`):
+```sh
+$ gem install duplo
+```
 
+My personal preference is to drop this into `.irbrc` (or `.pryrc`):
 
 ```ruby
-begin
-  require "duplo"
-  include Duplo
-rescue LoadError
-end
+require "duplo"
+include Duplo
 ```
 
-and have those handy shortcuts available in every session, `a` and `h`
-in particular.
+and have all those handy shortcuts available in every session.
+
 
 
 ## Testing
@@ -154,20 +156,10 @@ in particular.
 To test the gem, clone the repo and run:
 
 ```
-$ bundle
-$ bundle exec rake
+$ bundle && bundle exec rake
 ```
 
 
-## Contributing
-
-1. [Fork it](https://github.com/topalovic/duplo/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
-
-
 ## License
 
 This gem is released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/duplo.rb

@@ -33,14 +33,16 @@ module Duplo
     end
 
     def build(part, path = [], &block)
+      raise %(Don't know how to build "#{part}", sorry) unless can_build? part
+
       part = part.dup
       brick = part.slice! BRICK
       type, size = crack brick
       toy = type.new
 
       if part.empty?
-        _block = block_given? ? block : proc { |path| path.last }
-        size.times { |i| add toy, _block.call(path + [i]) }
+        block ||= proc { |path| path.is_a?(Array) ? path.last : path }
+        size.times { |i| add toy, block.call(path.empty? ? i : path + [i]) }
       else
         size.times { |i| add toy, build(part, path + [i], &block) }
       end
@@ -68,11 +70,6 @@ module Duplo
 
   module_function
 
-  def abc(n = nil)
-    range = "a".."z"
-    n ? range.take(n) : range.to_a
-  end
-
   def respond_to_missing?(method_name, *)
     toy = method_name.to_s
     Duplo.can_build?(toy) || super

data/lib/duplo/version.rb

@@ -1,3 +1,3 @@
 module Duplo
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/spec/duplo_spec.rb

@@ -2,21 +2,14 @@ require "spec_helper"
 
 describe Duplo do
 
-  let(:default_size) { Duplo.default_size }
+  let(:default_size)   { Duplo.default_size }
   let(:valid_bricks)   { %w[a aa s ss h hh a0 a1h a2s33h44] }
   let(:invalid_bricks) { %w[A n 0 11 1s a2s33t44] }
 
-    it "has a version number" do
+  it "has a version number" do
     expect(Duplo::VERSION).not_to be nil
   end
 
-  describe ".abc" do
-    it "provides alphabet" do
-      expect(Duplo.abc).to eq ("a".."z").to_a
-      expect(Duplo.abc 4).to eq ("a".."d").to_a
-    end
-  end
-
   describe ".respond_to?" do
     it "returns true for valid bricks" do
       valid_bricks.each do |brick|
@@ -62,6 +55,28 @@ describe Duplo do
         expect(Duplo.build brick).to eq toy
       end
     end
+
+    it "raises error when given invalid brick" do
+      invalid_bricks.each do |brick|
+        expect { Duplo.build brick }.to raise_error RuntimeError
+      end
+    end
+
+    describe "when given a block" do
+      let(:block) { proc { |entry| entry.class } }
+
+      describe "when given one dimension" do
+        it "yields entry path as integer and populates entries" do
+          expect(Duplo.build "a1", &block).to eq [Fixnum]
+        end
+      end
+
+      describe "when given more than one dimension" do
+        it "yields entry path as array and populates entries" do
+          expect(Duplo.build "a1a1", &block).to eq [[Array]]
+        end
+      end
+    end
   end
 
   describe ".smash" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duplo
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Nikola Topalović
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-09 00:00:00.000000000 Z
+date: 2015-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -71,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Generate nested collections with minimum effort.