easol-canvas 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 466969ef38180518fc021186d0c5fa694a3ddf947bae466c7cabed401fa44c1e
-  data.tar.gz: 2521767c9f3eff3944c4b897b503c14715d52abf6642e30f1d330403ea167d85
+  metadata.gz: 8570c1c4d1a8f7097f621722730ca8c882b633b901c8d22fb13f7dcbcb2ac8df
+  data.tar.gz: d10b1319c6e1be3e0e43a77575fbf73f71f4a9f77582486d5b34d374d9c42105
 SHA512:
-  metadata.gz: 6b49d991c487acd1fe4bac1219a3c67d98b68ba56757ccd4fc7b7310f0532942bc1377431b1ec29e729ffff77d00cb6a63313e6cd07329080970720036b2f29f
-  data.tar.gz: 616a6b356396c5aee908a21449633508d1336ad695a6f5b0e690b276f1d1b8eade52cd0eb919329199d7cd661066f60fce6d2c3f8a1b1639094c5b3f00debad0
+  metadata.gz: 2dbfd55872ab41728e9243392a02c64551379cf42b99f59e455ade832fc028aa154b78e93600ec8bba8ac4fdcc52001850f2fd9cead452d64b896e1a997a0c63
+  data.tar.gz: d6507b81b2fe0f72aad4407601606fa305b45e0d2142753eccc03cda5760277ceeaf54f83b6d8468274490e33afa4360da7174dd23599b4e5aa0a9fe484ab5d3

data/lib/canvas/checks/valid_block_schemas_check.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Canvas
+  # :documented:
+  # This check will validate the schema defined in the front matter
+  # within each block template file.
+  #
+  # Example of block Liquid with valid front matter:
+  #
+  # ---
+  # my_title:
+  #   type: string
+  # my_color:
+  #   type: color
+  #   label: My color
+  #   hint: "Select your favourite color"
+  # ---
+  #
+  # <p>My block HTML</p>
+  #
+  class ValidBlockSchemasCheck < Check
+    def run
+      custom_types = Canvas::FetchCustomTypes.call
+      block_files.each do |filename|
+        file = File.read(filename)
+        front_matter = extract_front_matter(file)
+        validate_format(filename, front_matter) &&
+          validate_schema(filename, front_matter, custom_types)
+      end
+    end
+
+    private
+
+    def block_files
+      Dir.glob("blocks/**/*.{html,liquid}")
+    end
+
+    def validate_format(filename, front_matter)
+      return true if front_matter.is_a?(Hash) &&
+                     front_matter.values.all? { |attr| attr.is_a?(Hash) }
+
+      @offenses << Offense.new(
+        message: "Invalid Block Schema: #{filename} - \nSchema is not in a valid format"
+      )
+      false
+    end
+
+    def validate_schema(filename, front_matter, custom_types)
+      schema = extract_schema(front_matter)
+      validator = Validator::BlockSchema.new(schema: schema, custom_types: custom_types)
+      return if validator.validate
+
+      validator.errors.each do |message|
+        @offenses << Offense.new(
+          message: "Invalid Block Schema: #{filename} - \n#{message}"
+        )
+      end
+    end
+
+    def extract_front_matter(file)
+      extractor = Canvas::FrontMatterExtractor.new(file)
+      front_matter = extractor.front_matter
+      front_matter.nil? ? {} : YAML.safe_load(front_matter)
+    end
+
+    def extract_schema(front_matter)
+      {
+        "attributes" => Canvas::ExpandAttributes.call(front_matter)
+      }
+    end
+  end
+end

data/lib/canvas/checks/valid_footer_schema_check.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Canvas
+  # :documented:
+  # This check will validate the schema defined in the front matter
+  # within each footer template file.
+  #
+  # Example of footer Liquid with valid front matter:
+  #
+  # ---
+  # max_item_levels: 2
+  # supports_open_new_tab: true
+  # attributes:
+  #   my_title:
+  #     type: string
+  #   my_color:
+  #     type: color
+  #     label: My color
+  #     hint: "Select your favourite color"
+  # ---
+  #
+  # <p>My footer HTML</p>
+  #
+  class ValidFooterSchemaCheck < Check
+    def run
+      file = File.read(footer_filename)
+      front_matter = extract_front_matter(file)
+      validate_format(front_matter) &&
+        validate_schema(front_matter)
+    end
+
+    private
+
+    def footer_filename
+      Dir.glob("partials/footer/index.{html,liquid}").first
+    end
+
+    def validate_format(front_matter)
+      return true if front_matter.is_a?(Hash) && attributes_valid_format(front_matter)
+
+      @offenses << Offense.new(
+        message: "Invalid Footer Schema: #{footer_filename} - \nSchema is not in a valid format"
+      )
+      false
+    end
+
+    def attributes_valid_format(front_matter)
+      return true unless front_matter.key?("attributes")
+
+      front_matter["attributes"].is_a?(Hash) &&
+        front_matter["attributes"].values.all? { |attr| attr.is_a?(Hash) }
+    end
+
+    def validate_schema(front_matter)
+      schema = extract_schema(front_matter)
+      validator = Validator::FooterSchema.new(
+        schema: schema,
+        custom_types: Canvas::FetchCustomTypes.call
+      )
+      return if validator.validate
+
+      validator.errors.each do |message|
+        @offenses << Offense.new(
+          message: "Invalid Footer Schema: #{footer_filename} - \n#{message}"
+        )
+      end
+    end
+
+    def extract_front_matter(file)
+      extractor = Canvas::FrontMatterExtractor.new(file)
+      front_matter = extractor.front_matter
+      front_matter.nil? ? {} : YAML.safe_load(front_matter)
+    end
+
+    def extract_schema(front_matter)
+      front_matter.merge(
+        "attributes" => Canvas::ExpandAttributes.call(front_matter["attributes"])
+      )
+    end
+  end
+end

data/lib/canvas/checks/valid_json_check.rb

@@ -0,0 +1,24 @@
+module Canvas
+  class ValidJsonCheck < Check
+    def run
+      json_files.each do |filename|
+        file = File.read(filename)
+        validator = Validator::Json.new(file)
+
+        next if validator.validate
+
+        validator.errors.each do |message|
+          @offenses << Offense.new(
+            message: "Invalid JSON: #{filename} - \n#{message}"
+          )
+        end
+      end
+    end
+
+    private
+
+    def json_files
+      Dir.glob("**/*.json")
+    end
+  end
+end

data/lib/canvas/checks/valid_liquid_check.rb

@@ -9,7 +9,7 @@ module Canvas
 
         next if validator.validate
 
-        validator.errors.map(&:message).each do |message|
+        validator.errors.each do |message|
           @offenses << Offense.new(
             message: "Invalid Liquid: #{filename} - \n#{message}"
           )

data/lib/canvas/checks/valid_menu_schema_check.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Canvas
+  # :documented:
+  # This check will validate the schema defined in the front matter
+  # within each menu template file.
+  #
+  # Example of menu Liquid with valid front matter:
+  #
+  # ---
+  # max_item_levels: 2
+  # supports_open_new_tab: true
+  # attributes:
+  #   my_title:
+  #     type: string
+  #   my_color:
+  #     type: color
+  #     label: My color
+  #     hint: "Select your favourite color"
+  # ---
+  #
+  # <p>My menu HTML</p>
+  #
+  class ValidMenuSchemaCheck < Check
+    def run
+      file = File.read(menu_filename)
+      front_matter = extract_front_matter(file)
+      validate_format(front_matter) &&
+        validate_schema(front_matter)
+    end
+
+    private
+
+    def menu_filename
+      Dir.glob("partials/menu/index.{html,liquid}").first
+    end
+
+    def validate_format(front_matter)
+      return true if front_matter.is_a?(Hash) && attributes_valid_format(front_matter)
+
+      @offenses << Offense.new(
+        message: "Invalid Menu Schema: #{menu_filename} - \nSchema is not in a valid format"
+      )
+      false
+    end
+
+    def attributes_valid_format(front_matter)
+      return true unless front_matter.key?("attributes")
+
+      front_matter["attributes"].is_a?(Hash) &&
+        front_matter["attributes"].values.all? { |attr| attr.is_a?(Hash) }
+    end
+
+    def validate_schema(front_matter)
+      schema = extract_schema(front_matter)
+      validator = Validator::MenuSchema.new(
+        schema: schema,
+        custom_types: Canvas::FetchCustomTypes.call
+      )
+      return if validator.validate
+
+      validator.errors.each do |message|
+        @offenses << Offense.new(
+          message: "Invalid Menu Schema: #{menu_filename} - \n#{message}"
+        )
+      end
+    end
+
+    def extract_front_matter(file)
+      extractor = Canvas::FrontMatterExtractor.new(file)
+      front_matter = extractor.front_matter
+      front_matter.nil? ? {} : YAML.safe_load(front_matter)
+    end
+
+    def extract_schema(front_matter)
+      front_matter.merge(
+        "attributes" => Canvas::ExpandAttributes.call(front_matter["attributes"])
+      )
+    end
+  end
+end

data/lib/canvas/constants.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Canvas
+  module Constants
+    COLOR_PALETTE_VALUES = %w[
+      primary
+      secondary
+      body-bg
+      body-color
+    ].freeze
+  end
+end

data/lib/canvas/services/expand_attributes.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Canvas
+  # :documented:
+  # This service will convert the attributes from a hash, as they are defined in the front matter,
+  # into an array of hashes that the {Canvas::Validator::SchemaAttribute} class expects.
+  # e.g. the following front matter:
+  #
+  # my_title:
+  #   type: string
+  # my_color:
+  #   type: color
+  #
+  # will get converted to:
+  #
+  # [
+  #   {
+  #     "name" => "my_title",
+  #     "type" => "string"
+  #   },
+  #   {
+  #     "name" => "my_color",
+  #     "type" => "color"
+  #   }
+  # ]
+  #
+  class ExpandAttributes
+    class << self
+      # @param attributes_hash [Hash] hash of attributes pulled from front matter
+      # @return [Array<Hash>] array of hashes that represent each attribute
+      def call(attributes_hash)
+        return [] if attributes_hash.nil?
+
+        attributes_hash.each_with_object([]) do |(name, attribute_hash), attrs|
+          attrs << attribute_hash.merge("name" => name)
+        end
+      end
+    end
+  end
+end

data/lib/canvas/services/fetch_custom_types.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Canvas
+  # :documented:
+  # This service can be used to fetch the custom types from the /types directory.
+  class FetchCustomTypes
+    class << self
+      # @return [Array<Hash>] a list of all the custom types defined in the
+      # theme within the /types directory.
+      def call
+        filenames = Dir.glob("types/*.json")
+        filenames.map { |filename| extract_json(filename) }.compact
+      end
+
+      private
+
+      def extract_json(filename)
+        file = File.read(filename)
+        JSON.parse(file)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/canvas/validators/block_schema.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "liquid"
+
+module Canvas
+  module Validator
+    # :documented:
+    # This class is used to validate a schema for a block.
+    # Example of a valid block schema:
+    # {
+    #   "attributes" => [
+    #     {
+    #       "name" => "my_title",
+    #       "type" => "string"
+    #     },
+    #     {
+    #       "name" => "my_color",
+    #       "type" => "color",
+    #       "label" => "My color",
+    #       "hint" => "Select your favourite color"
+    #     }
+    #   ]
+    # }
+    class BlockSchema
+      PERMITTED_KEYS = %w[attributes].freeze
+
+      attr_reader :errors, :schema
+
+      # @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_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_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
+          )
+          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/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

@@ -4,8 +4,8 @@ require "liquid"
 module Canvas
   module Validator
     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,21 @@
+require "json"
+
+module Canvas
+  module Validator
+    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

@@ -19,7 +19,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