truncator 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2291c4c5706173cac9a8d622c702e15fa3d0b17
-  data.tar.gz: 193f48279bd97d6a4c298417c796ff42f7c78e95
+  metadata.gz: 50aa3fe4a5e7f94318128cad88fa00d37c118b01
+  data.tar.gz: 1e74abed03fc0af9dd4a1f1b248d3a772b5015c4
 SHA512:
-  metadata.gz: 9e58e7ce29d2996fc93868c89d94d86351827a8b9a396724bb21514dd844d91b4e1bd8613cb1e996adc23f72c079d80b4cc5d6579857d57e8ff98ae06fb3b38a
-  data.tar.gz: e403967ea6e475503f3050939ae5e9b0e780f941e4c3c0d15fa1b34c12e422a638e18a0e539b43df70c364bf9d1f56029079eef883e5970eabfa57adf0e3c10e
+  metadata.gz: 8651a8088c7e57b183b3320551b890e0678bfb7b65d6d6e30e5d7e027877fec47ae787bf49b16fc0837fc7c4da2a0a0d32dc87d5ccd36532d1c74f2d5eb5215b
+  data.tar.gz: 6c3e960903c5ed73e291eb42a92fde49cba0392021ae86d9da1d59d4cb0db68471a70743c8aed86675b97a66d402a58989cc7edf71b15f6f39618bcd7f2609ab

data/Gemfile

@@ -3,6 +3,3 @@ source 'https://rubygems.org'
 gemspec
 
 ruby '2.0.0'
-
-gem 'rspec', '~> 2.13'
-gem 'byebug'

data/lib/truncator.rb

@@ -1,2 +1,5 @@
 require 'truncator/version'
+require 'truncator/extended_uri'
+require 'truncator/extended_string'
+require 'truncator/extended_array'
 require 'truncator/url_parser'

data/lib/truncator/extended_array.rb

@@ -0,0 +1,12 @@
+module Truncator
+  module ExtendedArray
+    refine Array do
+
+      # Generate all possible combinations of sequential elements
+      # Example: [1, 2, 3].sequences #=> [[1], [2], [3], [1, 2], [2, 3], [1, 2, 3]]
+      def sequences
+        self.each_index.inject([]) { |result, i| self.each_cons(i + 1) { |cons| result << cons }; result }
+      end
+    end
+  end
+end

data/lib/truncator/extended_string.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext/class/attribute_accessors'
+
+class String
+  cattr_accessor :separator
+end
+
+module Truncator
+  module ExtendedString
+    refine String do
+      def truncate!(length, separator = nil)
+        separator ||= self.separator
+        fail ArgumentError, 'Separator should be present. Pass it via last argument or set globally String.separator=' unless separator
+        if self.length > length
+          self[(length - separator.length)..-1] = separator
+        end
+        self
+      end
+
+      def truncate(*args)
+        self.dup.truncate!(*args)
+      end
+
+      def valid_length?(valid_length)
+        self.length <= valid_length
+      end
+
+      def invalid_length?(*args)
+        not valid_length?(*args)
+      end
+    end
+  end
+end

data/lib/truncator/extended_uri.rb

@@ -0,0 +1,78 @@
+require 'uri'
+
+module Truncator
+  module ExtendedURI
+    refine URI::Generic do
+      def ordinary_hostname?
+        if %w(https ftp).include?(self.scheme) || self.userinfo || self.port_defined?
+          false
+        else
+          true
+        end
+      end
+
+      def path_blank?
+        ['', nil, '/'].include? self.path
+      end
+
+      def paths
+        self.path.split('/').delete_if(&:empty?)
+      end
+
+      def paths=(paths_array)
+        _path = paths_array.join('/')
+        # We should insure that we have leading '/'
+        _path.prepend('/') unless _path[0] == '/'
+        self.path = _path
+        self
+      end
+
+      def last_path_with_query
+        str = "#{self.paths.last}"
+        if self.query
+          str += "?#{self.query}"
+        end
+        str
+      end
+
+      def last_path_with_query=(str)
+        last_path, query = str.split('?')
+        _paths = self.paths
+        _paths[-1] = last_path.to_s if _paths.last
+        self.paths = _paths
+        self.query = query
+        self
+      end
+
+      def query_parameters
+        URI.decode_www_form(self.query)
+      end
+
+      def query_parameters=(params)
+        self.query = URI.encode_www_form(params)
+      end
+
+      ##App specific
+      def special_format
+        str = self.to_s
+        if ordinary_hostname?
+          str.sub!(/\Ahttp:\/\//, '') # remove http protocol
+          str.gsub(/\/{2,}/, '/') # replace multiple slashes by one
+          str.chomp!('/') # remove slash from the end
+        end
+        str
+      end
+
+      private
+        def port_defined?
+          port = self.port
+          self.to_s.include? ":#{port}"
+        end
+
+        def self.insure_leading_slash!(str)
+          str.prepend('/') unless str[0] == '/'
+          str
+        end
+    end
+  end
+end

data/lib/truncator/url_parser.rb

@@ -1,155 +1,92 @@
-class UrlParser
-  class << self
-    URL_VALID_SYMBOLS = %Q{[#{Regexp.escape('!#$&-;=?-[]_~')}a-zA-Z0-9]}
-    SEPARATOR = '...'
-
-    def shorten_url(url, truncation_length = 42)
-      url = url.dup
-      unless ordinary_hostname?(url)
-        if url[-1] != '/'
-          # truncate all parameter except the first
-          url[url.index('&')..-1] = '...'
-        end
-        return url
-      end
-
-      url.sub!(/\Ahttp:\/\//, '') # remove http protocol
-      url.gsub(/\/{2,}/, '/') # replace multiple slashes by one
-      url.chomp!('/') # remove slash from the end
-      return url if valid_length?(url.length, truncation_length)
-
-      if !has_path?(url)
-        url = truncate(url, truncation_length)
-        return url
-      end
-
-      if params_exists?(url)
-        if invalid_length?(hostname(url).length, truncation_length) and last_directory(url).length > truncation_length
-          url = truncate_last_directory(url, truncation_length)
-        elsif valid_length?(url.length - last_directory(url).length, truncation_length) or !has_dirs?(url)
-          url = truncate(url, truncation_length)
-        end
-      else
-        if valid_length?(hostname(url).length, truncation_length)
-          url = truncate_by_shortest(url, truncation_length)
-        else
-          url = truncate_all_directories(url)
-          url = truncate_last_directory(url, truncation_length)
+using Truncator::ExtendedURI
+using Truncator::ExtendedString
+using Truncator::ExtendedArray
+
+module Truncator
+  class UrlParser
+    class << self
+      SEPARATOR = '...'
+      String.separator = SEPARATOR
+
+      def shorten_url(uri, truncation_length = 42)
+        uri = URI(uri)
+
+        if not uri.ordinary_hostname?
+          if uri.query
+            uri.query_parameters = [uri.query_parameters.first]
+            return uri.to_s + SEPARATOR
+          else
+            return uri.to_s
+          end
         end
-      end
 
-      url
-    end
+        return uri.special_format if uri.special_format.valid_length?(truncation_length)
 
-    private
-      ## FIXME: add to String#truncate
-      def truncate(str, length)
-        str = str.dup
-        if str.length > length
-          str[(length - SEPARATOR.length)..-1] = SEPARATOR
+        if uri.path_blank? and not uri.query
+          return uri.special_format.truncate!(truncation_length)
         end
-        str
-      end
 
-      def ordinary_hostname?(url)
-        if url.start_with?('https://')
-          # https
-          false
-        elsif url =~ /^http[s]?:\/\/[a-zA-Z\d.]+:\d{1,5}\//
-          # has port
-          false
-        elsif url.start_with?('ftp://')
-          # ftp
-          false
-        elsif url =~ /^http:\/\/[a-zA-Z\d]+:[a-zA-Z\d]+@[a-zA-Z\d.]+\//
-          # with credentials
-          false
+        if uri.query
+          if uri.host.invalid_length?(truncation_length) and uri.last_path_with_query.length > truncation_length
+            uri = truncate_last_path_segment(uri, truncation_length)
+          elsif uri.special_format.valid_length?(truncation_length + uri.last_path_with_query.length) or not uri.path_blank?
+            return uri.special_format.truncate!(truncation_length)
+          end
         else
-          true
+          if uri.host.valid_length?(truncation_length)
+            uri = truncate_by_shortest(uri, truncation_length)
+          else
+            uri = truncate_all_paths_except_last(uri)
+            uri = truncate_last_path_segment(uri, truncation_length)
+          end
         end
-      end
-
-      def hostname(url)
-        url[0..(url.index('/') - 1)]
-      end
-
-      def valid_length?(url_length, truncation_length)
-        url_length <= truncation_length
-      end
-
-      def invalid_length?(url_length, truncation_length)
-        !valid_length?(url_length, truncation_length)
-      end
 
-      # Check if url has query parameters
-      def params_exists?(url)
-        valid_symbols_before_params = URL_VALID_SYMBOLS.dup.tap { |r| r[-1] = '.\/]' }
-        !!(url =~ /^#{valid_symbols_before_params}+\?(#{URL_VALID_SYMBOLS}+)/)
+        uri.special_format
       end
 
-      def params(url)
-        valid_symbols_before_params = URL_VALID_SYMBOLS.dup.tap { |r| r[-1] = '.\/]' }
-        url.match(/^#{valid_symbols_before_params}+\?(#{URL_VALID_SYMBOLS}+)/)[1]
-      end
-
-      # Get the 'directories' of the link
-      def directories(url)
-        url.to_enum(:scan, /(?<=\/)(#{URL_VALID_SYMBOLS}+)(?=\/)/).map { Regexp.last_match }
-      end
-
-      def truncate_all_directories(url)
-        first_slash = url.index('/')
-        last_slash = url.rindex('/')
-        url = url.dup
-        url[first_slash..last_slash] = "/#{SEPARATOR}/"
-        url
-      end
-
-      def last_directory(url)
-        url[(url.rindex('/') + 1)..-1]
-      end
-
-      def truncate_last_directory(url, truncation_length)
-        last_dir_begin = url.rindex('/') + 1
-        last_dir = last_directory(url)
-        url = url.dup
-        url[last_dir_begin..-1] = truncate(last_dir, truncation_length)
-        url
-      end
+      private
+        def truncate_all_paths_except_last(uri)
+          uri = uri.dup
+          paths = uri.paths
+          if paths.size > 1
+            uri.paths = [SEPARATOR, paths.last]
+          end
+          uri
+        end
 
-      # If url has any 'dirs' this is suburls between '/'
-      def has_dirs?(url)
-        url.count('/') > 1
-      end
+        def truncate_last_path_segment(uri, truncation_length)
+          uri = uri.dup
+          last_path_with_query = uri.last_path_with_query
+          uri.last_path_with_query = last_path_with_query.truncate(truncation_length)
+          uri
+        end
 
-      def has_path?(url)
-        url.count('/') > 0
-      end
+        def sort_paths_by_length_and_index!(paths)
+          paths.lazy.with_index.sort_by { |a, i| [a.size, i] }.map(&:first)
+        end
 
-      def truncate_by_shortest(url, target_length)
-        url = url.dup
-        dirs = directories(url)
-        dirs_sorted = dirs.sort_by { |d| d.to_s.length }
+        # Get the sequences of paths from uri
+        def paths_sequences_from_uri(uri)
+          paths = uri.paths[0..-2]
+          paths.sequences.uniq.map { |i| i.join('/') }
+        end
 
-        # Get the shortest dir and try to truncate the url by this dir and nexts
-        dirs_sorted.each do |next_min_dir|
-          current_dirs_length = 0
-          current_dirs_count = 0
-          dirs[dirs.index(next_min_dir)..-1].each do |dir|
-            current_dirs_length += dir.to_s.length
-            current_dirs_count += 1
-            current_dirs_length_with_slashes = current_dirs_length + (current_dirs_count - 1) - SEPARATOR.length
-            break if url.length - current_dirs_length_with_slashes <= target_length
+        # Find the appropriate sequence to truncate uri to target length
+        def find_truncated_sequence(uri, sorted_sequences, target_length)
+          sorted_sequences.find do |seq|
+            (uri.special_format.length - seq.length + SEPARATOR.length) <= target_length
           end
-          current_dirs_length_with_slashes = current_dirs_length + (current_dirs_count - 1) - SEPARATOR.length
+        end
 
-          if url.length - current_dirs_length_with_slashes <= target_length
-            url[next_min_dir.begin(0)..
-              (dirs[dirs.index(next_min_dir) + (current_dirs_count - 1)].end(0) - 1)] = SEPARATOR
-            break
-          end
+        # Truncate the uri via truncating the shortest possible path sequence
+        def truncate_by_shortest(uri, target_length)
+          uri = uri.dup
+          sorted_sequences = sort_paths_by_length_and_index!(paths_sequences_from_uri(uri))
+          truncated_part = find_truncated_sequence(uri, sorted_sequences, target_length)
+
+          uri.path = uri.path.sub(truncated_part, SEPARATOR)
+          uri
         end
-        url
-      end
+    end
   end
 end

data/lib/truncator/version.rb

@@ -1,3 +1,3 @@
 module Truncator
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/url_parser_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require 'truncator'
 
-describe UrlParser do
+describe Truncator::UrlParser do
 
   describe ".shorten_url" do
 
     context "when no truncation length is specified, the URL is too long, has sublevels, but no query params" do
-      let(:shortened) { UrlParser.shorten_url "http://www.foo.com/this/is/a/b/c/d/e/f/string.html" }
+      let(:shortened) { Truncator::UrlParser.shorten_url "http://www.foo.com/this/is/a/b/c/d/e/f/string.html" }
 
       it "should default to truncate at 42 characters" do
         # shortened.should == "www.foo.com/this/is/a/.../e/f/string.html"
@@ -15,7 +15,7 @@ describe UrlParser do
     end
 
     context 'when URL has a large last folder level' do
-      let(:shortened) { UrlParser.shorten_url "http://m.whitehouse.gov/blog/2013/08/23/check-out-secretary-education-arne-duncans-google-hangout-sal-khan?utm_source=email&utm_medium=email&utm_content=email232-graphic2&utm_campaign=education" }
+      let(:shortened) { Truncator::UrlParser.shorten_url "http://m.whitehouse.gov/blog/2013/08/23/check-out-secretary-education-arne-duncans-google-hangout-sal-khan?utm_source=email&utm_medium=email&utm_content=email232-graphic2&utm_campaign=education" }
 
       it "should should default to truncate at 42 characters" do
         shortened.should == "m.whitehouse.gov/blog/2013/08/23/check-..."
@@ -24,7 +24,7 @@ describe UrlParser do
 
     context "when URL is too long, has sublevels, but no query params" do
       it "should ellipse the directories and just show the file" do
-        UrlParser.shorten_url("http://www.foo.com/this/is/a/really/long/url/that/has/no/query/string.html", 30).should == "www.foo.com/.../string.html"
+        Truncator::UrlParser.shorten_url("http://www.foo.com/this/is/a/really/long/url/that/has/no/query/string.html", 30).should == "www.foo.com/.../string.html"
       end
 
       it "should replace path segments with ellipses to shorten the path as much as necessary" do
@@ -34,7 +34,7 @@ describe UrlParser do
         0.upto(20) do |n|
           url = url_prefix + url_middle + url_suffix
           url_middle += "and/on/"
-          shorter_url = UrlParser.shorten_url(url, 30)
+          shorter_url = Truncator::UrlParser.shorten_url(url, 30)
           #TODO: rewrite this
           shorter_url.should == if url[7..-1].length <= 30
                                   url[7..-1]
@@ -51,7 +51,7 @@ describe UrlParser do
         0.upto(20) do |n|
           url = url_prefix + url_middle + url_suffix
           url_middle += "nd/on/"
-          shorter_url = UrlParser.shorten_url(url, 30)
+          shorter_url = Truncator::UrlParser.shorten_url(url, 30)
           #TODO: rewrite this
           shorter_url.should == if url[7..-1].length <= 30
                                   url[7..-1]
@@ -63,16 +63,16 @@ describe UrlParser do
 
       # it "should replace path segments with ellipses to shorten the path as much as necessary for various lengths", focus: true do
       #   url = "http://www.foo.com/this/goes/on/and/on/and/on/with/XXX.html"
-      #   UrlParser.shorten_url(url, 24).should == "www.foo.com/.../XXX.html"
-      #   32.upto(33) { |n| UrlParser.shorten_url(url, n).should == "www.foo.com/.../on/with/XXX.html" }
-      #   35.upto(39) { |n| UrlParser.shorten_url(url, n).should == "www.foo.com/this/.../with/XXX.html" }
-      #   40.upto(42) { |n| UrlParser.shorten_url(url, n).should == "www.foo.com/this/goes/.../with/XXX.html" }
-      #   43.upto(45) { |n| UrlParser.shorten_url(url, n).should == "www.foo.com/this/goes/.../on/with/XXX.html" }
+      #   Truncator::UrlParser.shorten_url(url, 24).should == "www.foo.com/.../XXX.html"
+      #   32.upto(33) { |n| Truncator::UrlParser.shorten_url(url, n).should == "www.foo.com/.../on/with/XXX.html" }
+      #   35.upto(39) { |n| Truncator::UrlParser.shorten_url(url, n).should == "www.foo.com/this/.../with/XXX.html" }
+      #   40.upto(42) { |n| Truncator::UrlParser.shorten_url(url, n).should == "www.foo.com/this/goes/.../with/XXX.html" }
+      #   43.upto(45) { |n| Truncator::UrlParser.shorten_url(url, n).should == "www.foo.com/this/goes/.../on/with/XXX.html" }
       # end
     end
 
     # context "when URL is too long and has at least one sublevel specified as well as a query parameter" do
-    #   let(:shortened) { UrlParser.shorten_url("http://www.foo.com/this/goes/on/and/on/and/on/and/on/and/ends/with/XXXX.html?q=1&a=2&b=3", 50) }
+    #   let(:shortened) { Truncator::UrlParser.shorten_url("http://www.foo.com/this/goes/on/and/on/and/on/and/on/and/ends/with/XXXX.html?q=1&a=2&b=3", 50) }
 
     #   it "should replace path segments with ellipses to shorten the path as much as necessary, and show only the first param, followed by ellipses" do
     #     shortened.should == "www.foo.com/this/goes/.../with/XXXX.html?q=1..."
@@ -80,7 +80,7 @@ describe UrlParser do
     # end
 
     context "when URL is more than 30 chars long and does not have at least one sublevel specified" do
-      let(:shortened) { UrlParser.shorten_url("http://www.mass.gov/?pageID=trepressrelease&L=4&L0=Home&L1=Media+%26+Publications&L2=Treasury+Press+Releases&L3=2006&sid=Ctre&b=pressrelease&f=2006_032706&csid=Ctre", 30) }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://www.mass.gov/?pageID=trepressrelease&L=4&L0=Home&L1=Media+%26+Publications&L2=Treasury+Press+Releases&L3=2006&sid=Ctre&b=pressrelease&f=2006_032706&csid=Ctre", 30) }
 
       it "should truncate to 30 chars with ellipses" do
         shortened.should == "www.mass.gov/?pageID=trepre..."
@@ -88,7 +88,7 @@ describe UrlParser do
     end
 
     context "when the URL contains a really long host name and a long trailing filename" do
-      let(:shortened) { UrlParser.shorten_url("http://www128376218.skjdhfskdjfhs.lqdkwjqlkwjdqlqwkjd.com/some/path/1234567890123456789012345678901234test_of_the_mergency_broadcastingnet_work.html", 30) }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://www128376218.skjdhfskdjfhs.lqdkwjqlkwjdqlqwkjd.com/some/path/1234567890123456789012345678901234test_of_the_mergency_broadcastingnet_work.html", 30) }
 
       it "should not truncate the host name and truncated the last part of the path to truncation length and all dirs" do
         shortened.should == "www128376218.skjdhfskdjfhs.lqdkwjqlkwjdqlqwkjd.com/.../123456789012345678901234567..."
@@ -97,7 +97,7 @@ describe UrlParser do
 
     #TODO: this and the next spec can be merged
     context "when the URL contains a really long host name and is an http url and has an empty path" do
-      let(:shortened) { UrlParser.shorten_url("http://www128376218.skjdhfskdj.lqdkwjqlkwjdqlqwkjd.com/", 30) }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://www128376218.skjdhfskdj.lqdkwjqlkwjdqlqwkjd.com/", 30) }
 
       it "should truncate the host name and have no trailing /" do
         shortened.should == "www128376218.skjdhfskdj.lqd..."
@@ -105,7 +105,7 @@ describe UrlParser do
     end
 
     context "when the URL contains a really long host name and is an http url and has an empty path and no trailing /" do
-      let(:shortened) { UrlParser.shorten_url("http://www128376218.skjdhfskdj.lqdkwjqlkwjdqlqwkjd.com", 30) }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://www128376218.skjdhfskdj.lqdkwjqlkwjdqlqwkjd.com", 30) }
 
       it "should truncate the URL and have no trailing /" do
         shortened.should == "www128376218.skjdhfskdj.lqd..."
@@ -113,7 +113,7 @@ describe UrlParser do
     end
 
     context "when the URL contains a really long host name and has a really long query parameter" do
-      let(:shortened) { UrlParser.shorten_url("http://www128376218.skjdhfskdjfhs.lqdkwjqlkwjdqlqwkjd.com/?cmd=1234567890123456789012345678901234&api_key=1234567890123456789012345678901234", 30) }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://www128376218.skjdhfskdjfhs.lqdkwjqlkwjdqlqwkjd.com/?cmd=1234567890123456789012345678901234&api_key=1234567890123456789012345678901234", 30) }
 
       it "should not truncate the host name but truncate the query parameter" do
         shortened.should == "www128376218.skjdhfskdjfhs.lqdkwjqlkwjdqlqwkjd.com/?cmd=1234567890123456789012..."
@@ -121,7 +121,7 @@ describe UrlParser do
     end
 
     context "when URL is really short and contains only the protocol http and hostname" do
-      let(:shortened) { UrlParser.shorten_url("http://bit.ly/") }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://bit.ly/") }
 
       it "should omit the protocol as well as trailing slash" do
         shortened.should == "bit.ly"
@@ -129,7 +129,7 @@ describe UrlParser do
     end
 
     context "when URL is really short and contains only the protocol http and hostname and a long query parameter" do
-      let(:shortened) { UrlParser.shorten_url("http://api.bit.ly/?cmd=boom&t=now&auth_token=f886c1c02896492577e92b550cd22b3c83b062") }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://api.bit.ly/?cmd=boom&t=now&auth_token=f886c1c02896492577e92b550cd22b3c83b062") }
 
       it "should omit the protocol as well as trailing slash" do
         shortened.should == "api.bit.ly/?cmd=boom&t=now&auth_token=f..."
@@ -137,7 +137,7 @@ describe UrlParser do
     end
 
     context "when URL is really short and contains only the protocol http and hostname and a short query parameter" do
-      let(:shortened) { UrlParser.shorten_url("http://api.bit.ly/?cmd=boom&t=now") }
+      let(:shortened) { Truncator::UrlParser.shorten_url("http://api.bit.ly/?cmd=boom&t=now") }
 
       it "should omit the protocol as well as trailing slash" do
         shortened.should == "api.bit.ly/?cmd=boom&t=now"
@@ -148,19 +148,19 @@ describe UrlParser do
       before do
         @long_urls = [
             "https://www.mass.gov/",
-            "http://www.mass.gov:80/",
+            "http://www.mass.gov:81/",
             "http://user:secret@www.mass.gov/",
             "https://www.mass.gov/?pageID=trepressrelease&L=4&L0=Home&L1=Media+%26+Publications&L2=Treasury+Press+Releases&L3=2006&sid=Ctre&b=pressrelease&f=2006_032706&csid=Ctre",
-            "http://www.mass.gov:80/?pageID=trepressrelease&L=4&L0=Home&L1=Media+%26+Publications&L2=Treasury+Press+Releases&L3=2006&sid=Ctre&b=pressrelease&f=2006_032706&csid=Ctre",
+            "http://www.mass.gov:81/?pageID=trepressrelease&L=4&L0=Home&L1=Media+%26+Publications&L2=Treasury+Press+Releases&L3=2006&sid=Ctre&b=pressrelease&f=2006_032706&csid=Ctre",
             "http://user:secret@www.mass.gov/?pageID=trepressrelease&L=4&L0=Home&L1=Media+%26+Publications&L2=Treasury+Press+Releases&L3=2006&sid=Ctre&b=pressrelease&f=2006_032706&csid=Ctre",
             "ftp://www.mass.gov/"
         ]
         @short_urls = [
             "https://www.mass.gov/",
-            "http://www.mass.gov:80/",
+            "http://www.mass.gov:81/",
             "http://user:secret@www.mass.gov/",
             "https://www.mass.gov/?pageID=trepressrelease...",
-            "http://www.mass.gov:80/?pageID=trepressrelease...",
+            "http://www.mass.gov:81/?pageID=trepressrelease...",
             "http://user:secret@www.mass.gov/?pageID=trepressrelease...",
             "ftp://www.mass.gov/"
         ]
@@ -168,7 +168,7 @@ describe UrlParser do
 
       it "should truncate to 30 chars with ellipses" do
         @long_urls.each_with_index do |url, x|
-          UrlParser.shorten_url(url, 30).should == @short_urls[x]
+          Truncator::UrlParser.shorten_url(url, 30).should == @short_urls[x]
         end
       end
     end

data/truncator.gemspec

@@ -15,7 +15,10 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files`.split($/)
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "activesupport", "~> 4.0.1"
+
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 2.13"
+  spec.add_development_dependency "byebug"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: truncator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - freemanoid
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-02 00:00:00.000000000 Z
+date: 2013-11-03 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: url truncator
 email:
 - freemanoid321@gmail.com
@@ -65,6 +93,9 @@ files:
 - README.md
 - Rakefile
 - lib/truncator.rb
+- lib/truncator/extended_array.rb
+- lib/truncator/extended_string.rb
+- lib/truncator/extended_uri.rb
 - lib/truncator/url_parser.rb
 - lib/truncator/version.rb
 - spec/spec_helper.rb