supports_pointer 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3e4e9bf143c824bb44ee0d6118ce2b19e931250728e6e7c656297f4cc651e304
+  data.tar.gz: 6604b4d85a25ce1b2467c85f7bf797a6ecb84d59c4cb06a9b7848893dc458c6a
+SHA512:
+  metadata.gz: 90bf68d4e41547e0dcf6a6fd92fa5cfbb28b2853e8a8efb1f88d91dc86cf4a7267d1510ac839b7af701fcdfff441c045a9e051cbc0fe1f470f35882b9045da6c
+  data.tar.gz: bfceb10d6c0234f3faa1cc2116d834e59f2567fccf938c10ec6d4a13da6360ee5bd845af63ced96166dc76ef6c041e7bbcf6d365e371350421e91db58c8cbf2f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2022 Greg Mikeska
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# SupportsPointer
+The SupportsPointer gem loads a concern to allow support for parsing and generation of various pointer types
+
+## Usage
+Add the following to your model:
+```ruby
+  parses_pointer :pointer_name_as_symbol,
+    template:/regexp(?<with_captures>.*)for(?<each_field>)/,
+    resolve:{|data| data[:with_captures].find_by(some_param:data[:other_capture]),
+    generate:{|target| "#{target.some_attr}:#{target.other_attr}"}
+```
+
+if the pointer being declared is a model pointer, or model_instance pointer, simply declare:
+```ruby
+  parses_pointer :model
+# and/or
+  parses_pointer :model_instance
+```
+if you use a model or model instance pointer that requires special handling (ie:alternate index param)
+you can overwrite the default resolver or generator with
+```ruby
+pointer_resolution {|data| some_block_to_resolve_pointer}
+# or
+pointer_generation {|data| some_block_to_generate_pointer}
+```
+
+Pointers are inherited like any other method. For instance, model & model instance
+can be declared on ApplicationRecord to allow parsing from any model in the project.
+However, pointers can also be parsed by
+other classes where the declaration is outside the class hierarchy.
+Lets say you have a "handle" pointer defined directly on class User,
+of the format "@username"
+
+```ruby
+parses_pointer :handle, template:/\^(?<handle>\w*)/, resolve:{|data| User.find_by handle:data[:handle]}
+pointer_generation :handle do |data| # feel free to mix-and-match between single-statement declarations
+  "@#{data.handle}"                  # and using pointer_resolution or pointer_generation methods.
+end
+```
+
+In the above example only the "User" model will be able to generate, parse or resolve
+"handle" pointers. To allow another model (say, "Widget", for example) to resolve user handles
+ you'd add the following to class Widget:
+
+```ruby
+uses_pointer :handle, from:User
+```
+
+This will allow the Widget class to access the handle pointer.
+
+A pointer can be parsed by calling ```parse_pointer``` on any model or object
+which supports the pointer type in question. In situations where a string matches
+the regexp of multiple pointer types, you can specify the pointer_type used for parsing with ```parse_{handle_name}_pointer``` such as ```parse_model_pointer``` or ```parse_model_instance_pointer```.
+
+When declaring model & model instance pointers, it may be helpful to declare a ```to_pointer``` method, returning ```generate_model_pointer``` and ```generate_model_instance_pointer```
+respectively:
+
+```ruby
+  def self.to_pointer
+    return generate_model_pointer(self)
+  end
+  def to_pointer
+    return generate_model_instance_pointer(self)
+  end
+```
+
+For more information, see the BlogPost and User models in ```/spec/dummy/models```.
+Note that while the dummy app contains a model called SettingsModel, this is being
+used to develop a pointer methodology to reference data inside a model's hash attributes.
+Documentation will be updated when the methodology is complete.
+
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "supports_pointer"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install supports_pointer
+```
+
+## Contributing
+Feel free to fork the repo. Pull requests are welcome for features and bug-fixes!
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/core_ext/regexp.rb

@@ -0,0 +1,340 @@
+require_relative "../terminal/terminal_formatting_support"
+
+class Regexp
+  def append(other_regex)
+    if(other_regex.is_a? Regexp)
+      other_string = other_regex.source
+    else
+      other_string = other_regex.to_s
+    end
+    Regexp.new(self.source+other_string)
+  end
+  def prepend(other_regex)
+    if(other_regex.is_a? Regexp)
+      other_string = other_regex.source
+    else
+      other_string = other_regex.to_s
+    end
+    Regexp.new(other_string+self.source)
+  end
+  def template
+    if(!@template)
+      @template = Regexp::Template.new(source:self.source)
+    end
+    return @template
+  end
+  class Template
+    include TerminalFormattingSupport
+    MATCHERS = {
+      any:".",
+      alpha:"[a-zA-Z]",
+      numeric:"\\d",
+      line_end:"$",
+      line_start:"^",
+      nonnumeric:"\\D",
+      whitespace:"\\s",
+      alphanumeric:"\\w",
+      nonwhitespace:"\\S",
+      nonalphanumeric:"\\W"
+    }
+    TYPE_MATCHER_DEFAULTS = {
+      string:".*",
+      integer:"\\d*",
+      decimal:"(\\d*.?\\d*)",
+    }
+    attr_reader :rx, :atoms
+    def self.capture_group(atoms,**args)
+      return Regexp::Template.new(atoms:[:placeholder_template]).capture_group(atoms,**args)
+    end
+
+    def initialize(**args)
+      if(args.keys.length == 0)
+        @rx = Regexp.new("")
+      elsif(args[:source_rx].is_a?(String))
+        @rx = Regexp.new(args[:source_rx])
+      elsif(args[:source_rx].is_a?(Regexp))
+        @rx = args[:source_rx]
+      elsif(!!args[:atoms] && args[:atoms].is_a?(Array))
+        @atoms = args[:atoms]
+        set_regex_from_atoms
+      end
+      @type_matchers = {}.merge(Template::TYPE_MATCHER_DEFAULTS)
+
+      if(!@atoms)
+        self.analyze
+      end
+    end
+    def set_regex_from_atoms
+      @rx = Regexp.new(@atoms.map{|a| render_atom(a) }.join(""))
+    end
+    def push(o)
+      if(o.is_a? Regexp)
+        o = o.source
+      elsif(o.is_a? Regexp::Template)
+        o = o.rx.source
+      end
+      @atoms << o
+      set_regex_from_atoms
+    end
+    def <<(o)
+      self.push(o)
+    end
+    def types
+      return @type_matchers.keys
+    end
+    def add_type(type_name, matcher)
+      @type_matchers[type_name.to_sym] = matcher
+    end
+    def preview(parent_type=nil)
+      numbering = @atoms.map.with_index do |a, index|
+        atom_text = render_atom(a)
+        # source = @rx.source.gsub(atom_text, atom_text+"|")
+        # spacer_count = (atom_text+"|").length/2
+        spacer_count = (atom_text).length/2
+        "#{" "*(spacer_count-1)}##{index}#{" "*(spacer_count)}"
+      end
+      @terminal = Terminal.new()
+      @terminal.clear_terminal
+      rx_source = @rx.source
+      descriptions = []
+      if(!parent_type)
+        @atoms.map.with_index do |a,index|
+          if(a.is_a?(Array) && a[0] == :"(" && a[a.length-1] == :")")
+            stringified = a.map(&:to_s).join('')
+            rx_source = rx_source.gsub(stringified,@terminal.rbg(r:0,b:0,g:5, text:stringified))
+            subatoms = a[1,a.length-2]
+            if(subatoms[0].to_s.start_with?("?<"))
+              name = subatoms.shift
+              name = name.to_s.match(/\?\<(?<name>.*)\>/)[:name]
+              name = "#{name}"
+            else
+              name = "anonymous_capture_group"
+            end
+            if(subatoms.length == 1)
+              a =  "#{@terminal.rbg(r:0,b:0,g:5, text:"Capture group \"#{name}\"")} captures #{self.describe(subatoms.first)}"
+            elsif(subatoms.length == 2)
+              a =    "#{@terminal.rbg(r:0,b:0,g:5, text:"Capture group \"#{name}\"")} captures #{self.describe(subatoms[0])} and #{self.describe(subatoms[0])}"
+            else
+              subatoms = subatoms.map{|s| self.describe(s)}
+              last_subatom = subatoms.pop
+            a =    "#{@terminal.rbg(r:0,b:0,g:5, text:"Capture group \"#{name}\"")} captures #{subatoms.join(',')} and #{last_subatom}"
+            end
+          else
+            rx_source = rx_source.gsub(a.to_s,@terminal.rbg(r:0,b:5,g:1, text:a.to_s))
+            a =  "#{@terminal.rbg(r:0,b:5,g:1, text:"\"#{a}\"")} matches #{self.describe(a)}"
+          end
+          descriptions << "##{index}. #{a}"
+        end
+      elsif(parent_type == :capture)
+        @atoms.map do |a|
+          if(a.to_s.include?("literal_"))
+            "#{a.to_s.gsub("_"," ")}"
+          elsif(a.to_s[0] == "(" && a.to_s[a.length-1] == ")")
+            "#{self.preview(a.to_s[1,a.length-1],:capture)}"
+          elsif(a.to_s[0] == "\\" && matchers.keys.include?(a.to_s[1]))
+            "#{matchers[a]}"
+          elsif(a.to_s[0] == "\\" && a.length <= 3 && !matchers.keys.include?(a.to_s[1]))
+            "literal #{a}"
+          else
+            "#{a}"
+          end
+        end
+      end
+      indent = 1
+      indent_str = "\t"*indent
+      puts "\n"*2
+      puts "#{indent_str}#{rx_source}"
+      puts "#{indent_str}#{@terminal.add_formatting(numbering.join(''), :yellow)}"
+      descriptions.each{|desc| puts "#{indent_str}#{desc}" }
+      return
+    end
+    def describe(atom)
+      matchers = {}
+      match_count = "exactly 1 instance"
+      if(atom.to_s[atom.to_s.length-1] == "*")
+        match_count = "any number of"
+      elsif(atom.to_s[atom.to_s.length-1] == "?")
+        match_count = "zero or one"
+      elsif(atom.to_s[atom.to_s.length-1] == "+")
+        match_count = "1 or more"
+      elsif(atom.to_s.match(/\{(?<count>.*)\}\z/))
+        match_count_data = atom.to_s.match(/\{(?<count>.*)\}\z/)[:count]
+        if(match_count_data.split(',').length == 2)
+          match_count = "between #{match_count_data.split(',').first} and #{match_count_data.split(',').last}"
+        elsif(match_count_data > 1)
+          match_count = "exactly #{match_count_data}"
+        end
+      end
+
+      if(atom.to_s.include?("literal_"))
+        desc = "#{atom.to_s.gsub("_"," ")}"
+        color= :yellow
+      elsif(atom.to_s[0] == "(" && atom.to_s[atom.length-1] == ")")
+        desc = "#{self.preview(atom.to_s[1,atom.length-1],:capture)}"
+      elsif(atom.to_s[0] == "\\" && self.class::MATCHERS.keys.include?(atom.to_s[1]))
+        desc = "#{self.class::MATCHERS[atom.to_s[1]]} characters"
+        color= :yellow
+      elsif(@type_matchers.values.include?(atom.to_s))
+        matcher_name = (@type_matchers.select{|k| @type_matchers[k] == atom.to_s}.first).first.to_s
+        desc  = "#{matcher_name}"
+        type_matcher = true
+        color = {r:4,b:0,g:4}
+      elsif(atom.to_s[0] == "\\" && atom.length <= 3 && !self.class::MATCHERS.keys.include?(atom.to_s[1]))
+        desc = "literal #{atom}"
+        color= :yellow
+      else
+        desc = @terminal.rbg(r:0,b:5,g:0, text:"\"#{atom}\"")
+      end
+      if(!type_matcher)
+        desc = "#{match_count} of #{@terminal.add_formatting(desc, color)}"
+        return desc.gsub(" of of "," of ")
+      else
+        desc[0] = desc[0].upcase
+        if("aeiou".include?(desc[0,1].downcase))
+          article = "an"
+        else
+          article = "a"
+        end
+        if(!!color && color.is_a?(Hash))
+          color[:text] = desc
+          desc = "#{article} #{@terminal.rbg(**color)}"
+        elsif(!!color)
+          desc = "#{article} #{@terminal.add_formatting(desc, color)}"
+        else
+          desc = "#{article} #{desc}."
+        end
+      end
+    end
+    def analyze
+      if(!!@rx && !!@rx.source)
+        src = @rx.source
+      end
+
+      current_segment = ""
+      current_atom = {}
+      atom_complete = false
+      while(!atom_complete)
+        src.split('').each do |char|
+          current_segment = "#{current_segment}#{char}"
+          if(char == "\\")
+            current_atom[:escaped] = true
+          end
+          if(char == ".")
+            current_atom[:match] = :any
+          end
+          if(char == "*")
+            current_atom[:count] = :any
+          end
+        end
+      end
+    end
+
+    def get_atom(**args)
+      self.class.get_atom(**args)
+    end
+
+    def self.get_atom(**args)     # args[:match] ":any, :numeric, :alphanumeric, etc, also ex: :except_numeric"
+                                  # args[:count] see self.count
+                                  # args[:string] for 'literal' text to be matched
+      if(!args[:types])
+        args[:types] = TYPE_MATCHER_DEFAULTS
+      else
+        args[:types] = args[:types]
+      end
+
+      result = ""
+      if(!!args[:match])
+
+        if(args[:match].to_s.include?('except_'))
+          args[:match] = args[:match].split("_")[1]
+          except = true
+        else
+          except = false
+        end
+        if(MATCHERS.keys.include?(args[:match]))
+          result = MATCHERS[args[:match].to_sym]
+          if(!!args[:count])
+            result = "#{result}#{self.count(args[:count])}"
+          end
+        elsif(args[:types].keys.include?(args[:match]))
+          result = "#{args[:types][args[:match].to_sym].to_s}"
+        end
+      elsif(!!args[:string])
+        if(args[:string].length == 2 && args[:string] == Regexp.escape(args[:string][1]))
+          result = "literal_#{args[:string][1]}"
+        else
+          result = args[:string]
+        end
+      end
+
+      if(!!except)
+        result = "[^#{result}]"
+      end
+      return result.to_sym
+    end
+
+    def render_atom(atom)
+      if(atom.is_a? Array)
+        atom = atom.map(&:to_s).join('')
+      end
+      atom_str = atom.to_s
+      if(atom_str.include?("literal_"))
+        return self.escape(atom_str.split("_").last)
+      else
+        return atom_str
+      end
+    end
+    def literal(atom_string)
+      return "#{self.escape(atom_string.to_s)}"
+    end
+    def line_start
+      return "^"
+    end
+    def line_end
+      return "$"
+    end
+    def count(count)
+      self.class.count(count)
+    end
+    def self.count(count)
+      if(count == :any)
+        return "*"
+      end
+      # if(count.is_a? Symbol)
+      if(count.to_s.match(/\>(?<count>\d*)$/))
+        count_number = count.to_s.match(/\>(?<count>\d*)/)[:count].to_i
+        return "+" if(count_number == 0)
+        return "{#{count_number},}"
+      elsif(count.to_s.match(/0_or_1/))
+        return "?"
+      elsif(count.to_s.match(/\>(?<count_min>\d*)_\<(?<count_max>\d*)/)) # Example: count(">3_<5".to_sym) for "greater than 3 less than 5"
+        counts = count.match(/\>(?<count_min>\d*)_\<(?<count_max>\d*)/)
+        count_min = counts[:count_min].to_i
+        count_max = counts[:count_max].to_i
+        return "{#{count_min},#{count_max}}"
+      elsif(count.to_s.match(/(?<count>\d*)/))
+        return"{#{count.to_s.match(/(?<count>\d*)/)[:count].to_i}}"
+      end
+    end
+    def capture_group(atoms,**args)
+      if(!atoms.is_a?(Array))
+        atoms = [atoms]
+      end
+      if(args[:name])
+        atoms.unshift("?<#{args[:name]}>".to_sym)
+      end
+      atoms.unshift(:"(")
+      atoms.push(:")")
+      def atoms.to_sym
+        self.map{|a| render_atom(a) }.join('').to_sym
+      end
+      return atoms
+    end
+    def self.group(atoms)
+      return "[#{atoms.join("")}]"
+    end
+    def group(atoms)
+      return "[#{atoms.join("")}]"
+    end
+  end
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,46 @@
+class String
+  def select(**args)
+    args[:parent] = self
+    Selection.new(**args)
+  end
+
+  class Selection
+    attr_accessor :parent, :cursor, :length, :value
+    def initialize(**args)
+      @parent = args[:parent]
+      @cursor = args[:cursor].to_i
+      @value = @parent[@cursor,args[:length]]
+    end
+
+    def length
+      @value.length
+    end
+
+    def inspect
+      return source
+    end
+
+    def source
+      @parent[self.cursor,self.length]
+    end
+
+    def source=(replacement)
+      @parent[self.cursor,self.length] = replacement
+      @value = @parent[self.cursor,replacement.length]
+    end
+
+
+    def method_missing(m,*args, &block)
+      if(!args)
+        args = []
+      end
+      @value.send(m,*args,&block) # preplay action on @value to maintain length
+      if(!!args[0] && args[0].is_a?(Integer))
+        args[0] = @cursor+args[0]
+        @parent.send(m,*args,&block)
+      else
+        source.send(m,*args,&block)
+      end
+    end
+  end
+end

data/lib/supports_pointer/railtie.rb

@@ -0,0 +1,4 @@
+module SupportsPointer
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/supports_pointer/version.rb

@@ -0,0 +1,3 @@
+module SupportsPointer
+  VERSION = "0.5.0"
+end

data/lib/supports_pointer.rb

@@ -0,0 +1,239 @@
+require "core_ext/regexp"
+require "core_ext/string"
+require "supports_pointer/version"
+require "supports_pointer/railtie"
+
+module SupportsPointer
+  MODEL_PARSER_ATOMS = [:"(?<model_name>\\w*)"]
+  MODEL_RESOLVER = Proc.new{ |data| data[:model_name].classify.constantize }
+  MODEL_GENERATOR = Proc.new{ |data| data.name }
+
+  MODEL_INSTANCE_PARSER_ATOMS = [:"(?<model_name>\\w*):(?<param>\\w*)"]
+  MODEL_INSTANCE_RESOLVER = Proc.new{ |data| data[:model_name].classify.constantize.find(data[:param]) }
+  MODEL_INSTANCE_GENERATOR = Proc.new{ |data| "#{data.class.name}:#{data.to_param}" }
+
+  HANDLE_PARSER_ATOMS = [:"@",:"(?<handle>\\w*)"]
+  extend ActiveSupport::Concern
+  included do
+    @@pointers = {}
+    @@segments = {}
+
+    # Declares a pointer type on the current class object
+    #
+    # @param name [Symbol] the name of the pointer type (ie: :model, etc..)
+    # @param args [Hash] the hash of pointer options to be declared for this pointer
+    # @return [Hash] the pointer type's data hash.
+    def self.parses_pointer(name, **args)
+      if(!@@pointers[self.name.to_sym])
+        @@pointers[self.name.to_sym] = {}
+      end
+      if(!@@pointers[self.name.to_sym][name.to_sym])
+        @@pointers[self.name.to_sym][name.to_sym] = {}
+      end
+
+      if(!!args[:template])
+        if(args[:template].is_a?(Regexp::Template))
+          @@pointers[self.name.to_sym][name.to_sym][:matcher] = args[:template].rx
+        elsif(args[:template].is_a?(Regexp))
+          @@pointers[self.name.to_sym][name.to_sym] = {}
+          @@pointers[self.name.to_sym][name.to_sym][:matcher] = args[:template]
+        elsif(args[:template].is_a?(String))
+          atoms = [:"{",:"(?<segment_name>\\w*)" ,:"}"]
+          segment_matcher = Regexp::Template.new(atoms:atoms)
+          segment_names = args[:template].scan(segment_matcher)
+        end
+      elsif(!args[:template] && SupportsPointer.const_defined?(name.to_s.upcase+"_PARSER_ATOMS"))
+          @@pointers[self.name.to_sym][name.to_sym][:matcher] = Regexp::Template.new(atoms:self.const_get((name.to_s.upcase+"_PARSER_ATOMS").to_sym)).rx
+          if(!args[:resolve])
+            @@pointers[self.name.to_sym][name.to_sym][:resolve] = self.const_get(name.to_s.upcase+"_RESOLVER")
+          end
+          if(!args[:generate])
+            @@pointers[self.name.to_sym][name.to_sym][:generate] = self.const_get(name.to_s.upcase+"_GENERATOR")
+          end
+      elsif(!args[:template] && !!args[:parse] )
+          @@pointers[self.name.to_sym][name.to_sym][:parser] = args[:parse]
+      end
+      if(!!args[:resolve])
+        @@pointers[self.name.to_sym][name.to_sym][:resolve] = args[:resolve]
+      end
+      if(!!args[:generate])
+        @@pointers[self.name.to_sym][name.to_sym][:generate] = args[:generate]
+      end
+      return !!@@pointers[self.name.to_sym][name.to_sym]
+    end
+
+    # Grants the current class access to a pointer type from another class
+    #
+    # @param name [Symbol] the name of the pointer type (ie: :model, etc..)
+    # @param args [Symbol] use :from to specify the class from which to grant access)
+    # @return [Hash] the pointer type's data hash
+    def self.uses_pointer(name, **args)
+      parser = args[:from].pointers[name.to_sym]
+      if(!@@pointers[self.name.to_sym])
+        @@pointers[self.name.to_sym] = {}
+      end
+      if(!@@pointers[self.name.to_sym][name])
+        @@pointers[self.name.to_sym][name] = parser
+      end
+      @@pointers[self.name.to_sym][name]
+    end
+
+    # Returns a hash of all pointers for a given instance's class
+    #
+    # @return [Hash] the data hash of all pointer types
+    def pointers
+      self.class.pointers
+    end
+
+    # Returns a hash of all pointers for a given class
+    #
+    # @return [Hash] the data hash of all pointer types
+    def self.pointers
+      if(!!@@pointers && !!@@pointers[self.name.to_sym])
+        if(superclass.respond_to?(:pointers))
+          return superclass.pointers.merge(@@pointers[self.name.to_sym])
+        else
+          return @@pointers[self.name.to_sym]
+        end
+      else
+        if(superclass.respond_to?(:pointers))
+          return superclass.pointers
+        else
+          return {}
+        end
+      end
+    end
+
+    # Returns an array of all pointer names declared on a class
+    #
+    # @return [Array] the array of pointer type names
+    def self.pointer_types
+      return self.pointers.keys
+    end
+
+    # Returns whether or not a particular string matches any known pointer type
+    # @param ptr the string to be matched as a potential pointer
+    # @return [Boolean] true if ptr is a pointer, false otherwise
+    def self.is_pointer?(ptr)
+      begin
+        result = !!self.resolve_pointer(ptr)
+      rescue
+        return false
+      end
+      return result
+    end
+
+    # Returns the pointer type name for a particular string
+    # @param ptr [String] the string to be matched against each pointer type
+    # @return [Symbol] the string's pointer type name
+    def self.pointer_type(ptr)
+      result = nil
+      self.pointers.each do |type, data|
+        if(!!data[:matcher] && ptr.match(data[:matcher]))
+          data = ptr.match(data[:matcher]).named_captures.symbolize_keys
+          if(data.none?(""))
+            result = type
+          end
+        elsif(!!data[:parser] && !!data[:parser].call(ptr))
+          result = type
+        end
+      end
+      return result
+    end
+
+    # Parses a pointer into a Hash of data ready for resolution
+    # @param ptr [String] the string to be parsed as a pointer
+    # @param args [Hash] use :type to specify the pointer type for parsing
+    # @return [Hash] the data parsed from ptr
+    def self.parse_pointer(ptr, **args)
+
+      if(!!args[:type])
+        type = args[:type]
+      else
+        type = pointer_type(ptr)
+      end
+
+      if(!!type)
+        return self.send("parse_#{type.to_s}_pointer",ptr)
+      else
+        raise NameError.new("Unknown pointer type '#{pointer_name}'.", pointer_name)
+      end
+    end
+
+    # Resolves a pointer into the referenced object
+    # @param ptr [String] the string to be parsed as a pointer
+    # @return the object referenced by ptr
+    def self.resolve_pointer(ptr)
+      data = self.parse_pointer(ptr)
+      if(!!data && !!data[:type])
+        return self.send("resolve_#{data[:type]}_pointer", data)
+      end
+    end
+
+    # Updates the Proc object used to generate a pointer
+    # @param name [Symbol] the pointer type to be updated
+    # @param block the block to be used for pointer generation
+    # @return [Hash] the pointer type's data hash
+    def self.pointer_generation(name,&block)
+      @@pointers[self.name.to_sym][name.to_sym][:generate] = block.to_proc
+      @@pointers[self.name.to_sym][name.to_sym]
+    end
+
+    # Updates the Proc object used to resolve a pointer
+    # @param name [Symbol] the pointer type to be updated
+    # @param block the block to be used for pointer resolution
+    # @return [Hash] the pointer type's data hash
+    def self.pointer_resolution(name,&block)
+      @@pointers[self.name.to_sym][name.to_sym][:resolve] = block.to_proc
+      @@pointers[self.name.to_sym][name.to_sym]
+    end
+    # Implements the parse, resolve and generate behavior for each pointer type
+    # @param m [Symbol] the method name being called (such as ```generate_model_pointer```)
+    # @param args [Hash] the arguments being passed to the called method
+    # @return the return value for the called method
+    def self.method_missing(m,*args)
+
+      if(m.to_s.match?(/resolve_(?<pointer_name>\w*)_pointer/))
+        pointer_name = m.to_s.match(/resolve_(?<pointer_name>\w*)_pointer/)[:pointer_name]
+        if(self.pointers.keys.include?(pointer_name.to_sym))
+          if(args[0].is_a? Hash)
+            return self.pointers[pointer_name.to_sym][:resolve].call(args[0])
+          elsif(args[0].is_a? String)
+            return self.pointers[pointer_name.to_sym][:resolve].call(self.send("parse_#{pointer_name}_pointer", args[0]))
+          end
+        else
+          raise NameError.new("Unknown pointer type. Pointer type '#{pointer_name}' not defined in #{self.name}.", pointer_name)
+        end
+      end
+
+      if(m.to_s.match?(/generate_(?<pointer_name>\w*)_pointer/))
+        pointer_name = m.to_s.match(/generate_(?<pointer_name>\w*)_pointer/)[:pointer_name]
+        if(self.pointers.keys.include?(pointer_name.to_sym) && !!self.pointers[pointer_name.to_sym][:generate])
+          return self.pointers[pointer_name.to_sym][:generate].call(args[0])
+        else
+          raise NameError.new("Unknown pointer type. Pointer type '#{pointer_name}' not defined in #{self.name}.", pointer_name)
+        end
+      end
+
+
+      if(m.to_s.match?(/parse_(?<pointer_name>\w*)_pointer/))
+        pointer_name = m.to_s.match(/parse_(?<pointer_name>\w*)_pointer/)[:pointer_name]
+
+        if(self.pointers.keys.include?(pointer_name.to_sym))
+          if(!!self.pointers[pointer_name.to_sym][:matcher])
+            data = args[0].match(self.pointers[pointer_name.to_sym][:matcher]).named_captures.symbolize_keys
+          elsif(!!self.pointers[pointer_name.to_sym][:parser])
+            data = self.pointers[pointer_name.to_sym][:parser].call(args[0])
+          end
+          data[:type] = pointer_name
+          return data
+        else
+          raise NameError.new("Unknown pointer type. Pointer type '#{pointer_name}' not defined in #{self.name}.", pointer_name)
+        end
+      end
+      # if(m.to_s.include? "generate_" &&  @segment_names.include?(m.to_s.split('_')[1]))
+      #   @segments[m.to_s.split('_')[1]] = block
+      # end
+    end
+  end
+end

data/lib/tasks/supports_pointer_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :supports_pointer do
+#   # Task goes here
+# end

data/lib/terminal/terminal.rb

@@ -0,0 +1,166 @@
+class Terminal
+  FORMATTING = {
+  reset:"0",
+  reset_bold:"21",
+  reset_muted:"22",
+  reset_italic:"22",
+  reset_underline:"24",
+  reset_blink:"25",
+  reset_inverted:"27",
+  reset_hidden:"28",
+  black_background: "40",
+  dark_gray_background: "40",
+  red_background: "41",
+  light_red_background: "41",
+  green_background: "42",
+  light_green_background: "42",
+  brown_orange_background: "43",
+  yellow_background: "43",
+  blue_background: "44",
+  light_blue_background: "44",
+  purple_background: "45",
+  light_purple_background: "45",
+  cyan_background: "46",
+  light_cyan_background: "46",
+  light_gray_background: "47",
+  white_background: "47",
+  bold: "1",
+  muted: "2",
+  italic: "3",
+  underline: "4",
+  blink: "5",
+  inverted: "7",
+  hidden: "8",
+  font1: "11",
+  font2: "12",
+  font3: "13",
+  font4: "14",
+  font5: "15",
+  black: "30",
+  dark_gray: "30",
+  red: "31",
+  light_red: "31",
+  green: "32",
+  light_green: "32",
+  brown_orange: "33",
+  yellow: "33",
+  blue: "34",
+  light_blue: "34",
+  purple: "35",
+  light_purple: "35",
+  cyan: "36",
+  light_cyan: "36",
+  light_gray: "37",
+  framed: "51",
+  encircled: "52",
+}
+  def initialize(**args)
+    if(args[:color])
+      @color = args[:color]
+    else
+      @color = :reset
+    end
+    if(args[:background])
+      @background = args[:background]
+    else
+      @background = :reset_background
+    end
+  end
+
+  def width(line,col)
+    `tput cols`
+  end
+
+  def height(line,col)
+    `tput lines`
+  end
+
+  def move_cursor_to(line,col)
+    puts "\e[#{line};#{col}H"
+  end
+
+  def to_clipboard(clip_string,capture=false)
+    if(has_app?("xsel"))
+      if(!!capture)
+        return `#{clip_string} | xsel -i`
+      else
+        return `echo #{clip_string} | xsel -i`
+      end
+    end
+  end
+
+  def from_clipboard
+    if(has_app?("xsel"))
+      return `xsel -o`
+    end
+  end
+
+  def clear_clipboard
+    if(has_app?("xsel"))
+      return `xsel -c`
+    end
+  end
+
+  def clear_terminal
+    puts "\e[H\e[2J\e[3J"
+  end
+
+  def has_app?(app_name)
+    return(`which #{app_name}` != "")
+  end
+
+  def build_formatting(name=:reset)
+    if(!name.is_a? Array)
+      name = [name]
+    end
+    return("\e[#{name.map{|n| Terminal::FORMATTING[n] }.join(';')}m")
+  end
+
+  def rbg(**args)
+    if(!!args[:red])
+      @red = args[:red]
+    elsif(!!args[:r])
+      @red = args[:r]
+    end
+    if(!!args[:blue])
+      @blue = args[:blue]
+    elsif(!!args[:b])
+      @blue = args[:b]
+    end
+    if(!!args[:green])
+      @green = args[:green]
+    elsif(!!args[:g])
+      @green = args[:g]
+    end
+    color_code = 16+(@red*36)+(@blue*1)+(@green*6)
+    if(!!args[:text])
+      return "\e[38;5;#{color_code}m#{args[:text]}#{build_formatting(:reset)}"
+    else
+      return color_code
+    end
+  end
+
+  def add_formatting(text,name=:reset)
+    if(!name.is_a?(Array))
+      name = [name]
+    end
+    name.map do |n|
+      if(name.to_s.match(/_(\d*)_/)) # ex: "_2_" for color 2.
+        "\e[38;5;#{name.to_s.match(/_(\d*)_/)[1]}m#{text}#{build_formatting(:reset)}"
+      else
+
+        if(FORMATTING.keys
+          .select{|k| k.to_s.include?("reset_")}.map{|k| k.to_s.split('_')[1]}
+          .include?(name.to_s))
+          reset_formatting = build_formatting("reset_#{name.to_s}".to_sym)
+        else
+          reset_formatting = build_formatting(:reset)
+
+        end
+        text = "#{build_formatting(name)}#{text}#{reset_formatting}"
+      end
+    end
+    return text
+  end
+
+end

data/lib/terminal/terminal_formatting_support.rb

@@ -0,0 +1,6 @@
+require_relative "terminal"
+module TerminalFormattingSupport
+  def self.included(base)
+    @terminal = Terminal.new()
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: supports_pointer
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Greg Mikeska
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.4
+description: A rails plugin to add human-readable pointers to models and other data
+  related objects.
+email:
+- gmikeska07@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/core_ext/regexp.rb
+- lib/core_ext/string.rb
+- lib/supports_pointer.rb
+- lib/supports_pointer/railtie.rb
+- lib/supports_pointer/version.rb
+- lib/tasks/supports_pointer_tasks.rake
+- lib/terminal/terminal.rb
+- lib/terminal/terminal_formatting_support.rb
+homepage: https://github.com/gmikeska/supports_pointer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gmikeska/supports_pointer
+  source_code_uri: https://github.com/gmikeska/supports_pointer
+  changelog_uri: https://github.com/gmikeska/supports_pointer/blob/master/CHANGELOG.MD
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: A rails plugin to add human-readable pointers to models and other data related
+  objects.
+test_files: []