easol-canvas 0.1.1 → 1.0.0

data/lib/canvas/validators/schema_attribute.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "liquid"
+
+module Canvas
+  module Validator
+    # :documented:
+    # This class can be used to validate the format of an attribute that is used
+    # within a schema.
+    #
+    # Example:
+    # {
+    #   "name" => "headings",
+    #   "type" => "string",
+    #   "default" => "My Heading",
+    #   "array" => true
+    # }
+    #
+    class SchemaAttribute
+      VALIDATORS = {
+        "image" => SchemaAttribute::Image,
+        "product" => SchemaAttribute::Product,
+        "post" => SchemaAttribute::Post,
+        "page" => SchemaAttribute::Page,
+        "link" => SchemaAttribute::Link,
+        "text" => SchemaAttribute::Base,
+        "string" => SchemaAttribute::Base,
+        "boolean" => SchemaAttribute::Base,
+        "number" => SchemaAttribute::Number,
+        "color" => SchemaAttribute::Color,
+        "select" => SchemaAttribute::Select,
+        "range" => SchemaAttribute::Range,
+        "radio" => SchemaAttribute::Radio,
+        "variant" => SchemaAttribute::Variant,
+      }.freeze
+      PRIMITIVE_TYPES = VALIDATORS.keys
+      RESERVED_NAMES = %w[
+        page
+        company
+        cart
+        flash
+        block
+      ].freeze
+
+      attr_reader :attribute, :custom_types, :errors, :additional_reserved_names
+
+      def initialize(attribute:, custom_types: [], additional_reserved_names: [])
+        @attribute = attribute
+        @custom_types = custom_types
+        @errors = []
+        @additional_reserved_names = additional_reserved_names
+      end
+
+      def validate
+        ensure_attribute_is_hash &&
+          ensure_not_reserved_name &&
+          ensure_not_boolean_array &&
+          ensure_not_radio_array &&
+          ensure_type_key_is_present &&
+          ensure_valid_for_type &&
+          ensure_composite_array_without_non_array_attributes
+
+        errors.empty?
+      end
+
+      private
+
+      def attribute_type
+        attribute["type"]&.downcase
+      end
+
+      def valid_types
+        PRIMITIVE_TYPES + custom_type_keys
+      end
+
+      def validator_for_type
+        @_validator ||= VALIDATORS[attribute_type].new(attribute) if VALIDATORS[attribute_type]
+      end
+
+      def custom_type_keys
+        custom_types.map { |type| type["key"]&.downcase }.compact
+      end
+
+      def ensure_type_key_is_present
+        return true if attribute.key?("type")
+
+        @errors << "Missing required keys: type"
+        false
+      end
+
+      def ensure_valid_for_type
+        return true if custom_type_keys.include?(attribute_type)
+
+        if validator_for_type.nil?
+          @errors << "\"type\" must be one of: #{valid_types.join(', ')}"
+          false
+        else
+          validator_for_type.validate
+          errors.concat(validator_for_type.errors)
+          validator_for_type.errors.empty?
+        end
+      end
+
+      def ensure_attribute_is_hash
+        return true if attribute.is_a? Hash
+
+        @errors << "Must be valid JSON"
+        false
+      end
+
+      def ensure_not_reserved_name
+        all_reserved_names = RESERVED_NAMES + additional_reserved_names
+        return true unless all_reserved_names.include?(attribute["name"])
+
+        @errors << "\"name\" can't be one of these reserved words: #{all_reserved_names.join(', ')}"
+        false
+      end
+
+      def ensure_not_boolean_array
+        return true unless attribute["type"] == "boolean" && attribute["array"] == true
+
+        @errors << "Boolean attributes cannot be arrays"
+        false
+      end
+
+      def ensure_not_radio_array
+        return true unless attribute["type"] == "radio" && attribute["array"] == true
+
+        @errors << "Radio attributes cannot be arrays"
+        false
+      end
+
+      def ensure_composite_array_without_non_array_attributes
+        custom_type = custom_types.find { |type| type["key"]&.downcase == attribute_type }
+
+        return true if !custom_type || attribute["array"] != true
+
+        sub_attributes = custom_type.fetch("attributes", [])
+        return true unless sub_attributes.any? { |attribute| attribute["type"] == "radio" }
+
+        @errors << "Cannot be an array because \"#{custom_type['key']}\" type includes nonarray types"
+        false
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/base.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      #
+      # Validations to run against an attribute's schema that are shared
+      # across types. This class acts as the base class for type-specific
+      # validators.
+      class Base
+        attr_reader :attribute, :errors
+
+        def initialize(attribute)
+          @attribute = attribute
+          @errors = []
+        end
+
+        def validate
+          ensure_has_required_keys &&
+            ensure_no_unrecognized_keys &&
+            ensure_keys_are_correct_types
+        end
+
+        private
+
+        # The base keys required for this attribute to be valid and their
+        # expected types. Types can also be specified as an array of discrete
+        # expected values.
+        # This can be overwritten in sub-validator class.
+        #
+        # @return [Hash]
+        def required_keys
+          {
+            "name" => String,
+            "type" => String
+          }
+        end
+
+        # Either a class or array of values we expect the default to be.
+        # This can be overwritten in sub-validator class.
+        def permitted_values_for_default_key
+          Object
+        end
+
+        # The optional keys that can be supplied for this attribute and their
+        # expected types. Types can also be specified as an array of discrete
+        # expected values.
+        # This can be overwritten in sub-validator class.
+        #
+        # @return [Hash]
+        def optional_keys
+          {
+            "default" => permitted_values_for_default_key,
+            "array" => [true, false],
+            "label" => String,
+            "hint" => String,
+            "group" => %w[content layout design mobile]
+          }
+        end
+
+        def all_permitted_keys
+          required_keys.merge(optional_keys)
+        end
+
+        def ensure_has_required_keys
+          missing_keys = required_keys.keys - attribute.keys
+          return true if missing_keys.empty?
+
+          @errors << "Missing required keys: #{missing_keys.join(', ')}"
+          false
+        end
+
+        def ensure_no_unrecognized_keys
+          unrecognized_keys = attribute.keys - all_permitted_keys.keys
+          return true if unrecognized_keys.empty?
+
+          @errors << "Unrecognized keys: #{unrecognized_keys.join(', ')}"
+          false
+        end
+
+        def ensure_keys_are_correct_types
+          all_permitted_keys.each do |key, expected|
+            if expected.is_a?(Class)
+              if attribute.key?(key) && !attribute[key].is_a?(expected)
+                actual = attribute[key].class.name
+                @errors << "\"#{key}\" is a #{actual}, expected #{expected}"
+                return false
+              end
+            else
+              if attribute.key?(key) && !expected.include?(attribute[key])
+                actual = attribute[key].to_s
+                @errors << "\"#{key}\" is '#{actual}', expected one of: #{[*expected].join(', ')}"
+                return false
+              end
+            end
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/color.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to color-type variables.
+      class Color < Base
+        def validate
+          super &&
+            ensure_default_keys_are_valid &&
+            ensure_default_values_are_valid
+        end
+
+        private
+
+        def permitted_values_for_default_key
+          Hash
+        end
+
+        def ensure_default_keys_are_valid
+          return true unless attribute.key?("default")
+          return true if attribute["default"].key?("palette")
+
+          key_diff = %w[r g b] - attribute["default"].keys
+          if key_diff.any? && key_diff != ["a"]
+            @errors << "\"default\" for color-type variables must include palette or rgba values"
+            return false
+          end
+
+          true
+        end
+
+        def ensure_default_values_are_valid
+          return true unless attribute.key?("default")
+
+          if attribute["default"].key?("palette")
+            ensure_palette_value_is_valid
+          else
+            ensure_rgb_value_is_valid
+          end
+        end
+
+        def ensure_palette_value_is_valid
+          return true if Constants::COLOR_PALETTE_VALUES.include?(attribute["default"]["palette"])
+
+          @errors << "\"default\" value for palette color-type must be one of "\
+                     "the following values: #{Constants::COLOR_PALETTE_VALUES.join(', ')}"
+          false
+        end
+
+        def ensure_rgb_value_is_valid
+          invalid_rgb_error = "\"default\" values for color-type variables must be "\
+                              "between 0 and 255 for rgb, and between 0 and 1 for a"
+
+          attribute["default"].each do |key, value|
+            if %w[r g b].include?(key) && !valid_rgb_value?(value)
+              @errors << invalid_rgb_error
+              return false
+            end
+
+            if key == "a" && !valid_alpha_value?(value)
+              @errors << invalid_rgb_error
+              return false
+            end
+          end
+
+          true
+        end
+
+        def valid_rgb_value?(value)
+          value.to_s.match?(/\A\d+\z/) && value.to_i.between?(0, 255)
+        end
+
+        def valid_alpha_value?(value)
+          value.to_s.match?(/([0-9]*[.])?[0-9]+/) && value.to_f.between?(0, 1)
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/image.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to link-type variables.
+      class Image < Base
+        ALLOWED_DEFAULT_KEYS = %w[url asset].freeze
+
+        def validate
+          super && ensure_default_key_is_valid
+        end
+
+        private
+
+        def ensure_default_key_is_valid
+          return true unless attribute.key?("default")
+
+          if attribute["array"]
+            attribute["default"].all? { |value| default_value_is_validate(value) }
+          else
+            default_value_is_validate(attribute["default"])
+          end
+        end
+
+        # The default value can be one of 3 different formats:
+        # - A string (for backwards compatibility) e.g. "http://my-image.jpg"
+        # - A hash with "url" key" e.g. { "url": "http://my-image.jpg" }
+        # - A hash with "asset" key" e.g. { "asset": "http://my-image.jpg" }
+        def default_value_is_validate(value)
+          return true if value.is_a?(String)
+
+          return true if value.is_a?(Hash) &&
+                         value.keys.size == 1 &&
+                         ALLOWED_DEFAULT_KEYS.include?(value.keys.first) &&
+                         value.values.first.is_a?(String)
+
+          @errors << "\"default\" for image-type variables must include a single url or asset value"
+          false
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/link.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to link-type variables.
+      class Link < Base
+        ALLOWED_DEFAULT_KEYS = %w[url page post product].freeze
+        INVALID_DEFAULT_ERROR = "\"default\" for link-type variables must include "\
+                                "a single url, page, post or product value"
+
+        def validate
+          super &&
+            ensure_single_default_provided &&
+            ensure_default_key_is_valid
+        end
+
+        private
+
+        def permitted_values_for_default_key
+          Hash
+        end
+
+        def ensure_default_key_is_valid
+          return true unless attribute.key?("default")
+
+          key = attribute["default"].keys.first
+
+          unless ALLOWED_DEFAULT_KEYS.include?(key)
+            @errors << INVALID_DEFAULT_ERROR
+            return false
+          end
+
+          true
+        end
+
+        def ensure_single_default_provided
+          return true unless attribute.key?("default")
+
+          if attribute["default"].count != 1
+            @errors << INVALID_DEFAULT_ERROR
+            return false
+          end
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/number.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to number-type variables.
+      class Number < Base
+        private
+
+        def optional_keys
+          super.merge("unit" => String)
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/page.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to page-type variables.
+      class Page < Base
+        ALLOWED_DEFAULT_VALUES = %w[ random ].freeze
+
+        def validate
+          super &&
+            ensure_default_values_are_valid
+        end
+
+        private
+
+        def permitted_values_for_default_key
+          if attribute["array"]
+            Array
+          else
+            String
+          end
+        end
+
+        def ensure_default_values_are_valid
+          return true unless attribute.key?("default")
+
+          if attribute["array"]
+            attribute["default"].all? { |value| default_value_is_validate(value) }
+          else
+            default_value_is_validate(attribute["default"])
+          end
+        end
+
+        def default_value_is_validate(value)
+          value = value.downcase
+          if !ALLOWED_DEFAULT_VALUES.include?(value)
+            @errors << "\"default\" for page-type variables must be "\
+                       "one of: #{ALLOWED_DEFAULT_VALUES.join(', ')}"
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/post.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to post-type variables.
+      class Post < Base
+        ALLOWED_DEFAULT_VALUES = %w[random].freeze
+
+        def validate
+          super &&
+            ensure_default_values_are_valid
+        end
+
+        private
+
+        def permitted_values_for_default_key
+          if attribute["array"]
+            Array
+          else
+            String
+          end
+        end
+
+        def ensure_default_values_are_valid
+          return true unless attribute.key?("default")
+
+          if attribute["array"]
+            attribute["default"].all? { |value| default_value_is_valid?(value) }
+          else
+            default_value_is_valid?(attribute["default"])
+          end
+        end
+
+        def default_value_is_valid?(value)
+          value = value.downcase
+          if !ALLOWED_DEFAULT_VALUES.include?(value)
+            @errors << "\"default\" for post-type variables must be "\
+                       "one of: #{ALLOWED_DEFAULT_VALUES.join(', ')}"
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/product.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to product-type variables.
+      class Product < Base
+        ALLOWED_DEFAULT_VALUES = %w[random].freeze
+
+        def validate
+          super &&
+            ensure_default_values_are_valid
+        end
+
+        private
+
+        def permitted_values_for_default_key
+          if attribute["array"]
+            Array
+          else
+            String
+          end
+        end
+
+        def ensure_default_values_are_valid
+          return true unless attribute.key?("default")
+
+          if attribute["array"]
+            attribute["default"].all? { |value| default_value_is_valid?(value) }
+          else
+            default_value_is_valid?(attribute["default"])
+          end
+        end
+
+        def default_value_is_valid?(value)
+          value = value.downcase
+          if !ALLOWED_DEFAULT_VALUES.include?(value)
+            @errors << "\"default\" for product-type variables must be "\
+                       "one of: #{ALLOWED_DEFAULT_VALUES.join(', ')}"
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/radio.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to radio-type variables.
+      class Radio < Base
+        def validate
+          super &&
+            ensure_at_least_one_option &&
+            ensure_options_are_valid
+        end
+
+        private
+
+        def permitted_values_for_default_key
+          if attribute["options"].is_a?(Array)
+            attribute["options"].map { |option| option["value"] }
+          else
+            []
+          end
+        end
+
+        def required_keys
+          super.merge(
+            "options" => Array
+          )
+        end
+
+        def ensure_at_least_one_option
+          return true if attribute["options"].length.positive?
+
+          @errors << "Must provide at least 1 option for radio type variable"
+          false
+        end
+
+        def ensure_options_are_valid
+          return true if attribute["options"].all? { |option|
+            select_option_valid?(option)
+          }
+
+          @errors << "All options for radio type variable must specify a label and value"
+          false
+        end
+
+        def select_option_valid?(option)
+          option.is_a?(Hash) &&
+            option.key?("value") &&
+            option.key?("label")
+        end
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attributes/range.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Canvas
+  module Validator
+    class SchemaAttribute
+      # :documented:
+      # Attribute validations specific to range-type variables.
+      class Range < Base
+        private
+
+        def optional_keys
+          super.merge(
+            "min" => Object,
+            "max" => Object,
+            "step" => Object,
+            "unit" => String
+          )
+        end
+      end
+    end
+  end
+end