general_units 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d17a99db7ba421efff46a40e27aec25b67f0e44c
-  data.tar.gz: ea9bab404d037a00f20aeecb31dd3c1f1efbc783
+  metadata.gz: ee405e53d489845a7239d7301ff0d582caac6565
+  data.tar.gz: 38c046bb71f0908432f04d0be231c3c2214793a4
 SHA512:
-  metadata.gz: 27da9ec610f978d90dce1ad760fd747e4b82f22fdf2a6043e8892bcb47353293734e8d0030a8030780d9c450120df3c2cf3e8b5d94f4e1c06bc9b70e0e64cd5f
-  data.tar.gz: 98ee8f29fa85e44dcd98e834943472f24c64cb4cb48778d93a11c5fc91f0d6e7b4d6064ee9e31e724b5de02ab9885240f72e1fb4f68ba9dc9c23771a13e4d763
+  metadata.gz: 36399caf5fef89a3d11771717d96d91031e986b5fc729f0443b34635fd17dd358990cb9d5bf7877ec38e3fad50976c8c934426c0634a34c586397e34909c58f7
+  data.tar.gz: bee9e5c75aa9f697e56f488d64a1173c58a9f2dff345ee0a8c1f2e7fb9cc537fac1df4fafa30ca054ba8239525380bfb5370745aaa7b3cee0754d5ad7774afc8

data/.gitignore

@@ -1,17 +1,5 @@
+.DS_Store
 *.gem
-*.rbc
 .bundle
-.config
-.yardoc
 Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
+pkg/*

data/lib/general_units/derivatives/box.rb

@@ -0,0 +1,163 @@
+require 'general_units/units/length'
+
+module GeneralUnits
+  
+  class Box
+  
+    VALUES = %w{length width height}
+  
+    attr_reader *VALUES, :unit
+  
+    def initialize(length = 0, width = 0, height = 0, unit)
+      VALUES.each {|v| instance_variable_set(:"@#{v}", validate_value(eval(v), unit))}
+      @unit = @height.unit
+    end
+  
+    def values
+      VALUES.map {|v| self.send(v)}
+    end
+  
+    def amount
+      length * width * height
+    end
+  
+    def convert_to(unit)
+      Box.new(*values.map {|v| v.convert_to(unit).amount}, unit)
+    end
+
+    def to_s(round = 2)
+      "#{values.map(&:to_f).map {|f| f.round(round)}.join("x")} #{unit.short}"
+    end
+    
+    def accommodates?(*boxes)
+      boxes.map! {|box| validate_capacity(box)}
+      boxes.sum(&:amount) < amount && includes?(Box.new(boxes.map(&:length).max, boxes.map(&:width).max, boxes.map(&:height).max, unit))
+    end
+  
+    def same_size?(other_object)
+      other_object = validate_capacity(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)
+      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 ###
+  
+    def -@
+      Box.new(*values.map {|v| -v}, unit)    
+    end
+  
+    def ==(other_object)
+      other_object = validate_capacity(other_object)
+      length == other_object.length && width == other_object.width && height == other_object.height
+    end
+
+    def eql?(other_object)
+      self == other_object
+    end
+
+    def <=>(val)
+      other_object = validate_capacity_or_length(other_object)
+      amount <=> case other_object
+      when Length then other_object
+      when Box then other_object.amount
+      end
+    end
+
+    def >(other_object)
+      other_object = validate_capacity_or_length(other_object)
+      amount > case other_object
+      when Length then other_object
+      when Box then other_object.amount
+      end
+    end
+ 
+    def <(other_object)
+      other_object = validate_capacity_or_length(other_object)
+      amount < case other_object
+      when Length then other_object
+      when Box then other_object.amount
+      end
+    end
+  
+    def >=(other_object)
+      other_object = validate_capacity_or_length(other_object)
+      amount >= case other_object
+      when Length then other_object
+      when Box then other_object.amount
+      end
+    end
+ 
+    def <=(other_object)
+      other_object = validate_capacity_or_length(other_object)
+      amount <= case other_object
+      when Length then other_object
+      when Box then other_object.amount
+      end
+    end
+
+    delegate :positive?, :negative?, :to => :amount
+  
+    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 Box then Box.new(*VALUES.map {|v| eval(v) + other_object.send(v)}, unit)
+      end
+    end
+  
+    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 Box then Box.new(*VALUES.map {|v| eval(v) - other_object.send(v)}, unit)
+      end
+    end
+  
+    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 Box then Box.new(*VALUES.map {|v| eval(v) * other_object.send(v)}, unit)
+      end
+    end
+  
+    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 Box then Box.new(*VALUES.map {|v| eval(v) / other_object.send(v)}, unit)
+      end
+    end
+  
+    delegate :div, :divmod, :modulo, :%, :remainder, :abs, :zero?, :nonzero?, :coerce, :to => :amount
+  
+    ### ARITHMETICS END ###
+  
+    private
+  
+    def validate_value(val, unit)
+      val.is_a?(Length) ? val.convert_to(unit) : Length.new(val, unit)
+    end
+  
+    def validate_capacity(val)
+      case val
+      when Box then val.convert_to(unit)
+      else raise(TypeError, "Box required, #{val.class} passed.")
+      end
+    end
+  
+    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.")
+      end
+    end
+  
+  end
+  
+end

data/lib/general_units/engine.rb

@@ -0,0 +1,4 @@
+module GeneralUnits #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/general_units/helpers/action_view_extension.rb

@@ -0,0 +1,11 @@
+module GeneralUnits
+
+  module ActionViewExtension
+    extend ActiveSupport::Concern
+  
+    included do
+    end
+    
+  end
+  
+end

data/lib/general_units/models/active_record_extension.rb

@@ -0,0 +1,11 @@
+module GeneralUnits
+
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+  
+    module ClassMethods
+    end
+    
+  end
+
+end

data/lib/general_units/numeric.rb

@@ -0,0 +1,11 @@
+class Numeric
+
+  def to_weight(unit = :gram)
+    GeneralUnits::Weight.new(self, unit)
+  end
+  
+  def to_length(unit = :millimeter)
+    GeneralUnits::Length.new(self, unit)
+  end
+
+end

data/lib/general_units/railtie.rb

@@ -0,0 +1,17 @@
+require 'rails'
+
+module GeneralUnits
+  class Railtie < ::Rails::Railtie
+    config.before_initialize do
+      ActiveSupport.on_load :active_record do
+        require 'general_units/models/active_record_extension'
+        include ActiveRecordExtension
+      end
+      ActiveSupport.on_load :action_view do
+        require 'general_units/helpers/action_view_extension'
+        include ActionViewExtension
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,152 @@
+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

data/lib/general_units/units/length.rb

@@ -0,0 +1,73 @@
+require 'general_units/units/arithmetics/methods'
+
+module GeneralUnits
+  class Length
+    ::GeneralUnits::Arithmetics.extend_class(self)
+    
+    class Unit
+      attr_reader :name, :short, :millimeters
+  
+      def initialize(name, short, millimeters)
+        @name = name.to_s
+        @short = short.to_s
+        @millimeters = millimeters.to_d
+      end
+  
+      def to_s
+        name
+      end
+  
+      def inspect
+        "\"#{name}\""
+      end
+    end
+
+    UNITS = {:mile_nautical => Unit.new("Mile (nautical)", "mln.", 1852000.0),
+             :mile => Unit.new("Mile", "ml.", 1609344.0),
+             :yard => Unit.new("Yard", "yrd.", 914.4),
+             :foot => Unit.new("Foot", "ft.", 304.8),
+             :inch => Unit.new("Inch", "in.", 25.4),
+             :kilometer => Unit.new("Kilometer", "km.", 1000000.0),
+             :meter => Unit.new("Meter", "m.", 1000.0),
+             :centimeter => Unit.new("Centimeter", "cm.", 10.0),
+             :millimeter => Unit.new("Millimeter", "mm.", 1.0)}
+
+    attr_reader :amount, :unit
+    delegate :to_f, :to => :amount
+    
+    def initialize(amount = 0, unit)
+      if unit = valid_unit?(unit)
+        @amount = amount.try(:to_d)||0.to_d
+        @unit = unit
+      end
+    end
+
+    def convert_to(unit)
+      if convert_unit = valid_unit?(unit)
+        convert_amount = amount * @unit.millimeters/convert_unit.millimeters
+        Length.new(convert_amount, unit)
+      end
+    end
+
+    def to_s(round = 2)
+      "#{to_f.round(round)} #{unit.short}"
+    end
+
+    def to_length
+      self
+    end
+
+    private
+
+    def valid_unit?(unit)
+      unit_object = case unit
+      when String then UNITS[unit.to_sym]
+      when Symbol then UNITS[unit]
+      when Unit then unit
+      else UNITS[unit.to_s.to_sym]
+      end
+      unit_object || raise(TypeError, "Unprocessable unit #{unit.inspect}")
+    end
+
+  end
+end

data/lib/general_units/units/weight.rb

@@ -0,0 +1,72 @@
+require 'general_units/units/arithmetics/methods'
+
+module GeneralUnits
+  class Weight
+    ::GeneralUnits::Arithmetics.extend_class(self)
+    
+    class Unit
+      attr_reader :name, :short, :grams
+  
+      def initialize(name, short, grams)
+        @name = name.to_s
+        @short = short.to_s
+        @grams = grams.to_d
+      end
+  
+      def to_s
+        name
+      end
+  
+      def inspect
+        "\"#{name}\""
+      end
+    end
+
+    UNITS = {:short_ton_us => Unit.new("Short ton (US)", "Sht.", 907184.74),
+             :pound_us => Unit.new("Pound (US)", "Pnd.", 453.59237),
+             :ounce_us => Unit.new("Ounce (US)", "Ounce", 28.349523),
+             :stone => Unit.new("Stone", "Stn", 6350.2932),
+             :long_ton_uk => Unit.new("Long Ton (UK)", "Lngt.", 1016046.9),
+             :metric_ton => Unit.new("Metric Ton", "Ton", 1000000.0),
+             :kilogram => Unit.new("Kilogram", "Kg.", 1000.0),
+             :gram => Unit.new("Gram", "g.", 1.0)}
+
+    attr_reader :amount, :unit
+    delegate :to_f, :to => :amount
+
+    def initialize(amount = 0, unit)
+      if unit = valid_unit?(unit)
+        @amount = amount.try(:to_d)||0.to_d
+        @unit = unit
+      end
+    end
+
+    def convert_to(unit)
+      if convert_unit = valid_unit?(unit)
+        convert_amount = amount * @unit.grams/convert_unit.grams
+        Weight.new(convert_amount, unit)
+      end
+    end
+
+    def to_s(round = 2)
+      "#{to_f.round(round)} #{unit.short}"
+    end
+
+    def to_weight
+      self
+    end
+
+    private
+
+    def valid_unit?(unit)
+      unit_object = case unit
+      when String then UNITS[unit.to_sym]
+      when Symbol then UNITS[unit]
+      when Unit then unit
+      else UNITS[unit.to_s.to_sym]
+      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.1"
+  VERSION = "0.0.2"
 end

data/lib/general_units.rb

@@ -4,6 +4,7 @@ module GeneralUnits
   def self.load!
     load_units!
     load_numeric!
+    load_derivatives!
     require 'general_units/engine'
     require 'general_units/railtie'
   end
@@ -16,6 +17,10 @@ module GeneralUnits
   def self.load_numeric!
     require 'general_units/numeric'
   end
+  
+  def self.load_derivatives!
+    require 'general_units/derivatives/box'
+  end
 
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: general_units
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Valery Kvon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-10 00:00:00.000000000 Z
+date: 2014-03-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -38,6 +38,15 @@ files:
 - Rakefile
 - general_units.gemspec
 - lib/general_units.rb
+- lib/general_units/derivatives/box.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/length.rb
+- lib/general_units/units/weight.rb
 - lib/general_units/version.rb
 homepage: http://vkvon.ru/projects/general_units
 licenses: