titleist 0.1.1 → 1.0.0

data/lib/titleist/title.rb

@@ -1,150 +1,113 @@
+# typed: true
+
 module Titleist
   # Object that turns passed-in scope details into a String of title
   # text derived from the +I18n+ locale configuration.
   class Title
-    # Top-level scope in the i18n locale for all title configuration.
-    ROOT_SCOPE = :titles
-
-    # @!attribute controller [r]
-    #   @return [String] Controller name of the current request.
-    attr_reader :controller
-
-    # @!attribute action [r]
-    #   @return [String] Action name of the current request.
-    attr_reader :action
-
-    # @!attribute context [r]
-    #   @return [Hash] Passed-in context from the helper method.
-    attr_reader :context
-
-    # @param controller [String] Current request controller name.
-    # @param action [String] Current request action name.
-    # @param context [Hash] Optional params passed in from the helper.
-    # @param root [Boolean] Whether this is the root path
-    def initialize(controller: '', action: '', context: {}, root: false)
+    extend T::Sig
+
+    # Default title format that can be overridden by changing the i18n
+    # key `titelist.format`.
+    FORMAT = '%{page} - %{app}'.freeze
+
+    # @param [String] controller - Current request controller name.
+    # @param [String] action - Current request action name.
+    # @param [Hash] context - Optional params passed in from the helper.
+    # @return [Titleist::Title]
+    def initialize(controller:, action:, **context)
       @controller = controller
       @action = action
-      @context = context
-      @root = root
+      @params = context
+    end
+
+    # Read title context
+    #
+    # @param [Symbol] key
+    # @return [String] the value or `nil`
+    def [](key)
+      @params[key]
+    end
+
+    # Write title context
+    #
+    # @param [Symbol] key
+    # @param [String] value
+    # @return [String] the value
+    def []=(key, value)
+      @params[key] = value
     end
 
     # Global application title.
     #
     # @return [String]
     def app
-      I18n.t :application, context.merge(
-        scope: ROOT_SCOPE,
+      @app ||= I18n.t :title, @params.reverse_merge(
+        scope: %i[layouts application],
         default: default_app_title
       )
     end
 
-    # Page title from given scope.
+    # Page title from the current scope.
     #
     # @return [String]
     def page
-      @page ||= I18n.t action.to_sym, context.merge(
-        scope: scope,
+      @page ||= I18n.t :title, @params.reverse_merge(
+        scope: [*controller_scope, @action],
         default: default_page_title
       )
     end
 
-    # @!attribute page [w]
-    #   Override the given scope and set a new page title.
+    # @!attribute page [rw]
+    #   Override the current page title
     #   @return [String]
     attr_writer :page
 
-    # Format this title as a +String+.
+    # Format the full page title.
     #
     # @return [String]
     def to_s
-      return app if root?
-
-      I18n.t :format, to_h
-    end
-
-    # Format this title as a +Hash+ of attributes.
-    #
-    # @return [Hash]
-    def to_h
-      {
-        scope: ROOT_SCOPE,
-        app: app,
-        page: page
-      }
-    end
-
-    # Whether the page we're generating a title for is the root path.
-    # This will cause no page title to display, and is set when the
-    # title object is instantiated.
-    #
-    # @return [Boolean]
-    def root?
-      @root
+      I18n.t :format, scope: :titleist, default: FORMAT, app: app, page: page
     end
 
     private
 
-    # Use the default configured app title in +Rails.configuration+ or
-    # the derived app title if one is not specified.
-    #
     # @private
-    # @return [String] Default application title from module or config.
+    # @return [String]
     def default_app_title
-      Rails.configuration.titleist.app_title || derived_app_title
-    end
-
-    # Derive app title by titleizing the application module name if one
-    # is not configured.
-    #
-    # @private
-    # @return [String] Default app title guessed from module name.
-    def derived_app_title
-      Rails.application.class.name.deconstantize.titleize
+      Rails.application.class.name&.deconstantize&.titleize.to_s
     end
 
-    # Default title of the current page, if one cannot be found.
-    #
     # @private
-    # @return [String] Action title combined with resource title.
+    # @return [String]
     def default_page_title
-      return controller.titleize if action == 'index'
+      return @controller.titleize if @action == 'index'
 
       [action_title, resource_title].join(' ')
     end
 
-    # Default title verb for the current action.
-    #
     # @private
-    # @return [String] "View", "Delete", or the titleized +action+.
+    # @return [String]
     def action_title
-      case action
+      case @action
       when 'show'
         'View'
       when 'destroy'
         'Delete'
       else
-        action.titleize
+        @action.titleize
       end
     end
 
-    # Default title of the resource the controller is operating on.
-    #
     # @private
-    # @return [String] Singularized controller name.
+    # @return [String]
     def resource_title
-      controller.singularize.titleize
+      @controller.singularize.titleize
     end
 
-    # Scope for +I18n+ derived from the controller name and root.
-    #
     # @private
-    # @return [Array] Derived i18n scope.
-    def scope
-      @scope ||= [ROOT_SCOPE, *demodulized_controller]
-    end
-
-    def demodulized_controller
-      controller.split('/').map(&:to_sym)
+    # @return [Array<String>]
+    def controller_scope
+      @controller.split('/')
     end
   end
 end

data/lib/titleist/version.rb

@@ -1,3 +1,7 @@
+# typed: true
 module Titleist
-  VERSION = '0.1.1'.freeze
+  # Current version of this library.
+  #
+  # @return [String]
+  VERSION = '1.0.0'.freeze
 end

data/rbi/sord.rbi

@@ -0,0 +1,117 @@
+# typed: strong
+# typed: false
+module Titleist
+  extend ActiveSupport::Autoload
+  VERSION = T.let('1.0.0'.freeze, T.untyped)
+
+  # Object that turns passed-in scope details into a String of title
+  # text derived from the +I18n+ locale configuration.
+  class Title
+    extend T::Sig
+    FORMAT = T.let('%{page} - %{app}'.freeze, T.untyped)
+
+    # _@param_ `controller` — - Current request controller name.
+    # 
+    # _@param_ `action` — - Current request action name.
+    # 
+    # _@param_ `context` — - Optional params passed in from the helper.
+    sig { params(controller: String, action: String, context: T::Hash[T.untyped, T.untyped]).void }
+    def initialize(controller:, action:, **context); end
+
+    # Read title context
+    # 
+    # _@param_ `key`
+    # 
+    # _@return_ — the value or `nil`
+    sig { params(key: Symbol).returns(String) }
+    def [](key); end
+
+    # Write title context
+    # 
+    # _@param_ `key`
+    # 
+    # _@param_ `value`
+    # 
+    # _@return_ — the value
+    sig { params(key: Symbol, value: String).returns(String) }
+    def []=(key, value); end
+
+    # Global application title.
+    sig { returns(String) }
+    def app; end
+
+    # Format the full page title.
+    sig { returns(String) }
+    def to_s; end
+
+    sig { returns(String) }
+    def default_app_title; end
+
+    sig { returns(String) }
+    def default_page_title; end
+
+    sig { returns(String) }
+    def action_title; end
+
+    sig { returns(String) }
+    def resource_title; end
+
+    sig { returns(T::Array[String]) }
+    def controller_scope; end
+
+    # Override the current page title
+    sig { returns(T.any(String, T.untyped)) }
+    attr_accessor :page
+  end
+
+  # Extensions into the Rails framework that mixin the controller and
+  # helper modules when ActionController and ActionView are loaded.
+  class Engine < Rails::Engine
+  end
+
+  # Helper methods in ActionView for rendering the title.
+  module Helper
+    extend T::Sig
+
+    # Render the full title as a `<title>` tag.
+    sig { returns(String) }
+    def title_tag; end
+
+    sig { returns(String) }
+    def title_text; end
+  end
+
+  # Controller mixins for reading titles without ActionView
+  module Controller
+    extend ActiveSupport::Concern
+    extend T::Sig
+
+    # Generate the full page title for this request. When output into the
+    # view, the entire title is shown. You may also call +title.page+ or
+    # +title.app+ to view individual pieces of the title.
+    sig { returns(Titleist::Title) }
+    def title; end
+
+    # Shorthand for calling +title.app+ in the view.
+    # 
+    # _@return_ — i18n-configured global application title.
+    sig { returns(String) }
+    def app_title; end
+
+    # Shorthand for calling +title.page+ in the view.
+    # 
+    # _@return_ — i18n-configured title for the current page.
+    sig { returns(String) }
+    def page_title; end
+  end
+end
+
+# typed: true
+# Generate initial files for the gem to work.
+class TitleistGenerator < Rails::Generators::Base
+  sig { returns(T.nilable(T.any())) }
+  def copy_locale; end
+
+  sig { returns(T.nilable(T.any())) }
+  def update_default_application_layout; end
+end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/gems/actioncable.rbi

@@ -0,0 +1,318 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strong
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/actioncable/all/actioncable.rbi
+#
+# actioncable-6.0.2.1
+module ActionCable
+  def self.gem_version; end
+  def self.server; end
+  def self.version; end
+  def server; end
+  extend ActiveSupport::Autoload
+end
+module ActionCable::VERSION
+end
+module ActionCable::Helpers
+end
+module ActionCable::Helpers::ActionCableHelper
+  def action_cable_meta_tag; end
+end
+class ActionCable::Engine < Rails::Engine
+end
+module ActionCable::Server
+  extend ActiveSupport::Autoload
+end
+module ActionCable::Server::Broadcasting
+  def broadcast(broadcasting, message, coder: nil); end
+  def broadcaster_for(broadcasting, coder: nil); end
+end
+class ActionCable::Server::Broadcasting::Broadcaster
+  def broadcast(message); end
+  def broadcasting; end
+  def coder; end
+  def initialize(server, broadcasting, coder:); end
+  def server; end
+end
+module ActionCable::Server::Connections
+  def add_connection(connection); end
+  def connections; end
+  def open_connections_statistics; end
+  def remove_connection(connection); end
+  def setup_heartbeat_timer; end
+end
+class ActionCable::Server::Configuration
+  def allow_same_origin_as_host; end
+  def allow_same_origin_as_host=(arg0); end
+  def allowed_request_origins; end
+  def allowed_request_origins=(arg0); end
+  def cable; end
+  def cable=(arg0); end
+  def connection_class; end
+  def connection_class=(arg0); end
+  def disable_request_forgery_protection; end
+  def disable_request_forgery_protection=(arg0); end
+  def initialize; end
+  def log_tags; end
+  def log_tags=(arg0); end
+  def logger; end
+  def logger=(arg0); end
+  def mount_path; end
+  def mount_path=(arg0); end
+  def pubsub_adapter; end
+  def url; end
+  def url=(arg0); end
+  def worker_pool_size; end
+  def worker_pool_size=(arg0); end
+end
+class ActionCable::Server::Worker
+  def __callbacks; end
+  def __callbacks?; end
+  def _run_work_callbacks(&block); end
+  def _work_callbacks; end
+  def async_exec(receiver, *args, connection:, &block); end
+  def async_invoke(receiver, method, *args, connection: nil, &block); end
+  def connection; end
+  def connection=(obj); end
+  def executor; end
+  def halt; end
+  def initialize(max_size: nil); end
+  def invoke(receiver, method, *args, connection:, &block); end
+  def logger; end
+  def self.__callbacks; end
+  def self.__callbacks=(val); end
+  def self.__callbacks?; end
+  def self._work_callbacks; end
+  def self._work_callbacks=(value); end
+  def self.connection; end
+  def self.connection=(obj); end
+  def stopping?; end
+  def work(connection); end
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  include ActionCable::Server::Worker::ActiveRecordConnectionManagement
+  include ActiveSupport::Callbacks
+end
+module ActionCable::Server::Worker::ActiveRecordConnectionManagement
+  def with_database_connections; end
+  extend ActiveSupport::Concern
+end
+module ActionCable::Channel
+  extend ActiveSupport::Autoload
+end
+module ActionCable::Channel::Callbacks
+  extend ActiveSupport::Concern
+  include ActiveSupport::Callbacks
+end
+module ActionCable::Channel::Callbacks::ClassMethods
+  def after_subscribe(*methods, &block); end
+  def after_unsubscribe(*methods, &block); end
+  def before_subscribe(*methods, &block); end
+  def before_unsubscribe(*methods, &block); end
+  def on_subscribe(*methods, &block); end
+  def on_unsubscribe(*methods, &block); end
+end
+module ActionCable::Channel::PeriodicTimers
+  def active_periodic_timers; end
+  def start_periodic_timer(callback, every:); end
+  def start_periodic_timers; end
+  def stop_periodic_timers; end
+  extend ActiveSupport::Concern
+end
+module ActionCable::Channel::PeriodicTimers::ClassMethods
+  def periodically(callback_or_method_name = nil, every:, &block); end
+end
+module ActionCable::Channel::Streams
+  def default_stream_handler(broadcasting, coder:); end
+  def identity_handler; end
+  def pubsub(*args, &block); end
+  def stop_all_streams; end
+  def stream_decoder(handler = nil, coder:); end
+  def stream_for(model, callback = nil, coder: nil, &block); end
+  def stream_from(broadcasting, callback = nil, coder: nil, &block); end
+  def stream_handler(broadcasting, user_handler, coder: nil); end
+  def stream_transmitter(handler = nil, broadcasting:); end
+  def streams; end
+  def worker_pool_stream_handler(broadcasting, user_handler, coder: nil); end
+  extend ActiveSupport::Concern
+end
+module ActionCable::Channel::Naming
+  def channel_name(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActionCable::Channel::Naming::ClassMethods
+  def channel_name; end
+end
+module ActionCable::Channel::Broadcasting
+  def broadcast_to(*args, &block); end
+  def broadcasting_for(*args, &block); end
+  extend ActiveSupport::Concern
+end
+module ActionCable::Channel::Broadcasting::ClassMethods
+  def broadcast_to(model, message); end
+  def broadcasting_for(model); end
+  def serialize_broadcasting(object); end
+end
+class ActionCable::Channel::Base
+  def __callbacks; end
+  def __callbacks?; end
+  def _run_subscribe_callbacks(&block); end
+  def _run_unsubscribe_callbacks(&block); end
+  def _subscribe_callbacks; end
+  def _unsubscribe_callbacks; end
+  def action_signature(action, data); end
+  def connection; end
+  def defer_subscription_confirmation!; end
+  def defer_subscription_confirmation?; end
+  def delegate_connection_identifiers; end
+  def dispatch_action(action, data); end
+  def ensure_confirmation_sent; end
+  def extract_action(data); end
+  def identifier; end
+  def initialize(connection, identifier, params = nil); end
+  def logger(*args, &block); end
+  def params; end
+  def perform_action(data); end
+  def periodic_timers=(val); end
+  def processable_action?(action); end
+  def reject; end
+  def reject_subscription; end
+  def rescue_handlers; end
+  def rescue_handlers=(val); end
+  def rescue_handlers?; end
+  def self.__callbacks; end
+  def self.__callbacks=(val); end
+  def self.__callbacks?; end
+  def self._subscribe_callbacks; end
+  def self._subscribe_callbacks=(value); end
+  def self._unsubscribe_callbacks; end
+  def self._unsubscribe_callbacks=(value); end
+  def self.action_methods; end
+  def self.clear_action_methods!; end
+  def self.method_added(name); end
+  def self.periodic_timers; end
+  def self.periodic_timers=(val); end
+  def self.periodic_timers?; end
+  def self.rescue_handlers; end
+  def self.rescue_handlers=(val); end
+  def self.rescue_handlers?; end
+  def subscribe_to_channel; end
+  def subscribed; end
+  def subscription_confirmation_sent?; end
+  def subscription_rejected?; end
+  def transmit(data, via: nil); end
+  def transmit_subscription_confirmation; end
+  def transmit_subscription_rejection; end
+  def unsubscribe_from_channel; end
+  def unsubscribed; end
+  extend ActionCable::Channel::Broadcasting::ClassMethods
+  extend ActionCable::Channel::Callbacks::ClassMethods
+  extend ActionCable::Channel::Naming::ClassMethods
+  extend ActionCable::Channel::PeriodicTimers::ClassMethods
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::DescendantsTracker
+  extend ActiveSupport::Rescuable::ClassMethods
+  include ActionCable::Channel::Broadcasting
+  include ActionCable::Channel::Callbacks
+  include ActionCable::Channel::Naming
+  include ActionCable::Channel::PeriodicTimers
+  include ActionCable::Channel::Streams
+  include ActiveSupport::Callbacks
+  include ActiveSupport::Rescuable
+end
+class ActionCable::Server::Base
+  def call(env); end
+  def config; end
+  def connection_identifiers; end
+  def disconnect(identifiers); end
+  def event_loop; end
+  def initialize(config: nil); end
+  def logger(*args, &block); end
+  def mutex; end
+  def pubsub; end
+  def remote_connections; end
+  def restart; end
+  def self.config; end
+  def self.config=(obj); end
+  def self.logger; end
+  def worker_pool; end
+  include ActionCable::Server::Broadcasting
+  include ActionCable::Server::Connections
+end
+module ActionCable::Connection
+  extend ActiveSupport::Autoload
+end
+module ActionCable::Connection::Identification
+  def connection_gid(ids); end
+  def connection_identifier; end
+  extend ActiveSupport::Concern
+end
+module ActionCable::Connection::Identification::ClassMethods
+  def identified_by(*identifiers); end
+end
+module ActionCable::Connection::InternalChannel
+  def internal_channel; end
+  def process_internal_message(message); end
+  def subscribe_to_internal_channel; end
+  def unsubscribe_from_internal_channel; end
+  extend ActiveSupport::Concern
+end
+module ActionCable::Connection::Authorization
+  def reject_unauthorized_connection; end
+end
+class ActionCable::Connection::Authorization::UnauthorizedError < StandardError
+end
+class ActionCable::Connection::Base
+  def allow_request_origin?; end
+  def beat; end
+  def close(reason: nil, reconnect: nil); end
+  def cookies; end
+  def decode(websocket_message); end
+  def dispatch_websocket_message(websocket_message); end
+  def encode(cable_message); end
+  def env; end
+  def event_loop(*args, &block); end
+  def finished_request_message; end
+  def handle_close; end
+  def handle_open; end
+  def identifiers; end
+  def identifiers=(val); end
+  def identifiers?; end
+  def initialize(server, env, coder: nil); end
+  def invalid_request_message; end
+  def logger; end
+  def message_buffer; end
+  def new_tagged_logger; end
+  def on_close(reason, code); end
+  def on_error(message); end
+  def on_message(message); end
+  def on_open; end
+  def process; end
+  def protocol; end
+  def pubsub(*args, &block); end
+  def receive(websocket_message); end
+  def request; end
+  def respond_to_invalid_request; end
+  def respond_to_successful_request; end
+  def self.identifiers; end
+  def self.identifiers=(val); end
+  def self.identifiers?; end
+  def send_async(method, *arguments); end
+  def send_welcome_message; end
+  def server; end
+  def started_request_message; end
+  def statistics; end
+  def subscriptions; end
+  def successful_request_message; end
+  def transmit(cable_message); end
+  def websocket; end
+  def worker_pool; end
+  extend ActionCable::Connection::Identification::ClassMethods
+  include ActionCable::Connection::Authorization
+  include ActionCable::Connection::Identification
+  include ActionCable::Connection::InternalChannel
+end