collavre_linear 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5cc482eb53e316ac259f9565368c50a59cbd1dce01be3b74100c41b239919731
+  data.tar.gz: cccca601d9c57cd0d45ee603d50b46663d6d3daac3373e93a4b4e3b9b59348b1
+SHA512:
+  metadata.gz: e4a88144150cd9d67ff55433fde009579709cb572cdc08a7cd5209c6d187394917a0efdcd8bbd6a73d60e85fc46ae5d21e8ac731b015b0a0973819e73b51cd61
+  data.tar.gz: 28ee1fc888af6a9a86fd2b18f30883668d273111ad01912a14cc73e0eb598ae412c0efd0733e850013e4da2e81bd4b888b564e74e0e654619df849457d13ec2c

data/app/controllers/collavre_linear/application_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CollavreLinear
+  class ApplicationController < ::ApplicationController
+    private
+
+    # Public HTTPS URL Linear will POST inbound webhook deliveries to. The
+    # engine is `isolate_namespace`d and mounted at MOUNT_PATH (/linear), so we
+    # fold the mount prefix back in explicitly via `script_name:` — the
+    # generated URL MUST be the fully mounted /linear/webhook, never the
+    # engine-internal /webhook, or Linear delivers to a 404 and inbound sync
+    # never runs.
+    def linear_webhook_url
+      CollavreLinear::Engine.routes.url_helpers.webhook_url(
+        Rails.application.config.action_mailer.default_url_options.merge(
+          script_name: CollavreLinear::Engine::MOUNT_PATH
+        )
+      )
+    end
+  end
+end

data/app/controllers/collavre_linear/auth_controller.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module CollavreLinear
+  class AuthController < ApplicationController
+    # callback is reached after the user authorizes on Linear's site; no
+    # session exists yet at that point so we allow unauthenticated access.
+    # We then require a logged-in user to associate the account.
+    before_action :require_authenticated_user!, only: %i[callback store_creative setup]
+
+    # GET /linear/auth/callback?code=...&state=...
+    # Exchange the authorization code, create/update the Account, capture
+    # the OAuth app actor id via the GraphQL viewer query.
+    def callback
+      expected_state = session.delete(:linear_oauth_state)
+      unless params[:state].present? && params[:state] == expected_state
+        redirect_to collavre.creatives_path,
+                    alert: I18n.t("collavre_linear.auth.invalid_state",
+                                  default: "Invalid OAuth state. Please try connecting again.")
+        return
+      end
+
+      tokens = OAuthTokenService.exchange(params[:code])
+
+      # Build a temporary account so we can call the viewer query
+      temp_account = CollavreLinear::Account.new(
+        access_token: tokens[:access_token]
+      )
+      client = CollavreLinear::Client.new(temp_account)
+      viewer = client.viewer_and_app_actor
+
+      # Never reassign a Linear identity already owned by another Collavre user
+      # (that would steal their account + project links). Bind by the CURRENT
+      # user instead (user_id is unique — one Linear account per user), so a
+      # reconnect with a different Linear UID updates in place rather than
+      # violating the unique index.
+      if CollavreLinear::Account.where(linear_uid: viewer[:user_id])
+                                .where.not(user_id: Current.user.id).exists?
+        redirect_to collavre.creatives_path,
+                    alert: I18n.t("collavre_linear.auth.already_linked_other")
+        return
+      end
+
+      account = CollavreLinear::Account.find_or_initialize_by(
+        user_id: Current.user.id
+      )
+      account.linear_uid       = viewer[:user_id]
+      account.access_token     = tokens[:access_token]
+      account.refresh_token    = tokens[:refresh_token]
+      account.token_expires_at = Time.current + tokens[:expires_in].to_i.seconds if tokens[:expires_in]
+      account.app_actor_id     = viewer[:app_actor_id]
+      account.workspace_id     = viewer[:organization_id]
+      account.save!
+
+      creative_id = session.delete(:linear_creative_id)
+      if creative_id.present?
+        # Redirect to the MOUNTED path (/linear/auth/setup). The engine is
+        # detached, so we fold its mount prefix in explicitly via `script_name:`
+        # — the bare engine-internal /auth/setup would 404 in the popup.
+        redirect_to linear_engine.setup_auth_path(
+          creative_id: creative_id,
+          script_name: CollavreLinear::Engine::MOUNT_PATH
+        )
+      else
+        redirect_to collavre.creatives_path,
+                    notice: I18n.t("collavre_linear.auth.connected", default: "Linear connected.")
+      end
+    end
+
+    # GET /linear/auth/setup?creative_id=...
+    # Setup wizard entry point — mirrors the collavre_github pattern.
+    def setup
+      @creative_id = params[:creative_id]
+
+      unless @creative_id.present?
+        render plain: I18n.t("collavre_linear.integration.missing_creative",
+                             default: "creative_id is required"),
+               status: :bad_request
+        return
+      end
+
+      @creative = Collavre::Creative.find_by(id: @creative_id)
+      unless @creative
+        render plain: I18n.t("collavre_linear.integration.missing_creative",
+                             default: "Creative not found"),
+               status: :not_found
+        return
+      end
+
+      unless @creative.has_permission?(Current.user, :admin)
+        render plain: I18n.t("collavre_linear.errors.forbidden",
+                             default: "Access denied"),
+               status: :forbidden
+        return
+      end
+
+      render layout: false
+    end
+
+    # POST /linear/auth/store_creative
+    # Persist creative_id and generate a CSRF state token in the session, then
+    # redirect the popup window straight to Linear's OAuth screen. The form
+    # POSTs into a popup with no JS handler, so returning JSON here would just
+    # render raw JSON in the popup and never start OAuth — a 303 redirect makes
+    # the popup follow through to Linear.
+    def store_creative
+      missing = OAuthTokenService.missing_config
+      if missing.any?
+        render plain: I18n.t("collavre_linear.auth.oauth_config_missing",
+                             keys: missing.join(", ")),
+               status: :service_unavailable
+        return
+      end
+
+      session[:linear_creative_id] = params[:creative_id]
+      state = SecureRandom.hex(24)
+      session[:linear_oauth_state] = state
+      authorize_url = OAuthTokenService.authorize_url(state: state, creative_id: params[:creative_id])
+      redirect_to authorize_url, allow_other_host: true, status: :see_other
+    end
+
+    private
+
+    def require_authenticated_user!
+      return if Current.user
+
+      redirect_to collavre.new_session_path,
+                  alert: I18n.t("collavre_linear.auth.login_first",
+                                default: "Please log in first.")
+    end
+
+    def linear_engine
+      CollavreLinear::Engine.routes.url_helpers
+    end
+  end
+end

data/app/controllers/collavre_linear/creatives/integrations_controller.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module CollavreLinear
+  module Creatives
+    class IntegrationsController < ApplicationController
+      include Collavre::IntegrationSetup
+      include Collavre::IntegrationPermission
+
+      before_action :set_creative
+      before_action :set_origin
+      before_action :ensure_read_permission
+      before_action :ensure_admin_permission, only: %i[create destroy resync update_secret options]
+
+      # POST /linear/creatives/:creative_id/integration
+      #
+      # Links a Creative subtree to a Linear team + project, provisions a
+      # webhook for the team, and enqueues an initial full export.
+      def create
+        account = Current.user.linear_account
+        unless account
+          render json: { error: I18n.t("collavre_linear.errors.not_connected") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        team_id          = params[:team_id].to_s.presence
+        linear_project_id = params[:linear_project_id].to_s.presence
+
+        unless team_id && linear_project_id
+          render json: { error: I18n.t("collavre_linear.errors.missing_params") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        # Serialize concurrent link attempts within the same tree. The overlap
+        # checks below are check-then-save with NO DB constraint spanning
+        # ancestors/descendants, so two requests linking a parent and a child
+        # Creative could both pass the overlap check and double-link the subtree.
+        # Every Creative in a tree shares one root, so a row lock on that root
+        # forces overlapping attempts to run one at a time; the loser then sees
+        # the winner's ProjectLink and is rejected. (project_taken's CROSS-tree
+        # race stays covered by the linear_project_id unique index +
+        # RecordNotUnique backstop below, since disjoint trees have distinct roots
+        # and would not serialize on this lock.)
+        overlapping_link = false
+        link = nil
+        begin
+          @origin.root.with_lock do
+            # Reject linking inside/around an already-linked subtree. A second
+            # ProjectLink on an ancestor/descendant would sync against the wrong
+            # project: IssueLink is unique per Creative and the exporter resolves
+            # both ProjectLink and IssueLink per creative WITHOUT account scope, so
+            # the new project would silently update the old project's issues. The
+            # check must span ALL accounts — a second admin with their own Linear
+            # account could otherwise hijack the subtree. Re-linking @origin to the
+            # SAME project stays idempotent (find_or_initialize_by below).
+            overlapping_ids =
+              (@origin.self_and_ancestors.ids + @origin.self_and_descendants.ids).uniq - [ @origin.id ]
+            overlapping = overlapping_ids.any? &&
+              CollavreLinear::ProjectLink.where(creative_id: overlapping_ids).exists?
+
+            # @origin may only carry the idempotent re-link target (same account
+            # AND same project). Any other existing link on @origin conflicts: a
+            # different project (the exporter would keep updating the old issue),
+            # or the same subtree claimed by another account. The ancestor/
+            # descendant check above excludes @origin, so guard @origin here.
+            origin_conflict = @origin.linear_project_links
+                                     .where.not(account: account, linear_project_id: linear_project_id)
+                                     .exists?
+
+            # One Linear project maps to exactly one Collavre root. Inbound
+            # webhooks resolve the project with an UNSCOPED
+            # find_by(linear_project_id:), so a second ProjectLink for the same
+            # project on a DISJOINT creative (not an ancestor/descendant, so the
+            # overlap check above misses it) would make imports/updates land on
+            # whichever row the DB returns while both roots export into it. Reject
+            # globally; re-linking @origin stays idempotent.
+            project_taken = CollavreLinear::ProjectLink
+                              .where(linear_project_id: linear_project_id)
+                              .where.not(creative_id: @origin.id)
+                              .exists?
+
+            if overlapping || origin_conflict || project_taken
+              overlapping_link = true
+            else
+              link = @origin.linear_project_links.find_or_initialize_by(
+                account:           account,
+                linear_project_id: linear_project_id
+              )
+              link.team_id = team_id
+              link.save!
+            end
+          end
+        rescue ActiveRecord::RecordNotUnique
+          # Race-safe backstop for the project_taken check above: the check is
+          # check-then-save, so two DISJOINT-tree requests (which do not share the
+          # root lock) can both pass it; the linear_project_id unique index rejects
+          # the loser's insert. Surface the same conflict instead of a 500.
+          overlapping_link = true
+        end
+
+        if overlapping_link
+          render json: { error: I18n.t("collavre_linear.errors.overlapping_link") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        # Existing descendants never fire after-commit callbacks during linking,
+        # so enqueue an outbound export for the whole subtree — otherwise a
+        # populated tree would only create the root Linear issue. Idempotent:
+        # the exporter skips unchanged content via its content hash.
+        enqueue_subtree_sync
+
+        # Inbound sync needs a webhook Linear can't auto-provision (app actors
+        # lack the admin scope), so the admin sets it up by hand and pastes the
+        # secret Linear generates via update_secret. The modal shows that guide.
+        render json: { success: true, project_link: serialize_link(link) }
+      rescue ActiveRecord::RecordInvalid => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      end
+
+      # DELETE /linear/creatives/:creative_id/integration
+      #
+      # Unlinks the Creative from its Linear project. The webhook is set up by
+      # hand in Linear (we never learn its id), so there is nothing to
+      # deregister here — the admin removes it in Linear's settings if desired.
+      def destroy
+        account = Current.user.linear_account
+        unless account
+          render json: { error: I18n.t("collavre_linear.errors.not_connected") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        link = @origin.linear_project_links.find_by(account: account)
+        unless link
+          render json: { error: I18n.t("collavre_linear.errors.not_found") },
+                 status: :not_found
+          return
+        end
+
+        link.destroy!
+
+        render json: { success: true }
+      end
+
+      # POST /linear/creatives/:creative_id/integration/resync
+      #
+      # Re-enqueues a full outbound export for the whole subtree. Mirrors the
+      # create path: enqueuing only the root would never recover stale/missing
+      # descendant issues. The ParentNotExportedError + retry_on deferral in
+      # OutboundSyncJob protects against parent-before-child races, so enqueuing
+      # the full subtree is safe.
+      def resync
+        account = Current.user.linear_account
+        unless account
+          render json: { error: I18n.t("collavre_linear.errors.not_connected") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        unless @origin.linear_project_links.where(account: account).exists?
+          render json: { error: I18n.t("collavre_linear.errors.not_found") },
+                 status: :not_found
+          return
+        end
+
+        # Resync is the human resolution path the conflict notice points to, so it
+        # must break the :conflict freeze — CreativeExporter#update_issue! (and the
+        # inbound applier) HALT on conflicted links, so without this the enqueued
+        # jobs would report success while making no API call and leaving the
+        # conflict stuck. Reopen conflicted links as :dirty so the export re-runs
+        # and pushes the local (kept) content Linear never received.
+        clear_conflicted_links
+
+        enqueue_subtree_sync
+
+        render json: { success: true, message: I18n.t("collavre_linear.integration.resync_started") }
+      end
+
+      # POST /linear/creatives/:creative_id/integration/secret
+      #
+      # Store the signing secret the admin copied from Linear's webhook settings.
+      # Linear owns the secret (it generates one per webhook and won't let us pick
+      # it), so the admin pastes it here and we propagate it to the team's sibling
+      # links — the one value all of the team's deliveries verify against.
+      def update_secret
+        account = Current.user.linear_account
+        unless account
+          render json: { error: I18n.t("collavre_linear.errors.not_connected") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        link = @origin.linear_project_links.find_by(account: account)
+        unless link
+          render json: { error: I18n.t("collavre_linear.errors.not_found") },
+                 status: :not_found
+          return
+        end
+
+        secret = params[:webhook_secret].to_s.strip
+        if secret.blank?
+          render json: { error: I18n.t("collavre_linear.errors.missing_secret") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        link.update_webhook_secret!(secret)
+
+        render json: { success: true }
+      end
+
+      # GET /linear/creatives/:creative_id/integration/options
+      #
+      # Teams and projects the connected account can see, so the link modal can
+      # offer dropdowns instead of asking the user to type raw Linear IDs.
+      def options
+        account = Current.user.linear_account
+        unless account
+          render json: { error: I18n.t("collavre_linear.errors.not_connected") },
+                 status: :unprocessable_entity
+          return
+        end
+
+        client = CollavreLinear::Client.new(account)
+        render json: { teams: client.list_teams, projects: client.list_projects }
+      rescue CollavreLinear::Client::Error => e
+        # Surface the Linear-side failure (expired token, revoked scope) instead
+        # of leaving the dropdowns silently empty.
+        render json: { error: e.message }, status: :bad_gateway
+      end
+
+      private
+
+      # Enqueue an outbound export for every Creative in the @origin subtree.
+      # Shared by create (initial link) and resync so both cover descendants.
+      def enqueue_subtree_sync
+        @origin.self_and_descendants.ids.each do |creative_id|
+          CollavreLinear::OutboundSyncJob.perform_later(creative_id)
+        end
+      end
+
+      # Reopen conflicted issue links in the subtree so an explicit resync can
+      # actually push. update_all bypasses the exporter's per-link lock, but a
+      # concurrent inbound re-marking one conflict just means that link no-ops
+      # again (the user resyncs once more) — no data loss, and it unsticks the
+      # common case the resync button promises to fix.
+      def clear_conflicted_links
+        CollavreLinear::IssueLink
+          .where(creative_id: @origin.self_and_descendants.ids)
+          .where(sync_state: CollavreLinear::IssueLink.sync_states[:conflict])
+          .update_all(sync_state: CollavreLinear::IssueLink.sync_states[:dirty])
+      end
+
+      def integration_forbidden_message
+        I18n.t("collavre_linear.errors.forbidden")
+      end
+
+      def serialize_link(link)
+        {
+          id:                link.id,
+          team_id:           link.team_id,
+          linear_project_id: link.linear_project_id,
+          sync_state:        link.sync_state,
+          webhook_id:        link.webhook_id
+        }
+      end
+    end
+  end
+end

data/app/controllers/collavre_linear/webhooks_controller.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module CollavreLinear
+  # Receives inbound webhooks from Linear.
+  #
+  # Security pipeline (all BEFORE enqueueing any work):
+  #   1. Verify `Linear-Signature` = HMAC-SHA256(webhook_secret, raw_body) with
+  #      a constant-time compare. Bad/missing signature -> 401.
+  #   2. Verify `webhookTimestamp` (ms epoch) is within +/- 60s of now to reject
+  #      replayed/stale deliveries. Out-of-window -> 401.
+  #   3. Drop our own events (EchoGuard) to avoid sync loops. Echo -> 200 ack,
+  #      but nothing enqueued.
+  #
+  # Machine-to-machine endpoint authenticated by the HMAC signature below, not a
+  # user session. Inherits ActionController::API, which carries no CSRF
+  # middleware — so there is nothing to skip, and no session cookie to forge.
+  class WebhooksController < ActionController::API
+    TIMESTAMP_WINDOW_MS = 60_000
+
+    def create
+      raw_body = request.raw_post.presence || request.body.read
+      payload  = JSON.parse(raw_body)
+
+      link    = find_project_link(payload)
+      # Resolve the secret at the TEAM level, not off the matched row's own
+      # column. find_project_link can return a specific row (project/issue/comment
+      # branches) that committed blank in the paste race even though a sibling
+      # holds the team's secret — verifying against the team's non-blank secret
+      # keeps those deliveries from a spurious 401.
+      secret  = link && CollavreLinear::ProjectLink.team_webhook_secret(link.team_id)
+
+      return head :unauthorized unless valid_signature?(raw_body, secret)
+      return head :unauthorized unless fresh_timestamp?(payload)
+      # Signature only proves the sender holds the signing link's per-TEAM secret.
+      # InboundApplier routes by the payload's own id/projectId, so a payload
+      # signed with team A's secret but naming team B's project/issue would let a
+      # user who can see A's (UI-visible) secret forge writes into B. Require every
+      # other identifier to resolve to the SAME team before enqueueing.
+      return head :unauthorized unless payload_identifiers_consistent?(payload, link)
+
+      account = resolve_account(link)
+      if account && CollavreLinear::EchoGuard.our_event?(account, payload)
+        # Our own actor bounced back — ack so Linear stops retrying, but do not
+        # re-apply our own change.
+        return head :ok
+      end
+
+      # Enqueue on the sequential linear_inbound queue (single-thread worker) so
+      # verified events apply strictly in receipt order — a comment that arrives
+      # after its issue's create must also be APPLIED after it.
+      CollavreLinear::InboundApplyJob.perform_later(payload)
+      head :ok
+    rescue JSON::ParserError
+      head :bad_request
+    end
+
+    private
+
+    # Match the payload's team/project to a ProjectLink so we can use its
+    # per-link webhook secret and account. Returns nil when nothing matches —
+    # the secret then resolves to nil and the delivery is rejected (401). There
+    # is no ENV/admin fallback: the secret lives only on the ProjectLink.
+    def find_project_link(payload)
+      team_id = extract_team_id(payload)
+      project_id = extract_project_id(payload)
+
+      if team_id.present?
+        # A team shares one webhook secret, but a sibling created concurrently
+        # with the admin's paste can commit blank and would 401 the delivery if
+        # the verifier picked it. Prefer any sibling that already holds the pasted
+        # secret; fall back to any team row so routing still resolves before a
+        # secret is ever pasted (that case 401s on the nil secret, as intended).
+        siblings = CollavreLinear::ProjectLink.where(team_id: team_id).to_a
+        link = siblings.find { |s| s.webhook_secret.present? } || siblings.first
+        return link if link
+      end
+
+      if project_id.present?
+        link = CollavreLinear::ProjectLink.find_by(linear_project_id: project_id)
+        return link if link
+      end
+
+      # Comment deliveries carry no team/project fields — they reference the
+      # parent issue instead. Resolve via the linked issue so verification uses
+      # that project's per-link secret; without this the delivery matches no
+      # link and is rejected (401).
+      if (issue_id = extract_issue_id(payload)).present?
+        issue_link = CollavreLinear::IssueLink.find_by(linear_issue_id: issue_id)
+        return issue_link.project_link if issue_link
+      end
+
+      nil
+    end
+
+    # The webhook secret is shared per TEAM (siblings adopt it, rotation rolls the
+    # whole team), so the team is the trust boundary. Every identifier the payload
+    # carries that resolves to a ProjectLink must belong to the signing link's
+    # team; a mismatch means a cross-team forgery signed with the wrong secret.
+    def payload_identifiers_consistent?(payload, link)
+      return false unless link
+
+      project_id = extract_project_id(payload)
+      if project_id.present?
+        other = CollavreLinear::ProjectLink.find_by(linear_project_id: project_id)
+        return false if other && other.team_id != link.team_id
+      end
+
+      issue_ids_in_payload(payload).each do |issue_id|
+        issue_link = CollavreLinear::IssueLink.find_by(linear_issue_id: issue_id)
+        return false if issue_link && issue_link.project_link.team_id != link.team_id
+      end
+
+      comment_ids_in_payload(payload).each do |comment_id|
+        comment_link = CollavreLinear::CommentLink.find_by(linear_comment_id: comment_id)
+        return false if comment_link &&
+          comment_link.issue_link.project_link.team_id != link.team_id
+      end
+
+      true
+    end
+
+    # Every issue identifier InboundApplier may route by: the comment's parent
+    # issue (data.issue.id / data.issueId), the Issue event's own id (data.id —
+    # what update_issue!/remove_issue!/create_issue! key on), and a create/
+    # reparent target (data.parentId). The comment-shaped extract_issue_id alone
+    # missed data.id, letting an Issue payload signed with team A's secret but
+    # naming team B's issue slip past the cross-team guard.
+    def issue_ids_in_payload(payload)
+      ids = [ extract_issue_id(payload), payload.dig("data", "parentId") ]
+      ids << payload.dig("data", "id") if payload["type"] == "Issue"
+      ids.compact_blank
+    end
+
+    # Comment events route update/remove by the Comment's own data.id (a
+    # linear_comment_id), which none of the issue-shaped extractors surface.
+    # Without checking it, a payload signed with team A's secret but naming team
+    # B's CommentLink slips past the guard and apply_comment! edits/deletes B's
+    # mirror. Only a Comment payload's data.id is a comment id (Issue payloads key
+    # it as an issue, already covered above).
+    def comment_ids_in_payload(payload)
+      return [] unless payload["type"] == "Comment"
+
+      [ payload.dig("data", "id") ].compact_blank
+    end
+
+    def extract_issue_id(payload)
+      payload.dig("data", "issue", "id") || payload.dig("data", "issueId")
+    end
+
+    def extract_team_id(payload)
+      payload.dig("data", "teamId") ||
+        payload.dig("data", "team", "id") ||
+        payload["teamId"]
+    end
+
+    def extract_project_id(payload)
+      payload.dig("data", "projectId") ||
+        payload.dig("data", "project", "id")
+    end
+
+    def resolve_account(link)
+      link&.account || CollavreLinear::Account.first
+    end
+
+    def valid_signature?(raw_body, secret)
+      return false if secret.blank?
+
+      signature = request.headers["Linear-Signature"] ||
+        request.get_header("HTTP_LINEAR_SIGNATURE")
+      return false if signature.blank?
+
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret, raw_body)
+      ActiveSupport::SecurityUtils.secure_compare(expected, signature)
+    end
+
+    def fresh_timestamp?(payload)
+      ts = payload["webhookTimestamp"]
+      return false if ts.blank?
+
+      ts_ms = Integer(ts)
+      now_ms = (Time.now.to_f * 1000).to_i
+      (now_ms - ts_ms).abs <= TIMESTAMP_WINDOW_MS
+    rescue ArgumentError, TypeError
+      false
+    end
+  end
+end