cucumber_factory 2.0.1 → 2.3.0

data/lib/cucumber_factory.rb

@@ -13,6 +13,7 @@ require 'cucumber_priority'
 
 # Gem
 require 'cucumber_factory/build_strategy'
+require 'cucumber_factory/update_strategy'
 require 'cucumber_factory/factory'
 require 'cucumber_factory/switcher'
 

data/lib/cucumber_factory/build_strategy.rb

@@ -7,79 +7,115 @@ module CucumberFactory
     class << self
 
       def from_prose(model_prose, variant_prose)
-        # don't use \w which depends on the system locale
-        underscored_model_name = model_prose.gsub(/[^A-Za-z0-9_\/]+/, "_")
-        if variant_prose.present?
-          variants = /\((.*?)\)/.match(variant_prose)[1].split(/\s*,\s*/)
-          variants = variants.collect { |variant| variant.downcase.gsub(" ", "_") }
+        variants = variants_from_prose(variant_prose)
+        factory = factory_bot_factory(model_prose, variants)
+
+        if factory
+          factory.compile # Required to load inherited traits!
+          strategy = factory_bot_strategy(factory, model_prose, variants)
+          transient_attributes = factory_bot_transient_attributes(factory, variants)
         else
-          variants = []
+          strategy = alternative_strategy(model_prose, variants)
+          transient_attributes = []
         end
 
-        if factory_bot_strategy = factory_bot_strategy(underscored_model_name, variants)
-          factory_bot_strategy
+        [strategy, transient_attributes]
+      end
+
+      def parse_model_class(model_prose)
+        underscored_model_name(model_prose).camelize.constantize
+      end
+
+      private
+
+      def variants_from_prose(variant_prose)
+        if variant_prose.present?
+          variants = /\((.*?)\)/.match(variant_prose)[1].split(/\s*,\s*/)
+          variants.collect { |variant| variant.downcase.gsub(" ", "_").to_sym }
         else
-          model_class = underscored_model_name.camelize.constantize
-          machinist_strategy(model_class, variants) ||
-            active_record_strategy(model_class) ||
-            ruby_object_strategy(model_class)
+          []
         end
       end
 
-      private
+      def factory_bot_factory(model_prose, variants)
+        return unless factory_bot_class
 
-      def factory_bot_strategy(factory_name, variants)
-        factory_class   = ::FactoryBot  if defined?(FactoryBot)
-        factory_class ||= ::FactoryGirl if defined?(FactoryGirl)
-        return unless factory_class
+        factory_name = factory_name_from_prose(model_prose)
+        factory = factory_bot_class.factories[factory_name]
 
-        variants = variants.map(&:to_sym)
-        factory_name = factory_name.to_s.underscore.gsub('/', '_').to_sym
+        if factory.nil? && variants.present?
+          factory = factory_bot_class.factories[variants[0]]
+        end
 
-        factory = factory_class.factories[factory_name]
+        factory
+      end
 
-        if factory.nil? && variants.present? && factory = factory_class.factories[variants[0]]
+      def factory_bot_strategy(factory, model_prose, variants)
+        return unless factory
+
+        factory_name = factory_name_from_prose(model_prose)
+        if factory_bot_class.factories[factory_name].nil? && variants.present?
           factory_name, *variants = variants
         end
 
-        if factory
-          new(factory.build_class) do |attributes|
-            # Cannot have additional scalar args after a varargs
-            # argument in Ruby 1.8 and 1.9
-            args = []
-            args += variants
-            args << attributes
-            factory_class.create(factory_name, *args)
-          end
+        new(factory.build_class) do |attributes|
+          # Cannot have additional scalar args after a varargs
+          # argument in Ruby 1.8 and 1.9
+          args = []
+          args += variants
+          args << attributes
+          factory_bot_class.create(factory_name, *args)
+        end
+      end
+
+      def factory_bot_transient_attributes(factory, variants)
+        return [] unless factory
+
+        factory_attributes = factory_bot_attributes(factory, variants)
+        class_attributes = factory.build_class.attribute_names.map(&:to_sym)
+
+        factory_attributes - class_attributes
+      end
+
+      def factory_bot_attributes(factory, variants)
+        traits = factory_bot_traits(factory, variants)
+        factory.with_traits(traits.map(&:name)).definition.attributes.names
+      end
+
+      def factory_bot_traits(factory, variants)
+        factory.definition.defined_traits.select do |trait|
+          variants.include?(trait.name.to_sym)
         end
+      end
 
+      def alternative_strategy(model_prose, variants)
+        model_class = parse_model_class(model_prose)
+        machinist_strategy(model_class, variants) ||
+          active_record_strategy(model_class) ||
+          ruby_object_strategy(model_class)
       end
 
       def machinist_strategy(model_class, variants)
-        if model_class.respond_to?(:make)
-
-          new(model_class) do |attributes|
-            if variants.present?
-              variants.size == 1 or raise 'Machinist only supports a single variant per blueprint'
-              model_class.make(variants.first.to_sym, attributes)
-            else
-              model_class.make(attributes)
-            end
-          end
+        return unless model_class.respond_to?(:make)
 
+        new(model_class) do |attributes|
+          if variants.present?
+            variants.size == 1 or raise 'Machinist only supports a single variant per blueprint'
+            model_class.make(variants.first, attributes)
+          else
+            model_class.make(attributes)
+          end
         end
       end
 
       def active_record_strategy(model_class)
-        if model_class.respond_to?(:create!)
-
-          new(model_class) do |attributes|
-            model = model_class.new
-            CucumberFactory::Switcher.assign_attributes(model, attributes)
-            model.save!
-            model
-          end
+        return unless model_class.respond_to?(:create!)
 
+        new(model_class) do |attributes|
+          model = model_class.new
+          CucumberFactory::Switcher.assign_attributes(model, attributes)
+          model.save!
+          model
         end
       end
 
@@ -89,6 +125,21 @@ module CucumberFactory
         end
       end
 
+      def factory_bot_class
+        factory_class = ::FactoryBot if defined?(FactoryBot)
+        factory_class ||= ::FactoryGirl if defined?(FactoryGirl)
+        factory_class
+      end
+
+      def factory_name_from_prose(model_prose)
+        underscored_model_name(model_prose).to_s.underscore.gsub('/', '_').to_sym
+      end
+
+      def underscored_model_name(model_prose)
+        # don't use \w which depends on the system locale
+        model_prose.gsub(/[^A-Za-z0-9_\/]+/, "_")
+      end
+
     end
 
 

data/lib/cucumber_factory/factory.rb

@@ -2,21 +2,25 @@ module CucumberFactory
   module Factory
     class Error < StandardError; end
 
-    ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?'
+    ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?' # ... with the year 1979 which is science fiction
     TEXT_ATTRIBUTES_PATTERN = ' (?:with|and) these attributes:'
+    UPDATE_ATTR_PATTERN = '(?: (?:has|belongs to)( the .+?))?(?:(?: and| but|,)*( is .+?))?' # ... belongs to the collection "Fantasy" and is trending
+    TEXT_UPDATE_ATTR_PATTERN = '(?: and|,)* has these attributes:'
 
-    RECORD_PATTERN = 'there is an? (.+?)( \(.+?\))?'
-    NAMED_RECORD_PATTERN = '(?:"([^\"]*)"|\'([^\']*)\') is an? (.+?)( \(.+?\))?'
+    RECORD_PATTERN = 'there is an? (.+?)( \(.+?\))?' # Given there is a movie (comedy)
+    NAMED_RECORD_PATTERN = '(?:"([^\"]*)"|\'([^\']*)\') is an? (.+?)( \(.+?\))?' # Given "LotR" is a movie
+    RECORD_UPDATE_PATTERN = 'the (.+?) (above|".+?"|\'.+?\')' # Given the movie "LotR" ...
 
     NAMED_RECORDS_VARIABLE = :'@named_cucumber_factory_records'
 
     VALUE_INTEGER = /\d+/
     VALUE_DECIMAL = /[\d\.]+/
     VALUE_STRING = /"[^"]*"|'[^']*'/
+    VALUE_FILE = /file:#{VALUE_STRING}/
     VALUE_ARRAY = /\[[^\]]*\]/
     VALUE_LAST_RECORD = /\babove\b/
 
-    VALUE_SCALAR = /#{VALUE_STRING}|#{VALUE_DECIMAL}|#{VALUE_INTEGER}/
+    VALUE_SCALAR = /#{VALUE_STRING}|#{VALUE_DECIMAL}|#{VALUE_INTEGER}|#{VALUE_FILE}/
 
     CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR = {
       :kind => :Before,
@@ -39,6 +43,12 @@ module CucumberFactory
       :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_creation, self, a1, a2, a3, a4) }
     }
 
+    UPDATE_STEP_DESCRIPTOR = {
+      :kind => :And,
+      :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}$/,
+      :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4) }
+    }
+
     NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
       :kind => :Given,
       :pattern => /^#{NAMED_RECORD_PATTERN}#{ATTRIBUTES_PATTERN}#{TEXT_ATTRIBUTES_PATTERN}?$/,
@@ -53,6 +63,13 @@ module CucumberFactory
       :priority => true
     }
 
+    UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
+      :kind => :And,
+      :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}#{TEXT_UPDATE_ATTR_PATTERN}$/,
+      :block => lambda { |a1, a2, a3, a4, a5| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4, a5) },
+      :priority => true
+    }
+
     class << self
 
       def add_steps(main)
@@ -61,6 +78,8 @@ module CucumberFactory
         add_step(main, CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
         add_step(main, NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
         add_step(main, CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR)
+        add_step(main, UPDATE_STEP_DESCRIPTOR)
+        add_step(main, UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
       end
 
       private
@@ -100,15 +119,31 @@ module CucumberFactory
       end
 
       def parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
-        build_strategy = BuildStrategy.from_prose(raw_model, raw_variant)
+        build_strategy, transient_attributes = CucumberFactory::BuildStrategy.from_prose(raw_model, raw_variant)
         model_class = build_strategy.model_class
+        attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes, transient_attributes)
+        record = build_strategy.create_record(attributes)
+        remember_record_names(world, record, attributes)
+        record
+      end
+
+      def parse_update(world, raw_model, raw_name, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
+        model_class = CucumberFactory::BuildStrategy.parse_model_class(raw_model)
+        attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes)
+        record = resolve_associated_value(world, model_class, model_class, model_class, raw_name)
+        CucumberFactory::UpdateStrategy.new(record).assign_attributes(attributes)
+        remember_record_names(world, record, attributes)
+        record
+      end
+
+      def parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil, transient_attributes = [])
         attributes = {}
         if raw_attributes.try(:strip).present?
           raw_attribute_fragment_regex = /(?:the |and |with |but |,| )+(.*?) (#{VALUE_SCALAR}|#{VALUE_ARRAY}|#{VALUE_LAST_RECORD})/
           raw_attributes.scan(raw_attribute_fragment_regex).each do |fragment|
             attribute = attribute_name_from_prose(fragment[0])
             value = fragment[1]
-            attributes[attribute] = attribute_value(world, model_class, attribute, value)
+            attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
           end
           unused_raw_attributes = raw_attributes.gsub(raw_attribute_fragment_regex, '')
           if unused_raw_attributes.present?
@@ -126,49 +161,74 @@ module CucumberFactory
           # DocString e.g. "first name: Jane\nlast name: Jenny\n"
           if raw_multiline_attributes.is_a?(String)
             raw_multiline_attributes.split("\n").each do |fragment|
-              raw_attribute, value = fragment.split(': ')
+              raw_attribute, value = fragment.split(': ', 2)
               attribute = attribute_name_from_prose(raw_attribute)
-              value = "\"#{value}\"" unless matches_fully?(value, VALUE_ARRAY)
-              attributes[attribute] = attribute_value(world, model_class, attribute, value)
+              value = "\"#{value}\"" unless matches_fully?(value, /#{VALUE_ARRAY}|#{VALUE_FILE}/)
+              attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
             end
           # DataTable e.g. in raw [["first name", "Jane"], ["last name", "Jenny"]]
           else
             raw_multiline_attributes.raw.each do |raw_attribute, value|
               attribute = attribute_name_from_prose(raw_attribute)
-              value = "\"#{value}\"" unless matches_fully?(value, VALUE_ARRAY)
-              attributes[attribute] = attribute_value(world, model_class, attribute, value)
+              value = "\"#{value}\"" unless matches_fully?(value, /#{VALUE_ARRAY}|#{VALUE_FILE}/)
+              attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
             end
           end
         end
-        record = build_strategy.create_record(attributes)
-        remember_record_names(world, record, attributes)
-        record
+        attributes
       end
 
-      def attribute_value(world, model_class, attribute, value)
-        association = model_class.respond_to?(:reflect_on_association) ? model_class.reflect_on_association(attribute) : nil
-
-        if matches_fully?(value, VALUE_ARRAY)
-          elements_str = unquote(value)
-          value = elements_str.scan(VALUE_SCALAR).map { |v| attribute_value(world, model_class, attribute, v) }
-        elsif association.present?
-          if matches_fully?(value, VALUE_LAST_RECORD)
-            value = CucumberFactory::Switcher.find_last(association.klass) or raise Error, "There is no last #{attribute}"
-          elsif matches_fully?(value, VALUE_STRING)
-            value = unquote(value)
-            value = get_named_record(world, value) || transform_value(world, value)
-          elsif matches_fully?(value, VALUE_INTEGER)
-            value = value.to_s
-            value = get_named_record(world, value) || transform_value(world, value)
-          else
-            raise Error, "Cannot set association #{model_class}##{attribute} to #{value}."
-          end
+      def attribute_value(world, model_class, transient_attributes, attribute, value)
+        associated, association_class = resolve_association(attribute, model_class, transient_attributes)
+
+        value = if matches_fully?(value, VALUE_ARRAY)
+          array_values = unquote(value).scan(VALUE_SCALAR)
+          array_values.map { |v| attribute_value(world, model_class, transient_attributes, attribute, v) }
+        elsif associated
+          resolve_associated_value(world, model_class, association_class, attribute, value)
         else
-          value = resolve_scalar_value(world, model_class, attribute, value)
+          resolve_scalar_value(world, model_class, attribute, value)
         end
         value
       end
 
+      def resolve_association(attribute, model_class, transient_attributes)
+        return unless model_class.respond_to?(:reflect_on_association)
+
+        association = model_class.reflect_on_association(attribute)
+        association_class = nil
+
+        if association
+          association_class = association.klass unless association.polymorphic?
+          associated = true
+        elsif transient_attributes.include?(attribute.to_sym)
+          klass_name = attribute.to_s.camelize
+          if Object.const_defined?(klass_name)
+            association_class = klass_name.constantize
+            associated = true
+          end
+        else
+          associated = false
+        end
+        [associated, association_class]
+      end
+
+      def resolve_associated_value(world, model_class, association_class, attribute, value)
+        if matches_fully?(value, VALUE_LAST_RECORD)
+          raise(Error, "Cannot set last #{model_class}##{attribute} for polymorphic associations") unless association_class.present?
+
+          CucumberFactory::Switcher.find_last(association_class) || raise(Error, "There is no last #{attribute}")
+        elsif matches_fully?(value, VALUE_STRING)
+          value = unquote(value)
+          get_named_record(world, value) || transform_value(world, value)
+        elsif matches_fully?(value, VALUE_INTEGER)
+          value = value.to_s
+          get_named_record(world, value) || transform_value(world, value)
+        else
+          raise Error, "Cannot set association #{model_class}##{attribute} to #{value}."
+        end
+      end
+
       def resolve_scalar_value(world, model_class, attribute, value)
         if matches_fully?(value, VALUE_STRING)
           value = unquote(value)
@@ -177,6 +237,9 @@ module CucumberFactory
           value = value.to_i
         elsif matches_fully?(value, VALUE_DECIMAL)
           value = BigDecimal(value)
+        elsif matches_fully?(value, VALUE_FILE)
+          path = File.path("./#{file_value_to_path(value)}")
+          value = File.new(path)
         else
           raise Error, "Cannot set attribute #{model_class}##{attribute} to #{value}."
         end
@@ -184,11 +247,20 @@ module CucumberFactory
       end
 
       def unquote(string)
+        # This method removes quotes or brackets from the start and end from a string
+        # Examples: 'single' => single, "double" => double, [1, 2, 3] => 1, 2, 3
         string[1, string.length - 2]
       end
 
+      def file_value_to_path(string)
+        # file paths are marked with a special keyword and enclosed with quotes.
+        # Example: file:"/path/image.png"
+        # This will extract the path (/path/image.png) from the text fragment above
+        unquote string.sub(/\Afile:/, '')
+      end
+
       def full_regexp(partial_regexp)
-        Regexp.new("\\A" + partial_regexp.source + "\\z", partial_regexp.options)
+        Regexp.new('\\A(?:' + partial_regexp.source + ')\\z', partial_regexp.options)
       end
 
       def matches_fully?(string, partial_regexp)
@@ -208,7 +280,7 @@ module CucumberFactory
       end
 
       def attribute_name_from_prose(prose)
-        prose.downcase.gsub(" ", "_").to_sym
+        prose.downcase.gsub(' ', '_').to_sym
       end
 
       def remember_record_names(world, record, attributes)

data/lib/cucumber_factory/update_strategy.rb

@@ -0,0 +1,30 @@
+module CucumberFactory
+
+  class UpdateStrategy
+
+    def initialize(record)
+      @record = record
+    end
+
+    def assign_attributes(attributes)
+      active_record_strategy(attributes) ||
+        ruby_object_strategy(attributes)
+    end
+
+    private
+
+    def active_record_strategy(attributes)
+      return unless @record.respond_to?(:save!)
+
+      CucumberFactory::Switcher.assign_attributes(@record, attributes)
+      @record.save!
+    end
+
+    def ruby_object_strategy(attributes)
+      attributes.each do |name, value|
+        @record.send("#{name}=".to_sym, value)
+      end
+    end
+
+  end
+end