RubyGems - return_bang - Versions diffs - 1.0 → 1.1 - Mend

return_bang 1.0 → 1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

data.tar.gz.sig CHANGED

@@ -1,2 +1,3 @@
-9L�C��M�}
-߁Z�z��ܦ/⊢V��U�^�׭����בlRg�-�$��6���)�G(�s�i�
+7�d+��*"��������N֝��W4�����Y�H�<!���־�b��5
+k���Sκ������O�4���@M>�~r��e�1S��F[y_�Ɓ���e8ӊ�z����ޒ򔦛��:���{Ϥ�/R�����I��O`�������S�\
+�d���6E<Tr&�d����"\�m�P�C4����|���V��^����e����N��Ty�w���$�2<$�w�|��dJ�)]A8�)�����{?��

data/History.txt CHANGED

@@ -1,5 +1,12 @@
+=== 1.1 / 2012-04-01
+* Minor enhancements
+  * Added raise! to raise exceptions
+  * Added rescue! to rescue exceptions raised
+  * Added ensure! to always execute a block of code to perform cleanup
 === 1.0 / 2011-12-20
-* Major enhancements
+* Major enhancement
   * Birthday!

data/README.rdoc CHANGED

@@ -6,16 +6,26 @@ bugs :: https://github.com/drbrain/return_bang/issues
 == Description
-return_bang implements non-local exits from methods.  Use return_bang to exit
-back to a processing loop from deeply nested code, or just to confound your
-enemies *and* your friends!  What could possibly go wrong?
+return_bang implements non-local exits for methods.  As a bonus, you also get
+exception handling that ignores standard Ruby's inflexible begin; rescue;
+ensure; end syntax.
+Use return_bang to exit back to a processing loop from deeply nested code, or
+just to confound your enemies *and* your friends!  What could possibly go
+wrong?
 == Features
 * Implements non-local exits for methods
 * Nestable
 * Named and stack-based exit points, go exactly where you need to be
-* Ignores pesky ensure blocks for when you really, really need to return
+* Full exception handling support through raise!, rescue! and ensure!
+* Ignores pesky ensure, rescue and require blocks for when you really, really
+  need to return
+== Problems
+* Not enough use of continuations
 == Synopsis

data/Rakefile CHANGED

@@ -5,14 +5,14 @@ require 'hoe'
 Hoe.plugin :minitest
 Hoe.plugin :git
+Hoe.plugin :travis
 Hoe.spec 'return_bang' do
   developer 'Eric Hodel', '[email protected]'
   rdoc_locations << 'docs.seattlerb.org:/data/www/docs.seattlerb.org/return_bang/'
-  self.readme_file = 'README.rdoc'
-  self.extra_rdoc_files << 'README.rdoc'
+  spec_extras['required_ruby_version'] = '>= 1.9.2'
 end
 # vim: syntax=ruby

data/lib/return_bang.rb CHANGED

@@ -1,59 +1,78 @@
-begin
-  require 'continuation'
-rescue LoadError
-  # in 1.8 it's built-in
-end
+require 'continuation'
 ##
 # ReturnBang is allows you to perform non-local exits from your methods.  One
 # potential use of this is in a web framework so that a framework-provided
 # utility methods can jump directly back to the request loop.
 #
-# return_here is used to designate where execution should be resumed.  Return
-# points may be arbitrarily nested.  #return! resumes at the previous resume
-# point, #return_to returns to a named return point.
+# Since providing just non-local exits is insufficient for modern Ruby
+# development, full exception handling support is also provided via #raise!,
+# #rescue! and #ensure!.  This exception handling support completely bypasses
+# Ruby's strict <tt>begin; rescue; ensure; return</tt> handling.
 #
 # require 'return_bang' gives you a module you may include only in your
 # application or library code.  require 'return_bang/everywhere' includes
 # ReturnBang in Object, so it is only recommended for application code use.
 #
-# Example:
+# == Methods
+#
+# return_here is used to designate where execution should be resumed.  Return
+# points may be arbitrarily nested.  #return! resumes at the previous resume
+# point, #return_to returns to a named return point.
+#
+# #raise! is used to indicate an exceptional situation has occurred and you
+# would like to skip the rest of the execution.
+#
+# #rescue! is used to rescue exceptions if you have a way to handle them.
+#
+# #ensure! is used when you need to perform cleanup where an exceptional
+# situation may occur.
+#
+# == Example
 #
 #   include ReturnBang
 #
 #   def framework_loop
 #     loop do
-#       # setup code
-#
 #       return_here do
-#         user_code
-#       end
+#         # setup this request
 #
-#       # resume execution here
-#     end
-#   end
+#         ensure! do
+#           # clean up this request
+#         end
+#
+#         rescue! FrameworkError do
+#           # display framework error
+#         end
 #
-#   def render_error_and_return message
-#     # generate error
+#         rescue! do
+#           # display application error
+#         end
 #
-#     return!
+#         user_code
+#       end
+#     end
 #   end
 #
 #   def user_code
 #     user_utility_method
-#     # these lines never reached
-#     # ...
+#
+#     other_condition = some_more code
+#
+#     return! if other_condition
+#
+#     # rest of user method
 #   end
 #
 #   def user_utility_method
-#     render_error_and_return "blah" if some_condition
-#     # these lines never reached
-#     # ...
+#     raise! "there was an error" if some_condition
+#
+#     # rest of utility method
 #   end
 module ReturnBang
-  VERSION = '1.0'
+  VERSION = '1.1'
   ##
   # Raised when attempting to return! when you haven't registered a location
@@ -63,31 +82,185 @@ module ReturnBang
   class NonLocalJumpError < StandardError
   end
+  def _make_exception args # :nodoc:
+    case args.length
+    when 0 then
+      if exception = Thread.current[:current_exception] then
+        exception
+      else
+        RuntimeError.new
+      end
+    when 1 then # exception or string
+      arg = args.first
+      case arg = args.first
+      when Class then
+        unless Exception >= arg then
+          raise TypeError,
+                "exception class/object expected (not #{arg.inspect})"
+        end
+        arg.new
+      else
+        RuntimeError.new arg
+      end
+    when 2 then # exception, string
+      klass, message = args
+      klass.new message
+    else
+      raise ArgumentError, 'too many arguments to raise!'
+    end
+  end
+  ##
+  # Executes the ensure blocks in +frames+ in the correct order.
+  def _return_bang_cleanup frames # :nodoc:
+    chunked = frames.chunk do |type,|
+      type
+    end
+    chunked.reverse_each do |type, chunk_frames|
+      case type
+      when :ensure then
+        chunk_frames.each do |_, block|
+          block.call
+        end
+      when :rescue then
+        if exception = Thread.current[:current_exception] then
+          frame = chunk_frames.find do |_, block, objects|
+            objects.any? do |object|
+              object === exception
+            end
+          end
+          next unless frame
+          # rebuild stack since we've got a handler for the exception.
+          unexecuted = frames[0, frames.index(frame) - 1]
+          _return_bang_stack.concat unexecuted if unexecuted
+          _, handler, = frame
+          handler.call exception
+          return # the exception was handled, don't continue up the stack
+        end
+      when :return then
+        # ignore
+      else
+        raise "[bug] unknown return_bang frame type #{type}"
+      end
+    end
+  end
   def _return_bang_names # :nodoc:
     Thread.current[:return_bang_names] ||= {}
   end
-  if {}.respond_to? :key then # 1.9
-    def _return_bang_pop # :nodoc:
-      return_point = _return_bang_stack.pop
+  def _return_bang_pop # :nodoc:
+    frame = _return_bang_stack.pop
+    _return_bang_names.delete _return_bang_names.key _return_bang_stack.length
+    frame
+  end
+  def _return_bang_stack # :nodoc:
+    Thread.current[:return_bang_stack] ||= []
+  end
+  ##
+  # Unwinds the stack to +continuation+ including trimming the stack above the
+  # continuation, removing named return_heres that can't be reached and
+  # executing any ensures in the trimmed stack.
-      _return_bang_names.delete _return_bang_names.key _return_bang_stack.length
+  def _return_bang_unwind_to continuation # :nodoc:
+    found = false
-      return_point
+    frames = _return_bang_stack.select do |_, block|
+      found || found = block == continuation
     end
-  else # 1.8
-    def _return_bang_pop # :nodoc:
-      return_point = _return_bang_stack.pop
-      value = _return_bang_stack.length
-      _return_bang_names.delete _return_bang_names.index value
+    start = _return_bang_stack.length - frames.length
+    _return_bang_stack.slice! start, frames.length
-      return_point
+    frames.each_index do |index|
+      offset = start + index
+      _return_bang_names.delete _return_bang_names.key offset
     end
+    _return_bang_cleanup frames
   end
-  def _return_bang_stack # :nodoc:
-    Thread.current[:return_bang_stack] ||= []
+  ##
+  # Adds an ensure block that will be run when exiting this return_here block.
+  #
+  # ensure! blocks run in the order defined and can be added at any time.  If
+  # an exception is raised before an ensure! block is encountered, that block
+  # will not be executed.
+  #
+  # Example:
+  #
+  #   return_here do
+  #     ensure! do
+  #       # this ensure! will be executed
+  #     end
+  #
+  #     raise! "uh-oh!"
+  #
+  #     ensure! do
+  #       # this ensure! will not be executed
+  #     end
+  #   end
+  def ensure! &block
+    _return_bang_stack.push [:ensure, block]
+  end
+  ##
+  # Raises an exception like Kernel#raise.
+  #
+  # ensure! blocks and rescue! exception handlers will be run as the exception
+  # is propagated up the stack.
+  def raise! *args
+    Thread.current[:current_exception] = _make_exception args
+    type, = _return_bang_stack.first
+    _, final = _return_bang_stack.shift if type == :return
+    frames = _return_bang_stack.dup
+    _return_bang_stack.clear
+    _return_bang_cleanup frames
+    final.call if final
+  end
+  ##
+  # Rescues +exceptions+ raised by raise! and yields the exception caught to
+  # the block given.
+  #
+  # If no exceptions are given, StandardError is rescued (like the rescue
+  # keyword).
+  #
+  # Example:
+  #
+  #   return_here do
+  #     rescue! do |e|
+  #       puts "handled exception #{e.class}: #{e}"
+  #     end
+  #
+  #     raise! "raising an exception"
+  #   end
+  def rescue! *exceptions, &block
+    exceptions = [StandardError] if exceptions.empty?
+    _return_bang_stack.push [:rescue, block, exceptions]
   end
   ##
@@ -99,7 +272,13 @@ module ReturnBang
     raise NonLocalJumpError, 'nowhere to return to' if
       _return_bang_stack.empty?
-    _return_bang_pop.call value
+    _, continuation, = _return_bang_stack.reverse.find do |type,|
+      type == :return
+    end
+    _return_bang_unwind_to continuation
+    continuation.call value
   end
   ##
@@ -112,15 +291,21 @@ module ReturnBang
     value = callcc do |cc|
       _return_bang_names[name] = _return_bang_stack.length if name
-      _return_bang_stack.push cc
+      _return_bang_stack.push [:return, cc]
       begin
         yield
       ensure
-        _return_bang_pop
+        _return_bang_unwind_to cc
       end
     end
+    if exception = Thread.current[:current_exception] then
+      Thread.current[:current_exception] = nil
+      raise exception
+    end
     # here is where the magic happens
     unwind_to = Thread.current[:unwind_to]

data/test/test_return_bang.rb CHANGED

@@ -13,6 +13,324 @@ class TestReturnBang < MiniTest::Unit::TestCase
   def teardown
     assert_empty _return_bang_stack
     assert_empty _return_bang_names
+    assert_nil Thread.current[:current_exception]
+  end
+  def test__make_exception
+    e = _make_exception []
+    assert_instance_of RuntimeError, e
+  end
+  def test__make_exception_class
+    e = _make_exception [StandardError]
+    assert_instance_of StandardError, e
+  end
+  def test__make_exception_class_message
+    e = _make_exception [StandardError, 'hello']
+    assert_instance_of StandardError, e
+    assert_equal 'hello', e.message
+  end
+  def test__make_exception_current_exception
+    expected = ArgumentError.new
+    Thread.current[:current_exception] = expected
+    e = _make_exception []
+    assert_same expected, e
+  ensure
+    Thread.current[:current_exception] = nil
+  end
+  def test__make_exception_message
+    e = _make_exception %w[hello]
+    assert_instance_of RuntimeError, e
+    assert_equal 'hello', e.message
+  end
+  def test__make_exception_non_Exception
+    e = assert_raises TypeError do
+      _make_exception [String]
+    end
+    assert_equal 'exception class/object expected (not String)', e.message
+  end
+  def test_ensure_bang
+    ensured = false
+    return_here do
+      ensure! do
+        ensured = true
+      end
+    end
+    assert ensured, 'ensured was not executed'
+  end
+  def test_ensure_bang_multiple
+    ensured = []
+    return_here do
+      ensure! do
+        ensured << 1
+      end
+      ensure! do
+        ensured << 2
+      end
+    end
+    assert_equal [1, 2], ensured
+  end
+  def test_ensure_bang_multiple_return
+    ensured = []
+    return_here do
+      ensure! do
+        ensured << 1
+      end
+      ensure! do
+        ensured << 2
+      end
+      return!
+    end
+    assert_equal [1, 2], ensured
+  end
+  def test_ensure_bang_nest
+    ensured = []
+    return_here do
+      ensure! do
+        ensured << 2
+      end
+      return_here do
+        ensure! do
+          ensured << 1
+        end
+      end
+    end
+    assert_equal [1, 2], ensured
+  end
+  def test_ensure_bang_nest_raise
+    ensured = []
+    assert_raises RuntimeError do
+      return_here do
+        ensure! do
+          ensured << 2
+        end
+        return_here do
+          ensure! do
+            ensured << 1
+          end
+          raise!
+        end
+      end
+    end
+    assert_equal [1, 2], ensured
+  end
+  def test_ensure_bang_raise_after
+    ensured = false
+    assert_raises RuntimeError do
+      return_here do
+        ensure! do
+          ensured = true
+        end
+        refute ensured, 'ensure! executed too soon'
+        raise!
+      end
+    end
+    assert ensured, 'ensure! not executed'
+  end
+  def test_ensure_bang_raise_before
+    ensured = false
+    assert_raises RuntimeError do
+      return_here do
+        raise!
+        ensure! do
+          ensured = true
+        end
+      end
+    end
+    refute ensured, 'ensure! must not be executed'
+  end
+  def test_ensure_bang_raise_in_ensure
+    ensured = []
+    assert_raises RuntimeError do
+      return_here do
+        ensure! do
+          ensured << 2
+        end
+        return_here do
+          ensure! do
+            ensured << 1
+            raise!
+          end
+        end
+      end
+    end
+    assert_equal [1, 2], ensured
+  end
+  def test_raise_bang
+    e = assert_raises RuntimeError do
+      return_here do
+        raise! 'hello'
+      end
+    end
+    assert_equal 'hello', e.message
+  end
+  def test_raise_bang_ignore_rescue
+    assert_raises RuntimeError do
+      return_here do
+        begin
+          raise! 'hello'
+        rescue
+          flunk 'must not execute rescue body'
+        end
+      end
+    end
+  end
+  def test_raise_bang_re_raise
+    rescues = []
+    assert_raises ArgumentError do
+      return_here do
+        rescue! do
+          rescues << 2
+        end
+        return_here do
+          rescue! do
+            rescues << 1
+            raise!
+          end
+          raise! ArgumentError, 'hello'
+        end
+      end
+    end
+    assert_equal [1, 2], rescues
+  end
+  def test_rescue_bang
+    rescued = false
+    assert_raises RuntimeError do
+      return_here do
+        rescue! do
+          rescued = true
+        end
+        raise! 'hello'
+      end
+    end
+    assert rescued, 'rescue not executed'
+  end
+  def test_rescue_bang_default
+    rescued = false
+    assert_raises Exception do
+      return_here do
+        rescue! do
+          rescued = true
+        end
+        raise! Exception
+      end
+    end
+    refute rescued, 'rescue must default to StandardError'
+  end
+  def test_rescue_bang_exceptions
+    rescued = false
+    ensured = true
+    return_here do
+      rescue! do
+        rescued = true
+      end
+      ensure! do
+        ensured = true
+      end
+      return!
+    end
+    refute rescued, 'rescue! must not execute'
+    assert ensured, 'ensure! must execute'
+  end
+  def test_rescue_bang_multiple
+    rescued = false
+    assert_raises TypeError do
+      return_here do
+        rescue! ArgumentError, TypeError do
+          rescued = true
+        end
+        raise! TypeError
+      end
+    end
+    assert rescued, 'rescue not executed'
+  end
+  def test_rescue_bang_type
+    rescued = false
+    assert_raises StandardError do
+      return_here do
+        rescue! StandardError do
+          rescued = true
+        end
+        rescue! RuntimeError do
+          flunk 'wrong rescue! executed'
+        end
+        raise! StandardError
+      end
+    end
+    assert rescued, 'StandardError exception not rescued'
   end
   def test_return_bang_no_return_here

metadata CHANGED

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: return_bang
 version: !ruby/object:Gem::Version
-  hash: 15
+  hash: 13
   prerelease:
   segments:
   - 1
-  - 0
-  version: "1.0"
+  - 1
+  version: "1.1"
 platform: ruby
 authors:
 - Eric Hodel
@@ -15,9 +15,9 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMRAwDgYDVQQDDAdkcmJy
+  MIIDeDCCAmCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBBMRAwDgYDVQQDDAdkcmJy
   YWluMRgwFgYKCZImiZPyLGQBGRYIc2VnbWVudDcxEzARBgoJkiaJk/IsZAEZFgNu
-  ZXQwHhcNMDcxMjIxMDIwNDE0WhcNMDgxMjIwMDIwNDE0WjBBMRAwDgYDVQQDDAdk
+  ZXQwHhcNMTIwMjI4MTc1NDI1WhcNMTMwMjI3MTc1NDI1WjBBMRAwDgYDVQQDDAdk
   cmJyYWluMRgwFgYKCZImiZPyLGQBGRYIc2VnbWVudDcxEzARBgoJkiaJk/IsZAEZ
   FgNuZXQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCbbgLrGLGIDE76
   LV/cvxdEzCuYuS3oG9PrSZnuDweySUfdp/so0cDq+j8bqy6OzZSw07gdjwFMSd6J
@@ -25,17 +25,18 @@ cert_chain:
   Gj/okWrQl0NjYOYBpDi+9PPmaH2RmLJu0dB/NylsDnW5j6yN1BEI8MfJRR+HRKZY
   mUtgzBwF1V4KIZQ8EuL6I/nHVu07i6IkrpAgxpXUfdJQJi0oZAqXurAV3yTxkFwd
   g62YrrW26mDe+pZBzR6bpLE+PmXCzz7UxUq3AE0gPHbiMXie3EFE0oxnsU3lIduh
-  sCANiQ8BAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
-  BBS5k4Z75VSpdM0AclG2UvzFA/VW5DANBgkqhkiG9w0BAQUFAAOCAQEAHagT4lfX
-  kP/hDaiwGct7XPuVGbrOsKRVD59FF5kETBxEc9UQ1clKWngf8JoVuEoKD774dW19
-  bU0GOVWO+J6FMmT/Cp7nuFJ79egMf/gy4gfUfQMuvfcr6DvZUPIs9P/TlK59iMYF
-  DIOQ3DxdF3rMzztNUCizN4taVscEsjCcgW6WkUJnGdqlu3OHWpQxZBJkBTjPCoc6
-  UW6on70SFPmAy/5Cq0OJNGEWBfgD9q7rrs/X8GGwUWqXb85RXnUVi/P8Up75E0ag
-  14jEc90kN+C7oI/AGCBN0j6JnEtYIEJZibjjDJTSMWlUKKkj30kq7hlUC2CepJ4v
-  x52qPcexcYZR7w==
+  sCANiQ8BAgMBAAGjezB5MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+  BBS5k4Z75VSpdM0AclG2UvzFA/VW5DAfBgNVHREEGDAWgRRkcmJyYWluQHNlZ21l
+  bnQ3Lm5ldDAfBgNVHRIEGDAWgRRkcmJyYWluQHNlZ21lbnQ3Lm5ldDANBgkqhkiG
+  9w0BAQUFAAOCAQEAPeWzFnrcvC6eVzdlhmjUub2s6qieBkongKRDHQz5MEeQv4LS
+  SARnoHY+uCAVL/1xGAhmpzqQ3fJGWK9eBacW/e8E5GF9xQcV3mE1bA0WNaiDlX5j
+  U2aI+ZGSblqvHUCxKBHR1s7UMHsbz1saOmgdRTyPx0juJs68ocbUTeYBLWu9V4KP
+  zdGAG2JXO2gONg3b4tYDvpBLbry+KOX27iAJulUaH9TiTOULL4ITJVFsK0mYVqmR
+  Q8Tno9S3e4XGGP1ZWfLrTWEJbavFfhGHut2iMRwfC7s/YILAHNATopaJdH9DNpd1
+  U81zGHMUBOvz/VGT6wJwYJ3emS2nfA2NOHFfgA==
   -----END CERTIFICATE-----
-date: 2011-12-21 00:00:00 Z
+date: 2012-04-01 00:00:00 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -45,32 +46,51 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        hash: 15
+        hash: 21
         segments:
         - 2
-        - 6
-        version: "2.6"
+        - 11
+        version: "2.11"
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency
-  name: hoe
+  name: rdoc
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        hash: 27
+        hash: 19
         segments:
-        - 2
-        - 12
-        version: "2.12"
+        - 3
+        - 10
+        version: "3.10"
   type: :development
   version_requirements: *id002
+- !ruby/object:Gem::Dependency
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        hash: 35
+        segments:
+        - 2
+        - 16
+        version: "2.16"
+  type: :development
+  version_requirements: *id003
 description: |-
-  return_bang implements non-local exits from methods.  Use return_bang to exit
-  back to a processing loop from deeply nested code, or just to confound your
-  enemies *and* your friends!  What could possibly go wrong?
+  return_bang implements non-local exits for methods.  As a bonus, you also get
+  exception handling that ignores standard Ruby's inflexible begin; rescue;
+  ensure; end syntax.
+  Use return_bang to exit back to a processing loop from deeply nested code, or
+  just to confound your enemies *and* your friends!  What could possibly go
+  wrong?
 email:
 - [email protected]
 executables: []
@@ -105,10 +125,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      hash: 3
+      hash: 55
       segments:
-      - 0
-      version: "0"
+      - 1
+      - 9
+      - 2
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -121,9 +143,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubyforge_project: return_bang
-rubygems_version: 1.8.12
+rubygems_version: 1.8.21
 signing_key:
 specification_version: 3
-summary: return_bang implements non-local exits from methods
+summary: return_bang implements non-local exits for methods
 test_files:
 - test/test_return_bang.rb

metadata.gz.sig CHANGED

@@ -1,2 +1,4 @@
-`"t�TW��nW��G$��c�=gTV�=�z|��t"�;� ��Jv�_�X2��:����,����V��|c��xD��ܫ�s�]�}F�$�E�'uJ�{���۔Y���t������4KϞ2���E�j����u�ԕ�'�U��A��y����$��ޅ
-稼�F�D�!�c����9 RsJ��҇�AF�a��y�=s`O�YQ�Z�w��~�~j�otɋ[1�臼�A��[�a_�`
+V���Ɗ`�`u�L�N�]n��ԙ�
+1��j%>��
+p�-ZyQ��
+�*�o�辵�2�ϸg�_���Q��]�