all-your-base 0.2.1 → 0.3.0

data/.gitignore

@@ -1,5 +1,5 @@
 *.sw?
 .DS_Store
 coverage
-rdoc
+doc
 pkg

data/README.rdoc

@@ -1,6 +1,62 @@
 = all-your-base
 
-These are extensions to Integer#to_s and String#to_i that allow bases larger than 36.
+All your base provides arbitrary base conversion.
+
+== Get it
+
+The latest release is available on gemcutter.
+ sudo gem install gemcutter
+ sudo gem tumble
+ sudo gem install all-your-base
+
+== Require it
+
+To use the generalized API:
+ require 'all_your_base'
+
+To use the simple Integer and String extensions:
+ require 'all_your_base/are/belong_to_us'
+
+== Use it
+
+All of the instance and class methods, including "new" accept an options hash.
+It can contain :charset, :radix, and :honor_negation.
+
+Instance Methods
+ @ayb = AllYourBase::Are.new
+ %w(foo bar muffin).map do |word|
+   "#{word} in base 10 is: #{@ayb.convert_to_base_10(word)}"
+ end
+ => foo in base 10 is: 253394
+ => bar in base 10 is: 227969
+ => muffin in base 10 is: 140676922357
+
+ %w(253394 227969 140676922357).map do |int|
+   "#{int} from base 10 is: #{@ayb.convert_from_base_10(int)}"
+ end
+ => 253394 from base 10 is: foo
+ => 227969 from base 10 is: bar
+ => 140676922357 from base 10 is: muffin
+
+Class Methods
+ AllYourBase::Are.convert_to_base_10("foo")
+ => 253394
+
+ AllYourBase::Are.convert_from_base_10(140676922357)
+ => "muffin"
+
+Fun Stuff!
+ "foo".from_base_78.to_base_32
+ => "7NEI"
+
+ 100011.from_base_3.to_base_11
+ => "205"
+
+ "foo".from_base_56.from_base_7.to_base_8.to_base_72
+ => "BAR"
+
+ "Zero".from_base_57.from_base_12.to_base_13.to_base_50
+ => "WIng"
 
 == Note on Patches/Pull Requests
 

data/Rakefile

@@ -42,7 +42,7 @@ Rake::RDocTask.new do |rdoc|
     version = ""
   end
 
-  rdoc.rdoc_dir = 'rdoc'
+  rdoc.rdoc_dir = 'doc'
   rdoc.title = "all-your-base #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/all-your-base.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{all-your-base}
-  s.version = "0.2.1"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rusty Burchfield"]
-  s.date = %q{2009-10-14}
+  s.date = %q{2009-10-19}
   s.description = %q{Provides numeric base conversions greater than base 36}
   s.email = %q{GICodeWarrior@gmail.com}
   s.extra_rdoc_files = [
@@ -28,6 +28,8 @@ Gem::Specification.new do |s|
      "lib/all_your_base.rb",
      "lib/all_your_base/are.rb",
      "lib/all_your_base/are/belong_to_us.rb",
+     "scripts/brute.rb",
+     "scripts/demo.rb",
      "spec/all_your_base/are/belong_to_us_spec.rb",
      "spec/all_your_base/are_spec.rb",
      "spec/spec_helper.rb"

data/lib/all_your_base/are.rb

@@ -1,6 +1,6 @@
 module AllYourBase
   class Are
-    
+
     # This charset works for "standard" bases 2-36 and 62.  It also provides
     # non-standard bases 1 and 37-61 for most uses.
     BASE_62_CHARSET = ('0'..'9').to_a + ('A'..'Z').to_a + ('a'..'z').to_a
@@ -14,24 +14,19 @@ module AllYourBase
     # or care about the validity of these characters.
     BASE_78_CHARSET = BASE_62_CHARSET + ['!', '$', '&', "'", '(', ')', '*', '+',
                                          ',', '-', '.', ':', ';', '=', '@', '_']
-    
-    def initialize(charset, options={})
-      options[:radix] ||= charset.size
-      if charset.size < 1 || charset.size < options[:radix]
-        raise ArgumentError.new('charset too small ' << charset.size.to_s)
-      elsif options[:radix] < 1
-        raise ArgumentError.new('illegal radix ' << options[:radix].to_s)
-      elsif charset.include?('-') && options[:honor_negation]
-        raise ArgumentError.new('"-" is unsupported in charset when honor_negation is set')
-      end
 
-      @charset = charset
-      @options = options
+    DEFAULT_OPTIONS = {:charset => BASE_78_CHARSET, :honor_negation => false}
+
+    def initialize(options={})
+      @default_options = DEFAULT_OPTIONS.merge(options)
+      @default_options = merge_and_validate_options
     end
 
-    def convert_to_base_10(string)
+    def convert_to_base_10(string, options={})
+      options = merge_and_validate_options(options)
+
       negate = false
-      if @options[:honor_negation]
+      if options[:honor_negation]
         negate = string[0...1] == '-'
         string = string[1...string.size] if negate
       end
@@ -39,30 +34,22 @@ module AllYourBase
       if string.size < 1
         raise ArgumentError.new('string too small ' << string.size.to_s)
       end
-      if !string.match(/\A[#{Regexp.escape(@charset[0...@options[:radix]].join(''))}]+\Z/)
+      if !string.match(/\A[#{Regexp.escape(options[:charset][0...options[:radix]].join(''))}]+\Z/)
         raise ArgumentError.new('invalid characters')
       end
-      regexp = Regexp.new(@charset.map{|c| Regexp.escape(c)}.join('|'))
+      regexp = Regexp.new(options[:charset].map{|c| Regexp.escape(c)}.join('|'))
       result = 0
       index = 0
       string.reverse.scan(regexp) do |c|
-        result += @charset.index(c) * (@options[:radix] ** index)
+        result += options[:charset].index(c) * (options[:radix] ** index)
         index += 1
       end
       return result * (negate ? -1 : 1)
     end
-    
-    def self.convert_to_base_10(string, charset, options={})
-      ayb = self.new(charset, options)
-      ayb.convert_to_base_10(string)
-    end
-    
-    def self.convert_from_base_10(int, charset, options={})
-      ayb = self.new(charset, options)
-      ayb.convert_from_base_10(int)
-    end
-    
-    def convert_from_base_10(int)
+
+    def convert_from_base_10(int, options={})
+      options = merge_and_validate_options(options)
+
       if !int.to_s.match(/\A-?[0-9]+\Z/)
         raise ArgumentError.new('invalid characters')
       end
@@ -70,22 +57,46 @@ module AllYourBase
       return '0' if int == 0
 
       negate = false
-      if @options[:honor_negation]
+      if options[:honor_negation]
         negate = int < 0
       end
       int = int.abs
-      
-      if @options[:radix] == 1
-        result = @charset.first * int
+
+      if options[:radix] == 1
+        result = options[:charset].first * int
       else
         s = ''
         while int > 0
-          s << @charset[int.modulo(@options[:radix])]
-          int /= @options[:radix]
+          s << options[:charset][int.modulo(options[:radix])]
+          int /= options[:radix]
         end
         result = s.reverse
       end
       return ((negate ? '-' : '') << result)
     end
+
+    def self.convert_to_base_10(string, options={})
+      @@ayb ||= self.new
+      @@ayb.convert_to_base_10(string, options)
+    end
+
+    def self.convert_from_base_10(int, options={})
+      @@ayb ||= self.new
+      @@ayb.convert_from_base_10(int, options)
+    end
+
+    private
+    def merge_and_validate_options(options={})
+      options = @default_options.merge(options)
+      options[:radix] ||= options[:charset].size
+      if options[:charset].size < 1 || options[:charset].size < options[:radix]
+        raise ArgumentError.new('charset too small ' << options[:charset].size.to_s)
+      elsif options[:radix] < 1
+        raise ArgumentError.new('illegal radix ' << options[:radix].to_s)
+      elsif options[:charset].include?('-') && options[:honor_negation]
+        raise ArgumentError.new('"-" is unsupported in charset when honor_negation is set')
+      end
+      return options
+    end
   end
 end

data/lib/all_your_base/are/belong_to_us.rb

@@ -6,17 +6,17 @@ module AllYourBase
       module From
         def method_missing(sym, *args, &block)
           if sym.to_s.match(/\Afrom_base_([0-9]+)\Z/)
-            AllYourBase::Are.convert_to_base_10(self.to_s, AllYourBase::Are::BASE_78_CHARSET, {:radix => $1.to_i})
+            AllYourBase::Are.convert_to_base_10(self.to_s, {:radix => $1.to_i})
           else
             super # NoMethodError
           end
         end
       end
-    
+
       module To
         def method_missing(sym, *args, &block)
           if sym.to_s.match(/\Ato_base_([0-9]+)\Z/)
-            AllYourBase::Are.convert_from_base_10(self.to_i, AllYourBase::Are::BASE_78_CHARSET, {:radix => $1.to_i})
+            AllYourBase::Are.convert_from_base_10(self.to_i, {:radix => $1.to_i})
           else
             super # NoMethodError
           end
@@ -30,4 +30,3 @@ String.send   :include, AllYourBase::Are::BelongToUs::From
 String.send   :include, AllYourBase::Are::BelongToUs::To
 Integer.send  :include, AllYourBase::Are::BelongToUs::From
 Integer.send  :include, AllYourBase::Are::BelongToUs::To
-

data/scripts/brute.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'all_your_base/are/belong_to_us'
+
+# Finds ways to convert from one string to another through four base
+# conversions.
+if ARGV.size != 2
+  puts <<EOF
+Usage: ruby brute.rb <from> <to>
+Finds ways to convert "from" to "to" through four base conversions.
+
+Example:
+$ ruby brute.rb foo bar
+'FOO' => 'BAR' -- [27, 9, 7, 53]
+'foo' => 'BAR' -- [56, 7, 8, 72]
+...
+
+$ irb -r rubygems -r all_your_base/are/belong_to_us
+irb(main):001:0> 'FOO'.from_base_27.from_base_9.to_base_7.to_base_53
+=> "BAR"
+EOF
+  exit 1
+end
+
+def multi_case(s)
+  a = ['']
+  s.split(/\s*/).each do |c|
+    a = a.map{|s| s + c.downcase} + a.map{|s| s + c.upcase}
+  end
+  return a
+end
+
+def valid_bases(s)
+  max = 0
+  s.split(/\s*/).each do |c|
+    idx = AllYourBase::Are::BASE_78_CHARSET.index(c)
+    max = idx if idx > max
+  end
+  return (max+1..78)
+end
+
+def conversions_of(i)
+  list = multi_case(i).uniq
+  results = []
+  list.each do |s|
+    valid_bases(s).each do |r|
+      results << [s, r, s.send(:"from_base_#{r}")]
+    end
+  end
+  return results
+end
+
+hello = conversions_of(ARGV[0])
+world = conversions_of(ARGV[1])
+
+hc = []
+hello.map{|h| conversions_of(h.last.to_s)}.each{|r| hc += r}
+hc.sort!{|a, b| a.last.to_i <=> b.last.to_i}
+
+wc = []
+world.map{|w| conversions_of(w.last.to_s)}.each{|r| wc += r}
+wc.sort!{|a, b| a.last.to_i <=> b.last.to_i}
+
+while !hc.empty? && !wc.empty? do
+  h = hc.first
+  w = wc.first
+  if h.last == w.last
+    lr = hello.select{|m| m.last.to_s == h.first.to_s}.first
+    rr = world.select{|m| m.last.to_s == w.first.to_s}.first
+    puts "'#{lr.first}' => '#{rr.first}' -- " \
+         "[#{lr[1]}, #{h[1]}, #{w[1]}, #{rr[1]}]"
+    hc.shift
+    wc.shift
+  elsif h.last.to_i < w.last.to_i
+    hc.shift
+  else
+    wc.shift
+  end
+end
+

data/scripts/demo.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'all_your_base/are/belong_to_us'
+
+sections = ['Instance Methods', 'Class Methods', 'Fun Stuff!']
+
+code = {'Instance Methods' =>
+['  @ayb = AllYourBase::Are.new
+  %w(foo bar muffin).map do |word|
+    "#{word} in base 10 is: #{@ayb.convert_to_base_10(word)}"
+  end',
+'  %w(253394 227969 140676922357).map do |int|
+    "#{int} from base 10 is: #{@ayb.convert_from_base_10(int)}"
+  end'],
+
+'Class Methods' =>
+['  AllYourBase::Are.convert_to_base_10("foo")',
+'  AllYourBase::Are.convert_from_base_10(140676922357)'],
+
+'Fun Stuff!' =>
+['  "foo".from_base_78.to_base_32',
+'  100011.from_base_3.to_base_11',
+'  "foo".from_base_56.from_base_7.to_base_8.to_base_72',
+'  "Zero".from_base_57.from_base_12.to_base_13.to_base_50']}
+
+sections.each do |s|
+  print "\e[H\e[2J"
+  puts "  # #{s}"
+  puts
+  code[s].each do |c|
+    print c
+    readline
+    result = eval(c)
+    if result.is_a?(Array)
+      puts result.map{|r| "=> #{r}"}.join("\n")
+    else
+      puts "=> #{result.inspect}"
+    end
+    readline
+  end
+end

data/spec/all_your_base/are_spec.rb

@@ -13,36 +13,32 @@ describe AllYourBase::Are do
 
   describe "#initialize" do
     it "should not allow charsets less 1" do
-      lambda {ayb = AllYourBase::Are.new([], {:radix =>1})}.should raise_error(ArgumentError, 'charset too small 0')
+      lambda {ayb = AllYourBase::Are.new({:charset => [], :radix => 1})}.should raise_error(ArgumentError, 'charset too small 0')
     end
     it "should not allow radix of less than 1" do
-      lambda {ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET, {:radix =>0})}.should raise_error(ArgumentError, 'illegal radix 0')
+      lambda {ayb = AllYourBase::Are.new({:radix => 0})}.should raise_error(ArgumentError, 'illegal radix 0')
     end
-    it "should set the charset instance variable" do
-      ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET, {:radix =>78})
-      ayb.instance_variable_get('@charset').should eql(AllYourBase::Are::BASE_78_CHARSET)
-    end
-    it "should set the options instance variable" do
-      ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET, {:radix => 12})
-      ayb.instance_variable_get('@options').should == {:radix => 12}
+    it "should default charset to base 78" do
+      ayb = AllYourBase::Are.new()
+      ayb.instance_variable_get('@default_options')[:charset].should eql(AllYourBase::Are::BASE_78_CHARSET)
     end
     it "should default radix to size of charset" do
-      ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET)
-      ayb.instance_variable_get('@options')[:radix].should eql(78)
+      ayb = AllYourBase::Are.new({:charset => [1, 2, 3]})
+      ayb.instance_variable_get('@default_options')[:radix].should eql(3)
     end
     it "should not allow a char set with - when :honor_negation is set" do
       lambda {
-        AllYourBase::Are.new(['a', 'y', 'b', '-'], {:honor_negation => true})
+        AllYourBase::Are.new({:charset => ['a', 'y', 'b', '-'], :honor_negation => true})
       }.should raise_error(ArgumentError, '"-" is unsupported in charset when honor_negation is set')
     end
   end
 
   describe "#convert_to_base_10" do
     before(:each) do
-      @ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET)
+      @ayb = AllYourBase::Are.new()
     end
     it "should raise if input is contains invalid characters" do
-      ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET, {:radix => 5})
+      ayb = AllYourBase::Are.new({:radix => 5})
       lambda {ayb.convert_to_base_10('foo')}.should raise_error("invalid characters")
     end
     it "should raise error if string is too short" do
@@ -53,7 +49,7 @@ describe AllYourBase::Are do
     end
     describe "when honor_negation is true" do
       before(:each) do
-        @ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_62_CHARSET, {:honor_negation => true})
+        @ayb = AllYourBase::Are.new({:charset => AllYourBase::Are::BASE_62_CHARSET, :honor_negation => true})
       end
       it "should raise error if string is too short" do
         lambda {@ayb.convert_to_base_10('-')}.should raise_error(ArgumentError, 'string too small 0')
@@ -69,40 +65,40 @@ describe AllYourBase::Are do
 
   describe "#convert_from_base_10" do
     it "should raise if input is not base 10" do
-      ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET, {:radix => 5})
+      ayb = AllYourBase::Are.new({:radix => 5})
       lambda {ayb.convert_from_base_10('foo')}.should raise_error("invalid characters")
     end
     it "should convert from base 10" do
-      @ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET)
+      @ayb = AllYourBase::Are.new()
       @ayb.convert_from_base_10(855149198991141649141572449638390201857110945891509).should eql('somebody_set_up_us_the_bomb')
     end
     it "should return '0' if value is 0" do
-      @ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_78_CHARSET)
+      @ayb = AllYourBase::Are.new()
       @ayb.convert_from_base_10(0).should eql('0')
     end
     it "should return a string with a - at the beginning if value is negative and negation is honored" do
-      @ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_64_CHARSET, {:honor_negation => true})
+      @ayb = AllYourBase::Are.new({:charset => AllYourBase::Are::BASE_64_CHARSET, :honor_negation => true})
       @ayb.convert_from_base_10(-100).should eql('-Bk')
     end
     it "should return value if radix is 1" do
-      @ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_64_CHARSET, {:radix =>1})
+      @ayb = AllYourBase::Are.new({:charset => AllYourBase::Are::BASE_64_CHARSET, :radix =>1})
       @ayb.convert_from_base_10(11).should eql('AAAAAAAAAAA')
     end
     it "should return other value if radix is not 1" do
-      @ayb = AllYourBase::Are.new(AllYourBase::Are::BASE_64_CHARSET,{:radix =>12})
+      @ayb = AllYourBase::Are.new({:charset => AllYourBase::Are::BASE_64_CHARSET, :radix => 12})
       @ayb.convert_from_base_10(11).should eql('L')
     end
   end
   
   describe ".convert_to_base_10" do
     it "should allow you to convert to base 10 without initializing an instance of AllYourBase::Are" do
-      result = AllYourBase::Are.convert_to_base_10('A', AllYourBase::Are::BASE_78_CHARSET)
+      result = AllYourBase::Are.convert_to_base_10('A')
       result.should eql(10)
     end
   end
   describe ".convert_from_base_10" do
     it "should allow you to convert from base 10 without initializing an instance of AllYourBase::Are" do
-      result = AllYourBase::Are.convert_from_base_10(10, AllYourBase::Are::BASE_78_CHARSET)
+      result = AllYourBase::Are.convert_from_base_10(10)
       result.should eql('A')
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: all-your-base
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Rusty Burchfield
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-14 00:00:00 -07:00
+date: 2009-10-19 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,6 +43,8 @@ files:
 - lib/all_your_base.rb
 - lib/all_your_base/are.rb
 - lib/all_your_base/are/belong_to_us.rb
+- scripts/brute.rb
+- scripts/demo.rb
 - spec/all_your_base/are/belong_to_us_spec.rb
 - spec/all_your_base/are_spec.rb
 - spec/spec_helper.rb