browsable 0.1.0

data/lib/browsable/cli.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "thor"
+require "json"
+require "erb"
+require "pastel"
+
+module Browsable
+  # The `browsable` command-line interface.
+  #
+  # CLI is a thin shell: it parses flags, runs the audit pipeline (sources →
+  # analyzers → report), and hands the Report to a formatter. Every command's
+  # real logic lives in the classes it orchestrates.
+  class CLI < Thor
+    # The analyzer used for each routed file kind.
+    ANALYZERS = {
+      css:  Analyzers::CSS,
+      erb:  Analyzers::ERB,
+      html: Analyzers::HTML,
+      js:   Analyzers::Javascript
+    }.freeze
+
+    SKIP_REASONS = {
+      css: "stylelint not found — run `browsable doctor`",
+      js:  "eslint / eslint-plugin-compat not found — run `browsable doctor`"
+    }.freeze
+
+    def self.exit_on_failure? = true
+
+    class_option :config, type: :string, aliases: "-c", desc: "Path to a config file"
+    class_option :format, type: :string, enum: %w[human json github], desc: "Output format"
+    class_option :json, type: :boolean, desc: "Shortcut for --format json"
+
+    desc "audit [PATH]", "Audit a Rails app's frontend for browser-compatibility issues"
+    long_desc <<~DESC
+      Discovers the project's CSS, ERB/HTML and JavaScript, audits each against
+      the browser-support target inferred from ApplicationController's
+      allow_browser policy, and reports what your code requires versus what your
+      policy permits. Runs with zero configuration.
+    DESC
+    option :target, type: :string, desc: "Override the inferred browserslist query"
+    option :"no-build", type: :boolean, default: false,
+                        desc: "Scan only what is on disk (browsable never builds assets itself)"
+    option :include, type: :array, default: [], desc: "Extra path globs to scan (repeatable)"
+    option :exclude, type: :array, default: [], desc: "Path globs to exclude (repeatable)"
+    option :"fail-on", type: :string, enum: %w[warning error], default: "error",
+                       desc: "Exit non-zero when a finding of this severity (or higher) exists"
+    def audit(path = ".")
+      root = File.expand_path(path)
+      config = load_config(root)
+      target = resolve_target(config)
+
+      warn_missing_dependencies
+      report = run_audit(root: root, config: config, target: target)
+      emit(report)
+      exit(report.exit_code(fail_on: options["fail-on"] || "error"))
+    end
+    default_command :audit
+
+    desc "doctor", "Check that browsable's system dependencies are installed"
+    option :fix, type: :boolean, default: false,
+                 desc: "Attempt to install missing dependencies via brew/npm"
+    def doctor
+      doc = Doctor.new
+      puts doc.render(color: color?)
+
+      if options[:fix] && !doc.ok?
+        puts
+        doc.fix!
+        puts
+        puts doc.render(color: color?)
+      end
+
+      exit(doc.ok? ? 0 : 1)
+    end
+
+    desc "check FILE [FILE...]", "Audit specific files (used by editor integrations)"
+    option :target, type: :string, desc: "Override the inferred browserslist query"
+    def check(*files)
+      abort_with("`check` needs at least one file path.") if files.empty?
+
+      paths = files.map { |file| File.expand_path(file) }
+      root = detect_root(paths.first)
+      config = load_config(root)
+      target = resolve_target(config)
+
+      report = run_audit(root: root, config: config, target: target, file_list: paths)
+      emit(report)
+      exit(report.exit_code(fail_on: "error"))
+    end
+
+    desc "init", "Generate a .browsable.yml in the current directory"
+    long_desc <<~DESC
+      Writes a fully-commented .browsable.yml. Rails users should prefer the
+      generator: `rails g browsable:install` (writes config/browsable.yml).
+    DESC
+    option :force, type: :boolean, default: false, desc: "Overwrite an existing file"
+    option :minimal, type: :boolean, default: false, desc: "Write section headers only"
+    option :target, type: :string, desc: "Pre-populate a manual target query"
+    def init
+      destination = File.expand_path(".browsable.yml")
+      if File.exist?(destination) && !options[:force]
+        abort_with("#{destination} already exists. Pass --force to overwrite.")
+      end
+
+      File.write(destination, render_config_template)
+      puts pastel.green("Created #{destination}")
+      puts pastel.dim("This file is optional — delete it and browsable still works. " \
+                      "Uncomment a line to override a default.")
+      puts pastel.dim("Run `browsable audit` to try it out.")
+    end
+
+    desc "target [PATH]", "Show the browser-support target browsable inferred"
+    def target(path = ".")
+      config = load_config(File.expand_path(path))
+      resolved = resolve_target(config)
+
+      unconstrained = options[:target] ? [] : config.unconstrained_browsers
+      caveats = []
+      unless options[:target]
+        caveats << config.policy_note if config.policy_note
+        caveats.concat(config.target_notes)
+      end
+      caveats << resolved.note if resolved.note
+
+      if json_output?
+        puts JSON.pretty_generate(
+          resolved.as_json.merge(unconstrained_browsers: unconstrained, notes: caveats)
+        )
+      else
+        puts pastel.bold("Target: #{resolved.query}")
+        resolved.browsers.each { |browser, version| puts "  #{browser.ljust(9)}>= #{version}" }
+        unconstrained.each do |browser|
+          puts pastel.dim("  #{browser.ljust(9)}any version  (not listed in allow_browser)")
+        end
+        caveats.each { |note| puts pastel.yellow("! #{note}") }
+      end
+    end
+
+    desc "version", "Print the browsable version"
+    def version
+      puts "browsable #{Browsable::VERSION}"
+    end
+    map %w[--version -v] => :version
+
+    private
+
+    # --- pipeline ------------------------------------------------------------
+
+    def run_audit(root:, config:, target:, file_list: nil)
+      available = Doctor.new.available_kinds
+      skips = []
+      files_by_kind = file_list ? route_files(file_list) : discover_files(root: root, config: config)
+
+      collect_importmap(root: root, config: config, files_by_kind: files_by_kind, skips: skips) if file_list.nil?
+
+      findings = []
+      ANALYZERS.each do |kind, analyzer_class|
+        files = files_by_kind[kind] || []
+        next if files.empty?
+
+        unless available.include?(kind)
+          skips << Report::Skip.new(kind: kind, reason: SKIP_REASONS.fetch(kind, "tooling unavailable"))
+          next
+        end
+
+        analyzer = analyzer_class.new(target: target, config: config)
+        findings.concat(analyzer.analyze(files))
+      rescue StandardError => e
+        skips << Report::Skip.new(kind: kind, reason: "#{kind} analysis failed: #{e.message}")
+      end
+
+      notes = []
+      # Surface target caveats — a policy that could not be inferred, or the
+      # Rails rule that browsers absent from an allow_browser hash are
+      # unconstrained — unless the user overrode the target on the command line.
+      unless options[:target]
+        notes << config.policy_note if config.policy_note
+        notes.concat(config.target_notes)
+      end
+      # How the target itself resolved (e.g. a built-in fallback) is relevant
+      # even when --target was passed.
+      notes << target.note if target.note
+
+      # The full policy landscape — every allow_browser callsite across the
+      # app's controllers, not just ApplicationController. Skipped for `check`,
+      # which audits specific files for editor integration.
+      policies = file_list ? [] : PolicyScanner.call(root)
+
+      Report.new(findings: findings, skips: skips, notes: notes, policies: policies,
+                 target: target, root: root, config_file: config.config_file)
+    end
+
+    def collect_importmap(root:, config:, files_by_kind:, skips:)
+      return unless config.importmap_enabled?
+
+      importmap = Sources::Importmap.new(root: root)
+      return unless importmap.present?
+
+      if ENV["BROWSABLE_OFFLINE"] == "1"
+        skips << Report::Skip.new(kind: :importmap,
+                                  reason: "BROWSABLE_OFFLINE=1 — remote pins were not fetched")
+        return
+      end
+
+      (files_by_kind[:js] ||= []).concat(importmap.fetch)
+    end
+
+    def discover_files(root:, config:)
+      src = config.sources
+      excludes = Array(options[:exclude]) + config.ignore_files
+
+      sources = [
+        Sources::Stylesheets.new(root: root, globs: src["stylesheets"], excludes: excludes),
+        Sources::Builds.new(root: root, globs: src["builds"], excludes: excludes),
+        Sources::Views.new(root: root, globs: src["views"], excludes: excludes),
+        Sources::Javascripts.new(root: root, globs: src["javascript"], excludes: excludes),
+        Sources::PublicAssets.new(root: root, globs: src["public"], excludes: excludes)
+      ]
+
+      extra = Array(src["custom"]) + Array(options[:include])
+      sources << Sources::Base.new(root: root, globs: extra, excludes: excludes) if extra.any?
+
+      route_files(sources.flat_map(&:files).uniq)
+    end
+
+    # Route files to an analyzer by extension. `*.html.erb` ends in `.erb`.
+    def route_files(files)
+      buckets = { css: [], erb: [], html: [], js: [] }
+      files.each do |file|
+        case File.extname(file).downcase
+        when ".css", ".scss" then buckets[:css] << file
+        when ".js", ".mjs"   then buckets[:js] << file
+        when ".erb"          then buckets[:erb] << file
+        when ".html", ".htm" then buckets[:html] << file
+        end
+        # TODO(v0.2): route Ruby view components (app/components/**/*.rb).
+      end
+      buckets
+    end
+
+    # --- output --------------------------------------------------------------
+
+    def emit(report)
+      puts formatter_class.new(report).render
+    end
+
+    def formatter_class
+      name = json_output? ? "json" : (options[:format] || "human")
+      { "human" => Formatters::Human, "json" => Formatters::Json,
+        "github" => Formatters::Github }.fetch(name)
+    end
+
+    def json_output?
+      options[:json] || options[:format] == "json"
+    end
+
+    # --- config / target ----------------------------------------------------
+
+    def load_config(root)
+      Config.load(root: root, path: options[:config])
+    rescue ConfigError => e
+      abort_with(e.message)
+    end
+
+    def resolve_target(config)
+      options[:target] ? Target.new(options[:target]) : config.target
+    end
+
+    # --- helpers -------------------------------------------------------------
+
+    def warn_missing_dependencies
+      return if ENV.key?("BROWSABLE_DRY_RUN")
+
+      missing = %i[css js] - Doctor.new.available_kinds
+      return if missing.empty?
+
+      $stderr.puts pastel(io: $stderr).yellow(
+        "! #{missing.join(' and ')} analysis is disabled (missing tools). " \
+        "Run `browsable doctor` for setup instructions."
+      )
+    end
+
+    # Walk up from a file to find the project root.
+    def detect_root(start)
+      dir = File.directory?(start) ? start : File.dirname(start)
+      markers = %w[Gemfile config.ru .browsable.yml config/browsable.yml]
+      current = dir
+      loop do
+        return current if markers.any? { |m| File.exist?(File.join(current, m)) }
+
+        parent = File.dirname(current)
+        return dir if parent == current
+
+        current = parent
+      end
+    end
+
+    def render_config_template
+      template_path = File.expand_path(
+        "../generators/browsable/install/templates/browsable.yml.tt", __dir__
+      )
+      policy = Config.load(root: Dir.pwd).detected_policy
+      comment =
+        case policy
+        when nil
+          "# (No allow_browser call detected — browsable will fall back to browserslist defaults.)"
+        when Hash
+          "# Detected: ApplicationController declares an explicit allow_browser versions hash."
+        else
+          "# Detected: ApplicationController uses `allow_browser versions: :#{policy}`"
+        end
+
+      ERB.new(File.read(template_path), trim_mode: "-")
+         .result_with_hash(detected_comment: comment,
+                           manual_query: options[:target],
+                           minimal: options[:minimal])
+    end
+
+    def color?
+      $stdout.tty?
+    end
+
+    def pastel(io: $stdout)
+      Pastel.new(enabled: io.tty?)
+    end
+
+    def abort_with(message)
+      $stderr.puts pastel(io: $stderr).red("Error: #{message}")
+      exit(1)
+    end
+  end
+end

data/lib/browsable/config.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Browsable
+  # Resolves the effective configuration for an audit run.
+  #
+  # browsable runs fully zero-config: when no config file is present every
+  # value below is inferred. A config file only exists to *override* defaults.
+  #
+  # Resolution precedence (highest wins) is applied by the caller:
+  #   1. CLI flags        (handled in CLI)
+  #   2. config file      (loaded here)
+  #   3. inferred Rails   (allow_browser policy, read here)
+  #   4. gem defaults     (DEFAULTS below)
+  class Config
+    DEFAULTS = {
+      "target" => {
+        "source"       => "allow_browsers", # allow_browsers | browserslist | manual
+        "manual_query" => "defaults"
+      },
+      "sources" => {
+        "stylesheets" => ["app/assets/stylesheets/**/*.{css,scss}"],
+        "builds"      => ["app/assets/builds/**/*.css"],
+        "views"       => ["app/views/**/*.{html.erb,turbo_stream.erb}",
+                          "app/components/**/*.{rb,html.erb}"],
+        "javascript"  => ["app/javascript/**/*.{js,mjs}"],
+        "importmap"   => true,
+        "public"      => ["public/**/*.{html,css,js}"],
+        "custom"      => []
+      },
+      "severity" => {
+        "baseline_newly_available" => "warning",
+        "baseline_limited"         => "error",
+        "below_target"             => "error"
+      },
+      "ignore" => {
+        "features" => [],
+        "files"    => []
+      }
+    }.freeze
+
+    # Discovery order for an implicit config file, relative to the project root.
+    CONFIG_FILENAMES = ["config/browsable.yml", ".browsable.yml"].freeze
+
+    attr_reader :root, :data, :config_file, :detected_policy, :policy_note
+
+    # Load and merge configuration for a project rooted at `root`.
+    #
+    # @param root [String] the Rails app (or project) root
+    # @param path [String, nil] an explicit config file path (from --config)
+    def self.load(root:, path: nil)
+      root = File.expand_path(root)
+      config_file = locate_file(root, path)
+      file_data = config_file ? parse_file(config_file) : {}
+      merged = deep_merge(DEFAULTS, file_data)
+      new(root: root, data: merged, config_file: config_file)
+    end
+
+    def self.locate_file(root, explicit)
+      if explicit
+        full = File.expand_path(explicit, root)
+        raise ConfigError, "Config file not found: #{explicit}" unless File.file?(full)
+
+        return full
+      end
+
+      CONFIG_FILENAMES
+        .map { |name| File.join(root, name) }
+        .find { |candidate| File.file?(candidate) }
+    end
+
+    def self.parse_file(path)
+      loaded = YAML.safe_load_file(path) || {}
+      raise ConfigError, "#{path} must contain a YAML mapping" unless loaded.is_a?(Hash)
+
+      loaded
+    rescue Psych::SyntaxError => e
+      raise ConfigError, "Could not parse #{path}: #{e.message}"
+    end
+
+    def self.deep_merge(base, override)
+      base.merge(override) do |_key, base_val, override_val|
+        if base_val.is_a?(Hash) && override_val.is_a?(Hash)
+          deep_merge(base_val, override_val)
+        else
+          override_val
+        end
+      end
+    end
+
+    def initialize(root:, data:, config_file: nil)
+      @root = root
+      @data = data
+      @config_file = config_file
+      # PolicyDetector statically resolves the Rails allow_browser policy.
+      # `policy_note` is set when a call was found but could not be resolved.
+      result = PolicyDetector.call(root)
+      @detected_policy = result.policy
+      @policy_note = result.note
+    end
+
+    def sources       = data.fetch("sources")
+    def severity      = data.fetch("severity")
+    def ignore_features = Array(data.dig("ignore", "features"))
+    def ignore_files    = Array(data.dig("ignore", "files"))
+    def importmap_enabled? = sources.fetch("importmap", true) != false
+
+    # Resolve the browser-support Target implied by this config.
+    def target
+      cfg = data.fetch("target")
+      case cfg["source"]
+      when "manual"
+        Target.new(cfg.fetch("manual_query", "defaults"))
+      when "browserslist"
+        # Defer entirely to the project's browserslist config (.browserslistrc).
+        Target.new("defaults")
+      else # "allow_browsers" (the default)
+        detected_policy ? Target.from_rails_policy(detected_policy) : Target.new("defaults")
+      end
+    end
+
+    # Major browsers an explicit allow_browser *hash* neither pins to a version
+    # nor blocks. Rails allows these at any version — it only ever blocks a
+    # browser it was given a minimum (or `false`) for — so browsable has no
+    # floor to audit them against. Empty unless the policy is an explicit hash.
+    def unconstrained_browsers
+      return [] unless detected_policy.is_a?(Hash)
+
+      Target::MODERN.keys - detected_policy.keys
+    end
+
+    # Informational caveats about the resolved target — so the user is never
+    # left guessing why a particular set of browsers is (or isn't) audited.
+    def target_notes
+      notes = []
+      inferring = data.dig("target", "source") == "allow_browsers"
+
+      # No allow_browser policy at all — explain the browserslist defaults fallback.
+      if inferring && detected_policy.nil? && policy_note.nil?
+        notes << "No allow_browser policy was found in ApplicationController, so browsable " \
+                 "is auditing against the browserslist `defaults` baseline. Add an " \
+                 "allow_browser call, or set `target:` in config/browsable.yml, to pick the " \
+                 "browsers to audit against explicitly."
+      end
+
+      # A partial hash policy — explain the browsers Rails leaves unconstrained.
+      if unconstrained_browsers.any?
+        pinned = detected_policy.keys.join(", ")
+        omitted = unconstrained_browsers.join(", ")
+        notes << "Your allow_browser policy pins a version only for #{pinned}. Rails leaves " \
+                 "every browser you don't list (#{omitted}) allowed at any version, so " \
+                 "browsable audits only #{pinned}. Add a `target:` block to " \
+                 "config/browsable.yml to audit the others."
+      end
+
+      notes
+    end
+
+    # True when an explicit config file was found and loaded.
+    def file_present? = !config_file.nil?
+  end
+end

data/lib/browsable/doctor.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "open3"
+require "shellwords"
+require "rbconfig"
+require "pastel"
+
+module Browsable
+  # Verifies that the external tools browsable shells out to are installed, and
+  # guides the user through installing whatever is missing.
+  #
+  # Herb is a gem dependency and runs in-process, so it is never checked here —
+  # only node, npm, stylelint, eslint and eslint-plugin-compat.
+  class Doctor
+    # A tool browsable depends on. `binary` is nil for packages that ship no
+    # executable (checked via the global npm tree instead). `enables` lists the
+    # analyzer kinds the tool unlocks.
+    Tool = Data.define(:key, :label, :binary, :npm_package, :purpose, :enables, :required) do
+      def binary? = !binary.nil?
+    end
+
+    # The resolved state of a tool on this machine.
+    Status = Data.define(:tool, :installed, :detail) do
+      def installed? = installed
+    end
+
+    TOOLS = [
+      Tool.new(key: :node, label: "node", binary: "node", npm_package: nil,
+               purpose: "JavaScript runtime that stylelint and eslint run on",
+               enables: %i[css js], required: true),
+      Tool.new(key: :npm, label: "npm", binary: "npm", npm_package: nil,
+               purpose: "installs the CSS/JS tooling (used by `doctor --fix`)",
+               enables: [], required: false),
+      Tool.new(key: :stylelint, label: "stylelint", binary: "stylelint",
+               npm_package: "stylelint stylelint-no-unsupported-browser-features",
+               purpose: "audits CSS for unsupported browser features",
+               enables: %i[css], required: true),
+      Tool.new(key: :eslint, label: "eslint", binary: "eslint",
+               npm_package: "eslint eslint-plugin-compat",
+               purpose: "audits JavaScript for unsupported browser features",
+               enables: %i[js], required: true),
+      Tool.new(key: :eslint_plugin_compat, label: "eslint-plugin-compat", binary: nil,
+               npm_package: "eslint-plugin-compat",
+               purpose: "the eslint plugin that performs the JS compat checks",
+               enables: %i[js], required: true)
+    ].freeze
+
+    # Analyzer kinds that need no external tooling at all.
+    ALWAYS_AVAILABLE = %i[erb html].freeze
+
+    def statuses
+      @statuses ||= TOOLS.map do |tool|
+        present = installed?(tool)
+        Status.new(tool: tool, installed: present, detail: detail_for(tool, present))
+      end
+    end
+
+    # True when every *required* tool is present.
+    def ok?
+      statuses.select { |s| s.tool.required }.all?(&:installed?)
+    end
+
+    def missing
+      statuses.reject(&:installed?).map(&:tool)
+    end
+
+    # Which analyzer kinds can actually run on this machine right now.
+    def available_kinds
+      # In dry-run mode the external tools are never invoked, so treat them all
+      # as available — this keeps specs and `BROWSABLE_DRY_RUN` audits working.
+      return %i[css erb html js] if ENV.key?("BROWSABLE_DRY_RUN")
+
+      kinds = ALWAYS_AVAILABLE.dup
+      %i[css js].each do |kind|
+        needed = TOOLS.select { |tool| tool.enables.include?(kind) }
+        kinds << kind if needed.all? { |tool| installed?(tool) }
+      end
+      kinds
+    end
+
+    # A formatted, colourised dependency report.
+    def render(color: $stdout.tty?)
+      pastel = Pastel.new(enabled: color)
+      lines = [pastel.bold("browsable doctor — system dependencies"), ""]
+
+      statuses.each do |status|
+        mark = status.installed? ? pastel.green("✓") : pastel.red("✗")
+        lines << "  #{mark} #{pastel.bold(status.tool.label)} — #{status.tool.purpose}"
+        lines << pastel.dim("      #{status.detail}") if status.detail
+      end
+
+      lines << ""
+      if ok?
+        lines << pastel.green.bold("All required tools are installed. You're ready to audit.")
+      else
+        lines << pastel.red.bold("Missing required tools — install them with:")
+        install_commands.each { |cmd| lines << "  #{pastel.cyan(cmd)}" }
+        lines << ""
+        lines << pastel.dim("Or run `browsable doctor --fix` to install them automatically.")
+      end
+      lines.join("\n")
+    end
+
+    # Attempt to install everything that is missing. Runnable commands only
+    # (npm/brew); anything that needs a manual download is reported, not run.
+    def fix!(io: $stdout, input: $stdin, assume_yes: false)
+      return true if ok?
+
+      runnable, manual = install_commands.partition { |cmd| cmd.start_with?("npm ", "brew ") }
+
+      manual.each { |cmd| io.puts "Manual step required: #{cmd}" }
+      return ok? if runnable.empty?
+
+      io.puts "browsable will run:"
+      runnable.each { |cmd| io.puts "  #{cmd}" }
+      unless assume_yes
+        io.print "Proceed? [y/N] "
+        answer = input.gets&.strip&.downcase
+        return false unless %w[y yes].include?(answer)
+      end
+
+      runnable.each do |cmd|
+        io.puts "+ #{cmd}"
+        system(cmd)
+      end
+      @statuses = nil
+      @installed_cache = nil
+      ok?
+    end
+
+    private
+
+    def install_commands
+      missing.map { |tool| install_command(tool) }.uniq
+    end
+
+    def install_command(tool)
+      case tool.key
+      when :node, :npm
+        mac? ? "brew install node" : "install Node.js — see https://nodejs.org/en/download"
+      else
+        "npm install -g #{tool.npm_package}"
+      end
+    end
+
+    def detail_for(tool, present)
+      if present
+        tool.binary? ? (tool_version(tool) || "installed") : "installed"
+      else
+        "not found — #{install_command(tool)}"
+      end
+    end
+
+    def installed?(tool)
+      @installed_cache ||= {}
+      @installed_cache.fetch(tool.key) do
+        @installed_cache[tool.key] = tool.binary? ? binary_on_path?(tool.binary) : npm_package_installed?(tool.npm_package)
+      end
+    end
+
+    def binary_on_path?(binary)
+      _out, status = Open3.capture2e("sh", "-c", "command -v #{Shellwords.escape(binary)}")
+      status.success?
+    rescue StandardError
+      false
+    end
+
+    # eslint-plugin-compat ships no executable, so check the global npm tree.
+    def npm_package_installed?(package)
+      _out, status = Open3.capture2e("npm", "ls", "-g", "--depth=0", package.to_s.split.first)
+      status.success?
+    rescue Errno::ENOENT
+      false # npm itself is missing
+    rescue StandardError
+      false
+    end
+
+    def tool_version(tool)
+      out, status = Open3.capture2e(tool.binary, "--version")
+      status.success? ? out.strip.lines.first&.strip : nil
+    rescue StandardError
+      nil
+    end
+
+    def mac?
+      RbConfig::CONFIG["host_os"].to_s.match?(/darwin|mac os/i)
+    end
+  end
+end