msmg_public 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 81762cbf5c6a373790c9b3377ce5b1371e769f45
+  data.tar.gz: 5e05a3462ede5afc08a8e6ecd42162a2caf32f66
+SHA512:
+  metadata.gz: 9f9f0219e41a521560b06a41de8a70eb43af9a7ccf9ccff6a0d938844010f1ad7471cb6327f29d479b3a0a4282e5fbfee18dd88e43b470af8882c1a6565f6f87
+  data.tar.gz: 0fd81f23a94643717688aec13815e3befdc8fa64aca41b2510cc5f0b992b4a66aa575b17b0fd29dc0dc543cf6644b05f2e13c1591c1494ba867fa6de833ecfec

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.gem

data/Rakefile

@@ -0,0 +1,18 @@
+# Tests
+
+require 'rake/testtask'
+require 'rubocop/rake_task'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs |= %w[
+    test
+    lib
+  ]
+  t.test_files = FileList['test/unit/**/test_*.rb']
+end
+
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.fail_on_error = true
+end
+
+task default: %i[test rubocop]

data/lib/comparable_by_attr.rb

@@ -0,0 +1,43 @@
+# Allow simple definitions for object comparisons
+module ComparableByAttr
+  include Comparable
+
+  # rubocop:disable Metrics/MethodLength class_eval wrapper
+  def self.included(klass)
+    klass.class_eval do
+      @__attr_precedence = nil
+
+      # attr_compare allows selection of specific instance variables and order
+      # to use within the comparison of objects created off the class
+      #
+      # Example:
+      #   class IgnoreC
+      #     include ComparableByAttr
+      #     attr_compare :a, :b
+      #
+      #     def initialize(a, b, c)
+      #       @a = a
+      #       @b = b
+      #       @c = c
+      #     end
+      #   end
+      #
+      # Arguments:
+      #   *prec = (Optional Precedence Map)
+      def self.attr_compare(*prec)
+        attr_prec = prec.map do |attr|
+          "@#{attr}".to_sym
+        end
+        @__attr_precedence = attr_prec
+      end
+
+      def <=>(other)
+        prec = self.class.instance_variable_get(:@__attr_precedence)
+        comp_order = prec || instance_variables.sort
+        this = comp_order.map { |field| instance_variable_get(field) }
+        that = comp_order.map { |field| other.instance_variable_get(field) }
+        this <=> that
+      end
+    end
+  end
+end

data/lib/dig.rb

@@ -0,0 +1,21 @@
+# Hash/Array #dig backport from Ruby 2.3.0
+# Dig method is common to Array and Hash
+[[], {}].each do |obj|
+  next if obj.respond_to?(:dig)
+  obj.class.class_eval do
+    # dig for values in Array/Hash
+    #
+    # Example:
+    #   g = { foo: [10, 11, 12] }
+    #   g.dig(:foo, 1)              #=> 11
+    #
+    # Arguments:
+    #   *keys: (Accessor List)
+    def dig(*keys)
+      elem = self[keys.shift]
+      return elem if keys.empty? || elem.nil?
+      return elem.dig(*keys) if elem.respond_to?(:dig)
+      raise TypeError, "#{elem.class} does not have a #dig method"
+    end
+  end
+end

data/lib/to_hash.rb

@@ -0,0 +1,46 @@
+# Generic ToHash mixin
+module ToHash
+  # to_hash generic implementation, generates a hash from object Mixing in this
+  # module from instance variables of the object
+  #
+  # Example:
+  #   class Foo
+  #     include ToHash
+  #     def initialize
+  #       @a = 1
+  #       @b = 2
+  #       @c = 3
+  #     end
+  #   end
+  #
+  #   Foo.new.to_hash             #=> { :a => 1, :b => 2, :c => 3}
+  #   Foo.new.to_hash(:c, 'a')    #=> { 'a' => 1, :c => 3 }
+  #
+  # Arguments:
+  #   *keys: (Optional key list)
+  def to_hash(*keys)
+    keys = keys.any? ? __named_map(keys) : __instance_map
+    keys = keys.map do |key, val|
+      [key, instance_variable_get(val)]
+    end
+    Hash[keys]
+  end
+
+  private
+
+  def __named_map(keys)
+    keys = keys.map do |key|
+      [key, "@#{key}".to_sym]
+    end
+    Hash[keys]
+  end
+
+  def __instance_map
+    keys = instance_variables.map do |var|
+      # Eliminate @ in naming key
+      key = var.to_s.delete('@').to_sym
+      [key, var]
+    end
+    Hash[keys]
+  end
+end

data/msmg_public.gemspec

@@ -0,0 +1,21 @@
+class << $LOAD_PATH
+  def merge!(other)
+    replace(self | other)
+  end
+end
+
+$LOAD_PATH.merge! [File.expand_path('../lib', __FILE__)]
+
+Gem::Specification.new do |spec|
+  raise 'RubyGems 2.0 or newer is required.' unless spec.respond_to?(:metadata)
+  spec.name = 'msmg_public'
+  spec.version = '0.1.0'
+  spec.authors = ['Andrew Smith']
+  spec.email = ['andrew.smith at moneysupermarket.com']
+
+  spec.summary = 'Various Ruby Sources'
+  spec.description = 'MSM pubicly available Ruby'
+  # spec.homepage = ''
+  spec.license = 'Apache-2.0'
+  spec.files = `git ls-files -z`.split("\x0")
+end

data/readme.md

@@ -0,0 +1,78 @@
+# Generic mixins
+
+Released by MSM DevOps group under Apache 2.0 license
+
+## ToHash
+
+Add a to_hash method to any class that will produce a hash from all instance variables or that can be called with a parameter set of instance variables in string or symbol form.
+By default the keys produced are symbols but when called with parameters it will use the parameter form passed for the keys (which can be mixed symbols and strings).
+In order to make an alternate default of to_hash with a specific set of attributes one may consider implementing to_hash can calling a super method to pass the params i.e.
+
+  class Foo
+    include ToHash
+  
+    def initialize
+      @foo = 1
+      @bar = 2
+      @boo = 3
+    end
+
+    def to_hash
+      super(:foo, 'bar')
+    end
+  end
+
+  Foo.new.to_hash == {
+    :foo => 1,
+    'bar' => 2
+  }
+
+## ComparableByAttr
+
+
+Adds a default behaviour for <=> based upon instance variables within the class and includes Comparable to produce other comparison operators.
+Instance variables by default are enumerated, sorted and stored in an array and the arrays are compared with their own l to r behaviour.
+One may override the instance variables used in the comparison and the order by specifying an attr_compare override in the class definition.
+
+  # instances will be comparable by [@a, @b, @c]
+  class Bar
+    include ComparableByAttr
+  
+    def initialize(a, b, c)
+      @a = a
+      @b = b
+      @c = c
+    end
+  end
+  
+  # instances will be comparable by [@c, @a]
+  class Bar
+    include ComparableByAttr
+    attr_compare :c, :a
+  
+    def initialize(a, b, c)
+      @a = a
+      @b = b
+      @c = c
+    end
+  end
+
+## dig
+
+A backport of the Ruby 2.3.0 dig instance method for Hash and Array written in Ruby.
+
+Since this code aims not to introduce unnecessary modules into the namespace and is targetted at extending Hash and Array directly it is not implemented as a Mixin but rather extends those classes directly using class_eval.
+
+The Ruby module aims for compatibility based upon the specification stated in the C library comments (which are recorded within the unit test for convenience).
+
+Documentation from Ruby 2.3.0 states..
+
+Extracts the nested value specified by the sequence of idx objects by calling dig at each step, returning nil if any intermediate step is nil.
+
+    h = { foo: {bar: {baz: 1}}}
+
+    h.dig(:foo, :bar, :baz)           #=> 1
+    h.dig(:foo, :zot, :xyz)           #=> nil
+
+    g = { foo: [10, 11, 12] }
+    g.dig(:foo, 1)                    #=> 11

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'simplecov'
+SimpleCov.command_name 'test:unit'
+SimpleCov.start do
+  add_group 'Libs', 'lib/'
+  track_files 'lib/*.rb'
+  add_filter '/test/'
+end

data/test/unit/test_comparable_by_attr.rb

@@ -0,0 +1,63 @@
+# Test classes
+
+require 'comparable_by_attr'
+
+# Test class
+class APrecB
+  include ComparableByAttr
+
+  def initialize(a, b)
+    @a = a
+    @b = b
+  end
+end
+
+# Test class
+class BPrecA
+  include ComparableByAttr
+  attr_compare :b, :a
+
+  def initialize(a, b)
+    @a = a
+    @b = b
+  end
+end
+
+# Test class
+class IgnoreC
+  include ComparableByAttr
+  attr_compare :a, :b
+
+  def initialize(a, b, c)
+    @a = a
+    @b = b
+    @c = c
+  end
+end
+
+# Unit Test
+require 'minitest/autorun'
+
+# rubocop:disable Lint/UselessComparison Unit Test
+# Unit test
+class TestComparableByAttr < Minitest::Test
+  def test_a_gt_b_aprecb
+    assert(APrecB.new(2, 1) > APrecB.new(1, 2))
+  end
+
+  def test_a_lt_b_aprecb
+    assert(APrecB.new(1, 2) < APrecB.new(2, 1))
+  end
+
+  def test_a_n_gt_b_aprecb
+    refute(APrecB.new(1, 2) > APrecB.new(1, 2))
+  end
+
+  def test_a_gt_b_bpreca
+    assert(BPrecA.new(1, 2) > BPrecA.new(2, 1))
+  end
+
+  def test_a_eq_b_ignorec
+    assert(IgnoreC.new(1, 1, 2) == IgnoreC.new(1, 1, 2))
+  end
+end

data/test/unit/test_dig.rb

@@ -0,0 +1,54 @@
+# Unit test for #dig
+
+# Contract from hash.c in Ruby 2.3.0 and later..
+# rubocop:disable Metrics/LineLength original documentation
+# /*
+# * call-seq:
+# *   hsh.dig(key, ...)                 -> object
+# *
+# * Extracts the nested value specified by the sequence of <i>key</i>
+# * objects by calling +dig+ at each step, returning +nil+ if any
+# * intermediate step is +nil+.
+# *
+# *   h = { foo: {bar: {baz: 1}}}
+# *
+# *   h.dig(:foo, :bar, :baz)     #=> 1
+# *   h.dig(:foo, :zot, :xyz)     #=> nil
+# *
+# *   g = { foo: [10, 11, 12] }
+# *   g.dig(:foo, 1)              #=> 11
+# *   g.dig(:foo, 1, 0)           #=> TypeError: Integer does not have #dig method
+# *   g.dig(:foo, :bar)           #=> TypeError: no implicit conversion of Symbol into Integer
+# */
+# rubocop:enable all
+
+require 'minitest/autorun'
+require 'dig'
+
+# Unit Test
+class TestDig < Minitest::Test
+  def setup
+    @h = { foo: { bar: { baz: 1 } } }
+    @g = { foo: [10, 11, 12] }
+  end
+
+  def test_hash_hash_hash
+    assert_equal(1, @h.dig(:foo, :bar, :baz))
+  end
+
+  def test_hash_miss_miss
+    assert_nil(@h.dig(:foo, :zot, :xyz))
+  end
+
+  def test_hash_array_fixnum_typerror
+    assert_raises(TypeError) do
+      @g.dig(:foo, 1, 0)
+    end
+  end
+
+  def test_hash_array_symbol_typerror
+    assert_raises(TypeError) do
+      @g.dig(:foo, :bar)
+    end
+  end
+end

data/test/unit/test_to_hash.rb

@@ -0,0 +1,46 @@
+# Test Classes
+require 'to_hash'
+
+# Test Class
+class TestClass
+  include ToHash
+
+  def initialize
+    @foo = 1
+    @bar = 2
+    @moo = 'three'
+  end
+end
+
+require 'minitest/autorun'
+
+# Unit test
+class TestToHash < Minitest::Test
+  def test_no_param
+    expected = {
+      foo: 1,
+      bar: 2,
+      moo: 'three'
+    }
+    assert_equal expected, TestClass.new.to_hash
+  end
+
+  def test_limited_text
+    expected = {
+      'foo' => 1,
+      'moo' => 'three'
+    }
+    assert_equal expected, TestClass.new.to_hash('foo', 'moo')
+  end
+
+  # Of course with hash ordering is not important and neith should be
+  # the order provided to the parameterisation
+  def test_mixed_keys
+    expected = {
+      'moo' => 'three',
+      foo: 1,
+      bar: 2
+    }
+    assert_equal expected, TestClass.new.to_hash(:foo, 'moo', :bar)
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: msmg_public
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-15 00:00:00.000000000 Z
+dependencies: []
+description: MSM pubicly available Ruby
+email:
+- andrew.smith at moneysupermarket.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Rakefile
+- lib/comparable_by_attr.rb
+- lib/dig.rb
+- lib/to_hash.rb
+- msmg_public.gemspec
+- readme.md
+- test/test_helper.rb
+- test/unit/test_comparable_by_attr.rb
+- test/unit/test_dig.rb
+- test/unit/test_to_hash.rb
+homepage: 
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.5
+signing_key: 
+specification_version: 4
+summary: Various Ruby Sources
+test_files: []