commerce_units 0.0.5

data/lib/commerce_units/unit.rb

@@ -0,0 +1,98 @@
+class CommerceUnits::Unit
+  class RequireOrdInstance < StandardError; end
+  class << self
+    def multiply(ua, ub)
+      new.tap do |u|
+        u.numerator = ua.numerator + ub.numerator
+        u.denominator = ua.denominator + ub.denominator
+      end.simplify
+    end
+    def divide(ua, ub)
+      multiply ua, ub.flip
+    end
+    def equals?(ua, ub)
+      divide(ua, ub).unitless?
+    end
+    def parse(string)
+      CommerceUnits::UnitParser.parse(string)
+    end
+  end
+
+  attr_reader :numerator, :denominator
+  def initialize
+    @numerator = []
+    @denominator = []
+  end
+
+  def *(other)
+    self.class.multiply self, other
+  end
+
+  def /(other)
+    self.class.divide self, other
+  end
+
+  def simplify
+    CommerceUnits::Unit.new.tap do |u|
+      u.numerator = _simplifier.numerator
+      u.denominator = _simplifier.denominator
+    end
+  end
+
+  def unitless?
+    numerator.blank? and denominator.blank?
+  end
+
+  def flip
+    CommerceUnits::Unit.new.tap do |u|
+      u.numerator = denominator
+      u.denominator = numerator
+    end
+  end
+
+  def to_root_dimension
+    CommerceUnits::Unit.new.tap do |u|
+      u.numerator = CommerceUnits.dimensional_database.from_array_of_unit_names!(numerator).map(&:root_dimension)
+      u.denominator = CommerceUnits.dimensional_database.from_array_of_unit_names!(denominator).map(&:root_dimension)
+    end
+  end
+
+  def numerator=(xs)
+    _assert_all_orderable! xs
+    @numerator = xs
+  end
+
+  def denominator=(xs)
+    _assert_all_orderable! xs
+    @denominator = xs
+  end
+
+  def ==(unit)
+    s = self.simplify
+    u = unit.simplify
+    s.numerator == u.numerator && s.denominator == u.denominator
+  end
+
+  def to_s
+    '#<CommerceUnits::Unit:' + self.object_id.to_s + " @numerator=#{numerator}, @denominator=#{denominator}>"
+  end
+
+  def pretty_inspect
+    n = numerator.join(" * ")
+    d = denominator.join(" * ")
+    n = n.blank? ? "(1)" : n
+    [n,d].reject(&:blank?).join(" / ")
+  end
+
+  private
+  def _assert_all_orderable!(xs)
+    xs.map do |x|
+      unless x.respond_to?(:<) && x.respond_to?(:>)
+        raise RequireOrdInstance, "You tried to use #{x} as a unit, but I can't do it because it's not comparable"
+      end
+    end
+  end
+  def _simplifier
+    @simplifier ||= CommerceUnits::Simplifier.new numerator: numerator, denominator: denominator
+  end
+end

data/lib/commerce_units/unit_lexer.rb

@@ -0,0 +1,67 @@
+class CommerceUnits::UnitLexer
+  class UnexpectedCharacter < StandardError; end
+  class << self
+    def tokenize(string)
+      string.split("").inject(new) do |lexer, character|
+        case character
+        when "*"
+          lexer.multiply_token
+        when "/"
+          lexer.divide_token
+        when " "
+          lexer.white_space
+        when /[a-zA-Z0-9]/
+          lexer.character character
+        else
+          raise UnexpectedCharacter, character
+        end
+      end.tokens
+    end
+  end
+  attr_accessor :tokens
+  def initialize
+    @tokens = []
+    @mode = :new_character
+  end
+  def multiply_token
+    _operator_token "*"
+  end
+  def divide_token
+    _operator_token "/"
+  end
+  def white_space
+    if :character == @mode
+      @tokens[-1] += " "
+      @mode = :space
+    end
+    self
+  end
+  def character(character)
+    case @mode
+    when :new_character
+      @tokens << character
+      @mode = :character
+    when :character, :space
+      @tokens[-1] += character
+      @mode = :character
+    else
+      raise UnexpectedCharacter, "character #{character} doesn't belong here"
+    end
+    self
+  end
+  private
+  def _operator_token(operator)
+    case @mode
+    when :character
+      @tokens << operator
+      @mode = :new_character
+    when :space
+      @tokens[-1].strip!
+      @tokens << operator
+      @mode = :new_character
+    else
+      raise UnexpectedCharacter, operator + ' should come after only units'
+    end
+    self
+  end
+end

data/lib/commerce_units/unit_parser.rb

@@ -0,0 +1,68 @@
+class CommerceUnits::UnitParser
+  class UnexpectedToken < StandardError; end
+  class << self
+    def parse(string)
+      _tokens(string).reduce_with_lookahead(new) do |parser, token, lookahead|
+        case token
+        when "*"
+          parser.multiply_token
+        when "/"
+          parser.divide_token
+        when nil
+          parser.eof_token
+        else
+          parser.units_token token
+        end
+      end.unit
+    end
+
+    private
+    def _tokens(string)
+      tokens = CommerceUnits::UnitLexer.tokenize(string)
+      tokens += [nil] if tokens.count.odd?
+      tokens
+    end
+  end
+  attr_accessor :unit
+  def initialize
+    @mode = :multiply
+    @unit = CommerceUnits::Unit.new
+  end
+  def multiply_token
+    if :units == @mode
+      @mode = :multiply
+    end
+    self
+  end
+  def divide_token
+    if :units == @mode
+      @mode = :divide
+    end
+    self
+  end
+  def eof_token
+    case @mode
+    when :multiply
+      raise UnexpectedToken, "You need to multiply by a term, not just end the file"
+    when :divide
+      raise UnexpectedToken, "You need to divide by a term, not just end the file"
+    else
+      @mode = :eof
+    end
+    self
+  end
+  def units_token(token)
+    case @mode
+    when :multiply
+      @unit *= CommerceUnits::Unit.new.tap { |u| u.numerator = [token] }
+      @mode = :units
+    when :divide
+      @unit *= CommerceUnits::Unit.new.tap { |u| u.denominator = [token] }
+      @mode = :units
+    else
+      raise UnexpectedToken, "You didn't tell me to either divide or multiply by your token: #{token}"
+    end
+    self
+  end
+end
+

data/lib/commerce_units/value.rb

@@ -0,0 +1,62 @@
+class CommerceUnits::Value
+  class << self
+    def from_params(number: number, units: units)
+      new number, CommerceUnits::UnitParser.parse(units)
+    end
+  end
+  delegate :unitless?,
+    to: :unit
+  attr_accessor :number, :unit
+  def initialize(number=nil, unit=nil)
+    @number = number
+    @unit = unit
+  end
+
+  def +(value)
+    v = _convert_units_to_match value
+    self.class.new v.number + number, unit
+  end
+
+  def -(value)
+    v = _convert_units_to_match value
+    self.class.new number - v.number, unit
+  end
+
+  def *(value)
+    self.class.new number * value.number, CommerceUnits::Unit.multiply(unit, value.unit)
+  end
+
+  def /(value)
+    self.class.new number / value.number, CommerceUnits::Unit.divide(unit, value.unit)
+  end
+
+  def flip
+    self.class.new.tap do |v|
+      v.number = 1.0 / number
+      v.unit = unit.flip
+    end
+  end
+
+  def simplify
+    CommerceUnits::TermsReducer.new(self).reduce_to_simplest_terms
+  end
+
+  def ==(value)
+    v = _convert_units_to_match value
+    number == v.number && unit == v.unit
+  end
+
+  def to_s
+    "#{number} #{unit.pretty_inspect}"
+  end
+
+  def constant?; unitless; end
+
+  private
+  def _convert_units_to_match(value)
+    CommerceUnits::Converter.new.tap do |c|
+      c.target_unit = self.unit
+      c.origin_value = value
+    end.coerce
+  end
+end

data/lib/commerce_units/version.rb

@@ -0,0 +1,3 @@
+module CommerceUnits
+  VERSION = "0.0.5"
+end

data/lib/commerce_units.rb

@@ -0,0 +1,27 @@
+require "functional_support"
+require "commerce_units/version"
+require "commerce_units/converter"
+require "commerce_units/dimension"
+require "commerce_units/simplifier"
+require "commerce_units/terms_reducer"
+require "commerce_units/unit"
+require "commerce_units/unit_lexer"
+require "commerce_units/unit_parser"
+require "commerce_units/value"
+module CommerceUnits
+  def self.table_name_prefix
+    "commerce_units_"
+  end
+  def self.dimensional_database
+    @dimensional_database ||= CommerceUnits::Dimension
+  end
+  def self.dimensional_database=(some_sort_of_class)
+    @dimensional_database = some_sort_of_class
+  end
+  def self.nt(number, unit)
+    CommerceUnits::Value.from_params number: number, unit: unit
+  end
+end
+
+# A helpful alias, but if and only if it isn't already used
+CU = CommerceUnits unless defined?(CU)

data/lib/generators/commerce_units/USAGE

@@ -0,0 +1,7 @@
+Description:
+  Generates the necessary files to get you up and running with Sorcery gem
+  
+Examples:
+  rails generate commerce_units:install
+
+    This will move the migration to create the commerce_units_dimensions table

data/lib/generators/commerce_units/install_generator.rb

@@ -0,0 +1,38 @@
+require 'rails/generators/migration'
+module CommerceUnits
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      desc "Create a migration for the dimensional storage"
+
+      source_root File.expand_path('../templates/migrations', __FILE__)
+
+      # Define the next_migration_number method (necessary for the migration_template method to work)
+      # Stolen shamelessly from socery gem's generators
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          sleep 1 # make sure each time we get a different timestamp
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          "%.3d" % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def generate_migration
+        migration_template "create_commerce_units_dimensions.rb.erb", "db/migrate/#{migration_file_name}"
+      end
+
+      def migration_name
+        "create_commerce_units_dimensions"
+      end
+
+      def migration_file_name
+        "#{migration_name}.rb"
+      end
+
+      def migration_class_name
+        migration_name.camelize
+      end
+    end
+  end
+end

data/lib/generators/commerce_units/templates/migrations/create_commerce_units_dimensions.rb.erb

@@ -0,0 +1,11 @@
+class CreateCommerceUnitsDimensions < ActiveRecord::Migration
+  def change
+    create_table :commerce_units_dimensions do |t|
+      t.string :root_dimension, null: false
+      t.string :unit_name, null: false
+      t.string :unitary_role, null: false, default: "tertiary"
+      t.decimal :multiply_constant, precision: 17, scale: 5, null: false, default: 1.0
+      t.timestamps
+    end
+  end
+end

data/spec/commerce_units/converter_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe CommerceUnits::Converter do
+  before { @lengths = CommerceUnits::LengthFactory.everything }
+  let(:centimeter) { CommerceUnits::LengthFactory.centimeter }
+  let(:meter) { CommerceUnits::LengthFactory.meter }
+  context 'factory' do
+    subject { CommerceUnits::Dimension.find_by_unit_name "centimeter" }
+    specify { should eq centimeter }
+  end
+  context '#coerce' do
+    let(:target_unit) { centimeter.to_unit }
+    let(:origin_unit) { meter.to_unit }
+    let(:origin_value) { CommerceUnits::Value.new 987, origin_unit }
+    let(:expected_value) { CommerceUnits::Value.new 98700, target_unit }
+    let(:converter) do
+      described_class.new.tap do |c|
+        c.target_unit = target_unit
+        c.origin_value = origin_value
+      end
+    end
+    subject { converter.coerce }
+    specify { should be_a CommerceUnits::Value }
+    specify { should eq expected_value }
+    context '#number' do
+      subject { converter.coerce.number }
+      specify { should be_a Numeric }
+      specify { should eq expected_value.number }
+    end
+
+    context '#unit' do
+      subject { converter.coerce.unit }
+      specify { should eq expected_value.unit }
+    end
+  end
+
+end

data/spec/commerce_units/dimension_spec.rb

@@ -0,0 +1,40 @@
+# == Schema Information
+#
+# Table name: scientific_dimensions
+#
+#  id                :integer          not null, primary key
+#  root_dimension    :string(255)      not null
+#  unit_name         :string(255)      not null
+#  unitary_role      :string(255)      default("tertiary"), not null
+#  multiply_constant :decimal(15, 5)   default(1.0), not null
+#  created_at        :datetime
+#  updated_at        :datetime
+#
+
+require 'spec_helper'
+
+describe CommerceUnits::Dimension do
+  let(:time1) { CommerceUnits::DimensionFactory.time_mock.make_primary! }
+  let(:time2) { CommerceUnits::DimensionFactory.time_mock }
+  let(:time3) { CommerceUnits::DimensionFactory.time_mock }
+  let(:time4) { CommerceUnits::DimensionFactory.time_mock }
+  let(:times) { [time1, time2, time3, time4] }
+  context '#root_dimension' do
+    specify { expect(time1.root_dimension).to eq time2.root_dimension }
+    specify { expect(time2.root_dimension).to eq time3.root_dimension }
+    specify { expect(time3.root_dimension).to eq time4.root_dimension }
+  end
+  context ':by_roots' do
+    subject { described_class.by_roots(:time) }
+    specify { should include times.first }
+    specify { should include times.second }
+    specify { should include times.third }
+    specify { should include times.last }
+  end
+  context ':primary_unit_by_roots' do
+    before { times }
+    subject { described_class.primary_unit_by_roots(:time).first }
+    specify { should eq time1 }
+  end
+
+end