https://github.com/culturehq/tiny_struct
Build Struct classes that do less.
https://github.com/culturehq/tiny_struct
ruby tool
Last synced: 12 months ago
JSON representation
Build Struct classes that do less.
- Host: GitHub
- URL: https://github.com/culturehq/tiny_struct
- Owner: CultureHQ
- License: mit
- Created: 2017-10-30T04:55:32.000Z (over 8 years ago)
- Default Branch: master
- Last Pushed: 2023-03-06T10:59:03.000Z (over 3 years ago)
- Last Synced: 2025-06-01T14:02:52.480Z (about 1 year ago)
- Topics: ruby, tool
- Language: Ruby
- Size: 161 KB
- Stars: 4
- Watchers: 0
- Forks: 0
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
# TinyStruct
[](https://github.com/CultureHQ/tiny_struct/actions)
[](https://github.com/CultureHQ/tiny_struct)
Often we want simple Ruby classes that follow the pattern of accepting data as arguments to the initializer and storing them as `attr_readers`. For example:
```ruby
class User
attr_reader :name, :email
def initialize(name, email)
@name = name
@email = email
end
def to_s
"#{name} <#{email}>"
end
end
user = User.new('Harry Potter', 'hpotter@hogwarts.edu')
# => #
```
This is pretty common, and more or less resembles a struct and an associated initializer in many other languages (see initializer lists in C++ or case classes in Scala).
You could refactor the above to inherit from Ruby's own `Struct` class, as in:
```ruby
class User < Struct.new(:name, :email)
def to_s
"#{name} <#{email}>"
end
end
```
This totally works! `Struct::new` returns a class, from which `User` then inherits. This pattern is great because it encapsulates the initialization and enforces a certain consistency over the way objects are created within a codebase.
However, there is a certain amount of bloat that comes from using the `Struct` class. Ruby defines a number of enumerable and comparison methods to allow them to function more like structs in other languages. This is why we built `TinyStruct`, which is effectively the same thing as a `Struct` but it does much less:
* In `Struct` classes all parameters are optional, in `TinyStruct` they are all required (encouraging explicit values for each member).
* In `Struct` classes each parameter is accessible through an `attr_accessor`, in `TinyStruct` they are accessible through `attr_reader`s (encouraging more data encapsulation).
* In `Struct` classes you can call all kinds of querying methods on the objects as if they were an enumerable of the various values they represent (e.g., `to_a`, `to_h`, `size`, `[]`, `values_at`, etc.), in `TinyStruct` none of these methods are defined (minifying the surface area of the class to encourage explicit method definitions if necessary).
You can use `TinyStruct` in the exact same way that you could use `Struct` (by inheriting from an object returned by the `::new` method.
Use `Struct` if you need the flexibility and extra query methods provided by the constructor. If not, consider using `TinyStruct`.
## Installation
Add this line to your application's Gemfile:
```ruby
gem 'tiny_struct'
```
And then execute:
$ bundle
Or install it yourself as:
$ gem install tiny_struct
## Development
After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/CultureHQ/tiny_struct.
## License
The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).