duplo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93bf9116a547102fde94dcfc60589763f00f53e0
+  data.tar.gz: 84d1ce7ffe10cc5cf596236e648faa9d4b92eca0
+SHA512:
+  metadata.gz: 0fed2f92b20b3bfb3261cb91573e60b56260c9fcddd2a8b9c91838a0c6f5b2bcc1f9be4a03b14aa389709cbfe24a5960f836c8a75b36f4d4da8cd923ab72e88e
+  data.tar.gz: fcf4f4e86ab76a7bc060c64033f9f5f5f7a842490e68796f26b39ec89e55b1f595fd59c0d63b2e1d4842e3a5dbc11d93a4c99a5a9fa09ae20d9f3d0e08d0a970

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Duplo changelog
+
+### 0.1.0 (2015-05-09)
+
+* First release

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Nikola Topalović
+
+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,160 @@
+Duplo
+=====
+
+Generating nested collections with minimum effort.
+
+```
+.-===============-.
+| ( ) ( ) ( ) ( ) |
+| ( ) ( ) ( ) ( ) |
+'-----------------' ndt.
+```
+
+
+## Usage
+
+Say you like matrices (bear with me), but not rolling them out by hand
+or writing nested loops to populate them. You might need a nested hash
+to test something real quick in your console, but generating it can be
+a royal PITA.
+
+So how about this:
+
+```ruby
+require "duplo"
+include Duplo
+
+a3a4
+# => [[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
+```
+
+Bam. A 3x4 matrix.
+
+Want it random? Sure. 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]]
+```
+
+Accessing the current entry path is easy peasy:
+
+```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"]]]
+ ```
+
+Have I mentioned that you can go up to an arbitrary number of
+dimensions? Just watch out, it might get sluggish with higher dims due
+to the recursive approach under the hood.
+
+So how 'bout them Hashes:
+
+```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"}}}
+```
+
+You can also use `s` for Sets, and mix and match collection types to
+your little heart's desire:
+
+```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"}>}]
+```
+
+You get the picture. If you're *really* bored, you can spell those out
+for fun:
+
+```ruby
+Duplo.spell "ah2s0"
+# => "5-element Array containing 2-element Hashes containing empty Sets"
+```
+
+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 the default size like this:
+
+```ruby
+Duplo.default_size = 3
+```
+
+Also, I sneaked in a cute little `abc` method that returns the
+alphabet as an array (as seen in the last example).
+
+
+## Installation
+
+You know the drill. Add this line to your application's Gemfile
+(presumably in the "development" or "test" group):
+
+```ruby
+gem "duplo"
+```
+
+or install it yourself as:
+
+```console
+$ gem install duplo
+```
+
+It's not exactly necessary to include the module, so you can work like
+this:
+
+```ruby
+Duplo.a2a2
+```
+
+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.
+
+My personal preference is to drop this in `.pryrc` (or `.irbrc`):
+
+
+```ruby
+begin
+  require "duplo"
+  include Duplo
+rescue LoadError
+end
+```
+
+and have those handy shortcuts available in every session, `a` and `h`
+in particular.
+
+
+## Testing
+
+To test the gem, clone the repo and run:
+
+```
+$ 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/version.rb

@@ -0,0 +1,3 @@
+module Duplo
+  VERSION = "0.1.0"
+end

data/lib/duplo.rb

@@ -0,0 +1,85 @@
+require "duplo/version"
+require "set"
+
+module Duplo
+
+  TOYS = {
+    "a" => Array,
+    "s" => Set,
+    "h" => Hash
+  }
+
+  BRICK = /[#{TOYS.keys.join}]\d*/
+
+  class << self
+
+    attr_writer :default_size
+
+    def default_size
+      @default_size || 5
+    end
+
+    def add(toy, part)
+      case toy
+      when Array, Set
+        toy << part
+      when Hash
+        toy.store(toy.size, part)
+      end
+    end
+
+    def can_build?(toy)
+      !!(toy.strip =~ /\A#{BRICK}+\z/)
+    end
+
+    def build(part, path = [], &block)
+      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]) }
+      else
+        size.times { |i| add toy, build(part, path + [i], &block) }
+      end
+
+      toy
+    end
+
+    def smash(toy)
+      toy.scan(BRICK).map { |brick| crack brick }
+    end
+
+    def crack(brick)
+      type, size = brick.split("", 2)
+      size = size.empty? ? default_size : size.to_i
+      [TOYS[type], size]
+    end
+
+    def spell(toy)
+      smash(toy).map.with_index do |(type, size), idx|
+        plural = idx == 0 ? "" : type == Hash ? "es" : "s"
+        size.zero? ? "empty #{type}#{plural}" : "#{size}-element #{type}#{plural}"
+      end.join(" containing ")
+    end
+  end
+
+  module_function
+
+  def abc(n = nil)
+    range = "a".."z"
+    n ? range.take(n) : range.to_a
+  end
+
+  def method_missing(method_name, *arguments, &block)
+    toy = method_name.to_s
+
+    if Duplo.can_build? toy
+      Duplo.build toy, *arguments, &block
+    else
+      super
+    end
+  end
+end

data/spec/duplo_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+describe Duplo do
+
+  let(:default_size) { Duplo.default_size }
+
+  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 ".can_build?" do
+    let(:valid_bricks)   { %w[a aa s ss h hh a0 a1h a2s33h44] }
+    let(:invalid_bricks) { %w[A n 0 11 1s a2s33t44] }
+
+    it "can build valid bricks" do
+      valid_bricks.each do |brick|
+        expect(Duplo.can_build? brick).to be true
+      end
+    end
+
+    it "cannot build invalid bricks" do
+      invalid_bricks.each do |brick|
+        expect(Duplo.can_build? brick).to be false
+      end
+    end
+  end
+
+  describe ".build" do
+    let(:bricks) do
+      {
+        "a"      => [0, 1, 2, 3, 4],
+        "h"      => { 0 => 0, 1 => 1, 2 => 2, 3 => 3, 4 => 4 },
+        "a2a3"   => [[0, 1, 2]] * 2,
+        "a3s2"   => [[0, 1].to_set] * 3,
+        "a2h3"   => [{ 0 => 0, 1 => 1, 2 => 2 }, { 0 => 0, 1 => 1, 2 => 2 }],
+        "a2h3s4" => [{ 0 => (0..3).to_set, 1 => (0..3).to_set, 2 => (0..3).to_set }] * 2
+      }
+    end
+
+    it "builds toys from bricks" do
+      bricks.each do |brick, toy|
+        expect(Duplo.build brick).to eq toy
+      end
+    end
+  end
+
+  describe ".smash" do
+    let(:bricks) do
+      {
+        "a"       => [[Array, default_size]],
+        "aa"      => [[Array, default_size], [Array, default_size]],
+        "a2a"     => [[Array, 2],  [Array, 5]],
+        "a2h0"    => [[Array, 2],  [Hash, 0]],
+        "a22h3s4" => [[Array, 22], [Hash, 3], [Set, 4]]
+      }
+    end
+
+    it "smashes bricks, rawr!" do
+      bricks.each do |brick, parts|
+        expect(Duplo.smash brick).to eq parts
+      end
+    end
+  end
+
+  describe ".spell" do
+    let(:bricks) do
+      {
+        "a"       => "5-element Array",
+        "aa"      => "5-element Array containing 5-element Arrays",
+        "a2h0"    => "2-element Array containing empty Hashes",
+        "a22h3s4" => "22-element Array containing 3-element Hashes containing 4-element Sets"
+      }
+    end
+
+    it "spells bricks properly" do
+      bricks.each do |brick, description|
+        expect(Duplo.spell brick).to eq description
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: duplo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nikola Topalović
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Generating nested collections with minimum effort.
+email:
+- nikola.topalovic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/duplo.rb
+- lib/duplo/version.rb
+- spec/duplo_spec.rb
+homepage: https://github.com/topalovic/duplo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Generating nested collections with minimum effort.
+test_files:
+- spec/duplo_spec.rb
+has_rdoc: