enum_ext 0.5.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3be0377b4cba2aee0f9ee1fbb19e5efa6c824b0e5965eefca3ea7de7108df363
-  data.tar.gz: c7a15c944f6598129b29f0ab61f3650a251af242111d90b056f86677fdf51780
+  metadata.gz: 8d99346b1ae5f9458733025608cad6e8a1ab427091ce44d10a544e880722633c
+  data.tar.gz: 6a1943ddedaa37022bdfe421dbc4c5d063c63149a96aaa0f05cdab35f423de6b
 SHA512:
-  metadata.gz: d920ca2ae630226a778ba83144115f360b97c4e9e52759ecc05aae77fd095fe806912ef81c01fe6750031f700c6e2d9c9511a4c7164897ce6ac3ccf86479a365
-  data.tar.gz: 4433d920ae0ec84e9ad33b6c728a238462f0884b7ce9c693143c06f0a41def984bc25ade651c7c4cdd1d15b32e8229b9deb6a13ba6059885dc9d5d216b591086
+  metadata.gz: ce540db8aca9002c6a46a5ae5eb7a45f7a296d4fd183493a8796e3b9dd007ebb04bc0793b1162b82e177de5b59ff06e8e553248a2aa4c725b17d3570d682444f
+  data.tar.gz: 7db85461bd47c03b3169259f699a29e7a1855fd791d53fb4fe84995b812739fe4968b8184665dfd04230b71e2d78152dc8868f78f89452f37d6b20ed00c77ecc

data/CHANGELOG.md

@@ -1,6 +1,25 @@
+# 0.8.0
+* Methods annotations added:
+  * Full descriptions: Class.enum.describe(short=true) / Class.enum.describe_short / Class.enum.describe_long / Class.enum.describe_basic
+  * Per-methods: Class.enum.describe_enum_i, describe_mass_assign_enum, describe_multi_enum_scopes e.t.c.
+* method Class.enum.supersets_raw added, it will return supersets decompositions to basic enum
+* Class.enum.all method now returns basic enum_values + supersets_raw decomposition to basic enums ( previously was a supersets i.e. high level definition )
+
+# 0.7.0 
+* rails 7 syntax support added
+* massive test process refactoring docker with both rails 7 and earlier support
+* simple translate_enum allowed via `ext: [:translate_enum]`
+
+# 0.6.0 (BREAKING CHANGES)
+* fixed issue with non array superset
+* standard helpers are now private, you should use enum_ext / enum , ext: []  approach to the definitions
+* class.superset_statuses moved to enum_obj -> class.statuses.superset_statuses
+* massive ReadMe refactoring
+
 # 0.5.3
 * refactored tests
 * multi_enum_scopes will be chainable with empty params (i.e. will not change the scope)
+* some development dependencies were added
 
 # 0.5.2
 * removed unused require from the upcoming version 

data/Dockerfile

@@ -0,0 +1,22 @@
+FROM ruby:3.0.3-bullseye
+
+WORKDIR /app
+#RUN  apt-get update && apt-get -y install lsb-release
+##
+#RUN wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add - && \
+#    sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list' && \
+#    apt-get update && apt-get -y install postgresql postgresql-client-12
+#
+#RUN sh -c 'echo "local   all             all                                     trust" > /etc/postgresql/14/main/pg_hba.conf' && \
+#    service postgresql start && \
+#    psql -U postgres -c 'CREATE DATABASE "niceql-test"'
+
+RUN  gem install bundler
+
+COPY lib/enum_ext/version.rb /app/lib/enum_ext/version.rb
+COPY enum_ext.gemspec /app/
+COPY Gemfile_rails_6 /app/Gemfile
+COPY Gemfile_rails_6.lock /app/Gemfile.lock
+COPY Rakefile /app/
+#
+RUN bundle install

data/Dockerfile_rails_7

@@ -0,0 +1,25 @@
+FROM ruby:3.0.3-bullseye
+
+WORKDIR /app
+#RUN  apt-get update && apt-get -y install lsb-release
+##
+#RUN wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add - && \
+#    sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list' && \
+#    apt-get update && apt-get -y install postgresql postgresql-client-12
+#
+#RUN sh -c 'echo "local   all             all                                     trust" > /etc/postgresql/14/main/pg_hba.conf' && \
+#    service postgresql start && \
+#    psql -U postgres -c 'CREATE DATABASE "niceql-test"'
+
+RUN  gem install bundler
+
+
+RUN  gem install bundler
+
+COPY lib/enum_ext/version.rb /app/lib/enum_ext/version.rb
+COPY enum_ext.gemspec /app/
+COPY Gemfile_rails_7 /app/Gemfile
+COPY Gemfile_rails_7.lock /app/Gemfile.lock
+COPY Rakefile /app/
+
+RUN bundle install

data/{Gemfile → Gemfile_rails_6}

@@ -3,3 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in enum_ext.gemspec
 gemspec
 
+gem 'activerecord', "<7"

data/{Gemfile.lock → Gemfile_rails_6.lock}

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    enum_ext (0.5.2)
+    enum_ext (0.8.0)
       activerecord (>= 5.2.4.3)
 
 GEM
@@ -94,4 +94,4 @@ DEPENDENCIES
   stubberry
 
 BUNDLED WITH
-   2.1.4
+   2.4.17

data/Gemfile_rails_7

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in enum_ext.gemspec
+gemspec
+
+gem 'activerecord', ">=7"

data/Gemfile_rails_7.lock

@@ -0,0 +1,102 @@
+PATH
+  remote: .
+  specs:
+    enum_ext (0.8.0)
+      activerecord (>= 5.2.4.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (7.0.6)
+      actionview (= 7.0.6)
+      activesupport (= 7.0.6)
+      rack (~> 2.0, >= 2.2.4)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (7.0.6)
+      activesupport (= 7.0.6)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activemodel (7.0.6)
+      activesupport (= 7.0.6)
+    activerecord (7.0.6)
+      activemodel (= 7.0.6)
+      activesupport (= 7.0.6)
+    activesupport (7.0.6)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    amazing_print (1.5.0)
+    builder (3.2.4)
+    byebug (11.1.3)
+    concurrent-ruby (1.2.2)
+    crass (1.0.6)
+    erubi (1.12.0)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    loofah (2.21.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    method_source (1.0.0)
+    minitest (5.18.1)
+    niceql (0.6.1)
+    nokogiri (1.15.3-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.3-x86_64-linux)
+      racc (~> 1.4)
+    racc (1.7.1)
+    rack (2.2.7)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rails-dom-testing (2.1.1)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    rails-i18n (7.0.7)
+      i18n (>= 0.7, < 2)
+      railties (>= 6.0.0, < 8)
+    rails_sql_prettifier (7.0.4)
+      activerecord (>= 7)
+      niceql (~> 0.6)
+    railties (7.0.6)
+      actionpack (= 7.0.6)
+      activesupport (= 7.0.6)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rake (13.0.6)
+    sqlite3 (1.6.3-x86_64-darwin)
+    sqlite3 (1.6.3-x86_64-linux)
+    stubberry (0.3.0)
+    thor (1.2.2)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.6.8)
+
+PLATFORMS
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  activerecord (>= 7)
+  amazing_print
+  bundler (>= 1.11)
+  byebug
+  enum_ext!
+  minitest
+  rails-i18n (>= 4)
+  rails_sql_prettifier
+  rake (>= 10.0)
+  sqlite3
+  stubberry
+
+BUNDLED WITH
+   2.4.17

data/README.md

@@ -7,7 +7,7 @@ EnumExt extends rails enum with localization/translation and it's helpers, mass-
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'enum_ext', '~> 0.3'
+gem 'enum_ext', '~> 0.7'
 ```
 
 And then execute:
@@ -49,7 +49,41 @@ Or install it yourself as:
      end
 ```
 
- Now let's review some examples of possible enum extensions
+## Inline definitions. Starting 0.5.0!! BREAKING CHANGES!
+
+Starting version 0.4.6, for concise and clearer code base, you can activate most of the extensions during enum definition, using `ext: [...]` notation.
+This is a preferable way now, and old helpers are private starting version 0.6!:
+
+```ruby
+    #Instead of three method calls:    
+    enum kind: {}
+    enum_i :kind # will raise an private method error starting ver 0.6
+    enum_mass_assign :kind # will raise an private method error starting ver 0.6
+
+    #You should go with ext  option instead:
+    enum kinds: {}, ext: [:enum_i, :enum_mass_assign]
+
+    # OR in case of standalone enum definition:
+    enum kinds: {} # somewhere where you can't or don't want reach 
+    enum_ext :kinds, [:enum_i, :enum_mass_assign, enum_supersets: {} ]
+```
+Rem: enum_ext could be called multiple times and merge later definitions, though I can't imagine why would you split it to multiple calls. 
+
+Rem: The only exceptions for the new syntax are full translation/humanization helpers definitions. 
+     Those will not add any clarity to code, and should be used via standalone helpers. 
+     But standard translate_enum without definitions still welcome:
+
+```ruby
+# GOOD: 
+  enum_ext :kinds, [:enum_i, :enum_mass_assign, :translate_enum, enum_supersets: {}]
+
+# BAD (even if correctly defines internationalization): 
+  enum_ext :kinds, [:enum_i, :enum_mass_assign, :translate_enum, enum_supersets: {}] do
+    I18n.t("scope.#{kind}")
+  end
+```
+
+## Humanization and localization
 
 ### Humanization (humanize_enum) 
   
@@ -81,7 +115,7 @@ Or install it yourself as:
 
   ```ruby
       humanize_enum :status do
-       I18n.t("scope.#{status}")
+        I18n.t("scope.#{status}")
       end
   ```
   
@@ -95,7 +129,6 @@ Or install it yourself as:
   ```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
   
@@ -113,6 +146,7 @@ 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:
+
 ```ruby
    translate_enum :status, 'active_record.request.enum'
 ```
@@ -124,7 +158,10 @@ Or it can be done with block either with translate or humanize:
    end
 ```
 
+## Enum extended functionality
+
 ### 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** 
@@ -135,22 +172,30 @@ Defines method enum_name_i shortcut for Model.enum_names[elem.enum_name] or enum
   request.paid_i # 10
 ```
 
-### Enum Sets (ext_enum_sets)
+### Enum SuperSets (enum_supersets)
  
- **Use-case** whenever you need superset of enums to behave like a enum.
+ **Use-case** whenever you need superset of enums to behave like a super enum.
  
- You can do this with method **ext_enum_sets** it creates: 
+ You can do this with method **enum_supersets** it creates: 
    - scopes for subsets, 
    - instance methods with `?` 
-   - and some class methods helpers
    
    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]  
-    }
+     enum status: [:in_cart, :waiting_for_payment, :paid, :packing, :ready_for_shipment, :on_delivery, :delivered],
+          ext: [enum_supersets: {
+                  delivery_set: [:ready_for_shipment, :on_delivery], # for shipping department for example
+                  in_warehouse: [:packing, :ready_for_shipment],    # this scope is just for superposition example below
+                  sold: [:paid, :delivery_set, :in_warehouse, :delivered] # also you can define any superposition of already defined supersets or enum values
+                }]
+
+     # supersets will be stored inside enum wrapper object, and can be de-referenced to basic enum values 
+     # using wrapper defined methods: "superset_enum_plural", i.e. statuses.sold_statuses -> [:paid, :packing, :ready_for_shipment, :on_delivery, :delivered]
+     # so new supersets could be defined using Array operations against newly defined methods
+     enum_ext :status, enum_supersets: {
+                    outside_warehouse: ( statuses.delivery_set_statuses - statuses.in_warehouse_statuses ) #... any other array operations like &, + and so can be used
+                  }
 ```
 
 it will generate:
@@ -162,13 +207,17 @@ instance:
 class:
     - named scopes: delivery_set, in_warehouse
     - 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])
 
-     class translation helpers ( started with t_... ):
-        - t_delivery_set_statuses_options (= [['translation or humanization', :ready_for_shipment] ...] ) for select inputs purposes
-        - 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 )
+enum methods:    
+    - Class.statuses.supersets -- will output superset definition hash
+    - Class.statuses.supersets_raw -- will output superset decompositions to basic enum types hash 
+    
+    - Class.statuses.delivery_superset (=[:ready_for_shipment, :on_delivery, :delivered] ), in_warehouse_statuses
+    - delivery_set_statuses_i (= [3,4,5]), in_warehouse_statuses_i (=[3])
+
+    translation helpers ( started with t_... ):
+    - Class.statuses.t_delivery_set_options (= [['translation or humanization', :ready_for_shipment] ...] ) for select inputs purposes
+    - Class.statuses.t_delivery_set_options_i (= [['translation or humanization', 3] ...]) same as above but with integer as value ( for example to use in Active admin filters )
 ```
 
  ```ruby
@@ -181,10 +230,10 @@ class:
     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 ):
+supersets creation could be called multiple times defining a superposition of already defined sets ( considering previous example ):
 
 ```ruby
- ext_enum_sets :status, {
+ enum_ext :status, enum_supersets: {
    outside_wharehouse: ( delivery_set_statuses - in_warehouse_statuses )#... any other array operations like &, + and so can be used
  }
 ```
@@ -192,7 +241,7 @@ ext_enum_sets can be called multiple times defining a superposition of already d
 Rem: you can refer previously defined set as usual kind in the same method call:
     
 ```ruby
-    ext_enum_sets :status, {
+    enum_ext :status, enum_supersets: {
         delivery_set: [:ready_for_shipment, :on_delivery, :delivered],
         not_in_cart: [:paid, :delivery_set] #
     }
@@ -243,11 +292,43 @@ Rem: you can refer previously defined set as usual kind in the same method call:
     order.requests.delivered.count              # >> N + M
 ```
 
+## Annotations helpers
+Sometimes under irb console you need a quick tip on whats extension available on a enum, so some describe_* helpers added to enum wrapper
+
+General description methods (describe/describe_short/describe_long)
+```
+  Class.enum.describe
+```  
+![img.png](img.png)
+
+```
+  Class.enum.describe_short
+```
+![img_1.png](img_1.png)
+
+```
+  Class.enum.describe_long
+```
+![img_2.png](img_2.png)
+
+And per extension methods (describe_enum_i, e.t.c)
+
+```ruby
+ EnumAnnotated.test_types.describe_mass_assign_enum
+```
+![img_3.png](img_3.png)
+
 ## Tests
-   rake test
- 
+Starting version 0.6 added support for rails 7+ enum definitions, that's making testing a little bit not that easy as running `rake test`.
+Now testings are done via `docker-compose up`. Look closer to Dockerfiles and `docker-compose.yml` 
+to get the idea how they working simultaneously without interference with each other. 
+
+
 ## Development
 
+## TODO
+[] better support for suffix/prefix as enum does
+[] describe method to observe current extension 
 
 ## Contributing
 
@@ -258,6 +339,6 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/alekse
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
-### Thanks
 
-Thanks for the star vzamanillo, it inspires me to do mass refactor and gracefully cover code in this gem by tests.
+### Thanks
+Thanks for the first star to vzamanillo, it inspires me to do mass refactor and gracefully cover code in this gem by tests.

data/docker-compose.yml

@@ -0,0 +1,24 @@
+version: "3.7"
+
+services:
+  test:
+    build: .
+    image: enum_ext
+    command: rake test
+    volumes:
+      - './lib:/app/lib'
+      - './test:/app/test'
+      - './Gemfile_rails_6:/app/Gemfile'
+      - './Gemfile_rails_6.lock:/app/Gemfile.lock'
+
+  test_7_0:
+    build:
+      context: .
+      dockerfile: Dockerfile_rails_7
+    image: enum_ext_rails_7
+    command: rake test
+    volumes:
+      - './lib:/app/lib'
+      - './test:/app/test'
+      - './Gemfile_rails_7:/app/Gemfile'
+      - './Gemfile_rails_7.lock:/app/Gemfile.lock'

data/lib/enum_ext/annotated.rb

@@ -0,0 +1,172 @@
+# I wanted to add some quick live annotation to what's defined and how it could be used
+# but have no idea how to do this in a super-neat way, so it a little bit chaotic and experimental
+module EnumExt::Annotated
+
+  # call it to see what's your enum current opitons
+  def describe_basic
+    puts yellow( "Basic #{enum_name} definition: \n" )
+    print_hash(enum_values)
+  end
+
+  # call it to see all enum extensions defined.
+  def describe_long
+    puts yellow( "\nEnumExt extensions:" )
+
+    puts [
+      describe_enum_i(false),
+      describe_mass_assign_enum(false),
+      describe_multi_enum_scopes(false),
+      describe_supersets(false),
+      describe_translations(false),
+      describe_humanizations(false)
+    ].join( "\n" + "-" * 100 + "\n" )
+  end
+
+  def describe(short = true)
+    describe_basic
+    short ? describe_short : describe_long
+  end
+
+  def describe_short
+    enabled, disabled = enabled_features.except(:key_sample).partition{!_2.blank?}.map{ |prt| prt.map(&:shift) }
+    puts <<~SHORT
+      #{yellow("EnumExt extensions:")}
+      #{cyan("Enabled")}: #{enabled.join(", ")}
+      #{red("Disabled")}: #{disabled.join(", ")}
+    SHORT
+
+    print_short(:supersets)
+    print_short(:translations)
+    print_short(:humanization)
+  end
+
+  # --------------------------------------------------------------------
+  # ------------- per helpers describers -------------------------------
+  # --------------------------------------------------------------------
+  def describe_enum_i(output = true)
+    description = basic_helpers_usage_header(:enum_i)
+    description << <<~ENUM_I if enabled_features[:enum_i]
+      #{black("instance")}.#{cyan( enabled_features[:enum_i] )} 
+      # output will be same as #{base_class.to_s}.#{enum_name}[:#{enabled_features[:key_sample]}]
+    ENUM_I
+
+    output ? puts(description) : description
+  end
+
+  def describe_mass_assign_enum(output = true)
+    description = basic_helpers_usage_header(:mass_assign_enum)
+    description << <<~MASS_ASSIGN if enabled_features[:mass_assign_enum]
+      # To assign #{enabled_features[:key_sample]} to all elements of any_scope or relation call:
+      #{black(base_class.to_s)}.any_scope.#{cyan( enabled_features[:mass_assign_enum] )}
+    MASS_ASSIGN
+
+    output ? puts(description) : description
+  end
+
+  def describe_multi_enum_scopes(output = true)
+    description = basic_helpers_usage_header(:multi_enum_scopes)
+    description << <<~MULTI_SCOPES if enabled_features[:multi_enum_scopes]
+      # Two scopes: with_#{enum_name} and without_#{enum_name} are defined
+      # To get elements with a given enums or supersets values call:
+      #{black(base_class.to_s)}.#{cyan("with_#{enum_name}")}(:#{keys.sample(2).join(", :")})
+      \n# To get all elements except for the ones with enums or supersets values call:
+      #{black(base_class.to_s)}.#{cyan("without_#{enum_name}")}(:#{keys.sample(2).join(", :")})
+    MULTI_SCOPES
+
+    output ? puts(description) : description
+  end
+
+  def describe_supersets(output = true)
+    description = if enabled_features[:supersets].blank?
+      red( "\nSupersets not used!\n" )
+    else
+      red( "\nSupersets definitions:\n" ) << inspect_hash(enabled_features[:supersets]) << <<~SUPERSETS
+          # Instance methods added: #{enabled_features[:supersets].keys.join("?, ")}?
+   
+          # Class level methods added: #{enabled_features[:supersets].keys.join(", ")}
+       SUPERSETS
+    end
+
+    output ? puts(description) : description
+  end
+
+  def describe_translations(output = true)
+    description = if enabled_features[:translations].blank?
+      red( "\nTranslations not used!\n" )
+    else
+      red( "\nTranslations definitions (will skip instance dependent translation)\n" ) <<
+        inspect_hash(enabled_features[:translations])
+    end
+
+    output ? puts(description) : description
+  end
+
+  def describe_humanizations(output = true)
+    description = if enabled_features[:humanization].blank?
+      red( "\nHumanization not used!\n" )
+    else
+      red( "\nHumanization definitions (will skip instance dependent humanization)\n" ) <<
+        inspect_hash(enabled_features[:humanization])
+    end
+
+    output ? puts(description) : description
+  end
+
+  private
+
+  def enabled_features
+    enum_sample = keys.first
+    {
+      key_sample: enum_sample,
+      enum_i: base_class.instance_methods.include?("#{enum_name}_i".to_sym) && "#{enum_name}_i",
+      mass_assign_enum: base_class.respond_to?("#{enum_sample}!") && "#{enum_sample}!",
+      multi_enum_scopes: base_class.respond_to?("with_#{enum_name.to_s.pluralize}") && "with_#{enum_name.to_s.pluralize}",
+      supersets: supersets_raw,
+      translations: try(:t_options),
+      humanization: try(:t_options)
+    }
+  end
+
+  def basic_helpers_usage_header(helper_name)
+    enabled_features[helper_name] ? "\n#{red(helper_name)} helpers enabled, usage:\n"
+           : "\n#{helper_name} wasn't used\n"
+  end
+
+  def print_hash(hsh)
+    defined?(ai) ? ap(hsh) : pp(hsh)
+  end
+
+  def inspect_hash(hsh)
+    defined?(ai) ? hsh.ai : hsh.inspect
+  end
+
+  def print_short(feature)
+    if enabled_features[feature].present?
+      puts black("#{feature.to_s.humanize}:")
+      print_hash(enabled_features[feature])
+    end
+  end
+
+  def yellow(str)
+    # yellow ANSI color
+    "\e[0;33;49m#{str}\e[0m"
+  end
+
+  def cyan(str)
+    # cyan ANSI color
+    "\e[0;36;49m#{str}\e[0m"
+  end
+
+  def red(str)
+    # red ANSI color
+    "\e[0;31;49m#{str}\e[0m"
+  end
+
+  def black(comment)
+    # bright black bold ANSI color
+    "\e[0;90;1;49m#{comment}\e[0m"
+  end
+
+end
+
+