govuk_publishing_components 21.56.2 → 21.60.0

data/app/controllers/govuk_publishing_components/component_guide_controller.rb

@@ -83,8 +83,9 @@ module GovukPublishingComponents
     def components_in_use
       matches = []
 
-      files = Dir["#{@application_path}/app/views/**/*.html.erb"]
+      files = Dir["#{@application_path}/app/views/**/*.erb"]
       files.concat Dir["#{@application_path}/app/**/*.rb"]
+      files.concat Dir["#{@application_path}/lib/**/*.{rb,erb}"]
 
       files.each do |file|
         data = File.read(file)

data/app/models/govuk_publishing_components/audit_applications.rb

@@ -0,0 +1,105 @@
+module GovukPublishingComponents
+  class AuditApplications
+    attr_reader :data
+
+    def initialize(path, name)
+      templates = Dir["#{path}/app/views/**/*.erb"]
+      stylesheets = Dir["#{path}/app/assets/stylesheets/**/*.scss"]
+      javascripts = Dir["#{path}/app/assets/javascripts/**/*.js"]
+
+      find_components = /(?<=govuk_publishing_components\/components\/)[\/a-zA-Z_-]+(?=['"])/
+
+      @find_all_stylesheets = /@import ["']{1}govuk_publishing_components\/all_components/
+      find_stylesheets = /(?<=@import ["']{1}govuk_publishing_components\/components\/)(?!print\/)+[a-zA-Z_-]+(?=['"])/
+
+      @find_all_print_stylesheets = /@import ["']{1}govuk_publishing_components\/all_components_print/
+      find_print_stylesheets = /(?<=@import ["']{1}govuk_publishing_components\/components\/print\/)[a-zA-Z_-]+(?=['"])/
+
+      @find_all_javascripts = /\/\/[ ]*= require govuk_publishing_components\/all_components/
+      find_javascripts = /(?<=require govuk_publishing_components\/components\/)[a-zA-Z_-]+/
+
+      components_in_templates = find_components(templates, find_components, "templates") || []
+      components_in_stylesheets = find_components(stylesheets, find_stylesheets, "stylesheets") || []
+      components_in_print_stylesheets = find_components(stylesheets, find_print_stylesheets, "print_stylesheets") || []
+      components_in_javascripts = find_components(javascripts, find_javascripts, "javascripts") || []
+
+      ruby_paths = %w[/app/helpers/ /app/presenters/ /lib/]
+      components_in_ruby = []
+      ruby_paths.each do |ruby_path|
+        components_in_ruby << find_components(Dir["#{path}#{ruby_path}**/*.{rb,erb}"], find_components, "ruby") || []
+      end
+      components_in_ruby = components_in_ruby.flatten.uniq
+
+      application_found = application_exists(path)
+      components_found = []
+
+      if application_found
+        components_found = [
+          {
+            location: "templates",
+            components: components_in_templates,
+          },
+          {
+            location: "stylesheets",
+            components: components_in_stylesheets,
+          },
+          {
+            location: "print_stylesheets",
+            components: components_in_print_stylesheets,
+          },
+          {
+            location: "javascripts",
+            components: components_in_javascripts,
+          },
+          {
+            location: "ruby",
+            components: components_in_ruby,
+          },
+        ]
+      end
+
+      @data = {
+        name: name,
+        application_found: application_found,
+        components_found: components_found,
+      }
+    end
+
+  private
+
+    def find_components(files, find, type)
+      components_found = []
+
+      files.each do |file|
+        src = File.read(file)
+        components_found << find_match(find, src, type)
+      rescue StandardError
+        puts "File #{file} not found"
+      end
+
+      components_found.flatten.uniq.sort
+    end
+
+    def find_match(find, src, type)
+      return %w[all] if src.match(@find_all_stylesheets) && type == "stylesheets"
+      return %w[all] if src.match(@find_all_print_stylesheets) && type == "print_stylesheets"
+      return %w[all] if src.match(@find_all_javascripts) && type == "javascripts"
+
+      matches = src.scan(find)
+      all_matches = []
+      matches.each do |match|
+        all_matches << clean_file_name(match.tr('[])\'"', ""))
+      end
+
+      all_matches
+    end
+
+    def clean_file_name(name)
+      name.tr("_-", " ").strip
+    end
+
+    def application_exists(directory)
+      File.directory?(directory)
+    end
+  end
+end

data/app/models/govuk_publishing_components/audit_comparer.rb

@@ -0,0 +1,185 @@
+module GovukPublishingComponents
+  class AuditComparer
+    attr_reader :applications_data, :gem_data
+
+    def initialize(gem_data, results)
+      if gem_data[:gem_found]
+        @gem_data = gem_data
+        @applications_data = sort_results(results)
+        @gem_data[:components_by_application] = get_components_by_application || []
+      end
+    end
+
+  private
+
+    def prettify_key(key)
+      key.to_s.gsub("_", " ").capitalize
+    end
+
+    def sort_results(results)
+      data = []
+
+      results.each do |result|
+        if result[:application_found]
+          templates = result[:components_found].find { |c| c[:location] == "templates" }
+          stylesheets = result[:components_found].find { |c| c[:location] == "stylesheets" }
+          print_stylesheets = result[:components_found].find { |c| c[:location] == "print_stylesheets" }
+          javascripts = result[:components_found].find { |c| c[:location] == "javascripts" }
+          ruby = result[:components_found].find { |c| c[:location] == "ruby" }
+
+          @all_stylesheets = true if stylesheets[:components].include?("all")
+          @all_print_stylesheets = true if print_stylesheets[:components].include?("all")
+          @all_javascripts = true if javascripts[:components].include?("all")
+
+          templates[:components] = include_any_components_within_components(templates[:components])
+
+          warnings = []
+          warnings << warn_about_missing_components(result[:components_found])
+          warnings << warn_about_missing_assets(result[:components_found])
+          warnings = warnings.flatten
+
+          data << {
+            name: result[:name],
+            application_found: result[:application_found],
+            summary: [
+              {
+                name: "Components in templates",
+                value: templates[:components].flatten.uniq.sort.join(", "),
+              },
+              {
+                name: "Components in stylesheets",
+                value: stylesheets[:components].join(", "),
+              },
+              {
+                name: "Components in print stylesheets",
+                value: print_stylesheets[:components].join(", "),
+              },
+              {
+                name: "Components in javascripts",
+                value: javascripts[:components].join(", "),
+              },
+              {
+                name: "Components in ruby",
+                value: ruby[:components].join(", "),
+              },
+            ],
+            warnings: warnings,
+            warning_count: warnings.length,
+          }
+        else
+          data << {
+            name: result[:name],
+            application_found: result[:application_found],
+          }
+        end
+      end
+
+      data
+    end
+
+    def include_any_components_within_components(components)
+      @gem_data[:components_containing_components].each do |component|
+        components << component[:sub_components] if components.include?(component[:component])
+      end
+
+      components.flatten.uniq.sort
+    end
+
+    def create_warning(component, message)
+      {
+        component: component,
+        message: message,
+      }
+    end
+
+    def find_missing_items(first_group, second_group)
+      warnings = []
+
+      first_group.each do |first|
+        first_location = first[:location]
+
+        second_group.each do |second|
+          second_location = second[:location]
+          second_location = "code" if %w[templates ruby].include?(second_location)
+          in_current = find_missing(second[:components].clone, first[:components].clone)
+
+          next if second[:components].include?("all")
+
+          in_current.each do |component|
+            if @gem_data.include?("component_#{second_location}".to_sym)
+              warnings << create_warning(component, "Included in #{first_location} but not #{second_location}") if @gem_data["component_#{second_location}".to_sym].include?(component)
+            end
+          end
+        end
+      end
+
+      warnings
+    end
+
+    def warn_about_missing_assets(components)
+      warnings = []
+
+      code = components.select { |c| c[:location] == "templates" || c[:location] == "ruby" }
+      code = [
+        {
+          location: "code",
+          components: code.map { |c| c[:components] }.flatten.uniq.sort,
+        },
+      ]
+      assets = components.select { |c| c[:location] == "stylesheets" || c[:location] == "print_stylesheets" || c[:location] == "javascripts" }
+
+      warnings << find_missing_items(code, assets)
+      warnings << find_missing_items(assets, code)
+      warnings.flatten
+    end
+
+    def warn_about_missing_components(results)
+      warnings = []
+
+      results.each do |result|
+        location = result[:location]
+        result[:components].each do |component|
+          warnings << create_warning(component, "Included in #{location} but component does not exist") if component_does_not_exist(component)
+        end
+      end
+
+      warnings
+    end
+
+    def component_does_not_exist(component)
+      !@gem_data[:component_code].include?(component) unless component == "all"
+    end
+
+    def find_missing(needle, haystack)
+      (haystack - needle).flatten.sort
+    end
+
+    def get_components_by_application
+      results = []
+      found_something = false
+
+      @gem_data[:component_listing].each do |component|
+        found_in_applications = []
+
+        @applications_data.each do |application|
+          next unless application[:application_found]
+
+          name = application[:name]
+          found_something = true
+
+          application[:summary].each do |item|
+            found_in_applications << name if item[:value].include?(component[:name])
+          end
+        end
+
+        results << {
+          component: component[:name],
+          count: found_in_applications.uniq.length,
+          list: found_in_applications.uniq.join(", "),
+        }
+      end
+
+      results if found_something
+    end
+  end
+end

data/app/models/govuk_publishing_components/audit_components.rb

@@ -0,0 +1,158 @@
+module GovukPublishingComponents
+  class AuditComponents
+    attr_reader :data
+
+    def initialize(path)
+      @data = {
+        gem_found: false,
+      }
+      @data = compile_data(path) if Dir.exist?(path)
+    end
+
+  private
+
+    def compile_data(path)
+      templates_path = "app/views/govuk_publishing_components/components"
+      stylesheets_path = "app/assets/stylesheets/govuk_publishing_components/components"
+      print_stylesheets_path = "app/assets/stylesheets/govuk_publishing_components/components/print"
+      javascripts_path = "app/assets/javascripts/govuk_publishing_components/components"
+      tests_path = "spec/components"
+      js_tests_path = "spec/javascripts/components"
+
+      templates = Dir["#{path}/#{templates_path}/*.erb"]
+      stylesheets = Dir["#{path}/#{stylesheets_path}/*.scss"]
+      print_stylesheets = Dir["#{path}/#{print_stylesheets_path}/*.scss"]
+      javascripts = Dir["#{path}/#{javascripts_path}/*.js"]
+      tests = Dir["#{path}/#{tests_path}/*.rb"]
+      js_tests = Dir["#{path}/#{js_tests_path}/*.js"]
+
+      @templates_full_path = "#{path}/#{templates_path}/"
+
+      @components = find_files(templates, [path, templates_path].join("/"))
+      @component_stylesheets = find_files(stylesheets, [path, stylesheets_path].join("/"))
+      @component_print_stylesheets = find_files(print_stylesheets, [path, print_stylesheets_path].join("/"))
+      @component_javascripts = find_files(javascripts, [path, javascripts_path].join("/"))
+      @component_tests = find_files(tests, [path, tests_path].join("/"))
+      @component_js_tests = find_files(js_tests, [path, js_tests_path].join("/"))
+
+      {
+        gem_found: true,
+        component_code: @components,
+        component_stylesheets: @component_stylesheets,
+        component_print_stylesheets: @component_print_stylesheets,
+        component_javascripts: @component_javascripts,
+        component_tests: @component_tests,
+        component_js_tests: @component_js_tests,
+        components_containing_components: find_all_partials_in(templates),
+        component_listing: list_all_component_details,
+      }
+    end
+
+    def find_files(files, replace)
+      files.map { |file| clean_file_name(file.gsub(replace, "")) }.sort
+    end
+
+    def clean_file_name(name)
+      name.tr("/_-", " ")
+        .gsub(".html.erb", "")
+        .gsub(".erb", "")
+        .gsub(".scss", "")
+        .gsub(".js", "")
+        .gsub("spec", "")
+        .gsub(".rb", "")
+        .strip
+    end
+
+    def get_component_name_from_full_path(path)
+      path.gsub("/_", "/")
+        .gsub(@templates_full_path, "")
+        .gsub(".html.erb", "")
+        .gsub(".erb", "")
+        .tr('\"\'', "")
+    end
+
+    def get_component_link(component)
+      "/component-guide/#{component.gsub(' ', '_')}"
+    end
+
+    def find_all_partials_in(templates)
+      components = []
+
+      templates.each do |template|
+        partials_found = true
+        components_to_search = [template]
+        components_found = []
+
+        while partials_found
+          extra_components = find_partials_in(components_to_search)
+
+          if extra_components.any?
+            components_found << extra_components
+            components_to_search = extra_components
+          else
+            partials_found = false
+            components_found = components_found.flatten.reject { |c| c.include?("/") }
+
+            if components_found.any?
+              component_name = clean_file_name(get_component_name_from_full_path(template))
+              components << {
+                component: component_name,
+                link: get_component_link(component_name),
+                sub_components: components_found.uniq.sort.map { |name| clean_file_name(name) },
+              }
+            end
+          end
+        end
+      end
+
+      components.sort_by { |c| c[:component] }
+    end
+
+    def find_partials_in(components)
+      extra_components = []
+      components.each do |component|
+        extra_components << components_within_component(component)
+      end
+
+      extra_components.flatten.uniq.sort
+    end
+
+    def components_within_component(file)
+      file = get_component_name_from_full_path(file)
+      file = "#{@templates_full_path}#{file}.html.erb".sub(/.*\K\//, "/_")
+      data = File.read(file)
+      match = data.scan(/["']{1}(govuk_publishing_components\/components\/[\/a-z_-]+["']{1})/)
+      match.flatten.uniq.map(&:to_s).sort.map do |m|
+        m.gsub("govuk_publishing_components/components/", "").tr('\"\'', "")
+      end
+    end
+
+    def list_all_component_details
+      all_component_information = []
+
+      @components.each do |component|
+        all_component_information << {
+          name: component,
+          link: get_component_link(component),
+          stylesheet: check_component_has("stylesheet", component),
+          print_stylesheet: check_component_has("print_stylesheet", component),
+          javascript: check_component_has("javascript", component),
+          tests: check_component_has("test", component),
+          js_tests: check_component_has("js_test", component),
+        }
+      end
+
+      all_component_information
+    end
+
+    def check_component_has(a_thing, component)
+      look_in = @component_stylesheets if a_thing == "stylesheet"
+      look_in = @component_print_stylesheets if a_thing == "print_stylesheet"
+      look_in = @component_javascripts if a_thing == "javascript"
+      look_in = @component_tests if a_thing == "test"
+      look_in = @component_js_tests if a_thing == "js_test"
+
+      true if look_in.include?(component)
+    end
+  end
+end