skn_utils 3.5.2 → 3.6.0

data/lib/skn_utils/exploring/commander.rb

@@ -1,68 +0,0 @@
-##
-# <project.root>/lib/skn_utils/exploring/commander.rb
-##
-# ref: https://github.com/saturnflyer/direction
-##
-# Provide a feature like the Forwardable library,
-# but set the return value to self.
-# It provides a class level "command" method to do
-# message forwarding.
-#
-# class SomeClass
-#   extend SknUtils::Commander
-#
-#   command [:print_details, :setup_things] => :collaborator
-#   query [:name, :id] => :collaborator, :type => :@partner
-# end
-#
-# This will define methods on instances that forward to the
-# provided receiver while enforcing encapsulation of the
-# relationship between objects.
-#
-# the collaborator and you must agree on how results can be exchanged
-# you might provide a callback method for it to set its return value on you
-# :callback, develop a protocol to exchange messages with collaborator
-##
-
-
-module SknUtils
-  module Exploring
-    module Commander
-
-      # Forward messages and return self, protecting the encapsulation of the object
-      def command(options)
-        Commander.define_methods(self, options) do |command, accessor|
-          %{
-            def #{command}(*args, &block)
-              #{accessor}.__send__(:#{command}, *args, &block)
-              self
-            end
-          }
-        end
-      end
-
-      # Forward messages and return the result of the forwarded message
-      def query(options)
-        Commander.define_methods(self, options) do |query, accessor|
-          %{
-            def #{query}(*args, &block)
-              #{accessor}.__send__(:#{query}, *args, &block)
-            end
-          }
-        end
-      end
-
-      # Commander's class method
-      def self.define_methods(mod, options)
-        method_defs = []
-        options.each_pair do |method_names, accessor|
-          Array(method_names).map do |message|
-            method_defs.push yield(message, accessor)
-          end
-        end
-        mod.class_eval method_defs.join("\n"), __FILE__, __LINE__
-      end
-
-    end # Commander
-  end # Exploring
-end # SknUtils

data/lib/skn_utils/exploring/configuration.rb

@@ -1,53 +0,0 @@
-##
-# File: <gem-root>/lib/skn_utils/exploring/configuration.rb
-#
-# Engines and Gem sometimes need a configuration object, this is an example
-# Options class, consider OpenStruct2 or ActiveSupport::OrderedOptions as alternatives
-
-module SknUtils
-  module Exploring
-    module Configuration
-
-      module_function
-
-      def option_defaults
-        @option_defaults ||= {one: 1, two: 2, three: 3}
-      end
-      def option_defaults=(parms)
-        @option_defaults = parms
-      end
-
-      def reset!
-        @configuration = Options.new(option_defaults)
-        true
-      end
-
-      def config
-        configure
-      end
-
-      def configure         # Initialize with both the configuration keys and default values
-        @configuration || reset!
-        yield(@configuration) if block_given?
-        @configuration
-      end
-
-      private
-
-      class Options
-        def initialize(parms={})
-          parms.each_pair do |k,v|
-            self.singleton_class.send(:attr_accessor, k)
-            instance_variable_set("@#{k}",v)
-          end
-        end
-      end
-
-    end
-    # require your Gem or Engine here
-
-  end
-end
-
-# In config/initializers/gem_config.rb
-# SknUtils::Exploring::Configuration.class_variable_set(:option_defaults, {one: 1, two: 2, three: 3})

data/lib/skn_utils/lists/circular_linked_list.rb

@@ -1,161 +0,0 @@
-##
-# File <SknUtils>/lib/skn_utils/lists/circular_linked_list.rb
-#
-#     ll = SknUtils::Lists::CircularLinkedList.new(*vargs, &compare_key_proc)
-# - or -
-#     ll = SknUtils::Lists::CircularLinkedList.new(1,2,3,4,5) {|element| element[:key] }
-# - or -
-#     ll = SknUtils::Lists::CircularLinkedList.new(
-#                     {key: 'Z'}, {key: 'K'}, {key: 'S'}, {key: 'n'}, {key: 's'}
-#          ) {|el| el[:key] }
-# - or -
-#     cmp_proc = lambda { |el| el[:key] }
-#     vargs = [{key: 'Z'}, {key: 'K'}, {key: 'S'}, {key: 'n'}, {key: 's'}]
-#     ll = SknUtils::Lists::CircularLinkedList.new(*vargs, &cmp_proc)
-###
-# value = ll.first
-# value = ll.at_index(4)
-# count = ll.insert({key: 'anyValue'})
-# ...
-# count = ll.sort!           -- defaults to :asc
-# count = ll.sort!(:desc)
-# count = ll.sort!() {|a,b| a[:key] <= b[:key] }
-##
-
-module SknUtils
-  module Lists
-    # Circularly Linked List
-    # Forward (#next) and Backwards (#prev) navigation
-    # No Head or Tail
-
-    # LinkedCommons provides;
-    # - #initialize, #first, #next, #current, #last, #at_index,
-    #   #insert, #prepend, #append, #empty?, #clear,
-    #   #each, #to_a, and #sort!
-    #
-    class CircularLinkedList < LinkedCommons
-
-      #
-      # Navigation
-      #
-
-
-      def prev
-        @current = @current.prev if @current and @current.prev
-        @current.value rescue nil
-      end
-
-      # -+ int position from current node
-      def nth(index)
-        node = @current
-        position = node
-        if index > 0
-          while index > 1 and node and node.next
-            node = node.next
-            index -= 1
-            @current = node
-            break if position.equal?(node)
-          end
-        elsif index < 0
-          while index < 0 and node and node.prev
-            node = node.prev
-            index += 1
-            @current = node
-            break if position.equal?(node)
-          end
-        end
-        current
-      end
-
-      #
-      # Modifications
-      #
-      # return new size
-      def insert(value)
-        node = @current
-        @current = LinkNode.call(value, node, :circle_after, self,  &@match_value)
-        if self.size == 0           # only
-          self.head      =  @current
-          self.tail      =  @current
-        elsif self.tail == node
-          self.tail      =  @current
-          @current.next      = self.head
-          self.head.prev = @current
-        end
-        self.size += 1
-      end
-      alias_method  :append, :insert
-
-      # return new size
-      def insert_before(position_value, value)
-        target = find_by_value(position_value)
-        node = LinkNode.call(value, target, :circle_before, self,  &@match_value)
-        @current = node
-        if self.size == 0           # only
-          self.head =  node
-          self.tail =  node
-        elsif self.head == target   # new head
-          self.head      =  node
-          node.prev      = self.tail
-          self.tail.next = node
-        end
-        self.size += 1
-      end
-
-      # return new size
-      def insert_after(position_value, value)
-        target = find_by_value(position_value)
-        node = LinkNode.call(value, target, :circle_after, self,  &@match_value)
-        @current = node
-        if self.size == 0           # only
-          self.head =  node
-          self.tail =  node
-        elsif self.tail == target
-          self.tail =  node
-          node.next      = self.head
-          self.head.prev = node
-        end
-        self.size += 1
-      end
-
-      # return remaining size
-      def remove(value)
-        target_node = find_by_value(value)
-        if target_node
-          if self.size == 1                           # will become zero
-            @current = nil
-            self.head = nil
-            self.tail = nil
-          elsif target_node.equal?(self.head)            # top
-            @current = target_node.next
-            @current.prev = target_node.prev
-            self.tail.next = @current
-            self.head = @current
-          elsif target_node.equal?(self.tail)            # bottom
-            @current = target_node.prev
-            @current.next = target_node.next
-            self.head.prev = @current
-            self.tail = @current
-          else                                   # middle
-            @current           = target_node.prev
-            @current.next      = target_node.next
-            @current.next.prev = @current
-          end
-          target_node.remove!
-          self.size -= 1
-        end
-      end
-
-    protected
-
-      def find_by_index(index)
-        return nil if ( index > self.size || index < 1 )
-        node = self.head
-        node = node.next while ( (index -= 1) > 0 )
-        @current = node
-        node
-      end
-
-    end # end class
-  end # module
-end # end module

data/lib/skn_utils/lists/doubly_linked_list.rb

@@ -1,139 +0,0 @@
-##
-# File <SknUtils>/lib/skn_utils/lists/doubly_linked_list.rb
-#
-#     ll = SknUtils::Lists::DoublyLinkedList.new(*vargs, &compare_key_proc)
-# - or -
-#     ll = SknUtils::Lists::DoublyLinkedList.new(1,2,3,4,5) {|element| element[:key] }
-# - or -
-#     ll = SknUtils::Lists::DoublyLinkedList.new(
-#                     {key: 'Z'}, {key: 'K'}, {key: 'S'}, {key: 'n'}, {key: 's'}
-#          ) {|el| el[:key] }
-# - or -
-#     cmp_proc = lambda { |el| el[:key] }
-#     vargs = [{key: 'Z'}, {key: 'K'}, {key: 'S'}, {key: 'n'}, {key: 's'}]
-#     ll = SknUtils::Lists::DoublyLinkedList.new(*vargs, &cmp_proc)
-###
-# value = ll.first
-# value = ll.at_index(4)
-# count = ll.insert({key: 'anyValue'})
-# ...
-# count = ll.sort!           -- defaults to :asc
-# count = ll.sort!(:desc)
-# count = ll.sort!() {|a,b| a[:key] <= b[:key] }
-##
-
-module SknUtils
-  module Lists
-    # Doubly Linked List
-    # Forward (#next) and Backwards (#prev) navigation
-    # Head when (prev == nil)
-    # Tail when (next == nil)
-
-    # LinkedCommons provides;
-    # - #initialize, #first, #next, #current, #last, #at_index,
-    #   #insert, #prepend, #append, #empty?, #clear,
-    #   #each, #to_a, and #sort!
-    #
-    class DoublyLinkedList < LinkedCommons
-
-      #
-      # Navigation
-      #
-
-      def prev
-        @current = @current.prev if @current and @current.prev
-        @current.value rescue nil
-      end
-
-      # -+ int position from current node
-      def nth(index)
-        node = @current
-        if index > 0
-          while index > 1 and node and node.next
-            node = node.next
-            index -= 1
-          end
-          @current = node
-        elsif index < 0
-          while index < 0 and node and node.prev
-            node = node.prev
-            index += 1
-          end
-          @current = node
-        end
-        current
-      end
-
-      #
-      # Modifications
-      #
-
-      # return new size
-      def insert(value)
-        node = @current
-        @current = LinkNode.call(value, node, :after, self,  &@match_value)
-        self.head = @current if self.head.nil?
-        self.tail = @current if self.tail.equal?(node)
-        self.size += 1
-      end
-      alias_method  :append, :insert
-
-      # return new size
-      def insert_before(position_value, value)
-        target = find_by_value(position_value)
-        node = LinkNode.call(value, target, :before, self,  &@match_value)
-        @current = node if target
-        self.head = node if self.head.equal?(target)
-        self.tail = node if self.tail.nil?
-        self.size += 1
-      end
-
-      # return new size
-      def insert_after(position_value, value)
-        target = find_by_value(position_value)
-        node = LinkNode.call(value, target, :after, self,  &@match_value)
-        @current = node
-        self.head = node if self.head.nil?
-        self.tail = node if self.tail.equal?(target)
-        self.size += 1
-      end
-
-      # return remaining size
-      def remove(value)
-        target_node = find_by_value(value)
-        if target_node
-          if self.size == 1                           # will become zero
-            @current = nil
-            self.head = nil
-            self.tail = nil
-          elsif target_node.prev.nil?            # top
-            @current = target_node.next
-            @current.prev = nil
-            self.head = @current
-          elsif target_node.next.nil?            # bottom
-            @current = target_node.prev
-            @current.next = nil
-            self.tail = @current
-          else                                   # middle
-            @current = target_node.prev
-            @current.next = target_node.next
-            target_node.next.prev = @current
-          end
-          target_node.remove!
-          self.size -= 1
-        end
-      end
-
-    protected
-
-      def find_by_index(index)
-        return nil if self.head.nil? or index < 1 or index > self.size
-        node = self.head
-        node = node.next while ((index -= 1) > 0 and node.next)
-        @current = node if node
-        node
-      end
-
-    end # end class
-  end # module
-end # end module

data/lib/skn_utils/lists/link_node.rb

@@ -1,103 +0,0 @@
-##
-# Node.
-# - primary object and container of value
-##
-
-module SknUtils
-  module Lists
-
-    class LinkNode
-
-      attr_accessor :prev, :next, :value
-
-      def self.call(val, anchor_node=nil, strategy=:after, mgr=nil, &cmp_key)
-        self.new(val, anchor_node, strategy, mgr, &cmp_key)
-      end
-
-      def initialize(val, anchor_node=nil, strategy=:after, mgr=nil, &cmp_key)
-        @value = val
-        @prev = nil
-        @next = nil
-        @provider = mgr
-        @cmp_proc = block_given? ? cmp_key : lambda {|a| a }
-
-        case strategy
-          when :single # after logic
-            if anchor_node
-              @next = anchor_node.next
-              anchor_node.next = self
-            end
-          when :before
-            @prev = anchor_node.prev if anchor_node
-            anchor_node.prev = self if anchor_node
-            @next = anchor_node
-          when :after
-            @next = anchor_node.next if anchor_node
-            anchor_node.next = self if anchor_node
-            @prev = anchor_node
-          when :circle_before
-            @prev = anchor_node ? anchor_node.prev : self
-            anchor_node.prev = self if anchor_node
-            @next = anchor_node ? anchor_node : self
-          when :circle_after
-            @next = anchor_node ? anchor_node.next : self
-            anchor_node.next = self if anchor_node
-            @prev = anchor_node ? anchor_node : self
-        end
-      end
-
-      def match_by_value(other_value)
-        @cmp_proc.call(self.value) == @cmp_proc.call(other_value)
-      end
-
-      # returns next node
-      def remove!
-        next_node = @next
-        @value = nil
-        @prev = nil
-        @next = nil
-        @provider = nil
-        @cmp_proc = nil
-        next_node
-      end
-
-      def to_s
-        "Node with value: #{@value}"
-      end
-
-      # Reverse API to Parent Linked List Class
-      def node_value
-        node_value_request(:current)
-      end
-      def first_node
-        node_request(:first)
-      end
-      def next_node
-        node_request(:next)
-      end
-      def current_node
-        node_request(:current)
-      end
-      def prev_node
-        node_request(:prev)
-      end
-      def last_node
-        node_request(:last)
-      end
-
-      # Retrieves requested node, not value
-      def node_request(method_sym=:current, *vargs, &block)
-        block_given? ? @provider.send(method_sym, *vargs, &block) :
-            (vargs.size == 0 ?  @provider.send(method_sym) : @provider.send(method_sym, *vargs))
-        @provider.instance_variable_get(:@current)
-      end
-
-      # Retrieves requested value, not node
-      def node_value_request(method_sym=:current, *vargs, &block)
-        block_given? ? @provider.send(method_sym, *vargs, &block) :
-            (vargs.size == 0 ?  @provider.send(method_sym) : @provider.send(method_sym, *vargs))
-      end
-
-    end
-  end # module
-end