exnum 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e19db98eceec0a2a9fa841e4f58bb1a5dcb1d92c
-  data.tar.gz: f02d44775ef8482c8de5e14403b1f8af8bca777f
+SHA256:
+  metadata.gz: 295aa28e2fb1dcfbfeddd68ac9feac4bcab8fbb746d7c594a52d6f2f5ec1cc66
+  data.tar.gz: 195d6394fbaddb4a56a3c306a7de22d44e3890da2c9f5b6f2e55ea192e6d5082
 SHA512:
-  metadata.gz: 7eb38d49e15ed528c9b85a1f022b8f92474b289debfac9adb173482ca76d298cf66e0a54d7838711c2cf327578805a1e644cc4246da89f00e200d10e837e8642
-  data.tar.gz: 68f4f32ea4410af3f7cc703b3efa0c2e4a2aeff30af20b14d51cf987b5668a378b9ef9aed54974ae141b2d82be410e0de7ca3c73d1cd81c09aa4dbc53b2a83d6
+  metadata.gz: bd5dacea7a74dbd63ae7fe1de7b42d1f75be5123250a0b1bfe28f1e98623fb12ceadeedd93479b653a0322026dd75322f66faea045fb60e397486fdfc7dd2460
+  data.tar.gz: 0c940ca68a4711848a2afed0b027f9a242895cc535f0d9b7c1efbd16a82610939fac2339940fb6c537999bf9716df1d16a5642d1d68d0fe70bb8d3c440d3f231

data/.circleci/config.yml

@@ -0,0 +1,36 @@
+# Ruby CircleCI 2.0 configuration file
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.6.3
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      - run:
+          name: Setup Code Climate test-reporter
+          command: |
+            # download test reporter as a static binary
+            curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+            chmod +x ./cc-test-reporter
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - run:
+          name: Run backend tests
+          command: |
+            ./cc-test-reporter before-build
+            bundle exec rake
+            ./cc-test-reporter after-build --coverage-input-type simplecov --exit-code $?
+
+workflows:
+  version: 2
+  workflow:
+    jobs:
+      - build

data/README.md

@@ -1,12 +1,12 @@
 # Exnum
 
 [![Gem Version](https://badge.fury.io/rb/exnum.svg)](https://badge.fury.io/rb/exnum)
-[![Build Status](https://travis-ci.org/Kta-M/exnum.svg?branch=master)](https://travis-ci.org/Kta-M/exnum)
-[![Code Climate](https://codeclimate.com/github/Kta-M/exnum/badges/gpa.svg)](https://codeclimate.com/github/Kta-M/exnum)
-[![Test Coverage](https://codeclimate.com/github/Kta-M/exnum/badges/coverage.svg)](https://codeclimate.com/github/Kta-M/exnum/coverage)
+[![CircleCI](https://circleci.com/gh/Kta-M/exnum.svg?style=svg)](https://circleci.com/gh/Kta-M/exnum)
+[![Maintainability](https://api.codeclimate.com/v1/badges/d8d694f943658d8a5506/maintainability)](https://codeclimate.com/github/Kta-M/exnum/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/d8d694f943658d8a5506/test_coverage)](https://codeclimate.com/github/Kta-M/exnum/test_coverage)
 
 Exnum is enum extention for Rails.
-This gem extends enum about i18n and associated parameters.
+This gem extends enum about i18n, associated parameters, and array for select box.
 
 ## Installation
 
@@ -18,30 +18,51 @@ gem 'exnum'
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install exnum
+```
+$ gem install exnum
+```
 
 ## Usage
 
-ActiveRecord:
-```
+```ruby
 class User < ActiveRecord::Base
   # the value of the key "val" defines enum values
   # and the others defines associated parameters
   exnum role: {
-    guest:   {val: 10, label: :red },
-    general: {val: 20, label: :green, permission: false },
-    admin:   {val: 30, label: :blue,  permission: true},
+    guest:   {val: 10, label: :red,   selectable: true, },
+    general: {val: 20, label: :green, selectable: true,  permission: false},
+    admin:   {val: 30, label: :blue,  selectable: false, permission: true},
   }
 end
+```
 
+### Assosiated parameter extention
+```ruby
+User.role_labels
+# => {"guest" => :red, "general" => :green, "admin" => :blue}
+User.role_labels{|p| p[:selectable]}
+# => {"guest" => :red, "general" => :green}
+User.role_permissions
+# => {"guest" => nil, "general" => false, "admin" => true}
 ```
 
-I18n:
+```ruby
+user = User.new(role: :general)
+user.role_label
+# => :green
+user.role_permission
+# => false
 ```
+
+### I18n extention
+
+```yaml
 ja:
   activerecord:
     enum:
@@ -50,47 +71,51 @@ ja:
           guest:   ゲスト
           general: 一般ユーザー
           admin:   管理者
-
 ```
 
-Then you can use i18n extention
-```
+```ruby
 User.roles_i18n
 # => {"guest" => "ゲスト", "general" => "一般ユーザー", "admin" => "管理者"}
+User.roles_i18n{|p| p[:selectable]}
+# => {"guest" => "ゲスト", "general" => "一般ユーザー"}
+```
 
+```ruby
 user = User.new(role: :guest)
 user.role_i18n
 # => "ゲスト"
 ```
 
-and assosiated parameter extention.
+### Array for select box extention
+```ruby
+User.roles_for_select
+# => [["ゲスト", "guest"], ["一般ユーザー", "general"], ["管理者", "admin"]]
+User.roles_for_select{|p| p[:selectable]}
+# => [["ゲスト", "guest"], ["一般ユーザー", "general"]]
 ```
-User.role_labels
-# => {"guest" => :red, "general" => :green, "admin" => :blue}
-User.role_permissions
-# => {"guest" => nil, "general" => false, "admin" => true}
 
-user = User.new(role: :general)
-user.role_label
-# => :green
-user.role_permission
-# => false
+You can use it like this:
+```ruby
+<%= f.select :role, User.roles_for_select %>
 ```
 
-And of cause, you can use methods provided by `enum`.
-
-`exnum` can also use as well as `enum`.
-Then you can use extention only about i18n.
-```
+### enum
+Of cause, you can use methods provided by `enum`.
+```ruby
 class User < ActiveRecord::Base
   exnum role: [:guest, :general, :admin]
 end
 ```
-```
+```ruby
 class User < ActiveRecord::Base
   exnum role: {guest: 10, general: 20, admin: 30}
 end
 ```
+```ruby
+class User < ActiveRecord::Base
+  exnum role: {guest: 10, general: 20, admin: 30}, _prefix: true
+end
+```
 
 ## Contributing
 
@@ -104,3 +129,4 @@ end
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
+

data/exnum.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "sqlite3", "~> 1.0"
   spec.add_development_dependency "pry-rails"
-  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "simplecov"
 end

data/lib/exnum/active_record/exnum.rb

@@ -1,8 +1,10 @@
 module ActiveRecord
   module Exnum
+
     def self.prepended(base)
       base.singleton_class.class_eval { self.prepend(ClassMethods) }
     end
+
     module ClassMethods
       def extended(base)
         base.class_attribute(:defined_params, instance_writer: false)
@@ -19,65 +21,77 @@ module ActiveRecord
     #--------------------------------------------------------------------------
 
     def exnum(definitions)
-      divided_definitions = definitions.inject({enums: {}, params: {}}) do |ret, (name, values)|
-        if !values.kind_of?(Hash)
-          ret[:enums][name]  = values
-        else
-          ret[:enums][name]  = extract_enums(name, values)
-          ret[:params][name] = extract_params(name, values)
+      enum_definitions = definitions.each_with_object({}) do |(name, values), ret|
+        ret[name] = extract_enums(values)
+      end
+      enum(enum_definitions)
+
+      pram_definitions = definitions.each_with_object({}) do |(name, values), ret|
+        next if %i[_prefix _suffix].include?(name)
+
+        ret[name] = extract_params(values)
+        self.send(name.to_s.pluralize).each do |k, v|
+          ret[name][k.to_sym] ||= {}
+          ret[name][k.to_sym][:val] = v
         end
-        ret
       end
 
-      enum(divided_definitions[:enums])
-      enum_i18n(divided_definitions[:enums])
-      enum_param(divided_definitions[:params])
+      enum_i18n(pram_definitions)
+      enum_param(pram_definitions)
+      enum_for_select(pram_definitions)
     end
 
-    #--------------------------------------------------------------------------
+    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
     private
-    def extract_enums(_name, values)
-      values.inject({}) do |ret, (field, value)|
+    def extract_enums(values)
+      return values unless values.kind_of?(Hash)
+
+      values.each_with_object({}) do |(field, value), ret|
         ret[field.to_sym] = (value.kind_of?(Hash) ? value[:val] : value)
-        ret
       end
     end
 
-    def extract_params(_name, values)
-      values.inject({}) do |ret, (field, value)|
-        if value.kind_of?(Hash)
-          ret[field.to_sym] = value.reject{|k, _| k == :val}
-        end
-        ret
+    def extract_params(values)
+      return {} unless values.kind_of?(Hash)
+
+      target_values = values.select{|_field, value| value.kind_of?(Hash)}
+      target_values.each_with_object({}) do |(field, value), ret|
+        ret[field.to_sym] = value
       end
     end
 
-    def enum_i18n(definitions)
-      klass = self
-      definitions.delete(:_prefix)
-      definitions.delete(:_suffix)
+    #--------------------------------------------------------------------------
 
+    def enum_i18n(definitions)
       definitions.each do |name, values|
+        enum_i18n_class_method(name, values)
+        enum_i18n_instance_method(name)
+      end
+    end
 
-        # define class method which returns i18n string of each satus
-        method_name = "#{name.to_s.pluralize}_i18n"
-        detect_enum_conflict!(name, method_name, true)
-        klass.singleton_class.send(:define_method, method_name) do
-          i18n_hash = ActiveSupport::HashWithIndifferentAccess.new
-          values.inject(i18n_hash) do |ret, (enum_name, _value)|
-            ret[enum_name] = i18n_string(klass, name, enum_name)
-            ret
-          end
+    # define class method which returns i18n string of each satus
+    def enum_i18n_class_method(name, values)
+      klass = self
+      method_name = "#{name.to_s.pluralize}_i18n"
+      detect_enum_conflict!(name, method_name, true)
+      klass.singleton_class.send(:define_method, method_name) do |&block|
+        i18n_hash = ActiveSupport::HashWithIndifferentAccess.new
+        values.each_with_object(i18n_hash) do |(enum_name, value), ret|
+          next if block.present? && !block.call(value)
+          ret[enum_name] = i18n_string(klass, name, enum_name)
         end
+      end
+    end
 
-        # define instance method which returns current i18n string of the instance
-        method_name = "#{name}_i18n"
-        detect_enum_conflict!(name, method_name, false)
-        klass.send(:define_method, method_name) do
-          status = self.send(name)
-          status.nil? ? nil : klass.send(:i18n_string, klass, name, status)
-        end
+    # define instance method which returns current i18n string of the instance
+    def enum_i18n_instance_method(name)
+      klass = self
+      method_name = "#{name}_i18n"
+      detect_enum_conflict!(name, method_name, false)
+      klass.send(:define_method, method_name) do
+        status = self.send(name)
+        status.nil? ? nil : klass.send(:i18n_string, klass, name, status)
       end
     end
 
@@ -85,6 +99,8 @@ module ActiveRecord
       I18n.t("#{klass.i18n_scope}.enum.#{klass.model_name.i18n_key}.#{name}.#{enum_name}")
     end
 
+    #--------------------------------------------------------------------------
+
     def enum_param(definitions)
       klass = self
       klass.defined_params.merge!(definitions)
@@ -92,29 +108,59 @@ module ActiveRecord
       definitions.each do |name, values|
         param_names = values.values.map(&:keys).flatten.uniq
         param_names.each do |param_name|
+          enum_param_class_method(name, values, param_name)
+          enum_param_instance_method(name, values, param_name)
+        end
+      end
+    end
 
-          # define class methods which returns the parameter's values of each status
-          method_name = "#{name}_#{param_name.to_s.pluralize}"
-          detect_enum_conflict!(name, method_name, true)
-          klass.singleton_class.send(:define_method, method_name) do
-            param_hash = ActiveSupport::HashWithIndifferentAccess.new
-            values.inject(param_hash) do |ret, (enum_name, params)|
-              ret[enum_name] = params[param_name]
-              ret
-            end
-          end
-
-          # define instance methods which returns the parameter's current value of the instance
-          method_name = "#{name}_#{param_name}"
-          detect_enum_conflict!(name, method_name, false)
-          define_method(method_name) do
-            status = self.send(name)
-            return if status.nil?
-            defined_params[name][status.to_sym][param_name]
-          end
+    # define class methods which returns the parameter's values of each status
+    def enum_param_class_method(name, values, param_name)
+      klass = self
+      method_name = "#{name}_#{param_name.to_s.pluralize}"
+      detect_enum_conflict!(name, method_name, true)
+      klass.singleton_class.send(:define_method, method_name) do |&block|
+        param_hash = ActiveSupport::HashWithIndifferentAccess.new
+        values.each_with_object(param_hash) do |(enum_name, params), ret|
+          next if block.present? && !block.call(params)
+          ret[enum_name] = params[param_name]
         end
       end
     end
+
+    # define instance methods which returns the parameter's current value of the instance
+    def enum_param_instance_method(name, values, param_name)
+      method_name = "#{name}_#{param_name}"
+      detect_enum_conflict!(name, method_name, false)
+      define_method(method_name) do
+        status = self.send(name)
+        return if status.nil?
+        defined_params[name][status.to_sym][param_name]
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+    def enum_for_select(definitions)
+      definitions.each do |name, values|
+        param_names = values.values.map(&:keys).flatten.uniq
+        param_names.each do |param_name|
+          enum_for_select_class_method(name, values, param_name)
+        end
+      end
+    end
+
+    # define class methods which returns the array for select box
+    def enum_for_select_class_method(name, values, param_name)
+      klass = self
+      method_name = "#{name.to_s.pluralize}_for_select"
+      detect_enum_conflict!(name, method_name, true)
+      klass.singleton_class.send(:define_method, method_name) do |&block|
+        i18n_hash = klass.send("#{name.to_s.pluralize}_i18n", &block)
+        i18n_hash.to_a.map(&:reverse)
+      end
+    end
+
   end
 end
 

data/lib/exnum/version.rb

@@ -1,3 +1,3 @@
 module Exnum
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: exnum
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kta-M
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2019-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: codeclimate-test-reporter
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -116,9 +116,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -149,8 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Enum extention for Rails

data/.travis.yml

@@ -1,6 +0,0 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.3.1
-before_install: gem install bundler -v 1.12.5
-script: CODECLIMATE_REPO_TOKEN=9eff3c4d9a268cc72972edde460103ef26b162565dafa64ef5b86649fd43427f bundle exec rake