safe-enum 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8b46454a6c48cc776ce859c3a4ff8c6913b78e3d
-  data.tar.gz: aa98b2d7f30253991c5d5ad4d2f9a9e550fbb648
+SHA256:
+  metadata.gz: 670e321a5a7e1961b6c4c940f720887a7b6dca7725f890cc27777aff7f0f2e17
+  data.tar.gz: 739fc2f8c14ccf50bb0265f6c748be615971ddb3e20128886e7c5562c31bd4b3
 SHA512:
-  metadata.gz: 32c878b5aeaa9e3443f8c490b21d0d34fe80d4213eee4d8e2f62b6d033886b0a8d46ad1f4a6210e3eca80c3edad2e96ecba7b519f61ac4acfd0d672ad1c8c21e
-  data.tar.gz: 20c18d7366e5732cf8e4fd64886bbe0efa17d0060863011c43c6aecb5cf53cdf5528e83041c7b455214a6e91b866680d12854ec0e1cc3fdd08f8358b5a779e4c
+  metadata.gz: cebfd3861390ba72e8740dc40b300a8b93920f3258832d08ba1c54074caa1ea93c9f4a3b68fada7a427cec76290e37212971483765a920b8ebe0f22f458997e6
+  data.tar.gz: 1938ac3742948d2936e951c8a66191ba06406e83ce2e351ac0c8cf29a6c08303f088f94103d77625c520249b80005b9eaf7b4d8f8049949e03cd560754127d36

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem

data/README.md

@@ -1,4 +1,3 @@
-![Travis](https://travis-ci.org/mezuka/enum.svg)
 # Enum
 
 This is a very basic implementation of enums in Ruby. The cornerstone of the library is **safety**.
@@ -8,7 +7,7 @@ This is a very basic implementation of enums in Ruby. The cornerstone of the lib
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'enum', require: 'enum'
+gem 'safe-enum'
 ```
 
 And then execute:
@@ -17,7 +16,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install enum
+    $ gem install safe-enum
 
 ## Usage
 
@@ -28,13 +27,27 @@ class Side < Enum::Base
 end
 ```
 
-Now `take` safely defined values by argument with its `Symbol` or `String` type. If there is no defined such value `Enum::TokenNotFoundError` exception will be raised. And this is the **safety** - you will be noticed about the problem and fix it by introducing a new value or fixing a source of the invalid value. While others implementations of enums in Ruby (that I know) just silently ignore invalid values returing `nil` this one will raise the exception **always**. Example of usage:
+Now get a value with the `enum` method safely defined values by argument with its `Symbol` or `String` type. If there is no defined such value `Enum::TokenNotFoundError` exception will be raised. And this is the **safety** - you will be noticed about the problem and fix it by introducing a new value or fixing a source of the invalid value. While others implementations of enums in Ruby (that I know) just silently ignore invalid values returning `nil` this one will raise the exception **always**. Example of usage:
 
 ```ruby
-Side.take(:left) # => "left"
-Side.take('left') # => "left"
-Side.take(:invalid) # => Enum::TokenNotFoundError: token 'invalid'' not found in the enum Side
-Side.take('invalid') # => Enum::TokenNotFoundError: token 'invalid'' not found in the enum Side
+Side.enum(:left) # => "left"
+Side.enum('left') # => "left"
+Side.enum(:invalid) # => Enum::TokenNotFoundError: token 'invalid'' not found in the enum Side
+Side.enum('invalid') # => Enum::TokenNotFoundError: token 'invalid'' not found in the enum Side
+```
+
+Get all defined enum values with the `all` method:
+
+```ruby
+Side.all # => ['left', 'rigth', 'whole']
+```
+
+> Order or the returned values in the same as their definition. It's guaranteed.
+
+In order to get array of defined enums safely use `enums` method:
+
+```ruby
+ Side.enums(:left, :right) # => ['left', 'right']
 ```
 
 If you have installed `I18n` in your application feel free to use `name` method to retreive the values' translations. For the given example the possible translation structure in `yml` format is the following:
@@ -59,6 +72,47 @@ Side.name(:invalid) # => Enum::TokenNotFoundError: token 'invalid'' not found in
 
 > If you don't have installed `I18n` in your project `NameError` exception will be raised on the `name` method call.
 
+Consider the case when we have an object with a field with only enum values. Extend the class of this object by `Enum::Predicates` and use `enumerize` method to generate predicates. This is a more convenient way matching current value of the field with an enum value. Usage the predicate methods is **safe** also. It means that you can't pass to the method invalid enum value neither can have an invalid value in the field:
+
+```ruby
+class Table
+  extend Enum::Predicates
+
+  attr_accessor :side
+
+  enumerize :side, Side
+end
+
+@table = Table.new
+@table.side_is?(:left) # => false
+@table.side_is?(nil) # => false
+
+@table.side = Side.enum(:left)
+@table.side_is?(:left) # => true
+@table.side_is?(:right) # => false
+@table.side_is?(nil) # => false
+@table.side_is?(:invalid) # => Enum::TokenNotFoundError: token 'invalid'' not found in the enum Side
+
+@table.side = 'invalid'
+@table.side_is?(nil) # => false
+@table.side_is?(:left) # => Enum::TokenNotFoundError: token 'invalid'' not found in the enum Side
+@table.side_any?(:left, :right) # => true
+@table.side_any?(:right) # => false
+@table.side_any?(:invalid, :left) # => Enum::TokenNotFoundError: token 'invalid'' not found in the enum Side
+```
+> If you pass to the predicate `nil` or have `nil` value in the field the result will be always `false`. If you want to check that the field is `nil` just use Ruby's standard method `nil?`.
+
+It's possible to get index of an enum value with `index` method. It can be convenient in some circumstances:
+
+```ruby
+class WeekDay < Enum::Base
+  values :sunday, :monday, :tuesday, :wednesday, :thusday, :friday, :saturday
+end
+WeekDay.index(:sunday) == Date.new(2015, 9, 13).wday # => true
+WeekDay.index(:monday) # => 1
+WeekDay.indexes # => [0, 1, 2, 3, 4, 5, 6]
+```
+
 ## 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.

data/lib/enum/base.rb

@@ -14,10 +14,22 @@ module Enum
       end
 
       def all
-        store.to_a
+        history
       end
 
-      def take(t)
+      def indexes
+        (0...store.size).to_a
+      end
+
+      def include?(token)
+        store.include?(token.to_s)
+      end
+
+      def enums(*tokens)
+        tokens.map { |token| enum(token) }
+      end
+
+      def enum(t)
         ts = t.to_s
         unless store.include?(ts)
           raise(TokenNotFoundError, "token '#{t}'' not found in the enum #{self}")
@@ -26,7 +38,11 @@ module Enum
       end
 
       def name(t)
-        translate(take(t))
+        translate(enum(t))
+      end
+
+      def index(token)
+        history.index(enum(token))
       end
 
       protected
@@ -39,10 +55,18 @@ module Enum
         @store = set
       end
 
+      def history
+        @history ||= Array.new
+      end
+
+      def history=(ary)
+        @history = ary
+      end
+
       def translate(token, options = {})
         I18n.t(token, scope: "enum.#{self}", exception_handler: proc do
           if superclass == Enum::Base
-            I18n.t(token, options.merge(scope: "enum.#{self}"))
+            I18n.t(token, **options.merge(scope: "enum.#{self}"))
           else
             superclass.translate(token, exception_handler: proc do
               I18n.t(token, scope: "enum.#{self}")
@@ -55,10 +79,12 @@ module Enum
 
       def add_value(val)
         store.add(val)
+        history.push(val)
       end
 
       def init_child_class(child)
         child.store = self.store.clone
+        child.history = self.history.clone
       end
 
     end

data/lib/enum/predicates.rb

@@ -0,0 +1,18 @@
+module Enum
+  module Predicates
+    def enumerize(field, enum)
+      define_method("#{field}_is?") do |other|
+        if (field_value = public_send(field)) && other
+          enum.enum(field_value) == enum.enum(other)
+        else
+          false
+        end
+      end
+
+      define_method("#{field}_any?") do |*others|
+        others.each { |other| enum.enum(other) } # make sure that all others values are valid enums
+        others.any? { |other| public_send("#{field}_is?", other) }
+      end
+    end
+  end
+end

data/lib/enum/version.rb

@@ -1,3 +1,3 @@
 module Enum
-  VERSION = "0.1.0"
+  VERSION = '0.3.1'
 end

data/lib/enum.rb

@@ -1,3 +1,12 @@
 require 'enum/version'
 require 'enum/token_not_found_error'
 require 'enum/base'
+require 'enum/predicates'
+
+module Enum
+  def self.[](*ary)
+    Class.new(Base) do
+      values(*ary)
+    end
+  end
+end

data/lib/safe-enum.rb

@@ -0,0 +1 @@
+require 'enum'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: safe-enum
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrey Koleshko
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2015-09-14 00:00:00.000000000 Z
+date: 2022-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,13 +86,15 @@ files:
 - enum.gemspec
 - lib/enum.rb
 - lib/enum/base.rb
+- lib/enum/predicates.rb
 - lib/enum/token_not_found_error.rb
 - lib/enum/version.rb
+- lib/safe-enum.rb
 homepage: https://github.com/mezuka/enum
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -107,9 +109,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Enum implementation
 test_files: []