Extracting substring from the middle of a string in Rails

I'm trying to extract a substring from a class type returned as a string:

'::Pos::EmailNotice'
'Pos::EmailNotice'
'::Pos::CallNotice'
'Pos::CallNotice'

So if I get a string 'Pos::{type}Notice', I would need to end up with {type}.

I've tried to use #slice as well as #delete_prefix and #delete_suffix but I'd like it to be more dynamic than that just in case the namespacing gets changed or we add more types of notices in the future.

I tried searching here but I couldn't find any answers explaining how to extract text in a case like this.

Assuming it always ends in Notice then this is probably the simplest:

main> %w[ ::Pos::EmailNotice Pos::EmailNotice ::Pos::CallNotice Pos::CallNotice ].map do |s|
main>   s.match(/([^:]+)Notice/)[1]
main> end
["Email", "Email", "Call", "Call"]

Which is basically saying "all non ':' chars before 'Notice'".

arr = [ "::Pos::EmailNotice",
        "Pos::EmailNotice", 
        "::Pos::CallNotice",
        "Pos::CallNotice"
      ]

<!-->
arr.map { |str| str[/[^:]*(?=Notice\z)/] }
#=> ["Email", "Email", "Call", "Call"]

Demo

The demo employs the PCRE regex engine. Though different in some ways to Ruby's Onigmo regex engine, in this case they give the same result. I've used the end-of-line anchor ($) rather than the end-of-string anchor (\z) in order to test the expression against multiple strings.

This employs the method String#[] with a regular expression as its argument.

The regular expression reads, "Match zero or more (*) characters other than (^) a colon to be followed by the literal "Notice" at the end of the string (\z)".

(?=Notice\z) is a positive lookahead.

You may wish to hover the cursor over each part of the regular expression at the link to obtain an explanation of its function.

Rails provides String#demodulize to strip the namespace off a module:

'::Pos::EmailNotice'.demodulize #=> "EmailNotice"
'Pos::EmailNotice'.demodulize   #=> "EmailNotice"
'::Pos::CallNotice'.demodulize  #=> "CallNotice"
'Pos::CallNotice'.demodulize    #=> "CallNotice"

You could use that along with delete_suffix!, e.g.

string = '::Pos::EmailNotice'

string.demodulize.delete_suffix!('Notice')
#=> "Email"

Another approach would be to convert the string to the actual class and have it implement a type method that you can call, e.g.:

module Pos
  class EmailNotice
    def self.type
      :email
    end
  end
end

You could then use Rails' String#constantize:

'::Pos::EmailNotice'.contantize.type #=> :email
'Pos::EmailNotice'.contantize.type   #=> :email

or with pure Ruby via Module#const_get:

Object.const_get('::Pos::EmailNotice').type #=> :email
Object.const_get('Pos::EmailNotice').type   #=> :email

Test strings

str = ['::Pos::EmailNotice', 'Pos::EmailNotice', 
  '::Pos::CallNotice', 'Pos::CallNotice', 'Pos::CallText']

Using gsub

str.map {|i| i.gsub /.*::|(Notice|Text)$/, ""}

["Email", "Email", "Call", "Call", "Call"]