Merge pull request #319 from kbrock/more_cops

More cops

Author: agrare

lib/floe/container_runner/docker.rb

@@ -176,7 +176,7 @@ def docker_event_status_to_event(status)
         when "die", "destroy"
           :delete
         else
-          :unkonwn
+          :unknown
         end
       end
 

lib/floe/workflow/choice_rule/data.rb

@@ -111,25 +111,27 @@ def parse_compare_key
             if (match_values = OPERATION.match(key))
               @compare_key = key
               @type, operator, @path = match_values.captures
-              @operation = "op_#{operator.downcase}?".to_sym
+              @operation = :"op_#{operator.downcase}?"
               @compare_predicate = parse_predicate(type)
               break
-            end
             # e.g. (Is)(String)
-            if (match_value = TYPE_CHECK.match(key))
+            elsif (match_value = TYPE_CHECK.match(key))
               @compare_key = key
               _operator, type = match_value.captures
               # type: nil means no runtime type checking.
               @type = @path = nil
-              @operation = "is_#{type.downcase}?".to_sym
+              @operation = :"is_#{type.downcase}?"
               @compare_predicate = parse_predicate("Boolean")
               break
             end
           end
           parser_error!("requires a compare key") if compare_key.nil? || operation.nil?
         end
 
-        # parse predicate at initilization time
+        # parse predicate at initialization time
+        # @param data_type [String] the data type of the variable
+        #                  When parsing operations (IntegerGreaterThan), this will be the operation data type (e.g.: Integer)
+        #                  When parsing type checks (IsString), this will always be a Boolean
         # @return the right predicate attached to the compare key
         def parse_predicate(data_type)
           path ? parse_path(compare_key) : parse_field(compare_key, data_type)
@@ -140,13 +142,13 @@ def compare_value(context, input)
           path ? fetch_path(compare_key, compare_predicate, context, input) : compare_predicate
         end
 
-        # feth the variable value at runtime
-        # @return variable value (left hand side )
+        # fetch the variable value at runtime
+        # @return variable value (left hand side)
         def variable_value(context, input)
           fetch_path("Variable", variable, context, input)
         end
 
-        # parse path at initilization time
+        # parse path at initialization time
         # helper method to parse a path from the payload
         def parse_path(field_name)
           value = payload[field_name]
@@ -155,6 +157,10 @@ def parse_path(field_name)
         end
 
         # parse predicate field at initialization time
+        # @param field_name [String] the compare key
+        # @param data_type [String] the data type of the variable
+        #                  When parsing operations (IntegerGreaterThan), this will be the operation data type (e.g.: Integer)
+        #                  When parsing type checks (IsString), this will always be a Boolean
         def parse_field(field_name, data_type)
           value = payload[field_name]
           return value if correct_type?(value, data_type)
@@ -165,6 +171,7 @@ def parse_field(field_name, data_type)
         # fetch a path at runtime
         def fetch_path(field_name, field_path, context, input)
           value = field_path.value(context, input)
+          # if this is an operation (GreaterThanPath), ensure the value is the correct type
           return value if type.nil? || correct_type?(value, type)
 
           runtime_field_error!(field_name, field_path.to_s, "required to point to a #{type}")
@@ -173,7 +180,7 @@ def fetch_path(field_name, field_path, context, input)
         # if we have runtime checking, check against that type
         #   otherwise assume checking a TYPE_CHECK predicate and check against Boolean
         def correct_type?(value, data_type)
-          send("is_#{data_type.downcase}?".to_sym, value)
+          send(:"is_#{data_type.downcase}?", value)
         end
       end
     end

lib/floe/workflow/context.rb

@@ -148,7 +148,7 @@ def to_h
       end
 
       def ==(other)
-        other.is_a?(self.class) && other.instance_variable_get("@context") == @context
+        other.kind_of?(self.class) && other.instance_variable_get(:@context) == @context
       end
       alias eql? ==
 

lib/floe/workflow/intrinsic_function/transformer.rb

@@ -236,15 +236,15 @@ def check_types(args, function, signature)
 
         rule(:states_string_split => {:args => subtree(:args)}) do
           args = Transformer.process_args(args(), "States.StringSplit", [String, String])
-          str, delimeter = *args
+          str, delimiter = *args
 
-          case delimeter.size
+          case delimiter.size
           when 0
             str.empty? ? [] : [str]
           when 1
-            str.split(delimeter)
+            str.split(delimiter)
           else
-            str.split(/[#{Regexp.escape(delimeter)}]+/)
+            str.split(/[#{Regexp.escape(delimiter)}]+/)
           end
         end
 

spec/workflow/context_spec.rb

@@ -201,8 +201,8 @@
   describe "#inspect" do
     it "has the same value with or without credentials" do
       # removing spaces because Hash#inspect in ruby 3.4 adds spaces that are not present before
-      expect(ctx.inspect.gsub(" ", "")).to eq("#<Floe::Workflow::Context: {\"Execution\" => {\"Input\" => {\"x\" => \"y\"}}, \"State\" => {}, \"StateHistory\" => [], \"StateMachine\" => {}, \"Task\" => {}}>".gsub(" ", ""))
-      expect(ctx_creds.inspect.gsub(" ", "")).to eq("#<Floe::Workflow::Context: {\"Execution\" => {\"Input\" => {\"x\" => \"y\"}}, \"State\" => {}, \"StateHistory\" => [], \"StateMachine\" => {}, \"Task\" => {}}>".gsub(" ", ""))
+      expect(ctx.inspect.delete(" ")).to eq("#<Floe::Workflow::Context: {\"Execution\" => {\"Input\" => {\"x\" => \"y\"}}, \"State\" => {}, \"StateHistory\" => [], \"StateMachine\" => {}, \"Task\" => {}}>".delete(" "))
+      expect(ctx_creds.inspect.delete(" ")).to eq("#<Floe::Workflow::Context: {\"Execution\" => {\"Input\" => {\"x\" => \"y\"}}, \"State\" => {}, \"StateHistory\" => [], \"StateMachine\" => {}, \"Task\" => {}}>".delete(" "))
     end
 
     it "doesn't expose credentials" do
@@ -238,7 +238,7 @@
       end
     end
 
-        describe "#eql?" do
+    describe "#eql?" do
       it "compares with values" do
         ctx1 = described_class.new(:input => input.to_json)
         ctx2 = described_class.new(:input => input.to_json)