pattern_expander 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    pattern_expander (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.4)
+    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.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  pattern_expander!
+  rake
+  rspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Noah Thorp
+
+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,81 @@
+Pattern Expander
+======
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pattern_expander'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pattern_expander
+
+Usage
+=====
+
+Takes patterns and outputs their combinations - think reverse regex. Lazily loads "pages" of combinations and returns results before the heat death of the universe.
+
+Pass in a string with randomly chosen values in square brackets"[]":
+
+    expander = PatternExpander.new(
+      "My [startup|band|puppy's] name is [i|e||Power |Awesome ][Ninja|Rockstar] [Ministry|Labs|Quux]"
+    )
+
+Get random samples with #sample:
+
+    expander.sample # my startup name is Power Rockstar Ministry
+    expander.sample # my puppy's name is iNinja Labs
+    expander.sample(3) # get multiple samples
+
+Get specific index values:
+
+    expander = PatternExpander.new("[a|b][1|2]")
+    expander[0] # "a1"
+    expander[1] # "a2"
+    expander[0..3] # ["a1", "a2", "b1", "b2"]
+
+By default you can use "+d" and "+w" to map to digits and alphanumeric
+characters. Here's an example of constructing a big UUID like pattern:
+
+    expander = PatternExpander.new(
+      "[+w][+w][+w][+w]-[+w][+w][+w][+w]-[+w][+w][+w][+w]-[+w][+w][+w][+w]"
+    )
+    expander.sample # "eo6a-68m6-coxw-14j7"
+    expander[10_000_000_000..10_000_000_002]
+    # returns ["aaaa-aaaa-aaaa-ahz2", "aaaa-aaaa-aaaa-ahz3", "aaaa-aaaa-aaaa-ahz4"]
+
+And you can pass your own substitutes in and come up with your next
+startup elevator pitch:
+
+    expander = PatternExpander.new("It's like [+company] for [+customer]",
+      substitutes: {
+       '+company' =>  ['Chat Roulette',  'Kickstarter', 'Stack Overflow', 'SpaceX'],
+       '+customer' => ['Texas', 'pets', 'tweens', 'magicians', 'figure skaters']
+      }
+    )
+    expander.sample # It's like Chat Roulette for magicians
+    expander.sample # It's like Stack Overflow for Texas
+    expander.sample # It's like SpaceX for figure skaters
+
+
+TODO
+====
+* Sample should return any value only once
+* Error when max range has been exceeded for the index
+* Delegate methods from PatternExpander to CombinationIndex
+* Gemify
+
+
+Contributing
+=====
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/init.rb

@@ -0,0 +1 @@
+Dir.glob(__dir__ + '/lib/*').each {|file| require file }

data/lib/combination_index.rb

@@ -0,0 +1,60 @@
+class CombinationIndex
+  attr_reader :element_lists
+
+  def initialize(element_lists)
+    @element_lists = element_lists
+  end
+
+  def [](index_or_range)
+    if index_or_range.class == Range
+      index_or_range.to_a.map { |index| _single_combination(index) }
+    else
+      _single_combination(index_or_range)
+    end
+  end
+
+  def sample(quantity=1)
+    return _sample_one if quantity == 1
+    result = []
+    quantity.times { result << _sample_one }
+    result
+  end
+
+  def size
+    _element_list_sizes.reduce(:*)
+  end
+
+  def _sample_one
+    self[rand(size)]
+  end
+  # converts a single index to several indexes
+  # ie converts from base ten (index) to a mixed base value
+  # with each place (element array) being a new base (size of the element array)
+  def _multi_array_indexes(i)
+    element_list_sizes_tmp = _element_list_sizes
+    array_indexes = []
+
+    while element_list_size = element_list_sizes_tmp.pop
+      i, remainder = i.divmod(element_list_size)
+      array_indexes.unshift remainder
+    end
+
+    array_indexes
+  end
+
+  def _element_list_sizes
+    element_lists.map(&:size)
+  end
+
+  def _single_combination(i)
+    combination = ""
+    element_list_indexes = _multi_array_indexes(i)
+
+    element_lists.each do |element_list|
+      element_list_index = element_list_indexes.shift
+      combination += element_list[element_list_index]
+    end
+
+    combination
+  end
+end

data/lib/pattern_expander/version.rb

@@ -0,0 +1,3 @@
+class PatternExpander
+  VERSION = "0.0.1"
+end

data/lib/pattern_expander.rb

@@ -0,0 +1,21 @@
+class PatternExpander
+  attr_reader :combination_index
+
+  def initialize(pattern, substitutes: nil, parser_class: PatternParser)
+
+    unless substitutes.nil?
+      parser = parser_class.new(substitutes: substitutes)
+    else
+      parser = parser_class.new
+    end
+    @combination_index = CombinationIndex.new(parser.parse(pattern))
+  end
+
+  def [](index_or_range)
+     combination_index[index_or_range]
+  end
+
+  def sample(quantity=1)
+    combination_index.sample(quantity)
+  end
+end

data/lib/pattern_parser.rb

@@ -0,0 +1,34 @@
+class PatternParser
+  attr_reader :substitutes, :delimiter
+
+  DEFAULT_SUBSTITUTES = {
+    "+w" => ('a'..'z').to_a + ('0'..'9').to_a,
+    "+d" => ('0'..'9').to_a,
+  }
+
+  def initialize(substitutes: DEFAULT_SUBSTITUTES)
+    @substitutes = substitutes
+    @delimiter = '|'
+  end
+
+  def parse(string)
+    parsed_groups = _parse_groups(string).map do |group|
+      group.split(delimiter)
+    end
+    _substitute(parsed_groups)
+  end
+
+  def _parse_groups(string)
+    string.scan(
+      /([^\[\]]+|[\#{delimiter}]+)/
+    ).flatten
+  end
+
+  def _substitute(groups)
+    groups.map do |group|
+      group.inject([]) do |memo, item|
+        memo += substitutes[item] || [item]
+      end
+    end
+  end
+end

data/pattern_expander.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pattern_expander/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pattern_expander"
+  spec.version       = PatternExpander::VERSION
+  spec.authors       = ["Noah Thorp"]
+  spec.email         = ["noah@rixiform.com"]
+  spec.description   = %q{Lazily generate string pattern combinations to name your [puppy|startup|band] or write bad poems or produce UUID variants. Kinda like reverse regex. Lazily loads "pages" of combinations and returns results before the heat death of the universe.}
+  spec.summary       = %q{Takes patterns and outputs their combinations - think reverse regex. }
+  spec.homepage      = "http://www.github.com/aquabu/pattern_expander"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/lib/combination_index_spec.rb

@@ -0,0 +1,89 @@
+require_relative '../spec_helper'
+
+describe CombinationIndex do
+  let(:combination_index) do
+    CombinationIndex.new([['a','b'], ['1','2']])
+  end
+
+  describe '#[]' do
+    it 'takes an integer and references the required array values' do
+      combination_index[0].should == 'a1'
+      combination_index[1].should == 'a2'
+      combination_index[2].should == 'b1'
+      combination_index[3].should == 'b2'
+    end
+
+    it 'can take a range' do
+      combination_index[0..2].should == ['a1','a2','b1']
+    end
+  end
+
+  describe '#_multi_array_indexes' do
+    it 'should take an index and an array of index sizes and return an array of indexes' do
+      combination_index = CombinationIndex.new([[:a,:b],[:a,:b],[:a,:b]])
+      combination_index._multi_array_indexes(0).should == [0,0,0]
+      combination_index._multi_array_indexes(1).should == [0,0,1]
+      combination_index._multi_array_indexes(2).should == [0,1,0]
+      combination_index._multi_array_indexes(3).should == [0,1,1]
+      combination_index._multi_array_indexes(4).should == [1,0,0]
+    end
+
+    it 'can handle a collection of index sizes of variable length' do
+      combination_index = CombinationIndex.new([[:a,:b],[:a,:b],[:a,:b],[:a,:b]])
+      combination_index._multi_array_indexes(8).should == [1,0,0,0]
+      combination_index._multi_array_indexes(15).should == [1,1,1,1]
+    end
+
+    it 'can handle a collection of indexes with different sizes' do
+      combination_index = CombinationIndex.new([[:a,:b,:c,:d,:e],[:a,:b,:c]])
+      combination_index._multi_array_indexes(0).should == [0,0]
+      combination_index._multi_array_indexes(2).should == [0,2]
+      combination_index._multi_array_indexes(3).should == [1,0]
+      combination_index._multi_array_indexes(14).should == [4,2]
+    end
+
+    it 'can handle many indexes of varying sizes' do
+      a = [:a]
+      combination_index = CombinationIndex.new(
+        [a * 6, a * 5, a * 4, a * 3, a * 2]
+      )
+      combination_index._multi_array_indexes(0).should == [0,0,0,0,0]
+      combination_index._multi_array_indexes(719).should == [5,4,3,2,1]
+    end
+  end
+
+  describe '#sample' do
+    it 'should get a random combination' do
+      letters = ('a'..'z').to_a + ('0'..'9').to_a
+      combination_elements = []
+      32.times do
+        combination_elements << letters
+      end
+
+      combination_index = CombinationIndex.new(combination_elements)
+
+      pattern = /^[a-z0-9]{32}$/
+
+      sample_1 = combination_index.sample
+      sample_1.should =~ pattern
+
+      sample_2 = combination_index.sample
+      sample_2.should =~ pattern
+
+      # chance of collision 1 in 36**32
+      sample_1.should_not == sample_2
+    end
+
+    it 'can return an arbitrary number of samples' do
+      combination_index.stub(:_sample_one) { 'foo' }
+      samples = combination_index.sample(3)
+      samples.should == ['foo','foo','foo']
+    end
+  end
+
+  it '#size should return the total number of combinations' do
+      CombinationIndex.new([[:a,:b],[0,1]]).size.should == 4
+      CombinationIndex.new([[:a,:b,:c],[0,1]]).size.should == 6
+      CombinationIndex.new([[:a,:b,:c],[0,1],[0,1]]).size.should == 12
+  end
+end

data/spec/lib/pattern_expander_spec.rb

@@ -0,0 +1,70 @@
+require_relative '../spec_helper'
+
+describe PatternExpander do
+  describe '#initialize' do
+    it 'can take substitutes' do
+      pattern_expander = PatternExpander.new(
+        '[+x]',
+       substitutes: {'+x' => ['did_it']}
+      )
+      pattern_expander[0].should == 'did_it'
+    end
+  end
+
+  describe '#[index]' do
+    let(:pattern_expander) { PatternExpander.new('[a|b|][1|2]') }
+
+    it 'takes an integer and references the required array values' do
+      pattern_expander = PatternExpander.new('[a|b|][1|2]')
+      pattern_expander[0].should == 'a1'
+      pattern_expander[1].should == 'a2'
+      pattern_expander[2].should == 'b1'
+      pattern_expander[3].should == 'b2'
+    end
+
+    it 'can use single values in expansions' do
+        pattern_expander = PatternExpander.new('[foo|biz|bang|bar][_][+d]')
+        pattern_expander[9..11].should == ["foo_9", "biz_0", "biz_1"]
+    end
+
+    it 'can reference character substitutions' do
+      pattern_expander = PatternExpander.new('[+d][+d]')
+      pattern_expander[11].should == "11"
+    end
+  end
+
+  describe '#[i..j] range selector' do
+    it 'should take a pattern and a range and return patterns for that range' do
+      pattern_expander = PatternExpander.new('[a|b|][1|2]')
+      pattern_expander[0..3].should == ['a1','a2','b1','b2']
+    end
+
+    it 'should allow combinations' do
+      pattern_expander = PatternExpander.new('[+d][+d]')
+      pattern_expander[21..23].should ==
+        ['21','22','23']
+    end
+
+    it 'handles big patterns' do
+      pattern_expander = PatternExpander.new('[+w][+w][+w][+w][+w][+w][+w]')
+      pattern_expander[100_000..100_003].should ==
+                                        ["aaacff2", "aaacff3", "aaacff4", "aaacff5"]
+    end
+  end
+
+  describe '#sample' do
+    let(:pattern_expander) do
+      PatternExpander.new('[+w][+d]')
+    end
+
+    it 'should get a random combination' do
+      pattern_expander.sample.should =~ /^\w\d$/
+    end
+
+    it 'can get any number of random combinations' do
+      samples = pattern_expander.sample(4)
+      samples.size.should == 4
+      samples.each {|s| s.should =~ /^\w\d$/ }
+    end
+  end
+end

data/spec/lib/pattern_parser_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../spec_helper'
+
+describe PatternParser do
+  let(:substitutes) do
+    {
+      "+w" => ('a'..'z').to_a + ('0'..'9').to_a,
+      "+d" => ('0'..'9').to_a,
+      "+l" => ('a'..'z').to_a
+    }
+  end
+
+  let(:subject) { PatternParser.new(substitutes: substitutes) }
+  let(:wildcard) { ['a'..'z', '0'..'9'].inject([]) {|m,v| m + v.to_a} }
+
+  describe '#parse' do
+    it 'converts patterns into arrays' do
+      subject.parse('[a|b|c][1|2|3]').should == [['a','b','c'], ['1','2','3']]
+    end
+
+    it 'substitutes patterns in arrays' do
+      subject.parse('[+d]').should == [('0'..'9').to_a]
+    end
+
+    it 'sustitutes patterns outside of arrays' do
+      subject.parse('+d').should == [('0'..'9').to_a]
+    end
+
+    it 'leaves non substituted string as ordinary arrays' do
+      subject.parse('foo[+d]bar').should == [['foo'],('0'..'9').to_a,['bar']]
+    end
+  end
+
+  describe '#_parse_groups' do
+    it 'should handle a single group' do
+      subject._parse_groups('[a]').should == ['a']
+    end
+
+    it 'should return an array of group string' do
+      subject._parse_groups('[a][b][c]').should == ['a','b','c']
+    end
+
+    it 'should return on array of group strings including | chars' do
+      subject._parse_groups('[a|b][c|d]').should == ['a|b','c|d']
+    end
+
+    it 'should return non bracket string as their own elements' do
+      subject._parse_groups('foo[a]').should == ['foo', 'a']
+    end
+  end
+
+
+  describe '#_substitute' do
+    it 'substitutes a +w  with an array of wildcard chars' do
+      subject._substitute([['+w']]).should == [ wildcard ]
+    end
+
+    it '_substitutes a +d with an array of numbers' do
+      subject._substitute([['+d']]).should == [ (0..9).map {|c| c.to_s} ]
+    end
+
+    it '_substitutes +l with an array of letters' do
+      subject._substitute([['+l']]).should == [ ('a'..'z').to_a ]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require_relative '../init'

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: pattern_expander
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Noah Thorp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Lazily generate string pattern combinations to name your [puppy|startup|band]
+  or write bad poems or produce UUID variants. Kinda like reverse regex. Lazily loads
+  "pages" of combinations and returns results before the heat death of the universe.
+email:
+- noah@rixiform.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- init.rb
+- lib/combination_index.rb
+- lib/pattern_expander.rb
+- lib/pattern_expander/version.rb
+- lib/pattern_parser.rb
+- pattern_expander.gemspec
+- spec/lib/combination_index_spec.rb
+- spec/lib/pattern_expander_spec.rb
+- spec/lib/pattern_parser_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.github.com/aquabu/pattern_expander
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Takes patterns and outputs their combinations - think reverse regex.
+test_files:
+- spec/lib/combination_index_spec.rb
+- spec/lib/pattern_expander_spec.rb
+- spec/lib/pattern_parser_spec.rb
+- spec/spec_helper.rb