highway 0.0.1 → 1.0.1

data/lib/highway/steps/types/anyof.rb

@@ -0,0 +1,64 @@
+#
+# anyof.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents a parameter type that's any of given types.
+      class AnyOf < Types::Any
+
+        public
+
+        # Initialize an instance.
+        #
+        # The variadic argument accepts types keyed by a tag symbol. Tags are
+        # used to later denote which type the value falls to.
+        #
+        # Consider a step which defines the following parameter:
+        #
+        # ```
+        # Types::AnyOf(
+        #   channel: Types::String.regex(/#\w+/),
+        #   user: Types::String.regex(/@\w+/),
+        # )
+        # ```
+        #
+        # Later, when a step which defined such a parameter receives a value,
+        # it doesn't receive just a plain `String`, it receives:
+        #
+        # ```
+        # { tag: :channel, value: "#general" }
+        # ```
+        #
+        # Thus retaining the information about which type definition matched
+        # the value.
+        #
+        # @param type_defs [Array] Type definitions. First match wins.
+        def initialize(**type_defs)
+          super(validate: nil)
+          @type_defs = type_defs
+        end
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [Object, nil]
+        def typecheck(value)
+          typechecked_defs = @type_defs.map { |tag, type| {tag: tag, value: type.typecheck_and_validate(value) } }
+          typechecked_defs.find { |typechecked_def| typechecked_def[:value] != nil }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/array.rb

@@ -0,0 +1,44 @@
+#
+# array.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents an array parameter type.
+      class Array < Types::Any
+
+        public
+
+        # Initialize an instance.
+        #
+        # @param element_type [Object] Type of inner elements.
+        # @param validate [Proc] A custom value validation block.
+        def initialize(element_type, validate: nil)
+          super(validate: validate)
+          @element_type = element_type
+        end
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [Array, nil]
+        def typecheck(value)
+          return nil unless value.kind_of?(::Array)
+          typechecked = value.map { |element| @element_type.typecheck_and_validate(element) }
+          typechecked if typechecked.all? { |element| !element.nil? }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/bool.rb

@@ -0,0 +1,36 @@
+#
+# bool.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents a boolean parameter type.
+      class Bool < Types::Any
+
+        public
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [Boolean, nil]
+        def typecheck(value)
+          case value
+            when ::TrueClass, 1, "1", "true", "yes" then true
+            when ::FalseClass, 0, "0", "false", "no" then false
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/enum.rb

@@ -0,0 +1,44 @@
+#
+# enum.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+require "highway/steps/types/string"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents an enum parameter type. It can be used in
+      # parameters which have a finite set of valid values.
+      class Enum < Types::String
+
+        public
+
+        # Initialize an instance.
+        #
+        # @param *values [String] Allowed enum values.
+        def initialize(*values)
+          super(validate: nil)
+          @values = values
+        end
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [String, nil]
+        def typecheck(value)
+          typechecked = super(value)
+          typechecked if !typechecked.nil? && @values.include?(typechecked)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/hash.rb

@@ -0,0 +1,45 @@
+#
+# hash.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+require "highway/utilities"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents a dictionary parameter type.
+      class Hash < Types::Any
+
+        public
+
+        # Initialize an instance.
+        #
+        # @param element_type [Object] Type of inner elements.
+        # @param validate [Proc] A custom value validation block.
+        def initialize(element_type, validate: nil)
+          super(validate: validate)
+          @element_type = element_type
+        end
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [Hash, nil]
+        def typecheck(value)
+          return nil unless value.is_a?(::Hash)
+          typechecked = Utilities::hash_map(value) { |key, element| [key, @element_type.typecheck_and_validate(element)] }
+          typechecked if typechecked.values.all? { |element| !element.nil? }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/number.rb

@@ -0,0 +1,38 @@
+#
+# number.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents a numeric parameter type. It can be used in
+      # parameters which have an integer or float value.
+      class Number < Types::Any
+
+        public
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [Integer, Float, nil]
+        def typecheck(value)
+          case value
+            when ::Numeric then value
+            when ::String && value.to_i.to_s == value then value.to_i
+            when ::String && value.to_f.to_s == value then value.to_f
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/set.rb

@@ -0,0 +1,39 @@
+#
+# set.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "set"
+
+require "highway/steps/types/any"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents a set parameter type. It's like array but ensures
+      # the values occur only once.
+      class Set < Types::Array
+
+        public
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [Set, nil]
+        def typecheck(value)
+          typechecked_array = super(value)
+          return nil if typechecked_array == nil
+          typechecked_set = ::Set.new(typechecked_array)
+          typechecked_set if typechecked_set.count == typechecked_array.count
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/string.rb

@@ -0,0 +1,47 @@
+#
+# string.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents a string parameter type.
+      class String < Types::Any
+
+        public
+
+        # Initialize an instance.
+        #
+        # @param regex [Regexp] A regular expression string must match.
+        #
+        # @return [Highway::Steps::Types::String]
+        def self.regex(regex)
+          self.new(validate: lambda { |value| regex =~ value })
+        end
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [String, nil]
+        def typecheck(value)
+          case value
+            when ::String then value
+            when ::Numeric then value.to_s
+            when ::TrueClass then "true"
+            when ::FalseClass then "false"
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/types/url.rb

@@ -0,0 +1,35 @@
+#
+# url.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/types/any"
+
+module Highway
+  module Steps
+    module Types
+
+      # This class represents an URL parameter type.
+      class Url < Types::String
+
+        public
+
+        # Typecheck and coerce a value if possible.
+        #
+        # This method returns a typechecked and coerced value or `nil` if value
+        # has invalid type and can't be coerced.
+        #
+        # @param value [Object] A value.
+        #
+        # @return [URI, nil]
+        def typecheck(value)
+          typechecked = super(value)
+          parsed = URI.parse(typechecked) rescue nil
+          parsed if parsed && parsed.kind_of?(URI::HTTP)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/utilities.rb

@@ -0,0 +1,51 @@
+#
+# utilities.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+module Highway
+
+  # This class contains a collection of utility functions used throughout the
+  # codebase.
+  class Utilities
+
+    public
+
+    # Map pairs of keys and values and combine them again into a Hash.
+    #
+    # @param subject [Hash] An input hash.
+    # @param transform [Proc] A transformation block.
+    #
+    # @return [Hash]
+    def self.hash_map(subject, &transform)
+      Hash[subject.map(&transform)]
+    end
+
+    # Join keypath into a string.
+    #
+    # @param keypath [Array<String>] A keypath.
+    #
+    # @return [String]
+    def self.keypath_to_s(keypath)
+      keypath.join(".")
+    end
+
+    # Recursively check whether the subject includes an element.
+    #
+    # @param subject [Object] A haystack.
+    # @param element [Object] A needle.
+    #
+    # @return [Boolean]
+    def self.recursive_include?(subject, element)
+      if subject.is_a?(Hash)
+        recursive_include?(subject.values, element)
+      elsif subject.respond_to?(:any?)
+        subject.any? { |value| recursive_include?(value, element) }
+      else
+        subject == element
+      end
+    end
+
+  end
+
+end