dictable 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '012759946bfcad31c242d510beaefdee1cf8508cbd9ec33aa6de60d681c0d823'
-  data.tar.gz: f33ef1f5cc079d1e21cbb06ae546ffaac3736066af62ef36b9d3af6809a44067
+  metadata.gz: 5bce84832eecc44c3b43987ab5a20d95fad7b135f5b14febd2e0cccccb414654
+  data.tar.gz: f02c799cf5ee3928c6d26adac75f9c84bbc02a335cb8d89579e90cbd605152fb
 SHA512:
-  metadata.gz: 1c98192e82814e00163eb10f85703300c55d4c75623c31599544da70cebadf4985c3c04a5c36cad9aaef1ca2c31f06a83361ff38bb34aea5b6502ce86fba5ea5
-  data.tar.gz: b4b48b2ac632a3115aa38bb62038a2354de1540f1ec6b27ba6f3675b8dffb71c9f4aab7751454b95742bc162dd035a4ff3590fcd58ad7cf77bddbd4210b6b635
+  metadata.gz: 1c8d79925d5b9495fb525c0d5d0c141aca3667c73ef37ae0f203a434f93e151fa30577e963463edf6b2b44572af712182c3acd0d78d44943b996764713acd275
+  data.tar.gz: f98accf83447ec44cd1162a5bd5b07b2ecd0b1bca26d4d1f957a47cab0285805b47ab097cce742f565a79595b3890163eaf2bc6155b0d456c7d129e4ef8e3a7d

data/CHANGELOG.md

@@ -24,4 +24,14 @@
 ## [0.1.4] - 2024-01-14
 
 - Refactor to use instance methods to avoid exposing so many
-- Added rubocop and fixed all errors
+- Added rubocop and fixed all errors
+
+## [0.1.5] - 2024-03-01
+
+- Refactor to simplify
+- Supporting leading zeroes is out of scope
+- Added dictionaries to explode address abbreviations
+
+## [0.1.6] - 2024-03-01
+
+- Fix issue with dictionaries not loading when importing the gem in another project

data/README.md

@@ -1,6 +1,10 @@
 # Dictable
 
-GitHub Copilot: Dictable is an opinionated Ruby gem designed to convert numbers into their spoken equivalents. This gem is particularly useful in situations where precise verbal communication of numbers is required, such as during phone calls or dictation. It makes certain decisions about the "best" way to pronounce numbers, which may be subject to debate.
+Ever encountered the challenge of ensuring your text-to-speech applications pronounce addresses just the way most people in the U.S. do? Dictable is here to bridge that gap. This Ruby Gem transforms addresses like `1234 N Lasalle Ave` into their spoken-word equivalents, such as `twelve thirty four north lasalle avenue`, optimizing them for clear and natural dictation.
+
+Our approach to converting numbers into words is opinionated and intentionally avoids frequent use of "hundred" and "thousand" unless common usage dictates otherwise. The goal? To closely replicate the nuanced way addresses are articulated in everyday conversation across the U.S. Dive into the examples from our tests to see the difference in action.
+
+In a landscape where text-to-voice platforms each have their unique way of pronouncing numbers, as of March 2024, Dictable hands you the reins for more consistent and predictable address dictation.
 
 ## Installation
 
@@ -29,27 +33,49 @@ To use Dictable, simply call the `to_dictable` method on any `Integer`, this con
 ```ruby
 require 'dictable'
 
-puts 123.to_dictable
-# Output: "one twenty three"
+puts Dictable.address('2300 N Lincoln Park St')
+# > 'twenthy three hundred North Lincoln Park Street'
 
-puts "1243".to_dictable_number
-# Output: "twelve forty three"
 ```
 
 ## Example
-List of samples from specs:
-
-- `100` is converted to `one hundred`
-- `123` is converted to `one twenty three`
-- `'001'` is converted to `zero zero one`
-- `'010'` is converted to `zero ten`
-- `'0000'` is converted to `zero zero zero zero`
-- `1000` is converted to `one thousand`
-- `4321` is converted to `forty three twenty one`
-- `4300` is converted to `forty three hundred`
-- `'0001'` is converted to `zero zero zero one`
-- `'0010'` is converted to `zero zero ten`
-- `'0100'` is converted to `zero one hundred`
+List of samples from specs for addresses:
+
+```
+Dictable::StreetName
+  converts 1234 N Lasalle Ave to 1234 north lasalle avenue
+  converts 1234 E Chelsea Rd to 1234 east chelsea road
+  converts 1234 s Chelsea st to 1234 south chelsea street
+  converts 1234 w Chelsea Blvd to 1234 west chelsea boulevard
+  converts 1234 N Clifford Dr to 1234 north clifford drive
+  converts 1234 E Chelsea Ct to 1234 east chelsea court
+  converts 1234 S Chelsea pl to 1234 south chelsea place
+  converts 1234 S Chelsea Pl Gandalf to 1234 south chelsea place gandalf
+  converts 1234 W Chelsea Ter to 1234 west chelsea terrace
+
+Dictable::StreetNumber
+  converts 0 to zero
+  converts 5 to five
+  converts 10 to ten
+  converts 21 to twenty one
+  converts 100 to one hundred
+  converts 103 to one hundred three
+  converts 303 to three hundred three
+  converts 123 to one twenty three
+  converts 323 to three twenty three
+  converts 1000 to one thousand
+  converts 4321 to forty three twenty one
+  converts 4300 to forty three hundred
+  converts 1900 to nineteen hundred
+  converts 32323 to thirty two three twenty three
+
+Dictable
+  #address
+    converts 1234 N Lasalle Ave to twelve thirty four north lasalle avenue
+    converts 123 S Lasalle rd to one twenty three south lasalle road
+    converts 1500 s Lasalle Rd to fifteen hundred south lasalle road
+
+```
 
 Please note that the numbers in quotes are treated as strings, which allows leading zeroes to be preserved.
 
@@ -63,4 +89,4 @@ Bug reports and pull requests are welcome on GitHub. This project aims to be a s
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/dictable.gemspec

@@ -8,9 +8,11 @@ Gem::Specification.new do |spec|
   spec.authors = ['Matias Verges']
   spec.email = ['matis@matis.io']
 
-  spec.summary = 'Transform numbers into words to dictate them easily.'
-  spec.description = 'Transform numbers into words to dictate them easily.' \
-                     "For example 1234 becomes twelve thirty four and 123456 becomes 'one two three, four five six'"
+  spec.summary = 'Transform street numbers into words to dictate them easily, and explodes street names abbreviations.'
+  spec.description =
+    'Transform street numbers into words to dictate them easily, and explodes street names abbreviations.' \
+    "For example 1234 becomes twelve thirty four and 123456 becomes 'one two three, four five six'"
+
   spec.homepage = 'https://github.com/matismasters/dictable'
   spec.required_ruby_version = '>= 2.6.0'
 

data/dictionaries/en/address_abbreviations_exploded.yml

@@ -0,0 +1,206 @@
+---
+n: north
+s: south
+e: east
+w: west
+aly: alley
+anx: anex
+arc: arcade
+ave: avenue
+byu: bayou
+bch: beach
+bnd: bend
+blf: bluff
+blfs: bluffs
+btm: bottom
+blvd: boulevard
+br: branch
+brg: bridge
+brk: brook
+brks: brooks
+bg: burg
+bgs: burgs
+byp: bypass
+cp: camp
+cyn: canyon
+cpe: cape
+cswy: causeway
+ctr: center
+ctrs: centers
+cir: circle
+cirs: circles
+clf: cliff
+clfs: cliffs
+clb: club
+cmn: common
+cmns: commons
+cor: corner
+cors: corners
+crse: course
+ct: court
+cts: courts
+cv: cove
+cvs: coves
+crk: creek
+cres: crescent
+crst: crest
+xing: crossing
+xrd: crossroad
+xrds: crossroads
+curv: curve
+dl: dale
+dm: dam
+dv: divide
+dr: drive
+drs: drives
+est: estate
+ests: estates
+expy: expressway
+ext: extension
+exts: extensions
+fls: falls
+fry: ferry
+fld: field
+flds: fields
+flt: flat
+flts: flats
+frd: ford
+frds: fords
+frst: forest
+frg: forge
+frgs: forges
+frk: fork
+frks: forks
+ft: fort
+fwy: freeway
+gdn: garden
+gdns: gardens
+gtwy: gateway
+gln: glen
+glns: glens
+grn: green
+grns: greens
+grv: grove
+grvs: groves
+hbr: harbor
+hbrs: harbors
+hvn: haven
+hts: heights
+hwy: highway
+hl: hill
+hls: hills
+holw: hollow
+inlt: inlet
+is: island
+iss: islands
+isle: isles
+jct: junction
+jcts: junctions
+ky: key
+kys: keys
+knl: knoll
+knls: knolls
+lk: lake
+lks: lakes
+land: land
+lndg: landing
+ln: lane
+lgt: light
+lgts: lights
+lf: loaf
+lck: lock
+lcks: locks
+ldg: lodge
+loop: loops
+mall: mall
+mnr: manor
+mnrs: manors
+mdw: meadow
+mdws: meadows
+mews: mews
+ml: mill
+mls: mills
+msn: mission
+mtwy: motorway
+mt: mount
+mtn: mountain
+mtns: mountains
+nck: neck
+orch: orchard
+oval: ovl
+opas: overpass
+park: parks
+pkwy: parkway
+pass: pass
+psge: passage
+path: paths
+pike: pikes
+pne: pine
+pnes: pines
+pl: place
+pln: plain
+plns: plains
+plz: plaza
+pt: point
+pts: points
+prt: port
+prts: ports
+pr: prairie
+radl: radial
+ramp: ramp
+rnch: ranch
+rpd: rapid
+rpds: rapids
+rst: rest
+rdg: ridge
+rdgs: ridges
+riv: river
+rd: road
+rds: roads
+rte: route
+row: row
+rue: rue
+run: run
+shl: shoal
+shls: shoals
+shr: shore
+shrs: shores
+skwy: skyway
+spg: spring
+spgs: springs
+spur: spurs
+sq: square
+sqs: squares
+sta: station
+stra: stravenue
+strm: stream
+st: street
+sts: streets
+smt: summit
+ter: terrace
+trwy: throughway
+trce: trace
+trak: track
+trfy: trafficway
+trl: trail
+trlr: trailer
+tunl: tunnel
+tpke: turnpike
+upas: underpass
+un: union
+uns: unions
+vly: valley
+vlys: valleys
+via: viaduct
+vw: view
+vws: views
+vlg: village
+vlgs: villages
+vl: ville
+vis: vista
+walk: walks
+wall: wall
+way: wy
+ways: ways
+wl: well
+wls: wells

data/dictionaries/en/numbers_to_words.yml

@@ -0,0 +1,32 @@
+---
+"0": zero
+"00": hundred # this enables the hundreds but also 15 hundred 36 hundred etc
+"000": thousand
+"1": one
+"2": two
+"3": three
+"4": four
+"5": five
+"6": six
+"7": seven
+"8": eight
+"9": nine
+"10": ten
+"11": eleven
+"12": twelve
+"13": thirteen
+"14": fourteen
+"15": fifteen
+"16": sixteen
+"17": seventeen
+"18": eighteen
+"19": nineteen
+"20": twenty
+"30": thirty
+"40": forty
+"50": fifty
+"60": sixty
+"70": seventy
+"80": eighty
+"90": ninety
+

data/lib/dictable/street_name.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Dictable
+  class StreetName
+    def initialize(street_number, lang: :en)
+      @street_number = street_number.downcase
+      @dictionary = Dictable.load_dictionary(:address_abbreviations_exploded, lang: lang)
+    end
+
+    def to_dictable
+      @street_number.split.map { |word| @dictionary[word.downcase] || word }.join(' ')
+    end
+  end
+end

data/lib/dictable/street_number.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Dictable
+  class StreetNumber
+    def initialize(street_number, lang: :en)
+      @street_number = street_number
+      @dictionary = Dictable.load_dictionary(:numbers_to_words, lang: lang)
+    end
+
+    def to_dictable
+      # less than 20 or multiples of 10
+      @dictionary.key?(@street_number)
+      return @dictionary[@street_number] if @dictionary.key?(@street_number)
+
+      # 100, 200, ... 900 and 1000, 2000, ... 9000
+      return plain_hundreds_or_thousands_to_words(@street_number) if hundreds_or_thousands?(@street_number)
+
+      # 20 or more and less than 100
+      return two_digit_number_to_words(@street_number) if @street_number.length == 2
+
+      # 5 digit addresses are rare, and we'll be opinionated and pronounce them as two digits, one digit, and two digits
+      return five_digit_number_to_words(@street_number) if @street_number.length == 5
+
+      # now everythinge else
+      parse_in_pairs(@street_number)
+    end
+
+    private
+
+    def hundreds_or_thousands?(number)
+      number[1..].to_i.zero? && (number.length == 3 || number.length == 4)
+    end
+
+    def plain_hundreds_or_thousands_to_words(number)
+      "#{@dictionary[number[0]]} #{@dictionary[number[1..]]}"
+    end
+
+    def five_digit_number_to_words(number)
+      [two_digit_number_to_words(number[0..1]), @dictionary[number[2]],
+       two_digit_number_to_words(number[3..])].join(' ')
+    end
+
+    def two_digit_number_to_words(number)
+      @dictionary[number] || "#{@dictionary["#{number[0]}0"]} #{@dictionary[number[1]]}"
+    end
+
+    def parse_in_pairs(number)
+      parts = []
+
+      # for 3 digit numbers, we extract the first digit and pronounce it as a single digit number
+      if number.length == 3
+        parts << @dictionary[number[0]]
+        number = number[1..]
+      end
+
+      parts += number.scan(/../).map { |pair| two_digit_number_to_words(pair) }
+      parts.join(' ')
+    end
+  end
+end

data/lib/dictable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dictable
-  VERSION = '0.1.4'
+  VERSION = '0.1.6'
 end

data/lib/dictable.rb

@@ -2,45 +2,33 @@
 
 # lib/dictable.rb
 require_relative 'dictable/version'
-require_relative 'dictable/extend_primitives'
-require_relative 'dictable/exceptions'
-require_relative 'dictable/dictable_number'
+require_relative 'dictable/street_name'
+require_relative 'dictable/street_number'
+require 'yaml'
 
 # We are going to change the design of the gem to make it more flexible.
-
-module DictableNumber
-  class Base
-    def initialize(number:)
-      @number = number
-    end
-
-    def to_dictable
-      raise NotImplementedError
-    end
+module Dictable
+  def self.address(address, lang: :en)
+    address_parts = address.split
+    street_number = address_parts.shift
+    street_address = address_parts.join(' ')
+
+    [
+      number_to_words(street_number, lang: lang),
+      explode_abberviations(street_address, lang: lang)
+    ].join(' ')
   end
 
-  module Transformers
-    
-
-end
-
-=begin
-
-module DictableNumber; end
-class DictableNumber::Base; end
-
-# Each language will have a dictionary
-module DictableNumber::English; end
-module DictableNumber::Spanish; end
-
-# this is the explanation of the adapter pattern
-# https://refactoring.guru/design-patterns/adapter/ruby/example
-
-
-
-
-
+  def self.number_to_words(street_number, lang:)
+    StreetNumber.new(street_number, lang: lang).to_dictable
+  end
 
+  def self.explode_abberviations(address, lang:)
+    StreetName.new(address, lang: lang).to_dictable
+  end
 
+  def self.load_dictionary(name, lang: :en)
+    dictionary_path = File.join(__dir__, '../dictionaries', lang.to_s, "#{name}.yml")
+    YAML.load_file(dictionary_path)
+  end
 end
-

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: dictable
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Matias Verges
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-03-04 00:00:00.000000000 Z
+date: 2024-03-06 00:00:00.000000000 Z
 dependencies: []
-description: Transform numbers into words to dictate them easily.For example 1234
-  becomes twelve thirty four and 123456 becomes 'one two three, four five six'
+description: Transform street numbers into words to dictate them easily, and explodes
+  street names abbreviations.For example 1234 becomes twelve thirty four and 123456
+  becomes 'one two three, four five six'
 email:
 - matis@matis.io
 executables: []
@@ -25,10 +26,11 @@ files:
 - README.md
 - Rakefile
 - dictable.gemspec
+- dictionaries/en/address_abbreviations_exploded.yml
+- dictionaries/en/numbers_to_words.yml
 - lib/dictable.rb
-- lib/dictable/dictable_number.rb
-- lib/dictable/exceptions.rb
-- lib/dictable/extend_primitives.rb
+- lib/dictable/street_name.rb
+- lib/dictable/street_number.rb
 - lib/dictable/version.rb
 - sig/dictable.rbs
 homepage: https://github.com/matismasters/dictable
@@ -57,5 +59,6 @@ requirements: []
 rubygems_version: 3.4.22
 signing_key: 
 specification_version: 4
-summary: Transform numbers into words to dictate them easily.
+summary: Transform street numbers into words to dictate them easily, and explodes
+  street names abbreviations.
 test_files: []

data/lib/dictable/dictable_number.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module Dictable
-  class DictableNumber
-    attr_reader :number_to_dictate, :dictable_number_in_words
-
-    ONES = %w[zero one two three four five six seven eight nine].freeze
-    TEENS = %w[ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen].freeze
-    TENS = %w[twenty thirty forty fifty sixty seventy eighty ninety].freeze
-
-    def initialize(number_to_dictate)
-      @number_to_dictate = number_to_dictate.to_s
-      validate_number(@number_to_dictate)
-    end
-
-    def to_dictable
-      @to_dictable ||= number_to_words
-    end
-
-    private
-
-    def number_to_words
-      number_as_string = @number_to_dictate
-
-      leading_zeroes_words = leading_zeroes_to_words(number_as_string)
-
-      number_without_leading_zeroes = number_without_leading_zeroes(number_as_string)
-      number_without_leading_zeroes_words = number_without_leading_zeroes_to_words(number_without_leading_zeroes)
-
-      [leading_zeroes_words, number_without_leading_zeroes_words].reject(&:empty?).join(' ')
-    end
-
-    def validate_number(number_as_string)
-      raise NonNumberCharactersPresent if number_as_string.match?(/[^0-9]/)
-    end
-
-    def number_without_leading_zeroes_to_words(number_as_string)
-      case number_as_string.length
-      when 1 then one_digit_number_to_words(number_as_string)
-      when 2 then two_digit_number_to_words(number_as_string)
-      when 3 then three_digit_number_to_words(number_as_string)
-      when 4 then four_digit_number_to_words(number_as_string)
-      else large_number_to_words(number_as_string)
-      end
-    end
-
-    def repeat_zeroes(number_of_zeroes)
-      Array.new(number_of_zeroes) { ONES[0] }.join(' ')
-    end
-
-    def leading_zeroes_to_words(number_as_string)
-      leading_zeroes = number_as_string.match(/^0+/).to_s
-      return '' if leading_zeroes.empty?
-
-      repeat_zeroes(leading_zeroes.length)
-    end
-
-    def number_without_leading_zeroes(number_as_string)
-      number_as_string.sub(/^0+/, '')
-    end
-
-    def single_thousands_to_words(number_as_string)
-      number = number_as_string.to_i / 1000
-
-      [one_digit_number_to_words(number), 'thousand'].join(' ')
-    end
-
-    def one_digit_number_to_words(number_as_string)
-      number = number_as_string.to_i
-      return repeat_zeroes(1) if number.zero?
-
-      ONES[number]
-    end
-
-    def two_digit_number_to_words(number_as_string)
-      number = number_as_string.to_i
-
-      return repeat_zeroes(2) if number.zero?
-      return TEENS[number - 10] if number < 20
-
-      div, mod = number.divmod(10)
-      TENS[div - 2] + (mod.zero? ? '' : " #{ONES[mod]}")
-    end
-
-    def three_digit_number_to_words(number_as_string)
-      number = number_as_string.to_i
-      return repeat_zeroes(3) if number.zero?
-
-      first_digit, remainder = number.divmod(100)
-      words = [ONES[first_digit]]
-      words << (remainder.zero? ? 'hundred' : two_digit_number_to_words(remainder))
-      words.join(' ')
-    end
-
-    def four_digit_number_to_words(number_as_string)
-      number = number_as_string.to_i
-
-      return repeat_zeroes(4) if number.zero?
-      return single_thousands_to_words(number_as_string) if (number % 1000).zero?
-
-      high_pair = number_as_string[0..1]
-      low_pair = number_as_string[2..3]
-
-      [
-        two_digit_number_to_words(high_pair),
-        low_pair.to_i.zero? ? 'hundred' : two_digit_number_to_words(low_pair)
-      ].join(' ')
-    end
-
-    def large_number_to_words(number_as_string)
-      number_as_string.chars.map { |digit| ONES[digit.to_i] }.each_slice(3).map { |digit| digit.join(' ') }.join(', ')
-    end
-  end
-end

data/lib/dictable/exceptions.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Dictable
-  class Error < StandardError; end
-
-  class NonNumberCharactersPresent < StandardError
-    def initialize
-      super('Non-number characters present')
-    end
-  end
-end

data/lib/dictable/extend_primitives.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class Integer
-  def to_dictable
-    Dictable::DictableNumber.new(self).to_dictable
-  end
-end
-
-class String
-  def to_dictable_number
-    Dictable::DictableNumber.new(self).to_dictable
-  end
-end