skn_utils 1.4.0

data/lib/skn_utils/generic_bean.rb

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

data/lib/skn_utils/nested_result_base.rb

@@ -0,0 +1,233 @@
+##
+# <Rails.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 
+#   into the 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 ]
+##
+# Public Components
+# --------------------------------
+# Inherit from NestedResultBase
+# or Include AttributeHelpers
+##
+#
+# Basic function includes:
+#  - provides the hash or dot notation methods of accessing values from object created; i.e
+#     'obj = ResultBean.new({value1: "some value", value2: {one: 1, two: "two"}}) 
+#     'x = obj.value1' or 'x = obj.value2.one'
+#     'x = obj["value1"]'
+#     'x = obj[:value1]'
+#
+#  - enables serialization by avoiding the use of 'singleton_class' methods which breaks Serializers
+#    Serializer supports xml, json, hash, and standard Marshall'ing
+#
+#    person = PageControls.new({name: "Bob"})
+#    person.attributes          # => {"name"=>"Bob"}
+#    person.serializable_hash   # => {"name"=>"Bob"}
+#    person.to_hash             # => {"name"=>"Bob"}
+#    person.to_json             # => "{\"name\":\"Bob\"}"
+#    person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<page-controls>\n  <name>Bob</name>\n</page-controls>\n"
+#    dmp = Marshal.dump(person) # => "\x04\bo:\x1ASknUtils::PageControls\x06:\n@nameI\"\bBob\x06:\x06ET"
+#    person = Marshal.load(dmp) # => #<SknUtils::PageControls:0x007faede906d40 @name="Bob">
+#
+#    ***GenericBean designed to automatically handle the setup for serialization and multi level without arrays 
+#
+#  - post create additions:
+#     'obj = ResultBean.new({value1: "some value", value2: {one: 1, two: "two"}}) 
+#     'x = obj.one'                          --causes NoMethodError
+#     'x = obj.one = 'some other value'      --creates a new instance value with accessors
+#     'x = obj.one = {key1: 1, two: "two"}'  --creates a new ***bean as the value of obj.one
+#     'y = obj.one.two'                      --returns "two"
+#     'y = obj.one[:two]                     --returns "two"
+#     'y = obj.one['two']                    --returns "two"
+#
+#  - supports predicates <attr>? and clear_<attr>? method patterns
+#     'obj = PageControls.new({name: "Something", phone: "2604815365"})'
+#     'obj.name?'       # => true    true or false, like obj.name.present?
+#     'obj.clear_name'  # => nil     sets :name to nil
+#
+##
+# The combination of this NestedResultBase(dot notation class) and AttributeHelpers(hash notation module), produces
+# this effect from an input hash:
+#
+#   {:depth => <select>, ...}  Input Hash                                        Basic dot notation
+#   -------------------------  ---------------------------------------          ---------------------------------
+#
+## (DOES NOT FOLLOW Values)
+#   * :single                  - {one: 1,                                         drb.one      = 1
+#                                 two: { one: 1,                                  drb.two      = {one: 1, two: 'two}
+#                                        two: "two"                               drb.two.two  = NoMethodError
+#                                      }, 
+#                                 three: [ {one: 'one', two: 2},                  drb.three    = [{one: 'one', two: 2},{three: 'three', four: 4}]
+#                                          {three: 'three', four: 4}              drb.three[1] = {three: 'three', four: 4}
+#                                        ]                                        drb.three[1].four = NoMethodError
+#                                }      
+#
+## (Follow VALUES that are Hashes only.)
+#   * :multi                   - {one: 1,                                         drb.one      = 1
+#                                 two: { one: 1,                                  drb.two.one  = 1
+#                                        two: "two"                               drb.two.two  = 'two'
+#                                      }, 
+#                                 three: [ {one: 'one', two: 2},                  drb.three    = [{one: 'one', two: 2},{three: 'three', four: 4}]
+#                                          {three: 'three', four: 4}              drb.three[1] = {three: 'three', four: 4}
+#                                        ]                                        drb.three[1].four = NoMethodError
+#                                }      
+#
+## (Follow VALUES that are Hashes and/or Arrays of Hashes)
+#   * :multi_with_arrays       - {one: 1,                                         drb.one      = 1
+#                                 two: { one: 1,                                  drb.two.one  = 1
+#                                        two: "two"                               drb.two.two  = 'two'
+#                                      }, 
+#                                 three: [ {one: 'one', two: 2},                  drb.three.first.one = 'one'
+#                                          {three: 'three', four: 4}              drb.three[1].four   = 4
+#                                        ]
+#                                }      
+#
+##
+# -- SubClassing Usage Examples --
+#
+# (DOES NOT FOLLOW Values)
+#       class SmallPackage < NestedResultBase
+#          def initialize(params={})
+#            super( params.merge({depth: :single}) )    # override default of :multi level
+#          end
+#       end
+#
+# (Follow VALUES that are Hashes only.)
+#       class ResultBean < NestedResultBase
+#          # defaults to :multi level
+#       end
+#   -- or --
+#       class ResultBean < NestedResultBase
+#          def initialize(params={})
+#            # your other init stuff here
+#            super(params)    # default taken 
+#          end
+#       end
+#   -- or --
+#       class ResultBean < NestedResultBase
+#          def initialize(params={})
+#            # your other init stuff here
+#            super( params.merge({depth: :multi}) )    # Specified
+#          end
+#       end
+# ** - or -- enable serialization and default to multi
+#       class GenericBean < NestedResultBase
+#          def initialize(params={})
+#            super( params.merge({enable_serialization: true}) )    # Specified with Serialization Enabled
+#          end
+#       end
+#
+# (Follow VALUES that are Hashes and/or Arrays of Hashes, and enable Serializers)
+#       class PageControl < NestedResultBase
+#          def initialize(params={})
+#            super( params.merge({depth: :multi_with_arrays, enable_serialization: true}) )    # override defaults
+#          end
+#       end
+#
+##
+# 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 ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    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
+    def initialize(params={})
+      @skn_enabled_depth = params.delete(:depth) {|not_found| :multi }
+      @skn_enable_serialization = params.delete(:enable_serialization) {|not_found| false }
+      case depth_level
+        when :single
+              single_level_initializer(params)                 
+        when :multi_with_arrays
+              multi_level_incl_arrays_initializer(params)
+        else
+              multi_level_initializer(params)                  
+      end
+    end
+
+    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
+
+    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
+
+    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
+
+    # Some keys have chars not suitable for symbol keys
+    def clean_key(original)
+      formatted_key = original.to_s
+      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

@@ -0,0 +1,20 @@
+##
+# <Rails.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
+    def initialize(params={})
+      super( params.merge({enable_serialization: true, depth: :multi_with_arrays}) )
+    end
+  end
+  
+end

data/lib/skn_utils/result_bean.rb

@@ -0,0 +1,17 @@
+##
+# <Rails.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/result_bean_with_errors.rb

@@ -0,0 +1,43 @@
+##
+# <Rails.root>/lib/skn_utils/result_bean_with_errors.rb
+#
+# *** See SknUtils::NestedResultBase for details ***
+#
+##
+# (Defaults)
+# :enable_serialization = false     -- for speed
+# :depth = :multi
+##
+#  Add the ActiveModel::Errors Object to bean structure, and
+#  filters @errors out of serialization features; i.e. not included in *.attributes()
+#
+#  bean.errors.add(:name, "can not be nil") if name == nil
+###
+
+module SknUtils
+  
+  class ResultBeanWithErrors < NestedResultBase
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+
+    attr_reader :errors
+
+    def initialize(params={})
+      @errors = params.delete :errors
+      @errors = ActiveModel::Errors.new(self) unless @errors.present?
+      super(params)
+    end
+
+    def read_attribute_for_validation(attr)
+      send(attr)
+    end
+
+    def self.human_attribute_name(attr, options = {})
+      attr
+    end
+
+    def self.lookup_ancestors
+      [self]
+    end
+  end
+end

data/lib/skn_utils/version.rb

@@ -0,0 +1,3 @@
+module SknUtils
+  VERSION = "1.4.0"
+end

data/skn_utils.gemspec

@@ -0,0 +1,50 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'skn_utils/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'skn_utils'
+  spec.version       = SknUtils::VERSION
+  spec.author        = 'James Scott Jr'
+  spec.email         = 'skoona@gmail.com'
+  spec.summary       = <<EOF
+Ruby convenience utilities, the first being a ResultBean. 
+
+ResultBean is a PORO (Plain Old Ruby Object) which inherits from NestedResultBean class (inlcuded). This class 
+is intantiated  via a hash at Ruby/Rails Runtime, allows access to vars via dot or hash notation, 
+and is serializable via to_xml, to_hash, and to_json.
+EOF
+
+  spec.description   = <<EOF
+Creates an PORO Object with instance variables and associated getters and setters for each input key, during runtime.
+ 
+If a key's value is also a hash, it too can optionally become an Object.
+ 
+If a key's value is a Array of Hashes, each element of the Array can optionally become an Object.
+  
+This nesting action is controlled by the value of the options key ':depth'.  Options key :depth defaults 
+to :multi, and has options of :single, :multi, or :multi_with_arrays
+  
+The ability of the resulting Object to be Marshalled(dump/load) can be preserved by merging configuration options
+into the input params key ':enable_serialization' set to true.  It defaults to false for speed purposes
+
+Review the RSpec tests, and or review the README for more details.
+EOF
+
+  spec.homepage      = "https://github.com/skoona/skn_utils"
+  spec.license       = "MIT"
+  spec.platform      = Gem::Platform::RUBY
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = []
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activemodel', '~> 3.2'  
+  
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", '~> 3.0'
+  spec.add_development_dependency "pry"
+  spec.post_install_message = "Thanks for installing SknUtils, keep watch more utilities will be added!"
+end

data/spec/lib/skn_utils/generic_bean_spec.rb

@@ -0,0 +1,94 @@
+##
+# 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( object.fifty.any_key).to eql "any value"  
+        expect( object.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 "Does not support - respond_to - methods, because it has no accessor methods" do
+      expect(object).not_to respond_to(:one)
+      expect(object.one).to eql "one"
+    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.attributes).to be_a(Hash)
+      expect(object.attributes[:one]).to be_eql("one")
+      expect(object.attributes[: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