platformos-check 0.0.1

data/lib/platformos_check/checks/unused_assign.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Checks unused {% assign x = ... %}
+  class UnusedAssign < LiquidCheck
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+
+    class TemplateInfo < Struct.new(:used_assigns, :assign_nodes, :includes)
+      def collect_used_assigns(templates, visited = Set.new)
+        collected = used_assigns
+        # Check recursively inside included snippets for use
+        includes.each do |name|
+          if templates[name] && !visited.include?(name)
+            visited << name
+            collected += templates[name].collect_used_assigns(templates, visited)
+          end
+        end
+        collected
+      end
+    end
+
+    def initialize
+      @templates = {}
+    end
+
+    def on_document(node)
+      @templates[node.app_file.name] = TemplateInfo.new(Set.new, {}, Set.new)
+    end
+
+    def on_assign(node)
+      @templates[node.app_file.name].assign_nodes[node.value.to] = node
+    end
+
+    def on_parse_json(node)
+      @templates[node.app_file.name].assign_nodes[node.value.to] = node
+    end
+
+    def on_function(node)
+      return if node.value.to.start_with?('_')
+
+      @templates[node.app_file.name].assign_nodes[node.value.to] = node
+    end
+
+    def on_graphql(node)
+      return if node.value.to.start_with?('_')
+
+      @templates[node.app_file.name].assign_nodes[node.value.to] = node
+    end
+
+    def on_include(node)
+      return unless node.value.template_name_expr.is_a?(String)
+
+      @templates[node.app_file.name].includes << node.value.template_name_expr
+    end
+
+    def on_variable_lookup(node)
+      @templates[node.app_file.name].used_assigns << case node.value.name
+                                                     when Liquid::VariableLookup
+                                                       node.value.name.name
+                                                     else
+                                                       node.value.name
+                                                     end
+    end
+
+    def on_end
+      @templates.each_pair do |_, info|
+        used = info.collect_used_assigns(@templates)
+        info.assign_nodes.each_pair do |name, node|
+          next if used.include?(name)
+
+          add_offense("`#{name}` is never used", node:) do |corrector|
+            case node.type_name
+            when :graphql
+              offset = node.markup.match(/^graphql\s+/)[0].size
+
+              corrector.insert_before(
+                node,
+                '_',
+                (node.start_index + offset)...(node.start_index + offset)
+              )
+            when :function
+              offset = node.markup.match(/^function\s+/)[0].size
+
+              corrector.insert_before(
+                node,
+                '_',
+                (node.start_index + offset)...(node.start_index + offset)
+              )
+            when :parse_json
+              # noop
+            else
+              corrector.remove(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platformos_check/checks/unused_partial.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class UnusedPartial < LiquidCheck
+    severity :suggestion
+    category :liquid
+    doc docs_url(__FILE__)
+
+    def initialize
+      @used_partials = Set.new
+    end
+
+    def on_render(node)
+      if node.value.template_name_expr.is_a?(String)
+        @used_partials << node.value.template_name_expr
+
+      elsif might_have_a_block_as_variable_lookup?(node)
+        # We ignore this case, because that's a "proper" use case for
+        # the render tag with OS 2.0
+        # {% render block %} shouldn't turn off the UnusedPartial check
+
+      else
+        # Can't reliably track unused partials if an expression is used, ignore this check
+        @used_partials.clear
+        ignore!
+      end
+    end
+    alias on_include on_render
+
+    def on_function(node)
+      if node.value.from.is_a?(String)
+        @used_partials << node.value.from
+      else
+        # Can't reliably track unused partials if an expression is used, ignore this check
+        @used_partials.clear
+        ignore!
+      end
+    end
+
+    def on_end
+      missing_partials.each do |app_file|
+        add_offense("This partial is not used", app_file:) do |corrector|
+          corrector.remove_file(@platformos_app.storage, app_file.relative_path.to_s)
+        end
+      end
+    end
+
+    def missing_partials
+      platformos_app.partials.reject { |t| @used_partials.include?(t.name) }
+    end
+
+    private
+
+    # This function returns true when the render node passed might have a
+    # variable lookup that refers to a block as template_name_expr.
+    #
+    # e.g.
+    #
+    # {% for block in col %}
+    #   {% render block %}
+    # {% endfor %}
+    #
+    # In this case, the `block` variable_lookup in the render tag might be
+    # a Block because col might be an array of blocks.
+    #
+    # @param node [Node]
+    def might_have_a_block_as_variable_lookup?(node)
+      return false unless node.type_name == :render
+
+      return false unless node.value.template_name_expr.is_a?(Liquid::VariableLookup)
+
+      name = node.value.template_name_expr.name
+      return false unless name.is_a?(String)
+
+      # We're going through all the parents of the nodes until we find
+      # a For node with variable_name === to the template_name_expr's name
+      find_parent(node.parent) do |parent_node|
+        next false unless parent_node.type_name == :for
+
+        parent_node.value.variable_name == name
+      end
+    end
+
+    # @param node [Node]
+    def find_parent(node, &)
+      return nil unless node
+
+      return node if yield node
+
+      find_parent(node.parent, &)
+    end
+  end
+end

data/lib/platformos_check/checks/valid_yaml.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class ValidYaml < YamlCheck
+    severity :error
+    category :yaml
+    doc docs_url(__FILE__)
+
+    def on_file(file)
+      return unless file.parse_error
+
+      message = file.parse_error
+      add_offense(message, app_file: file)
+    end
+  end
+end

data/lib/platformos_check/checks.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "pp"
+require "timeout"
+
+module PlatformosCheck
+  class Checks < Array
+    CHECK_METHOD_TIMEOUT = 5 # sec
+
+    def call(method, *)
+      each do |check|
+        call_check_method(check, method, *)
+      end
+    end
+
+    def disableable
+      @disableable ||= self.class.new(select(&:can_disable?))
+    end
+
+    def whole_platformos_app
+      @whole_platformos_app ||= self.class.new(select(&:whole_platformos_app?))
+    end
+
+    def single_file
+      @single_file ||= self.class.new(select(&:single_file?))
+    end
+
+    private
+
+    def call_check_method(check, method, *args)
+      return unless check.respond_to?(method) && !check.ignored?
+
+      # If you want to use binding.pry in unit tests, define the
+      # PLATFORMOS_CHECK_DEBUG environment variable. e.g.
+      #
+      #   $ export PLATFORMOS_CHECK_DEBUG=true
+      #   $ bundle exec rake tests:in_memory
+      #
+      if ENV['PLATFORMOS_CHECK_DEBUG']
+        check.send(method, *args)
+      else
+        Timeout.timeout(CHECK_METHOD_TIMEOUT) do
+          check.send(method, *args)
+        end
+      end
+    rescue Liquid::Error, PlatformosCheckError
+      raise
+    rescue StandardError => e
+      node = args.first
+      app_file = node.respond_to?(:app_file) ? node.app_file.relative_path : "?"
+      markup = node.respond_to?(:markup) ? node.markup : ""
+      node_class = node.respond_to?(:value) ? node.value.class : "?"
+      line_number = node.respond_to?(:line_number) ? node.line_number : "?"
+
+      PlatformosCheck.bug(<<~EOS)
+        Exception while running `#{check.code_name}##{method}`:
+        ```
+        #{e.class}: #{e.message}
+          #{e.backtrace.join("\n  ")}
+        ```
+
+        Platformos App File: `#{app_file}`
+        Node: `#{node_class}`
+        Markup:
+        ```
+        #{markup}
+        ```
+        Line number: #{line_number}
+        Check options: `#{check.options.pretty_inspect}`
+      EOS
+    end
+  end
+end

data/lib/platformos_check/checks_tracking.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module ChecksTracking
+    def inherited(klass)
+      Check.all << klass
+    end
+  end
+end

data/lib/platformos_check/cli.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module PlatformosCheck
+  class Cli
+    class Abort < StandardError; end
+
+    FORMATS = %i[text json]
+
+    attr_accessor :path
+
+    def initialize
+      @path = "."
+      @command = :check
+      @include_categories = []
+      @exclude_categories = []
+      @auto_correct = false
+      @update_docs = false
+      @config_path = nil
+      @fail_level = :error
+      @format = :text
+    end
+
+    def option_parser(parser = OptionParser.new, help: true)
+      return @option_parser if defined?(@option_parser)
+
+      @option_parser = parser
+      @option_parser.banner = "Usage: platformos-check [options] [/path/to/your/platformos_app]"
+
+      @option_parser.separator("")
+      @option_parser.separator("Basic Options:")
+      @option_parser.on(
+        "-C", "--config PATH",
+        "Use the config provided, overriding .platformos-check.yml if present",
+        "Use :platformos_app_app_extension to use default checks for app extensions"
+      ) { |path| @config_path = path }
+      @option_parser.on(
+        "-o", "--output FORMAT", FORMATS,
+        "The output format to use. (text|json, default: text)"
+      ) { |format| @format = format.to_sym }
+      @option_parser.on(
+        "-c", "--category CATEGORY", Check::CATEGORIES, "Only run this category of checks",
+        "Runs checks matching all categories when specified more than once"
+      ) { |category| @include_categories << category.to_sym }
+      @option_parser.on(
+        "-x", "--exclude-category CATEGORY", Check::CATEGORIES, "Exclude this category of checks",
+        "Excludes checks matching any category when specified more than once"
+      ) { |category| @exclude_categories << category.to_sym }
+      @option_parser.on(
+        "-a", "--auto-correct",
+        "Automatically fix offenses"
+      ) { @auto_correct = true }
+      @option_parser.on(
+        "--fail-level SEVERITY", [:crash] + Check::SEVERITIES,
+        "Minimum severity (error|suggestion|style) for exit with error code"
+      ) do |severity|
+        @fail_level = severity.to_sym
+      end
+
+      @option_parser.separator("")
+      @option_parser.separator("Miscellaneous:")
+      @option_parser.on(
+        "--init",
+        "Generate a .platformos-check.yml file"
+      ) { @command = :init }
+      @option_parser.on(
+        "--print",
+        "Output active config to STDOUT"
+      ) { @command = :print }
+      @option_parser.on(
+        "--update-docs",
+        "Update PlatformOS Check docs (objects, filters, and tags)"
+      ) { @update_docs = true }
+      @option_parser.on(
+        "-h", "--help",
+        "Show this. Hi!"
+      ) { @command = :help } if help
+      @option_parser.on(
+        "-l", "--list",
+        "List enabled checks"
+      ) { @command = :list }
+      @option_parser.on(
+        "-v", "--version",
+        "Print PlatformOS Check version"
+      ) { @command = :version }
+
+      if ENV["PLATFORMOS_CHECK_DEBUG"]
+        @option_parser.separator("")
+        @option_parser.separator("Debugging:")
+        @option_parser.on(
+          "--profile",
+          "Output a profile to STDOUT compatible with FlameGraph."
+        ) { @command = :profile }
+      end
+
+      @option_parser.separator("")
+      @option_parser.separator(<<~EOS)
+        Description:
+            PlatformOS Check helps you follow platformOS best practices by analyzing the
+            Liquid & JSON inside your app.
+
+            You can configure checks in the .platformos-check.yml file of your platformos_app root directory.
+      EOS
+
+      @option_parser
+    end
+
+    def parse(argv)
+      @path = option_parser.parse(argv).first || "."
+    rescue OptionParser::InvalidArgument => e
+      abort(e.message)
+    end
+
+    def run!
+      unless %i[version init help].include?(@command)
+        @config = if @config_path
+                    PlatformosCheck::Config.new(
+                      root: @path,
+                      configuration: PlatformosCheck::Config.load_config(@config_path)
+                    )
+                  else
+                    PlatformosCheck::Config.from_path(@path)
+                  end
+        @config.include_categories = @include_categories unless @include_categories.empty?
+        @config.exclude_categories = @exclude_categories unless @exclude_categories.empty?
+        @config.auto_correct = @auto_correct
+      end
+
+      send(@command)
+    end
+
+    def run
+      run!
+      exit(0)
+    rescue Abort => e
+      if e.message.empty?
+        exit(1)
+      else
+        abort(e.message)
+      end
+    rescue PlatformosCheckError => e
+      warn(e.message)
+      exit(2)
+    end
+
+    def self.parse_and_run!(argv)
+      cli = new
+      cli.parse(argv)
+      cli.run!
+    end
+
+    def self.parse_and_run(argv)
+      cli = new
+      cli.parse(argv)
+      cli.run
+    end
+
+    def list
+      puts @config.enabled_checks
+    end
+
+    def version
+      puts PlatformosCheck::VERSION
+    end
+
+    def init
+      dotfile_path = PlatformosCheck::Config.find(@path)
+      raise Abort, "#{PlatformosCheck::Config::DOTFILE} already exists at #{@path}" unless dotfile_path.nil?
+
+      config_name = @config_path || "default"
+      File.write(
+        File.join(@path, PlatformosCheck::Config::DOTFILE),
+        File.read(PlatformosCheck::Config.bundled_config_path(config_name))
+      )
+
+      puts "Writing new #{PlatformosCheck::Config::DOTFILE} to #{@path}"
+    end
+
+    def print
+      puts YAML.dump(@config.to_h)
+    end
+
+    def help
+      puts option_parser
+    end
+
+    def check(out_stream = STDOUT)
+      update_docs
+
+      warn "Checking #{@config.root} ..."
+      storage = PlatformosCheck::FileSystemStorage.new(@config.root, ignored_patterns: @config.ignored_patterns)
+      platformos_app = PlatformosCheck::App.new(storage)
+      raise Abort, "No platformos_app files found." if platformos_app.all.empty?
+
+      analyzer = PlatformosCheck::Analyzer.new(platformos_app, @config.enabled_checks, @config.auto_correct)
+      analyzer.analyze_platformos_app
+      analyzer.correct_offenses
+      print_with_format(platformos_app, analyzer, out_stream)
+      # corrections are committed after printing so that the
+      # source_excerpts are still pointing to the uncorrected source.
+      analyzer.write_corrections
+      raise Abort, "" if analyzer.uncorrectable_offenses.any? do |offense|
+        offense.check.severity_value <= Check.severity_value(@fail_level)
+      end
+    end
+
+    def update_docs
+      return unless @update_docs
+
+      warn 'Updating documentation...'
+
+      PlatformosCheck::PlatformosLiquid::SourceManager.download
+    end
+
+    def profile
+      require 'ruby-prof-flamegraph'
+
+      result = RubyProf.profile do
+        check(STDERR)
+      end
+
+      # Print a graph profile to text
+      printer = RubyProf::FlameGraphPrinter.new(result)
+      printer.print(STDOUT, {})
+    rescue LoadError
+      warn "Profiling is only available in development"
+    end
+
+    def print_with_format(platformos_app, analyzer, out_stream)
+      case @format
+      when :text
+        PlatformosCheck::Printer.new(out_stream).print(platformos_app, analyzer.offenses, @config.auto_correct)
+      when :json
+        PlatformosCheck::JsonPrinter.new(out_stream).print(analyzer.offenses)
+      end
+    end
+  end
+end