rails_attr_enum 0.1.0 → 0.1.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZjQyNmMyOWJkNGFjZmViNjBlZTg5OGEzYTAyZjc2N2MwOTUyYjk5Ng==
-  data.tar.gz: !binary |-
-    OTNhYjFjOGFiZjQ1NTg3N2QzNjE5YmFkZWNjNmVkM2EwZWVjZDk2OA==
+SHA1:
+  metadata.gz: 3bb8000f3dc7b7ea0f1cf0c782cb0e7b1494070d
+  data.tar.gz: 840eb22350179ec480a12db0964c937067963632
 SHA512:
-  metadata.gz: !binary |-
-    ZmNmNDYxMjFlY2VkNWQ3MjZmNTQwNTdkYzEwYTgyNDM0Yjg2MmU2ZmRjODgy
-    MGI4YTJhMzU2MDQ5MTBhYWVmMTM4N2UzZmM0NDk4NjUzM2M3MGUxYTFmM2Ey
-    ZWFhN2Y1YjFlN2EwNjQ2YTNlZTM4ZGQzY2Q1OTM3ZGM3YjcyODE=
-  data.tar.gz: !binary |-
-    MDk4YzYxMzBkZDZmZjQ2ZTU1MGM3NGE0ZjA4YmNkNzNjMjM0ZTcwOGI2Nzc1
-    Y2I3ODhmZDQxMjczOGMwYmM4OWE4ODVjMjgxNDIyNTAxMDgyZGM3NGIyZjA0
-    Y2M4YjNjNTNlYTdkYWE1MDUzYTY5NjlmYWQ3Y2U5ZjFjMWMyOTc=
+  metadata.gz: 260ffdeda4eb00489b5701444c3a21e88b1fe962f69b5cf0d3c220797ec2c6f5221835c1cc1cf6625119addd3c98ccd0ffab82a53d52d9f779886b2dba35f743
+  data.tar.gz: 6b19aabcad242e31ed1960e140d34b16d6d312c4ac64628abb7b3df7d8e59d59b6a3d5354e69b14f2ba193246784734e084045428265219733c7f6fc4e7b6be7

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### v0.1.1
+* Added support for filtering results from `Enum.label_value_pairs` by
+  passinging in enum value keys as symbol arguments.
+
 ### v0.1.0
 * Added Rails scope helpers for searching on enum values. For a given
   model `User` with an enum attribute of `role` with keys `admin`,

data/README.md

@@ -1,46 +1,63 @@
 # RailsAttrEnum
-## Enums for Rails models
 
-I created RailsAttrEnum as a way to create an enum-like structure similar to
-enums in C languages. You can specify the accepted identifiers for the possible
-integer values for the model's attribute as well have built-in validation to
-ensure only the values are accepted.
+Enums for Rails attributes. Specify enumeration identifiers for int attributes
+on your Rails models. Includes constants for your identifiers, validation,
+model class scopes, and instance helper methods.
 
-### Usage
+## Build Status
+[![Build Status](https://travis-ci.org/jfairbank/rails_attr_enum.png?branch=master)](https://travis-ci.org/jfairbank/rails_attr_enum)
 
-Here's an example given a class `User` with an attribute `role`:
+## Installation
+Add to your Gemfile:
 
-    # Example model User for a blog app
-    class User < ActiveRecord::Base
-      extend RailsAttrEnum
+```ruby
+gem 'rails_attr_enum'
+```
 
-      attr_enum :role, :admin, :editor, :author, :user
-    end
+And then run bundler:
+
+    $ bundle install
+
+## Usage
+
+Here's an example given a class `User` with an attribute `role`:
+
+```ruby
+# Example model User for a blog app
+class User < ActiveRecord::Base
+  extend RailsAttrEnum
+  attr_enum :role, :admin, :editor, :author, :user
+end
 
-    # Creates module `User::Role` with constants for each possible value
-    User::Role::ADMIN  == 0
-    User::Role::EDITOR == 1
-    User::Role::AUTHOR == 2
-    User::Role::USER   == 3
+# Creates module `User::Role` with constants for each possible value
+User::Role::ADMIN  == 0
+User::Role::EDITOR == 1
+User::Role::AUTHOR == 2
+User::Role::USER   == 3
+```
 
 [View other ways to define and customize enums](https://github.com/jfairbank/rails_attr_enum/wiki/Adding-an-Enum-to-a-Model)
 
-### Helpers for Model Instances
+## Helpers for Model Instances
 
 A couple helpers methods are added to the model and the enum attribute.
 
 Get the "display" label for the current value with the `display_*` method:
 
-    user = User.new(User::Role::ADMIN)
-    user.display_role == 'Admin'
+```ruby
+user = User.new(role: User::Role::ADMIN)
+user.display_role == 'Admin'
+```
 
 You can check for a specific value with a query `*?` method:
 
-    user = User.new(User::Role::AUTHOR)
-    user.role.admin?  # false
-    user.role.editor? # false
-    user.role.author? # true
-    user.role.user?   # false
+```ruby
+user = User.new(role: User::Role::AUTHOR)
+user.role.admin?  # false
+user.role.editor? # false
+user.role.author? # true
+user.role.user?   # false
+```
 
 The query method works via a forwarding class, so the normal `role` and `role=`
 methods should work as expected.
@@ -48,95 +65,136 @@ methods should work as expected.
 **NOTE**: one caveat to this is if you try to use
 a hash map of the enum values to some other value. See below:
 
-    alt_label_map = {
-      User::Role::ADMIN  => 'The admin user',
-      User::Role::EDITOR => 'An editor',
-      User::Role::AUTHOR => 'An author',
-      User::Role::USER   => 'A user'
-    }
+```ruby
+alt_label_map = {
+  User::Role::ADMIN  => 'The admin user',
+  User::Role::EDITOR => 'An editor',
+  User::Role::AUTHOR => 'An author',
+  User::Role::USER   => 'A user'
+}
 
-    user = User.new(User::Role::EDITOR)
-    alt_label = alt_label_map[user.role]
-    alt_label == nil # not 'An editor'
+user = User.new(role: User::Role::EDITOR)
+alt_label = alt_label_map[user.role]
+alt_label == nil # not 'An editor'
+```
 
-If you want the hash to work as expected than call the `.value` method on the
+If you want the hash to work as expected then call the `.value` method on the
 attribute:
 
-    alt_label = alt_label_map[user.role.value]
-    alt_label == 'An editor'
+```ruby
+alt_label = alt_label_map[user.role.value]
+alt_label == 'An editor'
+```
 
 Thus, the `.value` method on the attribute gives the actual `Fixnum` value.
 There is also a `.key` method which gives the symbol key:
 
-    user = User.new(User::Role::ADMIN)
-    user.role.key == :admin
+```ruby
+user = User.new(role: User::Role::ADMIN)
+user.role.key == :admin
+```
 
 The attribute value can also be set with a bang `*!` method
 
-    user = User.new
-    user.role.user!
-    user.display_role == 'User'
+```ruby
+user = User.new
+user.role.user!
+user.display_role == 'User'
 
-    user.role.author!
-    user.display_role == 'Author'
+user.role.author!
+user.display_role == 'Author'
+```
 
-### Scopes for Models
+## Scopes for Models
 
 Convenient scopes are created for each possible enum value on the model class:
 
-    User.scope_admin  == User.where(role: User::Role::ADMIN)
-    User.scope_editor == User.where(role: User::Role::EDITOR)
-    User.scope_author == User.where(role: User::Role::AUTHOR)
-    User.scope_user   == User.where(role: User::Role::USER)
+```ruby
+User.scope_admin  == User.where(role: User::Role::ADMIN)
+User.scope_editor == User.where(role: User::Role::EDITOR)
+User.scope_author == User.where(role: User::Role::AUTHOR)
+User.scope_user   == User.where(role: User::Role::USER)
+```
 
-### Enum Helper Methods
+## Enum Helper Methods
 
 Helper methods are added to the actual `Enum` module as well.
 
-`get_label` and `get_key` get the (surprise!) label and key for a given enum
+### get_label and get_key
+Get the (surprise!) label and key for a given enum
 value:
 
-    User::Role.get_label(User::Role::ADMIN) == 'Admin'
-    User::Role.get_key(User::Role::USER) == :user
+```ruby
+User::Role.get_label(User::Role::ADMIN) == 'Admin'
+User::Role.get_key(User::Role::USER) == :user
+```
 
----
+### attr_name
+Return the attribute name as a symbol
 
-`attr_name` returns the attribute symbol
+```ruby
+User::Role.attr_name == :role
+```
 
-    User::Role.attr_name == :role
+### keys
+Return all the enum keys
 
----
+```ruby
+User::Role.keys == [:admin, :editor, :author, :user]
+```
 
-`keys` returns all the enum keys
+### values
+Return all the enum values
 
-    User::Role.keys == [:admin, :editor, :author, :user]
+```ruby
+User::Role.values == [0, 1, 2, 3]
+```
 
----
+### labels
+Return all the enum labels
 
-`values` returns all the enum values
+```ruby
+User::Role.labels == ['Admin', 'Editor', 'Author', 'User']
+```
 
-    User::Role.values == [0, 1, 2, 3]
-
----
-
-`labels` returns all the enum labels
-
-    User::Role.labels == ['Admin', 'Editor', 'Author', 'User']
-
----
-
-`label_value_pairs` returns an array of pairs of the label and value for each
+### label_value_pairs
+Return an array of pairs of the label and value for each
 enum value. This is mainly a convenience method for something like the
 collection option for a select input in the
 [Formtastic](https://github.com/justinfrench/formtastic) or
-[ActiveAdmin (which uses Formtastic)](https://github.com/gregbell/active_admin)
-gems:
+[ActiveAdmin](https://github.com/gregbell/active_admin) (which uses Formtastic)
+gems, so you can easily generate select options:
+
+```ruby
+User::Role.label_value_pairs == [
+  ['Admin', 0], ['Editor', 1], ['Author', 2], ['User', 3]
+]
+
+# In an ActiveAdmin form
+ActiveAdmin.register User do
+  form do |f|
+    f.inputs 'User Details' do
+      f.input :first_name
+      f.input :last_name
+      f.input :email
+
+      # Example usage of `label_value_pairs`
+      f.input :role, as: :select, collection: User::Role.label_value_pairs
+    end
+  end
+end
+```
 
-    User::Role.label_value_pairs ==
-      [['Admin', 0], ['Editor', 1], ['Author', 2], ['User', 3]]
+You can also filter the results by passing in enum value keys as symbol
+arguments:
 
----
+```ruby
+User::Role.label_value_pairs(:admin, :author) == [
+  ['Admin', 0], ['Author', 2]
+]
+```
 
+### to_h and to_json
 `to_h` and `to_json` return a hash and a json string representation of the enum,
 respectively. They both offer an `only` and an `except` option to specify if
 you only want the value or maybe only the label and key or if you want
@@ -144,27 +202,29 @@ everything but key. **NOTE**:  passing only key to `only` or excluding all but
 one key via `except` will give that single value (whether it's value, key, or
 label) instead of a hash. See below to understand:
 
-    # Default call with no options
-    User::Role.to_h == {
-      'ADMIN'  => { key: :admin,  label: 'Admin',  value: 0 },
-      'EDITOR' => { key: :editor, label: 'Editor', value: 1 },
-      'AUTHOR' => { key: :author, label: 'Author', value: 2 },
-      'USER'   => { key: :user,   label: 'User',   value: 3 }
-    }
-
-    # Call with a single symbol (would also work with `only: [:value]`)
-    # Notice the mapped values are not hashes like above because we only
-    # specified that we wanted the value
-    User::Role.to_h(only: :value) == {
-      'ADMIN'  => 0,
-      'EDITOR' => 1,
-      'AUTHOR' => 2,
-      'USER'   => 3
-    }
-
-    # Would also work with `except: [:value]`
-    User::Role.to_json(except: :value) ==
-      "{\"ADMIN\":{\"key\":\"admin\",\"label\":\"Admin\"},\"EDITOR\":{\"key\":\"editor\",\"label\":\"Editor\"},\"AUTHOR\":{\"key\":\"author\",\"label\":\"Author\"},\"USER\":{\"key\":\"user\",\"label\":\"User\"}}"
-
-### Feedback and Pull Requests Welcome
+```ruby
+# Default call with no options
+User::Role.to_h == {
+  'ADMIN'  => { key: :admin,  label: 'Admin',  value: 0 },
+  'EDITOR' => { key: :editor, label: 'Editor', value: 1 },
+  'AUTHOR' => { key: :author, label: 'Author', value: 2 },
+  'USER'   => { key: :user,   label: 'User',   value: 3 }
+}
+
+# Call with a single symbol (would also work with `only: [:value]`)
+# Notice the mapped values are not hashes like above because we only
+# specified that we wanted the value
+User::Role.to_h(only: :value) == {
+  'ADMIN'  => 0,
+  'EDITOR' => 1,
+  'AUTHOR' => 2,
+  'USER'   => 3
+}
+
+# Would also work with `except: [:value]`
+User::Role.to_json(except: :value) ==
+  "{\"ADMIN\":{\"key\":\"admin\",\"label\":\"Admin\"},\"EDITOR\":{\"key\":\"editor\",\"label\":\"Editor\"},\"AUTHOR\":{\"key\":\"author\",\"label\":\"Author\"},\"USER\":{\"key\":\"user\",\"label\":\"User\"}}"
+```
+
+## Feedback and Pull Requests Welcome
 This is my first real Rails gem, so I welcome all feedback and ideas. I hope this gem is as helpful to you as it has been to me in my own projects.

data/lib/rails_attr_enum/enum.rb

@@ -23,8 +23,15 @@ module RailsAttrEnum
         @entries << entry
       end
 
-      def label_value_pairs
-        labels.zip values
+      def label_value_pairs(*keys)
+        if keys.empty?
+          labels.zip(values)
+        else
+          @entries.reduce([]) do |arr, entry|
+            arr << [entry.label, entry.value] if keys.include?(entry.key)
+            arr
+          end
+        end
       end
 
       def get_label(value)

data/lib/rails_attr_enum/version.rb

@@ -1,3 +1,3 @@
 module RailsAttrEnum
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/test/dummy/log/development.log

@@ -112,3 +112,21 @@ DEPRECATION WARNING: Model.scoped is deprecated. Please use Model.all instead. (
    (0.1ms)  rollback transaction
    (0.3ms)  begin transaction
    (0.1ms)  rollback transaction
+   (1.7ms)  CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255), "role" integer, "created_at" datetime, "updated_at" datetime) 
+   (1.5ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (1.7ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.2ms)  SELECT version FROM "schema_migrations"
+   (1.4ms)  INSERT INTO "schema_migrations" (version) VALUES ('20131023212242')
+  ActiveRecord::SchemaMigration Load (0.3ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (1.3ms)  CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255), "role" integer, "created_at" datetime, "updated_at" datetime) 
+   (1.1ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (1.1ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.1ms)  SELECT version FROM "schema_migrations"
+   (0.9ms)  INSERT INTO "schema_migrations" (version) VALUES ('20131023212242')
+  ActiveRecord::SchemaMigration Load (0.3ms)  SELECT "schema_migrations".* FROM "schema_migrations"
+   (18.1ms)  CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255), "role" integer, "created_at" datetime, "updated_at" datetime) 
+   (1.2ms)  CREATE TABLE "schema_migrations" ("version" varchar(255) NOT NULL) 
+   (1.1ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.2ms)  SELECT version FROM "schema_migrations"
+   (1.3ms)  INSERT INTO "schema_migrations" (version) VALUES ('20131023212242')
+  ActiveRecord::SchemaMigration Load (0.3ms)  SELECT "schema_migrations".* FROM "schema_migrations"