option 1.1.0 → 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d62b3e8f924c0460d6f8c1d33e5ca1c2b32ec3e4ed57c51357c31463fe0144a
+  data.tar.gz: 8046156564e161b894f525f7ec27c1c096a54ba8faf8ab1a8f405281e12a7c0c
+SHA512:
+  metadata.gz: e56d12174634bcbb184cb2a6a0f173cf4b36ed09be2b6889750ced4f7d234e434f50209835532eea7a0cf484ca7cea40a6cc26169f3503f70fd6a4590a002b54
+  data.tar.gz: 7449965349fbacfd90665cce8ec3af2af7896836e687177ccd33b81344af1d0924ae10912d1202f70a0085c23811f9449f570fe74a41812027ab812e77e9e2a8

data/.gitignore

@@ -16,3 +16,5 @@ test/tmp
 test/version_tmp
 tmp
 .rvmrc
+
+.mise.toml

data/Gemfile

@@ -1,4 +1,3 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in option.gemspec
 gemspec

data/README.md

@@ -76,6 +76,10 @@ end
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Added some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+3. Implement your feature. Patches not considered without accompanying tests.
+4. Commit your changes (`git commit -am 'Added some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+## License
+http://rares.mit-license.org/

data/lib/option/version.rb

@@ -1,3 +1,3 @@
 module Option
-  VERSION = "1.1.0"
+  VERSION = "1.2.1"
 end

data/lib/option.rb

@@ -10,7 +10,6 @@ class OptionClass
     end
   end
 
-
   private
 
   def assert_option(result)
@@ -96,6 +95,10 @@ class SomeClass < OptionClass
       else self
     end
   end
+
+  def error(*argv)
+    self
+  end
 end
 
 class NoneClass < OptionClass
@@ -171,6 +174,10 @@ class NoneClass < OptionClass
   def flatten
     self
   end
+
+  def error(*argv)
+    argv.empty? ? raise : raise(*argv)
+  end
 end
 
 None = NoneClass.new

data/option.gemspec

@@ -3,10 +3,10 @@ require File.expand_path('../lib/option/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Rob Ares"]
-  gem.email         = ["rob.ares@gmail.com"]
+  gem.email         = [""]
   gem.description   = %q{Ruby port of Scala's Option Monad}
   gem.summary       = %q{Option attempts to be faithful to the useful parts of the scala api. We lose the type safety but still is quite useful when dealing with optional values.}
-  gem.homepage      = "http://www.github.com/rares/option"
+  gem.homepage      = "http://www.gitlab.com/rob.ares/option"
 
   gem.files         = `git ls-files`.split($\)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
@@ -15,9 +15,5 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Option::VERSION
 
-  gem.signing_key   = "/Volumes/External/gem-private_key.pem"
-  gem.cert_chain    = ["gem-public_cert.pem"]
-
-  gem.add_development_dependency "rake",     "= 0.9.2.2"
-  gem.add_development_dependency "minitest", "= 3.4.0"
+  gem.add_development_dependency "minitest", ">= 5.20.0"
 end

data/spec/acceptance_spec.rb

@@ -11,21 +11,21 @@ describe "Option" do
     describe "left identity" do
 
       it "obeys (return x) >>= f == f x" do
-        some.flat_map(&upcase).must_equal(upcase.call(some.get))
+        _(some.flat_map(&upcase)).must_equal(upcase.call(some.get))
       end
     end
 
     describe "right identity" do
 
       it "obeys m >>= return == m" do
-        some.flat_map { |v| Some(v) }.must_equal(some)
+        _(some.flat_map { |v| Some(v) }).must_equal(some)
       end
     end
 
     describe "associative composition" do
 
       it "obeys (m >>= f) >>= g == m >>= (\\x -> f x >>= g)" do
-        some.flat_map(&upcase).flat_map(&empty).
+        _(some.flat_map(&upcase).flat_map(&empty)).
           must_equal(upcase.call(some.get).flat_map(&empty))
       end
     end

data/spec/option_spec.rb

@@ -3,211 +3,228 @@ require "spec_helper"
 describe NoneClass do
 
   it "#dup results in a TypeError" do
-    lambda { None.dup }.must_raise TypeError
+    _ { None.dup }.must_raise TypeError
   end
 
   it "#clone results in a TypeError" do
-    lambda { None.clone }.must_raise TypeError
+    _ { None.clone }.must_raise TypeError
   end
 
   it "#to_a returns an empty array" do
-    None.to_a.must_equal([])
+    _(None.to_a).must_equal([])
   end
 
   it "#get raises IndexError" do
-    lambda { None.get }.must_raise IndexError
+    _ { None.get }.must_raise IndexError
   end
 
   it "#get_or_else executes the block" do
-    None.get_or_else { "Some" }.must_equal "Some"
+    _(None.get_or_else { "Some" }).must_equal "Some"
   end
 
   it "#each does not execute the block" do
     expected = nil
     None.each { |v| expected = v }
 
-    expected.must_be_nil
+    _(expected).must_be_nil
   end
 
   it "#or_nil should return nil" do
-    None.or_nil.must_be_nil
+    _(None.or_nil).must_be_nil
   end
 
   it "#present? should be false" do
-    None.present?.must_equal(false)
+    _(None.present?).must_equal(false)
   end
 
   it "#empty? should be true" do
-    None.empty?.must_equal(true)
+    _(None.empty?).must_equal(true)
   end
 
   it "#map should return itself" do
-    None.map {}.must_be_none
+    _(None.map {}).must_be_none
   end
 
   it "#flat_map should return itself" do
-    None.flat_map {}.must_be_none
+    _(None.flat_map {}).must_be_none
   end
 
   it "#exists? should return false" do
-    None.exists? {}.must_equal(false)
+    _(None.exists? {}).must_equal(false)
   end
 
   it "#include? should return false" do
-    None.include?(value).must_equal(false)
+    _(None.include?(subject_value)).must_equal(false)
   end
 
   it "#fold should invoke the default proc" do
-    None.fold(proc { value }) { |v| v.to_f }.must_equal(value)
+    _(None.fold(proc { subject_value }) { |v| v.to_f }).must_equal(subject_value)
   end
 
   it "#filter with a true predicate returns itself" do
-    Option(value).filter { |i| i == 12 }.must_be_some(value)
+    _(Option(subject_value).filter { |i| i == 12 }).must_be_some(subject_value)
   end
 
   it "#filter with a false predicate returns None" do
-    Option(value).filter { |i| i == 1 }.must_be_none
+    _(Option(subject_value).filter { |i| i == 1 }).must_be_none
   end
 
   it "should be aliased to None" do
-    None.must_be_instance_of(NoneClass)
+    _(None).must_be_instance_of(NoneClass)
   end
 
   it "#inside should return itself without invoking the block" do
     expected = nil
-    None.inside { |v| expected = value }
-    expected.must_be_nil
+    None.inside { |v| expected = subject_value }
+    _(expected).must_be_nil
   end
 
   it "#or_else should invoke the block and return an Option" do
-    None.or_else { Some(value) }.must_be_some(value)
+    _(None.or_else { Some(subject_value) }).must_be_some(subject_value)
   end
 
   it "#or_else should raise a TypeError if an Option is not returned" do
-    lambda { None.or_else { value } }.must_raise TypeError
+    _ { None.or_else { subject_value } }.must_raise TypeError
   end
 
   it "#flatten should return itself" do
-    None.flatten.must_be_none
+    _(None.flatten).must_be_none
+  end
+
+  it "#error should raise a RuntimeError with the given message" do
+    _ { None.error("error") }.must_raise RuntimeError, "error"
+  end
+
+  it "#error should raise the error passed to it" do
+    _ { None.error(ArgumentError.new("name")) }.must_raise ArgumentError, "name"
+  end
+
+  it "should assemble an Error from the arguments passed in" do
+    _ { None.error(StandardError, "this is a problem") }.must_raise StandardError, "this is a problem"
   end
 end
 
 describe SomeClass do
 
   it "#to_a returns the value wrapped in an array" do
-    Some(value).to_a.must_equal([value])
+    _(Some(subject_value).to_a).must_equal([subject_value])
   end
 
   it "#get returns the inner value" do
-    Some(value).get.must_equal(value)
+    _(Some(subject_value).get).must_equal(subject_value)
   end
 
   it "#get_or_else does not execute the block;" do
     expected = nil
-    Some(value).get_or_else { expected = true }
+    Some(subject_value).get_or_else { expected = true }
 
-    expected.must_be_nil
+    _(expected).must_be_nil
   end
 
   it "#get_or_else returns the value" do
-    Some(value).get_or_else { }.must_equal(value)
+    _(Some(subject_value).get_or_else { }).must_equal(subject_value)
   end
 
   it "#each executes the block passing the inner value" do
     expected = nil
-    Some(value).each { |v| expected = v }
+    Some(subject_value).each { |v| expected = v }
 
-    expected.must_equal(value)
+    _(expected).must_equal(subject_value)
   end
 
   it "#or_nil should return the inner value" do
-    Some(value).or_nil.must_equal(value)
+    _(Some(subject_value).or_nil).must_equal(subject_value)
   end
 
   it "#present? should be true" do
-    Some(value).present?.must_equal(true)
+    _(Some(subject_value).present?).must_equal(true)
   end
 
   it "#empty? should be false" do
-    Some(value).empty?.must_equal(false)
+    _(Some(subject_value).empty?).must_equal(false)
   end
 
   it "#map should return the result of the proc over the value in a Some" do
-    Some(value).map { |v| v * 2 }.must_be_some(24)
+    _(Some(subject_value).map { |v| v * 2 }).must_be_some(24)
   end
 
   it "#flat_map should raise TypeError if the returned value is not an Option" do
-    lambda { Some(value).flat_map { |v| v * 2 } }.must_raise TypeError
+    _ { Some(subject_value).flat_map { |v| v * 2 } }.must_raise TypeError
   end
 
   it "#flat_map should return an Option value from the block" do
-    Some(value).flat_map { |v| Option(v * 2) }.must_be_some(24)
+    _(Some(subject_value).flat_map { |v| Option(v * 2) }).must_be_some(24)
   end
 
   it "#flat_map can return None from the block" do
-    Some(value).flat_map { |_| None }.must_be_none
+    _(Some(subject_value).flat_map { |_| None }).must_be_none
   end
 
   it "#exists? should return true when the block evaluates true" do
-    Some(value).exists? { |v| v % 2 == 0 }.must_equal(true)
+    _(Some(subject_value).exists? { |v| v % 2 == 0 }).must_equal(true)
   end
 
   it "#exists? should return false when the block evaluates false" do
-    Some(value).exists? { |v| v % 2 != 0 }.must_equal(false)
+    _(Some(subject_value).exists? { |v| v % 2 != 0 }).must_equal(false)
   end
 
   it "#include? should return true when the passed value and the boxed value are the same" do
-    Some(value).include?(value).must_equal(true)
+    _(Some(subject_value).include?(subject_value)).must_equal(true)
   end
 
   it "#include? should return false when the passed value and the boxed value are not the same" do
-    Some(value).include?(value + 1).must_equal(false)
+    _(Some(subject_value).include?(subject_value + 1)).must_equal(false)
   end
 
   it "#fold should map the proc over the value and return it" do
-    Some(value).fold(proc { value * 2 }) { |v| v * 3 }.must_equal(36)
+    _(Some(subject_value).fold(proc { value * 2 }) { |v| v * 3 }).must_equal(36)
   end
 
   it "#filter should return itself" do
-    None.filter { |i| i == 0 }.must_be_none
+    _(None.filter { |i| i == 0 }).must_be_none
   end
 
   it "#inside should invoke the proc and return itself" do
     expected = nil
-    Some(value).inside { |v| expected = v }.must_be_some(value)
-    expected.must_equal(value)
+    _(Some(subject_value).inside { |v| expected = v }).must_be_some(subject_value)
+    _(expected).must_equal(subject_value)
   end
 
   it "#or_else should return itself" do
-    Some(value).or_else { None }.must_be_some(value)
+    _(Some(subject_value).or_else { None }).must_be_some(subject_value)
   end
 
   it "should wrap the creation of a Some" do
-    Some(value).must_be_instance_of(SomeClass)
+    _(Some(subject_value)).must_be_instance_of(SomeClass)
   end
 
   it "should be aliased to Some" do
-    Some.new(value).must_be_some(value)
+    _(Some.new(subject_value)).must_be_some(subject_value)
   end
 
   it "#flatten" do
-    inner_value = Some(Some(Some(value))).flatten
-    inner_value.must_be_some(value)
-    inner_value.or_nil.must_equal(value)
+    inner_value = Some(Some(Some(subject_value))).flatten
+    _(inner_value).must_be_some(subject_value)
+    _(inner_value.or_nil).must_equal(subject_value)
+  end
+
+  it "#error should return the Some" do
+    value = !!(Some(subject_value).error("error") rescue false)
+    _(value).must_equal true
   end
 end
 
 describe OptionClass do
 
   it "must return a some if the passed value is not nil" do
-    Option(value).must_be_some(value)
+    _(Option(subject_value)).must_be_some(subject_value)
   end
 
   it "must return a None if the passed value is nil" do
-    Option(nil).must_be_none
+    _(Option(nil)).must_be_none
   end
 
   it "should do equality checks against the boxed value" do
-    Option(value).must_equal(value)
+    _(Option(subject_value)).must_equal(subject_value)
   end
 end

data/spec/spec_helper.rb

@@ -2,9 +2,9 @@ require "minitest/autorun"
 require "minitest/pride"
 require "minitest/spec"
 
-require "option"
+require_relative "../lib/option"
 
-module MiniTest::Assertions
+module Minitest::Assertions
 
   def assert_some(value, option, msg = nil)
     assert (option.is_a?(Some) && option.or_nil == value), "Expected Some(#{value})"
@@ -18,6 +18,6 @@ end
 OptionClass.infect_an_assertion :assert_some, :must_be_some
 OptionClass.infect_an_assertion :assert_none, :must_be_none
 
-def value
+def subject_value
   12
 end

metadata

@@ -1,124 +1,67 @@
 --- !ruby/object:Gem::Specification
 name: option
 version: !ruby/object:Gem::Version
-  version: 1.1.0
-  prerelease: 
+  version: 1.2.1
 platform: ruby
 authors:
 - Rob Ares
 autorequire: 
 bindir: bin
-cert_chain:
-- !binary |-
-  LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURNakNDQWhxZ0F3SUJB
-  Z0lCQURBTkJna3Foa2lHOXcwQkFRVUZBREEvTVJFd0R3WURWUVFEREFoeWIy
-  SXUKWVhKbGN6RVZNQk1HQ2dtU0pvbVQ4aXhrQVJrV0JXZHRZV2xzTVJNd0VR
-  WUtDWkltaVpQeUxHUUJHUllEWTI5dApNQjRYRFRFek1ESXdNVEF6TlRjeE1s
-  b1hEVEUwTURJd01UQXpOVGN4TWxvd1B6RVJNQThHQTFVRUF3d0ljbTlpCkxt
-  RnlaWE14RlRBVEJnb0praWFKay9Jc1pBRVpGZ1ZuYldGcGJERVRNQkVHQ2dt
-  U0pvbVQ4aXhrQVJrV0EyTnYKYlRDQ0FTSXdEUVlKS29aSWh2Y05BUUVCQlFB
-  RGdnRVBBRENDQVFvQ2dnRUJBT2xneU5SZGtyRXZXdTVDMzBxUgovZk16UXhW
-  LyszSTd2enF6SlFsbUt6ODU5WGgweCtEOGN3Q1hvME84Vjd4em00NCtiWVlm
-  SE81OWRLZFRBcVlNCkxJTmczazB3SjFmVjAzUHdOSEtkQmI5bW5vRERBamxZ
-  WlVZSW1abkxRQzhpeVJRVitXNGltRlVwN0pyZ0psVFcKeGZ0MW93UEVBdFg5
-  REtVSCtuZ213clRPU3YxZ2Y5dU51NUZpN3U3M1BBQU5LUldSb3VtT09DM2pl
-  STJFRFR0UgpkcGQzY0hXYjF6SEQxY1czUVByYlBrNUc1bm9vNHJJMUc1K24v
-  dnducDdRSDRUUGppWVNzVFg3NHorUnFyK1FUClJ6eTF2S3l2ZlEyYU5jQ1Mw
-  Z1hlWTh4a0tNWW1IRHViekJuNFk4bXZDcmZrMFRFcFNuSmZiZ2xjdlF4MDVN
-  dGcKRmJzQ0F3RUFBYU01TURjd0NRWURWUjBUQkFJd0FEQWRCZ05WSFE0RUZn
-  UVVvQnhON1I5cXVFL3A3NVBPSkY2dgpUYlVJSTJBd0N3WURWUjBQQkFRREFn
-  U3dNQTBHQ1NxR1NJYjNEUUVCQlFVQUE0SUJBUUJGdXppWHpDM1JSNkg1Ckox
-  RjQ2K2pKdytNOFpsYnpMREEzNnYrdm9memN5Q1FDQkV0U2YxSVVaaGh6U1pZ
-  cC9VR2h3TTRnOEs3NXRMT3IKemFIcHRObUZ3eXJZZ09SMnJnbE5TVHBZdFJC
-  TGt4S1E5Z2k2NkpkUk1kQWs1U0JDUGJ6akQ1M1RybWVjbXFGTwp5T1FOQWVr
-  ck9SNFZMcDQwZFFPMGcranRtQXV4TGN5OGdNazAzb1dHZjRvVE5jazRKVUM4
-  Q3FZR1VhenZ6a2hYCmNHbytaT1ZzbXhuVUNUaE90UE9idHRNSXdVZjY5Y1pa
-  RXJwU3JwSW9FRXoyUnBGQTJvZnJ6T0lNbW5FZUxUUWoKVUp6THlpQXI4SmVG
-  TjI4bXJ1dXFjNHFrRFZLUHBUdExQRk9GZXMzclRFSEIzaGZiM3AzczV5MW9R
-  dTYzb0puagpSK3QwWXZjVwotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg==
-date: 2013-02-16 00:00:00.000000000 Z
+cert_chain: []
+date: 2024-06-17 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.9.2.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.9.2.2
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.4.0
+        version: 5.20.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.4.0
+        version: 5.20.0
 description: Ruby port of Scala's Option Monad
 email:
-- rob.ares@gmail.com
+- ''
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
 - Gemfile
-- LICENSE
 - README.md
 - Rakefile
-- gem-public_cert.pem
 - lib/option.rb
 - lib/option/version.rb
 - option.gemspec
 - spec/acceptance_spec.rb
 - spec/option_spec.rb
 - spec/spec_helper.rb
-homepage: http://www.github.com/rares/option
+homepage: http://www.gitlab.com/rob.ares/option
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4306780363685144709
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -4306780363685144709
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 3.5.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Option attempts to be faithful to the useful parts of the scala api. We lose
   the type safety but still is quite useful when dealing with optional values.
 test_files:

data/.travis.yml

@@ -1,10 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 1.9.2
-  - jruby-18mode
-  - jruby-19mode
-  - rbx-18mode
-  - rbx-19mode
-  - 1.8.7
-  - ree

data/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2012 Rob Ares
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/gem-public_cert.pem

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDMjCCAhqgAwIBAgIBADANBgkqhkiG9w0BAQUFADA/MREwDwYDVQQDDAhyb2Iu
-YXJlczEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQBGRYDY29t
-MB4XDTEzMDIwMTAzNTcxMloXDTE0MDIwMTAzNTcxMlowPzERMA8GA1UEAwwIcm9i
-LmFyZXMxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkWA2Nv
-bTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOlgyNRdkrEvWu5C30qR
-/fMzQxV/+3I7vzqzJQlmKz859Xh0x+D8cwCXo0O8V7xzm44+bYYfHO59dKdTAqYM
-LINg3k0wJ1fV03PwNHKdBb9mnoDDAjlYZUYImZnLQC8iyRQV+W4imFUp7JrgJlTW
-xft1owPEAtX9DKUH+ngmwrTOSv1gf9uNu5Fi7u73PAANKRWRoumOOC3jeI2EDTtR
-dpd3cHWb1zHD1cW3QPrbPk5G5noo4rI1G5+n/vwnp7QH4TPjiYSsTX74z+Rqr+QT
-Rzy1vKyvfQ2aNcCS0gXeY8xkKMYmHDubzBn4Y8mvCrfk0TEpSnJfbglcvQx05Mtg
-FbsCAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUoBxN7R9quE/p75POJF6v
-TbUII2AwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQBFuziXzC3RR6H5
-J1F46+jJw+M8ZlbzLDA36v+vofzcyCQCBEtSf1IUZhhzSZYp/UGhwM4g8K75tLOr
-zaHptNmFwyrYgOR2rglNSTpYtRBLkxKQ9gi66JdRMdAk5SBCPbzjD53TrmecmqFO
-yOQNAekrOR4VLp40dQO0g+jtmAuxLcy8gMk03oWGf4oTNck4JUC8CqYGUazvzkhX
-cGo+ZOVsmxnUCThOtPObttMIwUf69cZZErpSrpIoEEz2RpFA2ofrzOIMmnEeLTQj
-UJzLyiAr8JeFN28mruuqc4qkDVKPpTtLPFOFes3rTEHB3hfb3p3s5y1oQu63oJnj
-R+t0YvcW
------END CERTIFICATE-----