smartname 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f2f4c617fed45e34cec94aa7d68ab31cf0a13673
-  data.tar.gz: 02aada66770f823481391f135d7e289d77d4af5e
+  metadata.gz: fa282b70e290a7ba8992394815a56a59a82a725e
+  data.tar.gz: 4eca49b980ee540634174c58bb21ad478d94ead6
 SHA512:
-  metadata.gz: cfdcd640b8a171858e06440dc2ec12046a2019f217d4068bb556c94bfca4baeeff02db5e5f1fd15da0e5cae0f8be1ebb6e673b9525d09e4dc58b7537ed2721dd
-  data.tar.gz: 489b2fea70357c763ec38ab65e26d646bfd27fb480228738179ac73562fd6970e13022b1ebbb3e9b95d015d1335bfe74734b3f77aad3f397ee4eb38c1e5c6e15
+  metadata.gz: f740e5c97e12c676d329c7c8da7c0ec4cbd2782ed8b034748bdb5b907e091a28ef150469f20c621e64650081ca01a01253e99f72592896cee097254277ce28ef
+  data.tar.gz: ba9b593644295fdb93de0db2b123f38bfd608a6b54dc6fcdf78d2cd62c6290f6ae9f12804e5ee2dda17a28ad61a90992fece91a95cbf8b3de228c84c49df84f2

data/Gemfile.lock

@@ -1,21 +1,53 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (3.2.13)
-      i18n (= 0.6.1)
-      multi_json (~> 1.0)
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.4.0)
+    builder (3.2.2)
     diff-lcs (1.1.3)
-    git (1.2.5)
-    htmlentities (4.3.1)
-    i18n (0.6.1)
-    jeweler (1.8.4)
+    faraday (0.8.11)
+      multipart-post (~> 1.2.0)
+    git (1.3.0)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (3.4.4)
+    highline (1.7.8)
+    htmlentities (4.3.4)
+    i18n (0.7.0)
+    jeweler (1.8.8)
+      builder
       bundler (~> 1.0)
       git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
       rake
       rdoc
-    json (1.7.7)
-    multi_json (1.7.2)
-    rake (10.0.4)
+    json (1.8.3)
+    jwt (1.5.1)
+    minitest (5.8.4)
+    multi_json (1.12.0)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (1.1.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0, < 1.5.2)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    rack (1.6.4)
+    rake (11.1.2)
     rdoc (3.12.2)
       json (~> 1.4)
     rspec (2.8.0)
@@ -26,6 +58,9 @@ GEM
     rspec-expectations (2.8.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.8.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
@@ -37,3 +72,6 @@ DEPENDENCIES
   jeweler (~> 1.8.3)
   rdoc (~> 3.12)
   rspec (~> 2.8.0)
+
+BUNDLED WITH
+   1.11.2

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.1

data/lib/smart_name.rb

@@ -9,14 +9,11 @@ class SmartName < Object
   OK4KEY_RE    = RUBYENCODING ? '\p{Word}\*' : '\w\*'
 
   include ActiveSupport::Configurable
-  
-  config_accessor :joint, :name_attribute, :banned_array, :var_re, :uninflect, :params, :session
-  
-  # Wagny defaults:
-  #config_accessor :joint,        :default => '+'
+
+  config_accessor :joint, :banned_array, :var_re, :uninflect, :params, :session
+
   SmartName.joint          = '+'
-  SmartName.banned_array   = [ '/', '~', '|' ]
-  SmartName.name_attribute = :cardname
+  SmartName.banned_array   = ['/', '~', '|']
   SmartName.var_re         = /\{([^\}]*\})\}/
   SmartName.uninflect      = :singularize
 
@@ -26,9 +23,9 @@ class SmartName < Object
 
   class << self
     def new obj
-      return obj if self.class===obj
-      str = Array===obj ? obj*joint : obj.to_s
-      if known_name = @@name2nameobject[str]
+      return obj if obj.is_a? self.class
+      str = obj.is_a?(Array) ? obj * joint : obj.to_s
+      if (known_name = @@name2nameobject[str])
         known_name
       else
         super str.strip
@@ -36,13 +33,12 @@ class SmartName < Object
     end
 
     def banned_re
-      %r{#{ (['['] + banned_array << joint )*'\\' + ']' }}
+      %r{#{ (['['] + banned_array << joint) * '\\' + ']' }}
     end
   end
 
-
-  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-  #~~~~~~~~~~~~~~~~~~~~~~ INSTANCE ~~~~~~~~~~~~~~~~~~~~~~~~~
+  # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  # ~~~~~~~~~~~~~~~~~~~~~~ INSTANCE ~~~~~~~~~~~~~~~~~~~~~~~~~
 
   attr_reader :simple, :parts, :key, :s
   alias to_s s
@@ -51,27 +47,38 @@ class SmartName < Object
     @s = str.to_s.strip
     @s = @s.encode('UTF-8') if RUBYENCODING
     @key = if @s.index(self.class.joint)
-        @parts = @s.split(/\s*#{JOINT_RE}\s*/)
-        @parts << '' if @s[-1,1] == self.class.joint
-        @simple = false
-        @parts.map { |p| p.to_name.key } * self.class.joint
-      else
-        @parts = [str]
-        @simple = true
-        str.empty? ? '' : simple_key
-      end
+             @parts = @s.split(/\s*#{JOINT_RE}\s*/)
+             @parts << '' if @s[-1, 1] == self.class.joint
+             @simple = false
+             @parts.map { |p| p.to_name.key } * self.class.joint
+           else
+             @parts = [str]
+             @simple = true
+             str.empty? ? '' : simple_key
+           end
     @@name2nameobject[str] = self
   end
 
-  def to_name()    self         end
-  def length()     parts.length end
-  def size()       to_s.size    end
-  def blank?()     s.blank?     end
+  def to_name
+    self
+  end
+
+  def length
+    parts.length
+  end
+
+  def size
+    to_s.size
+  end
+
+  def blank?
+    s.blank?
+  end
   alias empty? blank?
 
   def valid?
-    not parts.find do |pt|
-      pt.match self.class.banned_re 
+    !parts.find do |pt|
+      pt.match self.class.banned_re
     end
   end
 
@@ -79,123 +86,151 @@ class SmartName < Object
     "<#{self.class.name} key=#{key}[#{self}]>"
   end
 
-  def == obj
-    object_key = case
-      when obj.respond_to?(:key)     ; obj.key
-      when obj.respond_to?(:to_name) ; obj.to_name.key
-      else                           ; obj.to_s
+  def == other
+    other_key =
+      case
+      when other.respond_to?(:key)     then other.key
+      when other.respond_to?(:to_name) then other.to_name.key
+      else                                  other.to_s
       end
-    object_key == key
+    other_key == key
   end
 
-
-  #~~~~~~~~~~~~~~~~~~~ VARIANTS ~~~~~~~~~~~~~~~~~~~
+  # ~~~~~~~~~~~~~~~~~~~ VARIANTS ~~~~~~~~~~~~~~~~~~~
 
   def simple_key
-    decoded.underscore.gsub(/[^#{OK4KEY_RE}]+/,'_').split(/_+/).reject(&:empty?).map(&(self.class.uninflect))*'_'
+    decoded
+      .underscore
+      .gsub(/[^#{OK4KEY_RE}]+/, '_')
+      .split(/_+/)
+      .reject(&:empty?)
+      .map(&self.class.uninflect) * '_'
   end
 
   def url_key
-    @url_key ||= decoded.gsub(/[^#{OK4KEY_RE}#{JOINT_RE}]+/,' ').strip.gsub /[\s\_]+/, '_'
+    @url_key ||= part_names.map do |part_name|
+      stripped = part_name.decoded.gsub(/[^#{OK4KEY_RE}]+/, ' ').strip
+      stripped.gsub(/[\s\_]+/, '_')
+    end * self.class.joint
   end
 
   def safe_key
-    @safe_key ||= key.gsub('*','X').gsub self.class.joint, '-'
+    @safe_key ||= key.tr('*', 'X').tr self.class.joint, '-'
   end
 
   def decoded
-    @decoded ||= (s.index('&') ?  HTMLEntities.new.decode(s) : s)
+    @decoded ||= s.index('&') ? HTMLEntities.new.decode(s) : s
   end
 
-  def pre_cgi
-    #why is this necessary?? doesn't real CGI escaping handle this??
-    # hmmm.  is this to prevent absolutizing
-    @pre_cgi ||= parts.join '~plus~'
+  # ~~~~~~~~~~~~~~~~~~~ PARTS ~~~~~~~~~~~~~~~~~~~
+
+  alias simple? simple
+  def junction?
+    !simple?
   end
 
-  def post_cgi
-    #hmm.  this could resolve to the key of some other card.  move to class method?
-    @post_cgi ||= s.gsub '~plus~', self.class.joint
+  def left
+    @left ||= simple? ? nil : parts[0..-2] * self.class.joint
   end
 
-  #~~~~~~~~~~~~~~~~~~~ PARTS ~~~~~~~~~~~~~~~~~~~
+  def right
+    @right ||= simple? ? nil : parts[-1]
+  end
 
-  alias simple? simple
-  def junction?()   not simple?                                             end
-
-  def left()        @left  ||= simple? ? nil : parts[0..-2]*self.class.joint end
-  def right()       @right ||= simple? ? nil : parts[-1]                    end
-                    
-  def left_name()   @left_name   ||= left  && self.class.new( left  )        end
-  def right_name()  @right_name  ||= right && self.class.new( right )        end
-                    
-  # Note that all n ames have a trunk and tag, but only junctions have left and right
-                    
-  def trunk()       @trunk ||= simple? ? s : left                           end
-  def tag()         @tag   ||= simple? ? s : right                          end
-                    
-  def trunk_name()  @trunk_name  ||= simple? ? self : left_name             end
-  def tag_name()    @tag_name    ||= simple? ? self : right_name            end
-                                                                            
-  def part_names()  @part_names  ||= parts.map  &:to_name                   end
-  def piece_names() @piece_names ||= pieces.map &:to_name                   end
-                                                                            
-  def pieces
-    @pieces ||= if simple?
-      [ self ]
-    else
-      junction_pieces = []
-      parts[1..-1].inject parts[0] do |left, right|
-        piece = [left, right] * self.class.joint
-        junction_pieces << piece
-        piece
-      end
-      parts + junction_pieces
-    end
+  def left_name
+    @left_name ||= left && self.class.new(left)
+  end
+
+  def right_name
+    @right_name ||= right && self.class.new(right)
+  end
+
+  # Note that all names have a trunk and tag,
+  # but only junctions have left and right
+
+  def trunk
+    @trunk ||= simple? ? s : left
+  end
+
+  def tag
+    @tag ||= simple? ? s : right
   end
 
+  def trunk_name
+    @trunk_name ||= simple? ? self : left_name
+  end
+
+  def tag_name
+    @tag_name ||= simple? ? self : right_name
+  end
 
+  def part_names
+    @part_names ||= parts.map(&:to_name)
+  end
 
-  #~~~~~~~~~~~~~~~~~~~~ SHOW / ABSOLUTE ~~~~~~~~~~~~~~~~~~~~
+  def piece_names
+    @piece_names ||= pieces.map(&:to_name)
+  end
+
+  def pieces
+    @pieces ||=
+      if simple?
+        [self]
+      else
+        junction_pieces = []
+        parts[1..-1].inject parts[0] do |left, right|
+          piece = [left, right] * self.class.joint
+          junction_pieces << piece
+          piece
+        end
+        parts + junction_pieces
+      end
+  end
+
+  # ~~~~~~~~~~~~~~~~~~~~ SHOW / ABSOLUTE ~~~~~~~~~~~~~~~~~~~~
 
   def to_show *ignore
-    ignore.map! &:to_name
+    ignore.map!(&:to_name)
 
     show_parts = parts.map do |part|
-      reject = ( part.empty? or part =~ /^_/ or ignore.member? part.to_name )
+      reject = (part.empty? || (part =~ /^_/) || ignore.member?(part.to_name))
       reject ? nil : part
     end
 
     show_name = show_parts.compact.to_name.s
-    
+
     case
-    when show_parts.compact.empty?;  self
-    when show_parts[0].nil?       ;  self.class.joint + show_name
+    when show_parts.compact.empty? then  self
+    when show_parts[0].nil?        then  self.class.joint + show_name
     else show_name
     end
   end
 
-
   def to_absolute context, args={}
     context = context.to_name
     parts.map do |part|
-      new_part = case part
-        when /^_user$/i;            name_proc = self.class.session and name_proc.call or part
-        when /^_main$/i;            self.class.params[:main_name]
-        when /^(_self|_whole|_)$/i; context.s
-        when /^_left$/i;            context.trunk #note - inconsistent use of left v. trunk
-        when /^_right$/i;           context.tag
+      new_part =
+        case part
+        when /^_user$/i
+          name_proc = self.class.session
+          name_proc ? name_proc.call : part
+        when /^_main$/i            then self.class.params[:main_name]
+        when /^(_self|_whole|_)$/i then context.s
+        when /^_left$/i            then context.trunk
+          # note - inconsistent use of left v. trunk
+        when /^_right$/i           then context.tag
         when /^_(\d+)$/i
           pos = $~[1].to_i
           pos = context.length if pos > context.length
-          context.parts[pos-1]
+          context.parts[pos - 1]
         when /^_(L*)(R?)$/i
           l_s, r_s = $~[1].size, !$~[2].empty?
           l_part = context.nth_left l_s
           r_s ? l_part.tag : l_part.s
-        when /^_/
-          custom = args[:params] ? args[:params][part] : nil
-          custom ? CGI.escapeHTML(custom) : part #why are we escaping HTML here?
+        # when /^_/
+        #   custom = args[:params] ? args[:params][part] : nil
+        #   custom ? CGI.escapeHTML(custom) : part
+        # why are we escaping HTML here?
         else
           part
         end.to_s.strip
@@ -209,11 +244,10 @@ class SmartName < Object
 
   def nth_left n
     # 1 = left; 2= left of left; 3 = left of left of left....
-    ( n >= length ? parts[0] : parts[0..-n-1] ).to_name
+    (n >= length ? parts[0] : parts[0..-n - 1]).to_name
   end
 
-
-  #~~~~~~~~~~~~~~~~~~~~ MISC ~~~~~~~~~~~~~~~~~~~~
+  # ~~~~~~~~~~~~~~~~~~~~ MISC ~~~~~~~~~~~~~~~~~~~~
 
   def replace_part oldpart, newpart
     oldpart = oldpart.to_name
@@ -230,10 +264,10 @@ class SmartName < Object
       self
     else
       if oldpart == parts[0, oldpart.length]
-        if self.length == oldpart.length
+        if length == oldpart.length
           newpart
         else
-          ( newpart.parts + parts[ oldpart.length..-1 ] ).to_name
+          (newpart.parts + parts[oldpart.length..-1]).to_name
         end
       else
         self
@@ -245,11 +279,10 @@ class SmartName < Object
   # shouldn't it use inclusions???
   def self.substitute! str, hash
     hash.keys.each do |var|
-      str.gsub! var_re do |x| 
+      str.gsub! var_re do |x|
         hash[var.to_sym]
       end
     end
     str
   end
-
 end

data/spec/inflection_helper.rb

@@ -4,9 +4,9 @@
 ActiveSupport::Inflector.inflections do |inflect|
   inflect.irregular 'grave', 'graveyard'
   inflect.uncountable 'this'
-#  inflect.uncountable 'plus'
+  #  inflect.uncountable 'plus'
   inflect.uncountable 'anonymous'
-  inflect.uncountable /^s$/
+  inflect.uncountable 's'
   inflect.singular(/(ss)$/i, '\1')
   inflect.plural(/(ss)$/i, '\1')
 end

data/spec/lib/smart_name_spec.rb

@@ -2,231 +2,232 @@
 require File.expand_path('../spec_helper', File.dirname(__FILE__))
 require 'core_ext'
 
-
 describe SmartName do
-
-  describe "#key" do
-    it "should remove spaces" do
-      "this    Name".to_name.key.should == "this_name"
+  describe '#key' do
+    it 'should remove spaces' do
+      'this    Name'.to_name.key.should == 'this_name'
     end
 
-    it "should have initial _ for initial cap" do
-      "This Name".to_name.key.should == "this_name"
+    it 'should have initial _ for initial cap' do
+      'This Name'.to_name.key.should == 'this_name'
     end
 
-    it "should have initial _ for initial cap" do
-      "_This Name".to_name.key.should == "this_name"
+    it 'should have initial _ for initial cap' do
+      '_This Name'.to_name.key.should == 'this_name'
     end
 
-    it "should singularize" do
-      "ethans".to_name.key.should == "ethan"
+    it 'should singularize' do
+      'ethans'.to_name.key.should == 'ethan'
     end
 
-    it "should underscore" do
-      "ThisThing".to_name.key.should == "this_thing"
+    it 'should underscore' do
+      'ThisThing'.to_name.key.should == 'this_thing'
     end
 
-    it "should handle plus cards" do
-      "ThisThing+Ethans".to_name.key.should == "this_thing+ethan"
+    it 'should handle plus cards' do
+      'ThisThing+Ethans'.to_name.key.should == 'this_thing+ethan'
     end
 
-    it "should retain * for star cards" do
-      "*right".to_name.key.should == "*right"
+    it 'should retain * for star cards' do
+      '*right'.to_name.key.should == '*right'
     end
 
     it "should not singularize double s's" do
-      "grass".to_name.key.should == 'grass'
+      'grass'.to_name.key.should == 'grass'
     end
 
     it "should not singularize letter 'S'" do
       'S'.to_name.key.should == 's'
     end
 
-    it "should handle unicode characters" do
-      "Mañana".to_name.key.should == 'mañana'
+    it 'should handle unicode characters' do
+      'Mañana'.to_name.key.should == 'mañana'
     end
 
-    it "should handle weird initial characters" do
+    it 'should handle weird initial characters' do
       '__you motha @#$'.to_name.key.should == 'you_motha'
       '?!_you motha @#$'.to_name.key.should == 'you_motha'
     end
 
-    it "should allow numbers" do
-      "3way".to_name.key.should == '3way'
+    it 'should allow numbers' do
+      '3way'.to_name.key.should == '3way'
     end
 
-    it "internal plurals" do
-      "cards hooks label foos".to_name.key.should == 'card_hook_label_foo'
+    it 'internal plurals' do
+      'cards hooks label foos'.to_name.key.should == 'card_hook_label_foo'
     end
 
-    it "should handle html entities" do
+    it 'should handle html entities' do
       # This no longer takes off the s, is singularize broken now?
-      "Jean-françois Noubel".to_name.key.should == 'jean_françoi_noubel'
+      'Jean-françois Noubel'.to_name.key.should == 'jean_françoi_noubel'
     end
   end
 
-
-  describe "parts and pieces" do
-    it "should produce simple strings for parts" do
-      "A+B+C+D".to_name.parts.should == %w{ A B C D }
+  describe 'parts and pieces' do
+    it 'should produce simple strings for parts' do
+      'A+B+C+D'.to_name.parts.should == %w( A B C D )
     end
 
-    it "should produce simple name objects for part_names" do
-      "A+B+C+D".to_name.part_names.should == %w{ A B C D }.map( &:to_name )
+    it 'should produce simple name objects for part_names' do
+      'A+B+C+D'.to_name.part_names.should == %w( A B C D ).map(&:to_name)
     end
-    
-    it "should produce compound strings for pieces" do
-      "A+B+C+D".to_name.pieces.should == %w{ A B C D A+B A+B+C A+B+C+D }
+
+    it 'should produce compound strings for pieces' do
+      'A+B+C+D'.to_name.pieces.should == %w( A B C D A+B A+B+C A+B+C+D )
     end
-    
-    it "should produce compound name objects for piece_names" do
-      "A+B+C+D".to_name.piece_names.should == %w{ A B C D A+B A+B+C A+B+C+D }.map( &:to_name )
+
+    it 'should produce compound name objects for piece_names' do
+      'A+B+C+D'.to_name.piece_names.should ==
+        %w( A B C D A+B A+B+C A+B+C+D ).map(&:to_name)
     end
   end
-  
-
 
-
-
-  describe "#url_key" do
-    cardnames = ["GrassCommons.org", 'Oh you @##', "Alice's Restaurant!", "PB & J", "Mañana"].map(&:to_name)
+  describe '#url_key' do
+    cardnames = [
+      'GrassCommons.org',
+      'Oh you @##',
+      "Alice's Restaurant!",
+      'PB & J',
+      'Mañana'
+    ].map(&:to_name)
 
     cardnames.each do |cardname|
-      it "should have the same key as the name" do
-        k, k2 = cardname.key, cardname.url_key
-        #warn "cn tok #{cardname.inspect}, #{k.inspect}, #{k2.inspect}"
-        k.should == k2.to_name.key
+      it 'should have the same key as the name' do
+        cardname.key.should == cardname.url_key.to_name.key
       end
     end
+
+    it 'should handle compound names cleanly' do
+      'What?+the!+heck$'.to_name.url_key.should == 'What+the+heck'
+    end
   end
 
-  describe "#valid" do
-    it "accepts valid names" do
-      "this+THAT".to_name.should be_valid
-      "THE*ONE*AND$!ONLY".to_name.should be_valid
+  describe '#valid' do
+    it 'accepts valid names' do
+      'this+THAT'.to_name.should be_valid
+      'THE*ONE*AND$!ONLY'.to_name.should be_valid
     end
 
-    it "rejects invalide names" do
-      "Tes~sd".to_name.should_not be_valid
-      "TEST/DDER".to_name.should_not be_valid
+    it 'rejects invalide names' do
+      'Tes~sd'.to_name.should_not be_valid
+      'TEST/DDER'.to_name.should_not be_valid
     end
   end
 
-  describe "#left_name" do
-    it "returns nil for non junction" do
-      "a".to_name.left_name.should == nil
+  describe '#left_name' do
+    it 'returns nil for non junction' do
+      'a'.to_name.left_name.should == nil
     end
 
-    it "returns parent for parent" do
-      "a+b+c+d".to_name.left_name.should == "a+b+c"
+    it 'returns parent for parent' do
+      'a+b+c+d'.to_name.left_name.should == 'a+b+c'
     end
   end
 
-  describe "#tag_name" do
-    it "returns last part of plus card" do
-      "a+b+c".to_name.tag.should == "c"
+  describe '#tag_name' do
+    it 'returns last part of plus card' do
+      'a+b+c'.to_name.tag.should == 'c'
     end
 
-    it "returns name of simple card" do
-      "a".to_name.tag.should == "a"
+    it 'returns name of simple card' do
+      'a'.to_name.tag.should == 'a'
     end
   end
 
-  describe "#safe_key" do
-    it "subs pluses & stars" do
-      "Alpha?+*be-ta".to_name.safe_key.should == "alpha-Xbe_tum"
+  describe '#safe_key' do
+    it 'subs pluses & stars' do
+      'Alpha?+*be-ta'.to_name.safe_key.should == 'alpha-Xbe_tum'
     end
   end
 
-  describe "#replace_part" do
-    it "replaces first name part" do
-      'a+b'.to_name.replace_part('a','x').to_s.should == 'x+b'
+  describe '#replace_part' do
+    it 'replaces first name part' do
+      'a+b'.to_name.replace_part('a', 'x').to_s.should == 'x+b'
     end
-    it "replaces second name part" do
-      'a+b'.to_name.replace_part('b','x').to_s.should == 'a+x'
+    it 'replaces second name part' do
+      'a+b'.to_name.replace_part('b', 'x').to_s.should == 'a+x'
     end
-    it "replaces two name parts" do
-      'a+b+c'  .to_name.replace_part('a+b', 'x'  ).to_s.should == 'x+c'
+    it 'replaces two name parts' do
+      'a+b+c'  .to_name.replace_part('a+b', 'x').to_s.should == 'x+c'
       'a+b+c+d'.to_name.replace_part('a+b', 'e+f').to_s.should == 'e+f+c+d'
     end
     it "doesn't replace two part tag" do
-      'a+b+c'.to_name.replace_part('b+c','x').to_s.should == 'a+b+c'
+      'a+b+c'.to_name.replace_part('b+c', 'x').to_s.should == 'a+b+c'
     end
   end
 
-
-  describe "#to_absolute" do
-    it "handles _self, _whole, _" do
-      "_self".to_name.to_absolute("foo").should == "foo"
-      "_whole".to_name.to_absolute("foo").should == "foo"
-      "_".to_name.to_absolute("foo").should == "foo"
+  describe '#to_absolute' do
+    it 'handles _self, _whole, _' do
+      '_self'.to_name.to_absolute('foo').should == 'foo'
+      '_whole'.to_name.to_absolute('foo').should == 'foo'
+      '_'.to_name.to_absolute('foo').should == 'foo'
     end
 
-    it "handles _left" do
-      "_left+Z".to_name.to_absolute("A+B+C").should == "A+B+Z"
+    it 'handles _left' do
+      '_left+Z'.to_name.to_absolute('A+B+C').should == 'A+B+Z'
     end
 
-    it "handles white space" do
-      "_left + Z".to_name.to_absolute("A+B+C").should == "A+B+Z"
+    it 'handles white space' do
+      '_left + Z'.to_name.to_absolute('A+B+C').should == 'A+B+Z'
     end
 
-    it "handles _right" do
-      "_right+bang".to_name.to_absolute("nutter+butter").should == "butter+bang"
-      "C+_right".to_name.to_absolute("B+A").should == "C+A"
+    it 'handles _right' do
+      '_right+bang'.to_name.to_absolute('nutter+butter').should == 'butter+bang'
+      'C+_right'.to_name.to_absolute('B+A').should == 'C+A'
     end
 
-    it "handles leading +" do
-      "+bug".to_name.to_absolute("hum").should == "hum+bug"
+    it 'handles leading +' do
+      '+bug'.to_name.to_absolute('hum').should == 'hum+bug'
     end
 
-    it "handles trailing +" do
-      "bug+".to_name.to_absolute("tracks").should == "bug+tracks"
+    it 'handles trailing +' do
+      'bug+'.to_name.to_absolute('tracks').should == 'bug+tracks'
     end
 
-    it "handles _(numbers)" do
-      "_1".to_name.to_absolute("A+B+C").should == "A"
-      "_1+_2".to_name.to_absolute("A+B+C").should == "A+B"
-      "_2+_3".to_name.to_absolute("A+B+C").should == "B+C"
+    it 'handles _(numbers)' do
+      '_1'.to_name.to_absolute('A+B+C').should == 'A'
+      '_1+_2'.to_name.to_absolute('A+B+C').should == 'A+B'
+      '_2+_3'.to_name.to_absolute('A+B+C').should == 'B+C'
     end
 
-    it "handles _LLR etc" do
-      "_R".to_name.to_absolute("A+B+C+D+E").should    == "E"
-      "_L".to_name.to_absolute("A+B+C+D+E").should    == "A+B+C+D"
-      "_LR".to_name.to_absolute("A+B+C+D+E").should   == "D"
-      "_LL".to_name.to_absolute("A+B+C+D+E").should   == "A+B+C"
-      "_LLR".to_name.to_absolute("A+B+C+D+E").should  == "C"
-      "_LLL".to_name.to_absolute("A+B+C+D+E").should  == "A+B"
-      "_LLLR".to_name.to_absolute("A+B+C+D+E").should == "B"
-      "_LLLL".to_name.to_absolute("A+B+C+D+E").should == "A"
+    it 'handles _LLR etc' do
+      '_R'.to_name.to_absolute('A+B+C+D+E').should    == 'E'
+      '_L'.to_name.to_absolute('A+B+C+D+E').should    == 'A+B+C+D'
+      '_LR'.to_name.to_absolute('A+B+C+D+E').should   == 'D'
+      '_LL'.to_name.to_absolute('A+B+C+D+E').should   == 'A+B+C'
+      '_LLR'.to_name.to_absolute('A+B+C+D+E').should  == 'C'
+      '_LLL'.to_name.to_absolute('A+B+C+D+E').should  == 'A+B'
+      '_LLLR'.to_name.to_absolute('A+B+C+D+E').should == 'B'
+      '_LLLL'.to_name.to_absolute('A+B+C+D+E').should == 'A'
     end
 
-    context "mismatched requests" do
-      it "returns _self for _left or _right on simple cards" do
-        "_left+Z".to_name.to_absolute("A").should == "A+Z"
-        "_right+Z".to_name.to_absolute("A").should == "A+Z"
+    context 'mismatched requests' do
+      it 'returns _self for _left or _right on simple cards' do
+        '_left+Z'.to_name.to_absolute('A').should == 'A+Z'
+        '_right+Z'.to_name.to_absolute('A').should == 'A+Z'
       end
 
-      it "handles bogus numbers" do
-        "_1".to_name.to_absolute("A").should == "A"
-        "_1+_2".to_name.to_absolute("A").should == "A+A"
-        "_2+_3".to_name.to_absolute("A").should == "A+A"
+      it 'handles bogus numbers' do
+        '_1'.to_name.to_absolute('A').should == 'A'
+        '_1+_2'.to_name.to_absolute('A').should == 'A+A'
+        '_2+_3'.to_name.to_absolute('A').should == 'A+A'
       end
 
-      it "handles bogus _llr requests" do
-           "_R".to_name.to_absolute("A").should == "A"
-           "_L".to_name.to_absolute("A").should == "A"
-          "_LR".to_name.to_absolute("A").should == "A"
-          "_LL".to_name.to_absolute("A").should == "A"
-         "_LLR".to_name.to_absolute("A").should == "A"
-         "_LLL".to_name.to_absolute("A").should == "A"
-        "_LLLR".to_name.to_absolute("A").should == "A"
-        "_LLLL".to_name.to_absolute("A").should == "A"
+      it 'handles bogus _llr requests' do
+           '_R'.to_name.to_absolute('A').should == 'A'
+           '_L'.to_name.to_absolute('A').should == 'A'
+          '_LR'.to_name.to_absolute('A').should == 'A'
+          '_LL'.to_name.to_absolute('A').should == 'A'
+         '_LLR'.to_name.to_absolute('A').should == 'A'
+         '_LLL'.to_name.to_absolute('A').should == 'A'
+        '_LLLR'.to_name.to_absolute('A').should == 'A'
+        '_LLLL'.to_name.to_absolute('A').should == 'A'
       end
     end
   end
 
-  describe "#to_show" do
-    it "ignores ignorables" do
+  describe '#to_show' do
+    it 'ignores ignorables' do
          'you+awe'.to_name.to_show('you').should == '+awe'
       'me+you+awe'.to_name.to_show('you').should == 'me+awe' #HMMM..... what should this do?
       'me+you+awe'.to_name.to_show('me' ).should == '+you+awe'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartname
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Gerry Gleason
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-10 00:00:00.000000000 Z
+date: 2016-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport