kid80-biggs 0.1.5

data/CHANGES.textile

@@ -0,0 +1,27 @@
+h3. biggs 0.1.5 - 2009-07-03
+
+* Removed recipient from format
+* Added alias for biggs -> formatted_address, to be clearer what the method does.
+
+h3. biggs 0.1.4 - 2009-5-21
+
+* Fixed Specs
+
+h3. biggs 0.1.3 - 2009-3-6
+
+* Correct japanese address format. [hiroshi]
+* Fixed docs for current API. [hiroshi]
+
+h3. biggs 0.1.2 - 2009-3-4
+
+* Values can now be specified by an array of symbols.
+
+h3. biggs 0.1.1 - 2009-3-3
+
+* Refactored activerecord-adapter to include only basic setup method in ActiveRecord:Base
+
+h3. biggs 0.1.0 - 2009-3-3
+
+* Allow Procs as params in biggs-activerecord-setup.
+* Cleanup
+

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.textile

@@ -0,0 +1,147 @@
+biggs is a small ruby gem/rails plugin for formatting postal addresses from over 60 countries.
+
+h3. Install
+
+As a ruby gem:
+   
+   sudo gem install yolk-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
+
+h3. 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",
+      :zip        => 10999,
+      :state      => "Berlin" # <= state/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).
+   
+   f = 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"
+
+h3. 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, zip, state, 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, 
+            :zip => :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 state specified, and the french/german format for addresses without an state.
+   
+h3. 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
+* Denmark
+* Egypt
+* Finland
+* France
+* Germany
+* Greece
+* Greenland
+* Hong Kong
+* Hungary
+* Iceland
+* India
+* Indonesia
+* Ireland
+* Israel
+* Italy
+* Japan
+* Jordan
+* Kuwait
+* Lebanon
+* Luxembourg
+* Macedonia
+* Mexico
+* Netherlands
+* New Zealand
+* Norway
+* Oman
+* Philippines
+* Poland
+* Portugal
+* Qatar
+* Romania
+* Russian Federation
+* Saudi Arabia
+* Serbia and Montenegro
+* Singapore
+* Slovakia
+* Slovenia
+* South Africa
+* South Korea
+* Spain
+* Sweden
+* Switzerland
+* Syrian Arab Republic
+* Taiwan
+* Turkey
+* Ukraine
+* United Arab Emirates
+* United Kingdom
+* United States
+* Yemen
+
+biggs is tested to behave well with Rails 2.2.2.
+
+Copyright (c) 2009 Yolk Sebastian Munz & Julia Soergel GbR

data/Rakefile

@@ -0,0 +1,22 @@
+task :default => [:spec]
+ 
+$gem_name = "biggs"
+ 
+desc "Run specs"
+task :spec do
+  sh "spec spec/* --format specdoc --color"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = $gem_name
+    s.summary = "biggs is a small ruby gem/rails plugin for formatting postal addresses from over 60 countries."
+    s.email = "sebastian@yo.lk"
+    s.homepage = "http://github.com/yolk/biggs"
+    s.description = s.summary
+    s.authors = ["Sebastian Munz"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 5
+:major: 0

data/formats.yml

@@ -0,0 +1,410 @@
+# Avaible placeholders:
+#   * street
+#   * zip
+#   * city
+#   * state
+#   * country
+#
+--- 
+ae: 
+  name: United Arab Emirates
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+ar: 
+  name: Argentina
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{region}}
+    {{country}}
+at: 
+  name: Austria
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+au: 
+  name: Australia
+  format: |-
+    {{street}}
+    {{locality}} {{region}} {{postal_code}}
+    {{country}}
+ba: 
+  name: Bosnia and Herzegovina
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+be: 
+  name: Belgium
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+bg: 
+  name: Bulgaria
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+bh: 
+  name: Bahrain
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+br: 
+  name: Brazil
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}} {{region}}
+    {{country}}
+ca: 
+  name: Canada
+  format: |-
+    {{street}}
+    {{locality}} {{region}} {{postal_code}}
+    {{country}}
+ch: 
+  name: Switzerland
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+cn: 
+  name: China
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}} {{region}}
+    {{country}}
+cz: 
+  name: Czech
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+de: 
+  name: Germany
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+dk: 
+  name: Denmark
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{region}}
+    {{country}}
+eg: 
+  name: Egypt
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+es: 
+  name: Spain
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}} {{region}}
+    {{country}}
+fi: 
+  name: Finland
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+fr: 
+  name: France
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+gb: 
+  name: United Kingdom
+  format: |-
+    {{street}}
+    {{locality}}
+    {{region}}
+    {{postal_code}}
+    {{country}}
+gl: 
+  name: Greenland
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+gr: 
+  name: Greece
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+hk: 
+  name: Hong Kong
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}} {{region}}
+    {{country}}
+hr: 
+  name: Croatia
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+hu: 
+  name: Hungary
+  format: |-
+    {{locality}}
+    {{street}}
+    {{postal_code}}
+    {{country}}
+id: 
+  name: Indonesia
+  format: |-
+    {{street}}
+    {{locality}}
+    {{region}} {{postal_code}}
+    {{country}}
+ie: 
+  name: Ireland
+  format: |-
+    {{street}}
+    {{locality}} {{region}} {{postal_code}}
+    {{country}}
+il: 
+  name: Israel
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+in: 
+  name: India
+  format: |-
+    {{street}}
+    {{region}}
+    {{locality}} {{postal_code}}
+    {{country}}
+is: 
+  name: Iceland
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+it: 
+  name: Italy
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}} {{region}}
+    {{country}}
+jo: 
+  name: Jordan
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+# Here is a sample of Japanese formatted addresses (Apple Japan HQ).
+# Usually they have "Postal mark" before zip (postal) code,
+# and parts of an address are not separated with space.
+#  Biggs::Formatter.new(:blank_country_on => "jp").format(
+#    "jp",
+#    :recipient => "アップルジャパン株式会社 本社",
+#    :street => "西新宿3-20-2",
+#    :city => "新宿区",
+#    :state => "東京都",
+#    :zip => "163-1480")
+#  〒163-1480
+#  東京都新宿区西新宿3-20-2
+#  アップルジャパン株式会社 本社
+jp: 
+  name: Japan
+  format: |-
+    〒{{postal_code}}
+    {{region}}{{locality}}{{street}}
+    {{country}}
+kr: 
+  name: South Korea
+  format: |-
+    {{street}}
+    {{locality}} {{region}}
+    {{postal_code}}
+    {{country}}
+kw: 
+  name: Kuwait
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{region}}
+    {{country}}
+lb: 
+  name: Lebanon
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+lu: 
+  name: Luxembourg
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+mk: 
+  name: Macedonia
+  format: |-
+    {{street}}
+    {{locality}} {{postal_code}}
+    {{country}}
+mx: 
+  name: Mexico
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}} {{region}}
+    {{country}}
+nl: 
+  name: Netherlands
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+no: 
+  name: Norway
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+nz: 
+  name: New Zealand
+  format: |-
+    {{street}}
+    {{region}}
+    {{locality}} {{postal_code}}
+    {{country}}
+om: 
+  name: Oman
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{region}}
+    {{country}}
+ph: 
+  name: Philippines
+  format: |-
+    {{street}} {{region}}
+    {{postal_code}} {{locality}}
+    {{country}}
+pl: 
+  name: Poland
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{region}}
+    {{country}}
+pt: 
+  name: Portugal
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}} {{region}}
+    {{country}}
+qa: 
+  name: Qatar
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+ro: 
+  name: Romania
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+ru: 
+  name: Russian Federation
+  format: |-
+    {{postal_code}} {{locality}}
+    {{street}}
+    {{country}}
+sa: 
+  name: Saudi Arabia
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+se: 
+  name: Sweden
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+sg: 
+  name: Singapore
+  format: |-
+    {{street}}
+    {{locality}} {{postal_code}}
+    {{country}}
+si: 
+  name: Slovenia
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+sk: 
+  name: Slovakia
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+sy: 
+  name: Syrian Arab Republic
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+tr: 
+  name: Turkey
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+tw: 
+  name: Taiwan
+  format: |-
+    {{street}}
+    {{locality}} {{region}} {{postal_code}}
+    {{country}}
+ua: 
+  name: Ukraine
+  format: |-
+    {{street}}
+    {{locality}} {{region}}
+    {{postal_code}}
+    {{country}}
+us: 
+  name: United States
+  format: |-
+    {{street}}
+    {{locality}} {{region}} {{postal_code}}
+    {{country}}
+ye: 
+  name: Yemen
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    {{country}}
+yu: 
+  name: Serbia and Montenegro
+  format: |-
+    {{street}}
+    {{postal_code}} {{locality}}
+    
+    {{region}}
+    {{country}}
+za: 
+  name: South Africa
+  format: |-
+    {{street}}
+    {{locality}}
+    {{region}}
+    {{postal_code}}
+    {{country}}

data/lib/biggs/activerecord.rb

@@ -0,0 +1,79 @@
+module Biggs
+  module ActiveRecordAdapter
+    
+    def self.included(base)
+      base.extend(InitialClassMethods)
+    end
+    
+    module InitialClassMethods
+      def biggs(method_name=nil, options={})
+        self.extend(ClassMethods)
+        self.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
+        write_inheritable_attribute(:biggs_value_methods, value_methods)
+        write_inheritable_attribute(:biggs_formatter, Biggs::Formatter.new(options))
+      end
+      
+      alias_method :formatted_address, :biggs
+    end
+    
+    module ClassMethods
+      def biggs_value_methods
+        read_inheritable_attribute(:biggs_value_methods) || write_inheritable_attribute(:biggs_value_methods, {})
+      end
+      
+      def biggs_instance
+        read_inheritable_attribute(:biggs_formatter) || write_inheritable_attribute(:biggs_formatter, Biggs::Formatter.new)
+      end
+    end
+    
+    module InstanceMethods
+      
+      def biggs_postal_address
+        self.class.biggs_instance.format(biggs_country, biggs_values)
+      end
+      
+      def formatted_field_names
+        self.class.biggs_instance.fields_for_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
+          self.send(key.to_sym)
+        when Proc
+          key.call(self).to_s
+        when Array
+          if key.all?{|it| it.is_a?(Symbol) }
+            key.map{|method| self.send(method) }.reject(&:blank?).join("\n")
+          else
+            raise "Biggs: Can't handle #{field} type Array with non-symbolic entries"
+          end
+        else
+          raise "Biggs: Can't handle #{field} type #{key.class}"
+        end
+      end
+    end
+  end
+end

data/lib/biggs/formatter.rb

@@ -0,0 +1,52 @@
+module Biggs
+  class Formatter
+    
+    FIELDS = [:street, :locality, :region, :postal_code, :country]
+    
+    def initialize(options={})
+      @blank_country_on = [options[:blank_country_on]].compact.flatten.map{|s| s.to_s.downcase}
+    end
+  
+    def format(country_code, values={})
+      values.symbolize_keys! if values.respond_to?(:symbolize_keys!)
+      country_code = country_code.dup.to_s.downcase
+    
+      country_entry = (Biggs.formats[country_code] || default_country_entry(country_code, values))
+      country_name = (country_entry["name"].dup || "").to_s
+      country_format = (country_entry["format"].dup || "").to_s
+    
+      (FIELDS - [:country]).each do |key|
+        country_format.gsub!(/\{\{#{key}\}\}/, (values[key] || "").to_s)
+      end
+
+      country_name = "" if blank_country_on.include?(country_code)
+      country_format.gsub!(/\{\{country\}\}/, country_name)
+    
+      country_format.gsub(/\n$/,"")
+    end
+    
+    def fields_for_format(country_code, values={})
+      values.symbolize_keys! if values.respond_to?(:symbolize_keys!)
+      country_code = country_code.dup.to_s.downcase
+      country_entry = (Biggs.formats[country_code])
+      country_format = (country_entry["format"].dup || "").to_s
+      
+      form_fields = country_format.scan(/\{\{(\w+)\}\}/)
+      
+    end
+  
+    attr_accessor :blank_country_on, :default_country_without_state, :default_country_with_state
+  
+    private
+  
+    def default_country_entry(country_code, values={})
+      {
+        "name" => country_code.to_s,
+        "format" => (values[:region] && values[:region] != "" ?
+                  Biggs.formats[default_country_with_state || "us"] :
+                  Biggs.formats[default_country_without_state || "fr"])["format"]
+      }
+    end
+  end
+  
+end

data/lib/biggs.rb

@@ -0,0 +1,20 @@
+require 'biggs/formatter'
+
+module Biggs
+  class << self
+    def formats
+      @@formats ||= YAML.load_file(File.join(File.dirname(__FILE__), '..', 'formats.yml')) || {}
+    end
+    
+    def enable_activerecord
+      return if ActiveRecord::Base.respond_to? :biggs_formatter
+      require 'biggs/activerecord'
+      ActiveRecord::Base.send :include, Biggs::ActiveRecordAdapter
+    end
+  end
+end
+
+if defined?(ActiveRecord) and defined?(ActiveRecord::Base)
+  Biggs.enable_activerecord
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rubygems'
+require 'spec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'biggs')

data/spec/unit/activerecord_spec.rb

@@ -0,0 +1,201 @@
+require 'rubygems'
+require 'active_record'
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+# A dummy class for mocking the activerecord connection class
+class Connection;end
+
+# StandardMethods for Address
+module BiggsStandardMethods
+  Biggs::Formatter::FIELDS.each do |field|
+    define_method(field) do
+      field == :country ? "us" : field.to_s.upcase
+    end
+  end
+end
+
+class FooBarEmpty < ActiveRecord::Base
+  include BiggsStandardMethods
+end
+
+class FooBar < ActiveRecord::Base
+  include BiggsStandardMethods
+  
+  biggs :postal_address
+end
+
+class FooBarCustomFields < ActiveRecord::Base
+  include BiggsStandardMethods
+  
+  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 < ActiveRecord::Base
+  include BiggsStandardMethods
+  
+  biggs :postal_address, :blank_country_on => "de"
+  
+  def country
+    "DE"
+  end
+end
+
+class FooBarCustomMethod < ActiveRecord::Base
+  include BiggsStandardMethods
+  
+  biggs :my_postal_address_method
+end
+
+class FooBarCustomProc < ActiveRecord::Base
+  include BiggsStandardMethods
+  
+  biggs :postal_address, 
+        :country => Proc.new {|it| it.method_accessed_from_proc + "XX"}, 
+        :state => Proc.new {|it| it.state.downcase }
+  
+  def method_accessed_from_proc
+    "DE"
+  end
+end
+
+class FooBarCustomArray < ActiveRecord::Base
+  include BiggsStandardMethods
+  
+  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
+    FooBar.included_modules.should be_include(Biggs::ActiveRecordAdapter)
+  end
+  
+  it "should set class value biggs_value_methods" do
+    FooBar.class_eval("biggs_value_methods").should be_is_a(Hash)
+    FooBar.class_eval("biggs_value_methods").size.should be_zero
+  end
+  
+  it "should set class value biggs_instance" do
+    FooBar.class_eval("biggs_instance").should be_is_a(Biggs::Formatter)
+  end
+  
+  it "should respond to biggs" do
+    FooBar.should be_respond_to(:biggs)
+  end
+end
+
+describe "ActiveRecord Instance" do
+  
+  describe "Empty" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBarEmpty.stub!(:connection).and_return(connection)
+    end
+  
+    it "should not have postal_address method" do
+      FooBarEmpty.new.should_not be_respond_to(:postal_address)
+    end
+  end
+  
+  describe "Standard" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBar.stub!(:connection).and_return(connection)
+    end
+  
+    it "should have postal_address method" do
+      FooBar.new.should be_respond_to(:postal_address)
+    end
+  
+    it "should return postal_address on postal_address" do
+      FooBar.new.postal_address.should eql("STREET\nCITY STATE ZIP\nUnited States")
+    end
+  end
+
+  describe "Customized Fields" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBarCustomFields.stub!(:connection).and_return(connection)
+    end
+  
+    it "should return address from custom fields on postal_address" do
+      FooBarCustomFields.new.postal_address.should eql("STREET\nZIP Hamburg\nGermany")
+    end
+  end
+
+  describe "Customized Blank DE Country" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBarCustomBlankDECountry.stub!(:connection).and_return(connection)
+    end
+  
+    it "should return address wo country on postal_address" do
+      FooBarCustomBlankDECountry.new.postal_address.should eql("STREET\nZIP CITY")
+    end
+  end
+  
+  describe "Customized Method name" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBarCustomMethod.stub!(:connection).and_return(connection)
+    end
+  
+    it "should have my_postal_address_method" do
+      FooBarCustomMethod.new.should be_respond_to(:my_postal_address_method)
+    end
+    
+    it "should return formatted address on my_postal_address_method" do
+      FooBarCustomMethod.new.my_postal_address_method.should eql("STREET\nCITY STATE ZIP\nUnited States")
+    end
+  end
+  
+  describe "Customized Proc as Param" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBarCustomProc.stub!(:connection).and_return(connection)
+    end
+    
+    it "should return formatted address for unknown-country DEXX" do
+      FooBarCustomProc.new.postal_address.should eql("STREET\nCITY state ZIP\ndexx")
+    end
+  end
+  
+  describe "Customized array of symbols" do
+    before(:each) do
+      connection = mock(Connection, :columns => [])
+      FooBarCustomArray.stub!(:connection).and_return(connection)
+    end
+    
+    it "should return formatted address with two lines for street" do
+      FooBarCustomArray.new.postal_address.should eql("Address line 1\nAddress line 2\nCITY STATE ZIP\nUnited States")
+    end
+  end
+
+end

data/spec/unit/biggs_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+FAKE_ATTR_WITH_STATE = {:state => "STATE", :city => "CITY", :zip => 12345, :street => "STREET", :recipient => "MR. X"}
+FAKE_ATTR_WO_STATE = {:city => "CITY", :zip => 12345, :street => "STREET", :recipient => "MR. X"}
+
+describe Biggs::Formatter, "with defaults" do
+  
+  before { @biggs = Biggs::Formatter.new }
+  
+  it "should format to us format" do
+    @biggs.format('us', FAKE_ATTR_WITH_STATE).should eql("STREET\nCITY STATE 12345\nUnited States")
+  end
+  
+  it "should format to de format" do
+    @biggs.format('de', FAKE_ATTR_WITH_STATE).should eql("STREET\n12345 CITY\nGermany")
+  end
+  
+  it "should format to british format" do
+    @biggs.format('gb', FAKE_ATTR_WITH_STATE).should eql("STREET\nCITY\nSTATE\n12345\nUnited Kingdom")
+  end
+  
+  it "should format to fr format" do
+    @biggs.format('fr', FAKE_ATTR_WO_STATE).should eql("STREET\n12345 CITY\nFrance")
+  end
+  
+  it "should format to fr format if country_code unknown and there is no STATE given" do
+    @biggs.format('unknown', FAKE_ATTR_WO_STATE).should eql("STREET\n12345 CITY\nunknown")
+  end
+  
+  it "should format to us format if country_code unknown and there is no STATE given" do
+    @biggs.format('unknown', FAKE_ATTR_WITH_STATE).should eql("STREET\nCITY STATE 12345\nunknown")
+  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
+      @biggs.format('de', FAKE_ATTR_WO_STATE).should eql("STREET\n12345 CITY")
+    end
+    
+    it "should have country in 'fr' address" do
+      @biggs.format('fr', FAKE_ATTR_WO_STATE).should eql("STREET\n12345 CITY\nFrance")
+    end
+    
+  end
+  
+  describe "blank_country_on multiple (US,de)" do
+    before { @biggs = Biggs::Formatter.new(:blank_country_on => ['US', "de"]) }
+    
+    it "should have blank country in 'us' address" do
+      @biggs.format('us', FAKE_ATTR_WITH_STATE).should eql("STREET\nCITY STATE 12345")
+    end
+    
+    it "should have country in 'fr' address" do
+      @biggs.format('fr', FAKE_ATTR_WITH_STATE).should eql("STREET\n12345 CITY\nFrance")
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: kid80-biggs
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Sebastian Munz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+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: 
+- LICENSE
+- README.textile
+files: 
+- CHANGES.textile
+- formats.yml
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION.yml
+- lib/biggs.rb
+- lib/biggs/activerecord.rb
+- lib/biggs/formatter.rb
+- spec/spec_helper.rb
+- spec/unit/activerecord_spec.rb
+- spec/unit/biggs_spec.rb
+has_rdoc: true
+homepage: http://github.com/yolk/biggs
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+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