$detail is either false or a class with methods
424072
public static function gradeShowAll($stmt, $detail = false) {
        echo('<table border="1">');
        echo("\n<tr><th>Name<th>Email</th><th>Grade</th><th>Date</th></tr>\n");

        while ( $row = $stmt->fetch(\PDO::FETCH_ASSOC) ) {
            echo('<tr><td>');
            if ( $detail ) {
                $detail->link($row);
            } else {
                echo(htmlent_utf8($row['displayname']));
            }
            echo("</td>\n<td>".htmlent_utf8($row['email'])."</td>
                <td>".htmlent_utf8($row['grade'])."</td>
                <td>".htmlent_utf8($row['updated_at'])."</td>
            </tr>\n");
        }
        echo("</table>\n");
    }
66950
def generate_detail_view(self):
        """"""

        name = model_class_form(self.model + 'DetailView')
        detail_args = dict(
            detailview_excludes=self.detailview_excludes,
            model=self.get_model_class,
            template_name=self.get_template('detail'),
            login_required=self.check_login_required,
            permissions=self.view_permission('detail'),
            inlineformset=self.inlineformset,
            permission_required=self.check_permission_required,
            custom_postfix_url=self.custom_postfix_url
        )

        detail_class = type(name, (BaseDetailViewMixin, DetailView), detail_args)
        self.classes[name] = detail_class
        return detail_class
414838
def method_missing(m, *args, &block)
      column_name = m.to_s.gsub(/\=$/, '')
      raise ExtendModelAt::InvalidColumn, "#{column_name} not exist" if @static == true and not (@columns.try(:keys).try(:include?, column_name.to_sym) )
      # If the method don't finish with "=" is fore read
      if m !~ /\=$/
        self[m.to_s]
      # but if finish with "=" is for wirte
      else
        self[column_name.to_s] = args.first
      end
    end
808530
def detail_view(self, request, instance_pk):
        
        kwargs = {'model_admin': self, 'instance_pk': instance_pk}
        view_class = self.detail_view_class
        return view_class.as_view(**kwargs)(request)
406888
function(details) {
        this.id = details.jobId;
        this.status = details.status;
        this.response = details.response;
        this.error = details.error;
    }
374230
def method_missing(meth, value)
      meth = sanitize_setter_method(meth)

      if defaults.key?(meth)
        @options[meth] = value
      else
        super
      end
    end
112598
private function processDetails(& $details, & $parent_rows, $options, $parent_keys = [], $parent_types = [], $parent_maps = [], $parent_settings = []) {
		$result = [
			'success' => false,
			'error' => [],
			'max_records' => []
		];
		foreach ($details as $k => $v) {
			// acl
			if (!empty($v['acl']) && !\Can::systemFeaturesExist($v['acl'])) continue;
			// initialize model
			$details[$k]['model_object'] = $model = \Factory::model($k, false);
			$pk = $v['pk'] ?? $model->pk;
			// generate keys from parent array
			$keys = [];
			$key_level = count($v['map']);
			if ($key_level == 1) {
				$k1 = key($v['map']);
				$v1 = $v['map'][$k1];
				$column = $v1;
			} else {
				$column = "concat_ws('::', " . implode(', ', $v['map']) . ")";
			}
			// special array for keys
			$parent_keys2 = $parent_keys;
			$parent_keys2[] = $k;
			$parent_types2 = $parent_types;
			$parent_types2[] = $v['type'];
			$parent_maps2 = $parent_maps;
			$parent_maps2[] = $v['map'];
			// create empty arrays
			$result_keys = [];
			$this->getAllChildKeys($parent_rows, $parent_maps2, $parent_keys2, $parent_types2, $result_keys, $keys);
			foreach ($result_keys as $k0 => $v0) {
				array_key_set($parent_rows, $v0, []);
			}
			// building query
			$query = $model->queryBuilder([
				'initiator' => 'collection',
				'skip_acl' => $this->options['skip_acl']
			])->select()->columns(['a.*']);
			// process column overrides
			$query->columnOverrides($model->columns);
			// where
			$query->where('AND', [$column, 'IN', $keys]);
			if (!empty($v['where'])) {
				$query->whereMultiple('AND', $v['where']);
			}
			// sql extensions
			if (!empty($v['sql']['where'])) {
				$query->whereMultiple('AND', $v['sql']['where']);
			}
			// if we need to count # of records
			if (!empty($parent_settings['max_records_model_name'])) {
				$counter_query = clone $query;
				$counter_query->columns(['counter' => 'COUNT(*)'], ['empty_existing' => true]);
				$temp = $counter_query->query();
				if (!empty($temp['rows'][0]['counter'])) {
					if ($temp['rows'][0]['counter'] >= $parent_settings['max_records']) {
						$result['max_records'][$parent_settings['max_records_model_name']] = $temp['rows'][0]['counter'];
						$result['success'] = true;
						return $result;
					}
				}
			}
			// orderby
			$orderby = $options['orderby'] ?? (!empty($model->orderby) ? $model->orderby : null);
			if (!empty($orderby)) {
				$query->orderby($orderby);
			}
			// for update
			if (!empty($options['for_update'])) {
				$query->forUpdate();
			}
			$query_result = $query->query(null);
			if (!$query_result['success']) {
				$this->primary_model->db_object->rollback();
				$result['error'] = array_merge($result['error'], $query_result['error']);
				return $result;
			}
			// process max records
			if (!empty($v['max_records'])) {
				$result['max_records'][$k] = $query_result['num_rows'];
				$v['max_records_model_name'] = $k;
			}
			if (!empty($parent_settings['max_records_model_name'])) {
				$result['max_records'][$parent_settings['max_records_model_name']] = $query_result['num_rows'];
				$v['max_records_model_name'] = $parent_settings['max_records_model_name'];
				$v['max_records'] = $parent_settings['max_records'];
			}
			// if we got rows
			if (!empty($query_result['rows'])) {
				$reverse_map = array_reverse($parent_maps2, true);
				foreach ($query_result['rows'] as $k2 => $v2) {
					$master_key = [];
					// entry itself
					if ($v['type'] == '1M') {
						$temp = [];
						foreach ($pk as $v0) {
							$temp[] = $v2[$v0];
						}
						$master_key[] = implode('::', $temp);
					}
					$previous = $v2;
					foreach ($reverse_map as $k3 => $v3) {
						$temp = [];
						if (empty($v['__relation_pk'])) {
							foreach ($v3 as $k4 => $v4) {
								$previous[$k4] = $previous[$v4];
								$temp[] = $previous[$v4];
							}
						} else {
							foreach ($v['__relation_pk'] as $k4 => $v4) {
								$temp[] = $previous[$v4];
							}
						}
						array_unshift($master_key, $parent_keys2[$k3]);
						if (($parent_types2[$k3 - 1] ?? '') != '11') {
							array_unshift($master_key, implode('::', $temp));
						}
					}
					array_key_set($parent_rows, $master_key, $v2);
				}
				// if we have more details
				if (!empty($v['details'])) {
					$detail_result = $this->processDetails($v['details'], $parent_rows, $options, $parent_keys2, $parent_types2, $parent_maps2, $v);
					if (!$detail_result['success']) {
						$result['error'] = array_merge($result['error'], $detail_result['error']);
						return $result;
					} else {
						if (!empty($detail_result['max_records'])) {
							foreach ($detail_result['max_records'] as $k19 => $v19) {
								$result['max_records'][$k19]+= $v19;
							}
						}
					}
				}
			}
		}
		$result['success'] = true;
		return $result;
	}
1029819
def update(details)
      details.each do |k, v|
        send("#{k}=", v)
      end
      self.class.update(component_key, details)
    end
1027879
function findInheritedMethods(ci, methods) {
    while (ci && ci.extends) {
        ci = findTypeMetaInfo(ci.extends);
        if (!ci) {
            console.warn('no meta info for: ' + ci.extends);
            continue;
        }
        (ci.methodsClass || ci.methods).forEach(m => {
            if (methods.find(mm => mm.name === m.name && getArgumentsString(mm) == getArgumentsString(m))) {
                return;
            }
            if (m.inheritance || isAngularLifeCircle(m.name)) {
                return;
            }
            // deep copy
            m = JSON.parse(JSON.stringify(m));
            delete m.inheritance;
            m.inheritInfo = {from: ci.name, type: ci.type || ci.subtype};
            methods.push(m);
        });
    }
}
400178
protected function displayJson(array $details)
    {
        $errors = 0;

        array_walk(
            $details,
            function (&$info) use (&$errors) {
                $info['file'] = (string) $info['file'];
                unset($info['template']);

                if (!$info['valid']) {
                    $info['message'] = $info['exception']->getMessage();
                    unset($info['exception']);
                    $errors++;
                }
            }
        );

        $this->line(json_encode($details, JSON_PRETTY_PRINT));

        return min($errors, 1);
    }
801838
public function setItemsDetail($detail = true, $primary_where_column = null)
	{
		if ($this->isSortable()) {
			throw new DataGridException('You can not use both sortable datagrid and items detail.');
		}

		$this->items_detail = new Column\ItemDetail(
			$this,
			$primary_where_column ?: $this->primary_key
		);

		if (is_string($detail)) {
			/**
			 * Item detail will be in separate template
			 */
			$this->items_detail->setType('template');
			$this->items_detail->setTemplate($detail);

		} elseif (is_callable($detail)) {
			/**
			 * Item detail will be rendered via custom callback renderer
			 */
			$this->items_detail->setType('renderer');
			$this->items_detail->setRenderer($detail);

		} elseif ($detail === true) {
			/**
			 * Item detail will be rendered probably via block #detail
			 */
			$this->items_detail->setType('block');

		} else {
			throw new DataGridException(
				'::setItemsDetail() can be called either with no parameters or with parameter = template path or callable renderer.'
			);
		}

		return $this->items_detail;
	}
507235
def _inspect_details(extras)
      details = [self.class.name]
      fields = _members.merge(extras)
      details << Inspect.from_fields(fields) unless fields.empty?
      "#<#{details.join(' ')}>"
    end
870048
def method_missing(name, *args, &block)
      getter_name = name[0..-2]

      if name =~ /^[a-z]+=$/ && !respond_to?(getter_name)
        define_accessor(getter_name, args.first)
      else
        super
      end
    end
1161030
def method_missing(meth, *args, &block)
      raise NoMethodError, "undefined method #{meth} for #{self.class.to_s}" if WotApiRu::Constants::PATH[meth.to_sym].nil?
      options = args[0] || {}
      options[:application_id] ||= WotApiRu::Settings[:application_id]
      path = WotApiRu::Constants::HOST + WotApiRu::Constants::PATH[meth.to_sym]
      invoke(path, options)
    end
182657
def method_missing(method, *args, &code)
    success = false
    result  = nil

    if method.to_s.match(/^set\_([a-z].*)$/)
      name = $1.to_sym

      if @types.has_key?(name) && args.length > 2
        @types[name].set([ args[0], args[1] ], args[2]) if args.length > 2
        success = true
      end

    elsif method.to_s.match(/^remove\_([a-z].*)$/)
      name = $1.to_sym

      if @types.has_key?(name) && args.length > 0
        @types[name].delete([ args[0], args[1] ])
        success = true
      end

    else
      name = @plurals[method.to_sym]

      if name && @types.has_key?(name)
        result  = @types[name]
        success = true
      end
    end
    super unless success # Raise NoMethodError
    result
  end
556945
function process( $tpl, &$textElements, $functionName, $functionChildren, $functionParameters, $functionPlacement, $rootNamespace, $currentNamespace )
    {
        $params = $functionParameters;
        switch ( $functionName )
        {
            case $this->BlockName:
            {
                $viewMode = "full";
                $name = $currentNamespace;
                // Read ini file
                $toolbarIni = eZINI::instance( "toolbar.ini" );

                if ( isset( $functionParameters["view"] ) )
                {
                    $viewMode = $tpl->elementValue( $functionParameters["view"], $rootNamespace, $currentNamespace, $functionPlacement );
                }

                if ( isset( $functionParameters["name"] ) )
                {
                    reset( $params );
                    $whatParamsShouldBeUnset = array();
                    $whatParamsShouldBeReplaced = array();
                    while ( ( $key = key( $params ) ) !== null )
                    {
                        $item =& $params[$key];
                        switch ( $key )
                        {
                            case "name":
                            case "view":
                                break;

                            default:
                            {
                                if ( !$tpl->hasVariable( $key, $name ) )
                                {
                                    $whatParamsShouldBeUnset[] = $key; // Tpl vars should be removed after including
                                }
                                else
                                {
                                    $whatParamsShouldBeReplaced[$key] = $tpl->variable( $key, $name ); // Tpl vars should be replaced after including
                                }

                                $item_value = $tpl->elementValue( $item, $rootNamespace, $currentNamespace, $functionPlacement );
                                $tpl->setVariable( $key, $item_value, $name );
                            } break;
                        }
                        next( $params );
                    }
                    $toolbarPosition = $tpl->elementValue( $functionParameters["name"], $rootNamespace, $currentNamespace, $functionPlacement );
                    $definedVariables = array();
                    $toolbarName = "Toolbar_" . $toolbarPosition;
                    $toolArray = $toolbarIni->variable( $toolbarName, 'Tool' );

                    if ( !is_array( $toolArray ) )
                        $toolArray = array();

                    $actionParameters = array();
                    foreach ( array_keys( $toolArray ) as $toolKey )
                    {
                        $definedVariables = array();
                        $tool = $toolArray[$toolKey];
                        $placement = $toolKey + 1;
                        if ( $toolbarIni->hasGroup( "Tool_" . $tool ) )
                        {
                            $actionParameters = $toolbarIni->group( "Tool_" . $tool );
                        }
                        if ( $toolbarIni->hasGroup( "Tool_" . $toolbarPosition . "_" . $tool . "_" . $placement ) )
                        {
                            $actionParameters = array_merge( $actionParameters, $toolbarIni->group( "Tool_" . $toolbarPosition . "_" . $tool . "_" . $placement ) );
                        }
                        foreach ( array_keys( $actionParameters ) as $key )
                        {
                            $itemValue = $actionParameters[$key];
                            $tpl->setVariable( $key, $itemValue, $name );
                            $definedVariables[] = $key;
                        }
                        $toolIDValue =  "Tool_" . $toolbarPosition . "_" . $tool . "_" . $placement;
                        $tpl->setVariable( "tool_id", $toolIDValue, $name );
                        $definedVariables[] = "tool_id";
                        $toolOffset = $placement;
                        $tpl->setVariable( "offset", $toolOffset, $name );
                        $definedVariables[] = "offset";
                        $uri = "design:toolbar/$viewMode/$tool.tpl";

                        if ( $placement == 1 )
                        {
                            if ( count( $toolArray ) == 1 )
                            {
                                $tpl->setVariable( "first", true );
                                $tpl->setVariable( "last", true );
                                $tpl->setVariable( "placement", "last" );
                                $definedVariables[] = "first";
                                $definedVariables[] = "last";
                                $definedVariables[] = "placement";
                            }
                            else
                            {
                                $tpl->setVariable( "first", true );
                                $tpl->setVariable( "last", false );
                                $tpl->setVariable( "placement", "first" );
                                $definedVariables[] = "first";
                                $definedVariables[] = "last";
                                $definedVariables[] = "placement";
                            }
                        }
                        else if ( $placement == count( $toolArray ) )
                        {
                            $tpl->setVariable( "first", false );
                            $tpl->setVariable( "last", true );
                            $tpl->setVariable( "placement", "last" );
                            $definedVariables[] = "first";
                            $definedVariables[] = "last";
                            $definedVariables[] = "placement";
                        }
                        else
                        {
                            $tpl->setVariable( "first", false );
                            $tpl->setVariable( "last",  false );
                            $tpl->setVariable( "placement", "" );
                            $definedVariables[] = "placement";
                        }
                        $tpl->processURI( $uri, true, $extraParameters, $textElements, $name, $name );
                        // unset var
                        foreach ( $whatParamsShouldBeUnset as $key )
                        {
                            $tpl->unsetVariable( $key, $name );
                        }
                        // replace var
                        foreach ( $whatParamsShouldBeReplaced as $key => $item_value )
                        {
                            $tpl->setVariable( $key, $item_value, $name );
                        }
                    }
                }
            }
        }
    }
152945
function collectInformation( $collection, &$collectionAttribute, $http, $base )
    {
        $dataType = $this->dataType();
        if ( $dataType )
        {
            $collectionAttribute->setAttribute( 'contentclass_attribute_id', $this->attribute( 'contentclassattribute_id' ) );
            $collectionAttribute->setAttribute( 'contentobject_attribute_id', $this->attribute( 'id' ) );
            $collectionAttribute->setAttribute( 'contentobject_id', $this->attribute( 'contentobject_id' ) );
            return $dataType->fetchCollectionAttributeHTTPInput( $collection, $collectionAttribute, $http, $base, $this );
        }

        return false;
    }