skn_utils 3.5.2 → 3.6.0

data/lib/skn_utils/lists/linked_commons.rb

@@ -1,216 +0,0 @@
-##
-# File <SknUtils>/lib/skn_utils/lists/linked_commons.rb
-#
-# Common routines for Linked List:
-#     #initialize, #first, #next, #current, #last, #at_index,
-#     #insert, #prepend, #append, #empty?, #clear,
-#     #each, #to_a, and #sort!
-#
-#   list = SknUtils::Lists::DoublyLinkedList.new(1,2,3,4)
-#
-#   value = list.first
-#   value = list.next
-#
-##
-#   Node Interface Special Methods called
-#   from LinkNode to execute regular methods on other nodes
-#
-#     #node_request(method_sym=:current, *vargs, &block)          ==> node
-#     #node_value_request(method_sym=:current, *vargs, &block)    ==> value or method return
-##
-#    node = SknUtils::Lists::DoublyLinkedList.call(1,2,3,4)
-#
-#    node = node.first_node
-#    value = node.value
-#    value = node.next_node.value
-##
-
-module SknUtils
-  module Lists
-
-    class LinkedCommons
-      attr_accessor :size
-
-      # Initialize and return first node if nodes are available, else class instance
-      def self.call(*vargs, &compare_key_proc)
-        target = self.new(*vargs, &compare_key_proc)
-        return target.instance_variable_get(:@current) if vargs.size > 1
-        target
-      end
-
-      def initialize(*vargs, &compare_key_proc)
-        @current = nil
-        @head = nil
-        @tail = nil
-        @size = 0
-
-        @match_value     = block_given? ? compare_key_proc : lambda {|obj| obj }
-        @sort_ascending  = lambda {|a_obj,b_obj| @match_value.call(a_obj) >= @match_value.call(b_obj)}
-        @sort_descending = lambda {|a_obj,b_obj| @match_value.call(a_obj) <= @match_value.call(b_obj)}
-        @sort_condition  = @sort_ascending
-
-        vargs.each {|value| insert(value) }
-        first if vargs.size > 1
-      end
-
-
-      # return values and position current to last node accessed
-      # prevent @current from nil assignment
-      def first
-        @current = self.head if self.head
-        @current.value rescue nil
-      end
-
-      def next
-        @current = @current.next if @current and @current.next
-        @current.value rescue nil
-      end
-
-      def current
-        @current.value rescue nil
-      end
-
-      def last
-        @current = self.tail if self.tail
-        @current.value rescue nil
-      end
-
-      # return node at positive index from head
-      def at_index(index)
-        find_by_index(index)
-        current
-      end
-
-      # Access to current node as anchor for Node based operations
-      # if initialized without vargs, this is only way to access a node
-      def nodes
-        @current
-      end
-
-      def empty?
-        self.size == 0
-      end
-
-      # return number cleared
-      def clear
-        rc = 0
-        node = self.head
-        position = node
-        while node do
-          node = node.remove!
-          rc += 1
-          break if position.equal?(node)
-        end
-
-        @current = nil
-        self.head = nil
-        self.tail = nil
-        self.size = 0
-        rc
-      end
-
-      # return new size
-      def prepend(value)
-        temp = self.head.value rescue nil
-        insert_before(temp, value)
-      end
-
-      #
-      # Enumerate
-      #
-
-      # perform each() or return enumerator
-      def each(&block)
-        @current = self.head
-        position = @current
-        if block_given?
-          while position do
-            block.call( position.value.dup )
-            position = position.next
-            break if position.equal?(@current)
-          end
-        else
-          Enumerator.new do |yielder|
-            while position do
-              yielder << position.value.dup
-              position = position.next
-              break if position.equal?(@current)
-            end
-          end
-        end
-      end
-
-      # convert self to a value array
-      def to_a
-        @current = self.head
-        position = self.head
-        result = []
-        while position do
-          result << position.value.dup
-          position = position.next
-          break if position.equal?(@current)
-        end
-        result
-      end
-
-      # block format: sort condition : {|a_obj,b_obj| a_obj >= b_obj}
-      def sort!(direction_sym=:default, &compare_sort_proc)
-        @active_sort_condition = block_given? ? compare_sort_proc :
-                                     case direction_sym
-                                       when :asc
-                                         @sort_ascending
-                                       when :desc
-                                         @sort_descending
-                                       else
-                                         @sort_condition
-                                     end
-        sorted = merge_sort(self.to_a)
-        clear
-        sorted.each {|item| insert(item) }
-        self.size
-      end
-
-
-    protected
-
-      attr_accessor :head, :tail
-
-      # scan for first occurance of matching value
-      def find_by_value(value)
-        return nil if value.nil? || self.size == 0
-        stop_node = self.head
-        target = stop_node
-        while target && !target.match_by_value(value)
-          target = target.next
-          break if stop_node.equal?(target)
-        end
-        target = nil unless target && target.match_by_value(value)
-        target
-      end
-
-      # Merged Sort via Ref: http://rubyalgorithms.com/merge_sort.html
-      # arr is Array to be sorted, sort_cond is Proc expecting a/b params returning true/false
-      def merge_sort(arr)
-        return arr if arr.size < 2
-        middle = arr.size / 2
-        left = merge_sort(arr[0...middle])
-        right = merge_sort(arr[middle..arr.size])
-        merge(left, right)
-      end
-
-      def merge(left, right)
-        sorted = []
-        while left.any? && right.any?
-          if @active_sort_condition.call(left.first, right.first)
-            sorted.push right.shift
-          else
-            sorted.push left.shift
-          end
-        end
-
-        sorted + left + right
-      end
-
-    end
-  end # module
-end

data/lib/skn_utils/lists/linked_list.rb

@@ -1,122 +0,0 @@
-##
-# File <SknUtils>/lib/skn_utils/lists/linked_list.rb
-#
-#     ll = SknUtils::Lists::LinkedList.new(*vargs, &compare_key_proc)
-# - or -
-#     ll = SknUtils::Lists::LinkedList.new(1,2,3,4,5) {|element| element[:key] }
-# - or -
-#     ll = SknUtils::Lists::LinkedList.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::LinkedList.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
-    # Singly Linked List
-    # Forward or #next navigation only
-    # Head is absolute via #first
-    # Tail when (next == nil)
-
-    # LinkedCommons provides;
-    # - #initialize, #first, #next, #current, #last, #at_index,
-    #   #insert, #prepend, #append, #empty?, #clear,
-    #   #each, #to_a, and #sort!
-    #
-    class LinkedList < LinkedCommons
-
-      #
-      # Navigation
-      #
-
-      # +int position from current node
-      def nth(index)
-        node = @current
-        while index > 1 and node and node.next
-          node = node.next
-          index -= 1
-          @current = node
-        end
-        # no reverse or prev for Single List
-        current
-      end
-
-      #
-      # Modifications
-      #
-
-      def insert(value)
-        node = @current
-        @current = LinkNode.call(value, node, :single, 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)
-        prior, target = find_by_value(position_value)
-        node = LinkNode.call(value, prior, :single, self,  &@match_value)
-        node.next = target if target
-        self.head = node if self.head.equal?(target)
-        self.tail = node if self.tail.nil?
-        @current = node
-        self.size += 1
-      end
-
-      # return new size
-      def insert_after(position_value, value)
-        prior, target = find_by_value(position_value)
-        node = LinkNode.call(value, target, :single, self,  &@match_value)
-        self.head = node if self.head.nil?
-        self.tail = node if self.tail.equal?(target)
-        @current = node
-        self.size += 1
-      end
-
-      # return remaining size
-      def remove(value)
-        prior, target_node = find_by_value(value)
-        @current = prior.nil? ? target_node.next : prior
-        @current.next = target_node.remove! if @current && target_node
-        self.tail = @current.next if @current && self.tail.equal?(target_node)
-        self.head = @current.next if @current && self.head.equal?(target_node)
-        self.size -= 1
-      end
-
-    protected
-
-      def find_by_value(value)
-        return [@current, nil] if self.head.nil? || value.nil?
-        prior  = self.head
-        target = prior
-        while target && !target.match_by_value(value)
-          prior = target
-          target = target.next
-        end
-        [prior, target]
-      end
-
-      def find_by_index(index)
-        return nil if self.head.nil? || index < 1 || 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 # end module
-end # end module

data/spec/lib/skn_utils/business_services/year_month_spec.rb

@@ -1,49 +0,0 @@
-##
-# spec/lib/skn_utils/node_based_linked_list_spec.rb
-#
-
-RSpec.describe SknUtils::BusinessServices::YearMonth, "Year Month Calculator " do
-
-  let(:basic) { described_class.new(2017, 1) }
-
-  context "Normal Operations " do
-
-    it "No params" do
-      expect{described_class.new}.to raise_error(ArgumentError)
-    end
-    it "With Params" do
-      expect(basic).to be_a described_class
-    end
-    it "#beginning_of month to be correct. " do
-      expect(basic.beginning_of).to be_a Time
-    end
-    it "#end_of month to be correct. " do
-      expect(basic.end_of).to be_a Time
-    end
-    it "#month to equal 3." do
-      expect(basic.month).to eq(1)
-    end
-    it "#year to equal 2017." do
-      expect(basic.year).to eq(2017)
-    end
-    it "#next.month to equal 2." do
-      expect(basic.next.month).to eq(2)
-    end
-    it "Comparisons are correct." do
-      expect(described_class.new(2017,1)).to eq(described_class.new(2017,1))
-      expect(described_class.new(2017,2)).to be > (described_class.new(2017,1))
-      expect(described_class.new(2017,1)).to be < (described_class.new(2017,2))
-    end
-  end
-
-  context "Range Operations " do
-
-    it "Can be represented in a Range object.  " do
-      range = described_class.new(2017, 1)..described_class.new(2017, 9)
-
-      expect(range).to  include(described_class.new(2017, 2))
-      expect(range).to  include(described_class.new(2017, 7))
-    end
-  end
-
-end

data/spec/lib/skn_utils/converters/hash_to_xml_spec.rb

@@ -1,120 +0,0 @@
-##
-# spec/lib/skn_utils/converters/hash_to_xml_spec.rb
-#
-
-describe SknUtils::Converters::HashToXml,  "Hash to XML Converter Utility " do
-
-  context "Initializers Feature. " do
-
-    it "#new can be called without params or block without error. " do
-      expect( described_class.new()).to be_a described_class
-    end
-
-    it "#call can be called without params or block without error. " do
-      expect( described_class.call()).to be nil
-    end
-
-    it "#call called with params returns xml string as expected. " do
-      string = described_class.call({
-                                      one: 1,
-                                      two: 2,
-                                      list: {item: [1,2,3]},
-                                      listings: {item: [1,2,3]}
-                                    })
-      puts __method__, string
-      expect(string).to be_a String
-    end
-
-    it "#call called with params and block yields xml string as expected. " do
-      described_class.call({
-                             one: 1,
-                             two: 2,
-                             list: {item: [1,2,3]},
-                             listings: {item: [1,2,3]}
-                           }) do |string|
-        puts __method__, string
-        expect(string).to be_a String
-      end
-    end
-
-  end
-
-  context "Handles Complex Hashes. " do
-    let(:array_of_hashes) {
-        {'resource' => [
-                      { 'name' => 'category1',
-                        'subCategory' => [
-                            { 'name' => 'subCategory1',
-                              'product' => [
-                                  { 'name' => 'productName1',
-                                    'desc' => 'desc1' },
-                                  { 'name' => 'productName2',
-                                    'desc' => 'desc2' } ]
-                            } ]
-                      },
-                      { 'name' => 'category2',
-                        'subCategory' => [
-                            { 'name' => 'subCategory2.1',
-                              'product' => [
-                                  { 'name' => 'productName2.1.1',
-                                    'desc' => 'desc1' },
-                                  { 'name' => 'productName2.1.2',
-                                    'desc' => 'desc2' } ]
-                            } ]
-                      }
-                   ]
-        }
-    }
-
-    let(:xml_aware_hash) {
-                    {'xmlAwareHash' =>
-                      {
-                        'num' => 99,
-                        'title' => 'something witty',
-                        'nested' => {
-                          'total' => [99, 98],
-                          '@attributes' => {'foo' => 'bar', 'hello' => 'world'}
-                        },
-                        'anothernest' => {
-                          '@attributes' => {'foo' => 'bar', 'hello' => 'world'},
-                          'date' => [
-                            'today',
-                            {'day' => 23, 'month' => 'Dec',
-                              'year' => {'y' => 1999, 'c' => 21},
-                              '@attributes' => {'foo' => 'blhjkldsaf'}
-                            }
-                          ]
-                        }
-                      }
-                    }
-    }
-
-    it "#call(nested_hash) return an xml string as expected." do
-      string = described_class.call({
-                                      one: 1,
-                                      two: 2,
-                                      list: {item: [1,2,3]},
-                                      listings: {
-                                          uri: 'topic/content/topic_value',
-                                          '@attributes' => {secured: true}}
-                                    })
-      puts __method__, string
-      expect( string ).to be_a String
-    end
-
-    it "#call(array_of_hashes) return an xml string as expected." do
-      string = described_class.call(array_of_hashes, false)
-      puts __method__, string
-      expect( string ).to be_a String
-    end
-
-    it "#call(xml_aware_hash) return an xml string as expected." do
-      string = described_class.call(xml_aware_hash)
-      puts __method__, string
-      expect( string ).to be_a String
-    end
-
-  end
-
-
-end

data/spec/lib/skn_utils/exploring/action_service_spec.rb

@@ -1,40 +0,0 @@
-##
-# spec/lib/skn_utils/exploring/action_service_spec.rb
-#
-
-RSpec.describe SknUtils::Exploring::ActionService, "Example Service Object class with command interface." do
-  let(:action) {
-    SknUtils::Exploring::ActionService.new('Thingys')
-  }
-
-  context "Handles Bad Input. " do
-    it "Handles invalid string input params" do
-      expect { action.('Samples') }.to output(/Samples/).to_stdout
-    end
-  end
-
-  context "Single Method Invocations. " do
-    it "Handles a call with no param" do
-      expect { action.() }.to output(/No Action Taken/).to_stdout
-    end
-    it "Handles a call with one param" do
-      expect { action.(:action_one) }.to output(/Thingys/).to_stdout
-    end
-    it "Handles a call with more than one param" do
-      expect { action.(:action_two, 'Wonderful') }.to output(/Wonderful/).to_stdout
-    end
-  end
-
-  context "Chaining Method Invocations. " do
-    it "Handles calls with no params" do
-      expect { action.().() }.to output(/No Action Taken/).to_stdout
-    end
-    it "Handles a calls with one param" do
-      expect { action.(:action_one).(:action_one) }.to output(/Thingys/).to_stdout
-    end
-    it "Handles a calls with more than one param" do
-      expect { action.(:action_two, 'Wonderful').(:action_two, 'Marvelous') }.to output(/Wonderful/).to_stdout
-    end
-  end
-
-end

data/spec/lib/skn_utils/exploring/commander_spec.rb

@@ -1,125 +0,0 @@
-##
-# spec/lib/skn_utils/commander_spec.rb
-#
-#
-
-class Person
-  extend SknUtils::Exploring::Commander
-  command [:make_me_a_sandwich, :cook, :blocky] => :@friend
-  query [:activities, :go, :say_what] => :friend
-  attr_accessor :friend
-end
-
-class Friend
-  def make_me_a_sandwich
-    Table.place "a sandwich!"
-  end
-
-  def cook(what)
-    Table.place what
-  end
-
-  def activities
-    'running, biking, hiking'
-  end
-
-  def go(do_what)
-    Activities.record do_what
-  end
-
-  def blocky(text)
-    Activities.record([yield(self).to_s,text].join(' '))
-  end
-
-  def say_what(text)
-    [yield(self).to_s,text].join(' ')
-  end
-end
-
-module Table
-  def self.place(text)
-    contents << text
-  end
-  def self.contents
-    @contents ||= []
-  end
-  def self.clear
-    @contents = []
-  end
-end
-
-module Activities
-  def self.record(text)
-    list << text
-  end
-  def self.list
-    @list ||= []
-  end
-  def self.clear
-    @list = []
-  end
-end
-
-RSpec.describe SknUtils::Exploring::Commander, 'command' do
-  let(:friend){ Friend.new }
-  let(:person){ person = Person.new
-  person.friend = friend
-  person
-  }
-  before do
-    Table.clear
-    Activities.clear
-  end
-  it 'forwards a message to another object' do
-    expect(Table.contents).to eq []
-    person.make_me_a_sandwich
-    expect(Table.contents).to include "a sandwich!"
-  end
-
-  it 'returns the original receiver' do
-    expect( person).to eq person.make_me_a_sandwich
-  end
-
-  it 'forwards additional arguments' do
-    expect(Table.contents).to eq []
-    person.cook('yum')
-    expect(Table.contents).to include "yum"
-  end
-
-  it 'forwards block arguments' do
-    expect(Activities.list).to eq []
-    person.blocky('yay!') do |friend|
-      "Arguments forwarded to #{friend}"
-    end
-    expect(Activities.list).to include "Arguments forwarded to #{friend} yay!"
-  end
-end
-
-RSpec.describe SknUtils::Exploring::Commander, 'query' do
-  let(:friend){ Friend.new }
-  let(:person){ person = Person.new
-  person.friend = friend
-  person
-  }
-  before do
-    Activities.clear
-  end
-
-  it 'forwards a message to another object' do
-    expect(person.activities).to eq "running, biking, hiking"
-  end
-
-  it 'forwards additional arguments' do
-    expect(Activities.list).to eq []
-    person.go('have fun')
-    expect(Activities.list).to include "have fun"
-  end
-
-  it 'forwards block arguments' do
-    expect(Activities.list).to eq []
-    what_said = person.say_what('yay!') do |friend|
-      "Arguments forwarded to #{friend}"
-    end
-    expect(what_said).to eq "Arguments forwarded to #{friend} yay!"
-  end
-end