prototype.jsを読み解く

第6回Prototypeライブラリ(1609~2051行目)

昔話

Google MapsやPrototypeライブラリが認知されるにつれ、JavaScriptに対する評価はずいぶんと変わってきました。

それ以前は、我々が制作するような企業向けのサイトでは、JavaScriptへの依存は最低限にとどめて、古いブラウザ(Netscape Navigator 4やInternet Explorer 4)でも同じように動作することが求められてきました。

JavaScriptを使ったとしても、実験的なページ(今はもうありませんがNavigation Voodoo(1999年)など)での公開か、ブラウザごとにJavaScriptをまったく別個に記述する(今も残っているものとしてはearth from above(富士写真フィルム, 2000年)がIEで動くようです)ようなことをしてきました。

今ではブラウザの UserAgent 文字列やバージョンを見て分岐する方法よりは、object detectionを使ってより長生きするページを制作する手法が好まれますが、この当時では(少なくとも弊社では)このあたりが限界でした。

最近は「古いブラウザでもまったく同じに見えるように」というリクエストは少なくなり、最新のブラウザではその機能の恩恵を受けた実装を行い、古いブラウザではそれなりに見える、くらいのところが落としどころとなっています。

では、今回は前回から引き続いてElementへの拡張です。

1609:   getDimensions: function(element) {
1610:     element = $(element);
1611:     var display = $(element).getStyle('display');
1612:     if (display != 'none' && display != null) // Safari bug
1613:       return {width: element.offsetWidth, height: element.offsetHeight};
1614: 
1615:     // All *Width and *Height properties give 0 on elements with display none,
1616:     // so enable the element temporarily
1617:     var els = element.style;
1618:     var originalVisibility = els.visibility;
1619:     var originalPosition = els.position;
1620:     var originalDisplay = els.display;
1621:     els.visibility = 'hidden';
1622:     els.position = 'absolute';
1623:     els.display = 'block';
1624:     var originalWidth = element.clientWidth;
1625:     var originalHeight = element.clientHeight;
1626:     els.display = originalDisplay;
1627:     els.position = originalPosition;
1628:     els.visibility = originalVisibility;
1629:     return {width: originalWidth, height: originalHeight};
1630:   },
1631: 

1609行目からはgetDimensions()です。

style.displayが表示状態の場合、offsetWidth, offsetHeightを使います。Safariではstyle.displayが'none'の場合、値を取得するとnullが返ってきますので、それにも対応できるようにしてあります。

次に、style.displayが非表示の場合には、visibility: hidden、position:absolute、display:blockとした上でclientWidth、clientHeightを取得します。positionがabsoluteになっているので、この変更によってレンダリングが崩れることが無いようになっています。もちろんvisibilityもhiddenなので要素自体もレンダリングはされません。

displayの値によって、offset{Width,Height}、client{Width,Height}が使い分けられています。ボーダーの幅を含むか含まないかの違いがあるので注意してください。

1632:   makePositioned: function(element) {
1633:     element = $(element);
1634:     var pos = Element.getStyle(element, 'position');
1635:     if (pos == 'static' || !pos) {
1636:       element._madePositioned = true;
1637:       element.style.position = 'relative';
1638:       // Opera returns the offset relative to the positioning context, when an
1639:       // element is position relative but top and left have not been defined
1640:       if (window.opera) {
1641:         element.style.top = 0;
1642:         element.style.left = 0;
1643:       }
1644:     }
1645:     return element;
1646:   },
1647: 
1648:   undoPositioned: function(element) {
1649:     element = $(element);
1650:     if (element._madePositioned) {
1651:       element._madePositioned = undefined;
1652:       element.style.position =
1653:         element.style.top =
1654:         element.style.left =
1655:         element.style.bottom =
1656:         element.style.right = '';
1657:     }
1658:     return element;
1659:   },
1660: 

1632行目からはmakePositioned()です。

style.positionを見て、'static'か何も指定されていなければ、'relative'に変更します。その際、後でundoPositioned()で利用するために、_madePositionedフラグを設定しておきます。

'relative'に設定することで、内部に含まれるposition:absoluteな要素がこの要素からの相対位置になるようにしたり、要素自身を本来のposition:staticな位置からtop, leftを使って移動させたい時に利用します。

コメントで言及されているOperaでの問題ですが、positionをstaticからrelativeに変えたとき、top, leftはFirefoxでは0pxに、IEではnullになります。ところがOperaでは親のうちposition:static以外のものからの相対位置が返ってきてしまいます。W3Cの勧告では、positionプロパティが変更された際にtop, leftがどうなっているべき、という記述は無いようなので、どのブラウザの挙動も間違っているわけではないのですが(といっても取得した値をそのまま再度設定すると移動してしまう、というのもどうかと思いますが⁠⁠、Operaだけが他と大きく異なるので、Firefoxに合わせるように代入しています。

1648行目からはundoPositioned()です。

先ほどmakePositioned()で設定した_madePositionedフラグが設定されていれば元に戻す処理を行い、そうでなければ何もしません。

戻す際には、_madePositionedを使っていない状態に戻し、styleのposition、top、left、bottom、rightを空文字に設定することでデフォルトの挙動に戻します。

1661:   makeClipping: function(element) {
1662:     element = $(element);
1663:     if (element._overflow) return element;
1664:     element._overflow = element.style.overflow || 'auto';
1665:     if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
1666:       element.style.overflow = 'hidden';
1667:     return element;
1668:   },
1669: 
1670:   undoClipping: function(element) {
1671:     element = $(element);
1672:     if (!element._overflow) return element;
1673:     element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
1674:     element._overflow = null;
1675:     return element;
1676:   }
1677: };
1678: 

1661行目からはmakeClipping()です。

この関数とundoClipping()では、_overflowプロパティを保存領域としてつかっています。もしそこに値が設定されていれば、すでにmakeClipping()が呼ばれている状態と判断してそのまま要素を返します。

そして、1664行目でstyle.overflowを_overflowに保存します。style.overflowが空の場合は'auto'扱いですが、空のままだと1663行目の判別式で偽となってしまうので、'auto'という文字列を入れておきます。

次にElement.getStyle()を使ってできるだけその要素自体の現状のoverflowプロパティを取得しようとします。何も返ってこなければ、デフォルトの'visible'の扱いとします。そしてその取得した値が'hidden'でなければ、style.overflowを'hidden'に設定して、クリップされる状態にします。

そして1670行目からはundoClipping()です。

makeClipping()関数により_overflowプロパティが設定されていなければ、呼び出しは無視されます。

設定されていれば、その値が'auto'なら空文字列を要素のstyle.overflowに代入し、そうでなければ_overflowに入っている文字列を代入します。

最後に、判別用の_overflowプロパティをnullクリアして終了です。

1679: Object.extend(Element.Methods, {
1680:   childOf: Element.Methods.descendantOf,
1681:   childElements: Element.Methods.immediateDescendants
1682: });
1683: 

1679行目からはElement.MethodsのdescendantOf、immediateDescendantsに別名をそれぞれchildOf、childElementsとして設定しています。

1684: if (Prototype.Browser.Opera) {
1685:   Element.Methods._getStyle = Element.Methods.getStyle;
1686:   Element.Methods.getStyle = function(element, style) {
1687:     switch(style) {
1688:       case 'left':
1689:       case 'top':
1690:       case 'right':
1691:       case 'bottom':
1692:         if (Element._getStyle(element, 'position') == 'static') return null;
1693:       default: return Element._getStyle(element, style);
1694:     }
1695:   };
1696: }

ここからは、Element.Methodsの関数を、ブラウザごとに微調整します。

まずはOpera用にgetStyle()を再定義します。

元のgetStyleを_getStyleとして保存しておき、新たにgetStyleを定義します。style.positionが'static'で、'left', 'top', 'right', 'bottom' のスタイル情報を取得しようとするとnullを返し、それ以外は元の_getStyle()を呼び出して値を返しています。

先ほどと似ていますが、Operaではposition指定が無い要素に明示的にposition:staticを指定すると、top, leftなどが自分の親のうちposition:static以外のものからの相対座標、に設定されます。これを嫌ってPrototypeライブラリのgetStyle()を使う場合はIEと同じようにnullを返すようにしています。

1697: else if (Prototype.Browser.IE) {
1698:   Element.Methods.getStyle = function(element, style) {
1699:     element = $(element);
1700:     style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
1701:     var value = element.style[style];
1702:     if (!value && element.currentStyle) value = element.currentStyle[style];
1703: 
1704:     if (style == 'opacity') {
1705:       if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
1706:         if (value[1]) return parseFloat(value[1]) / 100;
1707:       return 1.0;
1708:     }
1709: 
1710:     if (value == 'auto') {
1711:       if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
1712:         return element['offset'+style.capitalize()] + 'px';
1713:       return null;
1714:     }
1715:     return value;
1716:   };
1717: 

IE用の修正として、getStyle()、setOpacity()、update()を入れ替えています。

1698行目のgetStyle()では、floatスタイルの取得に'float', 'cssFloat'ではなく'styleFloat'を使うようにしています。

また、IEではdocument.defaultView.getComputedStyle()が使えないので、その代わりにcurrentStyleプロパティを参照しています。こちらも要素に指定されたスタイルではなく、実際に描画されているスタイル情報を取得することになります。

'opacity'を取得しようとしている場合は、'filter'に'alpha(opacity=50)'のような指定が入っているかどうかをチェックし、その値をFirefoxなどと合わせる為に100で割って返しています(IEは100で不透明⁠⁠。

このalpha()の内側は、opacity=50などの他にもいくつかのパラメータが利用できます。また大文字で記述しても効果があるので、この正規表現だとカバーできない条件が多いでしょう。

得られた値が'auto'の場合、元のgetStyle()では単にnullを返していましたが、ここでは取得しようとしているスタイルが'width'か'height'でその要素のdisplayスタイルが'none'以外の場合、offsetWidthかoffsetHeightで値が取れるのでそれを使って返します。

1718:   Element.Methods.setOpacity = function(element, value) {
1719:     element = $(element);
1720:     var filter = element.getStyle('filter'), style = element.style;
1721:     if (value == 1 || value === '') {
1722:       style.filter = filter.replace(/alpha\([^\)]*\)/gi,'');
1723:       return element;
1724:     } else if (value < 0.00001) value = 0;
1725:     style.filter = filter.replace(/alpha\([^\)]*\)/gi, '') +
1726:       'alpha(opacity=' + (value * 100) + ')';
1727:     return element;
1728:   };
1729: 

1718行目からはsetOpacity()の上書きです。

半透明化はIEではfilter: alpha(opacity=<integer>)を使うので、その形で実装しなおします。

まず、現状のfilterスタイルの値を取得しておきます。指定しようとしている値が1もしくは空文字列の場合、完全な不透明を指定していることになるので、filter文字列からalpha()関数呼び出しをまるごと削除します。

もし指定しようとしている値が極端に小さければ0として扱うようにし、その後alpha()呼び出しを削除した後、指定された値でalpha(opacity=値)を追加しています。

先ほども書きましたが、alpha()にはopacity以外にもいろいろと指定できるため、alpha()まるごと削除、はちょっと乱暴でしょう。

1730:   // IE is missing .innerHTML support for TABLE-related elements
1731:   Element.Methods.update = function(element, html) {
1732:     element = $(element);
1733:     html = typeof html == 'undefined' ? '' : html.toString();
1734:     var tagName = element.tagName.toUpperCase();
1735:     if (['THEAD','TBODY','TR','TD'].include(tagName)) {
1736:       var div = document.createElement('div');
1737:       switch (tagName) {
1738:         case 'THEAD':
1739:         case 'TBODY':
1740:           div.innerHTML = '<table><tbody>' +  html.stripScripts() + '</tbody></table>';
1741:           depth = 2;
1742:           break;
1743:         case 'TR':
1744:           div.innerHTML = '<table><tbody><tr>' +  html.stripScripts() + '</tr></tbody></table>';
1745:           depth = 3;
1746:           break;
1747:         case 'TD':
1748:           div.innerHTML = '<table><tbody><tr><td>' +  html.stripScripts() + '</td></tr></tbody></table>';
1749:           depth = 4;
1750:       }
1751:       $A(element.childNodes).each(function(node) { element.removeChild(node) });
1752:       depth.times(function() { div = div.firstChild });
1753:       $A(div.childNodes).each(function(node) { element.appendChild(node) });
1754:     } else {
1755:       element.innerHTML = html.stripScripts();
1756:     }
1757:     setTimeout(function() { html.evalScripts() }, 10);
1758:     return element;
1759:   }
1760: }

1730行目からはupdate()の上書きです。

IEではテーブル関係の一部だけをinnerHTMLで書き換えることができないので、その場合の例外処理を行います。

書き換えようとしている要素のタグ名がthead、tbody、tr、td以外の場合は、元々のupdate()と挙動は同じです。

例外対象のタグの場合は、空の div 要素を作って、その中に必要な階層のテーブル関係のタグと、今回更新したい内容をくっつけて、まとめて innerHTML に代入します。その際、後で何階層下のタグを取り出すのか、ということを示す数値を depth 変数に入れておきます。

1751行目で、要素の子供ノードをすべて削除します。その後、depthで指定された回数だけdiv.firstChildを辿ります。これでdivは今回html変数に入った文字列から作った要素のひとつ親の要素を示すようになります。

最後に、divのchildNodesすべてを、elementにappendChild()して終了です。

1761: else if (Prototype.Browser.Gecko) {
1762:   Element.Methods.setOpacity = function(element, value) {
1763:     element = $(element);
1764:     element.style.opacity = (value == 1) ? 0.999999 :
1765:       (value === '') ? '' : (value < 0.00001) ? 0 : value;
1766:     return element;
1767:   };
1768: }
1769: 

1761行目からは Gecko(Mozilla系)用の修正です。元々の関数との変更点は、指定された値が1だったときに、style.opacityに''を設定していたのが0.999999を設定している、という点です。

この0.999999を渡す、という処理は他のライブラリでも見かけますが、由来が見つけられませんでした。簡単なテストでは1.0でも0.999999でもレンダリング結果は変わらないように見えます。

1770: Element._attributeTranslations = {
1771:   names: {
1772:     colspan:   "colSpan",
1773:     rowspan:   "rowSpan",
1774:     valign:    "vAlign",
1775:     datetime:  "dateTime",
1776:     accesskey: "accessKey",
1777:     tabindex:  "tabIndex",
1778:     enctype:   "encType",
1779:     maxlength: "maxLength",
1780:     readonly:  "readOnly",
1781:     longdesc:  "longDesc"
1782:   },
1783:   values: {
1784:     _getAttr: function(element, attribute) {
1785:       return element.getAttribute(attribute, 2);
1786:     },
1787:     _flag: function(element, attribute) {
1788:       return $(element).hasAttribute(attribute) ? attribute : null;
1789:     },
1790:     style: function(element) {
1791:       return element.style.cssText.toLowerCase();
1792:     },
1793:     title: function(element) {
1794:       var node = element.getAttributeNode('title');
1795:       return node.specified ? node.nodeValue : null;
1796:     }
1797:   }
1798: };
1799: 

1770行目からはElement._attributeTranslationsです。

Element.readAttribute()でIE用の例外処理に用いられたり、Element.Methods.Simulated.hasAttribute()の中でプロパティ名の正規化に用いられたりします。

namesプロパティに入っているのは、要素の属性名の大文字小文字を正規化するための変換テーブルです。

valuesの方には、例外処理を必要とする要素の属性が含まれており、"style"、"title"は独自の関数を、それ以外は_getAttr()か_flag()が使われます。

_getAttr()内ではgetAttribute()関数の第二引数に2を渡しています。これは、IE独自の拡張かと思われますが、真だと大文字小文字を区別して属性を探すようです。

_flags()内では、checked="checked"というようなフラグ形式のものにおいて、適切な文字列が返されるようにするものです。

1800: (function() {
1801:   Object.extend(this, {
1802:     href: this._getAttr,
1803:     src:  this._getAttr,
1804:     type: this._getAttr,
1805:     disabled: this._flag,
1806:     checked:  this._flag,
1807:     readonly: this._flag,
1808:     multiple: this._flag
1809:   });
1810: }).call(Element._attributeTranslations.values);
1811: 

"href"、"src"、"type"、"disabled"、"checked"、"readonly"、"multiple"属性用に、内部用関数_getAttr、_flagを割り当てます。

Element._attributeTranslations.valuesのプロパティを、そのオブジェクト内の関数を値として設定するため、無名関数とcall()を使ってthisとして表記できるようにして短く記述しています。callを使わずに引数として渡してしまう方が素直かと思います。

1812: Element.Methods.Simulated = {
1813:   hasAttribute: function(element, attribute) {
1814:     var t = Element._attributeTranslations, node;
1815:     attribute = t.names[attribute] || attribute;
1816:     node = $(element).getAttributeNode(attribute);
1817:     return node && node.specified;
1818:   }
1819: };
1820: 

Element.Methods.Simulatedは、特定のブラウザでHTMLElementインターフェイスの実装が欠けているのを補うための関数が置かれています。

といっても今のところはIE 6, 7用のhasAttribute()関数のみです。Element.extend()で自動的に拡張されたり、Element.hasAttribute()から間接的に呼ばれたり、Element.addMethods()で拡張するのに使われています。

hasAttribute()では、Element._attributeTranslations.namesハッシュを使ってIE用にプロパティ名を正規化し、getAttributeNode()で属性ノードを取得しています。ここで、この関数が真を返すのはnodeが取得でき、かつnode.specifiedが真の場合です。このgetAttributeNode()が返すnodeはInterface Attrを実装する属性ノードで、そのspecifiedはユーザーが値を設定した場合に真となる、と定義されています(要素がその属性としてデフォルト値を持っていても、ユーザーが値を設定しなければ偽⁠⁠。一方hasAttribute()はその要素がデフォルト値を持っていても真となる、と定義されています。それに従うと、ここではnode.specifiedを使っているのは間違いかと思われます。

1821: Element.Methods.ByTag = {};
1822: 

1821行目では、Element.MEthods.ByTagオブジェクトを用意しています。この中身はElement.addMethods()で詰め込まれ、利用されています。

1823: Object.extend(Element, Element.Methods);
1824: 

ここまでで用意してきたElement.Methods内の拡張用のメソッド群を、Elementクラスに拡張しています。

1825: if (!Prototype.BrowserFeatures.ElementExtensions &&
1826:  document.createElement('div').__proto__) {
1827:   window.HTMLElement = {};
1828:   window.HTMLElement.prototype = document.createElement('div').__proto__;
1829:   Prototype.BrowserFeatures.ElementExtensions = true;
1830: }
1831: 

1825行目からは、window.HTMLElementプロパティが存在しているかどうかを見て、無いようなら作成しています。

div要素の __proto__ としてプロトタイプオブジェクトが存在するようなら、そこに様々なHTMLElementインターフェイスが実装されているはずなので、それをwindow.HTMLElementとして流用します。

1832: Element.hasAttribute = function(element, attribute) {
1833:   if (element.hasAttribute) return element.hasAttribute(attribute);
1834:   return Element.Methods.Simulated.hasAttribute(element, attribute);
1835: };
1836: 

クロスブラウザで使えるhasAttribute()関数です。

Element化した要素は、メソッドとしてhasAttribute()を持っていますが、それ以外の要素にも使えるようにグローバルにElement.hasAttribute()を用意しています。

1837: Element.addMethods = function(methods) {
1838:   var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
1839: 
1840:   if (!methods) {
1841:     Object.extend(Form, Form.Methods);
1842:     Object.extend(Form.Element, Form.Element.Methods);
1843:     Object.extend(Element.Methods.ByTag, {
1844:       "FORM":     Object.clone(Form.Methods),
1845:       "INPUT":    Object.clone(Form.Element.Methods),
1846:       "SELECT":   Object.clone(Form.Element.Methods),
1847:       "TEXTAREA": Object.clone(Form.Element.Methods)
1848:     });
1849:   }
1850: 
1851:   if (arguments.length == 2) {
1852:     var tagName = methods;
1853:     methods = arguments[1];
1854:   }
1855: 
1856:   if (!tagName) Object.extend(Element.Methods, methods || {});
1857:   else {
1858:     if (tagName.constructor == Array) tagName.each(extend);
1859:     else extend(tagName);
1860:   }
1861: 
1862:   function extend(tagName) {
1863:     tagName = tagName.toUpperCase();
1864:     if (!Element.Methods.ByTag[tagName])
1865:       Element.Methods.ByTag[tagName] = {};
1866:     Object.extend(Element.Methods.ByTag[tagName], methods);
1867:   }
1868: 
1869:   function copy(methods, destination, onlyIfAbsent) {
1870:     onlyIfAbsent = onlyIfAbsent || false;
1871:     var cache = Element.extend.cache;
1872:     for (var property in methods) {
1873:       var value = methods[property];
1874:       if (!onlyIfAbsent || !(property in destination))
1875:         destination[property] = cache.findOrStore(value);
1876:     }
1877:   }
1878: 
1879:   function findDOMClass(tagName) {
1880:     var klass;
1881:     var trans = {
1882:       "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
1883:       "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
1884:       "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
1885:       "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
1886:       "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
1887:       "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
1888:       "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
1889:       "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
1890:       "FrameSet", "IFRAME": "IFrame"
1891:     };
1892:     if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
1893:     if (window[klass]) return window[klass];
1894:     klass = 'HTML' + tagName + 'Element';
1895:     if (window[klass]) return window[klass];
1896:     klass = 'HTML' + tagName.capitalize() + 'Element';
1897:     if (window[klass]) return window[klass];
1898: 
1899:     window[klass] = {};
1900:     window[klass].prototype = document.createElement(tagName).__proto__;
1901:     return window[klass];
1902:   }
1903: 
1904:   if (F.ElementExtensions) {
1905:     copy(Element.Methods, HTMLElement.prototype);
1906:     copy(Element.Methods.Simulated, HTMLElement.prototype, true);
1907:   }
1908: 
1909:   if (F.SpecificElementExtensions) {
1910:     for (var tag in Element.Methods.ByTag) {
1911:       var klass = findDOMClass(tag);
1912:       if (typeof klass == "undefined") continue;
1913:       copy(T[tag], klass.prototype);
1914:     }
1915:   }
1916: 
1917:   Object.extend(Element, Element.Methods);
1918:   delete Element.ByTag;
1919: };
1920: 

ちょっと大きめなElement.addMethods()関数です。

$()でElement化される要素に自動的に追加されるメソッドに、自分で作ったものを加えることができます。また、このElement.addMethods()はprototype.js読み込みの最後で引数なしで呼び出され、デフォルトの追加メソッドのセットアップも行います。

まずは関数内で短く記述するために、Prototype.BrowserFeaturesオブジェクトとElement.Methods.ByTagオブジェクトをそれぞれF、Tという変数に代入しておきます。

次に、引数がなにも指定されていなかった場合は、Form, Form.Elementに対してそれぞれ指定されたメソッドを追加します。さらに、Element.Methods.ByTagに<form>, <input>, <select>, <textarea>に対する追加メソッドも加えておきます。

addMethods()は、引数ひとつの場合はすべてのタグを対象とし、引数が二つの場合は特定のタグだけを対象とします。1851行目からにおいて、引数が二つあったときに指定されたタグ名を保存しています。

1856行目で、タグ名が指定されていなければ、Object.extend()を使って、拡張メソッドが格納されているElement.Methodsオブジェクトに指定されたmethodsをマージします。

もしタグ名が指定されているなら、この関数内ローカルの関数extend()を呼び出します。タグ名が配列の場合はそれぞれに対してextend()を呼び出します。

1862行目からは、関数内の関数定義としてextend()が定義されています。タグ名を大文字に揃え、Element.Methods.ByTagがタグ名をキーとするハッシュということになっているので存在していなければ空で初期化し、Object.extend()を使ってタグ名とメソッド定義を含むハッシュ、のペアとして格納しておきます。この時methods変数は、外側のaddMethods()関数内のローカル変数ですが、関数内で定義された関数の中からでも外側の変数を参照できるので、特に引数として渡さなくてもエラーとはなりません。

1869行目からも関数内の関数copy()です。これは1905行目以降で使います。

Element.extend()でも使ったElement.extend.cacheを使い、メモリを無駄に使わないようにしつつ、methodsをdestinationにコピーします。onlyIfAbsentフラグですでにメソッドがあった時に上書きするかしないかを指定しています。

次も関数内関数でfindDOMClass()です。

Firefox、WebKitではwindow.HTMLDivElementなどにHTML要素のコンストラクタとなる関数が入っています。IEではこれらが存在しないので、その場合は(完全に等価なものではありませんが)作成してそれを返します。

DOMで定義されているHTML Elementインターフェイスには、要素名と一致しない名前が多々存在するので、その対応表となるハッシュをtransとして用意しています。

その対応表に存在するタグで、window直下にその名前のプロパティが存在すればそれを返します。次は大文字となっているタグ名を使って"HTMLDIVElement"などの文字列を作り、それがwindowのプロパティに存在するかどうかを確かめます。

それでもダメならタグ名の部分の先頭だけ大文字にした形"HTMLDivElement"等で試します。

それでも見つからなければ、window直下にその名前のオブジェクトを作ってしまい、要素を一旦作成してそのプロトタイプを拾って代入しておきます。一般にHTMLElementなどはコンストラクタとなるべき関数オブジェクトが適切かと思われるので、ここは {} という空オブジェクトではなく function(){} のような空関数オブジェクトの方が良さそうです。

ということで、このfindDOMClass()は、タグ名を渡されると、⁠適切なprototypeプロパティを持つ)そのコンストラクタを返す、という関数になります。

1904行目からまたaddMethods()のメインの処理に戻ります。実行中のブラウザにwindow.HTMLElementプロパティが存在していたなら、そのHTMLElementのprototypeに、Element.Methodsをコピーしておきます。Element.Methods.Simulatedの方は、HTMLElementに関数が存在しなければ追加しています。

1909行目からは、SpecificElementExtensionsが真の時に実行されます。このフラグは <div>, <form> のプロトタイプが異なるときに真になります。ということは、HTMLDivElement, HTMLFormElementでそれぞれ異なるプロトタイプオブジェクトを持つ、ということなので、様々な要素型ごとに独自のメソッド群を実装している、と推測できます。

Element.Methods.ByTagで指定されたタグそれぞれについて、先ほど定義したfindDOMClass()でDOM HTMLインターフェイスを取得し、もし存在すればそのprototypeにElement.Methods.ByTagで指定された関数オブジェクトをコピーします。

後は、再度ElementをElement.Methodsで拡張しなおして終了です。1823行目で既にElementに追加していますが、この関数内でElement.Methodsが変更されている場合があるので再度拡張しています。

また、1910行目の Element.Methods.ByTagは、せっかくTに代入してあるのでそれを使う方が短く記述できます。

最後の delete Element.ByTagは、今のところ参照されていない変数のようですが、なぜかdeleteしています。Ticket #7888で指摘された問題に対して、Changeset 6561で変更された部分ですが、これらを見てもやはり理由はわかりません。

1921: var Toggle = { display: Element.toggle };
1922: 
1923: /*--------------------------------------------------------------------------*/
1924: 

Toggleオブジェクトを定義していますが、今のところ公式ドキュメントにも載っていませんし、他から参照されているわけでもないようです。

Abstract.Insertion オブジェクト

1925: Abstract.Insertion = function(adjacency) {
1926:   this.adjacency = adjacency;
1927: }
1928: 

Abstract.Insertionオブジェクトのコンストラクタです。

adjacencyには、"beforeBegin", "afterBegin", "beforeEnd", "afterEnd"が指定され、後ほどinsertAdjacentHTML()に渡されます。

1929: Abstract.Insertion.prototype = {
1930:   initialize: function(element, content) {
1931:     this.element = $(element);
1932:     this.content = content.stripScripts();
1933: 
1934:     if (this.adjacency && this.element.insertAdjacentHTML) {
1935:       try {
1936:         this.element.insertAdjacentHTML(this.adjacency, this.content);
1937:       } catch (e) {
1938:         var tagName = this.element.tagName.toUpperCase();
1939:         if (['TBODY', 'TR'].include(tagName)) {
1940:           this.insertContent(this.contentFromAnonymousTable());
1941:         } else {
1942:           throw e;
1943:         }
1944:       }
1945:     } else {
1946:       this.range = this.element.ownerDocument.createRange();
1947:       if (this.initializeRange) this.initializeRange();
1948:       this.insertContent([this.range.createContextualFragment(this.content)]);
1949:     }
1950: 
1951:     setTimeout(function() {content.evalScripts()}, 10);
1952:   },
1953: 
1954:   contentFromAnonymousTable: function() {
1955:     var div = document.createElement('div');
1956:     div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
1957:     return $A(div.childNodes[0].childNodes[0].childNodes);
1958:   }
1959: }
1960: 

Abstract.Insertionのprototypeです。

具体的なInsertion.Before などの prototype を構築する際に、

Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), { ... }

のような形を取ります。new Abstract.Insertion()から返されるメモリ上のインスタンスオブジェクトには、prototypeプロパティとしてAbstract.Insertion.prototypeを持つことになります。これをベースに、Insertion.Beforeならそれ独自のプロパティ・メソッドを{ ... }に加えていくことになります。

よって、1930行目からが各Insertion.*クラスで共有されるコンストラクタとなります。

Insertion.Beforeなどのクラスは、利用時にはnew Insertion.Beforeとnewを使うことで動作します。コンストラクタでは、adjacency引数が指定されていて、elementにinsertAdjacentHTMLプロパティとしてメソッドが存在する(IE, Opera)かどうかを見ています。

もし偽の場合、insertAdjacentHTML()のように細かく位置を指定することができません。まずcreateRange(), createContextualFragment()を使ってコンテキストに合ったDOMツリーフラグメントを作成します。それをinsertContent()に渡して実際に挿入します。insertContent()はBefore, Top, Bottom, After各クラスで上書き定義されており、その中で状況に合った位置に挿入するようになっています。

insertAdjacentHTML()が使える場合はそれをtry {}し、もし失敗したらタグがテーブル関係かどうかを調べます。IE では<tbody>, <tr>などの中途半端なDOMツリーは構築できないので、その場合はcontentFromAnonymousTable()を使って、空のテーブルを作ってそこに渡されたHTMLを流し込んだ状態でDOMツリー化する、という手順を踏みます。

最後に、<script>タグ部分を非同期に実行して終了です。

1954行目からは、先ほどコンストラクタで呼び出されたcontentFromAnonymousTable()です。

IEでは<td>, <th>タグを頂点とするDOMツリー生成ができないので、いったん外側のテーブルタグ文字列で囲った文字列を作り、それをダミーの<div>のinnerHTMLプロパティに流し込んで、その後奥に入っている<td>, <th>部分のDOMツリーを取り出して返す、ということをしています。

1961: var Insertion = new Object();
1962: 

Insertion.*クラス用の入れ物として、Insertionオブジェクトを用意しています。この下にBefore, Top, Bottom, Afterが入ります。

Insertion.Before クラス

1963: Insertion.Before = Class.create();
1964: Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
1965:   initializeRange: function() {
1966:     this.range.setStartBefore(this.element);
1967:   },
1968: 
1969:   insertContent: function(fragments) {
1970:     fragments.each((function(fragment) {
1971:       this.element.parentNode.insertBefore(fragment, this.element);
1972:     }).bind(this));
1973:   }
1974: });
1975: 

1963行目からは Insertion.Beforeクラスです。Class.create()した後で、前述のとおりAbstract.Insertionをnewしたものに、Insertion.Before独自の拡張をObject.extend()して、Insertion.Before.prototypeに入れています。

Insertion.* 各クラスで拡張しているのは、insertAdjacentHTML()が使えないときに、コンストラクタから呼び出されるinitializeRange()とinsertContent()というメソッドになります。

initializeRange()は、this.rangeにcreateRange()したものが入っている前提で、HTML文字列をDOMツリー化する際のコンテキストを設定します。

Insertion.Beforeの場合、渡されたelementの直前に挿入されるのでrange.setStartBefore()を使います。

1969行目からのinsertContent()では、渡された文書フラグメントを、element.parentNode.insertBefore()を使ってelementの直前に流し込んでいます。

Insertion.Top クラス

1976: Insertion.Top = Class.create();
1977: Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
1978:   initializeRange: function() {
1979:     this.range.selectNodeContents(this.element);
1980:     this.range.collapse(true);
1981:   },
1982: 
1983:   insertContent: function(fragments) {
1984:     fragments.reverse(false).each((function(fragment) {
1985:       this.element.insertBefore(fragment, this.element.firstChild);
1986:     }).bind(this));
1987:   }
1988: });
1989: 

1976行目からはInsertion.Topです。

基本的な構造はInsertion.Beforeと同じで、Abstract.Insertionコンストラクタに渡す文字列が'afterBegin'となっています。

initializeRange()では、selectNodeContents()でelement全体を示す範囲を作り、collapse(true) ⁠trueは先頭側に縮める)でelementの直前を指すようにします。

insertContent()の方は、受け取ったfragmentsをreverse(false)でコピーしつつ逆順に並び替え、それぞれに対してinsertBefore(element.firstChild)してelementの直前にひとつずつ入れていきます。ひとつずつinsertBefore()しているので、reverse()しておかないと、HTML文字列から作ったDOMツリーの配列が逆順に現れてしまいます。

Insertion.Bottomクラス

1990: Insertion.Bottom = Class.create();
1991: Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
1992:   initializeRange: function() {
1993:     this.range.selectNodeContents(this.element);
1994:     this.range.collapse(this.element);
1995:   },
1996: 
1997:   insertContent: function(fragments) {
1998:     fragments.each((function(fragment) {
1999:       this.element.appendChild(fragment);
2000:     }).bind(this));
2001:   }
2002: });
2003: 

1990行目からはInsertion.Bottomです。

initializeRange()はInsertion.Topとほぼ同様で、collapse()へのパラメータがthis.elementとなっています。ここはfalseで後ろ側へ縮める、ということになっているので、falseであるべきでしょう(prototype.jsのtrunkではInsertionまわりがごっそり置き換わっているので、最新版ではすでのこの部分のコードは存在しません⁠⁠。

insertContent()では、fragmentsそれぞれをappendChild()してやるだけ、という簡単なもので済んでいます。

Insertion.After クラス

2004: Insertion.After = Class.create();
2005: Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
2006:   initializeRange: function() {
2007:     this.range.setStartAfter(this.element);
2008:   },
2009: 
2010:   insertContent: function(fragments) {
2011:     fragments.each((function(fragment) {
2012:       this.element.parentNode.insertBefore(fragment,
2013:         this.element.nextSibling);
2014:     }).bind(this));
2015:   }
2016: });
2017: 
2018: /*--------------------------------------------------------------------------*/
2019: 

2004行目からはInsertion.Afterです。

initializeRange()では、rangeに対してsetStartAfter()を呼んでいます。

insertContent()では、fragmentsそれぞれに対して、parentNode.insertBefore(element.nextSibling)を呼び出すことで、elementの後ろに挿入されるようになっています。

elementのnextSiblingが存在しない場合、insertBefore()にnullを渡すことになりますが、その場合も子供ノードの最後に挿入されることになっています。

Element.ClassNames

2020: Element.ClassNames = Class.create();

ある要素が持つ、複数になりうるクラス名をEnumerableとして抽象化するためのクラスです。いつもどおりClass.create()した上でprototypeを拡張しています。

2021: Element.ClassNames.prototype = {
2022:   initialize: function(element) {
2023:     this.element = $(element);
2024:   },
2025: 

コンストラクタです。渡されたelementをthis.elementに保存しているだけです。

2026:   _each: function(iterator) {
2027:     this.element.className.split(/\s+/).select(function(name) {
2028:       return name.length > 0;
2029:     })._each(iterator);
2030:   },
2031: 

Enumerable.each()から呼び出される_each()メソッドです。要素のclassNameプロパティを、空白文字でsplit()して、長さがあるものだけをselect()で抽出しています。

これにより、Enumerable.each()を使うと、要素中の各クラス指定ごとにイテレータ関数が実行されることになります。

2032:   set: function(className) {
2033:     this.element.className = className;
2034:   },
2035: 

2032行目からはset()です。これは単に指定された文字列をclassNameプロパティにセットします。事前にクラスが指定されていたとしても、この指定ですべて上書きされます。

2036:   add: function(classNameToAdd) {
2037:     if (this.include(classNameToAdd)) return;
2038:     this.set($A(this).concat(classNameToAdd).join(' '));
2039:   },
2040: 

add()メソッドでは、すでに指定されたクラスが要素に含まれている場合には何もせずに帰ります。

$A(this)すると Enumerable.toArray()が呼ばれ、map()経由でeach()が呼ばれるので、結果としてクラス指定の文字列を空白文字でsplit()した配列になります。これにconcat()した結果を最後にjoin(' ')して、単一のクラス指定文字列に変換します。それをset()でclassNameプロパティに設定して終了です。

2041:   remove: function(classNameToRemove) {
2042:     if (!this.include(classNameToRemove)) return;
2043:     this.set($A(this).without(classNameToRemove).join(' '));
2044:   },
2045: 

2041行目からはremove()メソッドです。

this.include()を使って、指定されたクラス名が自分に含まれていなければそのまま帰ります。

含まれていれば、$A(this)で配列化したものにwithout()で指定されたクラス以外を集めて、join(' ')したものをset()で上書きしています。

2046:   toString: function() {
2047:     return $A(this).join(' ');
2048:   }
2049: };
2050: 

toString()では、配列化したものをjoin(' ')で繋げて返しています。element.classNameをそのまま返してもいいような気がしますが、この方が余計な空白などが取り除かれた形に正規化されるので、そういう理由かもしれません。

2051: Object.extend(Element.ClassNames.prototype, Enumerable);

最後にElement.ClassNamesのprototypeにEnumerableを拡張してElement.ClassNamesは完成です。

おすすめ記事

記事・ニュース一覧