alnum 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 540fcbabc9ec1452ffe147f018924f7594511c84
+  data.tar.gz: ffc28febfd232baa286f2a70027751755c5a9163
+SHA512:
+  metadata.gz: 543ec3b8eeea6fca40eb8ad85844635295db713b02f16efbaed9ad51b9407ed99d64184c515fb5ec42c2eb6242d4674b0aa7d4d5240ccda0e63517ae4da9cea7
+  data.tar.gz: 2c201eb26e79a302d369ff96731c7b18c244b1d36a7d939dc99640fdb744fd90aea2d3e8b25a4fab013d8d39d1a3ff5b228118590394ed234851484f13a921a1

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Hanes Barbosa Marques de Oliveira
+
+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,80 @@
+# alnum
+
+Alnum is a generator of alphanumeric code from integers and vice-versa.
+
+## Installation
+
+```ruby
+[sudo] gem install alnum
+```
+
+## The Long Story Short
+
+Quick examples to hit the road:
+
+### Instantiate your cypher
+
+```ruby
+cypher = Alnum::Cypher.new
+```
+
+### Get your alphanumeric code
+
+```ruby
+cypher.write(32456) => "8ru"
+```
+
+### Instantiate your decipher
+
+```ruby
+decipher = Alnum::Decipher.new
+```
+
+### Get your integer back
+
+```ruby
+ decipher.read("8ru") => 32456
+```
+
+## Purpose
+
+This gem was created to serve as a parser that can generates alphanumeric tokens as a resultant conversion of integer numbers. It can work backwards too, converting alphanumeric codes back to the previous integer representation. You can only decipher a code that was created by this same module.
+
+This can be used for any kind of tokens, but mainly for shortening URIs or URLs.
+
+## URL Shorteners
+
+When you're using URL shorteners, you are switching your link by an alphanumeric token. The short or tiny URLs are abstrations of the real ones. The original link is stored in some database and you can use the tiny generated code to share among all those social media out there.
+
+Systems can store large URLs in databases and using the ID key generated (integer) can create a short URL. So you can append this little part to your domain like this:
+
+http://www.yourdomain.com/token
+
+The module here doesn’t create the hole functionality, just give you methods for the parsing. This way you’re not bounded to the developer’s perception on how your framework should behave across classes, controllers, views, etc.
+
+## Background
+
+According to the HTTP protocol, an URI can be depicted as follows:
+
+scheme://authority/path?query#fragment
+
+As an example we can figure out how it appears in the real world:
+
+http://github.com/search?utf8=✓&q=gemname
+
+In the example above there’s no fragment, but you got the mood.
+
+As a intended shortener functionality, this code focus on the URI part called “path”. So we need to investigate the characters allowed to be part of this particular slice of the resource.
+
+You can restrict the outcome to just alphanumeric characters or unleash the full amount of symbols in order to have even more small tokens. However, taking punctuation characters or such can result in more gibberished words.
+
+At a glance, when we take a look at the rules applied to the path part we can consider that:
+
+* If the path does not begins with a slash (“/”) character, it should be empty (that’s not our case).
+* The path is terminated by the first question mark ("?") – the <query> portion, the number sign ("#") character – the <fragment> – or by the end of the URI.
+
+Path segments like “.” and “..” and so forth, has special meanings, so you should take care of it in your application or restrict your characters just to alphanumeric when parsing.
+
+## Conclusion
+
+The code here just give you symbols from the alphabet and digits. You can expand the classes in differents flavors as you wish.

data/alnum.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = 'alnum'
+  s.version     = '0.0.1'
+  s.date        = '2015-05-26'
+  s.summary     = "Alphanumeric code generator."
+  s.description = "Alnum is a generator of alphanumeric code from integers and vice-versa. Can be useful shortening ID numbers in order to create tiny or short URLs."
+  s.authors     = ["Hanes Barbosa"]
+  s.email       = 'hanes.barbosa@gmail.com'
+  s.homepage    = 'http://github.com/hanesbarbosa/alnum'
+  s.license     = 'MIT'
+  s.post_install_message = "Let's cypher some code!"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 1.9.3'
+end

data/lib/alnum/cypher.rb

@@ -0,0 +1,26 @@
+require_relative '../alnum'
+
+module Alnum
+
+  class Cypher
+
+    def write(number)
+      raise TypeError, "Only integers allowed" unless number.is_a? Integer   
+
+      numbers = []
+      quotient = 0
+
+      until number < BASE do
+        rest = number % BASE
+        quotient = (number - rest) / BASE
+        numbers << SYMBOLS[rest]
+        number = quotient
+      end
+
+      numbers << SYMBOLS[number]
+      numbers.reverse.join
+    end
+
+  end
+
+end

data/lib/alnum/decipher.rb

@@ -0,0 +1,22 @@
+require_relative '../alnum'
+
+module Alnum
+
+  class Decipher
+
+    def read(alphanumeric)
+      number = 0
+      count = 0
+
+      alphanumeric.to_s.reverse.each_char() do |c|
+        raise RangeError, "Code contains characters out of range: '#{c}'" if SYMBOLS.index(c).nil?
+        number += SYMBOLS.index(c) * BASE**count
+        count += 1
+      end
+
+      number
+    end
+    
+  end
+
+end

data/lib/alnum.rb

@@ -0,0 +1,14 @@
+require_relative 'alnum/cypher'
+require_relative 'alnum/decipher'
+
+module Alnum
+
+  SYMBOLS = %w{
+    0 1 2 3 4 5 6 7 8 9
+    a b c d e f g h i j k l m n o p q r s t u v w x y z
+    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+  }
+
+  BASE = SYMBOLS.length
+
+end

data/test/support/test_data.rb

@@ -0,0 +1,5 @@
+SYMBOLS = %w{
+    0 1 2 3 4 5 6 7 8 9
+    a b c d e f g h i j k l m n o p q r s t u v w x y z
+    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+  }

data/test/test_alnum.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require_relative '../lib/alnum'
+require_relative './support/test_data'
+
+class TestAlnum < Test::Unit::TestCase
+
+  def test_amount_of_symbols
+    assert_equal Alnum::SYMBOLS.length, SYMBOLS.length    
+  end
+
+  def test_symbols_should_be_the_same
+    assert_equal Alnum::SYMBOLS, SYMBOLS
+  end
+
+end

data/test/test_cypher.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require_relative '../lib/alnum/cypher'
+require_relative './support/test_data'
+
+class TestCypher < Test::Unit::TestCase
+
+  def setup
+    @cypher = Alnum::Cypher.new
+  end
+
+  def test_one_character_range
+    62.times do |number|
+      assert_equal @cypher.write(number), "#{SYMBOLS[number]}"
+    end
+  end
+
+  def test_only_integers_allowed
+    assert_raise TypeError do
+      @cypher.write('a')
+    end   
+  end
+
+  def test_empty_arguments
+    assert_raise ArgumentError do
+      @cypher.write()
+    end
+  end
+
+end

data/test/test_decipher.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require_relative '../lib/alnum/decipher'
+require_relative './support/test_data'
+
+class TestDecipher < Test::Unit::TestCase
+
+	def setup
+		@decipher = Alnum::Decipher.new		
+	end
+
+	def test_one_character_range
+		62.times do |number|
+			assert_equal @decipher.read(SYMBOLS[number]), number
+		end
+	end
+
+	def test_character_out_of_range
+		assert_raise RangeError do
+			@decipher.read('-')
+		end
+	end
+
+	def test_empty_arguments
+		assert_raise ArgumentError do
+			@decipher.read()
+		end
+	end
+
+end

data/test/test_suite_all.rb

@@ -0,0 +1,3 @@
+require_relative 'test_alnum'
+require_relative 'test_cypher'
+require_relative 'test_decipher'

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: alnum
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Hanes Barbosa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-26 00:00:00.000000000 Z
+dependencies: []
+description: Alnum is a generator of alphanumeric code from integers and vice-versa.
+  Can be useful shortening ID numbers in order to create tiny or short URLs.
+email: hanes.barbosa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- alnum.gemspec
+- lib/alnum.rb
+- lib/alnum/cypher.rb
+- lib/alnum/decipher.rb
+- test/support/test_data.rb
+- test/test_alnum.rb
+- test/test_cypher.rb
+- test/test_decipher.rb
+- test/test_suite_all.rb
+homepage: http://github.com/hanesbarbosa/alnum
+licenses:
+- MIT
+metadata: {}
+post_install_message: Let's cypher some code!
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Alphanumeric code generator.
+test_files:
+- test/support/test_data.rb
+- test/test_alnum.rb
+- test/test_cypher.rb
+- test/test_decipher.rb
+- test/test_suite_all.rb