Override Ruby's method_missing in order to provide `On#let` interface.

 @api private

 @since 0.11.0

 @raise [NoMethodError] If doesn't respond to the given method.
12708
def method_missing(name, *args, &block)
      helpers.key?(name) ? helpers.fetch(name).call : super
    end
50799
def try(*method_chain)
      obj = self.element
      method_chain.each do |m|
        # We'll break out and return nil if any part of the chain
        # doesn't respond properly.
        (obj = nil) && break unless obj.respond_to?(m)
        obj = obj.send(m)
      end
      obj
    end
1120907
def method_missing(method, *args)
      super unless args.empty?

      if @ifds.first.respond_to?(method)
        @ifds.first.send(method)
      elsif TAGS.include?(method)
        @ifds.first.to_hash[method]
      else
        super
      end
    end
530776
def method_missing(method, *args, &block)
      if method[-1] == '='
        # setter
        key = method.slice(0...-1).to_sym

        unless has_key?(key)
          super
        end
        self[key] = args[0]
      else
        unless has_key?(method)
          super
        end

        prop = self[method]
        if prop.is_a? JSFunction
          prop.call_with_instance(self, *args, &block)
        else
          prop
        end
      end
    end
307786
def method_missing(method, *args, &block)
      raise Checky::Exception unless methods.include?("populate_#{method}".to_sym)
      @storage.send("#{method}=", send("populate_#{method}", *args, &block))
      @storage.checky_blocks[method.to_sym] = block if block_given?
    rescue Checky::Exception
      @self_before_instance_eval.send method, *args, &block if @self_before_instance_eval.present?
    end
1185652
def method_missing(method, *args, &block)
      Proxy.new(@lookup_chain).public_send(method, *args, &block)
    end
932957
def method_missing(method, *args, &block)
      return super unless @template.respond_to? method
      # Delegate the method so that we don't come in here the next time
      # when same method is called
      self.class.delegate method, to: :@template
      @template.public_send method, *args, &block
    end
856236
def method_missing(method, *args, &block)
      send(target_method(method), method, *args, &block).tap do 
        create_delegation_method!(method)
      end
    end
428330
def method_missing(method, *args, &block)
      if respond_to_missing?(method)
        new.public_send(method, *args, &block)
      else
        super
      end
    end
236182
def method_missing(method, *args, &block)
      if main_app_url_helper?(method)
        main_app.send(method, *args)
      else
        super
      end
    end
1081592
def method_missing(sym, *args, &block)
      if (data && data[sym])
        data[sym]
      else
        super(sym, *args, &block)
      end
    end
896951
def method_missing(*args, &block)
      Thread.pass until defined?(@result)
      
      case @result
      when Exception
        def self.method_missing(*args, &block); raise @result; end
      else
        def self.method_missing(*args, &block); @result.send(*args, &block); end
      end
      
      self.method_missing(*args, &block)
    end
763039
def method_missing(method, *args, &block)
      super
    rescue NoMethodError
      return regs(method) if self.has_reg?(method)
      return ports(method) if self.has_port?(method)
      if method.to_s =~ /=$/
        define_singleton_method(method) do |val|
          instance_variable_set("@#{method.to_s.sub('=', '')}", val)
        end
      else
        define_singleton_method(method) do
          instance_variable_get("@#{method}")
        end
      end
      send(method, *args, &block)
    end
237148
def method_missing(method, *args, &block)
      const_methods = @constructor.class.instance_methods(false)
      if const_methods.include? method
        return @constructor.send(method, *args, &block)
      else
        super
      end
    end
1241005
def method_missing(method_name, *args)
      if Color::X11Named.color_names.include?(method_name) && args.empty?
        color(method_name)
      else
        super
      end
    end
1006655
def respond_to?(method, *args, &block)
      const_methods = @constructor.class.instance_methods(false)
      if const_methods.include? method
        true
      else
        super
      end
    end
217698
def method_missing(name, *args)
      if [:create_by_authentication, :create_from_session].include? name
        raise NoMethodError.new("Cannot call method #{name} on class #{self.class} because it is specifically denied.", 'Method Protected')
      else
        self.class.send(name, @session, *args)
      end
    end