easol-canvas 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b413ee9262a5f7b363a8f53950da655c1c85aaf71474a331b412c62d5ae8f62
-  data.tar.gz: ecae8f840fffee09e161857beb61cb002d3006f63e00e7e52283342c228234a9
+  metadata.gz: 5446d70b87d779a13b4a5b3f132b91a29722d84167fcc2ac9b61a142e7b5a45c
+  data.tar.gz: ccc2f5bc197c2f7ec72969289989742f3400f69e2a2eb468c001fd994237f2bc
 SHA512:
-  metadata.gz: 42fe4d0cdede7d029e2e4c6ced43c23defb19a109bf11df3a4933d9411d2c6c83173042f4f2fee148573042760e62645eeb44b2e3af53e28b9bc91588c23d0a1
-  data.tar.gz: 492e9fbeb71dfc80b56874d83e441ec799ae7ab04dedd668dc3e47c0cdfaabb0c9c9312fdeff2b792039ca44fb127af1eb1d876072c12d4c468567c6e20b6d6a
+  metadata.gz: a1b2ab985beac4aef8812c35fcda2707c52fc204c26435d7bf9dd7b33441dc9666739e4a9319e64e1fab31fab8f46d73e7af79c63b14ae21a084f517c0e7f9ea
+  data.tar.gz: f57a9566ebb142092e574dc0889a636c673342e5a71e5ccc1f111951c4ac1fa78995dbbe090cd2de7d5c3cd073dbecd3999aca06889a3beb5419d72616547090

data/lib/canvas/checks/valid_block_schemas_check.rb

@@ -22,8 +22,9 @@ module Canvas
     def run
       custom_types = Canvas::FetchCustomTypes.call
       block_files.each do |filename|
-        file = File.read(filename)
-        front_matter = extract_front_matter(file)
+        front_matter = extract_front_matter(filename)
+        next unless front_matter
+
         validate_format(filename, front_matter) &&
           validate_schema(filename, front_matter, custom_types)
       end
@@ -37,7 +38,8 @@ module Canvas
 
     def validate_format(filename, front_matter)
       return true if front_matter.is_a?(Hash) &&
-                     front_matter.values.all? { |attr| attr.is_a?(Hash) }
+                     (front_matter.key?("attributes") ? front_matter["attributes"] : front_matter).values.all? { |attr| attr.is_a?(Hash) }
+
 
       @offenses << Offense.new(
         message: "Invalid Block Schema: #{filename} - \nSchema is not in a valid format"
@@ -45,8 +47,7 @@ module Canvas
       false
     end
 
-    def validate_schema(filename, front_matter, custom_types)
-      schema = extract_schema(front_matter)
+    def validate_schema(filename, schema, custom_types)
       validator = Validator::BlockSchema.new(schema: schema, custom_types: custom_types)
       return if validator.validate
 
@@ -57,16 +58,18 @@ module Canvas
       end
     end
 
-    def extract_front_matter(file)
+    def extract_front_matter(filename)
+      file = File.read(filename)
+
       extractor = Canvas::FrontMatterExtractor.new(file)
       front_matter = extractor.front_matter
       front_matter.nil? ? {} : YAML.safe_load(front_matter)
-    end
+    rescue Psych::SyntaxError
+      @offenses << Offense.new(
+        message: "Invalid Block Schema: #{filename} - \nFront matter's YAML is not in a valid format"
+      )
 
-    def extract_schema(front_matter)
-      {
-        "attributes" => Canvas::ExpandAttributes.call(front_matter)
-      }
+      nil
     end
   end
 end

data/lib/canvas/checks/valid_footer_schema_check.rb

@@ -51,8 +51,7 @@ module Canvas
         front_matter["attributes"].values.all? { |attr| attr.is_a?(Hash) }
     end
 
-    def validate_schema(front_matter)
-      schema = extract_schema(front_matter)
+    def validate_schema(schema)
       validator = Validator::FooterSchema.new(
         schema: schema,
         custom_types: Canvas::FetchCustomTypes.call
@@ -71,11 +70,5 @@ module Canvas
       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_menu_schema_check.rb

@@ -51,8 +51,7 @@ module Canvas
         front_matter["attributes"].values.all? { |attr| attr.is_a?(Hash) }
     end
 
-    def validate_schema(front_matter)
-      schema = extract_schema(front_matter)
+    def validate_schema(schema)
       validator = Validator::MenuSchema.new(
         schema: schema,
         custom_types: Canvas::FetchCustomTypes.call
@@ -71,11 +70,5 @@ module Canvas
       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/services/expand_attributes.rb

@@ -30,6 +30,7 @@ module Canvas
       # @return [Array<Hash>] array of hashes that represent each attribute
       def call(attributes_hash)
         return [] if attributes_hash.nil?
+        return attributes_hash if attributes_hash.is_a?(Array)
 
         attributes_hash.each_with_object([]) do |(name, attribute_hash), attrs|
           attrs << attribute_hash.merge("name" => name)

data/lib/canvas/validators/block_schema.rb

@@ -9,35 +9,46 @@ module Canvas
     # This class is used to validate a schema for a block.
     # Example of a valid block schema:
     # {
-    #   "attributes" => [
-    #     {
-    #       "name" => "my_title",
+    #   "attributes" => {
+    #     "my_title" => {
     #       "type" => "string"
     #     },
-    #     {
-    #       "name" => "my_color",
+    #     "my_color" => {
     #       "type" => "color",
     #       "label" => "My color",
     #       "hint" => "Select your favourite color"
     #     }
+    #   },
+    #   "layout" => [
+    #     {
+    #       "type" => "tab",
+    #       "label" => "Content",
+    #       "elements" => [
+    #         "my_title",
+    #         "my_color"
+    #       ]
+    #     }
     #   ]
     # }
     class BlockSchema
-      PERMITTED_KEYS = %w[attributes].freeze
+      PERMITTED_KEYS = %w[attributes layout].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
+        @schema = normalize_schema(schema)
         @custom_types = custom_types
         @errors = []
       end
 
       def validate
+        @errors = []
+
         if ensure_valid_format
           ensure_no_unrecognized_keys
+          ensure_layout_is_valid
           ensure_attributes_are_valid
         end
 
@@ -48,12 +59,22 @@ module Canvas
 
       def ensure_valid_format
         return true if schema.is_a?(Hash) &&
-                       (schema["attributes"].nil? || attributes_array_of_hashes?(schema))
+                       (schema["attributes"].nil? || attributes_hash_of_hashes?(schema))
 
         @errors << "Schema is not in a valid format"
         false
       end
 
+      def ensure_layout_is_valid
+        return true unless schema["layout"]
+
+        layout_validator = LayoutSchema.new(schema: @schema)
+        return true if layout_validator.validate
+
+        @errors += layout_validator.errors
+        false
+      end
+
       def ensure_no_unrecognized_keys
         unrecognized_keys = schema.keys - PERMITTED_KEYS
         return true if unrecognized_keys.empty?
@@ -65,7 +86,8 @@ module Canvas
       def ensure_attributes_are_valid
         return true unless schema["attributes"]
 
-        schema["attributes"].each do |attribute_schema|
+        attributes = Canvas::ExpandAttributes.call(schema["attributes"])
+        attributes.each do |attribute_schema|
           attr_validator = Validator::SchemaAttribute.new(
             attribute: attribute_schema,
             custom_types: @custom_types
@@ -77,9 +99,17 @@ module Canvas
         end
       end
 
-      def attributes_array_of_hashes?(schema)
-        schema["attributes"].is_a?(Array) &&
-          schema["attributes"].all? { |attr| attr.is_a?(Hash) }
+      def attributes_hash_of_hashes?(schema)
+        schema["attributes"].is_a?(Hash) &&
+          schema["attributes"].values.all? { |attr| attr.is_a?(Hash) }
+      end
+
+      # To support older schemas that do not nest the attributes
+      # under the `attributes` key.
+      def normalize_schema(schema)
+        return schema if schema.key?("attributes")
+
+        { "attributes" => schema }
       end
     end
   end

data/lib/canvas/validators/footer_schema.rb

@@ -11,19 +11,27 @@ module Canvas
     #
     # 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"
+    #   "max_item_levels" => 2,
+    #   "supports_open_new_tab" => "true",
+    #   "attributes" => {
+    #      "text_color" => {
+    #        "type" => "color"
+    #      },
+    #      "background_color" => {
+    #        "type" => "color"
     #      }
-    #   }
+    #   },
+    #   "layout" => [
+    #     {
+    #       "type" => "tab",
+    #       "label" => "Content",
+    #       "elements" => [
+    #         "text_color",
+    #         "background_color"
+    #       ]
+    #     }
+    #   ]
     # }
-    #
     class FooterSchema < MenuSchema; end
   end
 end

data/lib/canvas/validators/layout_schema.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "json"
+require "json-schema"
+
+module Canvas
+  module Validator
+    # :documented:
+    # This class is used to validate a layout definition, part of block schema.
+    # Example of a valid layout definition:
+    # {
+    #   "attributes" => {
+    #     "title" => {
+    #       "type" => "string"
+    #     }
+    #     ...
+    #   },
+    #   "layout" => [
+    #     {
+    #       "label" => "Design",
+    #       "type" => "tab",
+    #         "elements" => [
+    #         "heading",
+    #         {
+    #           "type" => "accordion",
+    #           "label" => "Logo",
+    #           "elements" => [
+    #             "description",
+    #             { "type" => "attribute", "name" => "logo_alt" },
+    #             "title"
+    #           ]
+    #         },
+    #         {
+    #           "type" => "accordion_toggle",
+    #           "toggle_attribute" => "cta_enabled",
+    #           "elements" => [
+    #             "cta_text",
+    #             "cta_target"
+    #           ]
+    #         }
+    #       ]
+    #     }
+    #   ]
+    # }
+    class LayoutSchema
+      attr_reader :errors
+
+      def initialize(schema:)
+        @schema = schema
+        @errors = []
+      end
+
+      def validate
+        @errors = []
+
+        if ensure_valid_format
+          ensure_no_unrecognized_keys
+          ensure_no_duplicate_keys
+          ensure_accordion_toggles_are_valid
+        end
+
+        @errors.empty?
+      end
+
+      private
+
+      attr_reader :schema
+
+      def ensure_no_duplicate_keys
+        attributes = fetch_all_attribute_names
+        duplicates =
+          attributes
+          .group_by { |(key)| key }
+          .filter { |key, usage| usage.size > 1 }
+
+        unless duplicates.empty?
+          duplicates.each do |attribute, usage|
+            @errors << "Duplicated attribute key `#{attribute}` found. Location: #{usage.map { |(_, location)| location }.join(", ")}"
+          end
+        end
+      end
+
+      def ensure_no_unrecognized_keys
+        attributes = fetch_all_attribute_names
+        defined_attributes = expanded_attributes.map { |definition| normalize_attribute(definition["name"]) } || []
+
+        attributes.each do |attribute, location|
+          @errors << "Unrecognized attribute `#{attribute}`. Location: #{location}" unless defined_attributes.include?(attribute)
+        end
+      end
+
+      # @return [Array<Array(String, String)>] an array of all the attribute names that
+      #         are mentioned in the layout schema, along with its path. The names are
+      #         normalized, i.e. downcased.
+      def fetch_all_attribute_names
+        attributes = fetch_elements_of_type("attribute")
+        attributes.map do |(node, path)|
+          [
+            normalize_attribute(node.is_a?(Hash) ? node["name"] : node),
+            path
+          ]
+        end
+      end
+
+      # @param type [String] the element type to fetch
+      # @return [Array<Array(<Hash, String>, String)] an array of elements that match
+      #   the given type. Each element is an array containing the node and its path.
+      def fetch_elements_of_type(type)
+        elements = []
+
+        fetch_element = ->(node, path) {
+          if type == "attribute" && node.is_a?(String)
+            elements << [node, path]
+          elsif node["type"] == type
+            elements << [node, path]
+          end
+
+          if node.is_a?(Hash) && node.key?("elements")
+            node["elements"].each_with_index do |element, i|
+              current_path = "#{path}/elements/#{i}"
+              fetch_element.call(element, current_path)
+            end
+          end
+        }
+
+        layout_schema.each_with_index do |tab, i|
+          current_path = "layout/#{i}"
+          fetch_element.call(tab, current_path)
+        end
+
+        elements
+      end
+
+      def ensure_valid_format
+        result = JSON::Validator.fully_validate(schema_definition, { "layout" => layout_schema }, strict: true, clear_cache: true)
+
+        return true if result.empty?
+
+        @errors += result
+        false
+      end
+
+      def ensure_accordion_toggles_are_valid
+        accordion_toggles = fetch_elements_of_type("accordion_toggle")
+        accordion_toggles.each do |accordion_toggle, location|
+          toggle_attribute = expanded_attributes.detect { |attr|
+            attr["name"] == accordion_toggle["toggle_attribute"]
+          }
+
+          if toggle_attribute.nil?
+            @errors << "The toggle_attribute in accordion_toggle is unrecognized. Location: #{location}"
+          elsif toggle_attribute["type"]&.downcase != "boolean"
+            @errors << "The toggle_attribute in accordion_toggle must be a boolean. Location: #{location}"
+          end
+        end
+      end
+
+      def layout_schema
+        schema["layout"] || []
+      end
+
+      def schema_definition
+        File.read(
+          File.join(File.dirname(__FILE__), "../../../", "schema_definitions", "layout.json")
+        )
+      end
+
+      def normalize_attribute(name)
+        name.strip.downcase
+      end
+
+      def expanded_attributes
+        return [] if schema["attributes"].nil?
+
+        @_expanded_attributes ||= Canvas::ExpandAttributes.call(schema["attributes"])
+      end
+    end
+  end
+end

data/lib/canvas/validators/menu_schema.rb

@@ -7,21 +7,33 @@ module Canvas
     #
     # 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"
+    #   "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"
+    #      },
+    #      "background_color" => {
+    #        "type" => "color"
     #      }
-    #   }
+    #   },
+    #   "layout" => [
+    #     {
+    #       "type" => "tab",
+    #       "label" => "Content",
+    #       "elements" => [
+    #         "fixed",
+    #         "background_color"
+    #       ]
+    #     }
+    #   ]
     # }
-    #
     class MenuSchema
-      PERMITTED_KEYS = %w[max_item_levels supports_open_new_tab attributes].freeze
+      PERMITTED_KEYS = %w[max_item_levels supports_open_new_tab attributes layout].freeze
       ADDITIONAL_RESERVED_NAMES = %w[items type].freeze
 
       attr_reader :schema, :errors
@@ -38,6 +50,7 @@ module Canvas
         if ensure_valid_format
           ensure_no_unrecognized_keys
           ensure_max_item_levels_is_valid
+          ensure_layout_is_valid
           ensure_attributes_are_valid
         end
 
@@ -48,7 +61,7 @@ module Canvas
 
       def ensure_valid_format
         return true if schema.is_a?(Hash) &&
-                       (schema["attributes"].nil? || attributes_array_of_hashes?(schema))
+                       (schema["attributes"].nil? || attributes_hash_of_hashes?(schema))
 
         @errors << "Schema is not in a valid format"
         false
@@ -70,10 +83,21 @@ module Canvas
         false
       end
 
+      def ensure_layout_is_valid
+        return true unless schema["layout"]
+
+        layout_validator = LayoutSchema.new(schema: @schema)
+        return true if layout_validator.validate
+
+        @errors += layout_validator.errors
+        false
+      end
+
       def ensure_attributes_are_valid
         return true unless schema["attributes"]
 
-        schema["attributes"].each do |attribute_schema|
+        attributes = Canvas::ExpandAttributes.call(schema["attributes"])
+        attributes.each do |attribute_schema|
           attr_validator = Validator::SchemaAttribute.new(
             attribute: attribute_schema,
             custom_types: @custom_types,
@@ -86,9 +110,9 @@ module Canvas
         end
       end
 
-      def attributes_array_of_hashes?(schema)
-        schema["attributes"].is_a?(Array) &&
-          schema["attributes"].all? { |attr| attr.is_a?(Hash) }
+      def attributes_hash_of_hashes?(schema)
+        schema["attributes"].is_a?(Hash) &&
+          schema["attributes"].values.all? { |attr| attr.is_a?(Hash) }
       end
     end
   end

data/lib/canvas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canvas
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

data/schema_definitions/layout.json

@@ -0,0 +1,87 @@
+{
+  "type": "object",
+  "properties": {
+    "layout": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/tab" }
+    }
+  },
+  "$defs": {
+    "tab": {
+      "type": "object",
+      "required": ["type", "label"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "const": "tab"
+        },
+        "label": {
+          "type": "string"
+        },
+        "elements": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "oneOf": [
+              { "type": "string" },
+              { "$ref": "#/$defs/accordion" },
+              { "$ref": "#/$defs/accordion_toggle" },
+              { "$ref": "#/$defs/attribute" }
+            ]
+          }
+        }
+      }
+    },
+    "accordion": {
+      "type": "object",
+      "required": ["label", "type"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "const": "accordion"
+        },
+        "label": {
+          "type": "string"
+        },
+        "elements": {
+          "type": "array",
+          "items": {
+            "oneOf": [{ "type": "string" }, { "$ref": "#/$defs/attribute" }]
+          }
+        }
+      }
+    },
+    "accordion_toggle": {
+      "type": "object",
+      "required": ["type", "toggle_attribute", "elements"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "const": "accordion_toggle"
+        },
+        "toggle_attribute": {
+          "type": "string"
+        },
+        "elements": {
+          "type": "array",
+          "items": {
+            "oneOf": [{ "type": "string" }, { "$ref": "#/$defs/attribute" }]
+          }
+        }
+      }
+    },
+    "attribute": {
+      "type": "object",
+      "required": ["name", "type"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "const": "attribute"
+        },
+        "name": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: easol-canvas
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Kyle Byrne
 - Ian Mooney
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-06 00:00:00.000000000 Z
+date: 2022-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -81,6 +81,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 description: |
   Canvas is a command line tool to help with building themes for Easol.
   It provides tooling to check theme directories for errors and to make sure
@@ -117,6 +131,7 @@ files:
 - lib/canvas/validators/footer_schema.rb
 - lib/canvas/validators/html.rb
 - lib/canvas/validators/json.rb
+- lib/canvas/validators/layout_schema.rb
 - lib/canvas/validators/liquid.rb
 - lib/canvas/validators/menu_schema.rb
 - lib/canvas/validators/sass.rb
@@ -135,11 +150,12 @@ files:
 - lib/canvas/validators/schema_attributes/variant.rb
 - lib/canvas/version.rb
 - lib/easol/canvas.rb
+- schema_definitions/layout.json
 homepage: https://rubygems.org/gems/easol-canvas
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -154,8 +170,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: CLI to help with building themes for Easol
 test_files: []