skn_utils 2.0.6 → 3.0.0

data/lib/skn_utils/nested_result_base.rb

@@ -1,123 +0,0 @@
-##
-# <project.root>/lib/skn_utils/nested_result_base.rb
-#
-# Creates an Object with instance variables and associated getters and setters for hash each input key. 
-#   If the key's value is also a hash itself, it too will become an Object.
-#   if the key's value is a Array of Hashes, each element of the Array will become an Object.
-# 
-# This nesting action is controlled by the value of the option key ':depth'. 
-#   The key :depth defaults to :multi, an has options of :single, or :multi_with_arrays
-# 
-# The ability of the resulting Object to be Marshalled(dump/load) can be preserved by merging 
-#   input params key ':enable_serialization' set to true.  It defaults to false for speed purposes
-#
-##
-# Operational Options
-# --------------------------------
-#  :enable_serialization = false     -- [ true | false ], for speed, omits creation of attr_accessor
-#  :depth = :multi                   -- [ :single | :multi | :multi_with_arrays ]
-##
-# NOTE: Cannot be Marshalled/Serialized unless input params.merge({enable_serialization: true}) -- default is false
-#       Use GenericBean if serialization is needed, it sets this value to true automatically
-##
-
-
-module SknUtils
-
-  class NestedResultBase
-    include AttributeHelpers
-
-    # :depth controls how deep into input hash/arrays we convert
-    # :depth => :single | :multi | :multi_with_arrays 
-    # :depth defaults to :multi
-    # :enable_serialization controls the use of singleton_method() to preserve the ability to Marshal
-    # :enable_serialization defaults to false
-    #:nodoc:
-    def initialize(params={})
-      @skn_enabled_depth = params.delete(:depth) {|not_found| :multi }
-      @skn_enable_serialization = params.delete(:enable_serialization) {|not_found| false }
-      case @skn_enabled_depth
-        when :single
-              single_level_initializer(params)                 
-        when :multi_with_arrays
-              multi_level_incl_arrays_initializer(params)
-        else
-              multi_level_initializer(params)                  
-      end
-    end
-
-    #:nodoc:
-    def single_level_initializer(params={})   # Single Level Initializer -- ignore value eql hash
-      params.each do |k,v|
-        key = clean_key(k)
-        singleton_class.send(:attr_accessor, key) unless respond_to?(key) or serialization_required?
-        instance_variable_set("@#{key}".to_sym,v)
-      end
-    end
-
-    #:nodoc:
-    def multi_level_initializer(params={}) # Multi Level Initializer -- value eql hash then interate
-      params.each do |k,v|
-        key = clean_key(k)
-        singleton_class.send(:attr_accessor, key) unless respond_to?(key) or serialization_required?
-        if v.kind_of?(Hash)
-          instance_variable_set("@#{key}".to_sym, self.class.new(v))
-        else
-          instance_variable_set("@#{key}".to_sym,v)
-        end
-      end
-    end
-
-    #:nodoc:
-    def multi_level_incl_arrays_initializer(params={}) # Multi Level Initializer including Arrays of Hashes
-      params.each do |k,v|
-        key = clean_key(k)
-        singleton_class.send(:attr_accessor, key) unless respond_to?(key) or serialization_required?
-        if v.kind_of?(Array) and v.first.kind_of?(Hash)
-          instance_variable_set("@#{key}".to_sym, (v.map {|nobj| self.class.new(nobj)}) )
-        elsif v.kind_of?(Hash)
-          instance_variable_set("@#{key}".to_sym, self.class.new(v))
-        else
-          instance_variable_set("@#{key}".to_sym,v)
-        end
-      end
-    end
-
-    # enablement for latter additions    
-    def serialization_required?
-      @skn_enable_serialization
-    end
-
-    # enablement for latter additions        
-    def depth_level
-      @skn_enabled_depth
-    end
-
-    # determines if this is one of our objects
-    #:nodoc:
-    def attribute_helper_object
-      true
-    end
-
-    # Some keys have chars not suitable for symbol keys => @,#,:,-
-    #:nodoc:
-    def clean_key(original)
-      formatted_key = original.to_s.gsub(/[#|@]/,'').gsub(/[:|-]/,'_')
-
-      # if /^[#|@|:]/.match(formatted_key)  # filter out (@xsi) from '@xsi:type' keys
-      #   label = /@(.+):(.+)/.match(formatted_key) || /[#|@|:](.+)/.match(formatted_key) || []
-      #   formatted_key = case label.size
-      #                     when 1
-      #                       label[1].to_s
-      #                     when 2
-      #                       "#{label[1]}_#{label[2]}"
-      #                     else
-      #                       original  # who knows what it was, give it back
-      #                   end
-      # end
-      # formatted_key
-    end
-    
-        
-  end
-end

data/lib/skn_utils/page_controls.rb

@@ -1,21 +0,0 @@
-##
-# <project.root>/lib/skn_utils/page_controls.rb
-#
-# *** See SknUtils::NestedResultBase for details ***
-#
-##
-# (Defaults)
-# :enable_serialization = true     -- for function
-# :depth = :multi_with_arrays
-##
-
-module SknUtils
-
-  class PageControls < NestedResultBase
-    #:nodoc:
-    def initialize(params={})
-      super( params.merge({enable_serialization: true, depth: :multi_with_arrays}) )
-    end
-  end
-  
-end

data/lib/skn_utils/result_bean.rb

@@ -1,17 +0,0 @@
-##
-# <project.root>/lib/skn_utils/result_bean.rb
-#
-# *** See SknUtils::NestedResultBase for details ***
-#
-##
-# (Defaults)
-# :enable_serialization = false     -- for speed
-# :depth = :multi
-##
-
-module SknUtils
-
-  class ResultBean < NestedResultBase
-  end
-  
-end

data/lib/skn_utils/value_bean.rb

@@ -1,20 +0,0 @@
-##
-# <project.root>/lib/skn_utils/generic_bean.rb
-#
-# *** See SknUtils::NestedResultBase for details ***
-#
-##
-# (Defaults)
-# :enable_serialization = true
-# :depth = :single
-
-module SknUtils
-
-  class ValueBean < NestedResultBase
-    #:nodoc:
-    def initialize(params={})
-      super( params.merge({enable_serialization: true, depth: :single}) )
-    end
-  end # end class
-  
-end # end module

data/spec/lib/skn_utils/generic_bean_spec.rb

@@ -1,96 +0,0 @@
-##
-# spec/lib/skn_utils/generic_bean_spec.rb
-#
-
-RSpec.describe SknUtils::GenericBean, "Generic Marshal'able Bean class " do
-  let(:object) {
-    SknUtils::GenericBean.new({one: "one",
-                             two: "two",
-                             three: {four: 4, five: 5, six: {seven: 7, eight: "eight" }},
-                             four: {any_key: "any value"}, five: []}
-                           )
-  }
-
-  context "Internal Operations, assuming :dept => :multi and enable_serialization => true" do
-    it "Creates an empty bean if no params are passed" do
-      is_expected.to be
-    end
-    it "Can be Marshalled after dynamically adding a key/value." do
-        expect { object.fifty = {any_key: "any value"} }.not_to raise_error  
-        expect { object.sixty = 60 }.not_to raise_error
-        dmp = obj = ""  
-        expect { dmp =  Marshal.dump(object) }.not_to raise_error
-        expect { obj = Marshal.load(dmp) }.not_to raise_error
-        expect(obj).to be_a(SknUtils::GenericBean)
-        expect(obj.fifty.any_key).to eql "any value"  
-        expect(obj.sixty).to eql 60
-    end
-    it "Initializes from a hash" do
-      expect(SknUtils::GenericBean.new({one: "one", two: "two"})).to be
-    end
-    it "Does not modify the base class, only singleton instance methods" do
-      obj1 = SknUtils::GenericBean.new({one: "one", two: "two"})
-      obj2 = SknUtils::GenericBean.new({three: "3", four: "4"})
-      expect(obj1.one).to eql "one"
-      expect(obj2.three).to eql "3"
-      expect(obj2.one?).to be false
-      expect(obj1.three?).to be false
-      expect { obj1.three }.to raise_error NoMethodError
-      expect { obj2.one }.to raise_error NoMethodError
-    end
-    it "Supports - respond_to? - method, because it has accessors or method_missing coverage" do
-      expect(object).to respond_to(:one)
-      expect(object.one).to eql "one"
-      expect{ object.fifty = {any_key: "any value"} }.not_to raise_error  
-      expect( object.fifty).to respond_to(:any_key)  
-    end
-    it "nest objects if multi-level hash is given" do
-      expect(object.one).to be_eql("one")
-      expect(object.two).to be_eql("two")
-      expect(object.three).to be_a(SknUtils::GenericBean)
-      expect(object.three.five).to eq(5)
-    end
-    it "#attributes method returns a hash of all attributes and their values." do
-      expect(object.to_hash).to be_a(Hash)
-      expect(object.to_hash[:one]).to be_eql("one")
-      expect(object.to_hash[:three]).to be_a(Hash)
-    end
-  end
-
-  shared_examples_for "retains initialization options" do
-    it "retains depth_level option flag" do
-      expect(@obj.depth_level).to eql(:multi)
-    end
-    it "retains serialization option flag" do
-      expect(@obj.serialization_required?).to be true
-    end    
-  end
-
-  context "Basic Operations without marshaling " do
-    before :each do
-      @obj = object
-    end
-
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-  context "Basic Operations after Yaml marshaling " do
-    before :each do
-      dmp = YAML::dump(object)
-      @obj = YAML::load(dmp)
-    end
-
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-  context "Basic Operations after Marshal marshaling " do
-    before :each do
-      dmp =  Marshal.dump(object)
-      @obj = Marshal.load(dmp)
-    end
-
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-
-end

data/spec/lib/skn_utils/page_controls_spec.rb

@@ -1,124 +0,0 @@
-##
-# spec/lib/skn_utils/generic_bean_spec.rb
-#
-
-RSpec.describe SknUtils::PageControls, "PageControls Marshal'able Bean class " do
-  let(:object) {
-    SknUtils::PageControls.new({one: "one",
-                               two: "two",
-                               three: {four: 4, five: 5, six: {seven: 7, eight: "eight" }},
-                               four: {any_key: "any value"}, 
-                               five: [],
-                               six: [{any_key: "any value"},
-                                     {four: 4, 
-                                      five: 5, 
-                                      six: {seven: 7, eight: "eight" }, 
-                                      twenty:[{seven: 7, eight: 8 }, {nine: 9, ten: 10 }]
-                                     }
-                                    ]
-                              })
-  }
-
-  context "Internal Operations, assuming :dept => :multi_with_arrays and enable_serialization => true" do
-    it "Creates an empty bean if no params are passed" do
-      is_expected.to be
-    end
-    it "Can be Marshalled after dynamically adding a key/value." do
-        expect { object.fifty = {any_key: "any value"} }.not_to raise_error  
-        expect { object.sixty = 60 }.not_to raise_error
-        dmp = obj = ""  
-        expect { dmp =  Marshal.dump(object) }.not_to raise_error
-        expect { obj = Marshal.load(dmp) }.not_to raise_error
-        expect(obj).to be_a(SknUtils::PageControls)
-        expect( obj.fifty.any_key).to eql "any value"  
-        expect( obj.sixty).to eql 60
-    end
-    it "Initializes from a hash" do
-      expect(object).to be
-    end
-    it "Does not modify the base class, only singleton instance methods" do
-      obj1 = SknUtils::PageControls.new({one: "one", two: "two"})
-      obj2 = SknUtils::PageControls.new({three: "3", four: "4"})
-      expect(obj1.one).to eql "one"
-      expect(obj2.three).to eql "3"
-      expect(obj2.one?).to be false
-      expect(obj1.three?).to be false
-      expect { obj1.three }.to raise_error NoMethodError
-      expect { obj2.one }.to raise_error NoMethodError
-    end
-    it "Supports predicates(?)" do
-      expect(object.one?).to be true
-      expect(object.three.five?).to be true
-      expect(object.fourtyfive?).to be false
-    end
-    it "Supports - respond_to? - method, because it has accessor or method_missing coverage" do
-      expect(object).to respond_to(:one)
-      expect(object.one).to eql "one"
-    end
-    it "nest objects if multi-level hash is given" do
-      expect(object.three).to be_a(SknUtils::PageControls)
-      expect(object.three.five).to eq(5)
-    end
-    it "nest objects if multi-level array of hashes is given" do
-      expect(object.six).to be_a(Array)
-      expect(object.six.first).to be_a(SknUtils::PageControls)
-      expect(object.six.last).to be_a(SknUtils::PageControls)
-      expect(object.six.last.six.eight).to eq('eight')
-    end
-    it "nest objects if multi-level array of hashes, and an element contains another array of hashes, is given" do
-      expect(object.six.first).to be_a(SknUtils::PageControls)
-      expect(object.six).to be_a(Array)
-      expect(object.six.last.twenty).to be_a(Array)
-      expect(object.six.last.twenty.first).to be_a(SknUtils::PageControls)
-      expect(object.six.last.twenty.last).to be_a(SknUtils::PageControls)
-      expect(object.six.last.twenty.first.eight).to eq(8)
-      expect(object.six.last.twenty.last.ten).to eq(10)
-    end
-    it "nest arrays of objects if array of hashes is dynamically given  (post-create)" do
-      expect { object.one_array = [{one: "one", two: "two"},{one: 1, two: 2}] }.not_to raise_error
-      expect(object.one_array.first.one).to eql("one")
-      expect(object.one_array.last.two).to eql(2)
-      expect(object.one_array[0]).to be_a(SknUtils::PageControls)
-    end
-    it "#attributes method returns a hash of all attributes and their values." do
-      expect(object.to_hash).to be_a(Hash)
-      expect(object.to_hash[:one]).to be_eql("one")
-      expect(object.to_hash[:three]).to be_a(Hash)
-      expect(object.to_hash[:six].last[:six][:eight]).to eql('eight')
-    end
-  end
-
-  shared_examples_for "retains initialization options" do
-    it "retains depth_level option flag" do
-      expect(@obj.depth_level).to eql(:multi_with_arrays)
-    end
-    it "retains serialization option flag" do
-      expect(@obj.serialization_required?).to be true
-    end    
-  end
-
-  context "Basic Operations without marshaling " do
-    before :each do
-      @obj = object
-    end
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end  
-  context "Basic Operations after Yaml marshaling " do
-    before :each do
-      dmp = YAML::dump(object)
-      @obj = YAML::load(dmp)
-    end    
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-  context "Basic Operations after Marshal marshaling " do
-    before :each do
-      dmp =  Marshal.dump(object)
-      @obj = Marshal.load(dmp)
-    end
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-
-end

data/spec/lib/skn_utils/result_bean_spec.rb

@@ -1,98 +0,0 @@
-##
-# spec/lib/skn_utils/result_bean_spec.rb
-#
-
-RSpec.describe SknUtils::ResultBean, "Result Bean class - Basic usage." do
-  let(:object) {
-    SknUtils::ResultBean.new({one: "one",
-                             two: "two",
-                             three: {four: 4, five: 5, six: {seven: 7, eight: "eight" }},
-                             four: {any_key: "any value"}, 
-                             five: [],
-                             six: [{four: 4, five: 5, six: {seven: 7, eight: "eight" }},
-                                   {four: 4, five: 5, six: {nine: 9, ten: "ten" }}
-                                  ]
-                            })
-  }
-
-  context "Internal Operations, assuming :dept => :multi and enable_serialization => false" do
-    it "Creates an empty bean if no params are passed" do
-      is_expected.to be
-    end
-    it "Initializes from a hash" do
-      expect(SknUtils::ResultBean.new({one: "one", two: "two"})).to be
-    end
-    it "Does not modify the base class, only singleton instance methods" do
-      obj1 = SknUtils::ResultBean.new({one: "one", two: "two"})
-      obj2 = SknUtils::ResultBean.new({three: 3, four: "4"})
-      expect(obj1.one).to eql "one"
-      expect(obj2.three).to eql 3
-      expect(obj2.one?).to be false
-      expect(obj1.three?).to be false
-      expect { obj1.three }.to raise_error NoMethodError
-      expect { obj2.one }.to raise_error NoMethodError
-    end
-    it "Supports - respond_to - methods, because it has accessor methods" do
-      expect(object).to respond_to(:one)
-    end
-    it "Supports - respond_to - methods, because it has respond_to_missing? method" do
-      expect(object.method(:one)).to be
-    end
-  end
-
-  shared_examples_for "retains initialization options" do
-    it "retains depth_level option flag" do
-      expect(@obj.depth_level).to eql(:multi)
-    end
-    it "retains serialization option flag" do
-      expect(@obj.serialization_required?).to be false
-    end    
-  end
-
-  context "Basic Operations after Marshal marshaling " do
-    it "Singleton objects (like ResultBean) cannot be marshaled" do
-      expect { Marshal.dump(object) }.to raise_error TypeError
-    end
-  end
-  context "Basic Operations without marshaling " do
-    before :each do
-      @obj = object
-    end
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "ruby pojo"
-  end
-  context "Basic Operations after Yaml marshaling " do
-    before :each do
-      dmp = YAML::dump(object)
-      @obj = YAML::load(dmp)
-    end
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "ruby pojo"
-  end
-  context "ResultBeans stripped of their internal singleton accessors can be Marshaled! " do
-    before :each do
-      dmp = YAML::dump(object)
-      obj = YAML::load(dmp)                        # Yaml'ing removes singleton accessor methods'
-                                                   # by initializing object without using its
-                                                   # initialize() method
-
-      dmp =  Marshal.dump(obj)                     # Now Marshal load/dump will work
-      @obj = Marshal.load(dmp)                     # Use GenericBean if Marshal support is needed
-    end
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "ruby pojo"
-  end
-  context "Basic Operations after Yaml marshaling via restored accessors " do
-    before :each do
-      dmp = YAML::dump(object)
-      @obj = YAML::load(dmp)
-      # Restore setters
-      # @obj.attributes.keys.each do |k|
-        # @obj.singleton_class.send(:attr_accessor, k)
-      # end
-    end
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "ruby pojo"
-  end
-
-end

data/spec/lib/skn_utils/value_bean_spec.rb

@@ -1,96 +0,0 @@
-##
-# spec/lib/skn_utils/Value_bean_spec.rb
-#
-
-RSpec.describe SknUtils::ValueBean, "Basic Value Bean class " do
-  let(:object) {
-    SknUtils::ValueBean.new({one: "one",
-                             two: "two",
-                             three: {four: 4, five: 5, six: {seven: 7, eight: "eight" }},
-                             four: {any_key: "any value"}, five: []}
-                           )
-  }
-
-  context "Internal Operations, assuming :dept => :multi and enable_serialization => true" do
-    it "Creates an empty bean if no params are passed" do
-      is_expected.to be
-    end
-    it "Can be Marshalled after dynamically adding a key/value." do
-        expect { object.fifty = {any_key: "any value"} }.not_to raise_error  
-        expect { object.sixty = 60 }.not_to raise_error
-        dmp = obj = ""  
-        expect { dmp =  Marshal.dump(object) }.not_to raise_error
-        expect { obj = Marshal.load(dmp) }.not_to raise_error
-        expect(obj).to be_a(SknUtils::ValueBean)
-        expect(obj.fifty[:any_key]).to eql "any value"
-        expect(obj.sixty).to eql 60
-    end
-    it "Initializes from a hash" do
-      expect(SknUtils::ValueBean.new({one: "one", two: "two"})).to be
-    end
-    it "Does not modify the base class, only singleton instance methods" do
-      obj1 = SknUtils::ValueBean.new({one: "one", two: "two"})
-      obj2 = SknUtils::ValueBean.new({three: "3", four: "4"})
-      expect(obj1.one).to eql "one"
-      expect(obj2.three).to eql "3"
-      expect(obj2.one?).to be false
-      expect(obj1.three?).to be false
-      expect { obj1.three }.to raise_error NoMethodError
-      expect { obj2.one }.to raise_error NoMethodError
-    end
-    it "Supports - respond_to? - method, because it has accessors or method_missing coverage" do
-      expect(object).to respond_to(:one)
-      expect(object.one).to eql "one"
-      expect{ object.fifty = {any_key: "any value"} }.not_to raise_error  
-      expect( object.fifty).not_to respond_to(:any_key)
-    end
-    it "nest objects if multi-level hash is given" do
-      expect(object.one).to be_eql("one")
-      expect(object.two).to be_eql("two")
-      expect(object.three).to be_a(Hash)
-      expect(object.three[:five]).to eq(5)
-    end
-    it "#attributes method returns a hash of all attributes and their values." do
-      expect(object.to_hash).to be_a(Hash)
-      expect(object.to_hash[:one]).to be_eql("one")
-      expect(object.to_hash[:three]).to be_a(Hash)
-    end
-  end
-
-  shared_examples_for "retains initialization options" do
-    it "retains depth_level option flag" do
-      expect(@obj.depth_level).to eql(:single)
-    end
-    it "retains serialization option flag" do
-      expect(@obj.serialization_required?).to be true
-    end    
-  end
-
-  context "Basic Operations without marshaling " do
-    before :each do
-      @obj = object
-    end
-
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-  context "Basic Operations after Yaml marshaling " do
-    before :each do
-      dmp = YAML::dump(object)
-      @obj = YAML::load(dmp)
-    end
-
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-  context "Basic Operations after Marshal marshaling " do
-    before :each do
-      dmp =  Marshal.dump(object)
-      @obj = Marshal.load(dmp)
-    end
-
-    it_behaves_like "retains initialization options"    
-    it_behaves_like "marshalable ruby pojo"
-  end
-
-end

data/spec/support/shared_example_marshalable_ruby_pojo.rb

@@ -1,54 +0,0 @@
-##
-# <root>/spec/support/shared_example_marshalable_ruby_pojo.rb
-#
-# refs: page_controls, generic_bean
-#
-
-RSpec.shared_examples "marshalable ruby pojo" do
-  it "provides getters" do
-    expect(@obj.one).to be_eql("one")
-    expect(@obj.two).to be_eql("two")
-  end
-  it "provides setters" do
-    @obj.one = "1"
-    @obj.two = "2"
-    expect(@obj.two).to be_eql("2")
-    expect(@obj.one).to be_eql("1")
-  end
-  it "#clear_attribute sets given attribute to nil." do
-    expect(@obj.two).to be_eql("two")
-    expect(@obj.clear_two).to be_nil
-  end
-  it "#attribute? returns true or false based on true presence and non-blank contents of attribute." do
-    expect(@obj.two?).to be true
-    @obj.two = false
-    expect(@obj.two?).to be true
-    @obj.clear_two
-    expect(@obj.two?).to be false
-    expect(@obj.three?).to be true
-    expect(@obj.four?).to be true
-    @obj.clear_three
-    expect(@obj.three?).to be false
-    @obj.clear_four
-    expect(@obj.four?).to be false
-  end
-  it "#attribute? returns false when attribute is not defined or unknown" do
-    expect(@obj.address?).to be false
-  end
-  it "raises an 'NoMethodError' error when attribute does not exist" do
-    expect { @obj.address }.to raise_error NoMethodError
-  end
-  it "#to_hash method excludes internal attributes unless overridden." do
-    expect(@obj.to_hash[:skn_enabled_depth]).to be_nil
-    expect(@obj.to_hash(false)[:skn_enabled_depth]).to be_nil
-    expect(@obj.to_hash(true)[:skn_enabled_depth]).to eql @obj.depth_level
-  end
-  context "transformations are enabled with " do
-    it "#to_hash method returns a serialized version of this object." do
-      expect(@obj.to_hash).to be_a(Hash)
-    end
-    it "#attributes method returns original input hash." do
-      expect(@obj.attributes).to be_a(Hash)
-    end
-  end
-end