wcc-contentful-app 0.4.0.pre.rc → 1.0.0.pre.rc1

data/Gemfile

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in wcc-contentful.gemspec
-gemspec
-
-gem 'wcc-contentful', path: File.expand_path('../wcc-contentful', __dir__)

data/lib/generators/wcc/templates/menu/generated_add_menus.ts

@@ -1,192 +0,0 @@
-
-import Migration from 'contentful-migration-cli'
-
-export = function (migration: Migration) {
-  const menu = migration.createContentType('menu', {
-    displayField: 'name',
-    name: 'Menu',
-    description: 'A Menu contains a number of Menu Buttons or other Menus, ' +
-      'which will be rendered as drop-downs.'
-  })
-
-  menu.createField('name', {
-    name: 'Menu Name',
-    type: 'Symbol',
-    localized: false,
-    required: true,
-    validations: [],
-    disabled: false,
-    omitted: false
-  })
-
-  menu.createField('items', {
-    name: 'Items',
-    type: 'Array',
-    localized: false,
-    required: false,
-    validations: [],
-    disabled: false,
-    omitted: false,
-    items:
-      {
-        type: 'Link',
-        validations:
-          [{
-            linkContentType:
-              ['dropdownMenu',
-                'menuButton'],
-            message: 'The items must be either buttons or drop-down menus.'
-          }],
-        linkType: 'Entry'
-      }
-  })
-
-  menu.changeEditorInterface('name', 'singleLine')
-  menu.changeEditorInterface('items', 'entryLinksEditor')
-
-  const menubutton = migration.createContentType('menuButton', {
-    displayField: 'text',
-    name: 'Menu Button',
-    description: 'A Menu Button is a clickable button that goes on a Menu.  It has a link to a Page or a URL.'
-  })
-
-  menubutton.createField('text', {
-    name: 'Text',
-    type: 'Symbol',
-    localized: false,
-    required: true,
-    validations:
-      [{
-        size:
-          {
-            min: 1,
-            max: 60
-          },
-        message: 'A Menu Button should have a very short text field - ideally a single word.  Please limit the text to 60 characters.'
-      }],
-    disabled: false,
-    omitted: false
-  })
-
-  menubutton.createField('icon', {
-    name: 'Icon',
-    type: 'Link',
-    localized: false,
-    required: false,
-    validations: [{ linkMimetypeGroup: ['image'] }],
-    disabled: false,
-    omitted: false,
-    linkType: 'Asset'
-  })
-
-  menubutton.createField('externalLink', {
-    name: 'External Link',
-    type: 'Symbol',
-    localized: false,
-    required: false,
-    validations:
-      [{
-        regexp: { pattern: '^(\\w+):(\\/\\/)?(\\w+:{0,1}\\w*@)?((\\w+\\.)+[^\\s\\/#]+)(:[0-9]+)?(\\/|(\\/|\\#)([\\w#!:.?+=&%@!\\-\\/]+))?$|^(\\/|(\\/|\\#)([\\w#!:.?+=&%@!\\-\\/]+))$' },
-        message: 'The external link must be a URL like \'https://www.watermark.org/\', a mailto url like \'mailto:info@watermark.org\', or a relative URL like \'#location-on-page\''
-      }],
-    disabled: false,
-    omitted: false
-  })
-
-  menubutton.createField('link', {
-    name: 'Page Link',
-    type: 'Link',
-    localized: false,
-    required: false,
-    validations:
-      [{
-        linkContentType: ['page'],
-        message: 'The Page Link must be a link to a Page which has a slug.'
-      }],
-    disabled: false,
-    omitted: false,
-    linkType: 'Entry'
-  })
-
-  menubutton.createField('ionIcon', {
-    name: 'Ion Icon',
-    type: 'Symbol',
-    localized: false,
-    required: false,
-    validations:
-      [{
-        regexp: { pattern: '^ion-[a-z\\-]+$' },
-        message: 'The icon should start with \'ion-\', like \'ion-arrow-down-c\'.  See http://ionicons.com/'
-      }],
-    disabled: false,
-    omitted: false
-  })
-
-  menubutton.createField('style', {
-    name: 'Style',
-    type: 'Symbol',
-    localized: false,
-    required: false,
-    validations: [{ in: ['oval-border'] }],
-    disabled: false,
-    omitted: false
-  })
-
-  menubutton.changeEditorInterface('text', 'singleLine')
-  menubutton.changeEditorInterface('icon', 'assetLinkEditor')
-  menubutton.changeEditorInterface('externalLink', 'singleLine')
-  menubutton.changeEditorInterface('link', 'entryLinkEditor')
-  menubutton.changeEditorInterface('ionIcon', 'singleLine')
-  menubutton.changeEditorInterface('style', 'dropdown')
-
-  const dropdownmenu = migration.createContentType('dropdownMenu', {
-    displayField: 'name',
-    name: 'Dropdown Menu',
-    description: 'A Dropdown Menu can be attached to a main menu to show additional menu items on click.'
-  })
-
-  dropdownmenu.createField('name', {
-    name: 'Menu Name',
-    type: 'Symbol',
-    localized: false,
-    required: false,
-    validations: [],
-    disabled: false,
-    omitted: false
-  })
-
-  dropdownmenu.createField('label', {
-    name: 'Menu Label',
-    type: 'Link',
-    localized: false,
-    required: false,
-    validations: [{ linkContentType: ['menuButton'] }],
-    disabled: false,
-    omitted: false,
-    linkType: 'Entry'
-  })
-
-  dropdownmenu.createField('items', {
-    name: 'Items',
-    type: 'Array',
-    localized: false,
-    required: false,
-    validations: [],
-    disabled: false,
-    omitted: false,
-    items:
-      {
-        type: 'Link',
-        validations:
-          [{
-            linkContentType:
-              ['menuButton']
-          }],
-        linkType: 'Entry'
-      }
-  })
-
-  dropdownmenu.changeEditorInterface('name', 'singleLine')
-  dropdownmenu.changeEditorInterface('label', 'entryLinkEditor')
-  dropdownmenu.changeEditorInterface('items', 'entryLinksEditor')
-}

data/lib/generators/wcc/templates/page/generated_add_pages.ts

@@ -1,50 +0,0 @@
-import Migration from 'contentful-migration-cli'
-
-export = function (migration: Migration) {
-  const page = migration.createContentType('page')
-    .name('Page')
-    .description('A page describes a collection of sections that correspond' +
-     'to a URL slug')
-    .displayField('title')
-
-  page.createField('title')
-    .name('Title')
-    .type('Symbol')
-    .required(true)
-
-  page.createField('slug')
-    .name('Slug')
-    .type('Symbol')
-    .required(true)
-    .validations([
-      {
-        unique: true
-      },
-      {
-        regexp: { pattern: "(\\/|\\/([\w#!:.?+=&%@!\\-\\/]))?$" },
-        message: "The slug must look like the path part of a URL and begin with a forward slash, example: '/my-page-slug'"
-      }
-    ])
-
-  page.createField('sections')
-    .name('Sections')
-    .type('Array')
-    .items({
-      type: 'Link',
-      linkType: 'Entry'
-    })
-
-  page.createField('subpages')
-    .name('Subpages')
-    .type('Array')
-    .items({
-      type: 'Link',
-      linkType: 'Entry',
-      validations: [
-        {
-          linkContentType: [ 'page' ]
-        }
-      ]
-    })
-
-}

data/lib/tasks/validate.rake

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-namespace :wcc_contentful do
-  desc 'Validates content types in your space against the validations defined on your models'
-  task :validate, :environment do |_t|
-    # Ensure application models are loaded before we validate
-    Rails.application.eager_load!
-
-    client = Services.instance.management_client ||
-      Services.instance.client
-
-    content_types = client.content_types(limit: 1000).items
-
-    content_types = WCC::Contentful::ModelValidators
-      .transform_content_types_for_validation(content_types)
-
-    errors = WCC::Contentful::Model.schema.call(content_types)
-    raise WCC::Contentful::ValidationError, errors.errors unless errors.success?
-  end
-end

data/lib/wcc/contentful/app/model_validators.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry-validation'
-
-require_relative 'model_validators/dsl'
-
-module WCC::Contentful::App::ModelValidators
-  def schema
-    return if validations.nil? || validations.empty?
-
-    all_field_validations =
-      validations.each_with_object({}) do |(content_type, procs), h|
-        next if procs.empty?
-
-        # "page": {
-        #   "sys": { ... }
-        #   "fields": {
-        #     "title": { ... },
-        #     "sections": { ... },
-        #     ...
-        #   }
-        # }
-        h[content_type] =
-          Dry::Validation.Schema do
-            # Had to dig through the internals of Dry::Validation to find
-            # this magic incantation
-            procs.each { |dsl| instance_eval(&dsl.to_proc) }
-          end
-      end
-
-    Dry::Validation.Schema do
-      all_field_validations.each do |content_type, fields_schema|
-        required(content_type).schema do
-          required('fields').schema(fields_schema)
-        end
-      end
-    end
-  end
-
-  def validations
-    # This needs to be a class variable so that subclasses defined in application
-    # code can add to the total package of model validations
-    # rubocop:disable Style/ClassVars
-    @@validations ||= {}
-    # rubocop:enable Style/ClassVars
-  end
-
-  # Accepts a block which uses the {dry-validation DSL}[http://dry-rb.org/gems/dry-validation/]
-  # to validate the 'fields' object of a content type.
-  def validate_fields(&block)
-    raise ArgumentError, 'validate_fields requires a block' unless block_given?
-
-    dsl = ProcDsl.new(Proc.new(&block))
-
-    ct = try(:content_type) || name.demodulize.camelize(:lower)
-    (validations[ct] ||= []) << dsl
-  end
-
-  # Validates a single field is of the expected type.
-  # Type expectations are one of:
-  #
-  # [:String]   the field type must be `Symbol` or `Text`
-  # [:Int]      the field type must be `Integer`
-  # [:Float]    the field type must be `Number`
-  # [:DateTime] the field type must be 'Date'
-  # [:Asset]    the field must be a link and the `linkType` must be `Asset`
-  # [:Link]     the field must be a link and the `linkType` must be `Entry`.
-  # [:Location] the field type must be `Location`
-  # [:Boolean]  the field type must be `Boolean`
-  # [:Json]     the field type must be `Json` - a json blob.
-  # [:Array]    the field must be a List.
-  #
-  # Additional validation options can be enforced:
-  #
-  # [:required] the 'Required Field' checkbox must be checked
-  # [:optional] the 'Required Field' checkbox must not be checked
-  # [:link_to]  (only `:Link` or `:Array` type) the given content type(s) must be
-  #             checked in the 'Accept only specified entry type' validations
-  #             Example:
-  #               validate_field :button, :Link, link_to: ['button', 'altButton']
-  #
-  # [:items]    (only `:Array` type) the items of the list must be of the given type.
-  #             Example:
-  #               validate_field :my_strings, :Array, items: :String
-  #
-  # Examples:
-  # see WCC::Contentful::Model::Menu and WCC::Contentful::Model::MenuButton
-  def validate_field(field, type, *options)
-    dsl = FieldDsl.new(field, type, options)
-
-    ct = try(:content_type) || name.demodulize.camelize(:lower)
-    (validations[ct] ||= []) << dsl
-  end
-
-  def no_validate_field(field)
-    ct = try(:content_type) || name.demodulize.camelize(:lower)
-    return unless v = validations[ct]
-
-    field = field.to_s.camelize(:lower) unless field.is_a?(String)
-    v.reject! { |dsl| dsl.try(:field) == field }
-  end
-
-  # Accepts a content types response from the API and transforms it
-  # to be acceptible for the validator.
-  def self.transform_content_types_for_validation(content_types)
-    if !content_types.is_a?(Array) && items = content_types.try(:[], 'items')
-      content_types = items
-    end
-
-    # Transform the array into a hash keyed by content type ID
-    content_types.each_with_object({}) do |ct, ct_hash|
-      # Transform the fields into a hash keyed by field ID
-      ct['fields'] =
-        ct['fields'].each_with_object({}) do |f, f_hash|
-          f_hash[f['id']] = f
-        end
-
-      ct_hash[ct.dig('sys', 'id')] = ct
-    end
-  end
-end

data/lib/wcc/contentful/app/model_validators/dsl.rb

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-
-module WCC::Contentful::App::ModelValidators
-  class ProcDsl
-    def to_proc
-      @proc
-    end
-
-    def initialize(proc)
-      @proc = proc
-    end
-  end
-
-  class FieldDsl
-    attr_reader :field
-
-    # "sections": {
-    #   "id": "sections",
-    #   "name": "Sections",
-    #   "type": "Array",
-    #   "localized": false,
-    #   "required": false,
-    #   "validations": [],
-    #   "disabled": false,
-    #   "omitted": false,
-    #   "items": {
-    #     "type": "Link",
-    #     "validations": [
-    #       {
-    #         "linkContentType": [
-    #           "Section"
-    #         ]
-    #       }
-    #     ],
-    #     "linkType": "Entry"
-    #   }
-    # }
-
-    def schema
-      return @field_schema if @field_schema
-
-      # example: required('type').value(...)
-      type_pred = parse_type_predicate(@type)
-
-      # example: [required('required').value(eq?: true), ...]
-      procs =
-        @options.map do |opt|
-          if opt.is_a?(Hash)
-            opt.map { |k, v| parse_option(k, v) }
-          else
-            parse_option(opt)
-          end
-        end
-
-      @field_schema =
-        Dry::Validation.Schema do
-          instance_eval(&type_pred)
-
-          procs.flatten.each { |p| instance_eval(&p) }
-        end
-    end
-
-    def to_proc
-      f = field
-      s = schema
-      proc { required(f).schema(s) }
-    end
-
-    def initialize(field, field_type, options)
-      @field = field.to_s.camelize(:lower) unless field.is_a?(String)
-      @type = field_type
-      @options = options
-    end
-
-    private
-
-    def parse_type_predicate(type)
-      case type
-      when :String
-        proc { required('type').value(included_in?: %w[Symbol Text]) }
-      when :Int
-        proc { required('type').value(eql?: 'Integer') }
-      when :Float
-        proc { required('type').value(eql?: 'Number') }
-      when :DateTime
-        proc { required('type').value(eql?: 'Date') }
-      when :Asset
-        proc {
-          required('type').value(eql?: 'Link')
-          required('linkType').value(eql?: 'Asset')
-        }
-      else
-        proc { required('type').value(eql?: type.to_s.camelize) }
-      end
-    end
-
-    def parse_option(option, option_arg = nil)
-      case option
-      when :required
-        proc { required('required').value(eql?: true) }
-      when :optional
-        proc { required('required').value(eql?: false) }
-      when :link_to
-        link_to_proc = parse_field_link_to(option_arg)
-        return link_to_proc unless @type.to_s.camelize == 'Array'
-
-        proc {
-          required('items').schema do
-            required('type').value(eql?: 'Link')
-            instance_eval(&link_to_proc)
-          end
-        }
-      when :items
-        type_pred = parse_type_predicate(option_arg)
-        proc {
-          required('items').schema do
-            instance_eval(&type_pred)
-          end
-        }
-      else
-        raise ArgumentError, "unknown validation requirement: #{option}"
-      end
-    end
-
-    def parse_field_link_to(option_arg)
-      raise ArgumentError, 'validation link_to: requires an argument' unless option_arg
-
-      # this works because a Link can only have one validation in its "validations" array -
-      # this will fail if Contentful ever changes that.
-
-      # the 'validations' schema needs to be optional because if we get the content
-      # types from the CDN instead of the management API, sometimes the validations
-      # don't get sent back.
-
-      # "validations": [
-      #   {
-      #     "linkContentType": [
-      #       "section-CardSearch",
-      #       "section-Faq",
-      #       "section-Testimonials",
-      #       "section-VideoHighlight"
-      #     ]
-      #   }
-      # ]
-
-      if option_arg.is_a?(Regexp)
-        return proc {
-          optional('validations').each do
-            schema do
-              required('linkContentType').each(format?: option_arg)
-            end
-          end
-        }
-      end
-
-      option_arg = [option_arg] unless option_arg.is_a?(Array)
-      proc {
-        optional('validations').each do
-          schema do
-            required('linkContentType').value(eql?: option_arg)
-          end
-        end
-      }
-    end
-  end
-end