namelogic 0.0.1 → 0.0.3

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.3

data/lib/name_logic.rb

@@ -1,193 +1,301 @@
 # -*- encoding : utf-8 -*-
-class NameLogic < String
 
-  # do: Object.send :include, NameLogic::ObjectMethods to enable x.to_name
-  module ObjectMethods
-    def to_name() NameLogic.new(self) end
-  end
-
-  require 'htmlentities'
-
-  class << self
-    attr_accessor :joint, :banned_array, :banned_re, :var_match,
-      :formal_joint, :uninflect, :name2nameobject
-  end
+require 'active_support/inflector'
 
-  def method_missing meth, *args
-    if self.class.respond_to? meth
-      self.class.send meth, *args
-    else raise end
-  end
+class Object
+  def to_name() NameLogic.new(self) end
+end
 
+class NameLogic < Object
+  require 'htmlentities'
 
   # Wagny defaults
-  JOINT             = ?+
-  BANNED_ARRAY      = [ ?/, ?~, ?| ]
+  JOINT             = '+'
+  BANNED_ARRAY      = [ '/', '~', '|' ]
   BANNED_CHARACTERS = BANNED_ARRAY * ' '
 
   VAR_MATCH         = /\{([^\}]*})\}/
-  WORD_RE           = RUBY_VERSION =~ /^1\.9/ ? '\p{Word}/' : '/\w/'
   SINGULAR          = :singularize
 
-  @name2nameobject = {}
+  RUBY19            = RUBY_VERSION =~ /^1\.9/
+  WORD_RE           = RUBY19 ? '\p{Word}' : '\w'
 
   # reset these class instance vars to your system's to customize name syntax
-  @joint = JOINT
-  @formal_joint = " <span class=\"wiki-joint\">#{JOINT}</span> "
-  @banned_array = BANNED_ARRAY
-  @banned_re = /#{ ([?[] + @banned_array << @joint )*?\\ }#{ ?] }/
-  @var_match = VAR_MATCH
-  @uninflect = SINGULAR
+  @@joint = JOINT
+  @@formal_joint = " <span class=\"wiki-joint\">#{JOINT}</span> "
+  @@banned_array = BANNED_ARRAY
+  @@banned_re = /#{ (['['] + @@banned_array << @@joint )*'\\' }#{ ']' }/
+  @@var_match = VAR_MATCH
+  @@uninflect = SINGULAR
+  @@name_attribute = :cardname
+  @@main_hash = {:main_name=>''}
+  @@code_hash = defined?(Card) ? Card : {}
+
+  @@name2nameobject = {}
 
   class << self
     def new obj
       return obj if NameLogic===obj
-      str = Array===obj ? obj*joint : obj.to_s
-      return obj if obj = name2nameobject[str]
-      super str.strip
+      str = Array===obj ? obj*@@joint : obj.to_s
+      if known_name = @@name2nameobject[str]
+        known_name
+      else
+        super str.strip
+      end
+    end
+
+    def set_code_hash hash
+      @@code_hash = hash
+    end
+
+    def set_main_hash hash
+      @@main_hash = hash
     end
 
-    def user() '' end # override to fetch your user string for _user subs
+    def unescape uri
+      # can't instantiate because key doesn't resolve correctly in unescaped form
+      # issue is peculiar to plus sign (+), which are interpreted as a space.
+      # if we could make that not happen, we could avoid this (and handle spaces in urls)
+      uri.gsub(' ','+').gsub '_',' '
+    end
+
+    # class var setters to change defaults, consider a config obect?
+    def joint() @@joint end
+    def joint @@joint=(v) = v end
+    def formal_joint() @@formal_joint end
+    def formal_joint=(v) @@formal_joint = v end
+    def banned_array() @@banned_array end
+    def banned_array=(v) @@banned_array = v end
+    def banned_re() @@banned_re end
+    def banned_re=(v) @@banned_re = v end
+    def var_match() @@var_match end
+    def var_match=(v) @@var_match = v end
+    def uninflect() @@uninflect end
+    def uninflect=(v) @@uninflect = v end
+    def name_attribute() @@name_attribute end
+    def name_attribute=(v) @@name_attribute = v end
+    def main_hash() @@main_hash end
+    def main_hash=(v) @@main_hash = v end
+    def code_hash() @@code_hash end
+    def code_hash=(v) @@code_hash = v end
   end
 
-  attr_reader :simple, :parts, :key
-  alias to_key key
+
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~ INSTANCE ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  attr_reader :simple, :parts, :key, :s
+  alias to_s s
 
   def initialize str
-    super str
-    #warn "init #{str.inspect}, #{inspect}, #{self.class.joint}, #{joint}"
-    @key = if index joint
-        @parts = str.split(/\s*#{Regexp.escape(joint)}\s*/)
-        @parts << '' if str[-1] == joint
+    @s = str.to_s.strip
+    @s = @s.encode('UTF-8') if RUBY19
+    @key = if @s.index(@@joint)
+        @parts = @s.split(/\s*#{Regexp.escape(@@joint)}\s*/)
+        @parts << '' if @s[-1] == @@joint
         @simple = false
-        @parts.map{|p| p.to_name.key } * joint  
+        @parts.map { |p| p.to_name.key } * @@joint
       else
         @parts = [str]
         @simple = true
-        empty? ? '' : generate_simple_key
+        str.empty? ? '' : simple_key
       end
-    name2nameobject[str] = self
+    @@name2nameobject[str] = self
   end
-  
-  def generate_simple_key
-    decode_html.underscore.gsub(/[^#{WORD_RE}\*]+/,'_').split(/_+/).reject(&:empty?).map(&uninflect)*?_
+
+  def to_name()    self                                           end
+  def valid?()     not parts.find { |pt| pt.match @@banned_re }   end
+  def length()     parts.length                                   end
+  def size()       to_s.size                                      end
+  def blank?()     s.blank?                                       end
+  alias empty? blank?
+
+  def inspect
+    "<NameLogic key=#{key}[#{self}]>"
   end
-  
-  def decode_html
-    @decoded ||= (index(?&) ?  HTMLEntities.new.decode(to_s) : to_s)
+
+  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
+      end
+    object_key == key
   end
-  
-  alias simple? simple
-  
-  def inspect() "<Name key=#{key}[#{self}, #{parts ? parts.size : 'no size'}]>" end
 
-  def self.unescape(uri) uri.gsub(' ','+').gsub('_',' ')             end
 
-  def self.substitute!( str, hash )
-    str.gsub!(var_match) { |x| (v=hash[var.to_sym]).nil? ? x : v }
-    str
-  end   
+  #~~~~~~~~~~~~~~~~~~~ VARIANTS ~~~~~~~~~~~~~~~~~~~
 
-  def ==(obj)
-    obj.nil? ? false :
-      key == (obj.respond_to?(:to_key) ? obj.to_key :
-             obj.respond_to?(:to_name) ? obj.to_name.key : obj.to_s)
+  def simple_key
+    decoded.underscore.gsub(/[^#{WORD_RE}\*]+/,'_').split(/_+/).reject(&:empty?).map(&@@uninflect)*'_'
   end
 
-  def size()    parts.size                                end
-  def to_name() self                                      end
-  def valid?()  not parts.find {|pt| pt.match(banned_re)} end
+  def url_key
+    @url_key ||= decoded.gsub(/[^\*#{WORD_RE}\s\+]/,' ').strip.gsub(/[\s\_]+/,'_')
+  end
 
-  def replace_part( oldpart, newpart )
-    oldpart = oldpart.to_name unless NameLogic===oldpart
-    newpart = newpart.to_name unless NameLogic===newpart
-    if oldpart.simple?
-      simple? ? (self == oldpart ? newpart : self) :
-                  parts.map{ |p| oldpart == p ? newpart : p }.to_name
-    elsif simple?
-      self
-    else
-      oldpart == parts[0, oldpart.size] ?
-        ((self.size == oldpart.size) ? newpart :
-           (newpart.parts+(parts[oldpart.size,].lines.to_a)).to_name) : self
-    end
+  def safe_key
+    @safe_key ||= key.gsub('*','X').gsub @@joint, '-'
   end
 
+  def decoded
+    @decoded ||= (s.index('&') ?  HTMLEntities.new.decode(s) : s)
+  end
 
-  def tag_name()      simple? ? self : parts[-1]                      end
-  def left_name()     simple? ? nil  : self.class.new(parts[0..-2])   end
-  def trunk_name()    simple? ? self : self.class.new(parts[0..-2])   end
-  def junction?()     not simple?                                     end
-  alias particle_names parts
+    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~'
+    end
 
-  def module_name()   gsub(/^\*/,'X_').gsub(/[\b\s]+/,'_').camelcase  end
-  def css_name()      @css_name ||= key.gsub('*','X').gsub('+','-')   end
+    def post_cgi
+      #hmm.  this could resolve to the key of some other card.  move to class method?
+      @post_cgi ||= s.gsub '~plus~', @@joint
+    end
 
-  def to_star()       star? ? self : ?*+self                          end
-  def star?()         simple? and self[0] == ?*                       end
-  def tag_star?()     junction? and ?* == parts[-1][0]                end
-  alias rstar? tag_star?
-  def star_rule(star)
-    star = star.to_s
-    [self, star.index(?*) ? star : ?*+star].to_name
-  end
+    #~~~~~~~~~~~~~~~~~~~ PARTS ~~~~~~~~~~~~~~~~~~~
 
-  alias blank? empty?
+    alias simple? simple
+    def junction?()     not simple?                                        end
 
-  def pre_cgi()          parts * '~plus~'                            end
-  def escape()           gsub(' ','_')                               end
+    def left()          @left  ||= simple? ? nil : parts[0..-2]*@@joint      end
+    def right()         @right ||= simple? ? nil : parts[-1]               end
 
-  def to_url_key()
-    @url_key ||= decode_html.gsub(/[^\*#{WORD_RE}\s\+]/,' ').
-      strip.gsub(/[\s\_]+/,'_')
-  end
+    def left_name()     @left_name  ||= left  && self.class.new( left  )   end
+    def right_name()    @right_name ||= right && self.class.new( right )   end
 
-  def piece_names()
-    simple? ? [self] : ([self] + trunk_name.piece_names + [tag_name]).uniq
-  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 to_show(context)
-    # FIXME this is not quite right.  distinction is that is leaves blank parts blank.
-    (self =~/\b_(left|right|whole|self|user|main|\d+|L*R?)\b/) ?
-       to_absolute(context) : self
+    def trunk_name()    @trunk_name ||= simple? ? self : left_name         end
+    def tag_name()      @tag_name   ||= simple? ? self : right_name        end
+
+    def pieces
+      @pieces ||= if simple?
+        [ self ]
+      else
+        trunk_name.pieces + [ tag_name ]
+      end
+    end
+
+
+    #~~~~~~~~~~~~~~~~~~~ TRAITS / STARS ~~~~~~~~~~~~~~~~~~~
+
+  def star?()         simple?   and '*' == s[0]               end
+  def rstar?()        right     and '*' == right[0]           end
+
+  def trait_name? *traitlist
+    junction? && begin
+      right_key = right_name.key
+      !!traitlist.find do |codename|
+        #puts "tn? #{codename}, #{traitlist.inspect}, #{@@code_hash[codename]}\n"
+        codecard = @@code_hash[ codename ] and codecard.send(@@name_attribute).key == right_key
+      end
+    end
   end
 
-  def escapeHTML(args)
-    args ? parts.map { |p| p =~ /^_/ and args[p] ? args[p] : p }*joint : self
+  def trait_name tag_code
+    codecard = @@code_hash[ tag_code ] and 
+      [ self, @@code_hash[ tag_code ].name ].to_name
   end
 
-  def to_absolute_name(rel_name=nil)
-    (rel_name || self).to_name.to_absolute(self)
+  def trait tag_code
+    trait_name( tag_code ).s
   end
 
-  def nth_left(n)
-    (n >= size ? parts[0] : parts[0..-n-1]).to_name
+
+
+  #~~~~~~~~~~~~~~~~~~~~ SHOW / ABSOLUTE ~~~~~~~~~~~~~~~~~~~~
+
+  def to_show context, args={}
+#      ignore = [ args[:ignore], context.to_name.parts ].flatten.compact.map &:to_name
+    ignore = [ args[:ignore] ].flatten.map &:to_name
+    fullname = parts.to_name.to_absolute_name context, args
+
+    show_parts = fullname.parts.map do |part|
+      reject = ( part.empty? or part =~ /^_/ or ignore.member? part.to_name )
+      reject ? nil : part
+    end
+
+    initial_blank = show_parts[0].nil?
+    show_name = show_parts.compact.to_name.s
+
+    initial_blank ? @@joint + show_name : show_name
   end
 
-  def to_absolute(context, params=nil)
+
+  def to_absolute context, args={}
     context = context.to_name
     parts.map do |part|
       new_part = case part
-        #when /^_user$/i;            user || part
-        when /^_main$/i;            Wagn::Conf[:main_name]
-        when /^(_self|_whole|_)$/i; context
-        when /^_left$/i;            context.trunk_name
-        when /^_right$/i;           context.tag_name
-        when /^_(\d+)$/i;
+        when /^_user$/i;            (user=Session.user_card) ? user.name : part
+        when /^_main$/i;            main_hash[: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
+        when /^_(\d+)$/i
           pos = $~[1].to_i
-          pos = context.size if pos > context.size
+          pos = context.length if pos > context.length
           context.parts[pos-1]
         when /^_(L*)(R?)$/i
-          l_s, r_s = $~[1].size, $~[2].empty?
-          trunk = context.nth_left(l_s)
-          r= r_s ? trunk.to_s : trunk.tag_name
+          l_s, r_s = $~[1].size, !$~[2].empty?
+          l_part = context.nth_left l_s
+          r_s ? l_part.tag : l_part.s
         when /^_/
-          (params && ppart = params[part]) ? CGI.escapeHTML( ppart ) : part
-        else                     part
-      end.strip
-      new_part.empty? ? context : new_part
-    end * joint
+          custom = args[:params] ? args[:params][part] : nil
+          custom ? CGI.escapeHTML(custom) : part #why are we escaping HTML here?
+        else
+          part
+        end.to_s.strip
+      new_part.empty? ? context.to_s : new_part
+    end * @@joint
   end
 
-end
+  def to_absolute_name *args
+    self.class.new to_absolute(*args)
+  end
+
+  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
+  end
+
+
+  #~~~~~~~~~~~~~~~~~~~~ MISC ~~~~~~~~~~~~~~~~~~~~
 
+  def replace_part oldpart, newpart
+    oldpart = oldpart.to_name
+    newpart = newpart.to_name
+    if oldpart.simple?
+      if simple?
+        self == oldpart ? newpart : self
+      else
+        parts.map do |p|
+          oldpart == p ? newpart.to_s : p
+        end.to_name
+      end
+    elsif simple?
+      self
+    else
+      if oldpart == parts[0, oldpart.length]
+        if self.length == oldpart.length
+          newpart
+        else
+          (newpart.parts+(parts[oldpart.length,].lines.to_a)).to_name
+        end
+      else
+        self
+      end
+    end
+  end
+
+  def self.substitute! str, hash
+    hash.keys.each do |var|
+      str.gsub!(@@var_match) { |x| (v=hash[var.to_sym]).nil? ? x : v }
+    end
+    str
+  end
+
+end

data/spec/inflection_helper.rb

@@ -0,0 +1,12 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format 
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.irregular 'grave', 'graveyard'
+  inflect.uncountable 'this'
+#  inflect.uncountable 'plus'
+  inflect.uncountable 'anonymous'
+  inflect.uncountable /^s$/
+  inflect.singular(/(ss)$/i, '\1')
+  inflect.plural(/(ss)$/i, '\1')
+end

data/spec/lib/name_logic_spec.rb

@@ -3,55 +3,168 @@ require File.expand_path('../spec_helper', File.dirname(__FILE__))
 
 describe NameLogic do
   
-  describe "#to_key" do
+  describe "#key" do
     it "should remove spaces" do
-      "This Name".to_name.to_key.should == "this_name"
+      "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"
+    end
+  
+    it "should have initial _ for initial cap" do
+      "_This Name".to_name.key.should == "this_name"
     end
   
     it "should singularize" do
-      "ethans".to_name.to_key.should == "ethan"
+      "ethans".to_name.key.should == "ethan"
     end                               
   
     it "should underscore" do 
-      "ThisThing".to_name.to_key.should == "this_thing"
+      "ThisThing".to_name.key.should == "this_thing"
     end
   
     it "should handle plus cards" do
-      "ThisThing+Ethans".to_name.to_key.should == "this_thing+ethan"
+      "ThisThing+Ethans".to_name.key.should == "this_thing+ethan"
     end          
   
     it "should retain * for star cards" do
-      "*right".to_name.to_key.should == "*right"
+      "*right".to_name.key.should == "*right"
     end
   
     it "should not singularize double s's" do
-      "grass".to_name.to_key.should == 'grass'    
+      "grass".to_name.key.should == 'grass'    
     end
     
     it "should not singularize letter 'S'" do
-      'S'.to_name.to_key.should == 's'
+      'S'.to_name.key.should == 's'
     end
     
     it "should handle unicode characters" do
-      "Mañana".to_name.to_key.should == 'mañana'
+      "Mañana".to_name.key.should == 'mañana'
     end
     
     it "should handle weird initial characters" do
-      '__you motha @#$'.to_name.to_key.should == 'you_motha'
-      '?!_you motha @#$'.to_name.to_key.should == 'you_motha'
+      '__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.to_key.should == '3way'
+      "3way".to_name.key.should == '3way'
     end
     
     it "internal plurals" do
-      "cards hooks label foos".to_name.to_key.should == 'card_hook_label_foo'
+      "cards hooks label foos".to_name.key.should == 'card_hook_label_foo'
     end
 
     it "should handle html entities" do
       # This no longer takes off the s, is singularize broken now?
-      "Jean-françois Noubel".to_name.to_key.should == 'jean_françoi_noubel'
+      "Jean-françois Noubel".to_name.key.should == 'jean_françoi_noubel'
+    end
+  end
+  
+
+  
+
+
+  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
+      end
+    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
+    end           
+    
+    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
+    end
+    
+    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"  
+    end
+    
+    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"
+    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'
+    end
+    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'
+    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'
+    end
+  end  
+
+  describe "Cardnames star handling" do
+    it "recognizes star cards" do
+      '*a'.to_name.star?.should be_true
+    end
+
+    it "doesn't recognize star cards with plusses" do
+      '*a+*b'.to_name.star?.should be_false
+    end
+
+    it "recognizes rstar cards" do
+      'a+*a'.to_name.rstar?.should be_true
+    end
+
+    it "doesn't recognize star cards as rstar" do
+      '*a'.to_name.rstar?.should be_false
+    end
+
+    it "doesn't recognize non-star or star left" do
+      '*a+a'.to_name.rstar?.should be_false
+    end
+  end
+  
+  describe "trait_name?" do
+    it "returns true for content codename" do
+      "bazoinga+*right+*content".to_name.trait_name?(:content).should be_true
+    end
+
+    it "handles arrays" do
+      "bazoinga+*right+*content".to_name.trait_name?(:content, :default).should be_true
+    end
+    
+    it "returns false for non-template" do
+      "bazoinga+*right+nontent".to_name.trait_name?(:content).should be_false
     end
   end
   
@@ -101,7 +214,7 @@ describe NameLogic do
     end
     
     context "mismatched requests" do
-      it "returns _self for _left or _right on non-junctions" 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
@@ -125,70 +238,14 @@ describe NameLogic do
     end
   end
   
-
-
-  describe "#to_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.to_key, cardname.to_url_key
-        #warn "cn tok #{cardname.inspect}, #{k.inspect}, #{k2.inspect}"
-        k.should == k2.to_name.to_key
-      end
-    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
-    end           
-    
-    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
-    end
-    
-    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_name.should == "c"  
-    end
-    
-    it "returns name of simple card" do
-      "a".to_name.tag_name.should == "a"
+  describe "#to_show" do
+    it "ignores ignorables" do
+               'you+awe'.to_name.to_show('A', :ignore=>'you'        ).should == '+awe'
+            'me+you+awe'.to_name.to_show('A', :ignore=>'you'        ).should == 'me+awe' #HMMM..... what should this do?
+            'me+you+awe'.to_name.to_show('A', :ignore=>['me','you'] ).should == '+awe'
+      '_left+_right+awe'.to_name.to_show('A+B', :ignore=>'A'        ).should == '+B+awe'
+               '?a?+awe'.to_name.to_show('B', :ignore=>'A'          ).should == '+awe'
     end
   end
-
-  describe "#css_name" do
-    it "subs pluses & stars" do
-      "Alpha?+*be-ta".to_name.css_name.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'
-    end
-    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'
-    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'
-    end
-  end  
+  
 end

data/spec/spec_helper.rb

@@ -1,15 +1,25 @@
-require File.expand_path(File.dirname(__FILE__) + "/../lib/name_logic")
-require 'active_support/inflector'
-
-# Add new inflection rules using the following format 
-ActiveSupport::Inflector.inflections do |inflect|
-   inflect.irregular 'grave', 'graveyard'
-   inflect.uncountable 'this'
-   #  inflect.uncountable 'plus'
-   inflect.uncountable 'anonymous'
-   inflect.uncountable /^s$/
-   inflect.singular(/(ss)$/i, '\1')
-   inflect.plural(/(ss)$/i, '\1')
+
+require 'name_logic'
+require File.expand_path('./inflection_helper', File.dirname(__FILE__))
+
+class CardMock < String
+  def name() to_name end
+end
+
+NameLogic.name_attribute= :name
+NameLogic.code_hash= { :content => CardMock.new('*content'), }
+
+RSpec.configure do |config|
+  
+  #config.include CustomMatchers
+  #config.include ControllerMacros, :type=>:controllers
+  #config.include AuthenticatedTestHelper, :type=>:controllers
+  #config.include(EmailSpec::Helpers)
+  #config.include(EmailSpec::Matchers)
+  
+  # == Mock Framework
+  # If you prefer to mock with mocha, flexmock or RR, uncomment the appropriate symbol:
+  # :mocha, :flexmock, :rr
+
 end
 
-Object.send :include, NameLogic::ObjectMethods

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: namelogic
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-24 00:00:00.000000000 Z
+date: 2012-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: htmlentities
-  requirement: &9304420 !ruby/object:Gem::Requirement
+  requirement: &9300760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 4.3.0
   type: :runtime
   prerelease: false
-  version_requirements: *9304420
+  version_requirements: *9300760
 - !ruby/object:Gem::Dependency
   name: active_support
-  requirement: &9303140 !ruby/object:Gem::Requirement
+  requirement: &9300220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *9303140
+  version_requirements: *9300220
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &9318660 !ruby/object:Gem::Requirement
+  requirement: &9299660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *9318660
+  version_requirements: *9299660
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &9317780 !ruby/object:Gem::Requirement
+  requirement: &9298960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '3.12'
   type: :development
   prerelease: false
-  version_requirements: *9317780
+  version_requirements: *9298960
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &9317080 !ruby/object:Gem::Requirement
+  requirement: &9314540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 1.1.0
   type: :development
   prerelease: false
-  version_requirements: *9317080
+  version_requirements: *9314540
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &9314980 !ruby/object:Gem::Requirement
+  requirement: &9313820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +76,7 @@ dependencies:
         version: 1.8.3
   type: :development
   prerelease: false
-  version_requirements: *9314980
+  version_requirements: *9313820
 description: Wiki Segmented Name Logic
 email: gerryg@inbox.com
 executables: []
@@ -90,6 +90,7 @@ files:
 - Rakefile
 - VERSION
 - lib/name_logic.rb
+- spec/inflection_helper.rb
 - spec/lib/name_logic_spec.rb
 - spec/spec_helper.rb
 - test.rb
@@ -113,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4038131039544687550
+      hash: 2225341963327626641
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: