easol-canvas 0.1.1 → 1.2.0

data/lib/canvas/validators/custom_type.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    # :documented:
+    # This class is used to validate the JSON defining a custom type.
+    #
+    # An example of a valid custom type:
+    # {
+    #   "key": "faq",
+    #   "name": "Faq",
+    #   "attributes": [
+    #     {
+    #       "name": "question",
+    #       "label": "Question",
+    #       "type": "string"
+    #     },
+    #     {
+    #       "name": "answer",
+    #       "label": "Answer",
+    #       "type": "text"
+    #     }
+    #   ]
+    # }
+    #
+    class CustomType
+      REQUIRED_KEYS = %w[key name attributes].freeze
+
+      attr_reader :schema, :errors
+
+      def initialize(schema:)
+        @schema = schema
+        @errors = []
+      end
+
+      def validate
+        ensure_valid_format &&
+          ensure_has_required_keys &&
+          ensure_no_unrecognized_keys &&
+          ensure_keys_are_correct_types &&
+          ensure_key_value_is_not_reserved &&
+          ensure_no_duplicate_attributes &&
+          ensure_attributes_are_valid &&
+          ensure_first_attribute_not_array
+
+        errors.empty?
+      end
+
+      private
+
+      def ensure_valid_format
+        return true if schema.is_a?(Hash)
+
+        @errors << "Schema is not in a valid format"
+        false
+      end
+
+      def ensure_has_required_keys
+        missing_keys = REQUIRED_KEYS - schema.keys
+        return true if missing_keys.empty?
+
+        @errors << "Missing required keys: #{missing_keys.join(', ')}"
+        false
+      end
+
+      def ensure_no_unrecognized_keys
+        unrecognized_keys = schema.keys - REQUIRED_KEYS
+        return true if unrecognized_keys.empty?
+
+        @errors << "Unrecognized keys: #{unrecognized_keys.join(', ')}"
+        false
+      end
+
+      def ensure_keys_are_correct_types
+        if !schema["key"].is_a?(String)
+          @errors << "\"key\" must be a string"
+          return false
+        end
+
+        if !schema["name"].is_a?(String)
+          @errors << "\"name\" must be a string"
+          return false
+        end
+
+        if !schema["attributes"].is_a?(Array) ||
+            schema["attributes"].empty? ||
+            schema["attributes"].any? { |a| !a.is_a?(Hash) }
+            @errors << "\"attributes\" must be an array of objects"
+          return false
+        end
+
+        true
+      end
+
+      # Ensuring the value for key doesn't clash with our primitive type keys.
+      # See {Canvas::Constants::PRIMITIVE_TYPES}
+      def ensure_key_value_is_not_reserved
+        if schema["key"] && Constants::PRIMITIVE_TYPES.include?(schema["key"].downcase)
+          @errors << "\"key\" can't be one of these reserved words: #{Constants::PRIMITIVE_TYPES.join(', ')}"
+          return false
+        end
+
+        true
+      end
+
+      def ensure_no_duplicate_attributes
+        attribute_names = schema["attributes"].map { |a| a["name"] }
+        duplicated_names = attribute_names.select { |a| attribute_names.count(a) > 1 }.uniq
+
+        return true if duplicated_names.empty?
+
+        @errors << "Some attributes are duplicated: #{duplicated_names.join(', ')}"
+        false
+      end
+
+      def ensure_attributes_are_valid
+        return true unless schema["attributes"]
+
+        schema["attributes"].each do |attribute_schema|
+          attr_validator = Validator::SchemaAttribute.new(
+            attribute: attribute_schema,
+            custom_types: []
+          )
+          next if attr_validator.validate
+
+          @errors << "Attribute \"#{attribute_schema['name']}\" is invalid "\
+                     "- #{attr_validator.errors.join(', ')}"
+        end
+      end
+
+      def ensure_first_attribute_not_array
+        first_attribute = schema.fetch("attributes").first
+
+        return true if first_attribute.nil? || first_attribute["array"] != true
+
+        @errors << "The first attribute cannot be an array"
+        false
+      end
+    end
+  end
+end

data/lib/canvas/validators/footer_schema.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# We need to require this file t ensure it is loaded first
+require_relative "menu_schema"
+
+module Canvas
+  module Validator
+    # :documented:
+    # This class is used to validate a schema for a footer. For now the logic is exactly the
+    # same as the menu schema.
+    #
+    # Example:
+    # {
+    #   "max_item_levels": 2,
+    #   "supports_open_new_tab": "true",
+    #   "attributes": {
+    #      "fixed": {
+    #         "group": "design",
+    #         "label": "Fixed when scrolling",
+    #         "hint": "The menu will stay fixed to the top when scrolling down the page.",
+    #         "type": "boolean",
+    #         "default: "false"
+    #      }
+    #   }
+    # }
+    #
+    class FooterSchema < MenuSchema; end
+  end
+end

data/lib/canvas/validators/html.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require "nokogiri"
 require "liquid"
 
 module Canvas
   module Validator
+    # :documented:
     class Html
-      LIQUID_TAG = /#{Liquid::TagStart}.*?#{Liquid::TagEnd}/om
-      LIQUID_VARIABLE = /#{Liquid::VariableStart}.*?#{Liquid::VariableEnd}/om
+      LIQUID_TAG = /#{::Liquid::TagStart}.*?#{::Liquid::TagEnd}/om
+      LIQUID_VARIABLE = /#{::Liquid::VariableStart}.*?#{::Liquid::VariableEnd}/om
       LIQUID_TAG_OR_VARIABLE = /#{LIQUID_TAG}|#{LIQUID_VARIABLE}/om
 
       attr_reader :errors

data/lib/canvas/validators/json.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Canvas
+  module Validator
+    # :documented:
+    class Json
+      attr_reader :errors
+
+      def initialize(file)
+        @file = file
+      end
+
+      def validate
+        ::JSON.parse(@file)
+        true
+      rescue ::JSON::ParserError => e
+        @errors = [e.message]
+        false
+      end
+    end
+  end
+end

data/lib/canvas/validators/liquid.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 require "nokogiri"
 require "liquid"
 
 module Canvas
   module Validator
+    # :documented:
     class Liquid
       attr_reader :errors
 
@@ -19,7 +22,7 @@ module Canvas
         )
         true
       rescue ::Liquid::SyntaxError => e
-        @errors = [e]
+        @errors = [e.message]
         false
       end
 

data/lib/canvas/validators/menu_schema.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Validator
+    # :documented:
+    # This class is used to validate a schema for a menu.
+    #
+    # Example:
+    # {
+    #   "max_item_levels": 2,
+    #   "supports_open_new_tab": "true",
+    #   "attributes": {
+    #      "fixed": {
+    #         "group": "design",
+    #         "label": "Fixed when scrolling",
+    #         "hint": "The menu will stay fixed to the top when scrolling down the page.",
+    #         "type": "boolean",
+    #         "default: "false"
+    #      }
+    #   }
+    # }
+    #
+    class MenuSchema
+      PERMITTED_KEYS = %w[max_item_levels supports_open_new_tab attributes].freeze
+      ADDITIONAL_RESERVED_NAMES = %w[items type].freeze
+
+      attr_reader :schema, :errors
+
+      # @param schema [Hash] the schema to be validated
+      # @param custom_types [Array<Hash>] a list of custom types
+      def initialize(schema:, custom_types: [])
+        @schema = schema
+        @custom_types = custom_types
+        @errors = []
+      end
+
+      def validate
+        if ensure_valid_format
+          ensure_no_unrecognized_keys
+          ensure_max_item_levels_is_valid
+          ensure_attributes_are_valid
+        end
+
+        @errors.empty?
+      end
+
+      private
+
+      def ensure_valid_format
+        return true if schema.is_a?(Hash) &&
+                       (schema["attributes"].nil? || attributes_array_of_hashes?(schema))
+
+        @errors << "Schema is not in a valid format"
+        false
+      end
+
+      def ensure_no_unrecognized_keys
+        unrecognized_keys = schema.keys - PERMITTED_KEYS
+        return true if unrecognized_keys.empty?
+
+        @errors << "Unrecognized keys: #{unrecognized_keys.join(', ')}"
+        false
+      end
+
+      def ensure_max_item_levels_is_valid
+        return true unless schema.key?("max_item_levels")
+        return true if [1, 2, 3].include?(schema["max_item_levels"].to_i)
+
+        @errors << "\"max_item_levels\" must be a number between 1 and 3"
+        false
+      end
+
+      def ensure_attributes_are_valid
+        return true unless schema["attributes"]
+
+        schema["attributes"].each do |attribute_schema|
+          attr_validator = Validator::SchemaAttribute.new(
+            attribute: attribute_schema,
+            custom_types: @custom_types,
+            additional_reserved_names: ADDITIONAL_RESERVED_NAMES
+          )
+          next if attr_validator.validate
+
+          @errors << "Attribute \"#{attribute_schema['name']}\" is invalid "\
+                     "- #{attr_validator.errors.join(', ')}"
+        end
+      end
+
+      def attributes_array_of_hashes?(schema)
+        schema["attributes"].is_a?(Array) &&
+          schema["attributes"].all? { |attr| attr.is_a?(Hash) }
+      end
+    end
+  end
+end

data/lib/canvas/validators/sass.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "sassc"
+
+module Canvas
+  module Validator
+    # :documented:
+    #
+    # This validator can be used to validate Sass.
+    class Sass
+      attr_reader :errors
+
+      def initialize(file)
+        @file = file
+      end
+
+      def validate
+        SassC::Engine.new(@file, style: :compressed).render
+        true
+      rescue SassC::SyntaxError => e
+        @errors = [e.message]
+        false
+      end
+    end
+  end
+end

data/lib/canvas/validators/schema_attribute.rb

@@ -0,0 +1,146 @@
+# 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
+      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
+        Constants::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