i18n_alchemy 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## master
+
+* Basic localization for numeric, date and time attributes
+* Accept hash of attributes on localized call
+* Localize attributes=, assign_attributes, update_attribute, and update_attributes ([@tomas-stefano](https://github.com/tomas-stefano))
+* Localize nested attributes ([@tomas-stefano](https://github.com/tomas-stefano))
+* JRuby compatibility ([@sobrinho](https://github.com/sobrinho))
+* Format numeric values based on the current I18n number precision, delimiter and thousand separator
+* Support for Rails 3.0, 3.1 and 3.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Carlos Antonio da Silva (carlosantoniodasilva@gmail.com)
+
+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,118 @@
+## I18nAlchemy
+
+I18n date/number parsing/localization
+
+I18nAlchemy aims to handle date, time and number parsing, based on current I18n locale format. The main idea is to have ORMs, such as ActiveRecord for now, to automatically accept dates/numbers given in the current locale format, and return these values localized as well.
+
+### Why
+
+Almost all projects I've been working so far required some sort of input using dates and numbers, and it has always been a pain due to lack of this support in ActiveRecord itself. As I do most of my projects using different date/number formats than the English defaults (I live in Brazil), we've been adopting different ways to handle that in each application.
+
+I've already used the delocalize gem in some of these projects, and validates_timeliness parser in others, and both work pretty well actually. But I think it might work a bit different than delocalize, and mainly, I wanted to learn more about I18n and ActiveRecord internals.
+
+## Usage
+
+I18nAlchemy is pretty straigthforward to use, you just need to include it in your ActiveRecord model. Lets say we are working with a Product model:
+
+```ruby
+class Product < ActiveRecord::Base
+  include I18n::Alchemy
+end
+```
+
+By mixing the module into your model, you get the *localized* method:
+
+```ruby
+@product   = Product.first
+@localized = @product.localized
+```
+
+Here are some examples on how to use it with numeric values:
+
+```ruby
+@localized.price = "1.99"
+
+@product.price   # => 1.99
+@localized.price # => "1.99"
+
+I18n.with_locale :pt do
+  @localized.price = "1,88"
+
+  @product.price   # => 1.88
+  @localized.price # => "1,88"
+end
+```
+
+Please notice that the localized proxy also formats your numeric values based on the current precision in your I18n locale file:
+
+```ruby
+@product.price = 1.3
+@localized.price # => "1.30", considering a precision of 2
+```
+
+And with thousand separators as well:
+
+```ruby
+@product.price = 1840.32
+@localized.price # => "1,840.32", considering separator = "," and delimiter = "."
+```
+
+Some examples with date / time objects:
+
+```ruby
+@localized.released_at = "12/31/2011"
+
+@product.released_at   # => Date.new(2011, 12, 31)
+@localized.released_at # => "12/31/2011"
+
+I18n.with_locale :pt do
+  @localized.released_at = "31/12/2011"
+
+  @product.released_at   # => Date.new(2011, 12, 31)
+  @localized.released_at # => "31/12/2011"
+end
+```
+
+The localized method quacks like ActiveRecord: you can give a hash of attributes and extra options if you want, and it will delegate everything to the object, parsing the attributes before:
+
+```ruby
+# This will parse the attributes in the given hash.
+I18n.with_locale :pt do
+  @localized = @product.localized(:price => "1,88")
+
+  @product.price   # => 1.88
+  @localized.price # => "1,88"
+end
+```
+
+## I18n configuration
+
+Right now the lib uses the same configuration for numeric, date and time values from Rails:
+
+```yaml
+en:
+
+  date:
+    formats:
+      default: "%m/%d/%Y"
+
+  time:
+    formats:
+      default: "%m/%d/%Y %H:%M:%S"
+
+  number:
+    format:
+      separator: '.'
+      delimiter: ','
+      precision: 2
+```
+
+Please notice the default date and time format is considered for input values for now, and it will only accept valid values matching these formats. We plan to add specific formats and to parse a list of possible input formats for I18nAlchemy, to make it more flexible, please refer to TODO file for more info.
+
+## Contact
+
+Carlos Antonio da Silva (http://github.com/carlosantoniodasilva)
+
+## License
+
+MIT License.

data/lib/i18n_alchemy/association_parser.rb

@@ -0,0 +1,49 @@
+module I18n
+  module Alchemy
+    class AssociationParser
+      attr_reader :target_class, :association_name
+
+      def initialize(target_class, association_name)
+        @target_class = target_class
+        @association_name = association_name
+        @association = @target_class.reflect_on_association(@association_name)
+        @proxy = @association.klass.new.localized
+      end
+
+      # Parse nested attributes for one-to-one and collection association
+      #
+      # ==== Examples
+      #
+      #  parse(:avatar_attributes => {:icon => 'sad_panda'})
+      #  parse(:posts_attributes  => [{:title => 'Foo!'}, {:title => 'Bar!'}])
+      #  parse(:posts_attributes => { 0 => {:title => 'Foo!'}, 1 => {:title => 'Bar!'})
+      #  parse(:posts_attributes => { "81u21udjsndja" => {:title => 'Foo!'}, "akmsams" => {:title => 'Baz!'}})
+      #
+      def parse(attributes)
+        if @association.macro == :has_many
+          attributes = if attributes.is_a?(Hash)
+            attributes.values
+          else
+            attributes
+          end
+          attributes.collect { |value_attributes| @proxy.send(:parse_attributes, value_attributes) }
+        else
+          @proxy.send(:parse_attributes, attributes)
+        end
+      end
+
+      # ==== Examples
+      #
+      #   class Member < ActiveRecord::Base
+      #     has_one :avatar
+      #     accepts_nested_attributes_for :avatar
+      #   end
+      #
+      #   AssociationParser.new(Member, :avatar).association_name_attributes # => "avatar_attributes"
+      #
+      def association_name_attributes
+        "#{association_name}_attributes"
+      end
+    end
+  end
+end

data/lib/i18n_alchemy/attribute.rb

@@ -0,0 +1,23 @@
+module I18n
+  module Alchemy
+    class Attribute
+      def initialize(target, attribute, parser)
+        @target    = target
+        @attribute = attribute
+        @parser    = parser
+      end
+
+      def read
+        @parser.localize(@target.send(@attribute))
+      end
+
+      def write(value)
+        @target.send(:"#{@attribute}=", parse(value))
+      end
+
+      def parse(value)
+        @parser.parse(value)
+      end
+    end
+  end
+end

data/lib/i18n_alchemy/date_parser.rb

@@ -0,0 +1,43 @@
+module I18n
+  module Alchemy
+    module DateParser
+      extend self
+
+      def parse(value)
+        return value unless valid_for_parsing?(value)
+
+        if parsed_date = Date._strptime(value, i18n_format)
+          build_object(parsed_date).to_s
+        else
+          value
+        end
+      end
+
+      def localize(value)
+        valid_for_localization?(value) ? I18n.localize(value) : value
+      end
+
+      protected
+
+      def build_object(parsed_date)
+        Date.new(*parsed_date.values_at(:year, :mon, :mday))
+      end
+
+      def i18n_format
+        I18n.t(:default, :scope => [i18n_scope, :formats])
+      end
+
+      def i18n_scope
+        :date
+      end
+
+      def valid_for_localization?(value)
+        value.is_a?(Date)
+      end
+
+      def valid_for_parsing?(value)
+        !valid_for_localization?(value)
+      end
+    end
+  end
+end

data/lib/i18n_alchemy/numeric_parser.rb

@@ -0,0 +1,57 @@
+module I18n
+  module Alchemy
+    module NumericParser
+      extend self
+
+      def parse(value)
+        if valid_for_parsing?(value)
+          value.gsub(delimiter, '_').gsub(separator, '.')
+        else
+          value
+        end
+      end
+
+      def localize(value)
+        if valid_for_localization?(value)
+          number_with_delimiter(format("%.#{precision}f", value))
+        else
+          value
+        end
+      end
+
+      private
+
+      def delimiter
+        translate :delimiter
+      end
+
+      def precision
+        translate :precision
+      end
+
+      def separator
+        translate :separator
+      end
+
+      def translate(key)
+        I18n.t(key, :scope => :"number.format")
+      end
+
+      def valid_for_localization?(value)
+        value.is_a?(Numeric) && !value.is_a?(Integer)
+      end
+
+      def valid_for_parsing?(value)
+        value.respond_to?(:gsub)
+      end
+
+      # Logic extracted from Rails' number_with_delimiter helper.
+      NUMBER_WITH_DELIMITER = /(\d)(?=(\d\d\d)+(?!\d))/
+      def number_with_delimiter(number)
+        parts  = number.split('.')
+        parts[0].gsub!(NUMBER_WITH_DELIMITER, "\\1#{delimiter}")
+        parts.join(separator)
+      end
+    end
+  end
+end

data/lib/i18n_alchemy/proxy.rb

@@ -0,0 +1,136 @@
+module I18n
+  module Alchemy
+    # Depend on AS::BasicObject which has a "blank slate" - no methods.
+    class Proxy < ActiveSupport::BasicObject
+      # TODO: cannot assume _id is always a foreign key.
+      # Find a better way to find that and skip these columns.
+      def initialize(target, attributes=nil, *args)
+        @target = target
+        @localized_attributes = {}
+
+        @target.class.columns.each do |column|
+          next if column.primary || column.name.ends_with?("_id")
+
+          parser = detect_parser(column)
+          if parser
+            create_localized_attribute(column.name, parser)
+            define_localized_methods(column.name)
+          end
+        end
+
+        @localized_associations = @target.class.nested_attributes_options.map do |association_name, options|
+          ::I18n::Alchemy::AssociationParser.new(@target.class, association_name)
+        end
+
+        assign_attributes(attributes, *args) if attributes
+      end
+
+      def attributes=(attributes)
+        @target.attributes = parse_attributes(attributes)
+      end
+
+      # This method is added to the proxy even thought it does not exist in
+      # Rails 3.0 (only >= 3.1).
+      def assign_attributes(attributes, *args)
+        if @target.respond_to?(:assign_attributes)
+          @target.assign_attributes(parse_attributes(attributes), *args)
+        else
+          self.attributes = attributes
+        end
+      end
+
+      def update_attributes(attributes, *args)
+        @target.update_attributes(parse_attributes(attributes), *args)
+      end
+
+      def update_attributes!(attributes, *args)
+        @target.update_attributes!(parse_attributes(attributes), *args)
+      end
+
+      def update_attribute(attribute, value)
+        attributes = parse_attributes(attribute => value)
+        @target.update_attribute(attribute, attributes.values.first)
+      end
+
+      # Override to_param to always return the +proxy.to_param+. This allow us
+      # to integrate with action view.
+      def to_param
+        @target.to_param
+      end
+
+      # Override to_model to always return the proxy, otherwise it returns the
+      # target object. This allows us to integrate with action view.
+      def to_model
+        self
+      end
+
+      # Allow calling localized methods with :send. This allows us to integrate
+      # with action view methods.
+      alias :send :__send__
+
+      # Allow calling localized methods with :try. If the method is not declared
+      # here, it'll be delegated to the target, losing localization capabilities.
+      def try(*a, &b)
+        __send__(*a, &b)
+      end
+
+      # Delegate all method calls that are not translated to the target object.
+      # As the proxy does not have any other method, there is no need to
+      # override :respond_to, just delegate it to the target as well.
+      def method_missing(*args, &block)
+        @target.send(*args, &block)
+      end
+
+      private
+
+      def create_localized_attribute(column_name, parser)
+        @localized_attributes[column_name] =
+          ::I18n::Alchemy::Attribute.new(@target, column_name, parser)
+      end
+
+      def define_localized_methods(column_name)
+        class << self; self; end.instance_eval do
+          define_method(column_name) do
+            @localized_attributes[column_name].read
+          end
+
+          # Before type cast must be localized to integrate with action view.
+          define_method("#{column_name}_before_type_cast") do
+            @localized_attributes[column_name].read
+          end
+
+          define_method("#{column_name}=") do |value|
+            @localized_attributes[column_name].write(value)
+          end
+        end
+      end
+
+      def detect_parser(column)
+        case
+        when column.number?
+          NumericParser
+        when column.type == :date
+          DateParser
+        when column.type == :datetime || column.type == :timestamp
+          TimeParser
+        end
+      end
+
+      def parse_attributes(attributes)
+        attributes = attributes.stringify_keys
+
+        @localized_attributes.each do |column_name, attribute|
+          next unless attributes.key?(column_name)
+          attributes[column_name] = attribute.parse(attributes[column_name])
+        end
+        @localized_associations.each do |association_parser|
+          association_attributes = association_parser.association_name_attributes
+          next unless attributes.key?(association_attributes)
+          attributes[association_attributes] = association_parser.parse(attributes[association_attributes])
+        end
+
+        attributes
+      end
+    end
+  end
+end

data/lib/i18n_alchemy/time_parser.rb

@@ -0,0 +1,22 @@
+module I18n
+  module Alchemy
+    module TimeParser
+      include DateParser
+      extend  self
+
+      protected
+
+      def build_object(parsed_date)
+        Time.utc(*parsed_date.values_at(:year, :mon, :mday, :hour, :min, :sec))
+      end
+
+      def i18n_scope
+        :time
+      end
+
+      def valid_for_localization?(value)
+        value.is_a?(Time) || value.is_a?(DateTime)
+      end
+    end
+  end
+end

data/lib/i18n_alchemy/version.rb

@@ -0,0 +1,5 @@
+module I18n
+  module Alchemy
+    VERSION = "0.0.1"
+  end
+end

data/lib/i18n_alchemy.rb

@@ -0,0 +1,17 @@
+require "date"
+require "active_record"
+require "i18n"
+require "i18n_alchemy/date_parser"
+require "i18n_alchemy/time_parser"
+require "i18n_alchemy/numeric_parser"
+require "i18n_alchemy/attribute"
+require "i18n_alchemy/association_parser"
+require "i18n_alchemy/proxy"
+
+module I18n
+  module Alchemy
+    def localized(attributes=nil, *args)
+      I18n::Alchemy::Proxy.new(self, attributes, *args)
+    end
+  end
+end

data/test/action_view_test.rb

@@ -0,0 +1,46 @@
+require "test_helper"
+
+class ActionViewTest < MiniTest::Unit::TestCase
+  def setup
+    @template  = ActionView::Base.new
+    @product   = Product.new(
+      :name         => "Potato",
+      :quantity     => 10,
+      :price        => 1.99,
+      :released_at  => Date.new(2011, 2, 28),
+      :last_sale_at => Time.mktime(2011, 2, 28, 13, 25, 30)
+    )
+    @localized = @product.localized
+
+    I18n.locale = :pt
+  end
+
+  def teardown
+    I18n.locale = :en
+  end
+
+  def test_text_field_with_string_attribute
+    assert_equal '<input id="product_name" name="product[name]" size="30" type="text" value="Potato" />',
+      @template.text_field(:product, :name, :object => @localized)
+  end
+
+  def test_text_field_with_integer_attribute
+    assert_equal '<input id="product_quantity" name="product[quantity]" size="30" type="text" value="10" />',
+      @template.text_field(:product, :quantity, :object => @localized)
+  end
+
+  def test_text_field_with_decimal_attribute
+    assert_equal '<input id="product_price" name="product[price]" size="30" type="text" value="1,99" />',
+      @template.text_field(:product, :price, :object => @localized)
+  end
+
+  def test_text_field_with_date_attribute
+    assert_equal '<input id="product_released_at" name="product[released_at]" size="30" type="text" value="28/02/2011" />',
+      @template.text_field(:product, :released_at, :object => @localized)
+  end
+
+  def test_text_field_with_time_attribute
+    assert_equal '<input id="product_last_sale_at" name="product[last_sale_at]" size="30" type="text" value="28/02/2011 13:25:30" />',
+      @template.text_field(:product, :last_sale_at, :object => @localized)
+  end
+end

data/test/db/test_schema.rb

@@ -0,0 +1,30 @@
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:"
+)
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :products do |t|
+    t.string     :name
+    t.decimal    :price
+    t.integer    :quantity
+    t.date       :released_at
+    t.datetime   :updated_at
+    t.timestamp  :last_sale_at
+    t.references :supplier
+    t.string     :my_precious
+  end
+
+  create_table :suppliers do |t|
+    t.string     :name
+    t.decimal    :a_decimal
+  end
+
+  create_table :accounts do |t|
+    t.references :supplier
+    t.string     :account_number
+    t.decimal    :total_money
+  end
+end

data/test/i18n_alchemy/date_parser_test.rb

@@ -0,0 +1,40 @@
+require "test_helper"
+
+class DateParserTest < MiniTest::Unit::TestCase
+  def setup
+    @parser = I18n::Alchemy::DateParser
+    @date   = Date.new(2011, 12, 31)
+  end
+
+  def test_does_not_convert_non_string_objects
+    assert_equal @date, @parser.parse(@date)
+  end
+
+  def test_parses_valid_string_dates_with_default_i18n_locale
+    assert_equal "2011-12-31", @parser.parse("12/31/2011")
+  end
+
+  def test_parsers_string_dates_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "2011-12-31", @parser.parse("31/12/2011")
+    end
+  end
+
+  def test_parsers_returns_the_given_string_when_invalid_date
+    assert_equal "31/12/2011", @parser.parse("31/12/2011")
+  end
+
+  def test_does_not_localize_string_values
+    assert_equal "12/31/2011", @parser.localize("12/31/2011")
+  end
+
+  def test_localizes_date_values
+    assert_equal "12/31/2011", @parser.localize(@date)
+  end
+
+  def test_localizes_date_values_based_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "31/12/2011", @parser.localize(@date)
+    end
+  end
+end

data/test/i18n_alchemy/numeric_parser_test.rb

@@ -0,0 +1,73 @@
+require "test_helper"
+
+class NumericParserTest < MiniTest::Unit::TestCase
+  def setup
+    @parser = I18n::Alchemy::NumericParser
+  end
+
+  def test_does_not_convert_non_string_objects
+    assert_equal 1.2, @parser.parse(1.2)
+  end
+
+  def test_parses_valid_string_numbers
+    assert_equal "1.2", @parser.parse("1.2")
+  end
+
+  def test_parses_string_numbers_with_delimiters
+    assert_equal "1_001.2", @parser.parse("1,001.2")
+    assert_equal "1_000_001.2", @parser.parse("1,000_001.2")
+  end
+
+  def test_integers
+    assert_equal 999, @parser.parse(999)
+    assert_equal "999", @parser.parse("999")
+  end
+
+  def test_parses_string_numbers_based_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "1.2", @parser.parse("1,2")
+    end
+  end
+
+  def test_parses_string_numbers_with_delimiters_based_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "1_001.2", @parser.parse("1.001,2")
+    end
+  end
+
+  def test_does_not_localize_string_values
+    assert_equal "1.2", @parser.localize("1.2")
+  end
+
+  def test_localize_numeric_values
+    assert_equal "1.20", @parser.localize(1.2)
+  end
+
+  def test_localize_numeric_values_with_delimiters
+    assert_equal "123.20", @parser.localize(123.2)
+    assert_equal "999.27", @parser.localize(999.27)
+  end
+
+  def test_localize_numeric_values_with_thousand_separators
+    assert_equal "1,001.20", @parser.localize(1001.2)
+    assert_equal "1,000,001.20", @parser.localize(1_000_001.2)
+  end
+
+  def test_localize_numbers_based_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "1,20", @parser.localize(1.2)
+    end
+  end
+
+  def test_localize_numbers_with_delimiters_based_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "99,20", @parser.localize(99.2)
+    end
+  end
+
+  def test_localize_numbers_with_separators_based_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "1.001,20", @parser.localize(1_001.2)
+    end
+  end
+end

data/test/i18n_alchemy/proxy_test.rb

@@ -0,0 +1,302 @@
+require "test_helper"
+
+class ProxyTest < MiniTest::Unit::TestCase
+  def setup
+    @product   = Product.new
+    @localized = @product.localized
+    @supplier  = Supplier.new
+    @supplier_localized = @supplier.localized
+
+    I18n.locale = :pt
+  end
+
+  def teardown
+    I18n.locale = :en
+  end
+
+  def test_delegates_orm_methods_to_target_object
+    assert @product.new_record?
+    assert @localized.save!(:name => "foo", :price => 1.99)
+    assert !@product.new_record?
+  end
+
+  def test_delegates_method_with_block_to_target_object
+    @localized.method_with_block do |attr|
+      assert_equal "called!", attr
+    end
+  end
+
+  def test_respond_to
+    assert_respond_to @localized, :price
+    assert_respond_to @localized, :price=
+    assert_respond_to @localized, :name
+    assert_respond_to @localized, :save
+    assert_respond_to @localized, :method_with_block
+  end
+
+  def test_does_not_localize_primary_key
+    @product.id = 1
+    assert_equal 1, @localized.id
+  end
+
+  def test_to_param
+    assert_equal @product.to_param, @localized.to_param
+  end
+
+  def test_does_not_localize_foreign_keys
+    @product.supplier_id = 1
+    assert_equal 1, @localized.supplier_id
+  end
+
+  def test_send
+    @product.name = "Potato"
+    assert_equal "Potato", @localized.send(:name)
+
+    @product.price = 1.88
+    assert_equal "1,88", @localized.send(:price)
+    assert_equal "1,88", @localized.send(:price_before_type_cast)
+  end
+
+  def test_try
+    @product.price = 1.99
+    assert_equal "1,99", @localized.try(:price)
+    assert_equal "1,99", @localized.try(:price_before_type_cast)
+  end
+
+  def test_try_with_block
+    @localized.try :method_with_block do |attr|
+      assert_equal "called!", attr
+    end
+  end
+
+  # Numeric
+  def test_parses_numeric_attribute_input
+    @localized.price = "1,99"
+    assert_equal 1.99, @product.price
+  end
+
+  def test_localizes_numeric_attribute_output
+    @product.price = 1.88
+    assert_equal "1,88", @localized.price
+  end
+
+  def test_localizes_numeric_attribute_before_type_cast_output
+    @product.price = 1.88
+    assert_equal "1,88", @localized.price_before_type_cast
+  end
+
+  def test_formats_numeric_attribute_output_when_localizing
+    @product.price = 1.3
+    assert_equal "1,30", @localized.price
+
+    @product.price = 2
+    assert_equal "2,00", @localized.price
+  end
+
+  def test_parsers_integer_attribute_input
+    @localized.quantity = "1,0"
+    assert_equal 1, @product.quantity
+  end
+
+  def test_localized_integer_attribute_output
+    @product.quantity = 1.0
+    assert_equal 1, @localized.quantity
+  end
+
+  def test_does_not_localize_other_attribute_input
+    @localized.name = "foo"
+    assert_equal "foo", @product.name
+  end
+
+  def test_does_not_localize_other_attribute_output
+    @product.name = "foo"
+    assert_equal "foo", @localized.name
+  end
+
+  # Date
+  def test_parses_date_attribute_input
+    @localized.released_at = "28/02/2011"
+    assert_equal Date.new(2011, 2, 28), @product.released_at
+  end
+
+  def test_localizes_date_attribute_output
+    @product.released_at = Date.new(2011, 2, 28)
+    assert_equal "28/02/2011", @localized.released_at
+  end
+
+  def test_localizes_date_attribute_before_type_cast_output
+    @product.released_at = Date.new(2011, 2, 28)
+    assert_equal "28/02/2011", @localized.released_at_before_type_cast
+  end
+
+  # DateTime
+  def test_parses_datetime_attribute_input
+    @localized.updated_at = "28/02/2011 13:25:30"
+    assert_equal Time.mktime(2011, 2, 28, 13, 25, 30), @product.updated_at
+  end
+
+  def test_localizes_datetime_attribute_output
+    @product.updated_at = Time.mktime(2011, 2, 28, 13, 25, 30)
+    assert_equal "28/02/2011 13:25:30", @localized.updated_at
+  end
+
+  def test_localizes_datetime_attribute_before_type_cast_output
+    @product.updated_at = Time.mktime(2011, 2, 28, 13, 25, 30)
+    assert_equal "28/02/2011 13:25:30", @localized.updated_at_before_type_cast
+  end
+
+  # Timestamp
+  def test_parses_timestamp_attribute_input
+    @localized.last_sale_at = "28/02/2011 13:25:30"
+    assert_equal Time.mktime(2011, 2, 28, 13, 25, 30), @product.last_sale_at
+  end
+
+  def test_localizes_timestamp_attribute_output
+    @product.last_sale_at = Time.mktime(2011, 2, 28, 13, 25, 30)
+    assert_equal "28/02/2011 13:25:30", @localized.last_sale_at
+  end
+
+  def test_localizes_timestamp_attribute_before_type_cast_output
+    @product.last_sale_at = Time.mktime(2011, 2, 28, 13, 25, 30)
+    assert_equal "28/02/2011 13:25:30", @localized.last_sale_at_before_type_cast
+  end
+
+  # Attributes
+  def test_initializes_proxy_with_attributes
+    @localized = @product.localized(
+      :name => "Banana", :price => "0,99", :released_at => "28/02/2011")
+
+    assert_equal 0.99, @product.price
+    assert_equal "0,99", @localized.price
+
+    assert_equal Date.new(2011, 2, 28), @product.released_at
+    assert_equal "28/02/2011", @localized.released_at
+  end
+
+  def test_initializes_proxy_with_attributes_and_skips_mass_assignment_security_protection_when_without_protection_is_used
+    @localized = @product.localized(attributes_hash, :without_protection => true)
+    if support_assign_attributes_without_protection?
+      assert_equal 'My Precious!', @localized.my_precious
+    else
+      assert_nil @localized.my_precious
+    end
+    assert_equal 1, @localized.quantity
+  end
+
+  def test_assign_attributes
+    @localized.assign_attributes(:price => '1,99')
+    assert_equal "1,99", @localized.price
+  end
+
+  def test_mass_assigning_invalid_attribute
+    assert_raises(ActiveRecord::UnknownAttributeError) do
+      @localized.assign_attributes('i_dont_even_exist' => 40)
+    end
+  end
+
+  def test_new_with_attr_protected_attributes
+    @localized.assign_attributes(attributes_hash)
+    assert_nil @localized.my_precious
+    assert_equal 1, @localized.quantity
+  end
+
+  def test_assign_attributes_skips_mass_assignment_security_protection_when_without_protection_is_used
+    @localized.assign_attributes(attributes_hash, :without_protection => true)
+    if support_assign_attributes_without_protection?
+      assert_equal 'My Precious!', @localized.my_precious
+    else
+      assert_nil @localized.my_precious
+    end
+    assert_equal 1, @localized.quantity
+  end
+
+  def test_assign_attributes_does_not_change_given_attributes_hash
+    assert_attributes_hash_is_not_changed(attributes = attributes_hash) do
+      @localized.assign_attributes(attributes)
+    end
+  end
+
+  def test_attributes_assignment
+    @localized.attributes = { :price => '1,99' }
+    assert_equal "1,99", @localized.price
+  end
+
+  def test_attributes_assignment_does_not_change_given_attributes_hash
+    assert_attributes_hash_is_not_changed(attributes = attributes_hash) do
+      @localized.attributes = attributes
+    end
+  end
+
+  def test_update_attributes
+    @localized.update_attributes(:price => '2,88')
+    assert_equal '2,88', @localized.price
+    assert_equal 2.88, @product.reload.price
+  end
+
+  def test_update_attributes_does_not_change_given_attributes_hash
+    assert_attributes_hash_is_not_changed(attributes = attributes_hash) do
+      @localized.update_attributes(attributes)
+    end
+  end
+
+  def test_update_attributes!
+    @localized.update_attributes!(:price => '2,88')
+    assert_equal '2,88', @localized.price
+    assert_equal 2.88, @product.reload.price
+  end
+
+  def test_update_attributes_bang_does_not_change_given_attributes_hash
+    assert_attributes_hash_is_not_changed(attributes = attributes_hash) do
+      @localized.update_attributes!(attributes)
+    end
+  end
+
+  def test_update_attribute
+    @localized.update_attribute(:price, '2,88')
+    assert_equal '2,88', @localized.price
+    assert_equal 2.88, @product.reload.price
+  end
+
+  # Nested Attributes
+  def test_should_assign_for_nested_attributes_for_collection_association
+    @supplier_localized.assign_attributes(:products_attributes => [{:price => '1,99'}, {:price => '2,93'}])
+    assert_equal 2, @supplier_localized.products.size
+    assert_equal '1,99', @supplier_localized.products.first.localized.price
+    assert_equal '2,93', @supplier_localized.products.last.localized.price
+  end
+
+  def test_should_assign_for_nested_attributes_passing_a_hash_for_collection_with_unique_keys
+    @supplier_localized.assign_attributes(:products_attributes => {"0" => {:price => '2,93', "_destroy"=>"false"}, "1" => {:price => '2,85', "_destroy" => "false"}})
+    prices = @supplier.products.map { |p| p.localized.price }.sort
+    assert_equal ['2,85', '2,93'], prices
+  end
+
+  def test_should_assign_for_nested_attributes_for_one_to_one_association
+    @supplier_localized.assign_attributes(:account_attributes => {:account_number => 10, :total_money => '100,87'})
+    account = @supplier_localized.account
+    assert_equal 10, account.account_number
+    assert_equal '100,87', account.localized.total_money
+  end
+
+  def test_update_attributes_for_nested_attributes
+    @supplier_localized.update_attributes(:account_attributes => {:total_money => '99,87'})
+    assert_equal '99,87', @supplier_localized.account.localized.total_money
+  end
+
+  def test_attributes_assignment_for_nested
+    @supplier_localized.attributes = {:account_attributes => {:total_money => '88,12'}}
+    assert_equal '88,12', @supplier_localized.account.localized.total_money
+  end
+
+  private
+
+  def attributes_hash
+    { :my_precious => 'My Precious!', :quantity => 1 }
+  end
+
+  def assert_attributes_hash_is_not_changed(attributes)
+    yield
+    assert_equal 1, attributes[:quantity]
+    assert_equal 'My Precious!', attributes[:my_precious]
+  end
+end

data/test/i18n_alchemy/time_parser_test.rb

@@ -0,0 +1,67 @@
+require "test_helper"
+
+module BaseTimeParserTest
+  def test_does_not_convert_non_string_objects
+    assert_equal @time, @parser.parse(@time)
+  end
+
+  # TODO: why so many time differences on the output?
+  def test_parses_valid_string_times_with_default_i18n_locale
+    output_timestamp = if RUBY_VERSION < "1.9"
+                         "Sat Dec 31 12:15:45 UTC 2011"
+                       else
+                         "2011-12-31 12:15:45 UTC"
+                       end
+
+    assert_equal output_timestamp, @parser.parse("12/31/2011 12:15:45")
+  end
+
+  def test_parsers_string_times_on_current_i18n_locale
+    I18n.with_locale :pt do
+      output_timestamp = if RUBY_VERSION < "1.9"
+                           "Sat Dec 31 12:15:45 UTC 2011"
+                         else
+                           "2011-12-31 12:15:45 UTC"
+                         end
+
+      assert_equal output_timestamp, @parser.parse("31/12/2011 12:15:45")
+    end
+  end
+
+  def test_parsers_returns_the_given_string_when_invalid_time
+    assert_equal "31/12/2011 12:15:45", @parser.parse("31/12/2011 12:15:45")
+  end
+
+  def test_does_not_localize_string_values
+    assert_equal "12/31/2011 12:15:45", @parser.localize("12/31/2011 12:15:45")
+  end
+
+  def test_localizes_time_values
+    assert_equal "12/31/2011 12:15:45", @parser.localize(@time)
+  end
+
+  def test_localizes_time_values_based_on_current_i18n_locale
+    I18n.with_locale :pt do
+      assert_equal "31/12/2011 12:15:45", @parser.localize(@time)
+    end
+  end
+end
+
+class TimeParserTest < MiniTest::Unit::TestCase
+  def setup
+    @parser = I18n::Alchemy::TimeParser
+    @time   = Time.mktime(2011, 12, 31, 12, 15, 45)
+  end
+
+  include BaseTimeParserTest
+end
+
+
+class DateTimeParserTest < MiniTest::Unit::TestCase
+  def setup
+    @parser = I18n::Alchemy::TimeParser
+    @time   = DateTime.new(2011, 12, 31, 12, 15, 45)
+  end
+
+  include BaseTimeParserTest
+end

data/test/locale/en.yml

@@ -0,0 +1,15 @@
+en:
+
+  date:
+    formats:
+      default: "%m/%d/%Y"
+
+  time:
+    formats:
+      default: "%m/%d/%Y %H:%M:%S"
+
+  number:
+    format:
+      separator: '.'
+      delimiter: ','
+      precision: 2

data/test/locale/pt.yml

@@ -0,0 +1,15 @@
+pt:
+
+  date:
+    formats:
+      default: "%d/%m/%Y"
+
+  time:
+    formats:
+      default: "%d/%m/%Y %H:%M:%S"
+
+  number:
+    format:
+      separator: ','
+      delimiter: '.'
+      precision: 2

data/test/models/account.rb

@@ -0,0 +1,5 @@
+class Account < ActiveRecord::Base
+  include I18n::Alchemy
+
+  belongs_to :supplier
+end

data/test/models/product.rb

@@ -0,0 +1,11 @@
+class Product < ActiveRecord::Base
+  include I18n::Alchemy
+
+  attr_protected :my_precious
+
+  belongs_to :supplier
+
+  def method_with_block
+    yield "called!"
+  end
+end

data/test/models/supplier.rb

@@ -0,0 +1,9 @@
+class Supplier < ActiveRecord::Base
+  include I18n::Alchemy
+
+  has_many :products
+  has_one  :account
+
+  accepts_nested_attributes_for :products
+  accepts_nested_attributes_for :account
+end

data/test/test_helper.rb

@@ -0,0 +1,26 @@
+require "rubygems"
+require "bundler/setup"
+Bundler.require :test
+
+require "minitest/unit"
+MiniTest::Unit.autorun
+
+require "i18n_alchemy"
+require "action_view"
+
+# Setup I18n after other requires to make sure our locales will override any
+# ActiveSupport / ActionView defaults.
+I18n.default_locale = :en
+I18n.locale = :en
+I18n.load_path << Dir[File.expand_path("../locale/*.yml", __FILE__)]
+
+require "db/test_schema"
+Dir["test/models/*.rb"].each { |file| require File.expand_path(file) }
+
+class MiniTest::Unit::TestCase
+  # AR 3.0 does not have assign_attributes and without_protection option, so we
+  # are going to skip such tests in this version.
+  def support_assign_attributes_without_protection?
+    @support_assign_attributes ||= ActiveRecord::VERSION::STRING >= "3.1.0"
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: i18n_alchemy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Carlos Antonio da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70234292607060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70234292607060
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70234292606460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70234292606460
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70234292605940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70234292605940
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70234292605400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: *70234292605400
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: &70234292604880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70234292604880
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70234292604220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *70234292604220
+description: I18n date/number parsing/localization
+email:
+- carlosantoniodasilva@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- lib/i18n_alchemy/association_parser.rb
+- lib/i18n_alchemy/attribute.rb
+- lib/i18n_alchemy/date_parser.rb
+- lib/i18n_alchemy/numeric_parser.rb
+- lib/i18n_alchemy/proxy.rb
+- lib/i18n_alchemy/time_parser.rb
+- lib/i18n_alchemy/version.rb
+- lib/i18n_alchemy.rb
+- test/action_view_test.rb
+- test/db/test_schema.rb
+- test/i18n_alchemy/date_parser_test.rb
+- test/i18n_alchemy/numeric_parser_test.rb
+- test/i18n_alchemy/proxy_test.rb
+- test/i18n_alchemy/time_parser_test.rb
+- test/locale/en.yml
+- test/locale/pt.yml
+- test/models/account.rb
+- test/models/product.rb
+- test/models/supplier.rb
+- test/test_helper.rb
+homepage: ''
+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'
+      segments:
+      - 0
+      hash: -3439421370757510840
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3439421370757510840
+requirements: []
+rubyforge_project: i18n_alchemy
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: I18n date/number parsing/localization
+test_files:
+- test/action_view_test.rb
+- test/db/test_schema.rb
+- test/i18n_alchemy/date_parser_test.rb
+- test/i18n_alchemy/numeric_parser_test.rb
+- test/i18n_alchemy/proxy_test.rb
+- test/i18n_alchemy/time_parser_test.rb
+- test/locale/en.yml
+- test/locale/pt.yml
+- test/models/account.rb
+- test/models/product.rb
+- test/models/supplier.rb
+- test/test_helper.rb