liquid_lint 1.0.0

data/lib/liquid_lint/sexp.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Symbolic expression which represents tree-structured data.
+  #
+  # The main use of this particular implementation is to provide a single
+  # location for defining convenience helpers when operating on Sexps.
+  class Sexp < Array
+    # Stores the line number of the code in the original document that
+    # corresponds to this Sexp.
+    attr_accessor :line
+
+    # Creates an {Sexp} from the given {Array}-based Sexp.
+    #
+    # This provides a convenient way to convert between literal arrays of
+    # {Symbol}s and {Sexp}s containing {Atom}s and nested {Sexp}s. These objects
+    # all expose a similar API that conveniently allows the two objects to be
+    # treated similarly due to duck typing.
+    #
+    # @param array_sexp [Array]
+    def initialize(array_sexp)
+      array_sexp.each do |atom_or_sexp|
+        case atom_or_sexp
+        when Array
+          push Sexp.new(atom_or_sexp)
+        else
+          push LiquidLint::Atom.new(atom_or_sexp)
+        end
+      end
+    end
+
+    # Returns whether this {Sexp} matches the given Sexp pattern.
+    #
+    # A Sexp pattern is simply an incomplete Sexp prefix.
+    #
+    # @example
+    #   The following Sexp:
+    #
+    #     [:html, :doctype, "html5"]
+    #
+    #   ...will match the given patterns:
+    #
+    #     [:html]
+    #     [:html, :doctype]
+    #     [:html, :doctype, "html5"]
+    #
+    # Note that nested Sexps will also be matched, so be careful about the cost
+    # of matching against a complicated pattern.
+    #
+    # @param sexp_pattern [Object,Array]
+    # @return [Boolean]
+    def match?(sexp_pattern)
+      # Delegate matching logic if we're comparing against a matcher
+      if sexp_pattern.is_a?(LiquidLint::Matcher::Base)
+        return sexp_pattern.match?(self)
+      end
+
+      # If there aren't enough items to compare then this obviously won't match
+      return false unless sexp_pattern.is_a?(Array) && length >= sexp_pattern.length
+
+      sexp_pattern.each_with_index do |sub_pattern, index|
+        return false unless self[index].match?(sub_pattern)
+      end
+
+      true
+    end
+
+    # Returns pretty-printed representation of this S-expression.
+    #
+    # @return [String]
+    def inspect
+      display
+    end
+
+    protected
+
+    # Pretty-prints this Sexp in a form that is more readable.
+    #
+    # @param depth [Integer] indentation level to display Sexp at
+    # @return [String]
+    def display(depth = 1) # rubocop:disable Metrics/AbcSize
+      indentation = ' ' * 2 * depth
+      output = '['.dup
+
+      each_with_index do |nested_sexp, index|
+        output << "\n"
+        output += indentation
+
+        output +=
+          if nested_sexp.is_a?(LiquidLint::Sexp)
+            nested_sexp.display(depth + 1)
+          else
+            nested_sexp.inspect
+          end
+
+        # Add trailing comma unless this is the last item
+        output += ',' if index < length - 1
+      end
+
+      output << "\n" << ' ' * 2 * (depth - 1) unless empty?
+      output << ']'
+
+      output
+    end
+  end
+end

data/lib/liquid_lint/sexp_visitor.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Provides an interface which when included allows a class to visit nodes in
+  # the Sexp of a Liquid document.
+  module SexpVisitor
+    # Traverse the Sexp looking for matches with registered patterns, firing
+    # callbacks for all matches.
+    #
+    # @param sexp [LiquidLint::Sexp]
+    def trigger_pattern_callbacks(sexp)
+      return if on_start(sexp) == :stop
+
+      traverse sexp
+    end
+
+    # Traverse the given Sexp, firing callbacks if they are defined.
+    #
+    # @param sexp [LiquidLint::Sexp]
+    def traverse(sexp)
+      patterns.each do |pattern|
+        next unless sexp.match?(pattern.sexp)
+
+        result = method(pattern.callback_method_name).call(sexp)
+
+        # Returning :stop indicates we should stop searching this Sexp
+        # (i.e. stop descending this branch of depth-first search).
+        # The `return` here is very intentional.
+        return if result == :stop # rubocop:disable Lint/NonLocalExitFromIterator
+      end
+
+      # Continue traversing children by default (match blocks can return `:stop`
+      # to not continue).
+      traverse_children(sexp)
+    end
+
+    # Traverse the children of this {Sexp}.
+    #
+    # @param sexp [LiquidLint::Sexp]
+    def traverse_children(sexp)
+      sexp.each do |nested_sexp|
+        traverse nested_sexp if nested_sexp.is_a?(Sexp)
+      end
+    end
+
+    # Returns the map of capture names to captured values.
+    #
+    # @return [Hash, CaptureMap]
+    def captures
+      self.class.captures || {}
+    end
+
+    # Returns the list of registered Sexp patterns.
+    #
+    # @return [Array<LiquidLint::SexpVisitor::SexpPattern>]
+    def patterns
+      self.class.patterns || []
+    end
+
+    # Executed before searching for any pattern matches.
+    #
+    # @param sexp [LiquidLint::Sexp] see {SexpVisitor::DSL.on_start}
+    # @return [Symbol] see {SexpVisitor::DSL.on_start}
+    def on_start(*)
+      # Overidden by DSL.on_start
+    end
+
+    # Mapping of Sexp pattern to callback method name.
+    #
+    # @attr_reader sexp [Array] S-expression pattern that when matched triggers the
+    #     callback
+    # @attr_reader callback_method_name [Symbol] name of the method to call when pattern is matched
+    SexpPattern = Struct.new(:sexp, :callback_method_name)
+    private_constant :SexpPattern
+
+    # Exposes a convenient Domain-specific Language (DSL) that makes declaring
+    # Sexp match patterns very easy.
+    #
+    # Include them with `extend LiquidLint::SexpVisitor::DSL`
+    module DSL
+      # Registered patterns that this visitor will look for when traversing the
+      # {LiquidLint::Sexp}.
+      attr_reader :patterns
+
+      # @return [Hash] map of capture names to captured values
+      attr_reader :captures
+
+      # DSL helper that defines a sexp pattern and block that will be executed if
+      # the given pattern is found.
+      #
+      # @param sexp_pattern [Sexp]
+      # @yield block to execute when the specified pattern is matched
+      # @yieldparam sexp [LiquidLint::Sexp] Sexp that matched the pattern
+      # @yieldreturn [LiquidLint::Sexp,Symbol,void]
+      #   If a Sexp is returned, indicates that traversal should jump directly
+      #   to that Sexp.
+      #   If `:stop` is returned, halts further traversal down this branch
+      #   (i.e. stops recursing, but traversal at higher levels will continue).
+      #   Otherwise traversal will continue as normal.
+      def on(sexp_pattern, &block)
+        # TODO: Index Sexps on creation so we can quickly jump to potential
+        # matches instead of checking array.
+        @patterns ||= []
+        @pattern_number ||= 1
+
+        # Use a monotonically increasing number to identify the method so that in
+        # debugging we can simply look at the nth defintion in the class.
+        unique_method_name = :"on_pattern_#{@pattern_number}"
+        define_method(unique_method_name, block)
+
+        @pattern_number += 1
+        @patterns << SexpPattern.new(sexp_pattern, unique_method_name)
+      end
+
+      # Define a block of code to run before checking for any pattern matches.
+      #
+      # @yield block to execute
+      # @yieldparam sexp [LiquidLint::Sexp] the root Sexp
+      # @yieldreturn [Symbol] if `:stop`, indicates that no further processing
+      #   should occur
+      def on_start(&block)
+        define_method(:on_start, block)
+      end
+
+      # Represents a pattern that matches anything.
+      #
+      # @return [LiquidLint::Matcher::Anything]
+      def anything
+        LiquidLint::Matcher::Anything.new
+      end
+
+      # Represents a pattern that matches the specified matcher, storing the
+      # matched value in the captures list under the given name.
+      #
+      # @param capture_name [Symbol]
+      # @param matcher [LiquidLint::Matcher::Base]
+      # @return [LiquidLint::Matcher::Capture]
+      def capture(capture_name, matcher)
+        @captures ||= LiquidLint::CaptureMap.new
+
+        @captures[capture_name] =
+          LiquidLint::Matcher::Capture.from_matcher(matcher)
+      end
+    end
+  end
+end

data/lib/liquid_lint/utils.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module LiquidLint
+  # Miscellaneus collection of helper functions.
+  module Utils
+    module_function
+
+    # Returns whether a glob pattern (or any of a list of patterns) matches the
+    # specified file.
+    #
+    # This is defined here so our file globbing options are consistent
+    # everywhere we perform globbing.
+    #
+    # @param glob [String, Array]
+    # @param file [String]
+    # @return [Boolean]
+    def any_glob_matches?(globs_or_glob, file)
+      path = File.expand_path(file)
+      Array(globs_or_glob).any? do |glob|
+        ::File.fnmatch?(File.expand_path(glob), path,
+                        ::File::FNM_PATHNAME | # Wildcards don't match path separators
+                        ::File::FNM_DOTMATCH)  # `*` wildcard matches dotfiles
+      end
+    end
+
+    # Find all consecutive items satisfying the given block of a minimum size,
+    # yielding each group of consecutive items to the provided block.
+    #
+    # @param items [Array]
+    # @param satisfies [Proc] function that takes an item and returns true/false
+    # @param min_consecutive [Fixnum] minimum number of consecutive items before
+    #   yielding the group
+    # @yield Passes list of consecutive items all matching the criteria defined
+    #   by the `satisfies` {Proc} to the provided block
+    # @yieldparam group [Array] List of consecutive items
+    # @yieldreturn [Boolean] block should return whether item matches criteria
+    #   for inclusion
+    def for_consecutive_items(items, satisfies, min_consecutive = 2)
+      current_index = -1
+
+      while (current_index += 1) < items.count
+        next unless satisfies[items[current_index]]
+
+        count = count_consecutive(items, current_index, &satisfies)
+        next unless count >= min_consecutive
+
+        # Yield the chunk of consecutive items
+        yield items[current_index...(current_index + count)]
+
+        current_index += count # Skip this patch of consecutive items to find more
+      end
+    end
+
+    # Count the number of consecutive items satisfying the given {Proc}.
+    #
+    # @param items [Array]
+    # @param offset [Fixnum] index to start searching from
+    # @yield [item] Passes item to the provided block.
+    # @yieldparam item [Object] Item to evaluate as matching criteria for
+    #   inclusion
+    # @yieldreturn [Boolean] whether to include the item
+    # @return [Integer]
+    def count_consecutive(items, offset = 0)
+      count = 1
+      count += 1 while (offset + count < items.count) && yield(items[offset + count])
+      count
+    end
+
+    # Calls a block of code with a modified set of environment variables,
+    # restoring them once the code has executed.
+    #
+    # @param env [Hash] environment variables to set
+    def with_environment(env)
+      old_env = {}
+      env.each do |var, value|
+        old_env[var] = ENV[var.to_s]
+        ENV[var.to_s] = value
+      end
+
+      yield
+    ensure
+      old_env.each { |var, value| ENV[var.to_s] = value }
+    end
+  end
+end

data/lib/liquid_lint/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Defines the gem version.
+module LiquidLint
+  VERSION = '1.0.0'
+end

data/lib/liquid_lint.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Load all liquid-lint modules necessary to parse and lint a file.
+# Ordering here can be important depending on class references in each module.
+
+# Need to load liquid before we can reference some classes or define filters
+require 'liquid'
+
+require 'liquid_lint/constants'
+require 'liquid_lint/exceptions'
+require 'liquid_lint/configuration'
+require 'liquid_lint/configuration_loader'
+require 'liquid_lint/utils'
+require 'liquid_lint/atom'
+require 'liquid_lint/sexp'
+require 'liquid_lint/file_finder'
+require 'liquid_lint/linter_registry'
+require 'liquid_lint/logger'
+require 'liquid_lint/version'
+
+# Load all filters (required by LiquidLint::Engine)
+Dir[File.expand_path('liquid_lint/filters/*.rb', File.dirname(__FILE__))].sort.each do |file|
+  require file
+end
+
+require 'liquid_lint/engine'
+require 'liquid_lint/document'
+require 'liquid_lint/capture_map'
+require 'liquid_lint/sexp_visitor'
+require 'liquid_lint/lint'
+require 'liquid_lint/ruby_parser'
+require 'liquid_lint/linter'
+require 'liquid_lint/reporter'
+require 'liquid_lint/report'
+require 'liquid_lint/linter_selector'
+require 'liquid_lint/runner'
+
+# Load all matchers
+require 'liquid_lint/matcher/base'
+Dir[File.expand_path('liquid_lint/matcher/*.rb', File.dirname(__FILE__))].sort.each do |file|
+  require file
+end
+
+# Load all linters
+Dir[File.expand_path('liquid_lint/linter/*.rb', File.dirname(__FILE__))].sort.each do |file|
+  require file
+end
+
+# Load all reporters
+Dir[File.expand_path('liquid_lint/reporter/*.rb', File.dirname(__FILE__))].sort.each do |file|
+  require file
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: liquid_lint
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- zeusintuivo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Configurable tool for writing clean and consistent Liquid templates
+email:
+- zeus@intuivo.com
+executables:
+- liquid-lint
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- bin/liquid-lint
+- config/default.yml
+- lib/liquid_lint.rb
+- lib/liquid_lint/atom.rb
+- lib/liquid_lint/capture_map.rb
+- lib/liquid_lint/cli.rb
+- lib/liquid_lint/configuration.rb
+- lib/liquid_lint/configuration_loader.rb
+- lib/liquid_lint/constants.rb
+- lib/liquid_lint/document.rb
+- lib/liquid_lint/engine.rb
+- lib/liquid_lint/exceptions.rb
+- lib/liquid_lint/file_finder.rb
+- lib/liquid_lint/filters/attribute_processor.rb
+- lib/liquid_lint/filters/control_processor.rb
+- lib/liquid_lint/filters/inject_line_numbers.rb
+- lib/liquid_lint/filters/sexp_converter.rb
+- lib/liquid_lint/filters/splat_processor.rb
+- lib/liquid_lint/lint.rb
+- lib/liquid_lint/linter.rb
+- lib/liquid_lint/linter/comment_control_statement.rb
+- lib/liquid_lint/linter/consecutive_control_statements.rb
+- lib/liquid_lint/linter/control_statement_spacing.rb
+- lib/liquid_lint/linter/embedded_engines.rb
+- lib/liquid_lint/linter/empty_control_statement.rb
+- lib/liquid_lint/linter/empty_lines.rb
+- lib/liquid_lint/linter/file_length.rb
+- lib/liquid_lint/linter/line_length.rb
+- lib/liquid_lint/linter/redundant_div.rb
+- lib/liquid_lint/linter/rubocop.rb
+- lib/liquid_lint/linter/tab.rb
+- lib/liquid_lint/linter/tag_case.rb
+- lib/liquid_lint/linter/trailing_blank_lines.rb
+- lib/liquid_lint/linter/trailing_whitespace.rb
+- lib/liquid_lint/linter/zwsp.rb
+- lib/liquid_lint/linter_registry.rb
+- lib/liquid_lint/linter_selector.rb
+- lib/liquid_lint/logger.rb
+- lib/liquid_lint/matcher/anything.rb
+- lib/liquid_lint/matcher/base.rb
+- lib/liquid_lint/matcher/capture.rb
+- lib/liquid_lint/matcher/nothing.rb
+- lib/liquid_lint/options.rb
+- lib/liquid_lint/rake_task.rb
+- lib/liquid_lint/report.rb
+- lib/liquid_lint/reporter.rb
+- lib/liquid_lint/reporter/checkstyle_reporter.rb
+- lib/liquid_lint/reporter/default_reporter.rb
+- lib/liquid_lint/reporter/emacs_reporter.rb
+- lib/liquid_lint/reporter/json_reporter.rb
+- lib/liquid_lint/ruby_extract_engine.rb
+- lib/liquid_lint/ruby_extractor.rb
+- lib/liquid_lint/ruby_parser.rb
+- lib/liquid_lint/runner.rb
+- lib/liquid_lint/sexp.rb
+- lib/liquid_lint/sexp_visitor.rb
+- lib/liquid_lint/utils.rb
+- lib/liquid_lint/version.rb
+homepage: https://github.com/zeusintuivo/liquid-lint
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.21
+signing_key:
+specification_version: 4
+summary: Liquid template linting tool
+test_files: []