platformos-check 0.4.8 → 0.4.10

data/lib/platformos_check/checks/translation_files_match.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  class TranslationFilesMatch < YamlCheck
+    severity :error
+    category :translation
+    doc docs_url(__FILE__)
+
+    PLURALIZATION_KEYS = Set.new(%w[zero one two few many other])
+
+    def on_file(file)
+      return unless file.translation?
+      return if file.parse_error
+      return add_offense_wrong_language_in_file(file) if file.language != file.language_from_path
+      return check_if_file_exists_for_all_other_languages(file) if file.language == @platformos_app.default_language
+
+      default_language_file = @platformos_app.grouped_files[PlatformosCheck::TranslationFile][file.name.sub(file.language, @platformos_app.default_language)]
+
+      return add_offense_missing_file(file) if default_language_file.nil?
+
+      add_offense_different_structure(file, default_language_file) unless same_structure?(default_language_file.content[@platformos_app.default_language], file.content[file.language])
+    end
+
+    protected
+
+    def add_offense_wrong_language_in_file(file)
+      add_offense("Mismatch detected - file inside #{file.language_from_path} directory defines translations for `#{file.language}`", app_file: file) do |_corrector|
+        file.update_contents(file.content[file.language_from_path] = file.content.delete(file.content[file.language]))
+        file.write
+      end
+    end
+
+    def add_offense_missing_file(file)
+      add_offense("Mismatch detected - missing `#{file.relative_path.to_s.sub(file.language, @platformos_app.default_language)}` to define translations the  default language", app_file: file)
+    end
+
+    def check_if_file_exists_for_all_other_languages(file)
+      @platformos_app.translations_hash.each_key do |lang|
+        next if lang == @platformos_app.default_language
+
+        language_file = @platformos_app.grouped_files[PlatformosCheck::TranslationFile][file.name.sub(file.language, lang)]
+        add_offense_missing_translation_file(file, lang) if language_file.nil?
+      end
+    end
+
+    def add_offense_missing_translation_file(file, lang)
+      missing_file_path = file.relative_path.to_s.sub(file.language, lang)
+      add_offense("Mismatch detected - missing `#{missing_file_path}` file to define translations for `#{lang}`", app_file: file) do |corrector|
+        missing_file_content = file.content.clone
+        missing_file_content[lang] = missing_file_content.delete(file.language)
+        corrector.create_file(@platformos_app.storage, missing_file_path, YAML.dump(missing_file_content))
+      end
+    end
+
+    def same_structure?(hash1, hash2)
+      if !hash1.is_a?(Hash) && !hash2.is_a?(Hash)
+        true
+      elsif (hash1.is_a?(Hash) && !hash2.is_a?(Hash)) || (!hash1.is_a?(Hash) && hash2.is_a?(Hash))
+        false
+      elsif pluralization?(hash1) && pluralization?(hash2)
+        true
+      elsif hash1.keys.map(&:to_s).sort != hash2.keys.map(&:to_s).sort
+        false
+      else
+        hash1.keys.all? { |key| same_structure?(hash1[key], hash2[key]) }
+      end
+    end
+
+    def add_offense_different_structure(file, default_language_file)
+      add_offense("Mismatch detected - structure differs from the default language file #{default_language_file.relative_path}", app_file: file) do |_corrector|
+        file.content[file.language].transform_values! { |v| v.nil? ? {} : v }
+        file.content[file.language] = default_language_file.content[default_language_file.language].deep_merge(file.content[file.language])
+        file.write
+      end
+    end
+
+    def pluralization?(hash)
+      hash.all? do |key, value|
+        PLURALIZATION_KEYS.include?(key) && !value.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/platformos_check/checks/translation_key_exists.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  # Recommends using {% liquid ... %} if 5 or more consecutive {% ... %} are found.
+  class TranslationKeyExists < LiquidCheck
+    severity :error
+    categories :translation, :liquid
+    doc docs_url(__FILE__)
+
+    def on_variable(node)
+      return unless node.value.name.is_a?(String)
+      return unless node.filters.size == 1
+
+      translation_filter = node.filters.detect { |f| TranslationFile::TRANSLATION_FILTERS.include?(f[0]) }
+      return unless translation_filter
+      return unless translation_filter
+
+      filter_attributes = translation_filter[2] || {}
+
+      return unless filter_attributes['default'].nil?
+      return if !filter_attributes['scope'].nil? && !filter_attributes['scope'].is_a?(String)
+
+      lang = filter_attributes['language'].is_a?(String) ? filter_attributes['language'] : @platformos_app.default_language
+      translation_components = node.value.name.split('.')
+
+      translation_components = filter_attributes['scope'].split('.') + translation_components if filter_attributes['scope']
+
+      return add_translation_offense(node:, lang:) if @platformos_app.translations_hash.empty?
+
+      hash = @platformos_app.translations_hash[lang] || {}
+      index = 0
+      while translation_components[index]
+        hash = hash[translation_components[index]]
+        if hash.nil?
+          add_translation_offense(node:, lang:)
+          break
+        end
+        index += 1
+      end
+    end
+
+    protected
+
+    def add_translation_offense(node:, lang:)
+      add_offense("Translation `#{lang}.#{node.value.name}` does not exists", node:)
+    end
+  end
+end

data/lib/platformos_check/checks/undefined_object.rb

@@ -6,6 +6,9 @@ module PlatformosCheck
     doc docs_url(__FILE__)
     severity :error
 
+    NOTIFICATION_GLOBAL_OBJECTS = %w[data response form].freeze
+    FORM_GLOBAL_OBJECTS = %w[form form_builder].freeze
+
     class TemplateInfo
       def initialize(app_file: nil)
         @all_variable_lookups = {}
@@ -19,7 +22,8 @@ module PlatformosCheck
       attr_reader :all_assigns, :all_captures, :all_forloops, :app_file, :all_renders
 
       def add_render(name:, node:)
-        @all_renders[name] = node
+        @all_renders[name] ||= []
+        @all_renders[name] << node
       end
 
       def add_variable_lookup(name:, node:)
@@ -39,8 +43,10 @@ module PlatformosCheck
       end
 
       def each_partial
-        @all_renders.each do |(name, info)|
-          yield [name, info]
+        @all_renders.each do |(name, nodes)|
+          nodes.each do |node|
+            yield [name, node]
+          end
         end
       end
 
@@ -56,14 +62,17 @@ module PlatformosCheck
           yield [key, info]
         end
       end
+
+      def first_declaration(name)
+        [all_assigns[name], all_captures[name]].compact.min_by(&:line_number)
+      end
     end
 
     def self.single_file(**_args)
       true
     end
 
-    def initialize(config_type: :default)
-      @config_type = config_type
+    def initialize
       @files = {}
     end
 
@@ -72,15 +81,15 @@ module PlatformosCheck
     end
 
     def on_assign(node)
-      @files[node.app_file.name].all_assigns[node.value.to] = node
+      @files[node.app_file.name].all_assigns[node.value.to] ||= node
     end
 
     def on_capture(node)
-      @files[node.app_file.name].all_captures[node.value.instance_variable_get(:@to)] = node
+      @files[node.app_file.name].all_captures[node.value.instance_variable_get(:@to)] ||= node
     end
 
     def on_parse_json(node)
-      @files[node.app_file.name].all_captures[node.value.to] = node
+      @files[node.app_file.name].all_captures[node.value.to] ||= node
     end
 
     def on_for(node)
@@ -102,7 +111,7 @@ module PlatformosCheck
     end
 
     def on_function(node)
-      @files[node.app_file.name].all_assigns[node.value.to] = node
+      @files[node.app_file.name].all_assigns[node.value.to] ||= node
 
       return unless node.value.from.is_a?(String)
 
@@ -113,13 +122,13 @@ module PlatformosCheck
     end
 
     def on_graphql(node)
-      @files[node.app_file.name].all_assigns[node.value.to] = node
+      @files[node.app_file.name].all_assigns[node.value.to] ||= node
     end
 
     def on_background(node)
       return unless node.value.partial_syntax
 
-      @files[node.app_file.name].all_assigns[node.value.to] = node
+      @files[node.app_file.name].all_assigns[node.value.to] ||= node
 
       return unless node.value.partial_name.is_a?(String)
 
@@ -155,10 +164,10 @@ module PlatformosCheck
       each_template do |(_name, info)|
         if info.app_file.notification?
           # NOTE: `data` comes from graphql for notifications
-          check_object(info, all_global_objects + %w[data response form])
+          check_object(info, all_global_objects + NOTIFICATION_GLOBAL_OBJECTS)
         elsif info.app_file.form?
           # NOTE: `data` comes from graphql for notifications
-          check_object(info, all_global_objects + %w[form form_builder])
+          check_object(info, all_global_objects + FORM_GLOBAL_OBJECTS)
         else
           check_object(info, all_global_objects)
         end
@@ -167,42 +176,37 @@ module PlatformosCheck
 
     private
 
-    attr_reader :config_type
-
     def each_template
       @files.each do |(name, info)|
         yield [name, info]
       end
     end
 
-    def check_object(info, all_global_objects, render_node = nil, visited_partials = Set.new, level = 0)
+    def check_object(info, all_global_objects, render_node = nil, level = 0)
       return if level > 1
 
       check_undefined(info, all_global_objects, render_node) unless info.app_file.partial? && render_node.nil? # ||
 
       info.each_partial do |(partial_name, node)|
-        next if visited_partials.include?(partial_name)
+        next unless @files[partial_name] # NOTE: undefined partial
 
         partial_info = @files[partial_name]
-
-        next unless partial_info # NOTE: undefined partial
-
         partial_variables = node.value.attributes.keys +
                             [node.value.instance_variable_get(:@alias_name)]
-        visited_partials << partial_name
-        check_object(partial_info, all_global_objects + partial_variables, node, visited_partials, level + 1)
+
+        check_object(partial_info, all_global_objects + partial_variables, node, level + 1)
       end
     end
 
     def check_undefined(info, all_global_objects, render_node)
-      all_variables = info.all_variables
       potentially_unused_variables = render_node.value.attributes.keys if render_node
+      missing_arguments = []
       info.each_variable_lookup(!!render_node) do |(key, node)|
         name, line_number = key
 
         potentially_unused_variables&.delete(name)
 
-        next if all_variables.include?(name)
+        next if info.all_variables.include?(name) && variable_declared_before_used?(name, info, line_number)
         next if all_global_objects.include?(name)
 
         node = node.parent
@@ -211,7 +215,7 @@ module PlatformosCheck
         next if node.variable? && node.filters.any? { |(filter_name)| filter_name == "default" }
 
         if render_node
-          add_offense("Missing argument `#{name}`", node: render_node)
+          missing_arguments << name
         elsif !info.app_file.partial?
           add_offense("Undefined object `#{name}`", node:, line_number:)
         end
@@ -219,8 +223,33 @@ module PlatformosCheck
 
       potentially_unused_variables -= render_node.value.internal_attributes if render_node && render_node.value.respond_to?(:internal_attributes)
       potentially_unused_variables&.each do |name|
-        add_offense("Unused argument `#{name}`", node: render_node)
+        add_offense("Unused argument `#{name}`", node: render_node) do |corrector|
+          match = render_node.markup.match(/(?<attribute>,?\s*#{name}\s*:\s*#{Liquid::QuotedFragment})\s*/)
+
+          corrector.replace(render_node, render_node.markup.sub(match[:attribute], ''), render_node.start_index...render_node.end_index)
+        end
       end
+
+      return if missing_arguments.empty?
+
+      add_offense("Missing arguments: #{missing_arguments.map { |name| "`#{name}`" }.join(', ')}", node: render_node) do |corrector|
+        new_attributes = ''
+        missing_arguments.each do |name|
+          new_attributes += ", #{name}: "
+          new_attributes += @files[render_node.app_file.name].all_assigns.key?(name) ? name : 'null'
+        end
+
+        start_pos = render_node.end_index
+        start_pos -= 1 while start_pos > 0 && render_node.source[start_pos - 1] == ' '
+        corrector.replace(render_node, new_attributes, start_pos...start_pos)
+      end
+    end
+
+    def variable_declared_before_used?(name, info, line_number_when_used)
+      declaration = info.first_declaration(name)
+      return true if declaration.nil?
+
+      declaration.line_number <= line_number_when_used
     end
   end
 end

data/lib/platformos_check/checks/unreachable_code.rb

@@ -8,7 +8,7 @@ module PlatformosCheck
 
     FLOW_COMMAND = %i[break continue return]
     CONDITION_TYPES = Set.new(%i[condition else_condition])
-    INCLUDE_FLOW_COMMAND = %w[break]
+    INCLUDE_FLOW_COMMAND = %w[break].freeze
 
     def on_document(node)
       @processed_files = {}
@@ -94,16 +94,16 @@ module PlatformosCheck
       @processed_files[path]
     end
 
-    def include_node_contains_flow_command?(root)
-      return false if root.nil?
+    def include_node_contains_flow_command?(node)
+      return false if node.nil?
 
-      root.nodelist.any? do |node|
-        if INCLUDE_FLOW_COMMAND.include?(node.respond_to?(:tag_name) && node.tag_name)
+      node.nodelist.any? do |n|
+        if INCLUDE_FLOW_COMMAND.include?(n.respond_to?(:tag_name) && n.tag_name)
           true
-        elsif node.respond_to?(:nodelist) && node.nodelist
-          include_node_contains_flow_command?(node)
-        elsif node.respond_to?(:tag_name) && node.tag_name == 'include' && node.template_name_expr.is_a?(String)
-          evaluate_include(node.template_name_expr)
+        elsif n.respond_to?(:nodelist) && n.nodelist
+          include_node_contains_flow_command?(n)
+        elsif n.respond_to?(:tag_name) && n.tag_name == 'include' && n.template_name_expr.is_a?(String)
+          evaluate_include(n.template_name_expr)
         else
           false
         end

data/lib/platformos_check/checks/unused_assign.rb

@@ -7,6 +7,13 @@ module PlatformosCheck
     category :liquid
     doc docs_url(__FILE__)
 
+    TAGS_FOR_AUTO_VARIABLE_PREPEND = Set.new(%i[graphql function background]).freeze
+    FILTERS_THAT_MODIFY_OBJECT = Set.new(%w[array_add add_to_array
+                                            prepend_to_array array_prepend
+                                            assign_to_hash_key hash_add_key add_hash_key
+                                            remove_hash_key hash_delete_key delete_hash_key]).freeze
+    PREPEND_CHARACTER = '_'
+
     class TemplateInfo < Struct.new(:used_assigns, :assign_nodes, :includes)
       def collect_used_assigns(templates, visited = Set.new)
         collected = used_assigns
@@ -34,7 +41,8 @@ module PlatformosCheck
     end
 
     def on_assign(node)
-      return if ignore_underscored?(node)
+      return if ignore_prepended?(node)
+      return if node.value.from.filters.any? { |filter_name, *_arguments| FILTERS_THAT_MODIFY_OBJECT.include?(filter_name) }
 
       @templates[node.app_file.name].assign_nodes[node.value.to] = node
     end
@@ -44,13 +52,21 @@ module PlatformosCheck
     end
 
     def on_function(node)
-      return if ignore_underscored?(node)
+      return if ignore_prepended?(node)
 
       @templates[node.app_file.name].assign_nodes[node.value.to] = node
     end
 
     def on_graphql(node)
-      return if ignore_underscored?(node)
+      return if node.value.to.nil?
+      return if ignore_prepended?(node)
+
+      @templates[node.app_file.name].assign_nodes[node.value.to] = node
+    end
+
+    def on_background(node)
+      return if node.value.to.nil?
+      return if ignore_prepended?(node)
 
       @templates[node.app_file.name].assign_nodes[node.value.to] = node
     end
@@ -77,25 +93,8 @@ module PlatformosCheck
           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
+            if TAGS_FOR_AUTO_VARIABLE_PREPEND.include?(node.type_name)
+              prepend_variable(node, corrector)
             else
               corrector.remove(node)
             end
@@ -106,8 +105,18 @@ module PlatformosCheck
 
     private
 
-    def ignore_underscored?(node)
-      node.value.to.start_with?('_')
+    def ignore_prepended?(node)
+      node.value.to.start_with?(PREPEND_CHARACTER)
+    end
+
+    def prepend_variable(node, corrector)
+      offset = node.markup.match(/^#{node.type_name}\s+/)[0].size
+
+      corrector.insert_before(
+        node,
+        PREPEND_CHARACTER,
+        (node.start_index + offset)...(node.start_index + offset)
+      )
     end
   end
 end

data/lib/platformos_check/cli.rb

@@ -188,7 +188,7 @@ module PlatformosCheck
     def check(out_stream = STDOUT)
       update_docs
 
-      warn "Checking #{@config.root} ..."
+      warn "Checking #{@config.root}:"
       storage = PlatformosCheck::FileSystemStorage.new(@config.root, ignored_patterns: @config.ignored_patterns)
       raise Abort, "No platformos_app files found." if storage.platformos_app.all.empty?
 

data/lib/platformos_check/ext/hash.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Hash
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block
+        yield(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+
+  def deep_merge(other_hash, &)
+    dup.deep_merge!(other_hash, &)
+  end
+end

data/lib/platformos_check/graphql_file.rb

@@ -71,6 +71,10 @@ module PlatformosCheck
       end
     end
 
+    def optional_arguments
+      @optional_arguments ||= defined_arguments - required_arguments
+    end
+
     def defined_arguments
       @defined_arguments ||= variables.map(&:name)
     end

data/lib/platformos_check/language_server/constants.rb

@@ -32,13 +32,29 @@ module PlatformosCheck
     PARTIAL_GRAPHQL = partial_tag_with_result('graphql')
     PARTIAL_BACKGROUND = partial_tag_with_result('background')
 
+    TAGS_FOR_FILTERS = 'echo|print|log|hash_assign|assign'
+    TRANSLATION_FILTERS_NAMES = 'translate|t_escape|translate_escape|t[^\\w]'
+    OPTIONAL_SCOPE_ARGUMENT = %((:?([\\w:'"\\s]*)\\s*(scope:\\s*['"](?<scope>[^'"]*)['"]))?)
+
+    LOCALIZE_FILTERS_NAMES = ''
+
     ASSET_INCLUDE = /
       \{\{-?\s*'(?<partial>[^']*)'\s*\|\s*asset_url|
       \{\{-?\s*"(?<partial>[^"]*)"\s*\|\s*asset_url|
 
       # in liquid tags the whole line is white space until the asset partial
-      ^\s*(?:echo|assign[^=]*=)\s*'(?<partial>[^']*)'\s*\|\s*asset_url|
-      ^\s*(?:echo|assign[^=]*=)\s*"(?<partial>[^"]*)"\s*\|\s*asset_url
+      ^\s*(?:#{TAGS_FOR_FILTERS}[^=]*=)\s*'(?<partial>[^']*)'\s*\|\s*asset_url|
+      ^\s*(?:#{TAGS_FOR_FILTERS}[^=]*=)\s*"(?<partial>[^"]*)"\s*\|\s*asset_url
+    /mix
+
+    TRANSLATION_FILTER = /
+      '(?<key>[^']*)'\s*\|\s*(#{TRANSLATION_FILTERS_NAMES})#{OPTIONAL_SCOPE_ARGUMENT}|
+      "(?<key>[^"]*)"\s*\|\s*(#{TRANSLATION_FILTERS_NAMES})#{OPTIONAL_SCOPE_ARGUMENT}
+    /mix
+
+    LOCALIZE_FILTER = /
+      [\s\w'"-:.]+\|\s*(localize|l):\s*'(?<key>[^']*)'|
+      [\s\w'"-:.]+\|\s*(localize|l):\s*"(?<key>[^"]*)"
     /mix
   end
 end

data/lib/platformos_check/language_server/document_link_provider.rb

@@ -7,6 +7,16 @@ module PlatformosCheck
       include PositionHelper
       include URIHelper
 
+      class DefaultTranslationFile
+        def initialize(default_language)
+          @default_language = default_language
+        end
+
+        def relative_path
+          Pathname.new(@default_language, "#{@default_language}.yml")
+        end
+      end
+
       class << self
         attr_accessor :partial_regexp, :app_file_type, :default_dir, :default_extension
 
@@ -41,18 +51,12 @@ module PlatformosCheck
 
       def document_links(buffer, platformos_app)
         matches(buffer, partial_regexp).map do |match|
-          start_row, start_column = from_index_to_row_column(
-            buffer,
-            match.begin(:partial)
-          )
+          start_row, start_column = start_coordinates(buffer, match)
 
-          end_row, end_column = from_index_to_row_column(
-            buffer,
-            match.end(:partial)
-          )
+          end_row, end_column = end_coordinates(buffer, match)
 
           {
-            target: file_link(match[:partial], platformos_app),
+            target: file_link(match, platformos_app),
             range: {
               start: {
                 line: start_row,
@@ -67,13 +71,66 @@ module PlatformosCheck
         end
       end
 
-      def file_link(partial, platformos_app)
+      def start_coordinates(buffer, match)
+        from_index_to_row_column(
+          buffer,
+          match.begin(:partial)
+        )
+      end
+
+      def end_coordinates(buffer, match)
+        from_index_to_row_column(
+          buffer,
+          match.end(:partial)
+        )
+      end
+
+      def file_link(match, platformos_app)
+        partial = match[:partial]
         relative_path = platformos_app.send(app_file_type).detect { |f| f.name == partial }&.relative_path
         relative_path ||= default_relative_path(partial)
 
         file_uri(@storage.path(relative_path))
       end
 
+      def translation_file_link(match, platformos_app)
+        @current_best_fit = platformos_app.translations.first || DefaultTranslationFile.new(platformos_app.default_language)
+        @current_best_fit_level = 0
+        array_of_translation_components = translation_components_for_match(match)
+        platformos_app.translations.each do |translation_file|
+          array_of_translation_components.each do |translation_components|
+            exact_match_level = translation_components.size
+            component_result = translation_file.content[platformos_app.default_language]
+            next if component_result.nil?
+
+            i = 0
+            while i < exact_match_level
+              component_result = yaml(component_result, translation_components[i])
+
+              break if component_result.nil?
+
+              i += 1
+              if i > @current_best_fit_level
+                @current_best_fit = translation_file
+                @current_best_fit_level = i
+              end
+
+              break unless component_result.is_a?(Hash)
+            end
+          end
+        end
+
+        file_uri(@storage.path(@current_best_fit&.relative_path))
+      end
+
+      def translation_components_for_match(match)
+        raise NotImplementedError
+      end
+
+      def yaml(component_result, component)
+        component_result[component]
+      end
+
       def default_relative_path(partial)
         return Pathname.new("app/#{default_dir}/#{partial}#{default_extension}") unless partial.start_with?('modules/')
 

data/lib/platformos_check/language_server/document_link_providers/localize_document_link_provider.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PlatformosCheck
+  module LanguageServer
+    class LocalizeDocumentLinkProvider < DocumentLinkProvider
+      @partial_regexp = LOCALIZE_FILTER
+      @app_file_type = :translations
+      @default_dir = 'translations'
+      @default_extension = '.yml'
+
+      def file_link(match, platformos_app)
+        translation_file_link(match, platformos_app)
+      end
+
+      def translation_components_for_match(match)
+        key = match[:key].split('.')
+        [
+          %w[time formats] + key,
+          %w[date formats] + key
+        ]
+      end
+
+      def start_coordinates(buffer, match)
+        from_index_to_row_column(
+          buffer,
+          match.begin(:key)
+        )
+      end
+
+      def end_coordinates(buffer, match)
+        from_index_to_row_column(
+          buffer,
+          match.end(:key)
+        )
+      end
+    end
+  end
+end