smartname 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25ae787d7849fe77b765c1465ed2b1a534f8206a
-  data.tar.gz: c27cf085aecc946cb2a40fdd3fd1489a1c146efc
+  metadata.gz: db3a78f4a254d599ca83a93a19d14a61a37c8b05
+  data.tar.gz: 1889454b39276d368ea7ae05b53e255c9f559490
 SHA512:
-  metadata.gz: e72752157b7207b45fc2633311183a66522a9115c39618be0f5b309e86a333a1ce8c2aab2be7cfb7884384f61dfd4419547de8b8c0f9df619e5fedcf05407d75
-  data.tar.gz: db06e0e3472152b197177d663ee67132b29397b643beebaa6049470cf945908dd07da0f3bff3b7d9fa37c0b870551347ffb181c4c6ec538d718ef4f350417598
+  metadata.gz: aa470ffc741acea8d1d3b3e22c9a61d8b79de9f2f2650c5f08d669e7920bc1c237cdd4310f6cbfef8ab8ccde0243a64dfc07cfd4895bbdafe14b19aa5f9ff8cf
+  data.tar.gz: 50be6deee20d1b2c0554645786be70167ceaf8b41147fe982dc42fac5d59d84290ffc1952c39e5a05251bada945244534817bf532ba3e0a151d3963d86902cc7

data/Gemfile.lock

@@ -1,17 +1,18 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (5.0.0.1)
+    activesupport (5.0.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    addressable (2.4.0)
-    builder (3.2.2)
-    concurrent-ruby (1.0.2)
+    addressable (2.5.0)
+      public_suffix (~> 2.0, >= 2.0.2)
+    builder (3.2.3)
+    concurrent-ruby (1.0.4)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
-    diff-lcs (1.2.5)
+    diff-lcs (1.3)
     faraday (0.9.2)
       multipart-post (>= 1.2, < 3)
     git (1.3.0)
@@ -23,39 +24,40 @@ GEM
       multi_json (>= 1.7.5, < 2.0)
       nokogiri (~> 1.6.0)
       oauth2
-    hashie (3.4.6)
+    hashie (3.5.4)
     highline (1.7.8)
     htmlentities (4.3.4)
-    i18n (0.7.0)
-    jeweler (2.1.2)
+    i18n (0.8.1)
+    jeweler (2.3.3)
       builder
       bundler (>= 1.0)
       git (>= 1.2.5)
       github_api (~> 0.11.0)
       highline (>= 1.6.15)
       nokogiri (>= 1.5.10)
+      psych (~> 2.2)
       rake
       rdoc
-      semver
-    json (1.8.3)
+      semver2
     jwt (1.5.6)
     mini_portile2 (2.1.0)
-    minitest (5.9.1)
+    minitest (5.10.1)
     multi_json (1.12.1)
-    multi_xml (0.5.5)
+    multi_xml (0.6.0)
     multipart-post (2.0.0)
     nokogiri (1.6.8.1)
       mini_portile2 (~> 2.1.0)
-    oauth2 (1.2.0)
-      faraday (>= 0.8, < 0.10)
+    oauth2 (1.3.0)
+      faraday (>= 0.8, < 0.11)
       jwt (~> 1.0)
       multi_json (~> 1.3)
       multi_xml (~> 0.5)
       rack (>= 1.2, < 3)
+    psych (2.2.4)
+    public_suffix (2.0.5)
     rack (2.0.1)
-    rake (11.3.0)
-    rdoc (4.2.2)
-      json (~> 1.4)
+    rake (12.0.0)
+    rdoc (5.1.0)
     rspec (3.5.0)
       rspec-core (~> 3.5.0)
       rspec-expectations (~> 3.5.0)
@@ -69,8 +71,8 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.5.0)
     rspec-support (3.5.0)
-    semver (1.0.1)
-    thread_safe (0.3.5)
+    semver2 (3.4.2)
+    thread_safe (0.3.6)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
 

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/lib/smart_name.rb

@@ -3,41 +3,61 @@
 require 'active_support/configurable'
 require 'active_support/inflector'
 require 'htmlentities'
+require_relative 'smart_name/parts'
+require_relative 'smart_name/variants'
+require_relative 'smart_name/contextual'
+require_relative 'smart_name/predicates'
+require_relative 'smart_name/manipulate'
 
 class SmartName < Object
+
+  include Parts
+  include Variants
+  include Contextual
+  include Predicates
+  include Manipulate
+
   RUBYENCODING = RUBY_VERSION !~ /^1\.8/
   OK4KEY_RE    = RUBYENCODING ? '\p{Word}\*' : '\w\*'
 
   include ActiveSupport::Configurable
 
-  config_accessor :joint, :banned_array, :var_re, :uninflect, :params, :session, :stabilize
+  config_accessor :joint, :banned_array, :var_re, :uninflect, :params,
+                  :session, :stabilize
 
   SmartName.joint          = '+'
   SmartName.banned_array   = ['/', '~', '|']
   SmartName.var_re         = /\{([^\}]*\})\}/
   SmartName.uninflect      = :singularize
-  SmartName.stabilize      = false       
-  
+  SmartName.stabilize      = false
 
   JOINT_RE = Regexp.escape joint
 
-  @@name2nameobject = {}
+  @@name2nameobject = {} # name cache
 
   class << self
     def new obj
       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
+      str = stringify obj
+      known_name(str) || super(str.strip)
+    end
+
+    def known_name str
+      @@name2nameobject[str]
+    end
+
+    def stringify obj
+      if obj.is_a?(Array)
+        obj.map(&:to_s) * joint
       else
-        super str.strip
+        obj.to_s
       end
     end
 
     def banned_re
       %r{#{ (['['] + banned_array << joint) * '\\' + ']' }}
     end
-    
+
     # Sometimes the core rule "the key's key must be itself" (called "stable" below) is violated
     # eg. it fails with singularize as uninflect method for Matthias -> Matthia -> Matthium
     # Usually that means the name is a proper noun and not a plural.
@@ -55,23 +75,14 @@ class SmartName < Object
 
   # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   # ~~~~~~~~~~~~~~~~~~~~~~ INSTANCE ~~~~~~~~~~~~~~~~~~~~~~~~~
-
-  attr_reader :simple, :parts, :key, :s
+  attr_reader :key, :s
   alias to_s s
 
   def initialize str
     @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
+    initialize_parts
+    @key = @part_keys.join(self.class.joint)
     @@name2nameobject[str] = self
   end
 
@@ -87,17 +98,6 @@ class SmartName < Object
     to_s.size
   end
 
-  def blank?
-    s.blank?
-  end
-  alias empty? blank?
-
-  def valid?
-    !parts.find do |pt|
-      pt.match self.class.banned_re
-    end
-  end
-
   def inspect
     "<#{self.class.name} key=#{key}[#{self}]>"
   end
@@ -111,195 +111,4 @@ class SmartName < Object
       end
     other_key == key
   end
-
-  # ~~~~~~~~~~~~~~~~~~~ VARIANTS ~~~~~~~~~~~~~~~~~~~
-
-  def simple_key
-    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
-
-  def safe_key
-    @safe_key ||= key.tr('*', 'X').tr self.class.joint, '-'
-  end
-
-  def decoded
-    @decoded ||= s.index('&') ? HTMLEntities.new.decode(s) : s
-  end
-
-  # ~~~~~~~~~~~~~~~~~~~ PARTS ~~~~~~~~~~~~~~~~~~~
-
-  alias simple? simple
-  def junction?
-    !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 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
-
-  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)
-
-    show_parts = parts.map do |part|
-      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? 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
-          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]
-        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?
-        else
-          part
-        end.to_s.strip
-      new_part.empty? ? context.to_s : new_part
-    end * self.class.joint
-  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 length == oldpart.length
-          newpart
-        else
-          (newpart.parts + parts[oldpart.length..-1]).to_name
-        end
-      else
-        self
-      end
-    end
-  end
-
-  # 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/contextual.rb

@@ -0,0 +1,113 @@
+class SmartName
+  module Contextual
+    RELATIVE_REGEXP = /\b_(left|right|whole|self|user|main|\d+|L*R?)\b/
+
+    def relative_name context_name
+      to_show(*context_name.to_name.parts).to_name
+    end
+
+    def absolute_name context_name
+      to_absolute_name(context_name)
+    end
+
+    # @return true if name is left or right of context
+    def child_of? context
+      return false unless junction?
+      context_key = context.to_name.key
+      absolute_name(context).parent_keys.include? context_key
+    end
+
+    def relative?
+      s =~ RELATIVE_REGEXP || starts_with_joint?
+    end
+
+    def simple_relative?
+      relative? && stripped.to_name.starts_with_joint?
+    end
+
+    def absolute?
+      !relative?
+    end
+
+    def stripped
+      s.gsub RELATIVE_REGEXP, ""
+    end
+
+    def starts_with_joint?
+      length >= 2 && parts.first.empty?
+    end
+
+    def to_show *ignore
+      ignore.map!(&:to_name)
+
+      show_parts = parts.map do |part|
+        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? 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
+
+      new_parts = replace_contextual_parts context
+
+      if new_parts.first.empty? && !new_parts.to_name.starts_with?(context)
+        new_parts[0] = context.to_s
+      end
+      if new_parts.last.empty? && !new_parts.to_name.ends_with?(context)
+        new_parts[-1] = context.to_s
+      end
+      new_parts.join self.class.joint
+    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
+
+    private
+
+    def replace_contextual_parts context
+      parts.map do |part|
+        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]
+          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?
+          else
+            part
+          end.to_s.strip
+        new_part
+      end
+    end
+  end
+end