measure_scaler 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b92da404900ec09dec83b7aa22f892e39bdb4a29
+  data.tar.gz: 1247474d4bdf6b08732bf4b7f8484492bdaa3923
+SHA512:
+  metadata.gz: 894b049483dd4ab06ae27f61afd7f9ffd25fa28259ea5158e94e8957b4dc22c7750acf3054e02d1dd9e2ceab58d960e22c3fcb8580e06e8a7b3bbac6e2a490a4
+  data.tar.gz: 60bdbdc710e795e533a75601058fbc8ab7bea4768559d06ee2442d14863a85acd8eb357f691b02922ee88f44794a89425682af92b4b717f86da17248521b937a

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: f2gvKLY4oblFVZqu9NCqryR2BsryRo3mT

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+cache: bundler
+
+
+rvm:
+  - jruby
+  - 1.9.3
+  - 2.0.0
+
+
+notifications:
+  email:
+    recipients:
+      - iwan.buetti@gmail.com
+    on_failure: change
+    on_success: never

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in measure_scaler.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,13 @@
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Iwan Buetti
+
+MIT License
+
+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,68 @@
+# MeasureScaler
+
+[![Build Status](https://travis-ci.org/iwan/measure_scaler.png)](https://travis-ci.org/iwan/measure_scaler)
+[![Coverage Status](https://img.shields.io/coveralls/iwan/measure_scaler.svg)](https://coveralls.io/r/iwan/measure_scaler)
+[![Code Climate](https://codeclimate.com/github/iwan/measure_scaler/badges/gpa.svg)](https://codeclimate.com/github/iwan/measure_scaler)
+
+Simple gem to deal with measure scaling.
+
+A couple of examples:
+
+```ruby
+include MeasureScaler
+
+m = Measure.new(12300.456789, "MWh")
+m.scale.to_s # => "12.300456789 GWh"
+```
+You can add precision:
+```ruby
+Measure.new(12300.456789, "MWh", 4).scale.to_s # => "12.3 GWh"
+Measure.new(12300.456789, "MWh", 5).scale.to_s # => "12.3 GWh"
+Measure.new(12300.456789, "MWh", 6).scale.to_s # => "12.3005 GWh"
+```
+
+It works with arrays too:
+```ruby
+Measure.new([20_000, 15_000, 8_934], "MWh").scale.qty # => [20.0, 15.0, 8.934]
+Measure.new([20_000, 15_000, 8_934], "MWh").scale.unit.to_s # => "GWh"
+```
+
+And works with 'reverse' unit of measure...
+```ruby
+Measure.new(12300.456789, "€/kWh", 4).scale.to_s # => "12.3 €/Wh"
+```
+
+You can define your measure pattern with regexp:
+```ruby
+PatternDefinitions.config do
+  add /^(€\/)(.?)(Wh)$/
+  add /^(.?)(Wh)$/
+end
+```
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'measure_scaler'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install measure_scaler
+
+<!-- ## Usage
+
+TODO: Write usage instructions here
+ -->
+## Contributing
+
+1. Fork it ( https://github.com/iwan/measure_scaler/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+
+# Default directory to look in is `/spec`
+# Run with `bundle exec rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'progress']
+end
+
+
+task :default => :spec

data/lib/measure_scaler.rb

@@ -0,0 +1,16 @@
+%w(
+  pattern_definitions
+  definitions
+  errors
+  prefixes
+  prefix
+  quantity_methods
+  unit
+  measure
+  version
+).each { |file| require File.join(File.dirname(__FILE__), 'measure_scaler', file) }
+
+
+module MeasureScaler
+  # Your code goes here...
+end

data/lib/measure_scaler/definitions.rb

@@ -0,0 +1,6 @@
+module MeasureScaler
+  PatternDefinitions.config do
+    add /^(€\/)(.?)(Wh)$/
+    add /^(.?)(Wh)$/
+  end
+end

data/lib/measure_scaler/errors.rb

@@ -0,0 +1,5 @@
+module MeasureScaler
+  class PrefixError < StandardError
+  
+  end
+end

data/lib/measure_scaler/measure.rb

@@ -0,0 +1,49 @@
+module MeasureScaler
+  class Measure
+    attr_reader :qty, :unit, :precision
+
+    # Measure.new(12500.34, "MWh")
+    def initialize(qty, unit, precision=nil)
+      @qty, @precision = qty, precision
+      @unit            = unit.is_a?(Unit) ? unit : Unit.new(unit)
+    end
+    
+    def scale
+      # TODO: gestisci unità non riconosciute (non valide)
+
+
+      if @unit.pattern_found?
+        ord = @qty.scaling_proposal # multipli di 3
+        ord, new_unit = @unit.scale(ord)
+        qty = @qty.scale(ord)
+        qty = precisize(qty) if @precision
+        Measure.new(qty, new_unit, @precision)
+      else
+        @qty = precisize(@qty) if @precision
+        self
+      end
+    end
+
+    def to_s
+      "#{@qty} #{@unit}"
+    end
+
+
+    private
+
+    # arg is an array or a numeric value
+    def precisize(arg)
+      if arg.is_a? Array
+        arg.map{|e| precisize_num(e)}
+      else
+        precisize_num(arg)
+      end
+    end
+
+    def precisize_num(num)
+      lg = Math.log10(num.to_f).ceil
+      (num.to_f*10**(@precision-lg)).round/(10.0**(@precision-lg))
+    end
+  end
+
+end

data/lib/measure_scaler/pattern_definitions.rb

@@ -0,0 +1,22 @@
+module MeasureScaler
+  module PatternDefinitions
+    extend self
+
+    def def_list
+      @def_list ||= Array.new
+    end
+    
+    def config(&block)
+      instance_eval(&block)
+    end
+
+    def add(regexp)
+      def_list << regexp unless def_list.include?(regexp)
+    end
+
+    def clear
+      def_list.clear
+    end
+  end
+
+end

data/lib/measure_scaler/prefix.rb

@@ -0,0 +1,41 @@
+module MeasureScaler
+  class Prefix
+    include Prefixes
+    attr_reader :symbol, :factor
+
+    def initialize(symbol)
+      validate(symbol)
+
+      @symbol = symbol
+      @factor = find_factor(symbol)
+    end
+
+    
+    def scale(proposed_order=0)
+      proposed_order = align_to_3(proposed_order)
+      # return the effective order and the new symbol
+      new_factor = [@factor+proposed_order, MAX_FACTOR].min
+      new_factor = [new_factor, MIN_FACTOR].max
+      new_symbol = find_symbol(new_factor)
+      effective_order  = new_factor - @factor
+      [effective_order, new_symbol] # TODO: perché non ritornare [new_order, Prefix.new(new_symbol)] ?
+    end
+
+    def to_s
+      @symbol
+    end
+
+    private
+    def validate(symbol)
+      raise PrefixError, "#{symbol} is not a valid prefix symbol" if !valid?(symbol)
+    end
+
+    def align_to_3(ord)
+      if ord%3==0
+        ord
+      else
+        (ord/3.0).round*3
+      end
+    end
+  end
+end

data/lib/measure_scaler/prefixes.rb

@@ -0,0 +1,35 @@
+module MeasureScaler
+  module Prefixes
+    # http://en.wikipedia.org/wiki/Metric_prefix
+
+    LIST = ["y", "z", "a", "f", "p", "n", "µ", "m", "", "k", "M", "G", "T", "P", "E", "Z", "Y"]
+    MAX_FACTOR = 24
+    MIN_FACTOR = -24
+    STEP = 3
+
+    # Get the base-10 exponent related to the symbol
+    # Example: find_factor("M") # => 6 (million)
+    def find_factor(symbol)
+      valid?(symbol) ? (LIST.index(symbol)*STEP)+MIN_FACTOR : nil
+    end
+
+    # Get the symbol related to base-10 passed
+    # The factor should be a multiple of 3, greater or equal to -24 
+    # and smaller or equal to 24
+    # Example: find_symbol(-3) # => "m" (thousandth)
+    def find_symbol(factor)
+      return nil if factor%STEP!=0 || factor<MIN_FACTOR || factor>MAX_FACTOR
+      LIST[(factor-MIN_FACTOR)/STEP]
+    end
+
+    # Is a valid symbol?
+    def valid?(symbol)
+      LIST.include?(symbol)
+    end
+
+    # Return the list of available symbols
+    def symbols_list
+      LIST
+    end
+  end
+end

data/lib/measure_scaler/quantity_methods.rb

@@ -0,0 +1,29 @@
+module MeasureScaler
+  module QuantityMethods
+    Numeric.class_eval do
+      def scaling_proposal
+        (Math.log10(self).floor/3)*3
+      end
+
+      def scale(ord) # order of magnitude
+        # TODO: raise if ord%3!=0
+        to_f/10**ord
+      end
+    end
+
+    Array.class_eval do
+      def scaling_proposal
+        a = self.map{|e| e.scaling_proposal}
+        h = Hash[a.uniq.map{|e| [e,0]}] # hash for count the proposal scale
+        a.each{|e| h[e]+=1}
+        most_freq = h.values.max
+        a = h.to_a.find_all{|e| e[1]==most_freq}.map{|e| e[0]}.sort
+        a[(a.size-1)/2] # or a[a.size/2]
+      end
+
+      def scale(ord) # order of magnitude
+        map{|e| e.scale(ord)}
+      end    
+    end
+  end
+end

data/lib/measure_scaler/unit.rb

@@ -0,0 +1,69 @@
+module MeasureScaler
+  class Unit
+    attr_reader :prefix, :preunit, :unit, :direction
+    def initialize(string_or_hash)
+      case string_or_hash
+      when String
+        decode_string(string_or_hash)
+      when Hash
+        h = {direction: 1, preunit: nil}.merge(string_or_hash)
+        @prefix    = Prefix.new(h[:prefix])
+        @preunit   = h[:preunit]
+        @unit      = h[:unit]
+        @direction = h[:direction]
+
+      else
+        raise "attribute not valid"
+      end
+    end
+
+
+    def pattern_found?
+      !@prefix.nil?
+    end
+
+    def scale(order) # order is a multiple of 3
+      definitive_order, new_prefix = @prefix.scale(order*@direction)
+      [ definitive_order*@direction, 
+        Unit.new(
+          prefix: new_prefix, 
+          preunit: @preunit, 
+          unit: @unit, 
+          direction: @direction)
+      ]
+    end
+    
+    def to_s(prefix=nil)
+      "#{@preunit}#{prefix||@prefix}#{@unit}"
+    end
+
+    private
+
+    def decode_string(s)
+      @prefix    = nil
+      @preunit   = nil
+      @unit      = nil
+      @direction = 1
+
+      s.strip!
+      PatternDefinitions.def_list.each do |regexp|
+        s.match(regexp) do |md|
+          # md is a MatchData obj
+          case md.size
+          when 3
+            @prefix  = Prefix.new(md[1]) # 
+            @unit    = md[2]          
+          when 4
+            @preunit = md[1]
+            @prefix  = Prefix.new(md[2])
+            @unit    = md[3]
+            @direction = -1 if @preunit.include?("/")
+          else
+            raise "unit string decode failed"
+          end
+          break
+        end
+      end
+    end
+  end
+end

data/lib/measure_scaler/version.rb

@@ -0,0 +1,3 @@
+module MeasureScaler
+  VERSION = "1.0.0"
+end

data/measure_scaler.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'measure_scaler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "measure_scaler"
+  spec.version       = MeasureScaler::VERSION
+  spec.authors       = ["Iwan Buetti"]
+  spec.email         = ["iwan.buetti@gmail.com"]
+  spec.summary       = "Simple gem to deal with measure scaling"
+  # spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.homepage      = "https://github.com/iwan/measure_scaler"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-remote"
+  spec.add_development_dependency "pry-nav"
+
+  spec.add_development_dependency "coveralls"
+
+end

data/spec/measure_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+include MeasureScaler
+
+RSpec.describe Measure do
+
+
+  context 'number' do
+    let(:qty1) { 12500.34 }
+    let(:unit1) { "MWh" }
+    let(:prec1) { 4 } # precision
+    let(:valid_measure1) { Measure.new(qty1, unit1) }
+    let(:valid_measure2) { Measure.new(qty1, unit1, prec1) }
+    let(:valid_measure2) { Measure.new(qty1, unit1, prec1) }
+
+    let(:valid_measure3) { Measure.new(qty1, "€/kWh") }
+    let(:valid_measure4) { Measure.new(qty1, "€/kWh", prec1) }
+
+    it 'initialize successfully' do
+      expect(valid_measure1.qty).to eq(qty1)
+      expect(valid_measure1.unit).to be_an_instance_of Unit
+      expect(valid_measure1.unit.prefix).to be_an_instance_of Prefix
+      expect(valid_measure1.unit.prefix.symbol).to eq("M")
+      expect(valid_measure1.unit.prefix.factor).to eq(6)
+      expect(valid_measure1.unit.unit).to eq("Wh")
+      expect(valid_measure1.unit.preunit).to be_nil
+      # ...
+      expect(valid_measure1.precision).to be_nil
+      expect(valid_measure2.precision).to eq(prec1)
+    end
+
+    it "initialize incorrectly" do
+    end
+
+    context 'without preunit' do
+      it "when scaled it's always a measure" do
+        expect(valid_measure1.scale).to be_an_instance_of Measure
+        expect(valid_measure2.scale).to be_an_instance_of Measure
+      end
+
+      it "scale without precision" do
+        scaled = valid_measure1.scale
+        expect(scaled.to_s).to eq("12.50034 GWh")
+      end
+
+      it "scale with precision" do
+        scaled = valid_measure2.scale
+        expect(scaled.to_s).to eq("12.5 GWh")
+        
+        expect(Measure.new(qty1, unit1, 1).scale.to_s).to eq("10.0 GWh")
+        expect(Measure.new(qty1, unit1, 2).scale.to_s).to eq("13.0 GWh")
+        expect(Measure.new(qty1, unit1, 5).scale.to_s).to eq("12.5 GWh")
+        expect(Measure.new(qty1, unit1, 6).scale.to_s).to eq("12.5003 GWh")
+        expect(Measure.new(qty1, unit1, 7).scale.to_s).to eq("12.50034 GWh")
+      end
+    end
+
+    context 'with preunit' do
+      it "when scaled it's always a measure" do
+        expect(valid_measure3.scale).to be_an_instance_of Measure
+      end
+
+      it "scale without precision" do
+        scaled = valid_measure3.scale
+        expect(scaled.to_s).to eq("12.50034 €/Wh")
+      end
+
+      it "scale with precision" do
+        scaled = valid_measure4.scale
+        expect(scaled.to_s).to eq("12.5 €/Wh")
+      end
+    end
+  end
+
+  context 'array' do
+    let(:arr1) { [12500.34, 201653.1, 5000.9] }
+    let(:unit1) { "MWh" }
+    let(:prec1) { 4 } # precision
+    let(:valid_measure1) { Measure.new(arr1, unit1) }
+    let(:valid_measure2) { Measure.new(arr1, unit1, prec1) }
+    let(:valid_measure2) { Measure.new(arr1, unit1, prec1) }
+
+    let(:valid_measure3) { Measure.new(arr1, "€/kWh") }
+    let(:valid_measure4) { Measure.new(arr1, "€/kWh", prec1) }
+
+    it 'initialize successfully' do
+      expect(valid_measure1.qty).to eq(arr1)
+      expect(valid_measure1.unit).to be_an_instance_of Unit
+      expect(valid_measure1.unit.prefix).to be_an_instance_of Prefix
+      expect(valid_measure1.unit.prefix.symbol).to eq("M")
+      expect(valid_measure1.unit.prefix.factor).to eq(6)
+      expect(valid_measure1.unit.unit).to eq("Wh")
+      expect(valid_measure1.unit.preunit).to be_nil
+      # ...
+      expect(valid_measure1.precision).to be_nil
+      expect(valid_measure2.precision).to eq(prec1)
+    end
+
+    it "initialize incorrectly" do
+    end
+
+    context 'without preunit' do
+      it "when scaled it's always a measure" do
+        expect(valid_measure1.scale).to be_an_instance_of Measure
+        expect(valid_measure2.scale).to be_an_instance_of Measure
+      end
+
+      it "scale without precision" do
+        scaled = valid_measure1.scale
+        expect(scaled.qty).to eq([12.50034, 201.6531, 5.0009])
+        expect(scaled.unit.to_s).to eq("GWh")
+      end
+
+      it "scale with precision" do
+        scaled = valid_measure2.scale
+        expect(scaled.qty).to eq([12.5, 201.7, 5.001])
+        expect(scaled.unit.to_s).to eq("GWh")        
+      end
+    end
+
+    context 'with preunit' do
+      it "when scaled it's always a measure" do
+        expect(valid_measure3.scale).to be_an_instance_of Measure
+        expect(valid_measure4.scale).to be_an_instance_of Measure
+      end
+
+      it "scale without precision" do
+        scaled = valid_measure3.scale
+        expect(scaled.qty).to eq([12.50034, 201.6531, 5.0009])
+        expect(scaled.unit.to_s).to eq("€/Wh")
+      end
+
+      it "scale with precision" do
+        scaled = valid_measure4.scale
+        expect(scaled.qty).to eq([12.5, 201.7, 5.001])
+        expect(scaled.unit.to_s).to eq("€/Wh")        
+      end
+
+    end
+  end
+end

data/spec/pattern_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+include MeasureScaler
+
+RSpec.describe PatternDefinitions do
+
+
+  it 'initialize successfully' do
+    expect(PatternDefinitions.def_list).to be_an_instance_of Array
+
+    PatternDefinitions.clear
+    expect(PatternDefinitions.def_list.size).to eq(0)
+
+    PatternDefinitions.config do
+      add /^(€\/)(.?)(Wh)$/
+      add /^(.?)(Wh)$/
+    end
+
+    expect(PatternDefinitions.def_list.size).to eq(2)
+
+    PatternDefinitions.config do
+      add /^(€\/)(.?)(Wh)$/ # <- already present
+      add /^(.?)(W)$/ #       <- new entry
+    end
+    expect(PatternDefinitions.def_list.size).to eq(3)
+
+    PatternDefinitions.clear
+    expect(PatternDefinitions.def_list.size).to eq(0)
+  end
+end

data/spec/prefix_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+include MeasureScaler
+
+RSpec.describe Prefix do
+  let(:valid_prefix) { Prefix.new("M") }
+
+  it 'initialize successfully' do
+    expect(valid_prefix).to be_an_instance_of Prefix
+    expect(valid_prefix.symbol).to eq("M")
+    expect(valid_prefix.factor).to eq(6)
+  end
+
+  it "initialize incorrectly" do
+    expect{Prefix.new("X")}.to raise_error(MeasureScaler::PrefixError)
+    expect{Prefix.new}.to raise_error
+  end
+
+  it "scale correctly" do
+    expect(valid_prefix.scale(0)).to eq([0, "M"])
+    expect(valid_prefix.scale(1)).to eq([0, "M"])
+    expect(valid_prefix.scale(2)).to eq([3, "G"])
+    expect(valid_prefix.scale(3)).to eq([3, "G"])
+    expect(valid_prefix.scale(30)).to eq([18, "Y"])
+
+    expect(valid_prefix.scale(-1)).to eq([0, "M"])
+    expect(valid_prefix.scale(-2)).to eq([-3, "k"])
+    expect(valid_prefix.scale(-3)).to eq([-3, "k"])
+    expect(valid_prefix.scale(-40)).to eq([-30, "y"])
+  end
+
+  it "scale incorrectly" do
+    
+  end
+
+  it "convert to string" do
+    expect(valid_prefix.to_s).to eq("M")
+  end
+
+
+end

data/spec/prefixes_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+include MeasureScaler
+
+RSpec.describe Prefixes do
+  class DummyClass; end
+
+  before(:all) do
+    @p = DummyClass.new
+    @p.extend Prefixes
+  end
+
+  it 'find first symbol factor' do
+    expect(@p.find_factor(Prefixes::LIST.first)).to eq(Prefixes::MIN_FACTOR)
+  end
+
+  it 'find last symbol factor' do
+    expect(@p.find_factor(Prefixes::LIST.last)).to eq(Prefixes::MAX_FACTOR)
+  end
+
+  it "doesn't find factor for invalid symbol" do
+    expect(@p.find_factor("X")).to be_nil
+  end
+
+  it 'find all symbol factor' do
+    Prefixes::LIST.each_with_index do |symbol, i|
+      factor = Prefixes::MIN_FACTOR + i*Prefixes::STEP
+      expect(@p.find_factor(symbol)).to eq(factor)
+    end
+  end
+
+  it "find all factor symbol" do
+    f = Prefixes::MIN_FACTOR
+    i = 0
+    while f<=Prefixes::MAX_FACTOR
+      expect(@p.find_symbol(f)).to eql(Prefixes::LIST[i])
+      f+=Prefixes::STEP
+      i+=1
+    end
+  end
+
+  it "doesn't find symbol for invalid factor" do
+    expect(@p.find_symbol(5)).to be_nil
+    expect(@p.find_symbol(-30)).to be_nil
+    expect(@p.find_symbol(30)).to be_nil
+  end
+
+  it "validate valid symbol" do
+    expect(@p.valid?("M")).to be_truthy
+    expect(@p.valid?("m")).to be_truthy
+    expect(@p.valid?("")).to be_truthy
+  end
+
+  it "validate non-valid symbol" do
+    expect(@p.valid?("X")).to be_falsey
+    expect(@p.valid?(nil)).to be_falsey
+  end
+
+  it "get symbols list" do
+    expect(@p.symbols_list).to eq(Prefixes::LIST)
+  end
+
+end

data/spec/quantity_methods_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+include MeasureScaler
+
+describe QuantityMethods do
+
+  context 'number' do
+    it "propose a scale" do
+      expect(2.5.scaling_proposal).to eq(0)
+      expect(25.scaling_proposal).to eq(0)
+      expect(250.scaling_proposal).to eq(0)
+      expect(999.99.scaling_proposal).to eq(0)
+      expect(1000.scaling_proposal).to eq(3)
+      expect(2500.scaling_proposal).to eq(3)
+      expect(2500000.scaling_proposal).to eq(6)
+
+      expect(0.25.scaling_proposal).to eq(-3)
+      expect(0.025.scaling_proposal).to eq(-3)
+      expect(0.0025.scaling_proposal).to eq(-3)
+      expect(0.00025.scaling_proposal).to eq(-6)
+    end
+
+    it "scale" do
+      expect(2500.scale(-3)).to eq(2500000)
+      expect(2500.scale(0)).to eq(2500)
+      expect(2500.scale(3)).to eq(2.5)
+
+      expect(0.scale(3)).to eq(0)
+    end
+  end
+
+  context 'array' do
+    it "propose a scale" do
+      expect([0.25, 1200, 34, 34214, 900, 899000].scaling_proposal).to eq(3)
+      expect([0.25, 1200, 34, 34214, 900].scaling_proposal).to eq(0)
+      expect([0.25, 1200, 34, 34214, 900, 0.01].scaling_proposal).to eq(0)
+      expect([0.25, 0.034, 0.9, 0.01].scaling_proposal).to eq(-3)
+    end
+
+    it "scale" do
+      expect([0.25, 1200, 34, 34214, 900, 899000].scale(0)).to eq([0.25, 1200, 34, 34214, 900, 899000])
+      expect([0.25, 1200, 34, 34214, 900, 899000].scale(3)).to eq([0.00025, 1.2, 0.034, 34.214, 0.9, 899])
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'coveralls'
+Coveralls.wear!
+
+
+require 'pry'
+require 'measure_scaler'

data/spec/unit_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+include MeasureScaler
+
+RSpec.describe Unit do
+  let(:valid_unit_1) { Unit.new("MWh") }
+  let(:valid_unit_2) { Unit.new("€/MWh") }
+  let(:valid_unit_3) { Unit.new(prefix: "M", preunit: "€/", unit: "Wh", direction: -1) }
+  let(:invalid_unit_1) { Unit.new("AAA") }
+  before do
+    PatternDefinitions.clear
+    PatternDefinitions.config do
+      add /^(€\/)(.?)(Wh)$/
+      add /^(.?)(Wh)$/
+    end
+
+  end
+
+  it 'initialize successfully' do
+    expect(valid_unit_1).to               be_an_instance_of Unit
+    expect(valid_unit_1.prefix).to        be_an_instance_of Prefix
+    expect(valid_unit_1.prefix.symbol).to eq("M")
+    expect(valid_unit_1.preunit).to       be_nil
+    expect(valid_unit_1.unit).to          eq("Wh")
+    expect(valid_unit_1.direction).to     eq(1)
+
+    expect(valid_unit_2).to               be_an_instance_of Unit
+    expect(valid_unit_2.prefix).to        be_an_instance_of Prefix
+    expect(valid_unit_2.prefix.symbol).to eq("M")
+    expect(valid_unit_2.preunit).to       eq("€/")
+    expect(valid_unit_2.unit).to          eq("Wh")
+    expect(valid_unit_2.direction).to     eq(-1)
+
+    expect(valid_unit_3).to               be_an_instance_of Unit
+    expect(valid_unit_3.prefix).to        be_an_instance_of Prefix
+    expect(valid_unit_3.prefix.symbol).to eq("M")
+    expect(valid_unit_3.preunit).to       eq("€/")
+    expect(valid_unit_3.unit).to          eq("Wh")
+    expect(valid_unit_3.direction).to     eq(-1)
+  end
+
+  it "fail init" do
+    expect{ Unit.new(2)}.to raise_error
+    expect(invalid_unit_1).to               be_an_instance_of Unit
+    expect(invalid_unit_1.prefix).to        be_nil
+    expect(invalid_unit_1.preunit).to       be_nil
+    expect(invalid_unit_1.unit).to          be_nil
+    expect(invalid_unit_1.direction).to     eq(1)
+  end
+
+  it "does find pattern" do
+    expect(valid_unit_1.pattern_found?).to be_truthy
+  end
+
+  it "doesn't find pattern" do
+    expect(invalid_unit_1.pattern_found?).to be_falsey
+  end
+
+  it "scale correctly" do
+    def_order, new_unit = valid_unit_1.scale(3)
+    expect(def_order).to eq(3)
+    expect(new_unit).to be_an_instance_of Unit
+    expect(new_unit.prefix).not_to eq(valid_unit_1.prefix)
+    expect(new_unit.preunit).to eq(valid_unit_1.preunit)
+    expect(new_unit.unit).to eq(valid_unit_1.unit)
+    expect(new_unit.direction).to eq(valid_unit_1.direction)
+
+    def_order, new_unit = valid_unit_2.scale(3)
+    expect(def_order).to eq(3)
+    expect(new_unit).to be_an_instance_of Unit
+    expect(new_unit.prefix).not_to eq(valid_unit_2.prefix)
+    expect(new_unit.preunit).to eq(valid_unit_2.preunit)
+    expect(new_unit.unit).to eq(valid_unit_2.unit)
+    expect(new_unit.direction).to eq(valid_unit_2.direction)
+
+  end
+
+end

data/usage/usage01.rb

@@ -0,0 +1,21 @@
+require_relative '../lib/measure_scaler'
+
+
+m = MeasureScaler::Measure.new(12300.456789, "MWh", 4)
+puts m.inspect
+puts m.to_s
+# puts m.unit.inspect
+m2 = m.scale
+puts m2.inspect
+puts m2.to_s
+# puts m.scale
+
+puts "--------------------------"
+
+puts MeasureScaler::Measure.new(12300.456789, "€/kWh", 4).scale.to_s
+
+puts "--------------------------"
+
+include MeasureScaler
+puts Measure.new(12300.456789, "€/kWh").scale.to_s
+

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: measure_scaler
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Iwan Buetti
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-nc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-remote
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- iwan.buetti@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/measure_scaler.rb
+- lib/measure_scaler/definitions.rb
+- lib/measure_scaler/errors.rb
+- lib/measure_scaler/measure.rb
+- lib/measure_scaler/pattern_definitions.rb
+- lib/measure_scaler/prefix.rb
+- lib/measure_scaler/prefixes.rb
+- lib/measure_scaler/quantity_methods.rb
+- lib/measure_scaler/unit.rb
+- lib/measure_scaler/version.rb
+- measure_scaler.gemspec
+- spec/measure_spec.rb
+- spec/pattern_spec.rb
+- spec/prefix_spec.rb
+- spec/prefixes_spec.rb
+- spec/quantity_methods_spec.rb
+- spec/spec_helper.rb
+- spec/unit_spec.rb
+- usage/usage01.rb
+homepage: https://github.com/iwan/measure_scaler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Simple gem to deal with measure scaling
+test_files:
+- spec/measure_spec.rb
+- spec/pattern_spec.rb
+- spec/prefix_spec.rb
+- spec/prefixes_spec.rb
+- spec/quantity_methods_spec.rb
+- spec/spec_helper.rb
+- spec/unit_spec.rb
+has_rdoc: