cardname 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15f37bd2c96222cfff562f06782c52e27a803dc0
+  data.tar.gz: 86752b10ed33282d3cafa93eaca1320aea1e8e94
+SHA512:
+  metadata.gz: d66817487594c22c30d7f1374c53711312c6d314609ec0d34ac8724def65bb7e853f1a5ce5e29a03aec902b4c28d136d535b2cbae2e87d7fa069575139ed8fdf
+  data.tar.gz: a3867d0234a9f27360e3bcf47328c5ff1380066b1af3ffad1487578796c0f6a47f14b5008d970d87b3ae3697fb12c86ebeafc8753d19cf13f9178437b416e498

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec"
+  gem "rdoc"
+  gem "bundler"
+  gem "jeweler"
+  #gem "rcov"
+end
+
+gem "activesupport"
+gem 'htmlentities'

data/Gemfile.lock

@@ -0,0 +1,91 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (5.0.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    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.3)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    git (1.3.0)
+    github_api (0.11.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.1)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 1.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.0)
+      oauth2
+    hashie (3.5.4)
+    highline (1.7.8)
+    htmlentities (4.3.4)
+    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
+      semver2
+    jwt (1.5.6)
+    mini_portile2 (2.1.0)
+    minitest (5.10.1)
+    multi_json (1.12.1)
+    multi_xml (0.6.0)
+    multipart-post (2.0.0)
+    nokogiri (1.6.8.1)
+      mini_portile2 (~> 2.1.0)
+    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 (12.0.0)
+    rdoc (5.1.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    semver2 (3.4.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler
+  htmlentities
+  jeweler
+  rdoc
+  rspec
+
+BUNDLED WITH
+   1.12.5

data/README.rdoc

@@ -0,0 +1,7 @@
+
+== Cardname
+
+Wiki Segmented Name Logic
+
+== Abstract
+

data/Rakefile

@@ -0,0 +1,39 @@
+
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+
+VERSION = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cardname #{VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/cardname/contextual.rb

@@ -0,0 +1,114 @@
+class Cardname
+  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
+      return "" if new_parts.empty?
+
+      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

data/lib/cardname/manipulate.rb

@@ -0,0 +1,73 @@
+class Cardname
+  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/cardname/parts.rb

@@ -0,0 +1,126 @@
+class Cardname
+  # 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
+
+    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
+
+    def + other
+      self.class.new(parts + other.to_name.parts)
+    end
+
+    def [] *args
+      self.class.new parts[*args]
+    end
+
+    # full support of array methods caused trouble with `flatten` calls
+    # It splits the parts of cardnames in arrays
+    # # name parts can be accessed and manipulated like an array
+    # def method_missing method, *args, &block
+    #   if ARRAY_METHODS.include? method # parts.respond_to?(method)
+    #     self.class.new parts.send(method, *args, &block)
+    #   else
+    #     super
+    #   end
+    # end
+    #
+    # def respond_to? method, include_private=false
+    #   return true if ARRAY_METHODS.include? method
+    #   super || parts.respond_to?(method, include_private)
+    # end
+  end
+end

data/lib/cardname/predicates.rb

@@ -0,0 +1,39 @@
+class Cardname
+  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/cardname/variants.rb

@@ -0,0 +1,36 @@
+class Cardname
+  module Variants
+    def simple_key
+      return "" if @s.empty?
+      decoded
+        .underscore
+        .gsub(/[^#{OK4KEY_RE}]+/, '_')
+        .split(/_+/)
+        .reject(&:empty?)
+        .map { |key| Cardname.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/lib/cardname.rb

@@ -0,0 +1,114 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_support/configurable'
+require 'active_support/inflector'
+require 'htmlentities'
+require_relative 'cardname/parts'
+require_relative 'cardname/variants'
+require_relative 'cardname/contextual'
+require_relative 'cardname/predicates'
+require_relative 'cardname/manipulate'
+
+class Cardname < 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
+
+  Cardname.joint          = '+'
+  Cardname.banned_array   = ['/', '~', '|']
+  Cardname.var_re         = /\{([^\}]*\})\}/
+  Cardname.uninflect      = :singularize
+  Cardname.stabilize      = false
+
+  JOINT_RE = Regexp.escape joint
+
+  @@name2nameobject = {} # name cache
+
+  class << self
+    def new obj
+      return obj if obj.is_a? self.class
+      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
+        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.
+    # You can choose between two solutions:
+    # 1. don't uninflect if the uninflected key is not stable (stabilize = false)
+    #    (probably the best choice because you want Matthias not to be the same  as Matthium)
+    # 2. uninflect until the key is stable (stabilize = true)
+    def stable_uninflect name
+      key_one = name.send(Cardname.uninflect)
+      key_two = key_one.send(Cardname.uninflect)
+      return key_one unless key_one != key_two
+      Cardname.stabilize ? stable_uninflect(key_two) : name
+    end
+  end
+
+  # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  # ~~~~~~~~~~~~~~~~~~~~~~ INSTANCE ~~~~~~~~~~~~~~~~~~~~~~~~~
+  attr_reader :key, :s
+  alias to_s s
+
+  def initialize str
+    @s = str.to_s.strip
+    @s = @s.encode('UTF-8') if RUBYENCODING
+    initialize_parts
+    @key = @part_keys.join(self.class.joint)
+    @@name2nameobject[str] = self
+  end
+
+  def to_name
+    self
+  end
+
+  def length
+    parts.length
+  end
+
+  def size
+    to_s.size
+  end
+
+  def inspect
+    "<#{self.class.name} key=#{key}[#{self}]>"
+  end
+
+  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
+    other_key == key
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,5 @@
+class Object
+  def to_name
+    Cardname.new self
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: cardname
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Gerry Gleason
+- Ethan McCutchen
+- Philipp Kühl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+description: Naming patterns abstracted from Decko cards
+email: info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- lib/cardname.rb
+- lib/cardname/contextual.rb
+- lib/cardname/manipulate.rb
+- lib/cardname/parts.rb
+- lib/cardname/predicates.rb
+- lib/cardname/variants.rb
+- lib/core_ext.rb
+homepage: http://decko.org
+licenses:
+- GPL-2.0
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+- "--inline-source"
+- "--line-numbers"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Card names without all the cards
+test_files: []