okei 0.0.2 → 1.0.0.pre.rc

data/app/models/okei/words.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module Okei
-
-  # Breaks the source string to words properly:
-  #
-  #   Words.new "М3 96% ЧИСТОГО СПИРТА /ЧЕЛ"
-  #   # => ["М", "^", "3", "96", "%", "ЧИСТОГО", "СПИРТА", "/", "ЧЕЛ"]
-  #
-  class Words < Array
-
-    def initialize(line = "")
-      @line = line.to_s
-      super @line.scan(/[А-Я]+|\d+.\d+|\d+|\/|\^|\%/)
-    end
-
-    # Maps words back to `Words` (not a base `Array`):
-    #
-    #   ["9.8", "М", "/", "С", "^", "2"].map { |i| i }.class
-    #   # => Words
-    #
-    # The method can be combined with `to_s`:
-    #
-    #   ["9.8", "М", "/", "С", "^", "2"].map { |i| i.lower }.to_s
-    #   # => "9.8 м/с2"
-    #
-    def map
-      Words.new super
-    end
-
-    # Joins words back to string when necessary:
-    #
-    #   ["М", "^", "3", "96", "ПРОЦ", "ЧИСТОГО", "СПИРТА", "/", "ЧЕЛ"].to_s
-    #   # => "М3 96 ПРОЦ ЧИСТОГО СПИРТА/ЧЕЛ"
-    #
-    def to_s
-      join(" ").gsub(" ^ ", "").gsub(" / ", "/")
-    end
-  end
-end

data/db/migrate/20141004212501_populate_okei_units.rb

@@ -1,14 +0,0 @@
-# Populates db with units of measure.
-class PopulateOkeiUnits < ActiveRecord::Migration
-  
-  def up
-    root = File.dirname File.dirname(Okei::Engine.called_from)
-    seed = File.join(root, "db", "seeds", "units.json")
-    Okei::Unit.delete_all
-    JSON.parse(File.read seed).each { |item| Okei::Unit.create! item }
-  end
-
-  def down
-    Okei::Unit.delete_all
-  end
-end

data/db/migrate/20141004212502_create_okei_words.rb

@@ -1,11 +0,0 @@
-# Creates db table for a dictionary of words used in unit names.
-class CreateOkeiWords < ActiveRecord::Migration
-  def change
-    create_table :okei_words do |t|
-      t.string :synonym
-      t.string :text
-    end
-
-    add_index :okei_words, :synonym, unique: true
-  end
-end

data/db/migrate/20141004212503_populate_okei_words.rb

@@ -1,15 +0,0 @@
-# Populates db with dictionary of words and phrases used in unit names.
-class PopulateOkeiWords < ActiveRecord::Migration
-  
-  def up
-    root = File.dirname File.dirname(Okei::Engine.called_from)
-    seed = File.join(root, "db", "seeds", "words.json")
-    JSON.parse(File.read seed).each do |synonym, text|
-      Okei::Word.create synonym: synonym, text: text
-    end
-  end
-
-  def down
-    Okei::Word.delete_all
-  end
-end

data/spec/factories/words.rb

@@ -1,7 +0,0 @@
-# encoding: utf-8
-FactoryGirl.define do
-  factory :word, class: Okei::Word do
-    sequence(:synonym) { |n| "ЕДИНИЦА#{ n }" }
-    sequence(:text)    { |n| "ЕД#{ n }" }
-  end
-end

data/spec/models/okei/line_spec.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-
-module Okei
-  describe Line do
-
-    describe ".new" do
-
-      # ========================================================================
-      # Matchers
-      # ========================================================================
-
-      RSpec::Matchers.define :turn_to do |line|
-        match do |str|
-          expect(Line.new str).to eq line
-        end
-        failure_message do |str|
-          "#{ str } should turn to #{ line }. #{ Line.new str } given."
-        end
-      end
-
-      # ========================================================================
-      # Tests
-      # ========================================================================
-
-      it "returns a string" do
-        expect(Line.new).to be_kind_of String
-      end
-
-      specify { expect("усл метр/сек^2").to turn_to "УСЛ МЕТР/СЕК ^ 2" }
-      specify { expect("100   М").to turn_to "100 М" }
-      specify { expect("0,1КМ").to turn_to "0.1КМ" }
-      specify { expect("М.1").to turn_to "М 1" }
-      specify { expect("М2").to turn_to "М ^ 2" }
-      specify { expect("М 2").to turn_to "М ^ 2" }
-      specify { expect("М.2").to turn_to "М ^ 2" }
-      specify { expect("М. 2").to turn_to "М ^ 2" }
-      specify { expect("М^2").to turn_to "М ^ 2" }
-      specify { expect("М3").to turn_to "М ^ 3" }
-      specify { expect("М 3").to turn_to "М ^ 3" }
-      specify { expect("М.3").to turn_to "М ^ 3" }
-      specify { expect("М. 3").to turn_to "М ^ 3" }
-      specify { expect("М^3").to turn_to "М ^ 3" }
-      specify { expect("М.4").to turn_to "М 4" }
-      specify { expect("ТЫС. Ч").to turn_to "ТЫС Ч" }
-      specify { expect("ТЫС. Ч.").to turn_to "ТЫС Ч" }
-      specify { expect(".ТЫС .Ч").to turn_to "ТЫС Ч" }
-      specify { expect("в 20-фут.экв.").to turn_to "В 20 ФУТ ЭКВ" }
-      specify { expect("METP B ЧAC").to turn_to "МЕТР В ЧАС" }
-      specify { expect("ГЕКТОЛИТР").to turn_to "ГЕКТО ^ ЛИТР" }
-      specify { expect("КИЛОЛИТР").to turn_to "КИЛО ^ ЛИТР" }
-      specify { expect("МИЛЛИЛИТР").to turn_to "МИЛЛИ ^ ЛИТР" }
-      specify { expect("МЕГАЛИТР").to turn_to "МЕГА ^ ЛИТР" }
-      specify { expect("САНТИЛИТР").to turn_to "САНТИ ^ ЛИТР" }
-      specify { expect("МИКРОЛИТР").to turn_to "МИКРО ^ ЛИТР" }
-      specify { expect("ТЕРАЛИТР").to turn_to "ТЕРА ^ ЛИТР" }
-      specify { expect("НАНОЛИТР").to turn_to "НАНО ^ ЛИТР" }
-      specify { expect("40%-НОГО СПИРТА").to turn_to "40% СПИРТА" }
-    end
-  end
-end

data/spec/models/okei/word_spec.rb

@@ -1,75 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-
-module Okei
-  describe Word do
-
-    describe "#synonym=" do
-
-      subject(:word) { Word.new }
-
-      it "sets #synonym" do
-        value = "МЕТР"
-        expect { word.synonym = value }.to change { word.synonym }.to value
-      end
-    end
-
-    describe "#text=" do
-
-      subject(:word) { Word.new }
-
-      it "sets #text" do
-        value = "М"
-        expect { word.text = value }.to change { word.text }.to value
-      end
-    end
-
-    describe "#valid?" do
-
-      subject(:word) { build :word }
-
-      before { expect(word).to be_valid }
-
-      it "fails when #synonym is absent" do
-        word.synonym = ""
-        expect(word).not_to be_valid
-      end
-
-      it "fails when #synonym is taken" do
-        create :word, synonym: word.synonym
-        expect(word).not_to be_valid
-      end
-
-      it "fails when #text is absent" do
-        word.text = ""
-        expect(word).not_to be_valid
-      end
-
-      it "passes when #text is taken" do
-        create :word, text: word.text
-        expect(word).to be_valid
-      end
-    end
-
-    describe ".translate" do
-
-      let!(:line) { "ТЕКСТ" }
-
-      context "when word exists" do
-
-        let!(:word) { create :word, synonym: line }
-
-        it "translates line" do
-          expect(Word.translate line).to eq word.text
-        end
-      end
-
-      context "when word is absent" do
-
-        it "returns the source" do
-          expect(Word.translate line).to eq line
-        end
-      end
-    end
-  end
-end

data/spec/models/okei/words_spec.rb

@@ -1,64 +0,0 @@
-# encoding: utf-8
-require "spec_helper"
-
-module Okei
-  describe Words do
-
-    describe ".new" do
-
-      RSpec::Matchers.define :have_words do |list|
-        match do |text|
-          expect(Words.new text).to eq list
-        end
-        failure_message do |text|
-          "#{ text } should have words #{ list }." \
-          " #{ Words.new text } given."
-        end
-      end
-
-      it "returns list of words" do
-        expect(Words.new).to be_kind_of Array
-      end
-
-      specify { expect("УСЛ МЕТР/СЕК^2").to have_words %w(УСЛ МЕТР / СЕК ^ 2) }
-      specify { expect("100   М").to have_words %w(100 М) }
-      specify { expect("2ШТ").to have_words %w(2 ШТ) }
-      specify { expect("1000КМ").to have_words %w(1000 КМ) }
-      specify { expect("0.1КМ").to have_words %w(0.1 КМ) }
-      specify { expect("М1").to have_words %w(М 1) }
-      specify { expect("М.1").to have_words %w(М 1) }
-      specify { expect("М4").to have_words %w(М 4) }
-      specify { expect("М.4").to have_words %w(М 4) }
-      specify { expect("ТЫС. Ч").to have_words %w(ТЫС Ч) }
-      specify { expect("ТЫС. Ч.").to have_words %w(ТЫС Ч) }
-      specify { expect(".ТЫС .Ч").to have_words %w(ТЫС Ч) }
-      specify { expect("90%").to have_words %w(90 %) }
-    end
-
-    describe "#map" do
-
-      subject(:words) { Words.new("M") }
-
-      it "should return a Words object" do
-        expect(subject.map { |word| word }).to be_kind_of Words
-      end
-    end
-
-    describe "#to_s" do
-
-      RSpec::Matchers.define :shape_into do |text|
-        match do |words|
-          expect(Words.new(words).to_s).to eq text
-        end
-        failure_message do |words|
-          "'#{ words }' should shape into '#{ text }'." \
-          " '#{ Words.new(words) }' given."
-        end
-      end
-
-      specify { expect("К ^ М ^ 2").to shape_into "КМ2" }
-      specify { expect("КМ / С").to shape_into "КМ/С" }
-      specify { expect("КИЛОМ").to shape_into "КИЛОМ" }
-    end
-  end
-end

data/spec/support/initializers/factory_girl.rb

@@ -1,6 +0,0 @@
-# Add factory girl syntax
-require "factory_girl"
-
-RSpec.configure do |config|
-  config.include FactoryGirl::Syntax::Methods
-end