enum_ext 0.4.6 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa096cf9f003cabf942dc6b30f2e172c5e3c4b3be881be0d487c0b34ec866b7a
-  data.tar.gz: b855d89b03d51c9554f4aa1d48fce352edba462a3866d5bfafc8196b1fd06c5d
+  metadata.gz: e43e1644acff1729643340c16a085e015c66a76949a313fe3d95c229261fe165
+  data.tar.gz: a5ccf00bf5bdc65d3e26d0d115e52dad86afe41cab4e71c5758ee43cbf9ff31f
 SHA512:
-  metadata.gz: 2bc5e06d1cdc9bdb2713659d2d5027b2c4807bad9f96d4e7378a1e4166cc2e14de1b7cc19391f8f42caf9a2392b4d16577c3274b77e0eb230fa92b75aeaf9cdd
-  data.tar.gz: c63f0b0557d1645e9ad267099291c75aab6dada2bae50555e8920786af885526ea8d98b8cc7d6e3125b5ebf855461d2f364600a855241792f06c2309d5502f08
+  metadata.gz: d521069cf6f12ee8ed5117a3a521fdc6f4c7e5e7e798a8fea32efaa28ebe549bf23c6e939f15ff0857b193a3162bfa386e8b5784e3f9b69fdabf861a22701a99
+  data.tar.gz: 263fe623bce43c3f1da806ef0904d36494918f1d168c77a1197e181337bd0d88cf51e30a0850b501d42156402a0131aa10ba5688026b5e1d09e7633bb2b1610c

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+# 0.5.0
+* with/without definitions will go standalone now, you need explicitly address them. Ex:
+```
+  multi_enum_scopes :test_type
+# OR
+  enum test_type: [..], ext: [:multi_enum_scopes]
+```
+* easier supersets definitions, no raw level class methods and multiple method call needed anymore for additive supersets:
+
+```ruby
+  ext_enum_sets :test_type, raw_level: [:unit_test, :spec]
+  ext_enum_sets :test_type,
+                fast: raw_level_test_types | [:controller]
+# Now it could be defined like this: 
+  ext_enum_sets :test_type, 
+                raw_level: [:unit_test, :spec],
+                fast: [:raw_level, :controller]
+```
+ Rem you still need couple `ext_enum_sets` calls if you want to use (`-` / `&` / `^`) array operators except for (`+` / `|`) 
+
+* Definitions now stored as IndifferentHash just as enum originally does 
+  and as an Array of strings not a symbols even if defined as ones
+* Some deprecations warning added
+
 # 0.4.6
 * allows enum to enable simple helpers directly at enum definition. Ex: 
 ```

data/README.md

@@ -22,19 +22,22 @@ Or install it yourself as:
  To use enum extension extend main model class with EnumExt module, 
  and customize your enums the way you need:
  
-    class SomeModel
-      extend EnumExt
+```ruby
       
-      enum_i ...
-      humanize_enum ...
-      translate_enum ...
-      ext_enum_sets ...
-      mass_assign_enum ...
+   class SomeModel
+      extend EnumExt
+    
+      enum kinds: {}, ext: [:enum_i, :enum_mass_assign, ]
+        humanize_enum #...
+        translate_enum #...
+        ext_enum_sets #...
     end
+```
  
  Let's assume that we have model Request representing some buying requests with enum **status**, and we have model Order with requests, 
  representing single purchase, like this:
 
+```ruby
      class Request
        extend EnumExt
        belongs_to :order
@@ -44,6 +47,7 @@ Or install it yourself as:
      class Order
        has_many :requests
      end
+```
 
  Now let's review some examples of possible enum extensions
 
@@ -51,19 +55,18 @@ Or install it yourself as:
   
   if app doesn't need internationalization, it may use humanize_enum to make enum user friendly
 
-  ```  
+```ruby
   humanize_enum :status, {
       #locale dependent example with pluralization and lambda:
-      in_cart: -> (t_self) { I18n.t("request.status.in_cart", count: t_self.sum ) }
+      in_cart: -> (t_self) { I18n.t("request.status.in_cart", count: t_self.sum ) },
   
       #locale dependent example with pluralization and proc:
-      paid: Proc.new{ I18n.t("request.status.paid", count: self.sum ) }
+      paid: Proc.new{ I18n.t("request.status.paid", count: self.sum ) },
   
       #locale independent:
       ready_for_shipment: "Ready to go!"
     }
-  end
-  ```  
+```  
    
   This humanize_enum adds to instance:
    - t_in_cart, t_paid, t_ready_for_shipment
@@ -76,28 +79,28 @@ Or install it yourself as:
   
   Example with block:
 
-  ```
-  humanize_enum :status do
-   I18n.t("scope.#{status}")
-  end
+  ```ruby
+      humanize_enum :status do
+       I18n.t("scope.#{status}")
+      end
   ```
   
   Example for select:
   
-  ```
+  ```ruby
     f.select :status, Request.t_statuses_options
   ```
   
   in Active Admin filters
-  ```
+  ```ruby
     filter :status, as: :select, label: 'Status', collection: Request.t_statuses_options_i
   ```
  
   
-  Rem: select options may break when using lambda() or proc with instance method, but will survive with block
+  **Rem:** select options may break when using lambda() or proc with instance method, but will survive with block
   
   Console:
-  ```
+  ```ruby
     request.sum = 3
     request.paid!
     request.status     # >> paid
@@ -110,47 +113,55 @@ Or install it yourself as:
 ### Translate (translate_enum) 
 
 Enum is translated using scope 'active_record.attributes.class_name_underscore.enum_plural', or the given one:
-
-       translate_enum :status, 'active_record.request.enum'
-
+```ruby
+   translate_enum :status, 'active_record.request.enum'
+```
 Or it can be done with block either with translate or humanize:
-        
-       translate_enum :status do 
-         I18n.t( "active_record.request.enum.#{status}" )
-       end
 
-### Enum to_i shortcut ( enum_i )
+```ruby
+   translate_enum :status do 
+     I18n.t( "active_record.request.enum.#{status}" )
+   end
+```
 
-Defines method enum_name_i shortcut for Model.enum_names[elem.enum_name]
+### Enum to_i shortcut ( enum_i )
+Defines method enum_name_i shortcut for Model.enum_names[elem.enum_name] or enum_name_before_type_cast
 
 **Ex** 
-  enum_i :status
-  ...
+```ruby
+  enum status: [:in_cart, :waiting_for_payment, :paid, :ready_for_shipment, :on_delivery, :delivered],
+       ext: [:enum_i]
+# some place else:
   request.paid_i # 10
-  
+```
 
 ### Enum Sets (ext_enum_sets)
  
- **Use-case** For example you have pay bills of different types, and you want to group some types in debit and credit "super-types", 
- and have scope PayBill.debit, instance method with question mark as usual enum does pay_bill.debit?.
+ **Use-case** whenever you need superset of enums to behave like a enum.
  
- You can do this with method **ext_enum_sets** it creates:  scopes for subsets, instance method with ? and some class methods helpers
+ You can do this with method **ext_enum_sets** it creates: 
+   - scopes for subsets, 
+   - instance methods with `?` 
+   - and some class methods helpers
    
-   For this call:
-   ```
-     ext_enum_sets :status, {
-                     delivery_set: [:ready_for_shipment, :on_delivery, :delivered] # for shipping department for example
-                     in_warehouse: [:ready_for_shipment]  # this just for superposition example  below
-                   }
-   ```
+   For instance:
+
+```ruby
+    ext_enum_sets :status, {
+        delivery_set: [:ready_for_shipment, :on_delivery, :delivered], # for shipping department for example
+        in_warehouse: [:ready_for_shipment]  
+    }
+```
+
 it will generate:
+
 ```
 instance:
     - methods: delivery_set?, in_warehouse?
 
 class:
     - named scopes: delivery_set, in_warehouse
-    - parametrized scopes: with_statuses, without_statuses
+    - parametrized scopes: with_statuses, without_statuses ( available as a standalone extension now, and will not be included by default in a versionafter 0.5.0)
     class helpers:
         - delivery_set_statuses (=[:ready_for_shipment, :on_delivery, :delivered] ), in_warehouse_statuses
         - delivery_set_statuses_i (= [3,4,5]), in_warehouse_statuses_i (=[3])
@@ -160,32 +171,45 @@ class:
         - t_delivery_set_statuses_options_i (= [['translation or humanization', 3] ...]) same as above but with integer as value ( for example to use in Active admin filters )
 ```
 
- ```
-   Console:
+ ```ruby
     request.on_delivery!
     request.delivery_set?                    # >> true
- 
+    
     Request.delivery_set.exists?(request)    # >> true
     Request.in_warehouse.exists?(request)    # >> false
-   
-    Request.delivery_set_statuses            # >> [:ready_for_shipment, :on_delivery, :delivered]
-   
-    Request.with_statuses( :payed, :delivery_set )    # >> :payed and [:ready_for_shipment, :on_delivery, :delivered] requests
-    Request.without_statuses( :payed )                # >> scope for all requests with statuses not eq to :payed
-    Request.without_statuses( :payed, :in_warehouse ) # >> scope all requests with statuses not eq to :payed or :ready_for_shipment
- ```  
- 
-   Rem:
-    ext_enum_sets can be called twice defining a superposition of already defined sets ( considering previous example ):
     
+    Request.delivery_set_statuses            # >> ["ready_for_shipment", "on_delivery", "delivered"]
+```
+Rem:
+ext_enum_sets can be called multiple times defining a superposition of already defined sets ( considering previous example ):
+
+```ruby
+ ext_enum_sets :status, {
+   outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )#... any other array operations like &, + and so can be used
+ }
 ```
+
+Rem: you can refer previously defined set as usual kind in the same method call:
+    
+```ruby
     ext_enum_sets :status, {
-                outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )... any other array operations like &, + and so can be used
-              }
+        delivery_set: [:ready_for_shipment, :on_delivery, :delivered],
+        not_in_cart: [:paid, :delivery_set] #
+    }
 ```
 
- 
-### Mass-assign ( mass_assign_enum )
+### Multi enum scopes
+
+```ruby
+  enum status: [:in_cart, :waiting_for_payment, :paid, :ready_for_shipment, :on_delivery, :delivered],
+       ext: [:multi_enum_scopes]
+
+# some place else:
+    Request.with_statuses( :payed, :delivery_set )    # >> status IN (:payed, :ready_for_shipment, :on_delivery, :delivered) 
+    Request.without_statuses( :payed, :in_warehouse ) # >> status NOT IN (:payed, :ready_for_shipment)
+``` 
+
+### Mass-assign ( enum_mass_assign )
  
  Syntax sugar for mass-assigning enum values. 
  
@@ -194,23 +218,25 @@ class:
     some_scope.update_all(status: Request.statuses[:new_status], update_at: Time.now)
  ```
  If you need callbacks you can do like this: some_scope.each(&:new_stat!) but if you don't need callbacks and you 
- have hundreds and thousands of records to change at once you need update_all
+ have hundreds and thousands of records to change at once you better call update_all
 
- ```
-    mass_assign_enum( :status )
+ ```ruby
+   enum status: [:in_cart, :waiting_for_payment, :paid, :ready_for_shipment, :on_delivery, :delivered],
+        ext: [:mass_assign_enum]
  ```
 
  Console:
 
-```
+```ruby
     request1.in_cart!
     request2.waiting_for_payment!
-    Request.non_paid.paid!
-    request1.paid?                         # >> true
-    request2.paid?                         # >> true
+    Request.not_paid.paid!
+   
+    request1.reload.paid?                          # >> true
+    request2.paid?                          # >> true
     request1.updated_at                     # >> ~ Time.now
     
-    order.requests.already_paid.count          # >> N
+    order.requests.already_paid.count           # >> N
     order.requests.delivered.count              # >> M
     order.requests.already_paid.delivered!
     order.requests.already_paid.count          # >> 0

data/lib/enum_ext/version.rb

@@ -1,3 +1,3 @@
 module EnumExt
-  VERSION = "0.4.6"
+  VERSION = "0.5.0"
 end

data/lib/enum_ext.rb

@@ -1,4 +1,5 @@
-require 'enum_ext/version'
+require "enum_ext/version"
+require "enum_ext/humanize"
 
 # Let's assume we have model Request with enum status, and we have model Order with requests like this:
 # class Request
@@ -10,22 +11,78 @@ require 'enum_ext/version'
 # class Order
 #   has_many :requests
 # end
-#
+
+puts <<~DEPRECATION
+  ---------------------DEPRECATION WARNING---------------------------
+  There are TWO MAJOR breaking changes coming into the next version :
+  First deprecation: all major DSL moving major class methods to 
+  enum, just for the sake of clarity:  
+
+  Ex for enum named kinds it could look like this: 
+
+    Class.ext_sets_to_kinds         --> Class.kinds.set_to_basic
+    Class.ext_kinds                 --> Class.kinds.sets
+    Class.all_kinds_defs            --> Class.kinds.all
+    Class.t_kinds_options           --> Class.kinds.t_options
+    Class.t_named_set_kinds_options --> Class.kinds.t_named_set_options
+  
+  Enum extensions preferable way will be using param to original enum call:
+  Ex:
+    #Instead of three method calls:    
+    enum kind: {}
+    enum_i :kind
+    enum_mass_assign :kind
+
+    #You should go with ext  option instead:
+    enum kinds: {}, ext: [:enum_i, :enum_mass_assign]
+DEPRECATION
+
 module EnumExt
 
+  class << self
+    def define_set_to_enum_method( extended_class, enum_plural)
+      #  ext_sets_to_kinds( :ready_for_shipment, :delivery_set ) --> [:ready_for_shipment, :on_delivery, :delivered]
+      extended_class.define_singleton_method("ext_sets_to_#{enum_plural}") do |*enum_or_sets|
+        return [] if enum_or_sets.blank?
+        enum_or_sets_strs = enum_or_sets.map(&:to_s)
+
+        next_level_deeper = try("ext_#{enum_plural}").slice( *enum_or_sets_strs ).values.flatten
+        (enum_or_sets_strs & send(enum_plural).keys | send("ext_sets_to_#{enum_plural}", *next_level_deeper)).uniq
+      end
+    end
+
+    def define_summary_methods(extended_class, enum_plural)
+      extended_class.define_singleton_method("ext_#{enum_plural}") do
+        @enum_ext_summary ||= ActiveSupport::HashWithIndifferentAccess.new
+      end unless respond_to?("ext_#{enum_plural}")
+
+      extended_class.define_singleton_method("all_#{enum_plural}") do
+        {
+          **send(enum_plural),
+          "ext_#{enum_plural}": {
+            **send("ext_#{enum_plural}")
+          }
+        } unless respond_to?("all_#{enum_plural}")
+      end
+    end
+  end
+
   # extending enum with inplace settings
-  # enum status: {}, ext: [:enum_i, :mass_assign_enum]
+  # enum status: {}, ext: [:enum_i, :mass_assign_enum, :enum_multi_scopes]
   # enum_i and mass_assign_enum ara
   def enum(definitions)
     extensions = definitions.delete(:ext)
-    super(definitions)
-    definitions.each do |name,|
-      [*extensions].each{|ext_method| send(ext_method, name) }
+
+    super(definitions).tap do
+      definitions.each do |name,|
+        [*extensions].each{|ext_method| send(ext_method, name) }
+      end
     end
   end
 
-  # defines shortcut for getting integer value of enum.
+  # Defines instance method a shortcut for getting integer value of an enum.
   # for enum named 'status' will generate:
+  #
   # instance.status_i
   def enum_i( enum_name )
     define_method "#{enum_name}_i" do
@@ -33,9 +90,35 @@ module EnumExt
     end
   end
 
+  # Defines two scopes for one for an inclusion: `WHERE enum IN( enum1, enum2 )`,
+  # and the second for an exclusion: `WHERE enum NOT IN( enum1, enum2 )`
+  #
+  # Ex:
+  #  Request.with_statuses( :payed, :delivery_set )    # >> :payed and [:ready_for_shipment, :on_delivery, :delivered] requests
+  #  Request.without_statuses( :payed )                # >> scope for all requests with statuses not eq to :payed
+  #  Request.without_statuses( :payed, :in_warehouse ) # >> scope all requests with statuses not eq to :payed or :ready_for_shipment
+  def multi_enum_scopes(enum_name)
+    enum_plural = enum_name.to_s.pluralize
+
+    self.instance_eval do
+      # with_enums scope
+      scope "with_#{enum_plural}", -> (*enum_list) {
+        where( enum_name => send("ext_sets_to_#{enum_plural}", enum_list) )
+      } if !respond_to?("with_#{enum_plural}") && respond_to?(:scope)
+
+      # without_enums scope
+      scope "without_#{enum_plural}", -> (*enum_list) {
+        where.not( enum_name => send("ext_sets_to_#{enum_plural}", enum_list) )
+      } if !respond_to?("without_#{enum_plural}") && respond_to?(:scope)
+
+      EnumExt.define_set_to_enum_method(self, enum_plural)
+      EnumExt.define_summary_methods(self, enum_plural)
+    end
+  end
 
   # ext_enum_sets
   # This method intend for creating and using some sets of enum values
+  #
   # it creates: scopes for subsets,
   #             instance method with ?,
   #             and some class methods helpers
@@ -69,53 +152,44 @@ module EnumExt
   #  Request.in_warehouse.exists?(request)    # >> false
   #
   #  Request.delivery_set_statuses            # >> [:ready_for_shipment, :on_delivery, :delivered]
-  #
-  #  Request.with_statuses( :payed, :delivery_set )    # >> :payed and [:ready_for_shipment, :on_delivery, :delivered] requests
-  #  Request.without_statuses( :payed )                # >> scope for all requests with statuses not eq to :payed
-  #  Request.without_statuses( :payed, :in_warehouse ) # >> scope all requests with statuses not eq to :payed or :ready_for_shipment
-  #
 
   #Rem:
   #  ext_enum_sets can be called twice defining a superposition of already defined sets ( considering previous example ):
   #  ext_enum_sets :status, {
-  #                  outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )... any other array operations like &, + and so can be used
+  #                  outside_warehouse: ( delivery_set_statuses - in_warehouse_statuses )... any other array operations like &, + and so can be used
   #                }
   def ext_enum_sets( enum_name, options = {} )
     enum_plural = enum_name.to_s.pluralize
 
     self.instance_eval do
-      define_singleton_method("ext_#{enum_plural}") do
-        @enum_ext_summary ||= {}
-      end unless respond_to?("ext_#{enum_plural}")
-
-      send("ext_#{enum_plural}").merge!( options )
+      EnumExt.define_set_to_enum_method(self, enum_plural)
+      EnumExt.define_summary_methods(self, enum_plural)
 
-      # with_enums scope
-      scope "with_#{enum_plural}", -> (sets_arr) {
-        where( enum_name => self.send( enum_plural ).slice(
-          *sets_arr.map{|set_name| self.try( "#{set_name}_#{enum_plural}" ) || set_name }.flatten.uniq.map(&:to_s) ).values )
-      } if !respond_to?("with_#{enum_plural}") && respond_to?(:scope)
+      puts(<<~DEPRECATION) unless respond_to?("with_#{enum_plural}")
+        ----------------DEPRECATION WARNING----------------
+        - with/without_#{enum_plural} are served now via multi_enum_scopes method, 
+          and will be removed from the ext_enum_sets in the next version!
+      DEPRECATION
+      multi_enum_scopes(enum_name)
 
-      # without_enums scope
-      scope "without_#{enum_plural}", -> (sets_arr) {
-        where.not( id: self.send("with_#{enum_plural}", sets_arr) )
-      } if !respond_to?("without_#{enum_plural}") && respond_to?(:scope)
+      send("ext_#{enum_plural}").merge!( options.transform_values{ _1.map(&:to_s) } )
 
       options.each do |set_name, enum_vals|
         # set_name scope
-        scope set_name, -> { where( enum_name => self.send( enum_plural ).slice( *enum_vals.map(&:to_s) ).values ) } if respond_to?(:scope)
+        scope set_name, -> { where( enum_name => send("#{set_name}_#{enum_plural}") ) } if respond_to?(:scope)
 
-          # class.enum_set_values
+        # class.enum_set_values
         define_singleton_method( "#{set_name}_#{enum_plural}" ) do
-          enum_vals
+          send("ext_sets_to_#{enum_plural}", *enum_vals)
         end
 
-        # class.enum_set_enums_i
-        define_singleton_method( "#{set_name}_#{enum_plural}_i" ) do
-          self.send( "#{enum_plural}" ).slice( *self.send("#{set_name}_#{enum_plural}") ).values
+        # instance.set_name?
+        define_method "#{set_name}?" do
+          send(enum_name) && self.class.send( "#{set_name}_#{enum_plural}" ).include?( send(enum_name) )
         end
 
         # t_... - are translation dependent methods
+        # This one is a narrow case helpers just a quick subset of t_ enums options for a set
         # class.t_enums_options
         define_singleton_method( "t_#{set_name}_#{enum_plural}_options" ) do
           return [["Enum translations call missed. Did you forget to call translate #{enum_name}"]*2] unless respond_to?( "t_#{enum_plural}_options_raw" )
@@ -130,28 +204,25 @@ module EnumExt
           send("t_#{enum_plural}_options_raw_i", send("t_#{set_name}_#{enum_plural}") )
         end
 
-        # instance.set_name?
-        define_method "#{set_name}?" do
-          self.send(enum_name) && ( enum_vals.include?( self.send(enum_name) ) || enum_vals.include?( self.send(enum_name).to_sym ))
-        end
-
         # protected?
-        # class.t_setname_enums ( translations or humanizations subset for a given set )
+        # class.t_set_name_enums ( translations or humanizations subset for a given set )
         define_singleton_method( "t_#{set_name}_#{enum_plural}" ) do
           return [(["Enum translations call missed. Did you forget to call translate #{enum_name}"]*2)].to_h unless respond_to?( "t_#{enum_plural}" )
 
-          send( "t_#{enum_plural}" ).slice( *self.send("#{set_name}_#{enum_plural}") )
+          send( "t_#{enum_plural}" ).slice( *send("#{set_name}_#{enum_plural}") )
         end
       end
     end
   end
 
   # Ex mass_assign_enum
+  #
   # Used for mass assigning for collection without callbacks it creates bang methods for collections using update_all.
   # it's often case when you need bulk update without callbacks, so it's gets frustrating to repeat:
   # some_scope.update_all(status: Request.statuses[:new_status], update_at: Time.now)
-  # If you need callbacks you can do like this: some_scope.each(&:new_stat!) but if you don't need callbacks and you have lots of records
-  # to change at once you need update_all
+  #
+  # If you need callbacks you can do like this: some_scope.each(&:new_stat!) but if you don't need callbacks
+  # and you have lots of records to change at once you need update_all
   #
   #  mass_assign_enum( :status )
   #
@@ -162,14 +233,13 @@ module EnumExt
   # request1.in_cart!
   # request2.waiting_for_payment!
   # Request.with_statuses( :in_cart, :waiting_for_payment ).payed!
-  # request1.paid?                         # >> true
-  # request2.paid?                         # >> true
+  # request1.paid?                          # >> true
+  # request2.paid?                          # >> true
   # request1.updated_at                     # >> Time.now
-  # defined?(Request::MassAssignEnum)      # >> true
   #
-  # order.requests.paid.all?(&:paid?) # >> true
+  # order.requests.paid.all?(&:paid?)       # >> true
   # order.requests.paid.delivered!
-  # order.requests.map(&:status).uniq                   #>> [:delivered]
+  # order.requests.map(&:status).uniq       #>> [:delivered]
 
   def mass_assign_enum( *enums_names )
     enums_names.each do |enum_name|
@@ -182,10 +252,12 @@ module EnumExt
       end
     end
   end
+  alias_method :enum_mass_assign, :mass_assign_enum
 
   # if app doesn't need internationalization, it may use humanize_enum to make enum user friendly
+  #
   # class Request
-  # humanize_enum :status, {
+  #   humanize_enum :status, {
   #     #locale dependent example with pluralization and lambda:
   #     payed: -> (t_self) { I18n.t("request.status.payed", count: t_self.sum ) }
   #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_ext
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.5.0
 platform: ruby
 authors:
 - alekseyl
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-04 00:00:00.000000000 Z
+date: 2023-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord