sha3 1.0.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16edba407e859ee7afacc8a405666ec66cab0052cd7788e79089bd3f0d295844
-  data.tar.gz: 5552886038bbec790d086599cbbe6ad09a0c3561b58a9a2dfff2b9c9834b7154
+  metadata.gz: c29bcfb557e028701b34ce0d2be3cdbec41882e45cedcb2f129e874bbb3867e5
+  data.tar.gz: 12c260b599a433def09b389d0cd39e72ebe2dae4e495979235aece99f2684e25
 SHA512:
-  metadata.gz: a8e36ae984df177684d4b1a70689a80824e9d9ee70fd07812eaa50c8f0cd90a90f292dca435764842b737fb268084d09fa5f47450bdc9cf93316253c70484945
-  data.tar.gz: a643ded4e2f9828d732f428eba1757c6cc383797f32b52ba7427dae8234ac9bc0e158712ccf64d7be77f2538b80904efaf26a0e455ce9515f9a76679929054c0
+  metadata.gz: 1be97184feef60e8340b6dd009f5c8eabcc6b2b72b050d2a3f08ef93d9c11184c7a9c1246f2cf241ef62d47fc13b96a62bab8b61002001b04942162dc9a7dd82
+  data.tar.gz: ca4d24baf5cda13fb0f071640875a16182aa234dca43b85d5d81e05ec80a9d3d1ea89b98b0f7f6a621d6395e6647472ef131c9dd2979f942556137108079ca80

data/.clang-format

@@ -0,0 +1,54 @@
+BasedOnStyle: Google  # Use Google's style as a foundation
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Left
+AlignOperands: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: true
+BinPackParameters: true
+BreakBeforeBraces: Attach
+BreakBeforeTernaryOperators: true
+ColumnLimit: 100
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+FixNamespaceComments: true
+IncludeBlocks: Regroup
+IndentCaseLabels: true
+IndentPPDirectives: None
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: false
+Language: Cpp
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+PointerAlignment: Left
+ReflowComments: true
+SortIncludes: true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles: false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard: Auto
+TabWidth: 2
+UseTab: Never

data/.document

@@ -1,4 +1,5 @@
--
-README.rdoc
-ChangeLog.rdoc
+README.md
 LICENSE.txt
+lib/**/*.rb
+ext/sha3/digest.{c,h}
+doc/**/*.rb

data/.rdoc_options

@@ -0,0 +1,10 @@
+---
+main_page: README.md
+title: SHA3
+
+charset: UTF-8
+encoding: UTF-8
+force_update: true
+markup: rdoc
+op_dir: html
+visibility: :private

data/.rspec

@@ -1,3 +1,3 @@
---format documentation
+--require spec_helper
 --color
---require ./spec/spec_helper
+--format documentation

data/.rubocop.yml

@@ -1,6 +1,10 @@
+plugins:
+  - rubocop-rake
+  - rubocop-rspec
+
 AllCops:
   NewCops: enable
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
 
 Layout/LineLength:
   Max: 120

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# SHA3 Ruby Gem Changelog
+
+## v1.0.5 (2022-10-23)
+
+### Security
+- Fixed buffer overflow vulnerability in Keccak implementation by updating to latest XKCP library
+- Added test to verify fix for buffer overflow vulnerability
+
+### Improvements
+- Updated XKCP library with improved directory structure
+- Refactored byte-length test vector generator
+
+### Documentation
+- Updated README with current supported Ruby versions
+- Added credits section to README
+- Fixed typo in README
+- Updated gem description
+
+### Maintenance
+- Updated development dependencies
+- Removed bundler from development dependencies list
+- Updated signing certificate
+- Added macOS file types to .gitignore

data/Gemfile

@@ -3,3 +3,14 @@
 source 'https://rubygems.org'
 
 gemspec
+
+group :development, :test do
+  gem 'irb'
+
+  gem 'rake', '~> 13'
+  gem 'rake-compiler', '~> 1'
+  gem 'rspec', '~> 3'
+  gem 'rubocop', '~> 1'
+  gem 'rubocop-rake', '~> 0.7'
+  gem 'rubocop-rspec', '~> 3'
+end

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Johanns Gregorian
+Copyright (c) 2025 Johanns Gregorian
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,123 +1,210 @@
-# sha3  
+# SHA3 for Ruby
 
 [![Gem Version](https://badge.fury.io/rb/sha3.svg)](https://badge.fury.io/rb/sha3) [![Ruby](https://github.com/johanns/sha3/actions/workflows/main.yml/badge.svg)](https://github.com/johanns/sha3/actions/workflows/main.yml)
 
-**SHA3 for Ruby** is a XKCP based native (C) binding to SHA3 (FIPS 202) cryptographic hashing algorithm.
+A high-performance native binding to the SHA3 (FIPS 202) cryptographic hashing algorithm, based on the [XKCP - eXtended Keccak Code Package](https://github.com/XKCP/XKCP).
+
+> [!CAUTION]
+> **Security Notice**: Do not use SHA-3 for hashing passwords. Instead, use a slow hashing function such as PBKDF2, Argon2, bcrypt, or scrypt.
+
+> [!IMPORTANT]
+> **Breaking Changes**: SHA3 version 2.0 introduces breaking changes to the API. Please review the changelog and ensure compatibility with your application.
+> If you need the previous behavior, lock your Gemfile to version '~> 1.0'.
+
+## Table of Contents
+
+- [Documentation](#documentation)
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [SHA-3 Fixed Hash Functions](#sha-3-fixed-hash-functions)
+  - [SHAKE128/256 Functions](#shake128256-functions)
+  - [Alternate Class Syntax](#alternate-class-syntax)
+  - [Hashing a File](#hashing-a-file)
+- [Development](#development)
+  - [Dependencies](#dependencies)
+  - [Testing](#testing)
+  - [Supported Ruby Versions](#supported-ruby-versions)
+- [Contributing](#contributing)
+- [Roadmap](#roadmap)
+- [License](#license)
+- [Credits](#credits)
+
+## Documentation
+
+- [API Documentation](https://docs.jsg.io/sha3/html/index.html)
+- [GitHub Repository](https://github.com/johanns/sha3#readme)
+- [Issue Tracker](https://github.com/johanns/sha3/issues)
+
+## Features
+
+- Full support for all SHA-3 variants (224, 256, 384, and 512 bit)
+- Support for SHAKE128 and SHAKE256 extendable-output functions (XOFs)
+- Native C implementation for high performance
+- Simple, Ruby-friendly API that follows Ruby's standard Digest interface
+- Comprehensive test suite with official NIST test vectors
+- Thread-safe implementation
 
-- [Home](https://github.com/johanns/sha3#readme)
-- [Issues](https://github.com/johanns/sha3/issues)
-- [Documentation](http://rubydoc.info/gems/sha3/frames)
-- [XKCP - eXtended Keccak Code Package](https://github.com/XKCP/XKCP)
-
-## Warning
+## Installation
 
-- Please do NOT use SHA3 to hash passwords -- use a slow hashing function instead (e.g.: `pbkdf2`, `argon2`, `bcrypt` or `scrypt`)
-- Version 1.0 introduces new API and is incompatible with previous versions (0.x).
+Add this line to your application's Gemfile:
 
-## Module details
+```ruby
+gem 'sha3', '~> 2.0'
+```
 
-**SHA3::Digest**: A standard *Digest* _subclass_. The interface, and operation of this class are parallel to digest classes bundled with MRI-based Rubies (e.g.: **Digest::SHA2**, and **OpenSSL::Digest**).
+And then execute:
 
-See [documentation for Ruby's **Digest** class for additional details](http://www.ruby-doc.org/stdlib-2.2.3/libdoc/digest/rdoc/Digest.html).
+```sh
+bundle install
+```
 
-## Installation
+Or install it yourself as:
 
-```shell
+```sh
 gem install sha3
 ```
 
 ## Usage
 
+### SHA-3 Fixed Hash Functions
+
 ```ruby
 require 'sha3'
-```
 
-Valid hash bit-lengths are: *224*, *256*, *384*, *512*.
+# Create a new digest instance
+digest = SHA3::Digest.new(:sha3_224, 'Start here')
 
-```ruby
-:sha224  :sha256  :sha384  :sha512
+# Add more data to be hashed
+digest << "Compute Me"
+digest.update("Me too")
+
+# Get the final hash value as a hex string
+digest.hexdigest
+# => "d6d38021d60857..."
 
-# SHA3::Digest.new(224) is SHA3::Digest.new(:sha224)
+# Or as a binary string
+digest.digest
 ```
 
-Alternatively, you can instantiate using one of four sub-classes:
+Valid algorithm symbols are:
 
-```ruby
-SHA3::Digest::SHA224.new() # 224 bits
-SHA3::Digest::SHA256.new() # 256 bits
-SHA3::Digest::SHA384.new() # 384 bits
-SHA3::Digest::SHA512.new() # 512 bits
-```
+- `:sha3_224` - SHA-3 224 bits
+- `:sha3_256` - SHA-3 256 bits
+- `:sha3_384` - SHA-3 384 bits
+- `:sha3_512` - SHA-3 512 bits
+- `:shake_128` - SHAKE128 extendable-output function
+- `:shake_256` - SHAKE256 extendable-output function
 
-### Basics
+### SHAKE128/256 Functions
+
+SHAKE128 and SHAKE256 are extendable-output functions (XOFs) that allow you to "squeeze" an arbitrary number of bytes from the hash state:
 
 ```ruby
-# Instantiate a new SHA3::Digest class with 256 bit length
-s = SHA3::Digest.new(:sha256)
+# Create a new SHAKE128 instance
+shake = SHA3::Digest.new(:shake_128)
 
-# OR #
+# Add data to be hashed
+shake << 'Squeeze this data...'
 
-s = SHA3::Digest::SHA256.new()
+# Squeeze 120 bytes (240 hex characters) from the hash state
+result = shake.hex_squeeze(120)
 
-# Update hash state, and compute new value
-s.update "Compute Me"
+# Or get binary output
+binary_result = shake.squeeze(1024)
 
-# << is an .update() alias
-s << "Me too"
+# You can call squeeze functions multiple times with arbitrary output lengths
+first_part = shake.squeeze(32)       # Get 32 bytes
+second_part = shake.squeeze(64)      # Get 64 bytes
+third_part = shake.hex_squeeze(128)  # Get 128 bytes as hex
+```
 
-# Returns digest value in bytes
-s.digest
-# => "\xBE\xDF\r\xD9\xA1..."
+### Alternate Class Syntax
 
-# Returns digest value as hex string
-s.hexdigest
-# => "bedf0dd9a15b647..."
+For convenience, you can also use dedicated classes for each algorithm:
 
-### Digest class-methods: ###
+```ruby
+# Available classes
+SHA3::Digest::SHA3_224.new([data])
+SHA3::Digest::SHA3_256.new([data])
+SHA3::Digest::SHA3_384.new([data])
+SHA3::Digest::SHA3_512.new([data])
+SHA3::Digest::SHAKE_128.new([data])
+SHA3::Digest::SHAKE_256.new([data])
+```
+
+```ruby
+# Example usage
+digest = SHA3::Digest::SHA3_256.new('Start here')
 
-SHA3::Digest.hexdigest(:sha224, "Hash me, please")
-# => "200e7bc18cd613..."
+digest << "Compute Me"
+digest.update("Me too")
 
-SHA3::Digest::SHA384.digest("Hash me, please")
-# => "\xF5\xCEpC\xB0eV..."
+digest.hexdigest
+# => "bedf0dd9a15b647..."
 ```
 
-### Hashing a file
+### Hashing a File
 
 ```ruby
-# Compute the hash value for given file, and return the result as hex
-s = SHA3::Digest::SHA224.file("my_fantastical_file.bin").hexdigest
+# Compute the hash value for a given file, and return the result as hex
+hash = SHA3::Digest::SHA3_256.file("my_file.bin").hexdigest
 
-# Calling SHA3::Digest.file(...) defaults to SHA256
-s = SHA3::Digest.file("tests.sh")
-# => #<SHA3::Digest: a9801db49389339...>
+# Calling SHA3::Digest.file(...) defaults to SHA3_256
+hash = SHA3::Digest.file("my_file.bin").hexdigest
+# => "a9801db49389339..."
 ```
 
-### Development Dependencies
+## Development
+
+### Dependencies
 
-* Native build tools (e.g., Clang/LLVM, GCC, Minigw, etc.)
-* Gems: rubygems-tasks, rake, rspec, yard
+- **C/C++** compiler and native build tools (e.g., Clang/LLVM, GCC, MinGW, etc.)
+- **Gems**: rake, rake-compiler, rspec, yard
 
 ### Testing
 
-Call ```rake``` to run the included RSpec tests.
+Run `rake` to build and run the (RSpec) tests.
 
-Only a small subset of test vectors are included in the source repository; however, the complete test vectors suite is available for download. Simply run the ```tests.sh``` shell script (available in the root of source directory) to generate full byte-length RSpec test files.
+To run the tests manually:
 
-  ```sh tests.sh```
+```bash
+bundle exec rspec
+```
 
-### Rubies
+The test suite includes a special `sha3_vectors_spec.rb` file that automatically:
+1. Downloads the official SHA3 test vectors from the XKCP repository
+2. Parses the test vectors
+3. Runs tests against all SHA3 variants (224, 256, 384, and 512 bit)
 
-Supported Ruby versions:
+The test vectors are downloaded only once and cached in the `spec/data` directory for future test runs.
 
-  - MRI Ruby 2.6 - 3.1
+### Supported Ruby Versions
 
-## Credits
+- MRI Ruby 2.7 - 3.1
 
-XKCP by Keccak team: [https://keccak.team/index.html]()
+## Roadmap
 
-## Copyright
+- [X] Add support for SHA-3 variants (224, 256, 384, and 512 bit)
+- [X] Add support for SHAKE128 and SHAKE256 extendable-output functions (XOFs)
+- [ ] Add support for cSHAKE, TurboSHANKE, and KMAC
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+Copyright (c) 2012 - 2025 Johanns Gregorian (https://github.com/johanns)
+
+Released under the MIT License. See [LICENSE.txt](LICENSE.txt) for details.
+
+## Credits
 
-Copyright (c) 2012 - 2022 Johanns Gregorian (https://github.com/johanns)
+- [XKCP - eXtended Keccak Code Package](https://github.com/XKCP/XKCP) by the Keccak team: [https://keccak.team/index.html](https://keccak.team/index.html)
+- All contributors to the SHA3 for Ruby project
 
-**See LICENSE.txt for details.**

data/Rakefile

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
 
+require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
 require 'rubocop/rake_task'
-
 RuboCop::RakeTask.new
 
 require 'rake/extensiontask'
 
 begin
   Rake::ExtensionTask.new :compile do |ext|
-    ext.name = 'sha3_n'
+    ext.name = 'sha3_digest'
     ext.ext_dir = 'ext/sha3'
     ext.tmp_dir = 'tmp'
     ext.source_pattern = '*.{c}'
@@ -24,4 +23,11 @@ rescue LoadError
   end
 end
 
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = '../docs/sha3'
+  rdoc.options << '--force-update'
+end
+
 task default: %i[compile spec]

data/certs/io+sha3@jsg.io.pem

@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEYDCCAsigAwIBAgIBATANBgkqhkiG9w0BAQsFADA7MRAwDgYDVQQDDAdpb19z
+aGEzMRMwEQYKCZImiZPyLGQBGRYDanNnMRIwEAYKCZImiZPyLGQBGRYCaW8wHhcN
+MjUwMzAxMDYxMTE1WhcNMjYwMzAxMDYxMTE1WjA7MRAwDgYDVQQDDAdpb19zaGEz
+MRMwEQYKCZImiZPyLGQBGRYDanNnMRIwEAYKCZImiZPyLGQBGRYCaW8wggGiMA0G
+CSqGSIb3DQEBAQUAA4IBjwAwggGKAoIBgQDMdO1oUQ9FzXYtfFktOXDx6oIf9uSk
+mg+yfo7uvcyNSa4gsF4+CY/TOYNBtwlD25AlgDqpxVCHFwUaBD+MHKyd8p6Eto1Q
+Bwb7YrjPOXlmCKQYr5sFfbjeUfQRKBUTAhzM0W/5Zh9C4gkOyZ/7SaU6mI/M/LgQ
+dZsw2y6l2bAl4aZaXgbnO7B1rPTPr6yQRZTveacmeTGHav1WACdE36Txqyv2QA7+
++VdYx04fOe2FEipan7d4TA4XKW+0Z+VWyoWFNyyxJtiT53PB10lztPiycBqZ+A3L
+aA2VjZekn3NFbsXMOa4fbSTMddb784IWEeySmTMu6W/yYpo1B1PbgRaD/z2Zg0Qj
+SZ2ldqqk68nvFVWqUlRbT8ZY6McKC1VEbNLLk7jNvdbgr/VPo4Zu5TP3FXjsPlpz
+1duXTtAGtHjPnS+tdkSinKv4OmbTHid9gnoDcRjlNpWxoULs9iSNb6lOCUeBxvF6
+4Eh7nyIPmaTDwPQtg5/RTvjZMqprS8D3tKsCAwEAAaNvMG0wCQYDVR0TBAIwADAL
+BgNVHQ8EBAMCBLAwHQYDVR0OBBYEFLCWxOjmn5qTuhjFG7fwiPXzSIlFMBkGA1Ud
+EQQSMBCBDmlvK3NoYTNAanNnLmlvMBkGA1UdEgQSMBCBDmlvK3NoYTNAanNnLmlv
+MA0GCSqGSIb3DQEBCwUAA4IBgQC4Y5pXxtopzHiSBsg6fuozv7zHXXuYXOL2Bq2x
+l8C8lYjC2pN/Fh+FlgrJkqAoJ0wBlh3+wkhYPhSehkUy/2HaUYYTd1Zv4Odw+C/Q
+rQnN5+nIv+gMrLwoBXH9sFjAp/iYKd4cDz5aUVNrPqibj8zivcSqFJ9lsyOvIZO6
+tajU2HVxXOkpTtLzMgPEGdwlFEd2tB7VCGFbrTskxrpv243b0HdpeEVh2e9dNkl4
+XobOvUPXHzFTDucYe8jpCn7e7Cj43PpTZFnxIRJnO8cVpX6n7UG8+JgBSqvwuv5C
+YwFBqP6G2+0e0EdIIMdbCDBTmJbFyBr6y4pzED/FvEFzhAmCKOcZ6RJ8H7hkX5rh
++L4c9pHTemc2sQl7kH+mrntu7pt6D4EM4FD5eyWujQN1ME7xvLIFm5SczqCzFDfe
+UjZtrp/rHLfHln46RvB+a1NlMRWxtJ7mQc/CMEbT+cpHlzuYa9qGakA4TmMpK10h
+uYUv/V6CD4iTEMby0dopwHt5NqE=
+-----END CERTIFICATE-----

data/doc/sha3.rb

@@ -0,0 +1,81 @@
+module SHA3
+  module Digest
+    # SHA3_224 is a cryptographic hash function that produces a 224-bit (28-byte) hash value.
+    #
+    # Usage:
+    #   digest = SHA3::Digest::SHA3_224.new
+    #   digest.update("message")
+    #   hash = digest.hexdigest
+    #
+    #   # Or more simply:
+    #   hash = SHA3::Digest::SHA3_224.hexdigest("message")
+    #
+    # See SHA3::Digest for complete API list and additional documentation.
+    class SHA3_224 < ::Digest::Class; end
+
+    # SHA3_256 is a cryptographic hash function that produces a 256-bit (32-byte) hash value.
+    #
+    # Usage:
+    #   digest = SHA3::Digest::SHA3_256.new
+    #   digest.update("message")
+    #   hash = digest.hexdigest
+    #
+    #   # Or more simply:
+    #   hash = SHA3::Digest::SHA3_256.hexdigest("message")
+    #
+    # See SHA3::Digest for complete API list and additional documentation.
+    class SHA3_256 < ::Digest::Class; end
+
+    # SHA3_384 is a cryptographic hash function that produces a 384-bit (48-byte) hash value.
+    #
+    # Usage:
+    #   digest = SHA3::Digest::SHA3_384.new
+    #   digest.update("message")
+    #   hash = digest.hexdigest
+    #
+    #   # Or more simply:
+    #   hash = SHA3::Digest::SHA3_384.hexdigest("message")
+    #
+    # See SHA3::Digest for complete API list and additional documentation.
+    class SHA3_384 < ::Digest::Class; end
+
+    # SHA3_512 is a cryptographic hash function that produces a 512-bit (64-byte) hash value.
+    #
+    # Usage:
+    #   digest = SHA3::Digest::SHA3_512.new
+    #   digest.update("message")
+    #   hash = digest.hexdigest
+    #
+    #   # Or more simply:
+    #   hash = SHA3::Digest::SHA3_512.hexdigest("message")
+    #
+    # See SHA3::Digest for complete API list and additional documentation.
+    class SHA3_512 < ::Digest::Class; end
+
+    # SHAKE_128 is an extendable-output function (XOF) that can produce hash values of any desired length.
+    #
+    # Usage:
+    #   digest = SHA3::Digest::SHAKE_128.new
+    #   digest.update("message")
+    #   hash = digest.hexdigest(32)  # Get 32 bytes (64 hex chars) of output
+    #
+    #   # Or more simply:
+    #   hash = SHA3::Digest::SHAKE_128.hexdigest("message", 32)
+    #
+    # See SHA3::Digest for complete API list and additional documentation.
+    class SHAKE_128 < ::Digest::Class; end
+
+    # SHAKE_256 is an extendable-output function (XOF) that can produce hash values of any desired length.
+    #
+    # Usage:
+    #   digest = SHA3::Digest::SHAKE_256.new
+    #   digest.update("message")
+    #   hash = digest.hexdigest(32)  # Get 32 bytes (64 hex chars) of output
+    #
+    #   # Or more simply:
+    #   hash = SHA3::Digest::SHAKE_256.hexdigest("message", 32)
+    #
+    # See SHA3::Digest for complete API list and additional documentation.
+    class SHAKE_256 < ::Digest::Class; end
+  end
+end