rails_omnibar 1.0.0

data/javascript/src/hooks/use_hotkey.ts

@@ -0,0 +1,18 @@
+import {useCallback, useEffect} from "preact/hooks"
+
+export const useHotkey = (hotkey: string, action: () => void) => {
+  const onKeyDown = useCallback(
+    ({metaKey, ctrlKey, key}: KeyboardEvent) => {
+      if ((metaKey || ctrlKey) && key.toLowerCase() == hotkey) {
+        action()
+      }
+    },
+    [action, hotkey]
+  )
+
+  useEffect(() => {
+    document.addEventListener("keydown", onKeyDown)
+
+    return () => document.removeEventListener("keydown", onKeyDown)
+  }, [onKeyDown])
+}

data/javascript/src/hooks/use_item_action.tsx

@@ -0,0 +1,20 @@
+import React, {useCallback} from "preact/hooks"
+import {Item, ModalBag} from "../types"
+
+export const useItemAction = (modal: ModalBag) => {
+  return useCallback(
+    (item: Item) => {
+      if (!item) return
+
+      item = item as Item
+      if (item.url) {
+        window.location.href = item.url
+      } else if (item.modalHTML) {
+        const __html = item.modalHTML
+        modal.setBody(<div dangerouslySetInnerHTML={{__html}} />)
+        modal.toggle()
+      }
+    },
+    [modal]
+  )
+}

data/javascript/src/hooks/use_modal.tsx

@@ -0,0 +1,33 @@
+import React, {useCallback, useMemo, useState} from "preact/hooks"
+import ReactModal from "react-modal"
+import {ModalBag} from "../types"
+
+export const useModal = (staticBody?: JSX.Element): ModalBag => {
+  const [open, setOpen] = useState(false)
+  const [body, setBody] = useState(<></>)
+
+  const modal = useMemo(
+    () => (
+      <ReactModal
+        ariaHideApp={false}
+        isOpen={open}
+        onRequestClose={() => setOpen(false)}
+        style={{overlay: {zIndex: 1001}, content: {zIndex: 1001}}}
+      >
+        <span
+          onClick={() => setOpen(false)}
+          style={{cursor: "pointer", float: "right"}}
+        >
+          ╳
+        </span>
+        <div style={{visibility: "hidden"}}>╳</div>
+        {staticBody || body}
+      </ReactModal>
+    ),
+    [body, open, setOpen, staticBody]
+  )
+
+  const toggle = useCallback(() => setOpen(!open), [setOpen, open])
+
+  return {modal, setBody, toggle}
+}

data/javascript/src/hooks/use_omnibar_extensions.ts

@@ -0,0 +1,33 @@
+import {useMemo} from "preact/hooks"
+import {AppArgs, Item} from "../types"
+import fuzzysort from "fuzzysort"
+import {tryCalculate} from "yaam"
+
+export const useOmnibarExtensions = (args: AppArgs) => {
+  return useMemo(() => [commands(args), items(args), calculator(args)], [args])
+}
+
+const commands = ({commandPattern: p, queryPath}: AppArgs) => {
+  const commandRegexp = useMemo(() => p && new RegExp(p.source, p.options), [p])
+
+  return async (q: string) => {
+    if (!queryPath || !commandRegexp?.test(q)) return []
+
+    const response = await fetch(`${queryPath}&q=${q}`)
+    return await response.json()
+  }
+}
+
+const items = ({items}: AppArgs) => {
+  return (q: string) => fuzzysort.go(q, items, {key: "title"}).map((r) => r.obj)
+}
+
+const calculator = ({calculator}: AppArgs) => {
+  return (q: string) => {
+    const result = calculator ? tryCalculate(q) : null
+    if (result !== null) {
+      return [{title: String(result), type: "default" as Item["type"]}]
+    }
+    return new Array<Item>()
+  }
+}

data/javascript/src/hooks/use_toggle_focus.ts

@@ -0,0 +1,15 @@
+import {useCallback} from "preact/hooks"
+import {INPUT_DATA_ID} from "../types"
+
+export const useToggleFocus = () => {
+  return useCallback(() => {
+    setTimeout(() => {
+      const input = document.querySelector(`[data-id=${INPUT_DATA_ID}]`)
+      if (input && document.activeElement === input) {
+        ;(input as HTMLInputElement).blur()
+      } else if (input) {
+        ;(input as HTMLInputElement).focus()
+      }
+    }, 100)
+  }, [])
+}

data/javascript/src/index.ts

@@ -0,0 +1 @@
+export * from './app'

data/javascript/src/types.ts

@@ -0,0 +1,34 @@
+export const INPUT_DATA_ID = "rails-omnibar"
+
+export type AppArgs = {
+  calculator: boolean
+  commandPattern: JsRegex
+  hotkey: string
+  items: Array<Item>
+  maxResults: number
+  modal: boolean
+  placeholder?: string
+  queryPath?: string
+}
+
+export type Item = {
+  title: string
+  url?: string
+  modalHTML?: string
+  type: "default" | "help"
+}
+
+export type JsRegex = {
+  source: string
+  options: string
+}
+
+export type ModalBag = {
+  modal: JSX.Element
+  setBody: (v: JSX.Element) => void
+  toggle: () => void
+}
+
+export type ModalArg = {
+  itemModal: ModalBag
+}

data/lib/rails_omnibar/command/base.rb

@@ -0,0 +1,44 @@
+class RailsOmnibar
+  module Command
+    class Base
+      attr_reader :pattern, :resolver, :description, :example
+
+      def initialize(pattern:, resolver:, description: nil, example: nil)
+        @pattern = cast_to_pattern(pattern)
+        @resolver = cast_to_proc(resolver, 2)
+        @description = description
+        @example = example
+      end
+
+      def call(input, omnibar = nil)
+        match = pattern.match(input)
+        # look at match for highest capturing group or whole pattern
+        value = match.to_a.last || raise(ArgumentError, 'input !~ pattern')
+        results = resolver.call(value, omnibar)
+        results = results.try(:to_ary) || [results]
+        results.map { |e| RailsOmnibar.cast_to_item(e) }
+      end
+
+      private
+
+      def cast_to_pattern(arg)
+        regexp =
+          case arg
+          when Regexp   then arg
+          when String   then /^#{Regexp.escape(arg)}.+/
+          when NilClass then /.+/
+          else raise ArgumentError, "pattern can't be a #{arg.class}"
+          end
+
+        regexp
+      end
+
+      def cast_to_proc(arg, arity)
+        arg = arg.is_a?(Proc) ? arg : arg.method(:call).to_proc
+        arg.is_a?(Proc) && arg.arity == arity ||
+          raise(ArgumentError, "arg must be a Proc with arity #{arity}")
+        arg
+      end
+    end
+  end
+end

data/lib/rails_omnibar/command/search.rb

@@ -0,0 +1,68 @@
+class RailsOmnibar
+  def self.add_search(**kwargs)
+    add_command Command::Search.new(**kwargs)
+  end
+
+  def self.add_record_search(**kwargs)
+    add_command Command::RecordSearch.new(**kwargs)
+  end
+
+  module Command
+    # Generic search.
+    class Search < Base
+      def initialize(finder:, itemizer:, **kwargs)
+        finder   = cast_to_proc(finder, 1)
+        itemizer = cast_to_proc(itemizer, 1)
+        resolver = ->(value, omnibar) do
+          findings = finder.call(value)
+          findings = Array(findings) unless findings.respond_to?(:first)
+          findings.first(omnibar.max_results).map(&itemizer)
+        end
+
+        super(resolver: resolver, **kwargs)
+      end
+    end
+
+    # ActiveRecord-specific search.
+    class RecordSearch < Search
+      def initialize(model:, columns: :id, pattern: nil, finder: nil, itemizer: nil, example: nil)
+        # casting and validations
+        model = model.to_s.classify.constantize unless model.is_a?(Class)
+        model < ActiveRecord::Base || raise(ArgumentError, 'model: must be a model')
+        columns = Array(columns).map(&:to_s)
+        columns.present? || raise(ArgumentError, 'columns: must be given')
+        columns.each { |c| c.in?(model.column_names) || raise(ArgumentError, "bad column #{c}") }
+
+        # default finder, uses LIKE/ILIKE for non-id columns
+        finder ||= ->(q) do
+          return model.none if q.blank?
+
+          columns.inject(model.none) do |rel, col|
+            rel.or(col =~ /id$/ ? model.where(col => q) :
+                                  model.where("#{col} #{RailsOmnibar.like} ?", "%#{q}%"))
+          end
+        end
+
+        # default itemizer
+        itemizer ||= ->(record) do
+          {
+            title: "#{record.class.name}##{record.id}",
+            url:   "/#{model.model_name.route_key}/#{record.to_param}",
+          }
+        end
+
+        super(
+          description: "Find #{model.name} by #{columns.join(' OR ')}".tr('_', ' '),
+          example:     example,
+          pattern:     pattern,
+          finder:      finder,
+          itemizer:    itemizer,
+        )
+      end
+    end
+  end
+
+  def self.like
+    @like ||= ActiveRecord::Base.connection.adapter_name =~ /^post|pg/i ? 'ILIKE' : 'LIKE'
+  end
+end

data/lib/rails_omnibar/commands.rb

@@ -0,0 +1,28 @@
+class RailsOmnibar
+  def self.handle(input)
+    commands.find { |h| h.pattern.match?(input) }&.then { |h| h.call(input, self) } || []
+  end
+
+  def self.command_pattern
+    commands.any? ? Regexp.union(commands.map(&:pattern)) : /$NO_COMMANDS/
+  end
+
+  def self.add_command(command)
+    commands << RailsOmnibar.cast_to_command(command)
+    clear_cache
+    self
+  end
+
+  def self.cast_to_command(arg)
+    case arg
+    when Command::Base then arg
+    when Hash          then Command::Base.new(**arg)
+    else raise(ArgumentError, "expected command, got #{arg.class}")
+    end
+  end
+
+  private_class_method\
+  def self.commands
+    @commands ||= []
+  end
+end

data/lib/rails_omnibar/config.rb

@@ -0,0 +1,35 @@
+class RailsOmnibar
+  def self.max_results=(arg)
+    arg.is_a?(Integer) && arg > 0 || raise(ArgumentError, 'max_results must be > 0')
+    @max_results = arg
+  end
+  def self.max_results
+    @max_results || 10
+  end
+
+  singleton_class.attr_writer :modal
+  def self.modal?
+    instance_variable_defined?(:@modal) ? !!@modal : false
+  end
+
+  singleton_class.attr_writer :calculator
+  def self.calculator?
+    instance_variable_defined?(:@calculator) ? !!@calculator : true
+  end
+
+  def self.hotkey
+    @hotkey || 'k'
+  end
+  def self.hotkey=(arg)
+    arg.to_s.size == 1 || raise(ArgumentError, 'hotkey must have length 1')
+    @hotkey = arg.to_s.downcase
+  end
+
+  singleton_class.attr_writer :placeholder
+  def self.placeholder
+    return @placeholder.presence unless @placeholder.nil?
+
+    help_item = items.find { |i| i.type == :help }
+    help_item && "Hint: Type `#{help_item.title}` for help"
+  end
+end

data/lib/rails_omnibar/engine.rb

@@ -0,0 +1,5 @@
+class RailsOmnibar
+  class Engine < Rails::Engine
+    isolate_namespace RailsOmnibar
+  end
+end

data/lib/rails_omnibar/item/base.rb

@@ -0,0 +1,21 @@
+class RailsOmnibar
+  module Item
+    class Base
+      attr_reader :title, :url, :modal_html, :type
+
+      def initialize(title:, url: nil, modal_html: nil, type: :default)
+        title.class.in?([String, Symbol]) && title.present? || raise(ArgumentError, 'title: must be a String')
+        url.present? && modal_html.present? && raise(ArgumentError, 'use EITHER url: OR modal_html:')
+
+        @title      = title
+        @url        = url
+        @modal_html = modal_html
+        @type       = type
+      end
+
+      def as_json(*)
+        { title: title, url: url, modalHTML: modal_html, type: type }
+      end
+    end
+  end
+end

data/lib/rails_omnibar/item/help.rb

@@ -0,0 +1,22 @@
+class RailsOmnibar
+  def self.add_help(**kwargs)
+    add_item Item::Help.new(for_commands: commands, **kwargs)
+    self.class
+  end
+
+  module Item
+    class Help < Base
+      def initialize(title: '? - Help', for_commands:, custom_content: nil)
+        super title: title, type: :help, modal_html: <<~HTML
+          <span>Available actions:<span>
+          <ul>
+            #{custom_content&.then { |c| "<li>#{c}</li>" } }
+            #{for_commands.map do |h|
+              "<li><b>#{h.description}</b><br>Example: `#{h.example}`</li>"
+            end.join}
+          </ul>
+        HTML
+      end
+    end
+  end
+end

data/lib/rails_omnibar/items.rb

@@ -0,0 +1,25 @@
+class RailsOmnibar
+  def self.add_item(item)
+    items << RailsOmnibar.cast_to_item(item)
+    clear_cache
+    self.class
+  end
+
+  def self.add_items(*args)
+    args.each { |arg| add_item(arg) }
+    self.class
+  end
+
+  def self.cast_to_item(arg)
+    case arg
+    when Item::Base then arg
+    when Hash       then Item::Base.new(**arg)
+    else raise(ArgumentError, "expected Item, got #{arg.class}")
+    end
+  end
+
+  private_class_method\
+  def self.items
+    @items ||= []
+  end
+end

data/lib/rails_omnibar/rendering.rb

@@ -0,0 +1,34 @@
+class RailsOmnibar
+  def self.render
+    @cached_html ||= <<~HTML.html_safe
+      <script src='#{urls.js_path}?v=#{RailsOmnibar::VERSION}' type='text/javascript'></script>
+      <div id='mount-rails-omnibar'>
+        <script type="application/json">#{to_json}</script>
+      </div>
+    HTML
+  end
+
+  require 'js_regex'
+
+  def self.as_json(*)
+    {
+      calculator:     calculator?,
+      commandPattern: JsRegex.new!(command_pattern, target: 'ES2018'),
+      hotkey:         hotkey,
+      items:          items,
+      maxResults:     max_results,
+      modal:          modal?,
+      placeholder:    placeholder,
+      queryPath:      urls.query_path(omnibar_class: self),
+    }
+  end
+
+  def self.urls
+    @urls ||= RailsOmnibar::Engine.routes.url_helpers
+  end
+
+  private_class_method\
+  def self.clear_cache
+    @cached_html = nil
+  end
+end

data/lib/rails_omnibar/version.rb

@@ -0,0 +1,3 @@
+class RailsOmnibar
+  VERSION = '1.0.0'
+end

data/lib/rails_omnibar.rb

@@ -0,0 +1,8 @@
+require 'rails'
+
+Dir[File.join(__dir__, 'rails_omnibar', '**', '*.rb')].sort.each { |f| require(f) }
+
+class RailsOmnibar
+  singleton_class.alias_method :configure, :tap
+  singleton_class.undef_method :new
+end

data/package.json

@@ -0,0 +1,27 @@
+{
+  "scripts": {
+    "compile": "npx webpack",
+    "test": "bundle exec rake"
+  },
+  "dependencies": {
+    "fuzzysort": "^2.0.4",
+    "omnibar2": "^2.4.0",
+    "preact": "^10.11.3",
+    "preact-habitat": "^3.3.0",
+    "react-modal": "^3.16.1",
+    "yaam": "^1.1.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.17.6",
+    "@babel/core": "^7.17.8",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/preset-react": "^7.16.7",
+    "@babel/preset-typescript": "^7.18.6",
+    "@types/react-modal": "^3.13.1",
+    "babel-loader": "^8.2.4",
+    "ts-loader": "^9.4.2",
+    "tslib": "^2.4.1",
+    "webpack": "^5.70.0",
+    "webpack-cli": "^4.9.2"
+  }
+}

data/rails_omnibar.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require_relative 'lib/rails_omnibar/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rails_omnibar'
+  spec.version       = RailsOmnibar::VERSION
+  spec.authors       = ['Janosch Müller']
+  spec.summary       = 'Omnibar for Rails'
+  spec.description   = 'Omnibar for Rails'
+  spec.homepage      = 'https://github.com/jaynetics/rails_omnibar'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0") + %w[javascript/compiled.js]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.7'
+
+  spec.add_dependency 'js_regex'
+  spec.add_dependency 'rails', ['>= 6.0', '< 8.0']
+
+  spec.add_development_dependency 'capybara', '~> 3.0'
+  spec.add_development_dependency 'factory_bot_rails', '~> 6.0'
+  spec.add_development_dependency 'puma', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec-rails', '~> 5.0'
+  spec.add_development_dependency 'sqlite3', '>= 1.3.6'
+  spec.add_development_dependency 'webdrivers', '~> 5.0'
+end

data/spec/app_template.rb

@@ -0,0 +1,17 @@
+gem 'rails_omnibar', path: __dir__ + '/../'
+
+generate 'model', 'User first_name:string last_name:string admin:boolean --no-test-framework'
+
+file 'app/lib/my_omnibar.rb', File.read(__dir__ + '/my_omnibar_template.rb')
+
+inject_into_class 'app/controllers/application_controller.rb', 'ApplicationController', <<-RUBY
+  def index
+    render html: MyOmnibar.render
+  end
+RUBY
+
+route 'mount RailsOmnibar::Engine => "/rails_omnibar"'
+route 'root "application#index"'
+route 'get "users/(*path)" => "application#index"'
+
+rake 'db:migrate db:test:prepare'

data/spec/lib/rails_omnibar/config_spec.rb

@@ -0,0 +1,53 @@
+require 'rails_helper'
+
+describe RailsOmnibar do
+  subject { Class.new(RailsOmnibar) }
+
+  it 'has a configurable max_results' do
+    expect(subject.max_results).to eq 10
+    subject.max_results = 5
+    expect(subject.max_results).to eq 5
+    expect { subject.max_results = 0 }.to raise_error(ArgumentError)
+    expect { subject.max_results = '5' }.to raise_error(ArgumentError)
+    expect { subject.max_results = 5.0 }.to raise_error(ArgumentError)
+  end
+
+  it 'has a configurable hotkey' do
+    expect(subject.hotkey).to eq 'k'
+    subject.hotkey = 'z'
+    expect(subject.hotkey).to eq 'z'
+    subject.hotkey = 'K' # should be downcased
+    expect(subject.hotkey).to eq 'k'
+    expect { subject.hotkey = '' }.to raise_error(ArgumentError)
+    expect { subject.hotkey = 'kk' }.to raise_error(ArgumentError)
+  end
+
+  it 'has a configurable rendering' do
+    expect(subject.modal?).to eq false
+    subject.modal = true
+    expect(subject.modal?).to eq true
+    subject.modal = false
+    expect(subject.modal?).to eq false
+  end
+
+  it 'has a configurable calculator' do
+    expect(subject.calculator?).to eq true
+    subject.calculator = false
+    expect(subject.calculator?).to eq false
+    subject.calculator = true
+    expect(subject.calculator?).to eq true
+  end
+
+  it 'has a configurable placeholder' do
+    expect(subject.placeholder).to eq nil
+    subject.placeholder = 'foo'
+    expect(subject.placeholder).to eq 'foo'
+    # falls back to help item hint if help item exists
+    subject.add_help(title: 'REEE')
+    expect(subject.placeholder).to eq 'foo'
+    subject.placeholder = nil
+    expect(subject.placeholder).to eq 'Hint: Type `REEE` for help'
+    subject.placeholder = false
+    expect(subject.placeholder).to eq nil
+  end
+end

data/spec/lib/rails_omnibar/version_spec.rb

@@ -0,0 +1,7 @@
+require 'rails_helper'
+
+describe RailsOmnibar::VERSION do
+  it 'is valid' do
+    expect(subject).to match(/\A\d+\.\d+\.\d+\z/)
+  end
+end

data/spec/my_omnibar_template.rb

@@ -0,0 +1,45 @@
+MyOmnibar = RailsOmnibar.configure do |c|
+  c.modal = true
+
+  c.add_item(title: 'important URL', url: 'https://www.disney.com')
+  c.add_item(title: 'boring URL', url: 'https://www.github.com')
+
+  c.add_record_search(pattern: /^u(\d+)/, model: User, example: 'u123')
+
+  c.add_record_search(pattern: /^u (.+)/, model: User, columns: %i[first_name last_name],
+                      example: 'u Joe')
+
+  c.add_record_search(
+    pattern:  /^U(\d+)/,
+    example:  'U123',
+    model:    User,
+    finder:   ->(id)   { User.where(admin: true, id: input[1..]) },
+    itemizer: ->(user) { { title: "Admin #{user.name}", url: admin_url(user) } }
+  )
+
+  c.add_search(
+    pattern:     /^g (.+)/,
+    example:     'g kittens',
+    finder:      ->(input) { [:fake_result_1, :fake_result_2, :fake_result_3] },
+    itemizer:    ->(entry) { { title: entry, url: "/#{entry}" } },
+    description: 'Google',
+  )
+
+  c.add_command(
+    description: 'Get count of a DB table',
+    pattern:     /COUNT (.+)/i,
+    example:     'COUNT users',
+    resolver:    ->(value, _omnibar) do
+      { title: value.classify.constantize.count.to_s }
+    rescue => e
+      { title: e.message }
+    end,
+  )
+
+  c.add_help
+
+  # Use a hotkey that is the same in most keyboard layouts to work around
+  # https://bugs.chromium.org/p/chromedriver/issues/detail?id=553
+  # (This is only relevant for testing with chromedriver.)
+  c.hotkey = 'm'
+end

data/spec/rails_helper.rb

@@ -0,0 +1,22 @@
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('dummy/config/environment', __dir__)
+require 'rspec/rails'
+
+require 'selenium/webdriver'
+require 'webdrivers/chromedriver'
+
+Capybara.server = :puma, { Silent: true }
+
+Dir['spec/support/**/*.rb'].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+  config.before(:each, type: :system) do
+    driven_by :selenium_chrome_headless
+  end
+  config.after(:each, type: :system) do
+    logs = page.driver.browser.logs.get(:browser)
+    logs.empty? || raise("JS errors: #{logs.map(&:message)}")
+  end
+end