sunspot_solr 2.2.2 → 2.2.3

data/solr/server/solr-webapp/webapp/js/angular/controllers/query.js

@@ -0,0 +1,99 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+solrAdminApp.controller('QueryController',
+  function($scope, $routeParams, $location, Query){
+    $scope.resetMenu("query");
+
+    // @todo read URL parameters into scope
+    $scope.query = {wt: 'json', q:'*:*', indent:'on'};
+    $scope.filters = [{fq:""}];
+    $scope.dismax = {defType: "dismax"};
+    $scope.edismax = {defType: "edismax", stopwords: true, lowercaseOperators: true};
+    $scope.hl = {hl:"on"};
+    $scope.facet = {facet: "on"};
+    $scope.spatial = {};
+    $scope.spellcheck = {spellcheck:"on"};
+    $scope.qt = "/select";
+
+    $scope.doQuery = function() {
+      var params = {};
+
+      var set = function(key, value) {
+        if (params[key]) {
+          params[key].push(value);
+        } else {
+          params[key] = [value];
+        }
+      }
+      var copy = function(params, query) {
+        for (var key in query) {
+          terms = query[key];
+          if (terms.length > 0 && key[0]!="$") {
+            set(key, terms);
+          }
+        }
+      };
+
+      copy(params, $scope.query);
+
+      if ($scope.isDismax)     copy(params, $scope.dismax);
+      if ($scope.isEdismax)    copy(params, $scope.edismax);
+      if ($scope.isHighlight)  copy(params, $scope.hl);
+      if ($scope.isFacet)      copy(params, $scope.facet);
+      if ($scope.isSpatial)    copy(params, $scope.spatial);
+      if ($scope.isSpellcheck) copy(params, $scope.spellcheck);
+
+      if ($scope.rawParams) {
+        for (var param in $scope.rawParams.split(/[&\n]/)) {
+            var parts = param.split("=");
+            set(parts[0], parts[1]);
+        }
+      }
+
+      var qt = $scope.qt ? $scope.qt : "select";
+
+      for (var filter in $scope.filters) {
+        copy(params, $scope.filters[filter]);
+      }
+
+      params.doNotIntercept=true;
+      params.core = $routeParams.core;
+      params.handler = qt;
+      var url = "/solr/" + $routeParams.core + qt + "?" + Query.url(params);
+      Query.query(params, function(data) {
+        $scope.lang = $scope.query.wt;
+        $scope.response = data;
+        $scope.url = $location.protocol() + "://" +
+                     $location.host() + ":" +
+                     $location.port() + url;
+      });
+    };
+
+    $scope.removeFilter = function(index) {
+      if ($scope.filters.length === 1) {
+        $scope.filters = [{fq: ""}];
+      } else {
+        $scope.filters.splice(index, 1);
+      }
+    };
+
+    $scope.addFilter = function(index) {
+      $scope.filters.splice(index+1, 0, {fq:""});
+    };
+  }
+);

data/solr/server/solr-webapp/webapp/js/angular/controllers/replication.js

@@ -0,0 +1,227 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+solrAdminApp.controller('ReplicationController',
+    function($scope, $rootScope, $routeParams, $interval, $timeout, Replication) {
+        $scope.resetMenu("replication");
+
+        $scope.iterationCount = 1;
+
+        $scope.refresh = function() {
+            Replication.details({core:$routeParams.core}, function(response) {
+                if ($scope.interval) $interval.cancel($scope.interval);
+                $scope.isSlave = (response.details.isSlave === 'true');
+                if ($scope.isSlave) {
+                    $scope.progress = getProgressDetails(response.details.slave);
+                    $scope.iterations = getIterations(response.details.slave);
+                    $scope.versions = getSlaveVersions(response.details);
+                    $scope.settings = getSlaveSettings(response.details);
+                    if ($scope.settings.isReplicating) {
+                        $timeout($scope.refresh, 1000);
+                    } else if(!$scope.settings.isPollingDisabled && $scope.settings.pollInterval) {
+                        $scope.interval = $interval(function() {
+                            $scope.settings.tick--;
+                        }, 1000, $scope.settings.tick);
+                        $timeout($scope.refresh, 1000*(1+$scope.settings.tick));
+                    }
+                } else {
+                    $scope.versions = getMasterVersions(response.details);
+                }
+                $scope.master = getMasterSettings(response.details, $scope.isSlave);
+            });
+
+        };
+
+        $scope.execute = function(command) {
+            Replication.command({core:$routeParams.core, command:command}, function(data){$scope.refresh()});
+        }
+
+        $scope.showIterations = function() { $scope.iterationCount = 100000}; // limitTo should accept undefined, but doesn't work.
+        $scope.hideIterations = function() { $scope.iterationCount = 1};
+
+        $scope.refresh();
+    });
+
+var getProgressDetails = function(progress) {
+
+    progress.timeRemaining = parseSeconds(progress.timeRemaining);
+    progress.totalPercent = parseInt(progress.totalPercent);
+    if (progress.totalPercent === 0) {
+        progress.totalPercentWidth = "1px";
+    } else {
+        progress.totalPercentWidth = progress.totalPercent + "%";
+    }
+    progress.currentFileSizePercent = parseInt(progress.currentFileSizePercent);
+
+    if (!progress.indexReplicatedAtList) {
+        progress.indexReplicatedAtList = [];
+    }
+
+    if (!progress.replicationFailedAtList) {
+        progress.replicationFailedAtList = [];
+    }
+    return progress;
+};
+
+var getIterations = function(slave) {
+
+    var iterations = [];
+
+    var find = function(list, date) {
+        return list.filter(function(e) {return e.date == date});
+    };
+
+    for (var i in slave.indexReplicatedAtList) {
+        var date = slave.indexReplicatedAtList[i];
+        var iteration = {date:date, status:"replicated", latest: false};
+        if (date == slave.indexReplicatedAt) {
+            iteration.latest = true;
+        }
+        iterations.push(iteration);
+    }
+
+    for (var i in slave.replicationFailedAtList) {
+        var failedDate = slave.replicationFailedAtList[i];
+        var matchingIterations = find(iterations, failedDate);
+        if (matchingIterations) {
+            iteration = matchingIterations[0];
+        } else {
+            iteration = {date: failedDate, latest:false};
+            iterations.push(iteration);
+        }
+        iteration.status = "failed";
+        if (failedDate == slave.replicationFailedAt) {
+            iteration.latest = true;
+        }
+    }
+    iterations.sort(function(a,b){ return a.date> b.date;}).reverse();
+    return iterations;
+};
+
+var getMasterVersions = function(data) {
+    versions = {masterSearch:{}, master:{}};
+
+    versions.masterSearch.version = data.indexVersion;
+    versions.masterSearch.generation = data.generation;
+    versions.masterSearch.size = data.indexSize;
+
+    versions.master.version = data.master.replicableVersion || '-';
+    versions.master.generation = data.master.replicableGeneration || '-';
+    versions.master.size = '-';
+
+    return versions;
+};
+
+var getSlaveVersions = function(data) {
+    versions = {masterSearch: {}, master: {}, slave: {}};
+
+    versions.slave.version = data.indexVersion;
+    versions.slave.generation = data.generation;
+    versions.slave.size = data.indexSize;
+
+    versions.master.version = data.slave.masterDetails.replicableVersion || '-';
+    versions.master.generation = data.slave.masterDetails.replicableGeneration || '-';
+    versions.master.size = '-';
+
+    versions.masterSearch.version = data.slave.masterDetails.indexVersion;
+    versions.masterSearch.generation = data.slave.masterDetails.generation;
+    versions.masterSearch.size = data.slave.masterDetails.indexSize;
+
+    versions.changedVersion = data.indexVersion !== data.slave.masterDetails.indexVersion;
+    versions.changedGeneration = data.generation !== data.slave.masterDetails.generation;
+
+    return versions;
+};
+
+var parseDateToEpoch = function(date) {
+    // ["Sat Mar 03 11:00:00 CET 2012", "Sat", "Mar", "03", "11:00:00", "CET", "2012"]
+    var parts = date.match( /^(\w+)\s+(\w+)\s+(\d+)\s+(\d+\:\d+\:\d+)\s+(\w+)\s+(\d+)$/ );
+
+    // "Sat Mar 03 2012 10:37:33"
+    var d = new Date( parts[1] + ' ' + parts[2] + ' ' + parts[3] + ' ' + parts[6] + ' ' + parts[4] );
+    return d.getTime();
+}
+
+var parseSeconds = function(time) {
+    var seconds = 0;
+    var arr = new String(time || '').split('.');
+    var parts = arr[0].split(':').reverse();
+
+    for (var i = 0; i < parts.length; i++) {
+        seconds += ( parseInt(parts[i], 10) || 0 ) * Math.pow(60, i);
+    }
+
+    if (arr[1] && 5 <= parseInt(arr[1][0], 10)) {
+        seconds++; // treat more or equal than .5 as additional second
+
+    }
+
+    return seconds;
+}
+
+var getSlaveSettings = function(data) {
+    var settings = {};
+    settings.masterUrl = data.slave.masterUrl;
+    settings.isPollingDisabled = data.slave.isPollingDisabled == 'true';
+    settings.pollInterval = data.slave.pollInterval;
+    settings.isReplicating = data.slave.isReplicating == 'true';
+    settings.nextExecutionAt = data.slave.nextExecutionAt;
+
+    if(settings.isReplicating) {
+        settings.isApprox = true;
+        settings.tick = parseSeconds(settings.pollInterval);
+    } else if (!settings.isPollingDisabled && settings.pollInterval) {
+        if( settings.nextExecutionAt ) {
+            settings.nextExecutionAtEpoch = parseDateToEpoch(settings.nextExecutionAt);
+            settings.currentTime = parseDateToEpoch(data.slave.currentDate);
+
+            if( settings.nextExecutionAtEpoch > settings.currentTime) {
+                settings.isApprox = false;
+                settings.tick = ( settings.nextExecutionAtEpoch - settings.currentTime) / 1000;
+            }
+        }
+    }
+    return settings;
+};
+
+var getMasterSettings = function(details, isSlave) {
+    var master = {};
+    var masterData = isSlave ? details.slave.masterDetails.master : details.master;
+    master.replicationEnabled = masterData.replicationEnabled == "true";
+    master.replicateAfter = masterData.replicateAfter.join(", ");
+
+    if (masterData.confFiles) {
+        master.files = [];
+        var confFiles = masterData.confFiles.split(',');
+        for (var i=0; i<confFiles.length; i++) {
+            var file = confFiles[i];
+            var short = file;
+            var title = file;
+            if (file.indexOf(":")>=0) {
+                title = file.replace(':', ' » ');
+                var parts = file.split(':');
+                if (isSlave) {
+                    short = parts[1];
+                } else {
+                    short = parts[0];
+                }
+            }
+            master.files.push({title:title, name:short});
+        }
+    }
+    return master;
+}

data/solr/server/solr-webapp/webapp/js/angular/controllers/schema-browser.js

@@ -0,0 +1,432 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+var cookie_schema_browser_autoload = 'schema-browser_autoload';
+
+solrAdminApp.controller('SchemaBrowserController',
+    function($scope, $routeParams, $location, $cookies, Luke) {
+        $scope.resetMenu("schema-browser");
+
+        $scope.refresh = function () {
+            Luke.schema({core: $routeParams.core}, function (schema) {
+                Luke.index({core: $routeParams.core}, function (index) {
+
+                    var data = mergeIndexAndSchemaData(index, schema.schema);
+
+                    $scope.fieldsAndTypes = getFieldsAndTypes(data);
+                    $scope.is = {};
+
+                    var search = $location.search();
+                    leftbar = {};
+                    $scope.isField = $scope.isDynamicField = $scope.isType = false;
+                    if (search.field) {
+                        $scope.selectedType = "Field";
+                        $scope.is.field = true;
+                        $scope.name = search.field;
+                        leftbar.fields = [$scope.name];
+                        var field = data.fields[$scope.name];
+                        leftbar.types = [field.type];
+                        if (field.dynamicBase) leftbar.dynamicFields = [field.dynamicBase];
+                        if (field.copySources && field.copySources.length>0) leftbar.copyFieldSources = field.copySources.sort();
+                        if (field.copyDests && field.copyDests.length>0) leftbar.copyFieldDests = field.copyDests.sort();
+                        $scope.fieldOrType = "field=" + $scope.name;
+                    } else if (search["dynamic-field"]) {
+                        $scope.selectedType = "Dynamic Field";
+                        $scope.is.dynamicField = true;
+                        $scope.name = search["dynamic-field"];
+                        leftbar.dynamicFields = [$scope.name];
+                        leftbar.types = [data.dynamic_fields[$scope.name].type];
+                        $scope.fieldOrType = "dynamic-field=" + $scope.name;
+                    } else if (search.type) {
+                        $scope.selectedType = "Type";
+                        $scope.is.type = true;
+                        $scope.name = search.type;
+                        leftbar.types = [$scope.name];
+                        leftbar.fields = filterFields("fields", data, $scope.name);
+                        leftbar.dynamicFields = filterFields("dynamic_fields", data, $scope.name);
+                        $scope.fieldOrType = "type=" + $scope.name;
+                    }
+                    $scope.leftbar = leftbar;
+                    $scope.core = $routeParams.core;
+                    $scope.defaultSearchField = data.default_search_field;
+                    $scope.uniqueKeyField = data.unique_key_field;
+                    $scope.isDefaultSearchField = ($scope.selectedType == "Field" && $scope.name == $scope.defaultSearchField);
+                    $scope.isUniqueKeyField = ($scope.selectedType == "Field" && $scope.name == $scope.uniqueKeyField);
+
+                    $scope.display = getFieldProperties(index, $routeParams.core, $scope.is, $scope.name);
+                    $scope.analysis = getAnalysisInfo(data, $scope.is, $scope.name);
+
+                    $scope.isAutoload = $cookies[cookie_schema_browser_autoload] == "true";
+                    if ($scope.isAutoload) {
+                        $scope.toggleTerms();
+                    }
+                });
+            });
+        };
+        $scope.refresh();
+
+        $scope.selectFieldOrType = function() {
+            $location.search($scope.fieldOrType);
+        }
+
+        $scope.toggleAnalyzer = function(analyzer) {
+            analyzer.show = !analyzer.show;
+        }
+
+        $scope.loadTermInfo = function() {
+            var params = {fl: $scope.name, core: $routeParams.core};
+            if ($scope.topTermsCount) {
+                params.numTerms = $scope.topTermsCount;
+            }
+            $scope.isLoadingTerms = true;
+            Luke.field(params, function (data) {
+                $scope.isLoadingTerms = false;
+                $scope.termInfo = getTermInfo(data.fields[$scope.name]);
+                if (!$scope.topTermsCount) {
+                    $scope.topTermsCount = $scope.termInfo.termCount;
+                }
+            });
+        }
+
+        $scope.toggleTerms = function() {
+            $scope.showTerms = !$scope.showTerms;
+
+            if ($scope.showTerms) {
+                $scope.loadTermInfo();
+            }
+        }
+
+        $scope.loadAllTerms = function() {
+            $scope.topTermsCount = $scope.termInfo.maxTerms;
+            $scope.loadTermInfo();
+        }
+
+        $scope.toggleAutoload = function() {
+            $scope.isAutoload = !$scope.isAutoload;
+            $cookies[cookie_schema_browser_autoload] = $scope.isAutoload;
+            console.log("cookie: " + $cookies[cookie_schema_browser_autoload]);
+        }
+    }
+);
+
+var getFieldsAndTypes = function(data) {
+    var fieldsAndTypes = [];
+    for (var field in data.fields) {
+        fieldsAndTypes.push({
+            group: "Fields",
+            value: "field=" + field,
+            label: field
+        });
+    }
+    for (var field in data.dynamic_fields) {
+        fieldsAndTypes.push({
+            group: "Dynamic Fields",
+            value: "dynamic-field=" + field,
+            label: field
+        });
+    }
+    for (var type in data.types) {
+        fieldsAndTypes.push({
+            group: "Types",
+            value: "type=" + type,
+            label: type
+        });
+    }
+    return fieldsAndTypes;
+};
+
+var filterFields = function(type, data, name) {
+    var fields = [];
+    for (var i in data.types[name].fields) {
+        var field = data.types[name].fields[i];
+        if (data[type][field]) {
+            fields.push(field)
+        }
+    }
+    return fields.sort();
+}
+
+var mergeIndexAndSchemaData = function(index, schema) {
+
+    var data = {
+        default_search_field: null,
+        unique_key_field: null,
+        key: {},
+        fields: {},
+        dynamic_fields: {},
+        types: {},
+        relations: {
+            f_df: {},
+            f_t: {},
+            df_f: {},
+            df_t: {},
+            t_f: {},
+            t_df: {}
+        }
+    };
+
+    data.fields = index.fields;
+
+    data.key = index.info.key;
+
+    data.default_search_field = schema.defaultSearchField;
+    data.unique_key_field = schema.uniqueKeyField;
+
+    data.dynamic_fields = schema.dynamicFields;
+    data.types = schema.types;
+
+    for (var field in schema.fields) {
+        data.fields[field] =
+            $.extend({}, data.fields[field], schema.fields[field]);
+    }
+
+    for (var field in data.fields) {
+        var copy_dests = data.fields[field].copyDests;
+        for (var i in copy_dests) {
+            var copy_dest = copy_dests[i];
+            if (!data.fields[copy_dest]) {
+                data.fields[copy_dest] = {
+                    partial: true,
+                    copySources: []
+                };
+            }
+
+            if (data.fields[copy_dest].partial) {
+                data.fields[copy_dest].copySources.push(field);
+            }
+        }
+
+        var copy_sources = data.fields[field].copySources;
+        for (var i in copy_sources) {
+            var copy_source = copy_sources[i];
+            if (!data.fields[copy_source]) {
+                data.fields[copy_source] = {
+                    partial: true,
+                    copyDests: []
+                };
+            }
+
+            if (data.fields[copy_source].partial) {
+                data.fields[copy_source].copyDests.push(field);
+            }
+        }
+
+        data.relations.f_t[field] = data.fields[field].type;
+
+        if (!data.relations.t_f[data.fields[field].type]) {
+            data.relations.t_f[data.fields[field].type] = [];
+        }
+        data.relations.t_f[data.fields[field].type].push(field);
+
+        if (data.fields[field].dynamicBase) {
+            data.relations.f_df[field] = data.fields[field].dynamicBase;
+
+            if (!data.relations.df_f[data.fields[field].dynamicBase]) {
+                data.relations.df_f[data.fields[field].dynamicBase] = [];
+            }
+            data.relations.df_f[data.fields[field].dynamicBase].push(field);
+        }
+    }
+
+    for (var dynamic_field in data.dynamic_fields) {
+        data.relations.df_t[dynamic_field] = data.dynamic_fields[dynamic_field].type;
+
+        if (!data.relations.t_df[data.dynamic_fields[dynamic_field].type]) {
+            data.relations.t_df[data.dynamic_fields[dynamic_field].type] = [];
+        }
+        data.relations.t_df[data.dynamic_fields[dynamic_field].type].push(dynamic_field);
+    }
+    return data;
+};
+
+var getFieldProperties = function(data, core, is, field) {
+
+    var display = {};
+
+    display.partialState = is.field && !!data.fields[field].partial;
+
+    display.columns = [];
+    display.rows = [];
+    var allFlags = "";
+
+    var addRow = function(name, flags) {
+        if (flags[0]!='(') {
+            display.rows.push({name:name, flags:flags});
+            for (var i in flags) {
+                if (flags[i]!="-" && allFlags.indexOf(flags[i])<0) {
+                    allFlags+=flags[i];
+                }
+            }
+        } else {
+            display.rows.push({name:name, comment:flags});
+        }
+    }
+
+    // Identify the rows for our field property table
+    if (is.field && data.fields[field]) {
+        if (data.fields[field].flags) {
+            addRow('Properties', data.fields[field].flags);
+        }
+        if (data.fields[field].schema) {
+            addRow('Schema', data.fields[field].schema);
+        }
+        if (data.fields[field].index) {
+            addRow('Index', data.fields[field].index);
+        }
+        display.docs = data.fields[field].docs;
+        display.docsUrl = "#/" + core + "/query?q=" + field + ":[* TO *]";
+        display.distinct = data.fields[field].distinct;
+        display.positionIncrementGap = data.fields[field].positionIncrementGap;
+        display.similarity = data.fields[field].similarity;
+    } else if (is.dynamicField && data.dynamic_fields[field] && data.dynamic_fields[field].flags) {
+        addRow('Properties', data.dynamic_fields[field].flags);
+    }
+
+    // identify columns in field property table:
+    for (var key in data.info.key) {
+        if (allFlags.indexOf(key)>=0) {
+            display.columns.push({key: key, name: data.info.key[key]});
+        }
+    }
+
+    // identify rows and cell values in field property table:
+    for (var i in display.rows) {
+        var row = display.rows[i];
+        row.cells = [];
+
+        for (var j in display.columns) {
+            var flag = display.columns[j].key;
+            row.cells.push({key: flag, value: row.flags.indexOf(flag)>=0});
+        }
+    }
+
+    return display;
+};
+
+var getAnalysisInfo = function(data, is, name) {
+
+    var analysis = {};
+
+    if (is.field) {
+        var type = data.relations.f_t[name];
+        analysis.query = "analysis.fieldname=" + name;
+    }
+    else if (is.dynamicField) {
+        var type = data.relations.df_t[name];
+        analysis.query = "analysis.fieldtype=" + type;
+    }
+    else if (is.type) {
+        var type = name;
+        analysis.query = "analysis.fieldtype=" + name;
+    }
+
+    var processComponentType = function (label, key, componentTypeData) {
+        if (componentTypeData) {
+            var components = [];
+                console.dir(componentTypeData);
+            for (var componentName in componentTypeData) {
+                console.log(componentName);
+                var componentData = componentTypeData[componentName];
+                var component = {className: componentData.className, args:[]};
+                if (componentData.args) {
+                    for (var argName in componentData.args) {
+                        var argValue = componentData.args[argName];
+                        if (argValue == "1" || argValue == "true") {
+                            component.args.push({name: argName, booleanValue:true});
+                        } else if (argValue == "0" || argValue == "false") {
+                            component.args.push({name: argName, booleanValue:false});
+                        } else {
+                            component.args.push({name: argName, value:argValue});
+                        }
+                    }
+                }
+                components.push(component);
+            }
+            return {label: label, key: key, components: components};
+        } else {
+            return {label: label, key: key};
+        }
+    }
+
+    var buildAnalyzer = function (analyzerData) {
+        var analyzer = {};
+        analyzer.className = analyzerData.className;
+        analyzer.componentTypes = [];
+        if (analyzerData.tokenizer) {
+            analyzer.componentTypes.push(processComponentType("Char Filters", "charFilters", analyzerData.charFilters));
+            analyzer.componentTypes.push(processComponentType("Tokenizer", "tokenizer", {tokenizer: analyzerData.tokenizer}));
+            analyzer.componentTypes.push(processComponentType("Token Filters", "tokenFilters", analyzerData.filters));
+        }
+        return analyzer;
+    }
+
+    analysis.data = data.types[type];
+    if (analysis.data) {
+        analysis.analyzers = [
+            {key: "index", name: "Index", detail: buildAnalyzer(analysis.data.indexAnalyzer)},
+            {key: "query", name: "Query", detail: buildAnalyzer(analysis.data.queryAnalyzer)}
+        ];
+    }
+    return analysis;
+}
+
+var getTermInfo = function(data) {
+
+    var termInfo = {};
+    if (data && data.topTerms) {
+        termInfo.topTerms = [];
+
+        var currentGroup = {count: 0}
+        for (var i = 0; i < data.topTerms.length; i += 2) {
+            var count = data.topTerms[i + 1];
+            if (currentGroup.count != count) {
+                currentGroup = {count: count, terms: []};
+                termInfo.topTerms.push(currentGroup);
+            }
+            currentGroup.terms.push(data.topTerms[i]);
+        }
+        termInfo.termCount = data.topTerms.length / 2;
+        termInfo.maxTerms = data.distinct;
+    }
+
+    if(data && data.histogram) {
+        termInfo.histogram = [];
+        termInfo.histogramMax = 0;
+        for (var i = 0; i < data.histogram.length; i += 2) {
+            termInfo.histogram.push({key: data.histogram[i], value: data.histogram[i + 1]});
+            termInfo.histogramMax = Math.max(termInfo.histogramMax, data.histogram[i + 1]);
+        }
+    }
+    return termInfo;
+};
+
+/*
+        var get_width = function get_width()
+        {
+          return $( this ).width();
+        }
+
+  var max_width = 10 + Math.max.apply( Math, $( 'p', topterms_table_element ).map( get_width ).get() );
+  topterms:
+    p { width: {{maxWidth}}px !important; }
+    ul { margin-left: {{max_width + 5 }}px !important; }
+
+  var max_width = 10 + Math.max.apply( Math, $( 'dt', histogram_holder_element ).map( get_width ).get() );
+  histogram_holder:
+    ul { margin-left: {{maxWidth}}px !important; }
+    li dt { left: {{-maxWidth}}px !important; width: {{maxWidth}}px !important; }
+*/