eropple-biggs 0.3.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e85e26e3b8e91e6ad36b4a977eb0612533919305
+  data.tar.gz: 531cbd742daa5ba9a44363ddb23c7714e5997be5
+SHA512:
+  metadata.gz: 22ff1be8108399d33269fcf39c29648e0302d7857839fe26a94be1e80c8267244488721da1dad40ea9c241d2be1a3dd9acb1c7fbc559b976759269c7e9b1f20c
+  data.tar.gz: c03358b221cc0b23d5cc1d56737fb7f0b602fa65314604a09429222acbe0122c00d81fb35f1d42adb0020c039ca45facb8efd237436091f557f8fe66368833fe

data/.gitignore

@@ -0,0 +1,3 @@
+biggs-*.*.*.gem
+Gemfile.lock
+.rbenv-*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3@biggs --create

data/CHANGES.md

@@ -0,0 +1,61 @@
+### dev
+
+### 0.3.3 / 2013-05-06
+
+* Added support for Rails 4 (by [mdemare](https://github.com/mdemare))
+
+### 0.3.2 / 2013-02-19
+
+* Fixed warning in Biggs::Format
+
+### 0.3.1 / 2012-08-02
+
+* Fixed LI format
+
+### 0.3.0 / 2012-06-15
+
+* Added country names for countries with default/unknown address format
+* Simplified inclusion of Biggs::ActiveRecordAdapter
+* Changed doc-format from textile to markdown
+
+### 0.2.2 / 2012-02-06
+
+* Compatibility with ActiveRecord/Rails 3.2
+
+### 0.2.1 / 2011-11-09
+
+* Fixed gemspec activerecord dependency
+
+### 0.2.0 / 2011-10-12
+
+* Added Bundler & removed jewler
+* Fixed Specs
+* Added NC (New Caledonia)
+
+### 0.1.5 / 2010-11-24
+
+* Fixed address format for Norway
+* Added TH (Thailand)
+
+### 0.1.4 / 2009-5-21
+
+* Fixed Specs
+
+### 0.1.3 / 2009-3-6
+
+* Correct japanese address format. (by [hiroshi](https://github.com/hiroshi))
+* Fixed docs for current API. (by [hiroshi](https://github.com/hiroshi))
+
+### 0.1.2 / 2009-3-4
+
+* Values can now be specified by an array of symbols.
+
+### 0.1.1 / 2009-3-3
+
+* Refactored activerecord-adapter to include only basic setup method in ActiveRecord:Base
+
+### 0.1.0 / 2009-3-3
+
+* Allow Procs as params in biggs-activerecord-setup.
+* Cleanup
+

data/Gemfile

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gem 'countries', :git => 'https://github.com/burningpony/countries.git'
+
+# Specify your gem's dependencies in dar_da_da.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Yolk Sebastian Munz & Julia Soergel GbR
+
+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,149 @@
+biggs is a small ruby gem/rails plugin for formatting postal addresses from over 60 countries.
+
+### Install
+
+As a ruby gem:
+
+    sudo gem install biggs
+
+If your rather prefer to install it as a plugin for rails, from your application directory simply run:
+
+    script/plugin install git://github.com/yolk/biggs.git
+
+### Standalone usage
+
+    f = Biggs::Formatter.new
+
+    f.format("de", # <= ISO alpha 2 code
+      :recipient  => "Yolk Sebastian Munz & Julia Soergel GbR",
+      :street     => "Adalbertstr. 11", # <= street + house number
+      :city       => "Berlin",
+      :postalcode        => 10999,
+      :region      => "Berlin" # <= region/province/region
+    )
+
+returns
+
+    "Yolk Sebastian Munz & Julia Soergel GbR
+    Adalbertstr. 11
+    10999 Berlin
+    Germany"
+
+At the moment Biggs::Formatter.new accepts only one option:
+
+*blank_county_on* ISO alpha 2 code (single string or array) of countries the formatter should skip the line "country" (for national shipping).
+
+    Biggs::Formatter.new(:blank_county_on => "de")
+
+With the data from the above example this would return:
+
+    "Yolk Sebastian Munz & Julia Soergel GbR
+    Adalbertstr. 11
+    10999 Berlin"
+
+### Usage with Rails and ActiveRecord
+
+    Address < ActiveRecord::Base
+      biggs :postal_address
+    end
+
+This adds the method postal_address to your Address-model, and assumes the presence of the methods/columns recipient, street, city, postalcode, region, and country to get the address data. Country should return the ISO-code (e.g. 'us', 'fr', 'de').
+
+You can customize the method-names biggs will use by passing in a hash of options:
+
+    Address < ActiveRecord::Base
+      biggs :postal_address,
+            :postalcode => :postal_code,
+            :country => :country_code,
+            :street => Proc.new {|address| "#{address.street} #{address.house_number}" }
+    end
+
+You can pass in a symbol to let biggs call a different method on your Address-model, or a Proc-object to create your data on the fly.
+
+You can even pass in a array of symbols:
+
+    Address < ActiveRecord::Base
+      biggs :postal_address,
+            :recipient => [:company_name, :person_name]
+    end
+
+This will call the methods company_name and person_name on your address-instance, remove any blank returned values and join the rest by a line break.
+
+To access the formatted address string, simply call the provided method on an address instance:
+
+    Address.find(1).postal_address
+
+If you pass in a ISO alpha 2 code as :country that is not supported by biggs, it will choose the US-format for addresses with an region specified, and the french/german format for addresses without an region.
+
+### Supported countries
+
+biggs knows how to format addresses of over 60 different countries. If you are missing one or find an misstake, feel free to let us know, fork this repository and commit your additions.
+
+* Argentina
+* Australia
+* Austria
+* Bahrain
+* Belgium
+* Bosnia and Herzegovina
+* Brazil
+* Bulgaria
+* Canada
+* China
+* Croatia
+* Czech Republic
+* Denmark
+* Egypt
+* Finland
+* France
+* Germany
+* Greece
+* Greenland
+* Hong Kong
+* Hungary
+* Iceland
+* India
+* Indonesia
+* Ireland
+* Israel
+* Italy
+* Japan
+* Jordan
+* Korea, Republic of
+* Kuwait
+* Lebanon
+* Liechtenstein
+* Luxembourg
+* Macedonia, the Former Yugoslav Republic Of
+* Mexico
+* Netherlands
+* New Caledonia
+* New Zealand
+* Norway
+* Oman
+* Philippines
+* Poland
+* Portugal
+* Qatar
+* Romania
+* Russian Federation
+* Saudi Arabia
+* Singapore
+* Slovakia
+* Slovenia
+* South Africa
+* Spain
+* Sweden
+* Switzerland
+* Syrian Arab Republic
+* Taiwan, Republic Of China
+* Thailand
+* Turkey
+* Ukraine
+* United Arab Emirates
+* United Kingdom
+* United States
+* Yemen
+
+biggs is tested to behave well with Rails 3.0, 3.1, 3.2 and 4.0
+
+Copyright (c) 2009-2013 Yolk Sebastian Munz & Julia Soergel GbR

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/biggs.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'biggs/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eropple-biggs'
+  s.version     = Biggs::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Sebastian Munz']
+  s.email       = ['sebastian@yo.lk']
+  s.homepage    = 'https://github.com/yolk/biggs'
+  s.summary     = 'biggs is a small ruby gem/rails plugin for formatting postal addresses from over 60 countries.'
+  s.description = 'biggs is a small ruby gem/rails plugin for formatting postal addresses from over 60 countries.'
+
+  s.rubyforge_project = 'biggs'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'activerecord',            '>= 3.0'
+  # s.add_dependency 'countries',            '>= 0.9.3'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec',       '>= 3.0.0'
+  s.add_development_dependency 'rspec-its',       '>= 1.1.0'
+  s.add_development_dependency 'sqlite3',     '>= 1.3.5'
+end

data/init.rb

@@ -0,0 +1 @@
+require 'biggs'

data/lib/biggs/activerecord.rb

@@ -0,0 +1,66 @@
+require 'active_support/core_ext/class/attribute'
+
+module Biggs
+  module ActiveRecordAdapter
+    def self.included(base)
+      base.extend(InitialClassMethods)
+    end
+
+    module InitialClassMethods
+      def biggs(method_name = nil, options = {})
+        class_attribute :biggs_value_methods
+        class_attribute :biggs_instance
+
+        send(:include, Biggs::ActiveRecordAdapter::InstanceMethods)
+        alias_method(method_name || :postal_address, :biggs_postal_address)
+
+        value_methods = {}
+        Biggs::Formatter::FIELDS.each do |field|
+          value_methods[field] = options.delete(field) if options[field]
+        end
+
+        self.biggs_value_methods = value_methods
+        self.biggs_instance = Biggs::Formatter.new(options)
+      end
+    end
+
+    module InstanceMethods
+      def biggs_postal_address
+        self.class.biggs_instance.format(biggs_country, biggs_values)
+      end
+
+      private
+
+      def biggs_country
+        biggs_get_value(:country)
+      end
+
+      def biggs_values
+        values = {}
+        (Biggs::Formatter::FIELDS - [:country]).each do |field|
+          values[field] = biggs_get_value(field)
+        end
+        values
+      end
+
+      def biggs_get_value(field)
+        key = self.class.biggs_value_methods[field.to_sym] || field.to_sym
+
+        case key
+        when Symbol
+          send(key.to_sym)
+        when Proc
+          key.call(self).to_s
+        when Array
+          if key.all? { |it| it.is_a?(Symbol) }
+            key.map { |method| send(method) }.reject(&:blank?).join("\n")
+          else
+            fail "Biggs: Can't handle #{field} type Array with non-symbolic entries"
+          end
+        else
+          fail "Biggs: Can't handle #{field} type #{key.class}"
+        end
+      end
+    end
+  end
+end

data/lib/biggs/format.rb

@@ -0,0 +1,24 @@
+module Biggs
+  class Format
+    attr_reader :country_name, :iso_code, :format_string, :country
+
+    def initialize(iso_code)
+      @iso_code      = iso_code.to_s.downcase
+      @country       = Biggs.country[@iso_code]
+      @country_name  = @country ? @country.name : nil
+      @format_string = @country ? @country.address_format : nil
+    end
+
+    class << self
+      def find(iso_code)
+        entries_cache[iso_code] ||= new(iso_code)
+      end
+
+      private
+
+      def entries_cache
+        @entries_cache ||= {}
+      end
+    end
+  end
+end

data/lib/biggs/formatter.rb

@@ -0,0 +1,33 @@
+module Biggs
+  class Formatter
+    FIELDS = [:recipient, :street, :city, :region, :postalcode, :country]
+
+    def initialize(options = {})
+      @blank_country_on = [options[:blank_country_on]].compact.flatten.map { |s| s.to_s.downcase }
+    end
+
+    def format(iso_code, values = {})
+      values.symbolize_keys! if values.respond_to?(:symbolize_keys!)
+
+      format = Biggs::Format.find(iso_code)
+      format_string = (format.format_string || default_format_string(values[:region])).dup.to_s
+      country_name = blank_country_on.include?(format.iso_code) ? '' : format.country_name || format.iso_code
+
+      (FIELDS - [:country]).each do |key|
+        format_string.gsub!(/\{\{#{key}\}\}/, (values[key] || '').to_s)
+      end
+      format_string.gsub!(/\{\{country\}\}/, country_name)
+      format_string.gsub(/\n$/, '')
+    end
+
+    attr_accessor :blank_country_on, :default_country_without_region, :default_country_with_region
+
+    private
+
+    def default_format_string(region)
+      region && region != '' ?
+        Biggs.country[default_country_with_region || 'us'].address_format :
+        Biggs.country[default_country_without_region || 'fr'].address_format
+    end
+  end
+end

data/lib/biggs/version.rb

@@ -0,0 +1,3 @@
+module Biggs
+  VERSION = '0.3.4'
+end

data/lib/biggs.rb

@@ -0,0 +1,16 @@
+require 'biggs/format'
+require 'biggs/formatter'
+require 'countries'
+
+module Biggs
+  class << self
+    def country
+      @@formats ||= Country
+    end
+  end
+end
+
+if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && !ActiveRecord::Base.respond_to?(:biggs_formatter)
+  require 'biggs/activerecord'
+  ActiveRecord::Base.send :include, Biggs::ActiveRecordAdapter
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rubygems'
+require 'rspec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'biggs')
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new('/tmp/biggs.log')
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: '/tmp/biggs.sqlite')
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Schema.define do
+  create_table :base_tables, force: true do |table|
+    table.string :name
+  end
+end

data/spec/unit/activerecord_spec.rb

@@ -0,0 +1,147 @@
+require 'rubygems'
+require 'active_record'
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+class BaseTable < ActiveRecord::Base
+  Biggs::Formatter::FIELDS.each do |field|
+    define_method(field) do
+      field == :country ? 'us' : field.to_s.upcase
+    end
+  end
+end
+
+class FooBarEmpty < BaseTable; end
+
+class FooBar < BaseTable
+  biggs :postal_address
+end
+
+class FooBarCustomFields < BaseTable
+  biggs :postal_address, country: :my_custom_country_method,
+                         city: :my_custom_city_method
+
+  def my_custom_country_method
+    'de'
+  end
+
+  def my_custom_city_method
+    'Hamburg'
+  end
+end
+
+class FooBarCustomBlankDECountry < BaseTable
+  biggs :postal_address, blank_country_on: 'de'
+
+  def country
+    'DE'
+  end
+end
+
+class FooBarCustomMethod < BaseTable
+  biggs :my_postal_address_method
+end
+
+class FooBarCustomProc < BaseTable
+  biggs :postal_address,
+        country: proc { |it| it.method_accessed_from_proc + 'XX' },
+        region: proc { |it| it.region.downcase }
+
+  def method_accessed_from_proc
+    'DE'
+  end
+end
+
+class FooBarCustomArray < BaseTable
+  biggs :postal_address,
+        street: [:address_1, :address_empty, :address_nil, :address_2]
+
+  def address_1
+    'Address line 1'
+  end
+
+  def address_2
+    'Address line 2'
+  end
+
+  def address_empty
+    ''
+  end
+
+  def address_nil
+    nil
+  end
+end
+
+describe 'ActiveRecord Class' do
+
+  it 'should include Biggs::ActiveRecordAdapter' do
+    expect(FooBar.included_modules).to be_include(Biggs::ActiveRecordAdapter)
+  end
+
+  it 'should set class value biggs_value_methods' do
+    expect(FooBar.class_eval('biggs_value_methods')).to be_is_a(Hash)
+    expect(FooBar.class_eval('biggs_value_methods').size).to be_zero
+  end
+
+  it 'should set class value biggs_instance' do
+    expect(FooBar.class_eval('biggs_instance')).to be_is_a(Biggs::Formatter)
+  end
+
+  it 'should respond to biggs' do
+    expect(FooBar).to be_respond_to(:biggs)
+  end
+end
+
+describe 'ActiveRecord Instance' do
+
+  describe 'Empty' do
+    it 'should not have postal_address method' do
+      expect(FooBarEmpty.new).not_to be_respond_to(:postal_address)
+    end
+  end
+
+  describe 'Standard' do
+    it 'should have postal_address method' do
+      expect(FooBar.new).to be_respond_to(:postal_address)
+    end
+
+    it 'should return postal_address on postal_address' do
+      expect(FooBar.new.postal_address).to eql("RECIPIENT\nSTREET\nCITY REGION POSTALCODE\nUnited States")
+    end
+  end
+
+  describe 'Customized Fields' do
+    it 'should return address from custom fields on postal_address' do
+      expect(FooBarCustomFields.new.postal_address).to eql("RECIPIENT\nSTREET\nPOSTALCODE Hamburg\nGermany")
+    end
+  end
+
+  describe 'Customized Blank DE Country' do
+    it 'should return address wo country on postal_address' do
+      expect(FooBarCustomBlankDECountry.new.postal_address).to eql("RECIPIENT\nSTREET\nPOSTALCODE CITY")
+    end
+  end
+
+  describe 'Customized Method name' do
+    it 'should have my_postal_address_method' do
+      expect(FooBarCustomMethod.new).to be_respond_to(:my_postal_address_method)
+    end
+
+    it 'should return formatted address on my_postal_address_method' do
+      expect(FooBarCustomMethod.new.my_postal_address_method).to eql("RECIPIENT\nSTREET\nCITY REGION POSTALCODE\nUnited States")
+    end
+  end
+
+  describe 'Customized Proc as Param' do
+    it 'should return formatted address for unknown-country DEXX' do
+      expect(FooBarCustomProc.new.postal_address).to eql("RECIPIENT\nSTREET\nCITY region POSTALCODE\ndexx")
+    end
+  end
+
+  describe 'Customized array of symbols' do
+    it 'should return formatted address with two lines for street' do
+      expect(FooBarCustomArray.new.postal_address).to eql("RECIPIENT\nAddress line 1\nAddress line 2\nCITY REGION POSTALCODE\nUnited States")
+    end
+  end
+
+end

data/spec/unit/biggs_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+FAKE_ATTR_WITH_REGION = { region: 'REGION', city: 'CITY', postalcode: 12_345, street: 'STREET', recipient: 'MR. X' }
+FAKE_ATTR_WO_REGION = { city: 'CITY', postalcode: 12_345, street: 'STREET', recipient: 'MR. X' }
+
+describe Biggs::Formatter, 'with defaults' do
+
+  before { @biggs = Biggs::Formatter.new }
+
+  it 'should format to us format' do
+    expect(@biggs.format('us', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\nCITY REGION 12345\nUnited States")
+  end
+
+  it 'should format to de format' do
+    expect(@biggs.format('de', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nGermany")
+  end
+
+  it 'should format to british format' do
+    expect(@biggs.format('gb', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\nCITY\nREGION\n12345\nUnited Kingdom")
+  end
+
+  it 'should format to fr format' do
+    expect(@biggs.format('fr', FAKE_ATTR_WO_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nFrance")
+  end
+
+  it 'should format to fr format if country_code unknown and there is no REGION given' do
+    expect(@biggs.format('unknown', FAKE_ATTR_WO_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nunknown")
+  end
+
+  it 'should format to us format if country_code unknown and there is no REGION given' do
+    expect(@biggs.format('unknown', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\nCITY REGION 12345\nunknown")
+  end
+
+  it 'should format to no(rwegian) format' do
+    expect(@biggs.format('no', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nNorway")
+  end
+
+  it 'should format to NC format' do
+    expect(@biggs.format('nc', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nNew Caledonia")
+  end
+
+  it 'should use country name if Country is known but format not' do
+    expect(@biggs.format('af', FAKE_ATTR_WO_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nAfghanistan")
+  end
+
+  it 'should use ISO Code if Country is unknown' do
+    expect(@biggs.format('xx', FAKE_ATTR_WO_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nxx")
+  end
+
+end
+
+describe Biggs, 'with options' do
+
+  describe 'blank_country_on de' do
+    before { @biggs = Biggs::Formatter.new(blank_country_on: 'de') }
+
+    it "should have blank country in 'de' address" do
+      expect(@biggs.format('de', FAKE_ATTR_WO_REGION)).to eql("MR. X\nSTREET\n12345 CITY")
+    end
+
+    it "should have country in 'fr' address" do
+      expect(@biggs.format('fr', FAKE_ATTR_WO_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nFrance")
+    end
+
+  end
+
+  describe 'blank_country_on multiple (US,de)' do
+    before { @biggs = Biggs::Formatter.new(blank_country_on: %w(US de)) }
+
+    it "should have blank country in 'us' address" do
+      expect(@biggs.format('us', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\nCITY REGION 12345")
+    end
+
+    it "should have country in 'fr' address" do
+      expect(@biggs.format('fr', FAKE_ATTR_WITH_REGION)).to eql("MR. X\nSTREET\n12345 CITY\nFrance")
+    end
+
+  end
+
+end

data/spec/unit/format_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'rspec/its'
+
+describe Biggs::Format do
+  describe '.find' do
+    context 'known country with format' do
+      subject { Biggs::Format.find('cn') }
+
+      it { is_expected.to be_kind_of(Biggs::Format) }
+      its(:country_name) { should eql('China') }
+      its(:iso_code) { should eql('cn') }
+      its(:format_string) { should eql("{{recipient}}\n{{street}}\n{{postalcode}} {{city}} {{region}}\n{{country}}") }
+    end
+
+    context 'known country with unknown format' do
+      subject { Biggs::Format.find('af') }
+
+      it { is_expected.to be_kind_of(Biggs::Format) }
+      its(:country_name) { should eql('Afghanistan') }
+      its(:iso_code) { should eql('af') }
+      its(:format_string) { should eql(nil) }
+    end
+
+    context 'unknown country' do
+      subject { Biggs::Format.find('xx') }
+
+      it { is_expected.to be_kind_of(Biggs::Format) }
+      its(:country_name) { should eql(nil) }
+      its(:iso_code) { should eql('xx') }
+      its(:format_string) { should eql(nil) }
+    end
+  end
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: eropple-biggs
+version: !ruby/object:Gem::Version
+  version: 0.3.4
+platform: ruby
+authors:
+- Sebastian Munz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.5
+description: biggs is a small ruby gem/rails plugin for formatting postal addresses
+  from over 60 countries.
+email:
+- sebastian@yo.lk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rvmrc"
+- CHANGES.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- biggs.gemspec
+- init.rb
+- lib/biggs.rb
+- lib/biggs/activerecord.rb
+- lib/biggs/format.rb
+- lib/biggs/formatter.rb
+- lib/biggs/version.rb
+- spec/spec_helper.rb
+- spec/unit/activerecord_spec.rb
+- spec/unit/biggs_spec.rb
+- spec/unit/format_spec.rb
+homepage: https://github.com/yolk/biggs
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: biggs
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: biggs is a small ruby gem/rails plugin for formatting postal addresses from
+  over 60 countries.
+test_files:
+- spec/spec_helper.rb
+- spec/unit/activerecord_spec.rb
+- spec/unit/biggs_spec.rb
+- spec/unit/format_spec.rb