modalh 1.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem 'units-system'
+
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1"
+  gem "jeweler", "~> 1.8.3"
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.6)
+    modalsupport (0.8.3)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    shoulda (3.0.1)
+      shoulda-context (~> 1.0.0)
+      shoulda-matchers (~> 1.0.0)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.0.0)
+    units-system (0.2.1)
+      modalsupport
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1)
+  jeweler (~> 1.8.3)
+  rdoc (~> 3.12)
+  shoulda
+  units-system

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Javier Goizueta
+
+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.rdoc

@@ -0,0 +1,97 @@
+= ModalH
+
+This is a plugin for localization & delocalization (parsing localized text representation) of data values (numbers, dates, etc.).
+It also handles values with units (referred to as 'measures')
+
+It lives inside the H (for human) namespace; the localization operation is referred to as H.to or to_h
+(conversion of a value to a localized text representation for human consumption)
+and delocalization (parsing) is referred to as H.from or from_h (conversion of a localized text for humans to a data value).
+
+It can be integrated with ModalFields[https://github.com/jgoizueta/modalfields] to simplify the declaration of attributes
+to be localized/delocalized.
+
+Code for date parsing has been _borrowed_ from delocalize[https://github.com/clemens/delocalize].
+
+== Localization/delocalization of general data values
+
+In views and controllers the method @to_h@ can be used to localize a value for human consumption
+and @from_h@ to parse human input into a value: (note that @I18n.locale@ will be use as a default)
+
+  puts to_h(3.4, :locale=>:es, :precision=>3)      # => 3,400
+  puts from_h('3,400', :locale=>:es, :type=>Float) # => 3.4
+
+There are also more type-specific methods @number_to_h@, @number_from_h@, @date_to_h@, @date_from_h@, etc.
+
+In models, or any other place outside views or controller the forms @H.to@ (or @H.to_h@) and @H.from@ (or @H.from_h@)
+are available with the same functionality:
+
+  puts H.to(3.4, :locale=>:es, :precision=>3)      # => 3,400
+  puts H.from('3,400', :locale=>:es, :type=>Float) # => 3.4
+
+Again, type-specific versions exist @H.number_to@, @H.number_from@, etc.
+
+Data values can be formatted with units with the @magnitude@ variants:
+
+  puts  H.magnitude_to(3.233, :units=>'km/h', :precision=>2) # => "3,23 km/h"
+
+User input with optional units can be parsed and converted to de desired units:
+
+  puts H.magnitude_from('20 m/s', :units=>'km/h') # => 72.0
+
+Inconsistent units will raise an error.
+
+== Localization/delocalization of Model attributes
+
+An attribute @attr@ can be declared to be localized in its model class like so:
+
+  number_h :attr, :precision=>3
+
+This can also be handled automatically with ModalFields (see the h/fields.rb documentation).
+
+When an attributes is declared to be localized, a localized representation of it is available as @attr_h@:
+
+  puts record.attr_h
+
+For example, in a form we could have:
+
+  f.text_field :attr_h
+
+To assign localized text to an attribute @attr_h=@ can be used:
+
+  record.attr_h = params[:model][:attr_h]
+
+So, forms will work as usual by simply using the @_h@ variant of the fields that need localization.
+
+When using ModalFields, the desired precision for a localized numeric attribute, if different from that of the database field,
+can be specified with the @:h_precision@ parameter:
+
+  attr :decimal, :precision=>3, :h_precision=>2
+
+An attribute can be declared to have units in its model using this syntax:
+
+  units_h :attr, :precision=>3, :units=>'mm'
+
+With ModalFields and using the provided automatic units detection, an attribute simply has to be named with the units name
+as a suffix (separated by an underscore):
+
+  attr_mm :decimal, :precision=>3
+
+In this case, to prevent an attribute with such suffix from having units, a parameter @:units=>nil@ can be passed.
+
+The localized form of an attribute with units, @attr_h@ will include its units as when using @H.magnitude_to@.
+
+A localized attribute with units, when assigned through its @attr_h=@ form will accept units in the localized text
+and will perform the proper conversion. Inconsistent units will produce a nil value for the attribute and will
+fail to validate.
+
+== TODO
+
+* Tests
+* Document translations used
+* New attribute types: bank account number, credit card number, NIF, money, ...
+
+== Copyright
+
+Copyright (c) 2012 Javier Goizueta. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "modalh"
+  gem.homepage = "http://github.com/jgoizueta/modalh"
+  gem.license = "MIT"
+  gem.summary = %Q{Rails plugin for localization & delocalization}
+  gem.description = %Q{Rails plugin for localization & delocalization of data values}
+  gem.email = "jgoizueta@gmail.com"
+  gem.authors = ["Javier Goizueta"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "modalh #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/h/active_record_extensions.rb

@@ -0,0 +1,101 @@
+module H
+
+  # Allow declaration of H conversion for Model attributes like this:
+  #
+  #   date_h :start
+  #   number_h :speed, :precision=>3
+  #
+  # The first argumet to each declaration is the attribute name; the rest of parameters are passed to the H conversion methods
+  module ActiveRecordExtensions
+
+    # Generic H field declarator
+    def _h(prefix, attr, *options)
+
+      instance_variable_set :"@#{attr}_h_options", options
+
+      class_eval do
+
+        validates_each attr do |record, attr_name, value|
+          record.errors.add attr_name.to_s if record.send(:"\#{attr_name}_h_invalid")
+        end
+
+        # attr=(v)
+        define_method :"#{attr}=" do |v|
+          write_attribute attr, v
+          instance_variable_set "@#{attr}_h", nil
+        end
+
+        # attr_h
+        define_method :"#{attr}_h" do
+          # don't cache it, because the locale may change
+          # unless instance_variable_defined? "@#{attr}_h"
+            instance_variable_set "@#{attr}_h", H.send(:"#{prefix}_to", send(attr), *self.class.instance_variable_get(:"@#{attr}_h_options"))
+          # end
+          instance_variable_get "@#{attr}_h"
+        end
+
+        # attr_h=(txt)
+        define_method :"#{attr}_h=" do |txt|
+          instance_variable_set "@#{attr}_h", txt
+          instance_variable_set "@#{attr}_h_invalid", false
+          write_attribute attr, nil
+          unless txt.blank?
+            begin
+               v = H.send(:"#{prefix}_from", txt, *self.class.instance_variable_get(:"@#{attr}_h_options"))
+            rescue
+               v = nil
+            end
+            instance_variable_set "@#{attr}_h_invalid", true if v.nil?
+          end
+          send :"#{attr}=", v
+        end
+
+        # attr_h? (returns true if it is valid and not blank)
+        define_method :"#{attr}_h?" do
+          !instance_variable_get("@#{attr}_h_invalid") && send(:"#{attr}_h")
+        end
+
+        # attr_h_invalid?
+        define_method :"#{attr}_h_invalid?" do
+          instance_variable_get "@#{attr}_h_invalid"
+        end
+
+        # attr_h_valid?
+        define_method :"#{attr}_h_valid?" do
+          !instance_variable_get "@#{attr}_h_invalid"
+        end
+
+      end
+
+    end
+
+    [:number, :integer, :date, :logical, :time, :datetime].each do |prefix|
+      define_method :"#{prefix}_h" do |attr, *options|
+        _h prefix, attr, *options
+      end
+    end
+
+    # TODO: support special suffix form of units, e.g. _m2 for m^2, for attribute names
+
+    def units_h(name, units, options={})
+      norm_units = H::Units.normalize_units(units)
+      raise ArgumentError, "invalid units #{units}" unless norm_units
+      options[:units] = norm_units
+      _h :magnitude, name, options
+      short_name = name.to_s.chomp("_#{units}")
+      class_eval do
+        define_method :"#{short_name}_measure" do
+          # ::Units::Measure[send(name), units.to_s]
+          v = send(name)
+          v && v*::Units.u(norm_units)
+        end
+        define_method :"#{short_name}_measure=" do |v|
+          # Units::Measure[send(name), units.to_s]
+          send :"#{name}=", v && v.in(norm_units)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/h/fields.rb

@@ -0,0 +1,142 @@
+# :encoding: utf-8
+
+module H
+
+  # Helpers to use in ModalFields hooks to automatically generate _h declarations
+  # Examples of use
+  #
+  #   ModalFields.hook do
+  #     decimal do |model, declaration|
+  #       H::Fields.declare_numeric_field model, declaration
+  #     end
+  #
+  #     float do |model, declaration|
+  #       H::Fields.declare_numeric_field model, declaration
+  #     end
+  #
+  #     integer do |model, declaration|
+  #       H::Fields.declare_integer_field model, declaration
+  #     end
+  #   end
+  #
+  #   ModalFields.hook do
+  #     all_fields do |model, declaration|
+  #       H::Fields.declare_auto_units_field model, declaration
+  #     end
+  #   end
+  #
+  #   ModalFields.hook do
+  #     all_fields do |model, declaration|
+  #       H::Fields.declare_auto_field_with_units model, declaration
+  #     end
+  #   end
+  #
+  module Fields
+    class <<self
+
+      # # For numeric types, a display precision different from the stored precision can be selected with
+      # # the :h_precision attribute:
+      def declare_numeric_field(model, declaration)
+        options = declaration.attributes.slice(:precision)
+        if precision = declaration.attributes[:h_precision]
+          options[:precision] = precision
+        end
+        declaration.remove_attributes! :h_precision
+        model.number_h declaration.name, options
+      end
+
+      # Integers can also be assigned a precision and presented as generic numbers
+      def declare_integer_field(model, declaration)
+        precision = declaration.attributes[:h_precision] || declaration.attributes[:precision] || 0
+        declaration.remove_attributes! :h_precision, :precision
+        if precision==0
+          model.integer_h declaration.name
+        else
+          model.number_h declaration.name, :precision=>precision
+        end
+      end
+
+      def declare_units_field(model, declaration, suffix_units=nil)
+        options = declaration.attributes.slice(:precision, :units)
+        options[:units] ||= suffix_units
+        if precision = declaration.attributes[:h_precision]
+          options[:precision] = precision
+        end
+        options[:precision] ||= {'m'=>1, 'mm'=>0, 'cm'=>0, 'km'=>3}[options[:units]] # TODO AppSettings
+        declaration.remove_attributes! :h_precision, :units
+        model.units_h declaration.name, options[:units], options
+      end
+
+      def declare_date_field(model, declaration)
+        model.date_h declaration.name
+      end
+
+      def declare_time_field(model, declaration)
+        model.time_h declaration.name
+      end
+
+      def declare_datetime_field(model, declaration)
+        model.datetime_h declaration.name
+      end
+
+      def declare_boolean_field(model, declaration)
+        model.logical_h declaration.name
+      end
+
+      # This is handy to be used in all_fields to make any field with a :units parameter or a valid units suffix a units_h field
+      # (and make other numberic fields _h too); If a field with a suffix corresponding to valid units should not be a measure,
+      # a :units=>nil parameter should be added.
+      def declare_auto_units_field(model, declaration)
+        if declaration.type==:float || declaration.type==:decimal || declaration.type==:integer
+          units = declaration.attributes[:units]
+          unless declaration.attributes.has_key?(:units)
+            units = declaration.name.to_s.split('_').last
+          end
+          if units && H::Units.valid?(units)
+            declare_units_field model, declaration, units
+          else
+            raise ArgumentError, "Invalid units #{declaration.attributes[:units]} in declaration of #{model.name}" if declaration.attributes[:units]
+            if declaration.type==:integer
+              declare_integer_field model, declaration
+            else
+              declare_numeric_field model, declaration
+            end
+          end
+        end
+      end
+
+      def declare_auto_field_with_units(model, declaration)
+        case declaration.type
+        when :date
+          declare_date_field model, declaration
+        when :time
+          declare_time_field model, declaration
+        when :datetime
+          declare_datetime_field model, declaration
+        when :boolean
+          declare_boolean_field model, declaration
+        else
+          declare_auto_units_field model, declaration
+        end
+      end
+
+      def declare_auto_field_without_units(model, declaration)
+        case declaration.type
+        when :date
+          declare_date_field model, declaration
+        when :time
+          declare_time_field model, declaration
+        when :datetime
+          declare_datetime_field model, declaration
+        when :boolean
+          declare_boolean_field model, declaration
+        when :integer
+          declare_integer_field model, declaration
+        when :float, :decimal
+          declare_numeric_field model, declaration
+        end
+      end
+
+    end
+  end
+end

data/lib/h/h.rb

@@ -0,0 +1,264 @@
+# :encoding: utf-8
+
+# Localized formatting for Human-iteraction
+module H
+
+  class <<self
+    # localized conversions
+
+    # Produce data from human-localized text (from user interface)
+    def from(txt, options={})
+      type = options[:type] || Float
+      type = Float if type==:number
+      type = check_type(type)
+      if type.ancestors.include?(Numeric)
+        number_from(txt, options)
+      elsif type.respond_to?(:strftime)
+        date_from(txt, options)
+      elsif type==:logical || type==:boolean
+        logical_from(txt, options)
+      else
+        nil
+      end
+    end
+
+    # Generate human-localized text (for user interface) from data
+    def to(value, options={})
+      case value
+      when Numeric
+        number_to(value, options)
+      when Time, Date, DateTime
+        date_to(value, options)
+      when TrueClass, FalseClass
+        logical_to(value, options)
+      else
+        options[:blank] || ''
+      end
+    end
+
+    def number_to(value, options={})
+      options = I18n.translate(:'number.format', :locale => options[:locale]).except(:precision).merge(options)
+      precision = options[:precision]
+
+      return options[:blank] || '' if value.nil?
+      unless value.kind_of?(String)
+        value = round(value,precision)
+        if value.try.nan?
+          return options[:nan] || "--"
+        elsif value.try.infinite?
+          inf = options[:inf] || '∞'
+          return value<0 ? "-#{inf}" : inf
+         else
+          value = value.to_i if precision==0
+          value = value.to_s
+          value = value[0...-2] if value.ends_with?('.0')
+         end
+      end
+      if options[:delimiter]
+        txt = value.to_s.tr(' ','').tr('.,',options[:separator]+options[:delimiter]).tr(options[:delimiter],'')
+      else
+        txt = value.to_s.tr(' ,','').tr('.',options[:separator])
+      end
+      raise ArgumentError, "Invalid number #{txt}" unless /\A[+-]?\d+(?:#{Regexp.escape(options[:separator])}\d*)?(?:[eE][+-]?\d+)?\Z/.match(txt)
+      if precision && precision>0
+        p = txt.index(options[:separator])
+        if p.nil?
+          txt << options[:separator]
+          p = txt.size - 1
+        end
+        p += 1
+        txt << "0"*(precision-txt.size+p) if txt.size-p < precision
+      end
+      digit_grouping txt, 3, options[:delimiter], txt.index(/\d/), txt.index(options[:separator]) || txt.size
+    end
+
+    def number_from(txt, options={})
+      options = I18n.translate(:'number.format', :locale => options[:locale]).except(:precision).merge(options)
+      type = check_type(options[:type] || (options[:precision]==0 ? Integer : Float))
+
+      return nil if txt.to_s.strip.empty? || txt==options[:blank]
+
+      if options[:delimiter]
+        txt = txt.tr(' ','').tr(options[:delimiter]+options[:separator], ',.').tr(',','')
+      else
+        txt = txt.tr(' ','').tr(options[:separator], '.')
+      end
+      raise ArgumentError, "Invalid number #{txt}" unless /\A[+-]?\d+(?:\.\d*)?(?:[eE][+-]?\d+)?\Z/.match(txt)
+      if type==Float
+        txt.to_f
+      elsif type==Integer
+        txt.to_i
+      else
+        type.new txt
+      end
+    end
+
+    def integer_to(value, options={})
+      options = I18n.translate(:'number.format', :locale => options[:locale]).merge(options)
+      if value.nil?
+        options[:blank] || ''
+      else
+        value = value.to_s
+        digit_grouping value, 3, options[:delimiter], value.index(/\d/), value.size
+      end
+    end
+
+    def integer_from(txt)
+      if txt.to_s.strip.empty? || txt==options[:blank]
+        nil
+      else
+        txt = txt.tr(' ','')
+        txt = txt.tr(options[:delimiter],'') if options[:delimiter]
+        txt = txt.tr(options[:separator],'.')
+      end
+      raise ArgumentError, "Invalid integer #{txt}" unless /\A[+-]?\d+(?:\.0*)?\Z/.match(txt)
+      txt.to_i
+    end
+
+    def date_to(value, options={})
+      I18n.l(value, options)
+    end
+
+    def date_from(txt, options={})
+      options = I18n.translate(:'number.format', :locale => options[:locale]).merge(options)
+      type = check_type(options[:type] || Date)
+
+      return nil if txt.to_s.strip.empty? || txt==options[:blank]
+      return txt if txt.respond_to?(:strftime)
+
+      translate_month_and_day_names! txt, options[:locale]
+      input_formats(type).each do |original_format|
+        next unless txt =~ /^#{apply_regex(original_format)}$/
+
+        txt = DateTime.strptime(txt, original_format)
+        return Date == type ?
+          txt.to_date :
+          Time.zone.local(txt.year, txt.mon, txt.mday, txt.hour, txt.min, txt.sec)
+      end
+      default_parse(txt, type)
+    end
+
+    def time_to(value, options={})
+      date_to value, options.reverse_merge(:type=>Time)
+    end
+
+    def time_from(txt, options={})
+      date_from value, options.reverse_merge(:type=>Time)
+    end
+
+    def datetime_to(value, options={})
+      date_to value, options.reverse_merge(:type=>DateTime)
+    end
+
+    def datetime_from(txt, options={})
+      date_from value, options.reverse_merge(:type=>DateTime)
+    end
+
+    def logical_to(value, options={})
+      options = I18n.translate(:'logical.format', :locale => options[:locale]).merge(options)
+      value.nil? ? options[:blank] : (value ? options[:true] : options[:false])
+    end
+
+    def logical_from(txt, options={})
+      options = I18n.translate(:'logical.format', :locale => options[:locale]).merge(options)
+      txt = normalize_txt(txt)
+      trues = options[:trues]
+      trues ||= [normalize_txt(options[:true])]
+      falses = options[:falses]
+      falses ||= [normalize_txt(options[:falses])]
+      trues.include?(txt) ? true : falses.include?(txt) ? false : nil
+    end
+
+    # TODO: currency, money, bank accounts, credit card numbers, ...
+
+    private
+      # include ActionView::Helpers::NumberHelper
+
+      def round(v, ndec)
+        return v if v.try.nan? || v.try.infinite?
+        if ndec
+          case v
+            when BigDecimal
+              v = v.round(ndec)
+            when Float
+              k = 10**ndec
+              v = (k*v).round.to_f/k
+          end
+        end
+        v
+      end
+
+      # pos0 first digit, pos1 one past last integral digit
+      def digit_grouping(txt,n,sep,pos0,pos1)
+        if sep
+          while pos1>pos0
+            pos1 -= n
+            txt.insert pos1, sep if pos1>pos0
+          end
+        end
+        txt
+      end
+
+      # Date-parsing has been taken from https://github.com/clemens/delocalize
+
+      REGEXPS = {
+            '%B' => "(#{Date::MONTHNAMES.compact.join('|')})",      # long month name
+            '%b' => "(#{Date::ABBR_MONTHNAMES.compact.join('|')})", # short month name
+            '%m' => "(\\d{1,2})",                                   # numeric month
+            '%A' => "(#{Date::DAYNAMES.join('|')})",                # full day name
+            '%a' => "(#{Date::ABBR_DAYNAMES.join('|')})",           # short day name
+            '%Y' => "(\\d{4})",                                     # long year
+            '%y' => "(\\d{2})",                                     # short year
+            '%e' => "(\\s\\d|\\d{2})",                              # short day
+            '%d' => "(\\d{1,2})",                                   # full day
+            '%H' => "(\\d{2})",                                     # hour (24)
+            '%M' => "(\\d{2})",                                     # minute
+            '%S' => "(\\d{2})"                                      # second
+          }
+
+      def default_parse(datetime, type)
+        return if datetime.blank?
+        begin
+          today = Date.current
+          parsed = Date._parse(datetime)
+          return if parsed.empty? # the datetime value is invalid
+          # set default year, month and day if not found
+          parsed.reverse_merge!(:year => today.year, :mon => today.mon, :mday => today.mday)
+          datetime = Time.zone.local(*parsed.values_at(:year, :mon, :mday, :hour, :min, :sec))
+          Date == type ? datetime.to_date : datetime
+        rescue
+          datetime
+        end
+      end
+
+      def translate_month_and_day_names!(datetime, locale=nil)
+        translated = I18n.t([:month_names, :abbr_month_names, :day_names, :abbr_day_names], :scope => :date, :locale=>locale).flatten.compact
+        original = (Date::MONTHNAMES + Date::ABBR_MONTHNAMES + Date::DAYNAMES + Date::ABBR_DAYNAMES).compact
+        translated.each_with_index { |name, i| datetime.gsub!(name, original[i]) }
+      end
+
+      def input_formats(type, locale=nil)
+        # Date uses date formats, all others use time formats
+        type = type == Date ? :date : :time
+        I18n.t(:"#{type}.formats", :locale=>locale).slice(*I18n.t(:"#{type}.input.formats", :locale=>locale)).values
+      end
+
+      def apply_regex(format)
+        format.gsub(/(#{REGEXPS.keys.join('|')})/) { |s| REGEXPS[$1] }
+      end
+
+      def normalize_txt(txt)
+        txt.mb_chars.normalize(:kd).gsub(/[^\x00-\x7F]/n,'').downcase.strip.to_s
+      end
+
+      def check_type(type)
+        orig_type = type
+        type = type.to_s.camelcase.safe_constantize if type.kind_of?(Symbol)
+        raise ArgumentError, "Invalid type #{orig_type}" unless type && type.class==Class
+        type
+      end
+
+
+  end
+
+end

data/lib/h/helpers.rb

@@ -0,0 +1,17 @@
+module H
+
+  # Define methods to_h for H.to, from_h from H.from, xxx_to_h from H.xxx_to, xxx_from_h from H.xxx_from
+  module Helpers
+
+    (%w{date number integer logical magnitude}<<nil).each do |type|
+      %w{from to}.each do |kind|
+        name = [type,kind].compact*'_'
+        define_method "#{name}_h" do |*args|
+          H.send name, *args
+        end
+      end
+    end
+
+  end
+
+end

data/lib/h/units.rb

@@ -0,0 +1,82 @@
+# :encoding: utf-8
+
+module H
+
+  module Units
+
+    UNIT_SYN = {
+      'm2'=>'m**2',
+      'kp/m2'=>'kp/m**2',
+      '"'=>:inch,
+      '\''=>:ft,
+      "''"=>:inch,
+      'in'=>:inch
+    }
+
+    class <<self
+
+      def valid?(u)
+        u = normalize_units(u)
+        u && ::Units.u(u) rescue nil
+      end
+
+      # Convert a units expression to a Ruby expression valid for units-syste
+      def normalize_units(u)
+        if u.blank?
+          u = nil
+        else
+          u = u.to_s
+          u = UNIT_SYN[u] || u
+          u = u.to_s.gsub('^','**').tr(' ','*')
+          begin
+            ::Units.u(u)
+          rescue
+            u = nil
+          end
+        end
+        u
+      end
+
+      # Convert a units expression to the format to be presented to the user
+      def denormalize_units(u)
+        if u.blank?
+          u = nil
+        else
+          u = u.to_s.gsub('**','^').tr('*',' ')
+        end
+        u
+      end
+
+    end
+
+  end
+
+  class <<self
+
+    def magnitude_to(v, options={})
+      return options[:blank] || '' if v.nil?
+      norm_units = options[:units]
+      txt = number_to(v, options)
+      txt << " #{H::Units.denormalize_units(norm_units)}"
+      txt
+    end
+
+    def magnitude_from(txt, options={})
+      return nil if txt.to_s.strip.empty? || txt==options[:blank]
+      norm_units = options[:units]
+      if txt.match(/^\s*([0-9\.,+-]+)\s*([a-zA-Z\"\'][a-zA-Z1-3\_\/\*\^\"\']*)\s*$/)
+        txt = $1
+        from_units = $2 || norm_units
+      else
+        from_units = norm_units
+      end
+      from_units = H::Units.normalize_units(from_units)
+      raise ArgumentError, "Invalid units for #{norm_units}: #{from_units}}" unless from_units
+      v = number_from(txt, options)
+      v *= ::Units.u(from_units)
+      v.in(norm_units)
+    end
+
+  end
+
+end

data/lib/modalh.rb

@@ -0,0 +1,22 @@
+require 'h/h'
+require 'h/units'
+require 'h/helpers'
+require 'h/active_record_extensions'
+require 'h/fields'
+
+# Define xxxx_h field declarators for Model classes
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend H::ActiveRecordExtensions
+end
+
+# Add controller & view xxx_to_h/xxx_from_h helpers
+if defined?(ActionController::Base)
+   class ActionController::Base
+     include H::Helpers
+   end
+   ActionController::Base.helper_method *H::Helpers.instance_methods
+end
+
+# Make same helpers accessible with the H prefix from elsewhere
+# (not really needed; can use H.to/H.from instead)
+H.extend H::Helpers

data/modalh.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "modalh"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Javier Goizueta"]
+  s.date = "2012-04-21"
+  s.description = "Rails plugin for localization & delocalization of data values"
+  s.email = "jgoizueta@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/h/active_record_extensions.rb",
+    "lib/h/fields.rb",
+    "lib/h/h.rb",
+    "lib/h/helpers.rb",
+    "lib/h/units.rb",
+    "lib/modalh.rb",
+    "modalh.gemspec",
+    "test/helper.rb",
+    "test/test_modalh.rb"
+  ]
+  s.homepage = "http://github.com/jgoizueta/modalh"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.21"
+  s.summary = "Rails plugin for localization & delocalization"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<units-system>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+    else
+      s.add_dependency(%q<units-system>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    end
+  else
+    s.add_dependency(%q<units-system>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'modalh'
+
+class Test::Unit::TestCase
+end

data/test/test_modalh.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestModalh < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: modalh
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Javier Goizueta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: units-system
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+description: Rails plugin for localization & delocalization of data values
+email: jgoizueta@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/h/active_record_extensions.rb
+- lib/h/fields.rb
+- lib/h/h.rb
+- lib/h/helpers.rb
+- lib/h/units.rb
+- lib/modalh.rb
+- modalh.gemspec
+- test/helper.rb
+- test/test_modalh.rb
+homepage: http://github.com/jgoizueta/modalh
+licenses:
+- MIT
+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: -2675616586541666340
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Rails plugin for localization & delocalization
+test_files: []