Using `include` and `using` inside a string of code

I am trying to evaluate a string that contains Ruby code, in the context of an instance, while maintaining standard Ruby methods such as using (for refinements) and include.

Here is my most stripped down example. I would like to make the user code (string) work as is, without modification to it. The Context#run method is where I am hoping to make the necessary changes.

require 'fileutils'

module SomeUserRefinement
  refine String do
    def header
      "=== #{self} ==="
    end
  end
end

class Context
  def run(code)
    instance_eval code
  end

  def some_instance_method
    puts "works"
  end
end

user_code = <<~CODE
  using SomeUserRefinement    # not working
  include FileUtils           # not working
  puts 'Caption'.header
  some_instance_method
CODE

context = Context.new
context.run user_code

Your overall intent is a bit unclear other than "...I would like to make the user code (string) work as is, without modification to it", which may or may not work in any given circumstance (e.g. if the user code is no good then it will always fail, as it does here)

Short Answer
Your requested implementation is simply not a functional possibility by design. Additionally your example attempts to mix and match instance methods and class instance methods while using the same receiver, which is also not possible.

Longer Answer

Had you posted the actual error message it would have shown:

undefined method `using' for #<Context:0x00007ff65eda4498> (NoMethodError)

This is because using is not an instance method. (same applies to include)

Okay so let's try to leverage the eigenclass for your instance

class Context
  def run(code)
    singleton_class.instance_eval code
  end
end

New error

`using': Module#using is not permitted in methods (RuntimeError)

If we read through the docs for refinements we see:
> Scope
>
>You may activate refinements at top-level, and inside classes and modules. You may not activate refinements in method scope. Refinements are activated until the end of the current class or module definition, or until the end of the current file if used at the top-level.

include does not have the same limitation and modules can be included in the eigenclass of an instance in a method scope; however your code also needs to be able to call some_instance_method in the same context with the same receiver, which is not possible.