smartname 0.4.0 → 0.5.0

data/lib/smart_name/manipulate.rb

@@ -0,0 +1,73 @@
+class SmartName
+  module Manipulate
+    # replace a subname
+    # keys are used for comparison
+    def replace old, new
+      old_name = old.to_name
+      new_name = new.to_name
+      return self if old_name.length > length
+      return replace_part(old_name, new_name) if old_name.simple?
+      return self unless include? old_name
+      replace_all_subsequences(old_name, new_name).to_name
+    end
+
+    def replace_part oldpart, newpart
+      ensure_simpliness oldpart, "Use 'replace' to replace junctions"
+
+      oldpart = oldpart.to_name
+      newpart = newpart.to_name
+
+      parts.map do |p|
+        oldpart == p ? newpart : p
+      end.to_name
+    end
+
+    def replace_piece oldpiece, newpiece
+      oldpiece = oldpiece.to_name
+      newpiece = newpiece.to_name
+
+      return replace_part oldpiece, newpiece if oldpiece.simple?
+      return self unless self.starts_with?(oldpiece)
+      return newpiece if oldpiece.length == length
+      newpiece + self[oldpiece.length..-1]
+    end
+
+    private
+
+    def replace_all_subsequences oldseq, newseq
+      res = []
+      i = 0
+      while i <= length - oldseq.length
+        # for performance reasons: check first character first then the rest
+        if oldseq.part_keys.first == part_keys[i] &&
+           oldseq.part_keys == part_keys[i, oldseq.length]
+          res += newseq.parts
+          i += oldseq.length
+        else
+          res << parts[i]
+          i += 1
+        end
+      end
+      res += parts[i..-1] if i < length
+      res
+    end
+
+    def ensure_simpliness part, msg=nil
+      return if part.to_name.simple?
+      raise StandardError, "'#{part}' has to be simple. #{msg}"
+    end
+  end
+
+  # ~~~~~~~~~~~~~~~~~~~~ MISC ~~~~~~~~~~~~~~~~~~~~
+
+  # HACK. This doesn't belong here.
+  # shouldn't it use inclusions???
+  def self.substitute! str, hash
+    hash.keys.each do |var|
+      str.gsub! var_re do |x|
+        hash[var.to_sym]
+      end
+    end
+    str
+  end
+end

data/lib/smart_name/parts.rb

@@ -0,0 +1,124 @@
+class SmartName
+  # naming conventions:
+  # methods that end with _name return name objects
+  # the same methods without _name return strings
+  module Parts
+    attr_reader :parts, :part_keys, :simple
+
+    alias simple? simple
+    alias_method :to_a, :parts
+    alias_method :to_ary, :parts
+
+    def to_ary
+      if parts.empty?
+        [""]
+      else
+        parts
+      end
+    end
+
+    def initialize_parts
+      # -1 = don't suppress trailing null fields
+      @parts = @s.split(/\s*#{JOINT_RE}\s*/, -1)
+      @simple = @parts.size <= 1
+      # simple check needed to avoid inifinite recursion
+      @part_keys =
+        @simple ? [simple_key] : @parts.map { |p| p.to_name.simple_key }
+    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
+
+    def left_key
+      @left_key ||=  simple? ? nil : part_keys[0..-2] * self.class.joint
+    end
+
+    def right_key
+      @right_key ||= simple? ? nil : part_keys.last
+    end
+
+    def parents
+      @parents ||= junction? ? [left, right] : []
+    end
+
+    def parent_names
+      @parent_names ||= junction? ? [left_name, right_name] : []
+    end
+
+    def parent_keys
+      @parent_keys ||= junction? ? [left_key, right_key] : []
+    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
+
+    def piece_names
+      @piece_names ||= pieces.map(&:to_name)
+    end
+
+    # self and all ancestors (= parts and recursive lefts)
+    # @example
+    #   "A+B+C+D".to_name.pieces
+    #   # => ["A", "B", "C", "D", "A+B", "A+B+C", "A+B+C+D"]
+    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
+
+    # name parts can be accessed and manipulated like an array
+    def method_missing method, *args, &block
+      if parts.respond_to?(method)
+        self.class.new parts.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to? method, include_private=false
+      super || parts.respond_to?(method, include_private)
+    end
+  end
+end

data/lib/smart_name/predicates.rb

@@ -0,0 +1,39 @@
+class SmartName
+  module Predicates
+    # @return true if name has more than one part
+    def junction?
+      !simple?
+    end
+
+    def blank?
+      s.blank?
+    end
+    alias empty? blank?
+
+    def valid?
+      !parts.find do |pt|
+        pt.match self.class.banned_re
+      end
+    end
+
+    # @return true if name starts with the same parts as `prefix`
+    def starts_with? prefix
+      start_name = prefix.to_name
+      start_name == self[0, start_name.length]
+    end
+    alias_method :start_with?, :starts_with?
+
+    # @return true if name ends with the same parts as `prefix`
+    def ends_with? postfix
+      end_name = postfix.to_name
+      end_name == self[-end_name.length..-1]
+    end
+    alias_method :end_with?, :ends_with?
+
+    # @return true if name has a chain of parts that equals `subname`
+    def include? subname
+      subkey = subname.to_name.key
+      key =~ /(^|#{JOINT_RE})#{Regexp.quote subkey}($|#{JOINT_RE})/
+    end
+  end
+end

data/lib/smart_name/variants.rb

@@ -0,0 +1,36 @@
+class SmartName
+  module Variants
+    def simple_key
+      return "" if @s.empty?
+      decoded
+        .underscore
+        .gsub(/[^#{OK4KEY_RE}]+/, '_')
+        .split(/_+/)
+        .reject(&:empty?)
+        .map { |key| SmartName.stable_uninflect(key) }
+        .join('_')
+    end
+
+    def url_key
+      @url_key ||= part_names.map do |part_name|
+        stripped = part_name.decoded.gsub(/[^#{OK4KEY_RE}]+/, ' ').strip
+        stripped.gsub(/[\s\_]+/, '_')
+      end * self.class.joint
+    end
+
+    # safe to be used in HTML as id ('*' and '+' are not allowed),
+    # but the key is no longer unique.
+    # For example "A-XB" and "A+*B" have the same safe_key
+    def safe_key
+      @safe_key ||= key.tr('*', 'X').tr self.class.joint, '-'
+    end
+
+    def decoded
+      @decoded ||= s.index('&') ? HTMLEntities.new.decode(s) : s
+    end
+
+    def to_sym
+      s.to_sym
+    end
+  end
+end

data/spec/lib/smart_name/contextual_spec.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+require_relative "../../spec_helper"
+
+RSpec.describe SmartName::Contextual do
+  describe '#to_absolute' do
+    it 'handles _self, _whole, _' do
+      expect('_self'.to_name.to_absolute('foo')).to eq('foo')
+      expect('_whole'.to_name.to_absolute('foo')).to eq('foo')
+      expect('_'.to_name.to_absolute('foo')).to eq('foo')
+    end
+
+    it 'handles _left' do
+      expect('_left+Z'.to_name.to_absolute('A+B+C')).to eq('A+B+Z')
+    end
+
+    it 'handles white space' do
+      expect('_left + Z'.to_name.to_absolute('A+B+C')).to eq('A+B+Z')
+    end
+
+    it 'handles _right' do
+      expect('_right+bang'.to_name.to_absolute('nutter+butter')).to eq('butter+bang')
+      expect('C+_right'.to_name.to_absolute('B+A')).to eq('C+A')
+    end
+
+    it 'handles leading +' do
+      expect('+bug'.to_name.to_absolute('hum')).to eq('hum+bug')
+    end
+
+    it 'handles trailing +' do
+      expect('bug+'.to_name.to_absolute('tracks')).to eq('bug+tracks')
+    end
+
+    it "handles leading + in context" do
+      expect("+B".to_name.to_absolute("+A")).to eq("+A+B")
+    end
+
+    it "handles leading + in context for child" do
+      expect("+A+B".to_name.to_absolute("+A")).to eq("+A+B")
+    end
+
+    it 'handles _(numbers)' do
+      expect('_1'.to_name.to_absolute('A+B+C')).to eq('A')
+      expect('_1+_2'.to_name.to_absolute('A+B+C')).to eq('A+B')
+      expect('_2+_3'.to_name.to_absolute('A+B+C')).to eq('B+C')
+    end
+
+    it 'handles _LLR etc' do
+      expect('_R'.to_name.to_absolute('A+B+C+D+E')).to    eq('E')
+      expect('_L'.to_name.to_absolute('A+B+C+D+E')).to    eq('A+B+C+D')
+      expect('_LR'.to_name.to_absolute('A+B+C+D+E')).to   eq('D')
+      expect('_LL'.to_name.to_absolute('A+B+C+D+E')).to   eq('A+B+C')
+      expect('_LLR'.to_name.to_absolute('A+B+C+D+E')).to  eq('C')
+      expect('_LLL'.to_name.to_absolute('A+B+C+D+E')).to  eq('A+B')
+      expect('_LLLR'.to_name.to_absolute('A+B+C+D+E')).to eq('B')
+      expect('_LLLL'.to_name.to_absolute('A+B+C+D+E')).to eq('A')
+    end
+
+    context 'mismatched requests' do
+      it 'returns _self for _left or _right on simple cards' do
+        expect('_left+Z'.to_name.to_absolute('A')).to eq('A+Z')
+        expect('_right+Z'.to_name.to_absolute('A')).to eq('A+Z')
+      end
+
+      it 'handles bogus numbers' do
+        expect('_1'.to_name.to_absolute('A')).to eq('A')
+        expect('_1+_2'.to_name.to_absolute('A')).to eq('A+A')
+        expect('_2+_3'.to_name.to_absolute('A')).to eq('A+A')
+      end
+
+      it 'handles bogus _llr requests' do
+        expect('_R'.to_name.to_absolute('A')).to eq('A')
+        expect('_L'.to_name.to_absolute('A')).to eq('A')
+        expect('_LR'.to_name.to_absolute('A')).to eq('A')
+        expect('_LL'.to_name.to_absolute('A')).to eq('A')
+        expect('_LLR'.to_name.to_absolute('A')).to eq('A')
+        expect('_LLL'.to_name.to_absolute('A')).to eq('A')
+        expect('_LLLR'.to_name.to_absolute('A')).to eq('A')
+        expect('_LLLL'.to_name.to_absolute('A')).to eq('A')
+      end
+    end
+  end
+
+  describe '#to_show' do
+    it 'ignores ignorables' do
+      expect('you+awe'.to_name.to_show('you')).to eq('+awe')
+      expect('me+you+awe'.to_name.to_show('you')).to eq('me+awe') #HMMM..... what should this do?
+      expect('me+you+awe'.to_name.to_show('me' )).to eq('+you+awe')
+      expect('me+you+awe'.to_name.to_show('me','you')).to eq('+awe')
+      expect('me+you'.to_name.to_show('me','you')).to eq('me+you')
+      expect('?a?+awe'.to_name.to_show('A')).to eq('+awe')
+      expect('+awe'.to_name.to_show()).to eq('+awe')
+      expect('+awe'.to_name.to_show(nil)).to eq('+awe')
+    end
+  end
+
+  describe "#child_of?" do
+    [["A+B",   "A",     true],
+     ["A+B",   "B",     true],
+     ["A+B+C", "A+B",   true],
+     ["A+B+C", "C",     true],
+     ["A+B",   "A+B",   false],
+     ["A+B",   "A+B+C", false],
+     ["A",     "A",     false],
+     ["A+B+C",  "A",    false],
+     ["A+C",   "A+B",   false],
+     ["A+B",   "C+B",   false],
+     ["X+A+B", "A+C",   false],
+     ["+A", "B",         true],
+     ["+A", "A",         true],
+     ["+A", "+D",        true],
+     ["+A", "+A",       false]].each do |a, b, res|
+      it "#{a} is a child of #{b}" do
+        expect(a.to_name.child_of?(b)).to be res
+      end
+    end
+  end
+
+  describe "#relative_name" do
+    [["A+B",   "A",   "+B"],
+     ["A+B",   "B",   "A"],
+     ["A",     "A",   "A"],
+     ["A+B",   "A+B", "A+B"],
+     ["A",     "A+B", "A"],
+     ["A+C",   "A+B", "+C"],
+     ["A+B",   "C+B", "A"],
+     ["X+A+B", "A+C", "X+B"]].each do |name, context, res|
+      it "#{name} relative to #{context} is #{res}" do
+        expect(name.to_name.relative_name(context).to_s).to eq res
+      end
+    end
+  end
+
+end

data/spec/lib/smart_name/manipulate_spec.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+require_relative "../../spec_helper"
+
+RSpec.describe SmartName::Manipulate do
+  describe '#replace' do
+    def replace str, change
+      str.to_name.replace(*change.to_a.flatten).to_s
+    end
+
+    it 'replaces first name part' do
+      expect(replace 'a+b', 'a' => 'x').to eq('x+b')
+    end
+    it 'replaces last name part' do
+      expect(replace 'a+b', 'b' => 'x').to eq('a+x')
+    end
+    it 'replaces middle name part' do
+      expect(replace 'a+c+b', 'c' => 'x').to eq('a+x+b')
+    end
+    it 'replaces all occurences' do
+      expect(replace'a+c+b+c+c','c' => 'x').to eq('a+x+b+x+x')
+    end
+    it 'replaces junction' do
+      expect(replace'a+b+c', 'a+b' => 'x').to eq('x+c')
+      expect(replace'a+b+c+d', 'a+b' => 'e+f').to eq('e+f+c+d')
+    end
+    it "replaces two part tag" do
+      expect(replace'a+b+c','b+c' => 'x').to eq('a+x')
+    end
+    it "replaces whole name" do
+      expect(replace'a+b+c','a+b+c' => 'x').to eq('x')
+    end
+
+    it "replaces based on key match" do
+      expect(replace'A+ b +C?','a+b+c' => 'x').to eq('x')
+    end
+    it "replaces with original format" do
+      expect(replace'a+b','a+B' => 'X?+C').to eq('X?+C')
+    end
+  end
+
+  describe '#replace_part' do
+    def replace str, change
+      str.to_name.replace_part(*change.to_a.flatten).to_s
+    end
+    it 'replaces all occurences' do
+      expect(replace'a+c+b+c+c','c' => 'x').to eq('a+x+b+x+x')
+    end
+    context "first argument is not a part" do
+      it 'raises error' do
+        expect { replace('a+c+b','a+c' => 'x') }.to raise_error(StandardError, /has to be simple/)
+      end
+    end
+  end
+
+  describe '#replace_piece' do
+    def replace str, change
+      str.to_name.replace_piece(*change.to_a.flatten).to_s
+    end
+    it "replaces two part trunk" do
+      expect(replace('a+b+c', 'a+b' =>'x')).to eq('x+c')
+    end
+    it "doesn't replace two part tag" do
+      expect(replace('a+b+c', 'b+c' => 'x')).to eq('a+b+c')
+    end
+    it "replaces whole name" do
+      expect(replace'a+b+c','a+b+c' => 'x').to eq('x')
+    end
+    it "replaces based on key match" do
+      expect(replace'A+ b +C?','a+b+c' => 'x').to eq('x')
+    end
+    it "replaces with original format" do
+      expect(replace'a+b','a+B' => 'X?+C').to eq('X?+C')
+    end
+  end
+end