dialecto-rails 0.1.0

data/lib/dialecto_rails/unmarked.rb

@@ -0,0 +1,42 @@
+module DialectoRails
+  # The per-request flag of live-site editing. It lives in the execution state of the thread (or fiber) that
+  # renders the page, so jobs and other threads never inherit it. It is here, outside `InContext`, because app
+  # code calls `DialectoRails.unmarked` and a process that never turns live mode on must not load any of the
+  # in-context machinery to do so.
+  LIVE_MARKING = :dialecto_live_marking
+
+  class << self
+    # True while this thread renders a page for an editor.
+    def live_marking?
+      state = execution_state
+      !state.nil? && state[LIVE_MARKING] == true
+    end
+
+    # Runs the block with live-site markers off and restores the flag after, even on a raise. Wrap whatever
+    # renders text that leaves the page, such as a mail sent while an editor's request is being handled.
+    def unmarked
+      state = execution_state
+      return yield unless state
+
+      previous = state[LIVE_MARKING]
+      state[LIVE_MARKING] = false
+      begin
+        yield
+      ensure
+        state[LIVE_MARKING] = previous
+      end
+    end
+
+    # The middleware's side of the flag.
+    def live_marking=(on)
+      state = execution_state
+      state[LIVE_MARKING] = on if state
+    end
+
+    private
+
+    def execution_state
+      defined?(::ActiveSupport::IsolatedExecutionState) ? ::ActiveSupport::IsolatedExecutionState : nil
+    end
+  end
+end

data/lib/dialecto_rails/usages/call_args.rb

@@ -0,0 +1,78 @@
+require "prism"
+
+module DialectoRails
+  module Usages
+    # What a translate call is made of: its positional arguments and the options of its trailing keyword hash.
+    module CallArgs
+      Options = Struct.new(:scope, :default, :separator, :splat, keyword_init: true)
+
+      TRANSLATE_NAMES = %i[t translate t! translate!].freeze
+      HELPER_RECEIVERS = %i[helpers view_context view controller].freeze
+
+      module_function
+
+      def positional(call)
+        arguments = call.arguments&.arguments || []
+        arguments.reject { |argument| argument.is_a?(Prism::KeywordHashNode) }
+      end
+
+      def keyword_hash(call)
+        (call.arguments&.arguments || []).find { |argument| argument.is_a?(Prism::KeywordHashNode) }
+      end
+
+      # `forward`: names of the enclosing method's own `*rest`, `**opts` and `&block`, whose splats pass the
+      # caller's options straight on and say nothing about the key.
+      def options(call, forward: [])
+        options = Options.new(splat: false)
+        keyword_hash(call)&.elements&.each do |element|
+          case element
+          when Prism::AssocNode
+            name = element.key.is_a?(Prism::SymbolNode) ? element.key.unescaped : nil
+            case name
+            when "scope" then options.scope = element.value
+            when "default" then options.default = element.value
+            when "separator" then options.separator = element.value
+            end
+          when Prism::AssocSplatNode
+            value = element.value
+            forwarded = value.is_a?(Prism::LocalVariableReadNode) && forward.include?(value.name)
+            options.splat = true unless forwarded
+          end
+        end
+        positional(call).drop(1).each do |extra|
+          options.splat = true if extra.is_a?(Prism::LocalVariableReadNode) || extra.is_a?(Prism::InstanceVariableReadNode)
+        end
+        options
+      end
+
+      def const_named?(node, name)
+        case node
+        when Prism::ConstantReadNode then node.name == name
+        when Prism::ConstantPathNode then node.parent.nil? && node.name == name
+        else false
+        end
+      end
+
+      # `Spree`, `::Spree` and `Admin::Helpers` as written (a leading `::` dropped), or nil for anything else.
+      def const_path(node)
+        case node
+        when Prism::ConstantReadNode then node.name.to_s
+        when Prism::ConstantPathNode
+          parent = node.parent.nil? ? "" : const_path(node.parent)
+          parent && (parent.empty? ? node.name.to_s : "#{parent}::#{node.name}")
+        end
+      end
+
+      # :none for a bare call (or `self.`), :i18n for `I18n.`, :helper for `helpers.`, `view_context.`…
+      # and :other for anything else.
+      def receiver_kind(call)
+        receiver = call.receiver
+        return :none if receiver.nil? || receiver.is_a?(Prism::SelfNode)
+        return :i18n if const_named?(receiver, :I18n)
+        return :helper if receiver.is_a?(Prism::CallNode) && HELPER_RECEIVERS.include?(receiver.name)
+
+        :other
+      end
+    end
+  end
+end

data/lib/dialecto_rails/usages/catalog_keys.rb

@@ -0,0 +1,67 @@
+require "psych"
+require "set"
+
+module DialectoRails
+  module Usages
+    # The keys the project's catalogs hold, as Dialecto counts them: every leaf, and a plural's root as one key.
+    # Read as a YAML syntax tree (never loaded), so tags and aliases can't run or expand.
+    class CatalogKeys
+      PLURAL_FORMS = %w[zero one two few many other].freeze
+
+      def initialize
+        @keys = Set.new
+        @prefixes = Set.new
+      end
+
+      attr_reader :keys
+
+      def add(content)
+        document = Psych.parse(content)
+        root = document&.root
+        return self unless root.is_a?(Psych::Nodes::Mapping)
+
+        pairs(root).each { |_locale, value| walk(value, []) }
+        self
+      rescue Psych::SyntaxError, EncodingError
+        self
+      end
+
+      def include?(key) = @keys.include?(key)
+
+      # True when `text` ends in a dot and some key starts with it (`"map."` in a prop).
+      def prefix?(text)
+        return false unless text.end_with?(".")
+
+        @prefixes.include?(text)
+      end
+
+      def empty? = @keys.empty?
+
+      private
+
+      def pairs(mapping) = mapping.children.each_slice(2).to_a
+
+      def walk(node, path)
+        case node
+        when Psych::Nodes::Mapping
+          entries = pairs(node).select { |key, _value| key.is_a?(Psych::Nodes::Scalar) && key.value != "<<" }
+          if !path.empty? && plural?(entries)
+            add_key(path)
+          else
+            entries.each { |key, value| walk(value, path + [key.value]) }
+          end
+        when Psych::Nodes::Scalar, Psych::Nodes::Sequence then add_key(path) unless path.empty?
+        end
+      end
+
+      def plural?(entries)
+        entries.any? && entries.all? { |key, value| PLURAL_FORMS.include?(key.value) && !value.is_a?(Psych::Nodes::Mapping) }
+      end
+
+      def add_key(path)
+        @keys << path.join(".")
+        path[0...-1].each_index { |index| @prefixes << (path[0..index].join(".") + ".") }
+      end
+    end
+  end
+end

data/lib/dialecto_rails/usages/check.rb

@@ -0,0 +1,70 @@
+module DialectoRails
+  module Usages
+    # `dialecto-rails check` (spec-0023 §6.8): code that reads a key the catalogs no longer hold. Runtime-only
+    # keys (`pattern` `*`) are never findings.
+    class Check
+      Finding = Struct.new(:code, :file, :line, :message, :warning, keyword_init: true)
+
+      # Namespaces Rails and common gems supply themselves, so a missing app catalog entry isn't a finding.
+      FRAMEWORK = %w[date time datetime number helpers errors activerecord activemodel activesupport support
+        views flash devise].freeze
+      TEST_FILE = %r{\A(?:test|spec|features)/}
+
+      def initialize(envelope, catalog)
+        @usages = envelope["usages"]
+        @catalog = catalog
+      end
+
+      def findings
+        @findings ||= @usages.flat_map { |usage| inspect_usage(usage) }
+      end
+
+      def failed? = findings.any? { |finding| !finding.warning }
+
+      private
+
+      def inspect_usage(usage)
+        case usage["kind"]
+        when "static" then static(usage)
+        when "set" then set(usage)
+        when "pattern" then pattern(usage)
+        else []
+        end
+      end
+
+      def static(usage)
+        key = usage["key"]
+        return [] if present?(key) || framework?(key) || Array(usage["defaults"]).any? { |entry| present?(entry["key"]) }
+
+        [finding("missing_key", usage, "reads #{key}, which no catalog has")]
+      end
+
+      def set(usage)
+        keys = usage["keys"]
+        return [] if keys.any? { |key| present?(key) || framework?(key) }
+
+        [finding("missing_keys", usage, "reads one of #{keys.first(3).join(", ")}#{keys.length > 3 ? ", …" : ""}; no catalog has any")]
+      end
+
+      def pattern(usage)
+        parts = usage["parts"]
+        return [] unless parts.any? { |part| part.key?("lit") }
+        return [] if framework?(usage["pattern"])
+
+        regexp = Regexp.new("\\A" + parts.map { |part| part["lit"] ? Regexp.escape(part["lit"]) : ".*" }.join + "\\z")
+        return [] if @catalog.keys.any? { |key| regexp.match?(key) }
+
+        [finding("no_matching_keys", usage, "reads #{usage["pattern"]}, which matches no catalog key")]
+      end
+
+      def present?(key) = @catalog.include?(key) || @catalog.prefix?("#{key}.")
+
+      def framework?(key) = FRAMEWORK.include?(key.to_s.split(".").first)
+
+      def finding(code, usage, message)
+        Finding.new(code: code, file: usage["file"], line: usage["start_line"], message: message,
+          warning: usage["file"].match?(TEST_FILE))
+      end
+    end
+  end
+end

data/lib/dialecto_rails/usages/haml_extractor.rb

@@ -0,0 +1,260 @@
+require "haml"
+require_relative "templates"
+
+module DialectoRails
+  module Usages
+    # Reduces a HAML template to the Ruby inside it, byte for byte where it was (spec-0023 §6.2): everything
+    # that isn't Ruby becomes a space, each piece of Ruby is written back at its own offset, and the `end`s the
+    # indentation implied are appended after the last byte, so no offset moves. The scan doesn't follow control
+    # flow, so `else`, `when` and `rescue` (which would need an `end` in the middle of the file) are left out and
+    # the branches simply follow one another; `case` loses its keyword for the same reason. The pieces come from
+    # `Haml::Parser`'s tree; where they sit comes from the source lines.
+    #
+    # Read: `= code`, `- code`, `%tag= code`, `%tag{attributes}`, `#{interpolation}` in text, and `:ruby` filters.
+    # A construct whose Ruby can't be put back in place raises `Unreadable`, and the file is reported unscanned.
+    class HamlExtractor
+      Unreadable = Templates::Unreadable
+
+      MID_BLOCK = %w[else elsif when in rescue ensure].freeze
+
+      def self.extract(bytes)
+        new(bytes).call
+      end
+
+      def initialize(bytes)
+        @source = bytes.b
+        @lines = []
+        position = 0
+        @source.each_line do |line|
+          @lines << position
+          position += line.bytesize
+        end
+        @out = @source.gsub(/[^\n]/n, " ")
+        @used = Hash.new(0)
+        @opens = 0
+        @last_end = 0
+      end
+
+      def call
+        root = Haml::Parser.new({}).call(@source.dup.force_encoding(Encoding::UTF_8))
+        walk(root)
+        (@out << "\n" << ("end\n" * @opens)).force_encoding(Encoding::UTF_8)
+      rescue Haml::SyntaxError => e
+        raise Unreadable, "HAML syntax error#{" on line #{e.line + 1}" if e.respond_to?(:line) && e.line}"
+      end
+
+      private
+
+      def walk(node)
+        node.children.each do |child|
+          visit(child)
+          walk(child)
+        end
+      end
+
+      def script?(node) = %i[script silent_script].include?(node.type)
+
+      def mid_block?(node) = script?(node) && MID_BLOCK.include?(node.value[:keyword].to_s)
+
+      # A node whose Ruby opens a block that needs an `end` (`case` is written without its keyword).
+      def opens_block?(node)
+        script?(node) && !node.children.empty? && !mid_block?(node) && node.value[:keyword].to_s != "case"
+      end
+
+      def visit(node)
+        value = node.value
+        case node.type
+        when :script, :silent_script then code(node, value[:text])
+        when :tag then tag(node, value)
+        when :plain then interpolations(node.line)
+        when :filter then ruby_filter(node, value) if value[:name] == "ruby"
+        end
+        @opens += 1 if opens_block?(node)
+      end
+
+      def tag(node, value)
+        line = node.line
+        attributes = value[:dynamic_attributes]
+        line = attribute_hash(line) if attributes&.old
+        return unless value[:parse] && value[:value]
+
+        found = locate(line, value[:value].b)
+        if found
+          write(found, value[:value])
+        else
+          interpolations(line)
+        end
+      end
+
+      # `%tag{ … }`: the hash as written, from its `{` to the matching `}` (it may span lines). Returns the line
+      # the hash ends on.
+      def attribute_hash(line)
+        text = line_text(line).b
+        open = text.index("{", @used[line])
+        raise Unreadable, "HAML attributes on line #{line} can't be placed in the source" unless open
+
+        start = @lines[line - 1] + open
+        close = matching_brace(@source, start + 1)
+        raise Unreadable, "HAML attributes on line #{line} aren't closed" unless close
+
+        # As an array literal: `[ a: 1 ]` and `[ attributes ]` both read as Ruby, which a `{ … }` statement doesn't.
+        region = @source.byteslice(start, close - start + 1)
+        region.setbyte(0, 91)
+        region.setbyte(-1, 93)
+        write(start, region)
+        last = line_of(close)
+        @used[last] = close - @lines[last - 1] + 1
+        last
+      end
+
+      def code(node, text)
+        text = text.to_s.strip
+        return if text.empty?
+
+        line = node.line
+        keyword = node.value[:keyword].to_s
+        return code_after_keyword(line, text, keyword) if %w[elsif case].include?(keyword)
+        return if MID_BLOCK.include?(keyword)
+
+        found = locate(line, text.b)
+        if found
+          write(found, text)
+        elsif text.start_with?('"') && text.include?("\#{")
+          interpolations(line) # a text line HAML turned into a quoted string
+        else
+          multiline(line, text)
+        end
+      end
+
+      # `elsif cond` and `case value` keep what follows the keyword; the keyword's bytes stay blank.
+      def code_after_keyword(line, text, keyword)
+        rest = text.sub(/\A#{keyword}\s*/, "")
+        return if rest.empty?
+
+        found = locate(line, rest.b)
+        raise Unreadable, "HAML code on line #{line} can't be placed in the source" unless found
+
+        write(found, rest)
+      end
+
+      # Code that spans lines is read by HAML as one line with single spaces between the parts; each part is
+      # put back on its own line.
+      def multiline(first_line, text)
+        word = text[/\S+/].to_s.b
+        first = line_text(first_line).b
+        at = first.index(word, @used[first_line])
+        raise Unreadable, "HAML code on line #{first_line} can't be placed in the source" unless at
+
+        index = first_line
+        loop do
+          raw = line_text(index).b
+          continues = raw.rstrip.end_with?(",") || raw.match?(/\s\|\s*\z/n)
+          piece = raw.strip.sub(/\s+\|\z/n, "")
+          if index == first_line
+            piece = raw.byteslice(at..).strip.sub(/\s+\|\z/n, "")
+            offset = @lines[index - 1] + at
+          else
+            offset = @lines[index - 1] + raw.index(piece)
+          end
+          write(offset, piece, terminate: !continues)
+          @used[index] = offset - @lines[index - 1] + piece.bytesize
+          break unless continues && index < @lines.length
+
+          index += 1
+        end
+      end
+
+      def interpolations(line_number)
+        line = line_text(line_number).b
+        position = 0
+        while (open = line.index("\#{", position))
+          close = matching_brace(line, open + 2)
+          break unless close
+
+          inner = line.byteslice(open + 2, close - open - 2)
+          absolute = @lines[line_number - 1] + open + 2
+          @out[absolute - 1] = ";" if absolute.positive?
+          @out[absolute, inner.bytesize] = inner
+          @last_end = absolute + inner.bytesize
+          position = close + 1
+        end
+      end
+
+      def matching_brace(text, from)
+        depth = 1
+        quote = nil
+        index = from
+        while index < text.bytesize
+          char = text.getbyte(index).chr
+          if quote
+            index += 1 if char == "\\"
+            quote = nil if char == quote
+          elsif ['"', "'"].include?(char) then quote = char
+          elsif char == "{" then depth += 1
+          elsif char == "}"
+            depth -= 1
+            return index if depth.zero?
+          end
+          index += 1
+        end
+        nil
+      end
+
+      def ruby_filter(node, value)
+        index = node.line + 1
+        value[:text].to_s.each_line do |text|
+          stripped = text.strip
+          next if stripped.empty?
+
+          index += 1 while index <= @lines.length && !line_text(index).include?(stripped)
+          raise Unreadable, ":ruby filter on line #{node.line} can't be placed in the source" if index > @lines.length
+
+          write(locate(index, stripped.b), stripped)
+        end
+      end
+
+      # The byte offset of `text` in a source line, searching from the end of what was already placed there.
+      def locate(line_number, text, from: nil)
+        return nil if line_number < 1 || line_number > @lines.length
+
+        line = line_text(line_number).b
+        at = line.index(text, from || @used[line_number])
+        return nil unless at
+
+        @used[line_number] = at + text.bytesize
+        @lines[line_number - 1] + at
+      end
+
+      CONTINUES = /(?:[,(\[{\\.]|&&|\|\||\+|-|\*|\?|:(?!:)\s*)\z/
+
+      def write(offset, text, terminate: true)
+        text = text.b
+        @out[offset - 1] = ";" if offset.positive? && @out.getbyte(offset - 1) == 32 && separate?(offset)
+        @out[offset, text.bytesize] = text
+        @last_end = offset + text.bytesize
+        # HAML reads each line on its own; Ruby would let `render "x", f:` swallow the next line.
+        open_ended = text.match?(CONTINUES) && !text.match?(/\w:\z/)
+        return if !terminate || open_ended
+
+        following = @out.getbyte(@last_end)
+        # A newline already ends a statement; it is replaced only after `f:`, which would take the next line as
+        # its value (and never after a piece that may hold a `#` comment, which would swallow what follows).
+        @out[@last_end] = ";" if following == 32 || (following == 10 && text.match?(/\w:\z/))
+      end
+
+      # A `;` goes before a piece when another piece already stands earlier on the same line.
+      def separate?(offset)
+        start = @out.rindex("\n", offset - 1) || -1
+        @out.byteslice(start + 1, offset - start - 1).match?(/\S/)
+      end
+
+      def line_of(offset) = (@lines.rindex { |start| start <= offset } || 0) + 1
+
+      def line_text(number)
+        from = @lines[number - 1]
+        to = @lines[number] || @source.bytesize
+        @source.byteslice(from, to - from).chomp
+      end
+    end
+  end
+end