active_cucumber 1.0.0 → 1.1.0

data/lib/active_cucumber/creator.rb

@@ -1,57 +1,78 @@
-require 'factory_girl'
+# frozen_string_literal: true
 
-module ActiveCucumber
+require "factory_bot"
 
+module ActiveCucumber
   # Creates ActiveRecord entries with data from given Cucumber tables.
   class Creator
+    include FactoryBot::Syntax::Methods
 
-    include FactoryGirl::Syntax::Methods
-
-    def initialize attributes, context
+    def initialize(attributes, context)
       @attributes = attributes
       context.each do |key, value|
         instance_variable_set "@#{key}", value
       end
     end
 
-    # Returns the FactoryGirl version of this Creator's attributes
-    def factorygirl_attributes
+    # Returns the FactoryBot version of this Creator's attributes.
+    # rubocop:disable Metrics/MethodLength
+    def factorybot_attributes
       symbolize_attributes!
-      @attributes.each do |key, value|
-        next unless respond_to?(method = method_name(key))
-        if (result = send method, value) || value.nil?
-          @attributes[key] = result if @attributes.key? key
+      # Capture original keys and values before any transformations
+      # to ensure each value_for_* method receives the original value
+      original_attributes = @attributes.dup
+      keys_to_process = original_attributes.keys
+      keys_to_process.each do |key|
+        method = method_name(key)
+        next unless respond_to?(method)
+
+        value = original_attributes[key]
+        result = send(method, value)
+
+        # Keep the transformed value if it's truthy or if the original was nil
+        # Check if key still exists (value_for_* method may have deleted it)
+        if result || value.nil?
+          @attributes[key] = result if @attributes.key?(key)
         else
-          @attributes.delete key
+          @attributes.delete(key)
         end
       end
+      @attributes
     end
+    # rubocop:enable Metrics/MethodLength
 
+    private
 
-  private
-
-    def method_missing method_name, *arguments
+    def method_missing(method_name, *, &)
       # This is necessary so that a Creator subclass can access
       # methods of @attributes as if they were its own.
-      @attributes.send method_name, *arguments
+      if @attributes.respond_to?(method_name, true)
+        @attributes.send(method_name, *, &)
+      else
+        super
+      end
     end
 
-
     # Returns the name of the value_for method for the given key
-    def method_name key
+    def method_name(key)
       "value_for_#{key}"
     end
 
-
-    # Converts the key given in Cucumber format into FactoryGirl format
-    def normalized_key key
+    # Converts the key given in Cucumber format into FactoryBot format
+    def normalized_key(key)
       key.downcase.parameterize.underscore.to_sym
     end
 
-    def normalized_value value
-      value.blank? ? nil : value
+    def normalized_value(value)
+      return nil if value.nil?
+      return nil if value.respond_to?(:blank?) && value.blank?
+
+      value
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      @attributes.respond_to?(method_name, include_private) || super
+    end
 
     # Makes the keys on @attributes be normalized symbols
     def symbolize_attributes!
@@ -61,7 +82,5 @@ module ActiveCucumber
         end
       end
     end
-
   end
-
 end

data/lib/active_cucumber/cucumberator.rb

@@ -1,57 +1,59 @@
-module ActiveCucumber
+# frozen_string_literal: true
 
+module ActiveCucumber
   # A decorator for ActiveRecord objects that adds methods to
   # format record attributes as they are displayed in Cucumber tables.
   #
   # This class is used by default. You can subclass it to create
   # custom Cucumberators for your ActiveRecord classes.
   class Cucumberator
-
     # object - the instance to decorate
-    def initialize object, context
+    def initialize(object, context)
       @object = object
       context.each do |key, value|
         instance_variable_set "@#{key}", value
       end
     end
 
-
     # Returns the Cucumber value for the given attribute key.
     #
     # If a value_for_* method is not defined for the given key,
     # returns the attribute value of the decorated object,
     # converted to a String.
-    def value_for key
+    def value_for(key)
       method_name = value_method_name key
       if respond_to? method_name
         send(method_name).to_s
       else
-        @object.send(normalized_key key).to_s
+        @object.send(normalized_key(key)).to_s
       end
     end
 
+    private
 
-  private
-
-    def method_missing method_name
+    def method_missing(method_name, *, &)
       # This is necessary so that a Cucumberator subclass can access
       # attributes of @object as if they were its own.
-      @object.send method_name
+      if @object.respond_to?(method_name, true)
+        @object.send(method_name, *, &)
+      else
+        super
+      end
     end
 
-
     # Converts the key given in Cucumber format into the format used to
     # access attributes on an ActiveRecord instance.
-    def normalized_key key
+    def normalized_key(key)
       key.to_s.downcase.parameterize.underscore
     end
 
+    def respond_to_missing?(method_name, include_private = false)
+      @object.respond_to?(method_name, include_private) || super
+    end
 
     # Returns the name of the value_of_* method for the given key
-    def value_method_name key
+    def value_method_name(key)
       "value_for_#{normalized_key key}"
     end
-
   end
-
 end

data/lib/active_cucumber/cucumparer.rb

@@ -1,8 +1,9 @@
-module ActiveCucumber
+# frozen_string_literal: true
 
+module ActiveCucumber
+  # provides Mortadella instances of the given database content
   class Cucumparer
-
-    def initialize database_content, cucumber_table, context
+    def initialize(database_content, cucumber_table, context)
       @database_content = database_content
       @cucumber_table = cucumber_table
       @context = context
@@ -10,6 +11,8 @@ module ActiveCucumber
 
     # Returns all entries in the database as a horizontal Mortadella table
     def to_horizontal_table
+      raise ArgumentError, "No headers provided in Cucumber table" if @cucumber_table.headers.empty?
+
       mortadella = Mortadella::Horizontal.new headers: @cucumber_table.headers
       @database_content = @database_content.all if @database_content.respond_to? :all
       @database_content.each do |record|
@@ -22,34 +25,32 @@ module ActiveCucumber
     end
 
     # Returns the given object as a vertical Mortadella table
-    def to_vertical_table object
+    def to_vertical_table(object)
       mortadella = Mortadella::Vertical.new
       cucumberator = cucumberator_for object
-      @cucumber_table.rows_hash.each do |key, _|
+      @cucumber_table.rows_hash.each_key do |key|
         mortadella[key] = cucumberator.value_for key
       end
       mortadella.table
     end
 
-  private
+    private
 
-    # Returns the Cucumberator subclass to be used by this Cucumparer instance
-    def cucumberator_class object
+    # Returns the Cucumberator subclass to be used by this Cucumparer instance.
+    def cucumberator_class(object)
       cucumberator_class_name(object).constantize
     rescue NameError
       Cucumberator
     end
 
     # Returns the name of the Cucumberator subclass to be used by this Cucumparer instance.
-    def cucumberator_class_name object
+    def cucumberator_class_name(object)
       "#{object.class.name}Cucumberator"
     end
 
     # Returns the Cucumberator object for the given ActiveRecord instance
-    def cucumberator_for object
+    def cucumberator_for(object)
       cucumberator_class(object).new object, @context
     end
-
   end
-
 end

data/lib/active_cucumber.rb

@@ -1,61 +1,133 @@
-require 'active_cucumber/cucumparer'
-require 'active_cucumber/cucumberator'
-require 'active_cucumber/active_record_builder'
-require 'active_cucumber/creator'
+# frozen_string_literal: true
+
+require "active_record"
+require "active_cucumber/cucumparer"
+require "active_cucumber/cucumberator"
+require "active_cucumber/active_record_builder"
+require "active_cucumber/creator"
 
 # The main namespace for this gem
 module ActiveCucumber
-
   # Returns the attributes to create an instance of the given ActiveRecord class
-  # that matches the given vertical Cucumber table
-  def self.attributes_for activerecord_class, cucumber_table, context: {}
+  # that matches the given vertical Cucumber table.
+  #
+  # @param activerecord_class [Class] the ActiveRecord class to create attributes for
+  # @param cucumber_table [Cucumber::MultilineArgument::DataTable] a vertical Cucumber table
+  # @param context [Hash] optional context values to inject into custom Creator classes
+  # @return [Hash] FactoryBot-compatible attributes hash
+  # @raise [TypeError] if activerecord_class is not an ActiveRecord class
+  def self.attributes_for(activerecord_class, cucumber_table, context: {})
+    validate_activerecord_class!(activerecord_class)
+    validate_context!(context)
     builder = ActiveRecordBuilder.new activerecord_class, context
     builder.attributes_for ActiveCucumber.vertical_table(cucumber_table)
   end
 
-
   # Creates entries of the given ActiveRecord class
-  # specified by the given horizontal Cucumber table
-  def self.create_many activerecord_class, cucumber_table, context: {}
+  # specified by the given horizontal Cucumber table.
+  #
+  # @param activerecord_class [Class] the ActiveRecord class to create records for
+  # @param cucumber_table [Cucumber::MultilineArgument::DataTable] a horizontal Cucumber table
+  # @param context [Hash] optional context values to inject into custom Creator classes
+  # @return [Array<ActiveRecord::Base>] array of created records
+  # @raise [TypeError] if activerecord_class is not an ActiveRecord class
+  # @raise [ActiveRecord::RecordInvalid] if any record fails validation
+  def self.create_many(activerecord_class, cucumber_table, context: {})
+    validate_activerecord_class!(activerecord_class)
+    validate_context!(context)
     builder = ActiveRecordBuilder.new activerecord_class, context
     builder.create_many ActiveCucumber.horizontal_table(cucumber_table)
   end
 
-
   # Creates an entry of the given ActiveRecord class
-  # specified by the given vertical Cucumber table
-  def self.create_one activerecord_class, cucumber_table, context: {}
+  # specified by the given vertical Cucumber table.
+  #
+  # @param activerecord_class [Class] the ActiveRecord class to create a record for
+  # @param cucumber_table [Cucumber::MultilineArgument::DataTable] a vertical Cucumber table
+  # @param context [Hash] optional context values to inject into custom Creator classes
+  # @return [ActiveRecord::Base] the created record
+  # @raise [TypeError] if activerecord_class is not an ActiveRecord class
+  # @raise [ActiveRecord::RecordInvalid] if the record fails validation
+  def self.create_one(activerecord_class, cucumber_table, context: {})
+    validate_activerecord_class!(activerecord_class)
+    validate_context!(context)
     builder = ActiveRecordBuilder.new activerecord_class, context
     builder.create_record ActiveCucumber.vertical_table(cucumber_table)
   end
 
-
   # Verifies that the database table for the given ActiveRecord class
   # matches the given horizontal Cucumber table.
   #
-  # Sorts records by creation date.
-  def self.diff_all! clazz, cucumber_table, context: {}
+  # @param clazz [Class] the ActiveRecord class to compare records from
+  # @param cucumber_table [Cucumber::MultilineArgument::DataTable] a horizontal Cucumber table
+  # @param context [Hash] optional context values to inject into custom Cucumberator classes
+  # @return [void]
+  # @raise [Cucumber::MultilineArgument::DataTable::Different] if tables don't match
+  # @note Records are sorted by creation date before comparison
+  def self.diff_all!(clazz, cucumber_table, context: {})
+    validate_activerecord_class_or_collection!(clazz)
+    validate_context!(context)
     cucumparer = Cucumparer.new clazz, cucumber_table, context
     cucumber_table.diff! cucumparer.to_horizontal_table
   end
 
-
-  # Verifies that the given object matches the given vertical Cucumber table
-  def self.diff_one! object, cucumber_table, context: {}
+  # Verifies that the given object matches the given vertical Cucumber table.
+  #
+  # @param object [ActiveRecord::Base] the ActiveRecord instance to compare
+  # @param cucumber_table [Cucumber::MultilineArgument::DataTable] a vertical Cucumber table
+  # @param context [Hash] optional context values to inject into custom Cucumberator classes
+  # @return [void]
+  # @raise [Cucumber::MultilineArgument::DataTable::Different] if tables don't match
+  def self.diff_one!(object, cucumber_table, context: {})
+    validate_activerecord_instance!(object)
+    validate_context!(context)
     cucumparer = Cucumparer.new object.class, cucumber_table, context
     cucumber_table.diff! cucumparer.to_vertical_table(object)
   end
 
-
-  # Returns the given horizontal Cucumber table in standardized format
-  def self.horizontal_table table
+  # Returns the given horizontal Cucumber table in standardized format.
+  #
+  # @param table [Cucumber::MultilineArgument::DataTable] a horizontal Cucumber table
+  # @return [Array<Hash>] array of hashes where keys are column headers and values are cell values
+  def self.horizontal_table(table)
     table.hashes
   end
 
-
-  # Returns the given vertical Cucumber table in standardized format
-  def self.vertical_table table
+  # Returns the given vertical Cucumber table in standardized format.
+  #
+  # @param table [Cucumber::MultilineArgument::DataTable] a vertical Cucumber table
+  # @return [Hash] hash where keys are from first column and values are from second column
+  def self.vertical_table(table)
     table.rows_hash
   end
 
+  # @api private
+  def self.validate_activerecord_class!(klass)
+    return if klass.is_a?(Class) && klass < ActiveRecord::Base
+
+    raise TypeError, "Expected an ActiveRecord class, got #{klass.inspect}"
+  end
+
+  # @api private
+  def self.validate_activerecord_class_or_collection!(value)
+    # Allow ActiveRecord class, array of instances, or ActiveRecord relation/association
+    return if value.is_a?(Class) && value < ActiveRecord::Base
+    return if value.is_a?(Array) || value.respond_to?(:all)
+
+    raise TypeError, "Expected an ActiveRecord class or collection, got #{value.class}"
+  end
+
+  # @api private
+  def self.validate_activerecord_instance!(object)
+    return if object.is_a?(ActiveRecord::Base)
+
+    raise TypeError, "Expected an ActiveRecord instance, got #{object.class}"
+  end
+
+  # @api private
+  def self.validate_context!(context)
+    return if context.is_a?(Hash)
+
+    raise TypeError, "Expected context to be a Hash, got #{context.class}"
+  end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_cucumber
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Kevin Goslar
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-10 00:00:00.000000000 Z
+date: 2025-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,196 +15,56 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '6.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: cucumber
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '7.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: cucumber_lint
+  name: factory_bot
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '5.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: factory_girl
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: faker
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: kappamaki
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: mortadella
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '1.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec-collection_matchers
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 description: Tools to compare ActiveRecord entries with Cucumber tables
 email:
 - kevin.goslar@gmail.com
@@ -213,19 +72,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".coveralls.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- DEVELOPMENT.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - active_cucumber.gemspec
-- circle.yml
-- cucumber_lint.yml
+- cucumber.yml
 - documentation/horizontal_diff.png
 - documentation/vertical_diff.png
+- dprint.json
 - features/active_cucumber/attributes_for.feature
 - features/active_cucumber/create_many.feature
 - features/active_cucumber/create_one.feature
@@ -254,11 +116,11 @@ files:
 - lib/active_cucumber/creator.rb
 - lib/active_cucumber/cucumberator.rb
 - lib/active_cucumber/cucumparer.rb
-homepage: https://github.com/Originate/active_cucumber
+homepage: https://github.com/kevgo/active_cucumber
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -266,16 +128,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5.1
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: ActiveRecord tools for Cucumber
 test_files: []