general_units 0.0.4 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b587736e5f764d47a5633f38ae9e871078a9d2d
-  data.tar.gz: 91594f7393deb805d8a15ffbdeddaeaded832e18
+  metadata.gz: 7bb73e1c7d4e5f31b9e497ed16286044be1bd8db
+  data.tar.gz: 1c48246254178ba001ca32f74470b0349aa3aef6
 SHA512:
-  metadata.gz: 4ec7e49bc0fb3bf97304216b650fbb1f23db262ca31475db84be92448b116e2d9e033be3a3002e3ab176dc9d715d5cdf30a79cb112614c321bad755de23eb98c
-  data.tar.gz: f75851118b3fcbbeda331e3999d2a6d205984ffd6fac174ea65512f4ce84eb552078055c9f729323c7399e6213ca6f0b9bf060085437096a2537417f98e708dc
+  metadata.gz: 50ed29c361c9264f312f7c258d7d2e990d670b39490abbf139b5014e4d20f9896880a2f7515792aaa370ea01095bbafdd6005a80950a57d69d090d623ef2f611
+  data.tar.gz: fb25b41770e84fa70242d47a65b781c6878773aebe6737fa2efb21c0d08464ed060248a4cb53c7ba4f74fd98a37aa38b2b97acb4065df666e045da1d28857c85

data/lib/general_units.rb

@@ -2,6 +2,7 @@ require "general_units/version"
 
 module GeneralUnits
   def self.load!
+    load_arithmetics!
     load_units!
     load_numeric!
     load_derivatives!
@@ -9,9 +10,16 @@ module GeneralUnits
     require 'general_units/railtie'
   end
 
+  def self.load_arithmetics!
+    require 'general_units/arithmetics/methods'
+  end
+
   def self.load_units!
+    require 'general_units/units/base/measurement'
+    require 'general_units/units/base/unit'
     require 'general_units/units/weight'
     require 'general_units/units/length'
+    require 'general_units/units/volume'
   end
   
   def self.load_numeric!

data/lib/general_units/arithmetics/methods.rb

@@ -0,0 +1,28 @@
+module GeneralUnits
+  
+  module Arithmetics
+    def self.two_factors_of(number)
+      if (number = number.to_i) && (number > 1)
+        primes, powers = number.prime_division.transpose
+        exponents = powers.map {|i| (0..i).to_a}
+        divisors = exponents.shift.product(*exponents).map do |powers|
+          primes.zip(powers).map {|prime, power| prime ** power}.inject(:*)
+        end
+        divisors.sort.map {|div| [div, number/div]}
+      else
+        []
+      end
+    end
+
+    def self.three_factors_of(number)
+      export = []
+      two_factors_of(number).each do |factors|
+        two_factors_of(factors[1]).each do |next_factors|
+          export << [factors[0]] + next_factors
+        end
+      end
+      export
+    end
+  end
+  
+end

data/lib/general_units/derivatives/box.rb

@@ -1,4 +1,5 @@
-require 'general_units/units/length'
+require 'prime'
+require 'general_units/derivatives/box/packer'
 
 module GeneralUnits
   
@@ -12,8 +13,10 @@ module GeneralUnits
     delegate :hash, :to => :attributes
   
     def initialize(length = 0, width = 0, height = 0, unit)
-      VALUES.each {|v| instance_variable_set(:"@#{v}", validate_value(eval(v), unit))}
-      @unit = @height.unit
+      if unit = valid_unit(unit)
+        VALUES.each {|v| instance_variable_set(:"@#{v}", validate_dimension_value(eval(v), unit))}
+        @unit = unit
+      end
     end
   
     def attributes
@@ -25,11 +28,11 @@ module GeneralUnits
     end
     
     def amount
-      values.sum
+      volume.amount
     end
   
     def volume
-      length * width * height
+      Volume.new(length * width * height, :"cubic_#{unit.code}")
     end
     
     def has_space?
@@ -44,33 +47,50 @@ module GeneralUnits
       values.map {|d| d.to_s(round)}.join("x")
     end
     
-    def formatted(round = nil)
-      "#{to_s(round)} #{unit.short}"
+    def formatted(round = nil, &block)
+      if block_given?
+        yield to_s(round), unit
+      else
+        "#{to_s(round)} #{unit.short}"          
+      end
+    end
+    
+    def to_volume
+      volume
     end
     
-    def accommodates?(*boxes)
-      boxes.map! {|box| validate_capacity(box)}
-      boxes.sum(&:volume) < volume && includes?(Box.new(boxes.map(&:length).max, boxes.map(&:width).max, boxes.map(&:height).max, unit))
+    def two_max_values
+      sorted = values.sort.reverse
+      sorted.first(2)
+    end
+    
+    def max_face
+      two_max_values[0] * two_max_values[1]
+    end
+    
+    def inspect
+      "<#{self.class.name} length=#{length} width=#{width} height=#{height} unit=#{unit}>"
     end
   
     def same_size?(other_object)
-      other_object = validate_capacity(other_object)
+      other_object = validate_box(other_object)
       eval VALUES.permutation.to_a.map {|values_names| "(length == other_object.#{values_names[0]} && width == other_object.#{values_names[1]} && height == other_object.#{values_names[2]})"}.join("||")
     end
   
     def includes?(other_object)
-      other_object = validate_capacity(other_object)
+      other_object = validate_box(other_object)
       eval VALUES.permutation.to_a.map {|values_names| "(length >= other_object.#{values_names[0]} && width >= other_object.#{values_names[1]} && height >= other_object.#{values_names[2]})"}.join("||")
     end
   
     ### ARITHMETICS START ###
+    delegate :<=>, :<, :>, :<=, :>=, :positive?, :negative?, :div, :divmod, :modulo, :%, :remainder, :abs, :zero?, :nonzero?, :coerce, :to => :volume
   
     def -@
       Box.new(*values.map {|v| -v}, unit)    
     end
   
     def ==(other_object)
-      other_object = validate_capacity(other_object)
+      other_object = validate_box(other_object)
       length == other_object.length && width == other_object.width && height == other_object.height
     rescue
       false
@@ -79,53 +99,11 @@ module GeneralUnits
     def eql?(other_object)
       self == other_object
     end
-
-    def <=>(other_object)
-      other_object = validate_capacity_or_length(other_object)
-      volume <=> case other_object
-      when Length then other_object
-      when Box then other_object.volume
-      end
-    end
-
-    def >(other_object)
-      other_object = validate_capacity_or_length(other_object)
-      volume > case other_object
-      when Length then other_object
-      when Box then other_object.volume
-      end
-    end
- 
-    def <(other_object)
-      other_object = validate_capacity_or_length(other_object)
-      volume < case other_object
-      when Length then other_object
-      when Box then other_object.volume
-      end
-    end
-  
-    def >=(other_object)
-      other_object = validate_capacity_or_length(other_object)
-      volume >= case other_object
-      when Length then other_object
-      when Box then other_object.volume
-      end
-    end
- 
-    def <=(other_object)
-      other_object = validate_capacity_or_length(other_object)
-      volume <= case other_object
-      when Length then other_object
-      when Box then other_object.volume
-      end
-    end
-
-    delegate :positive?, :negative?, :to => :volume
   
     def +(other_object)
       other_object = validate_capacity_or_length(other_object)
       case other_object
-      when Length then Box.new(*values.map {|v| v + other_object/3}, unit)
+      when Length, Volume then Box.new(*values.map {|v| v + other_object/3}, unit)
       when Box then Box.new(*VALUES.map {|v| eval(v) + other_object.send(v)}, unit)
       end
     end
@@ -133,7 +111,7 @@ module GeneralUnits
     def -(other_object)
       other_object = validate_capacity_or_length(other_object)
       case other_object
-      when Length then Box.new(*values.map {|v| v - other_object/3}, unit)
+      when Length, Volume then Box.new(*values.map {|v| v - other_object/3}, unit)
       when Box then Box.new(*VALUES.map {|v| eval(v) - other_object.send(v)}, unit)
       end
     end
@@ -141,7 +119,7 @@ module GeneralUnits
     def *(other_object)
       other_object = validate_capacity_or_length(other_object)
       case other_object
-      when Length then Box.new(*values.map {|v| v * other_object}, unit)
+      when Length, Volume then Box.new(*values.map {|v| v * other_object}, unit)
       when Box then Box.new(*VALUES.map {|v| eval(v) * other_object.send(v)}, unit)
       end
     end
@@ -149,22 +127,109 @@ module GeneralUnits
     def /(other_object)
       other_object = validate_capacity_or_length(other_object)
       case other_object
-      when Length then Box.new(*values.map {|v| v / other_object}, unit)
+      when Length, Volume then Box.new(*values.map {|v| v / other_object}, unit)
       when Box then Box.new(*VALUES.map {|v| eval(v) / other_object.send(v)}, unit)
       end
     end
+    
+    ### ARITHMETICS END ###
   
-    delegate :div, :divmod, :modulo, :%, :remainder, :abs, :zero?, :nonzero?, :coerce, :to => :volume
+    def multiplicator(sum)
+      GeneralUnits::Arithmetics.three_factors_of(sum).map do |v|
+        Box.new(v[0]*length, v[1]*width, v[2]*height, unit)
+      end
+    end
   
-    ### ARITHMETICS END ###
+    def multiply_to_strong_box(sum)
+      multiplicator(sum).min_by {|box| box.values.max - box.values.min}
+    end
+    
+    def multiply_to_optimal(sum)
+      if sum.odd?
+        [multiply_to_strong_box(sum-1), self]
+      else
+        [multiply_to_strong_box(sum)]
+      end.compact
+    end
+    
+    def concat_with(other_box, &block)
+      #other_box = other_box.convert_to(unit)
+      
+      length_1, width_1, height_1 = *values.sort.reverse
+      length_2, width_2, height_2 = *other_box.values.sort.reverse
+
+      x1 = (length_1 - length_2).abs
+      length = [length_1, length_2].max
+
+      x2 = (width_1 - width_2).abs
+      width = [width_1, width_2].max
+
+      height = height_1 + height_2
+
+      if x1 > 0
+        y1 = width
+        z1 = length_1 > length_2 ? height_2 : height_1
+        yield(Box.new(x1, y1, z1, unit)) if block_given?
+      end
+
+      if x2 > 0
+        y2 = ((length_1 > length_2) && (width_1 > width_2)) ? length-x1 : length
+        z2 = width_1 > width_2 ? height_2 : height_1
+        yield(Box.new(x2, y2, z2, unit)) if block_given?
+      end
+      
+      Box.new(length, width, height, unit).convert_to(unit)
+    end
+
+    def estimated_spaces_with(other_box, &block)
+      #other_box = other_box.convert_to(unit)
+      
+      if includes?(other_box)
+        length_1, width_1, height_1 = *values.sort.reverse
+        length_2, width_2, height_2 = *other_box.values.sort.reverse
+        
+        estimated_spaces = []
+        
+        x1 = (length_1 - length_2).abs
+        if x1 > 0
+          space1 = Box.new(x1, width_1, height_1, unit)
+          estimated_spaces << space1
+          yield(space1) if block_given?
+        end
+  
+        x2 = (width_1 - width_2).abs
+        if x2 > 0
+          space2 = Box.new(length_1 - x1, x2, height_1, unit)
+          estimated_spaces << space2
+          yield(space2) if block_given?
+        end
+  
+        x3 = (height_1 - height_2).abs
+        if x3 > 0
+          space3 = Box.new(length_2, width_2, x3, unit)
+          estimated_spaces << space3
+          yield(space3) if block_given?
+        end
+        
+        estimated_spaces
+      end
+    end
   
     private
+    
+    def valid_unit(unit)
+      unit_object = case unit
+      when String, Symbol then Length.units.find {|u| u.code.to_s == unit.to_s}
+      when Base::Unit then unit
+      end
+      unit_object || raise(TypeError, "Unprocessable unit #{unit.inspect}")
+    end
   
-    def validate_value(val, unit)
+    def validate_dimension_value(val, unit)
       val.is_a?(Length) ? val.convert_to(unit) : Length.new(val, unit)
     end
   
-    def validate_capacity(val)
+    def validate_box(val)
       case val
       when Box then val.convert_to(unit)
       else raise(TypeError, "Box required, #{val.class} passed.")
@@ -173,9 +238,10 @@ module GeneralUnits
   
     def validate_capacity_or_length(val)
       case val
-      when Box, Length then val.convert_to(unit)
-      when Numeric then val.to_length(unit)
-      else raise(TypeError, "Box or Length or Numeric required, #{val.class} passed.")
+      when Box then val.convert_to(unit)
+      when Volume then val.convert_to(volume.unit.code)
+      when Length, Numeric then val.to_volume(volume.unit.code)
+      else raise(TypeError, "Box or Volume or Numeric required, #{val.class} passed.")
       end
     end
   

data/lib/general_units/derivatives/box/packer.rb

@@ -0,0 +1,52 @@
+module GeneralUnits
+  class Box
+    
+    class Packer
+      attr_reader :boxes, :gaps, :coupled, :gaps_used, :rotated
+      
+      def initialize(*boxes)
+        @boxes = boxes.sort_by(&:max_face).reverse
+        @coupled = @boxes.first # first box - biggest
+        @gaps = []
+        @gaps_used = [] # for test
+        @rotated = 0 # if height > current length
+        pack!
+      end
+      
+      def to_s
+        inspect
+      end
+      
+      def inspect
+        "<#{self.class.name} boxes=#{boxes.size} gaps=#{gaps.size} used=#{gaps_used.size} coupled=#{coupled}>"
+      end
+      
+      private
+      
+      def pack!
+        boxes[1..-1].each do |box|
+          unless use_gap_for(box)
+            @coupled = coupled.concat_with(box) {|r| @gaps << r}
+            # if coupled.height > coupled.length
+            #   @rotated += 1
+            # end
+          end
+        end
+        coupled
+      end
+      
+      def use_gap_for(box)
+        gap = @gaps.find_all {|g| g.includes?(box)}.min_by {|g| g.volume - box.volume}
+        if gap && gap.estimated_spaces_with(box) {|r| @gaps << r}
+          @gaps.delete_if {|r| r.object_id == gap.object_id}
+          @gaps_used << box
+          true
+        else
+          false
+        end
+      end
+      
+    end
+
+  end
+end

data/lib/general_units/helpers/action_view_extension.rb

@@ -7,11 +7,11 @@ module GeneralUnits
     end
     
     def weight_units_for_select
-      Weight::UNITS.map {|u| [u.name, u.code]}
+      Weight.units.map {|u| [u.name, u.code]}
     end
     
     def length_units_for_select
-      Length::UNITS.map {|u| [u.name, u.code]}
+      Length.units.map {|u| [u.name, u.code]}
     end
     
   end

data/lib/general_units/models/active_record_extension.rb

@@ -1,7 +1,7 @@
 module GeneralUnits
 
   module ActiveRecordExtension
-    extend ActiveSupport::Concern
+    extend ::ActiveSupport::Concern
   
     module ClassMethods
       
@@ -17,12 +17,12 @@ module GeneralUnits
         self._has_weight[prefix][:default_unit] = default_unit = options[:default_unit]||:kilogram
         self._has_weight[prefix][:default_unit_method] = default_unit_method = options[:default_unit_method]||:"deafult_#{prefix}_unit"
         
-  			validates_inclusion_of unit_field, :in => Weight::UNITS.map {|u| u.code.to_s}, :if => Proc.new {|o| o.send(amount_field).present?}
+        validates_inclusion_of unit_field, :in => Weight.units.map {|u| u.code.to_s}, :if => Proc.new {|o| o.send(amount_field).present?}
         
         class_eval <<-EOV
         
           def #{unit_field}=(value)
-            if value.to_sym.in?(GeneralUnits::Weight::UNITS.map(&:code))
+            if value.to_sym.in?(GeneralUnits::Weight.units.map(&:code))
               super(value.to_s) 
             else
               raise ArgumentError, "Unprocessable unit: \#{value.inspect\}"
@@ -77,12 +77,12 @@ module GeneralUnits
         self._has_length[prefix][:default_unit] = default_unit = options[:default_unit]||:centimeter
         self._has_length[prefix][:default_unit_method] = default_unit_method = options[:default_unit_method]||:"deafult_#{prefix}_unit"
         
-  			validates_inclusion_of unit_field, :in => Length::UNITS.map {|u| u.code.to_s}, :if => Proc.new {|o| o.send(amount_field).present?}
+        validates_inclusion_of unit_field, :in => Length.units.map {|u| u.code.to_s}, :if => Proc.new {|o| o.send(amount_field).present?}
         
         class_eval <<-EOV
         
           def #{unit_field}=(value)
-            if value.to_sym.in?(GeneralUnits::Length::UNITS.map(&:code))
+            if value.to_sym.in?(GeneralUnits::Length.units.map(&:code))
               super(value.to_s) 
             else
               raise ArgumentError, "Unprocessable unit: \#{value.inspect\}"
@@ -140,12 +140,12 @@ module GeneralUnits
         self._has_box[prefix][:default_unit] = default_unit = options[:default_unit]||:centimeter
         self._has_box[prefix][:default_unit_method] = default_unit_method = options[:default_unit_method]||:"deafult_#{prefix}_unit"
         
-  			validates_inclusion_of unit_field, :in => Length::UNITS.map {|u| u.code.to_s}, :if => Proc.new {|o| o.send(length_field).present? || o.send(width_field).present? || o.send(height_field).present?}
+        validates_inclusion_of unit_field, :in => Length.units.map {|u| u.code.to_s}, :if => Proc.new {|o| o.send(length_field).present? || o.send(width_field).present? || o.send(height_field).present?}
         
         class_eval <<-EOV
         
           def #{unit_field}=(value)
-            if value.to_sym.in?(GeneralUnits::Length::UNITS.map(&:code))
+            if value.to_sym.in?(GeneralUnits::Length.units.map(&:code))
               super(value.to_s) 
             else
               raise ArgumentError, "Unprocessable unit: \#{value.inspect\}"

data/lib/general_units/numeric.rb

@@ -7,5 +7,9 @@ class Numeric
   def to_length(unit = :millimeter)
     GeneralUnits::Length.new(self, unit)
   end
+  
+  def to_volume(unit = :cubic_millimeter)
+    GeneralUnits::Volume.new(self, unit)
+  end
 
 end

data/lib/general_units/units/base/measurement.rb

@@ -0,0 +1,185 @@
+module GeneralUnits
+  module Base
+    class Measurement
+      class_attribute :units unless defined?(units)
+      
+      attr_reader :amount, :unit
+      delegate :hash, :to => :attributes
+
+      def initialize(amount = 0, unit)
+        if unit = valid_unit?(unit)
+          @amount = amount.try(:to_d)||0.to_d
+          @unit = unit
+        end
+      end
+    
+      def attributes
+        {:amount => amount, :unit => unit}
+      end
+
+      def to_s(round = nil)
+        "#{to_f.divmod(1).last == 0 ? to_f.round(0) : to_f.round(round||2)}"
+      end
+      
+      def inspect
+        "<#{self.class.name} amount=#{amount} unit=#{unit}>"
+      end
+    
+      def formatted(round = nil, &block)
+        if block_given?
+          yield to_s(round), unit
+        else
+          "#{to_s(round)} #{unit.short}"          
+        end
+      end
+      
+      ### ARITHMETICS START ###
+      delegate :to_f, :to_d, :to_i, :round, :to => :amount
+    
+      def measurement
+        self.class.name.split("::").last.underscore
+      end
+    
+      def -@
+        self.class.new(-amount, unit)
+      end
+
+      def ==(other_object)
+        amount == valid_amount(other_object)
+      rescue NoMethodError
+        false
+      end
+
+      def eql?(other_object)
+        self == other_object
+      end
+
+      def <=>(other_object)
+        amount <=> valid_amount(other_object)
+      rescue NoMethodError
+        raise ArgumentError, "Comparison of #{self.class} with #{val.inspect} failed"
+      end
+      
+      def >(other_object)
+        amount > valid_amount(other_object)
+      end
+     
+      def <(other_object)
+        amount < valid_amount(other_object)
+      end
+      
+      def >=(other_object)
+        amount >= valid_amount(other_object)
+      end
+     
+      def <=(other_object)
+        amount <= valid_amount(other_object)
+      end
+    
+      def positive?
+        self > 0
+      end
+
+      def negative?
+        self < 0
+      end
+
+      def +(other_object)
+        self.class.new(amount + valid_amount(other_object), unit)
+      end
+
+      def -(other_object)
+        self.class.new(amount - valid_amount(other_object), unit)
+      end
+
+      def *(other_object)
+        self.class.new(amount * valid_amount(other_object), unit)
+      end
+
+      def /(other_object)
+        self.class.new(amount / valid_amount(other_object), unit)
+      end
+
+      def div(value)
+        amount.div(value)
+      end
+
+      def divmod(val)
+        if val.is_a?(self.class)
+          divmod_object(val)
+        else
+          divmod_other(val)
+        end
+      end
+
+      def divmod_object(val)
+        amount = val.convert_to(unit).amount
+        quotient, remainder = amount.divmod(amount)
+        [quotient, self.class.new(remainder, unit)]
+      end
+      private :divmod_object
+
+      def divmod_other(val)
+        quotient, remainder = amount.divmod(valid_amount(other_object))
+        [self.class.new(quotient, unit), self.class.new(remainder, unit)]
+      end
+      private :divmod_other
+
+      def modulo(val)
+        divmod(val)[1]
+      end
+
+      def %(val)
+        modulo(val)
+      end
+
+      def remainder(val)
+        if val.is_a?(self.class) && unit != val.unit
+          val = val.convert_to(unit)
+        end
+
+        if (amount < 0 && val < 0) || (amount > 0 && val > 0)
+          self.modulo(val)
+        else
+          self.modulo(val) - (val.is_a?(self.class) ? val : self.class.new(val, unit))
+        end
+      end
+
+      def abs
+        self.class.new(amount.abs, unit)
+      end
+
+      def zero?
+        amount == 0
+      end
+
+      def nonzero?
+        amount != 0 ? self : nil
+      end
+
+      def coerce(other)
+        [self, other]
+      end
+      ### ARITHMETICS END ###
+      
+      private
+
+      def valid_amount(other_object)
+        case other_object
+        when self.class then other_object.convert_to(unit).amount
+        when Numeric then other_object
+        else other_object.send(:"to_#{measurement}").convert_to(unit).amount
+        end
+      end
+
+      def valid_unit?(unit)
+        unit_object = case unit
+        when String, Symbol then units.find {|u| u.code.to_s == unit.to_s}
+        when Unit then unit
+        end
+        unit_object || raise(TypeError, "Unprocessable unit #{unit.inspect}")
+      end
+      
+    end
+  end
+end

data/lib/general_units/units/base/unit.rb

@@ -0,0 +1,36 @@
+module GeneralUnits
+  module Base
+    class Unit
+      METRIC_SYSTEMS = [:metric, :english, :american]
+    
+      attr_reader :code, :name, :short, :fractional, :system
+
+      def initialize(code, name, short, fractional, system = :metric)
+        @code = code
+        @name = name.to_s
+        @short = short.to_s
+        @fractional = fractional.to_d
+        @system = system.to_sym
+        METRIC_SYSTEMS.each do |s|
+          class_eval do
+            define_method "#{s}?" do
+              self.system == s
+            end
+          end
+        end
+      end
+
+      def to_s
+        name
+      end
+
+      def inspect
+        code
+      end
+    
+      def system
+        METRIC_SYSTEMS.find {|s| s == @system}
+      end
+    end
+  end
+end

data/lib/general_units/units/length.rb

@@ -1,52 +1,19 @@
-require 'general_units/units/arithmetics/methods'
-
 module GeneralUnits
-  class Length
-    ::GeneralUnits::Arithmetics.extend_class(self)
+  class Length < ::GeneralUnits::Base::Measurement
     
-    class Unit
-      attr_reader :code, :name, :short, :millimeters
-  
-      def initialize(code, name, short, millimeters)
-        @code = code
-        @name = name.to_s
-        @short = short.to_s
-        @millimeters = millimeters.to_d
-      end
-  
-      def to_s
-        name
-      end
-  
-      def inspect
-        code
-      end
+    class Unit < ::GeneralUnits::Base::Unit
+      alias :millimeters :fractional
     end
 
-    UNITS = [Unit.new(:mile_nautical, "Mile (nautical)", "mln.", 1852000.0),
-             Unit.new(:mile, "Mile", "ml.", 1609344.0),
-             Unit.new(:yard, "Yard", "yrd.", 914.4),
-             Unit.new(:foot, "Foot", "ft.", 304.8),
-             Unit.new(:inch, "Inch", "in.", 25.4),
-             Unit.new(:kilometer, "Kilometer", "km.", 1000000.0),
-             Unit.new(:meter, "Meter", "m.", 1000.0),
-             Unit.new(:centimeter, "Centimeter", "cm.", 10.0),
-             Unit.new(:millimeter, "Millimeter", "mm.", 1.0)]
-
-    attr_reader :amount, :unit
-    delegate :to_f, :to => :amount
-    delegate :hash, :to => :attributes
-    
-    def initialize(amount = 0, unit)
-      if unit = valid_unit?(unit)
-        @amount = amount.try(:to_d)||0.to_d
-        @unit = unit
-      end
-    end
-    
-    def attributes
-      {:amount => amount, :unit => unit}
-    end
+    self.units = [Unit.new(:mile_nautical, "Mile (nautical)", "mln", 1852000.0, :english),
+                  Unit.new(:mile, "Mile", "ml", 1609344.0, :english),
+                  Unit.new(:yard, "Yard", "yrd", 914.4, :english),
+                  Unit.new(:foot, "Foot", "ft", 304.8, :english),
+                  Unit.new(:inch, "Inch", "in", 25.4, :english),
+                  Unit.new(:kilometer, "Kilometer", "km", 1000000.0),
+                  Unit.new(:meter, "Meter", "m", 1000.0),
+                  Unit.new(:centimeter, "Centimeter", "cm", 10.0),
+                  Unit.new(:millimeter, "Millimeter", "mm", 1.0)]
 
     def convert_to(unit)
       if convert_unit = valid_unit?(unit)
@@ -54,27 +21,10 @@ module GeneralUnits
         Length.new(convert_amount, unit)
       end
     end
-
-    def to_s(round = nil)
-      "#{to_f.divmod(1).last == 0 ? to_f.round(0) : to_f.round(round||2)}"
-    end
     
-    def formatted(round = nil)
-      "#{to_s(round)} #{unit.short}"
-    end
-
-    def to_length
-      self
-    end
-
-    private
-
-    def valid_unit?(unit)
-      unit_object = case unit
-      when String, Symbol then UNITS.find {|u| u.code.to_s == unit.to_s}
-      when Unit then unit
-      end
-      unit_object || raise(TypeError, "Unprocessable unit #{unit.inspect}")
+    def to_volume(unit_code)
+      volume = GeneralUnits::Volume.new(amount, :"cubic_#{unit.code}")
+      unit_code ? volume.convert_to(unit_code) : volume
     end
 
   end

data/lib/general_units/units/volume.rb

@@ -0,0 +1,20 @@
+module GeneralUnits
+  class Volume < ::GeneralUnits::Base::Measurement
+    
+    class Unit < ::GeneralUnits::Base::Unit
+      alias :cubic_millimeters :fractional
+    end
+
+    self.units = Length.units.map do |unit|
+                   Unit.new("cubic_#{unit.code}", "Cubic #{unit.name}", "#{unit.short}", unit.fractional**3, unit.system)
+                 end
+
+    def convert_to(unit)
+      if convert_unit = valid_unit?(unit)
+        convert_amount = amount * @unit.cubic_millimeters/convert_unit.cubic_millimeters
+        Volume.new(convert_amount, unit)
+      end
+    end
+
+  end
+end

data/lib/general_units/units/weight.rb

@@ -1,51 +1,18 @@
-require 'general_units/units/arithmetics/methods'
-
 module GeneralUnits
-  class Weight
-    ::GeneralUnits::Arithmetics.extend_class(self)
+  class Weight < ::GeneralUnits::Base::Measurement
     
-    class Unit
-      attr_reader :code, :name, :short, :grams
-  
-      def initialize(code, name, short, grams)
-        @code = code
-        @name = name.to_s
-        @short = short.to_s
-        @grams = grams.to_d
-      end
-  
-      def to_s
-        name
-      end
-  
-      def inspect
-        code
-      end
-    end
-
-    UNITS = [Unit.new(:short_ton_us, "Short ton (US)", "Sht.", 907184.74),
-             Unit.new(:pound_us, "Pound (US)", "Pnd.", 453.59237),
-             Unit.new(:ounce_us, "Ounce (US)", "Ounce", 28.349523),
-             Unit.new(:stone, "Stone", "Stn", 6350.2932),
-             Unit.new(:long_ton_uk, "Long Ton (UK)", "Lngt.", 1016046.9),
-             Unit.new(:metric_ton, "Metric Ton", "Ton", 1000000.0),
-             Unit.new(:kilogram, "Kilogram", "Kg.", 1000.0),
-             Unit.new(:gram, "Gram", "g.", 1.0)]
-
-    attr_reader :amount, :unit
-    delegate :to_f, :to => :amount
-    delegate :hash, :to => :attributes
-
-    def initialize(amount = 0, unit)
-      if unit = valid_unit?(unit)
-        @amount = amount.try(:to_d)||0.to_d
-        @unit = unit
-      end
+    class Unit < ::GeneralUnits::Base::Unit
+      alias :grams :fractional
     end
     
-    def attributes
-      {:amount => amount, :unit => unit}
-    end
+    self.units = [Unit.new(:short_ton_us, "Short ton (US)", "Sht", 907184.74, :american),
+                  Unit.new(:pound_us, "Pound (US)", "Pnd", 453.59237, :american),
+                  Unit.new(:ounce_us, "Ounce (US)", "Ounce", 28.349523, :american),
+                  Unit.new(:stone, "Stone", "Stn", 6350.2932, :english),
+                  Unit.new(:long_ton_uk, "Long Ton (UK)", "Lngt", 1016046.9, :english),
+                  Unit.new(:metric_ton, "Metric Ton", "Ton", 1000000.0),
+                  Unit.new(:kilogram, "Kilogram", "Kg", 1000.0),
+                  Unit.new(:gram, "Gram", "g.", 1.0)]
 
     def convert_to(unit)
       if convert_unit = valid_unit?(unit)
@@ -53,28 +20,6 @@ module GeneralUnits
         Weight.new(convert_amount, unit)
       end
     end
-
-    def to_s(round = nil)
-      "#{to_f.divmod(1).last == 0 ? to_f.round(0) : to_f.round(round||2)}"
-    end
     
-    def formatted(round = nil)
-      "#{to_s(round)} #{unit.short}"
-    end
-
-    def to_weight
-      self
-    end
-
-    private
-
-    def valid_unit?(unit)
-      unit_object = case unit
-      when String, Symbol then UNITS.find {|u| u.code.to_s == unit.to_s}
-      when Unit then unit
-      end
-      unit_object || raise(TypeError, "Unprocessable unit #{unit.inspect}")
-    end
-
   end
 end

data/lib/general_units/version.rb

@@ -1,3 +1,3 @@
 module GeneralUnits
-  VERSION = "0.0.4"
+  VERSION = "0.0.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: general_units
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.7
 platform: ruby
 authors:
 - Valery Kvon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-26 00:00:00.000000000 Z
+date: 2014-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -38,14 +38,18 @@ files:
 - Rakefile
 - general_units.gemspec
 - lib/general_units.rb
+- lib/general_units/arithmetics/methods.rb
 - lib/general_units/derivatives/box.rb
+- lib/general_units/derivatives/box/packer.rb
 - lib/general_units/engine.rb
 - lib/general_units/helpers/action_view_extension.rb
 - lib/general_units/models/active_record_extension.rb
 - lib/general_units/numeric.rb
 - lib/general_units/railtie.rb
-- lib/general_units/units/arithmetics/methods.rb
+- lib/general_units/units/base/measurement.rb
+- lib/general_units/units/base/unit.rb
 - lib/general_units/units/length.rb
+- lib/general_units/units/volume.rb
 - lib/general_units/units/weight.rb
 - lib/general_units/version.rb
 homepage: http://vkvon.ru/projects/general_units

data/lib/general_units/units/arithmetics/methods.rb

@@ -1,152 +0,0 @@
-module GeneralUnits
-  
-  module Arithmetics
-    def self.extend_class(klass)
-      unit_name = klass.name.split("::").last.underscore
-      klass.class_eval <<-EOV
-        delegate :to_f, :to_d, :to_i, :to => :amount
-      
-        def -@
-          #{klass.name}.new(-amount, unit)
-        end
-
-        def ==(other_object)
-          other_object = other_object.to_#{unit_name} unless other_object.is_a?(#{klass.name})
-          amount == other_object.convert_to(unit).amount
-        rescue NoMethodError
-          false
-        end
-
-        def eql?(other_object)
-          self == other_object
-        end
-
-        def <=>(val)
-          val = val.to_#{unit_name}
-          unless amount == 0 || val.amount == 0 || unit == val.unit
-            val = val.convert_to(unit)
-          end
-          amount <=> val.amount
-        rescue NoMethodError
-          raise ArgumentError, "Comparison of #{self.class} with \#{val.inspect} failed"
-        end
-        
-        def >(other_object)
-          other_object = other_object.is_a?(#{klass.name}) ? other_object.convert_to(unit) : other_object.to_#{unit_name}
-          amount > other_object.amount
-        end
-       
-        def <(other_object)
-          other_object = other_object.is_a?(#{klass.name}) ? other_object.convert_to(unit) : other_object.to_#{unit_name}
-          amount < other_object.amount
-        end
-        
-        def >=(other_object)
-          other_object = other_object.is_a?(#{klass.name}) ? other_object.convert_to(unit) : other_object.to_#{unit_name}
-          amount >= other_object.amount
-        end
-       
-        def <=(other_object)
-          other_object = other_object.is_a?(#{klass.name}) ? other_object.convert_to(unit) : other_object.to_#{unit_name}
-          amount <= other_object.amount
-        end
-      
-        def positive?
-          amount > 0
-        end
-
-        def negative?
-          amount < 0
-        end
-
-        def +(other_object)
-          other_object = other_object.is_a?(#{klass.name}) ? other_object.convert_to(unit) : other_object.to_#{unit_name}
-          #{klass.name}.new(amount + other_object.amount, unit)
-        end
-
-        def -(other_object)
-          other_object = other_object.is_a?(#{klass.name}) ? other_object.convert_to(unit) : other_object.to_#{unit_name}
-          #{klass.name}.new(amount - other_object.amount, unit)
-        end
-
-        def *(value)
-          case value
-          when Numeric then #{klass.name}.new(amount * value, unit)
-          when #{klass.name} then #{klass.name}.new(amount * value.convert_to(unit).amount, unit)
-          else raise ArgumentError, "Can't multiply a #{klass.name} by a \#{value.class.name}'s value"
-          end
-        end
-
-        def /(value)
-          case value
-          when Numeric then #{klass.name}.new(amount / value, unit)
-          when #{klass.name} then #{klass.name}.new(amount / value.convert_to(unit).amount, unit)
-          else raise ArgumentError, "Can't divide a #{klass.name} by a \#{value.class.name}'s value"
-          end
-        end
-
-        def div(value)
-          amount.div(value)
-        end
-
-        def divmod(val)
-          if val.is_a?(#{klass.name})
-            divmod_object(val)
-          else
-            divmod_other(val)
-          end
-        end
-
-        def divmod_object(val)
-          amount = val.convert_to(unit).amount
-          quotient, remainder = amount.divmod(amount)
-          [quotient, #{klass.name}.new(remainder, unit)]
-        end
-        private :divmod_object
-
-        def divmod_other(val)
-          quotient, remainder = amount.divmod(val.to_#{unit_name}(unit).amount)
-          [#{klass.name}.new(quotient, unit), #{klass.name}.new(remainder, unit)]
-        end
-        private :divmod_other
-
-        def modulo(val)
-          divmod(val)[1]
-        end
-
-        def %(val)
-          modulo(val)
-        end
-
-        def remainder(val)
-          if val.is_a?(#{klass.name}) && unit != val.unit
-            val = val.convert_to(unit)
-          end
-
-          if (amount < 0 && val < 0) || (amount > 0 && val > 0)
-            self.modulo(val)
-          else
-            self.modulo(val) - (val.is_a?(#{klass.name}) ? val : #{klass.name}.new(val, unit))
-          end
-        end
-
-        def abs
-          #{klass.name}.new(amount.abs, unit)
-        end
-
-        def zero?
-          amount == 0
-        end
-
-        def nonzero?
-          amount != 0 ? self : nil
-        end
-
-        def coerce(other)
-          [self, other]
-        end
-      EOV
-    end
-  end
-  
-end