reloc 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.DS_Store
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Dave Kinkead
+
+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,62 @@
+# Reloc
+
+A super simple way to generate easy to read, hard to guess, domain specific unique IDs.
+
+## Installation
+
+Install the gem:
+
+    $ gem install reloc
+
+Then require it
+
+	require 'reloc'
+
+## Usage
+
+Throw Reloc an (auto-incrementing) integer to generate easy to read, hard to guess unique IDs.
+
+	Reloc.generate( 12345 )
+	#	=>	"7bmgk"
+	Reloc.generate( 12346 )
+	#	=>	"2wrdt"
+
+You can ensure your IDs are domain specific
+
+	Reloc.generate( 12345, 'www.somedomain.com' )
+	#	=>	"8fgqb"
+	Reloc.generate( 12345, 'www.anotherdomain.com' )
+	#	=>	"oswn1"
+
+And configure the minimum ID length (default is 5 characters)
+
+	Reloc.config( {:min_chars => 3} )
+	Reloc.generate( 12345 )
+	#	=>	"8z7"	
+
+Hook it up to [Redis][redis] and you've got your own URL shortener in just a few lines of code
+
+	require 'redis'
+	require 'reloc'
+	
+	redis = Redis.new
+	redis.set( "counter", 0 )
+
+	counter = Reloc.generate( redis.incr "counter" )
+	#	=> "68hy1"
+
+	redis.set( counter, "http://some-url.com" )
+	#	=> OK
+
+	redis.get( "68hy1" )
+	#	=> "http://some-url.com"
+
+## 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
+
+[redis]:http://redis.io/

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "specs"
+  t.test_files = FileList['specs/*_spec.rb']
+  t.verbose = true
+end

data/lib/reloc.rb

@@ -0,0 +1,5 @@
+require "reloc/version"
+
+module Reloc
+  # Your code goes here...
+end

data/lib/reloc/core.rb

@@ -0,0 +1,95 @@
+require 'digest/md5'
+
+module Reloc
+
+  @@env = {
+    :min_chars => 5,
+    :domain => nil,
+    :salts => {
+      nil => '5it68qhmyrc13jzxelgfdasuv04npo97b2wk', #   Generate a new code with (('0'..'9').to_a + ('a'..'z').to_a).shuffle.join
+    }
+  }
+  ALPH = (('0'..'9').to_a + ('a'..'z').to_a).join.split( // )
+
+
+  # Public: Generate a random ordering of an alphanumeric-bet
+  #
+  # domain    - A domain to create unique IDs for
+  #
+  # Examples
+  #
+  #   Reloc.salt
+  #   # =>  'z2y54c8pnwrl63o17hxmbtauqegd0vfi9ksj'
+  #
+  #   Reloc.salt( 'some-domain' )
+  #   # =>  'dfs7k0eqt6j2mvir3wogn81p9yczuhx5b4al'
+  #
+  # Returns a random ordering of an alpha-num-bet
+  def self.salt( domain=nil )
+    # just suffle the alpha-num-bet
+    return ( ('0'..'9').to_a + ('a'..'z').to_a ).shuffle.join if domain.nil?
+    # unless a domain is provided
+    alph = ALPH.clone
+    hash = ( Digest::MD5.hexdigest( domain ) ).split( // ).map! { |n| n.to_i(16) }
+    salt = []
+    pos = 0
+    36.times do |n|
+      n %= 32
+      pos = ( pos + hash[n] ) % alph.length
+      salt.push( alph[pos] )
+      alph.delete_at pos
+    end
+    salt.join
+  end
+
+
+  # Public: Sets configuration variables
+  #
+  # min_chars - The minimum characters to generate in a reloc
+  #
+  # Example
+  #
+  #   Reloc.config( {:min_chars => 3} )
+  #   # =>  { :min_chars => 3,
+  #           :domain => nil,
+  #           :salts => { nil => '5it68qhmyrc13jzxelgfdasuv04npo97b2wk' }
+  #         }
+  #
+  # Returns the current config variables
+  def self.config( env={} )
+    env.each { |k,v| @@env[k] = v }
+    @@env
+  end
+
+
+  # Public: Generate a unique reloc for some integer + domain pair
+  #
+  # num       - The integer to be encoded
+  # domain    - The domain constraint on uniqueness
+  #
+  # Examples
+  #
+  #   Reloc.generate( 123456 )
+  #   # =>  '7bmgk'
+  #
+  #   Reloc.generate( 123456, 'some domain' )
+  #   # =>  '8fgqb'
+  #
+  #  Returns the encoded integer or nil on error
+  def self.generate( num, domain=nil )
+    return nil unless num.instance_of? Fixnum
+    unless @@env[:salts].has_key?( domain )
+      @@env[:salts][domain] = self.salt( domain )
+    end
+    salt = @@env[:salts][domain].split( // )
+    incr = num % 36
+    num += ( 36**(@@env[:min_chars] - 1) )
+    b36 = num.to_s(36).split( // )
+    res = []
+    b36.each do |s|
+      res << salt[( ALPH.index( s ) + incr * 2 ) % 36]
+      incr += 1
+    end
+    res.join
+  end
+end

data/lib/reloc/version.rb

@@ -0,0 +1,3 @@
+module Reloc
+  VERSION = "0.0.1"
+end

data/reloc.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reloc/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "reloc"
+  gem.version       = Reloc::VERSION
+  gem.authors       = ["Dave Kinkead"]
+  gem.email         = ["dave@kinkead.com.au"]
+  gem.description   = %q{Create easy to read, hard to guess, domain specific unique IDs}
+  gem.summary       = %q{A super simple way to generate easy to read, hard to guess, domain specific unique IDs.}
+  gem.homepage      = "https://github.com/davekinkead/Reloc"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|specs|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'rake'
+end

data/specs/core_spec.rb

@@ -0,0 +1,97 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'reloc/core'
+
+describe 'Reloc' do
+
+  describe 'salt' do
+    it 'should generate a random order of 0-9a-z from no arg' do
+      salt = Reloc.salt
+      salt.must_be_kind_of String
+      salt.length.must_equal 36
+      salt.split( // ).sort.must_equal (('0'..'9').to_a + ('a'..'z').to_a).join.split( // )
+    end
+
+    it 'should generate a domain salt if a domain is provided' do
+      salt = Reloc.salt( "I don't always salt my hashes...but when I do" )
+      salt.length.must_equal 36
+      salt[/[a-z0-9]{36}/].must_equal salt
+    end
+
+    it 'should generate a different salt for a different domain' do
+      results = []
+      100.times do |n|
+        results.push( Reloc.salt( "Mumbo number #{n}") )
+      end
+      results.length.must_equal results.uniq.length
+    end
+  end
+
+  describe 'config' do
+    it 'should return a hash' do
+      Reloc.config.must_be_kind_of Hash
+    end
+
+    it 'should set minimum characters to return' do
+      env = Reloc.config( { :min_chars => 3 } )
+      env[:min_chars].must_equal 3
+    end
+
+    it 'should set the default domain' do
+      domain = 'wiggle**5, yeah you know it!'
+      env = Reloc.config( { :domain => domain } )
+      env[:domain].must_equal domain
+    end
+  end
+
+  describe 'encode' do
+    before :each do
+      Reloc.config( { :min_chars => 5, :domain => nil } )
+    end
+
+    it 'should return nil on error' do
+      Reloc.generate( 'string' ).must_be_nil
+      Reloc.generate( 12.7 ).must_be_nil
+    end
+
+    it 'should return alphanum of default length 5 for some int' do
+      Reloc.generate( 123456 ).length.must_equal 5
+    end
+
+    it 'should return the same ID for the same num+domain pair' do
+      Reloc.generate( 123 ).must_equal Reloc.generate( 123 )
+    end
+
+    it 'should fail duplicate test check when duplicate is added' do
+      results = []
+      100.times { |n| results << Reloc.generate( n ) }
+      results.length.must_equal results.uniq.length
+      # now generate a duplicate
+      results << Reloc.generate( 1 )
+      results.length.must_equal ( results.uniq.length + 1 )
+    end
+
+    # I've tested this to 10 Million times with no collision
+    #   which theoretically shouldn't occur as extra digits just
+    #   get added when num gets larger
+    it 'should pass duplicate test for x million tries' do
+      results = []
+      100.times { |n| results << Reloc.generate( n ) }
+      results.length.must_equal results.uniq.length
+    end
+
+    it 'should return the correct number of characters' do
+      Reloc.config( { :min_chars => 3 } )
+      Reloc.generate( 27 ).length.must_equal 3
+    end
+
+    it 'should automatically create a domain specific salt if a domain is provided' do
+      config = Reloc.config
+      one = Reloc.generate( 12345 )
+      config[:salts].has_key?( 'some-domain' ).must_equal false
+      two = Reloc.generate( 12345, 'some-domain' )
+      config[:salts].has_key?( 'some-domain' ).must_equal true
+      one.wont_equal two
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: reloc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dave Kinkead
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Create easy to read, hard to guess, domain specific unique IDs
+email:
+- dave@kinkead.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/reloc.rb
+- lib/reloc/core.rb
+- lib/reloc/version.rb
+- reloc.gemspec
+- specs/core_spec.rb
+homepage: https://github.com/davekinkead/Reloc
+licenses: []
+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.23
+signing_key: 
+specification_version: 3
+summary: A super simple way to generate easy to read, hard to guess, domain specific
+  unique IDs.
+test_files:
+- specs/core_spec.rb