# Japanese translations for PACKAGE package.
# Copyright (C) 2011 THE PACKAGE'S COPYRIGHT HOLDER
# This file is distributed under the same license as the PACKAGE package.
#  <yamada@clear-code.com>, 2011.
#
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2011-11-20 22:17+0900\n"
"PO-Revision-Date: 2012-06-20 16:56+0900\n"
"Last-Translator:  <yamada@clear-code.com>\n"
"Language-Team: Japanese\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../README.md:1
msgid ""
"YARD: Yay! A Ruby Documentation Tool\n"
"===================================="
msgstr ""
"YARD: Yay! A Ruby Documentation Tool\n"
"===================================="

#: ../README.md:4
msgid ""
"**Homepage**:     [http://yardoc.org](http://yardoc.org)   \n"
"**IRC**:          [irc.freenode.net / #yard](irc://irc.freenode.net/"
"yard)    \n"
"**Git**:          [http://github.com/lsegal/yard](http://github.com/lsegal/"
"yard)   \n"
"**Author**:       Loren Segal  \n"
"**Contributors**: See Contributors section below    \n"
"**Copyright**:    2007-2012    \n"
"**License**:      MIT License    \n"
"**Latest Version**: 0.8.2.1 (codename \"Shave It\")    \n"
"**Release Date**: June 10th 2012"
msgstr ""
"**Homepage**:     [http://yardoc.org](http://yardoc.org)   \n"
"**IRC**:          [irc.freenode.net / #yard](irc://irc.freenode.net/yard)    \n"
"**Git**:          [http://github.com/lsegal/yard](http://github.com/lsegal/yard)   \n"
"**Author**:       Loren Segal  \n"
"**Contributors**: See Contributors section below    \n"
"**Copyright**:    2007-2012    \n"
"**License**:      MIT License    \n"
"**Latest Version**: 0.8.2.1 (codename \"Shave It\")    \n"
"**Release Date**: June 10th 2012"

#: ../README.md:14
msgid ""
"Synopsis\n"
"--------"
msgstr ""
"概要\n"
"--------"

#: ../README.md:17
msgid ""
"YARD is a documentation generation tool for the Ruby programming language.\n"
"It enables the user to generate consistent, usable documentation that can "
"be\n"
"exported to a number of formats very easily, and also supports extending "
"for\n"
"custom Ruby constructs such as custom class level definitions. Below is a\n"
"summary of some of YARD's notable features."
msgstr ""
"YARDはプログミング言語Rubyのドキュメント生成ツールである。\n"
"ユーザーが一貫性のあるドキュメント作成を可能にし、\n"
"いくつかの書式へ簡単にエキスポートできる。\n"
"又、カスタム定義によってRubyのカスタム構文用に\n"
"拡張することをサポートもする。\n"
"下はYARDの著名な機能の要約となる。"

#: ../README.md:24
msgid ""
"Feature List\n"
"------------"
msgstr ""
"機能リスト\n"
"------------"

#: ../README.md:27
msgid ""
"**1. RDoc/SimpleMarkup Formatting Compatibility**: YARD is made to be "
"compatible\n"
"with RDoc formatting. In fact, YARD does no processing on RDoc "
"documentation\n"
"strings, and leaves this up to the output generation tool to decide how to\n"
"render the documentation."
msgstr ""
"** 1. RDoc/SimpleMarkup書式との両立**: YARDはRDocの書式と両立する。\n"
"実際には、YARDはRDocドキュメント文字列の処理を行わない。\n"
"それは、後でドキュメント作成を表示する方法を選択する為、\n"
"その文字列を残している。"

#: ../README.md:32
msgid ""
"**2. Yardoc Meta-tag Formatting Like Python, Java, Objective-C and other "
"languages**:\n"
"YARD uses a '@tag' style definition syntax for meta tags alongside  regular "
"code\n"
"documentation. These tags should be able to happily sit side by side RDoc "
"formatted\n"
"documentation, but provide a much more consistent and usable way to "
"describe\n"
"important information about objects, such as what parameters they take and "
"what types\n"
"they are expected to be, what type a method should return, what exceptions "
"it can\n"
"raise, if it is deprecated, etc.. It also allows information to be better "
"(and more\n"
"consistently) organized during the output generation phase. You can find a "
"list\n"
"of tags in the {file:docs/Tags.md#taglist Tags.md} file."
msgstr ""
"** 2. Python, Java, Objective-Cや他の言語のようなYardocのメタタグフォーマット **:\n"
"YARDは通常のコードのドキュメントの側にメタタグ用の'@tag'スタイルの定義構文を使う\n"
"これらのタグは幸いなことにRDoc形式にフォーマットされたドキュメントと並んで配置する事ができる\n"
"しかしオブジェクトについて重要な情報を提供する為に更に一貫して便利な方法を提供する。\n"
"それらの何らかのパラメーターとそれらの何らかの期待される型を取得するには、\n"
"どの型のメソッドを返さなければならないか、\n"
"どの例外を上げることができるか、\n"
"もしそれが重複した場合は,, etc..\n"
"それは出力生成段階の間によりよく(そして一貫して)整理された情報を受け入れる\n"
"{file:docs/Tags.md#taglist Tags.md} ファイルでタグのリストについて紹介している。"

#: ../README.md:42
msgid ""
"YARD also supports an optional \"types\" declarations for certain tags.\n"
"This allows the developer to document type signatures for ruby methods and\n"
"parameters in a non intrusive but helpful and consistent manner. Instead of\n"
"describing this data in the body of the description, a developer may "
"formally\n"
"declare the parameter or return type(s) in a single line. Consider the\n"
"following method documented with YARD formatting:"
msgstr ""
"YARDは特定のタグを用い省略可能な\"型\"の宣言をサポートもする。\n"
"これにより開発者はRubyメソッド用や、\n"
"煩わしくなく、しかし役に立つパラメータや、\n"
"一貫性のある形式を型の用法として記述可能になる。\n"
"説明の中にこのデータを記述する代わりに、\n"
"開発者は、1つの行の中でパラメータやリターンタイプを形式的に宣言できる。\n"
"YARDの書式を使用した次のメソッドの記述を考えてみる。"

#: ../README.md:49
msgid ""
"     # Reverses the contents of a String or IO object.\n"
"     #\n"
"     # @param [String, #read] contents the contents to reverse\n"
"     # @return [String] the contents reversed lexically\n"
"     def reverse(contents)\n"
"       contents = contents.read if respond_to? :read\n"
"       contents.reverse\n"
"     end"
msgstr ""
"     # 文字列やIOオブジェクトの内容を逆にする\n"
"     #\n"
"     # @param [String, #read] 逆にするためのコンテンツを入れる\n"
"     # @return [String] 逆になった単語のコンテンツ\n"
"     def reverse(contents)\n"
"       contents = contents.read if respond_to? :read\n"
"       contents.reverse\n"
"     end"

#: ../README.md:58
msgid ""
"With the above @param tag, we learn that the contents parameter can either "
"be\n"
"a String or any object that responds to the 'read' method, which is more\n"
"powerful than the textual description, which says it should be an IO "
"object.\n"
"This also informs the developer that they should expect to receive a String\n"
"object returned by the method, and although this may be obvious for a\n"
"'reverse' method, it becomes very useful when the method name may not be as\n"
"descriptive."
msgstr ""
"上記の@paramタグによって、contentsのパラメータが\n"
"Stringまたは何らかのオブジェクトのいずれかを\n"
"'read'メソッドに返すことが分かる。\n"
"それは原文の説明よりももっと強力な\n"
"IOオブジェクトになると言える。\n"
"これは開発者達がメソッドによって返された、\n"
"Stringオブジェクトを受け取ることを期待することや、\n"
"この場合は\"reverse\"メソッドの目的が明らかとはいえ、\n"
"メソッド名が説明を含んでいない時にとても便利という事を\n"
"意味している。"

#: ../README.md:66
msgid ""
"**3. Custom Constructs and Extensibility of YARD**: YARD is designed to be\n"
"extended and customized by plugins. Take for instance the scenario where "
"you\n"
"need to document the following code:"
msgstr ""
"** 3. YARDのカスタムコンストラクタと拡張性 **: YARDは\n"
"プラグインによって拡張やカスタマイズする為に設計されている。\n"
"例えばあなたが次のコードのドキュメントの場所を必要とするシナリオを考える。"

#: ../README.md:70
msgid ""
"    class List\n"
"      # Sets the publisher name for the list.\n"
"      cattr_accessor :publisher\n"
"    end"
msgstr ""
"    class List\n"
"      # リスト用の発行者名を設定する\n"
"      cattr_accessor :publisher\n"
"    end"

#: ../README.md:75
msgid ""
"This custom declaration provides dynamically generated code that is hard for "
"a\n"
"documentation tool to properly document without help from the developer. To\n"
"ease the pains of manually documenting the procedure, YARD can be extended "
"by\n"
"the developer to handle the `cattr_accessor` construct and automatically "
"create\n"
"an attribute on the class with the associated documentation. This makes\n"
"documenting external API's, especially dynamic ones, a lot more consistent "
"for\n"
"consumption by the users."
msgstr ""
"このカスタム宣言は動的に生成されるコードを提供する。\n"
"それは開発者からの助けなしで正確なドキュメントを\n"
"ドキュメント作成ツールで作るのが困難な為である。\n"
"手書きでドキュメント作成する苦労が楽になるように、\n"
"YARDは `cattr_accessor` コンストラクタを操作する。\n"
"又、関連するドキュメントとクラスの属性を自動的に生成するように、\n"
"開発者によって拡張できる。\n"
"この拡張によって、ユーザーによって使用する多くの一貫性のある動的な\n"
"ドキュメント作成の外部のAPIを作れる。"

#: ../README.md:83
msgid ""
"YARD is also designed for extensibility everywhere else, allowing you to "
"add\n"
"support for new programming languages, new data structures and even where/"
"how\n"
"data is stored."
msgstr ""
"YARDはどこでも拡張できるように設計されている。\n"
"新しいプログラム言語や新しいデータ構造や\n"
"どこにどのようにデータを格納するかといったサポートを追加できる。"

#: ../README.md:87
msgid ""
"**4. Raw Data Output**: YARD also outputs documented objects as raw data "
"(the\n"
"dumped Namespace) which can be reloaded to do generation at a later date, "
"or\n"
"even auditing on code. This means that any developer can use the raw data "
"to\n"
"perform output generation for any custom format, such as YAML, for "
"instance.\n"
"While YARD plans to support XHTML style documentation output as well as\n"
"command line (text based) and possibly XML, this may still be useful for "
"those\n"
"who would like to reap the benefits of YARD's processing in other forms, "
"such\n"
"as throwing all the documentation into a database. Another useful way of\n"
"exploiting this raw data format would be to write tools that can auto "
"generate\n"
"test cases, for example, or show possible unhandled exceptions in code."
msgstr ""
"**4. 未加工データの出力**: YARDはオブジェクトのドキュメントを未加工のままデー"
"タ(ダンプした名前空間)出力する。後で生成する時や、コードを等しく調査する時は"
"再ロードされる。\n"
"つまり、開発者の誰もが何らかのカスタム書式のように出力生成を実行する為に、未"
"加工データを使う。例えば、YAMLのように。\n"
"YARDはXHTMLスタイルドキュメント出力もコマンドライン(テキストベース)も\n"
"(もしかしたらXMLも)サポートを計画しているので、\n"
"全てのドキュメントをデータベースへ投げておけば、\n"
"将来、他の型でもYARDの処理の恩恵を受けようと考えている人にとっては、\n"
"役立つかもしれない。\n"
"この未加工データの書式を利用する他の有用な方法として、\n"
"自動生成テストケースができるツールを書く為や、\n"
"コードの未処理例外を明らかにすること、などがある。"

#: ../README.md:98
msgid ""
"**5. Local Documentation Server**: YARD can serve documentation for "
"projects\n"
"or installed gems (similar to `gem server`) with the added benefit of "
"dynamic\n"
"searching, as well as live reloading. Using the live reload feature, you "
"can\n"
"document your code and immediately preview the results by refreshing the "
"page;\n"
"YARD will do all the work in re-generating the HTML. This makes writing\n"
"documentation a much faster process."
msgstr ""
"**5. ローカルドキュメントサーバー**:\n"
"YARDは動的な検索も再ロードの利点も用い\n"
"プロジェクトやインストール済みのgem( `gem server` と同様)用のドキュメント作成を提供する。\n"
"live reload機能によって,あなたのコードを記述したり\n"
"ページをリフレーシュする事によって結果をすぐにプレビューできる\n"
"YARDはHTML再生成の全ての仕事をする\n"
"これによりドキュメントの作成をより高速のプロセスで行える。"

#: ../README.md:106
msgid "## Installing"
msgstr "## インストール"

#: ../README.md:108
msgid "To install YARD, use the following command:"
msgstr "YARDをインストールする為に次のコマンドを使う。"

#: ../README.md:110
msgid "    $ gem install yard"
msgstr "    $ gem install yard"

#: ../README.md:112
msgid "(Add `sudo` if you're installing under a POSIX system as root)"
msgstr ""
"(もしPOSIXシステムのルート下でインストールしている場合、sudoを追加する)"

#: ../README.md:114
msgid ""
"Alternatively, if you've checked the source out directly, you can call\n"
"`rake install` from the root project directory."
msgstr ""
"上のコマンドの代わりに、もしソースを直接チェックアウトしたならば、\n"
"あなたはプロジェクトのルートディレクトリから `rake install` を行う事ができる"

#: ../README.md:117
msgid ""
"**Important Note for Debian/Ubuntu users:** there's a possible chance your "
"Ruby\n"
"install lacks RDoc, which is occasionally used by YARD to convert markup to "
"HTML.\n"
"If running `which rdoc` turns up empty, install RDoc by issuing:"
msgstr ""
"**Debian/Ubuntuユーザーへの重要な注意:**\n"
"RubyがRDocなしでinstallされる可能性がある。\n"
"RDocはYARDによってマークアップをHTMLに変換する為に時々使われるので、\n"
"もし `which rdoc` コマンドでパスが存在しない場合は、次のコマンドでRDocをインストールする。"

#: ../README.md:121
msgid "    $ sudo apt-get install rdoc"
msgstr "    $ sudo apt-get install rdoc"

# YARD::CLI::Yardoc
#: ../README.md:124
msgid "## Usage"
msgstr "## 使用法"

#: ../README.md:126
msgid ""
"There are a couple of ways to use YARD. The first is via command-line, and "
"the\n"
"second is the Rake task."
msgstr ""
"それらYARDを使うにはいくつかの方法がある。\n"
"最初はコマンドライン経由で、もうひとつはRake taskという方法がある。"

#: ../README.md:129
msgid "**1. yard Command-line Tool**"
msgstr "**1. yardのコマンドラインツール**"

#: ../README.md:131
msgid ""
"YARD comes packaged with a executable named `yard` which can control the "
"many\n"
"functions of YARD, including generating documentation, graphs running the\n"
"YARD server, and so on. To view a list of available YARD commands, type:"
msgstr ""
"YARDは実行可能な `yard` という名前と一緒にパッケージが入っている。\n"
"ドキュメントの生成や、グラフ、YARDサーバーを起動などを含み\n"
"たくさんの機能を制御できる。\n"
"利用可能なYARDのコマンドの一覧を表示するには、以下をタイプする。"

#: ../README.md:135
msgid "    $ yard --help"
msgstr "    $ yard --help"

#: ../README.md:137
msgid ""
"Plugins can also add commands to the `yard` executable to provide extra\n"
"functionality."
msgstr "プラグインは追加の機能を提供する為に実行可能な `yard` コマンドを追加できる。"

#: ../README.md:140
msgid "### Generating Documentation"
msgstr "### ドキュメントを生成する"

#: ../README.md:142
msgid ""
"<span class=\"note\">The `yardoc` executable is a shortcut for `yard doc`.</"
"span>"
msgstr "<span class=\"note\">The `yardoc` executable is a shortcut for `yard doc`.</span>"

#: ../README.md:144
msgid ""
"The most common command you will probably use is `yard doc`, or `yardoc`. "
"You\n"
"can type `yardoc --help` to see the options that YARD provides, but the\n"
"easiest way to generate docs for your code is to simply type `yardoc` in "
"your\n"
"project root. This will assume your files are\n"
"located in the `lib/` directory. If they are located elsewhere, you can "
"specify\n"
"paths and globs from the commandline via:"
msgstr ""
"恐らく最も使用される一般的なコマンドは `yard doc` 、または `yardoc` となるだろう。\n"
"YARDが提供するオプションを見るには `yardoc --help` をタイプする事で表示できる。\n"
"でも、ドキュメントを生成するのに最も簡単な方法は、\n"
"あなたのプロジェクトのルートで `yardoc` をタイプする方法である。\n"
"これはあなたのファイルが `lib/` ディレクトリの中で示されるとみなす。\n"
"もし他の場所にあるなら、次のようにコマンドラインからパスとglobを指定する:"

#: ../README.md:151
msgid "    $ yardoc 'lib/**/*.rb' 'app/**/*.rb' ...etc..."
msgstr "    $ yardoc 'lib/**/*.rb' 'app/**/*.rb' ...etc..."

#: ../README.md:153
msgid ""
"The tool will generate a `.yardoc` file which will store the cached "
"database\n"
"of your source code and documentation. If you want to re-generate your docs\n"
"with another template you can simply use the `--use-cache` (or -c)\n"
"option to speed up the generation process by skipping source parsing."
msgstr ""
"このツールは `.yardoc` ファイルを生成する。それは\n"
"あなたのソースコードとドキュメントをキャッシュしたデータベースを格納する。\n"
"もしあなたが他のテンプレートと共にドキュメントを再生成したいなら、\n"
"単に `--use-cache` (or -c) オプションを使えばよい。\n"
"ソースの解析をスキップする事によって生成プロセスをスピードアップする。"

#: ../README.md:158
msgid ""
"YARD will by default only document code in your public visibility. You can\n"
"document your protected and private code by adding `--protected` or\n"
"`--private` to the option switches. In addition, you can add `--no-private`\n"
"to also ignore any object that has the `@private` meta-tag. This is similar\n"
"to RDoc's \":nodoc:\" behaviour, though the distinction is important. RDoc\n"
"implies that the object with :nodoc: would not be documented, whereas\n"
"YARD still recommends documenting private objects for the private API (for\n"
"maintainer/developer consumption)."
msgstr ""
"YARDはデフォルトでpublicな可視性の中のコードだけを記述する。\n"
"`--protected` や `--private` オプション引数の追加によって\n"
"protectedとprivateなコードを記録できる。\n"
"さらに、 `--no-private` の追加によって、\n"
"`@private` メタタグを持った何らかのオブジェクトの無視もできる。\n"
"区別は重要であるものの、これはRDocの\":nodoc:\"の挙動と似ている。\n"
"RDocはオブジェクトと共に:nodoc:は記録されないことを暗示する。\n"
"ところが、YARDは今もなおprivate APIの為に\n"
"privateなオブジェクトのドキュメント作成を\n"
"推奨する。(メンテナーや開発者が利用する為に)"

#: ../README.md:167
msgid ""
"You can also add extra informative files (README, LICENSE) by separating\n"
"the globs and the filenames with '-'."
msgstr ""
"globとファイル名と共に'-'で区切ることによって、\n"
"追加の情報ファイル(README, LICENSE)を追加もできる。"

#: ../README.md:170
msgid "    $ yardoc 'app/**/*.rb' - README LICENSE FAQ"
msgstr "    $ yardoc 'app/**/*.rb' - README LICENSE FAQ"

#: ../README.md:172
msgid ""
"If no globs precede the '-' argument, the default glob (`lib/**/*.rb`) is\n"
"used:"
msgstr "もしglob無しで、'-'引数が先行する場合、デフォルトのglobは( `lib/**/*.rb` )を使う。"

#: ../README.md:175
msgid "    $ yardoc - README LICENSE FAQ"
msgstr "    $ yardoc - README LICENSE FAQ"

#: ../README.md:177
msgid ""
"Note that the README file can be specified with its own `--readme` switch."
msgstr ""
"次の事に留意する。READMEファイルは自身の`--readme`引数と共に指定される。"

#: ../README.md:179
msgid ""
"You can also add a `.yardopts` file to your project directory which lists\n"
"the switches separated by whitespace (newlines or space) to pass to yardoc\n"
"whenever it is run. A full overview of the `.yardopts` file can be found in\n"
"{YARD::CLI::Yardoc}."
msgstr ""
"あなたはあなたのプロジェクトディレクトリに `.yardopts` を追加することもできる。\n"
"これは起動する時に毎回、スペースによって区切られた引数のリストをyardocに渡す。\n"
" `.yardopts` ファイルの全ての概要は、 {YARD::CLI::Yardoc} で見つけることができる。"

#: ../README.md:184
msgid "### Queries"
msgstr "### クエリー"

#: ../README.md:186
msgid ""
"The `yardoc` tool also supports a `--query` argument to only include "
"objects\n"
"that match a certain data or meta-data query. The query syntax is Ruby, "
"though\n"
"a few shortcuts are available. For instance, to document only objects that "
"have\n"
"an \"@api\" tag with the value \"public\", all of the following syntaxes "
"would give\n"
"the same result:"
msgstr ""
"`yardoc` ツールは、 `--query` 引数をサポートもする。\n"
"これはマッチするいくらかのデータやメタデータクエリーのオブジェクトだけ含んでいる。\n"
"クエリーの構文はRubyで、いくつかのショートカットが利用可能。\n"
"例えば、\"@api\"タグと\"public\"な値を持つオブジェクトだけを記述するには、\n"
"次のようになる。(全て同じ結果となる。)"

#: ../README.md:192
msgid ""
"    --query '@api.text == \"public\"'\n"
"    --query 'object.has_tag?(:api) && object.tag(:api).text == \"public\"'\n"
"    --query 'has_tag?(:api) && tag(:api).text == \"public\"'"
msgstr ""
"    --query '@api.text == \"public\"'\n"
"    --query 'object.has_tag?(:api) && object.tag(:api).text == \"public\"'\n"
"    --query 'has_tag?(:api) && tag(:api).text == \"public\"'"

#: ../README.md:196
msgid ""
"Note that the \"@tag\" syntax returns the first tag named \"tag\" on the "
"object.\n"
"To return the array of all tags named \"tag\", use \"@@tag\"."
msgstr ""
"次の事に留意する。\n"
"\"@tag\"構文は、オブジェクトの最初に\"tag\"と名付けられたタグを返す。\n"
"全ての\"tag\"と名付けたタグの配列を返すには、\"@@tag\"を使う。"

#: ../README.md:199
msgid ""
"Multiple `--query` arguments are allowed in the command line parameters. "
"The\n"
"following two lines both check for the existence of a return and param tag:"
msgstr ""
"複数の`--query`引数はコマンドライン引数の中で許可される。\n"
"次の2行は両方とも実際の返り値とparamタグをチェックする。"

#: ../README.md:202
msgid ""
"    --query '@return' --query '@param'\n"
"    --query '@return && @param'"
msgstr ""
"    --query '@return' --query '@param'\n"
"    --query '@return && @param'"

#: ../README.md:205
msgid ""
"For more information about the query syntax, see the {YARD::Verifier} class."
msgstr "さらなるquery構文の情報については、 {YARD::Verifier} クラスを参照する。"

#: ../README.md:207
msgid "**2. Rake Task**"
msgstr "**2. Rake Task**"

#: ../README.md:209
msgid ""
"The second most obvious is to generate docs via a Rake task. You can do this "
"by\n"
"adding the following to your `Rakefile`:"
msgstr ""
"もう一つの方法として、Rakeのタスクを介してドキュメントを生成する。\n"
"あなたの `Rakefile` に次の内容を追加することによって作成できる:"

#: ../README.md:212
msgid ""
"    YARD::Rake::YardocTask.new do |t|\n"
"      t.files   = ['lib/**/*.rb', OTHER_PATHS]   # optional\n"
"      t.options = ['--any', '--extra', '--opts'] # optional\n"
"    end"
msgstr ""
"    YARD::Rake::YardocTask.new do |t|\n"
"      t.files   = ['lib/**/*.rb', OTHER_PATHS]   # optional\n"
"      t.options = ['--any', '--extra', '--opts'] # optional\n"
"    end"

#: ../README.md:217
msgid ""
"both the `files` and `options` settings are optional. `files` will default "
"to\n"
"`lib/**/*.rb` and `options` will represents any options you might want\n"
"to add. Again, a full list of options is available by typing `yardoc --"
"help`\n"
"in a shell. You can also override the options at the Rake command-line with "
"the\n"
"OPTS environment variable:"
msgstr ""
"`files` も `options` の設定も、省略可能。\n"
"`files` は `lib/**/*.rb` にデフォルトで設定される、\n"
"そして `options` は追加したいオプションを表している。\n"
"さらに、オプションの全てのリストは、\n"
"シェルで `yardoc --help` を\n"
"タイプすることによって利用可能。又、\n"
"RakeコマンドラインとOPTS環境変数でoptionsを上書きできる。"

#: ../README.md:223
msgid "    $ rake yard OPTS='--any --extra --opts'"
msgstr "    $ rake yard OPTS='--any --extra --opts'"

#: ../README.md:225
msgid "**3. `yri` RI Implementation**"
msgstr "**3. `yri` RIの実装**"

#: ../README.md:227
msgid ""
"The yri binary will use the cached .yardoc database to give you quick ri-"
"style\n"
"access to your documentation. It's way faster than ri but currently does "
"not\n"
"work with the stdlib or core Ruby libraries, only the active project. "
"Example:"
msgstr ""
"yriコマンドはドキュメントをri-styleで速くアクセスする為に、\n"
"キャッシュした.yardocデータベースを使うだろう。\n"
"これはriよりも速い方法だが、しかし、今の所、\n"
"stdlibかコアRubyライブラリ、アクティブプロジェクトだけでしか\n"
"動かない。\n"
"使用例:"

#: ../README.md:231
msgid ""
"    $ yri YARD::Handlers::Base#register\n"
"    $ yri File.relative_path"
msgstr ""
"    $ yri YARD::Handlers::Base#register\n"
"    $ yri File.relative_path"

#: ../README.md:234
msgid ""
"Note that class methods must not be referred to with the \"::\" namespace\n"
"separator. Only modules, classes and constants should use \"::\"."
msgstr ""
"次の事に留意する。\n"
"クラスメソッドは、\"::\"ネームスペース区切りとともに参照されるべきではない。\n"
"モジュールだけクラスと定数は\"::\"を使うべきである。"

#: ../README.md:237
msgid ""
"You can also do lookups on any installed gems. Just make sure to build the\n"
".yardoc databases for installed gems with:"
msgstr ""
"あなたはインストール済みの任意のgemを検索できる。\n"
"以下はインストール済みのgemとともに.yardocデータベースをビルドする。"

#: ../README.md:240
msgid "    $ sudo yard gems"
msgstr "    $ sudo yard gems"

#: ../README.md:242
msgid ""
"If you don't have sudo access, it will write these files to your `~/.yard`\n"
"directory. `yri` will also cache lookups there."
msgstr ""
"sudo権限をもっていない場合は、あなたの `~/.yard` ディレクトリにこれらを記述する。\n"
" `yri` はそれらをcache検索する。"

#: ../README.md:245
msgid "**4. `yard server` Documentation Server**"
msgstr "**4. `yard server` ドキュメント作成サーバー**"

#: ../README.md:247
msgid ""
"The `yard server` command serves documentation for a local project or all "
"installed\n"
"RubyGems. To serve documentation for a project you are working on, simply "
"run:"
msgstr ""
"`yard server` コマンドは、\n"
"ローカルプロジェクトやインストール済みのRubyGems用の\n"
"ドキュメント作成を提供する。\n"
"ドキュメント作成を提供するには、\n"
"あなたが取り組んでいるプロジェクト上で次のコマンドを単に実行する。"

#: ../README.md:250 ../docs/WhatsNew.md:542
msgid "    $ yard server"
msgstr "    $ yard server"

#: ../README.md:252
msgid ""
"And the project inside the current directory will be parsed (if the source "
"has\n"
"not yet been scanned by YARD) and served at [http://localhost:8808](http://"
"localhost:8808)."
msgstr ""
"上のコマンドによってプロジェクトの現在のディレクトリ内部は解析される。\n"
"(YARDによってスキャンされたにもかかわらずソースがなかった場合)\n"
"そして [http://localhost:8808](http://localhost:8808) で提供される。"

#: ../README.md:255
msgid "### Live Reloading"
msgstr "### Live Reloading"

#: ../README.md:257
msgid ""
"If you want to serve documentation on a project while you document it so "
"that\n"
"you can preview the results, simply pass `--reload` (`-r`) to the above "
"command\n"
"and YARD will reload any changed files on each request. This will allow you "
"to\n"
"change any documentation in the source and refresh to see the new contents."
msgstr ""
"結果をプレビューできるようにドキュメント化しながら、\n"
"プロジェクトのドキュメント作成を提供したいなら、\n"
"上のコマンドに単純に `--reload` (`-r`)を渡す。\n"
"YARDはそれぞれのリクエストのどれかの変更があったファイルを再ロードする。\n"
"これはあなたがソースの中のドキュメントの変更や\n"
"新しいコンテンツを見るのにリフレッシュを可能にする。"

#: ../README.md:262
msgid "### Serving Gems"
msgstr "### Serving Gems"

#: ../README.md:264
msgid "To serve documentation for all installed gems, call:"
msgstr ""
"全てのインストール済みのgemのドキュメント作成を提供するには、\n"
"次のコマンドを入力する。"

#: ../README.md:266 ../docs/WhatsNew.md:562
msgid "    $ yard server --gems"
msgstr "    $ yard server --gems"

#: ../README.md:268
msgid ""
"This will also automatically build documentation for any gems that have not\n"
"been previously scanned. Note that in this case there will be a slight "
"delay\n"
"between the first request of a newly parsed gem."
msgstr ""
"これは自動的に以前にスキャンされていないあらゆるgemのドキュメントをビルドす"
"る。\n"
"次の事に留意する。\n"
"この場合、新たに解析されたgemの最初の要求の間にわずかな遅延が発生する。"

#: ../README.md:273
msgid "**5. `yard graph` Graphviz Generator**"
msgstr "**5. `yard graph` はGraphvizのジェネレーター**"

#: ../README.md:275
msgid ""
"You can use `yard graph` to generate dot graphs of your code. This, of "
"course,\n"
"requires [Graphviz](http://www.graphviz.org) and the `dot` binary. By "
"default\n"
"this will generate a graph of the classes and modules in the best UML2 "
"notation\n"
"that Graphviz can support, but without any methods listed. With the `--"
"full`\n"
"option, methods and attributes will be listed. There is also a `--"
"dependencies`\n"
"option to show mixin inclusions. You can output to stdout or a file, or pipe "
"directly\n"
"to `dot`. The same public, protected and private visibility rules apply to "
"`yard graph`.\n"
"More options can be seen by typing `yard graph --help`, but here is an "
"example:"
msgstr ""
"あなたのコードの図を生成する為に `yard graph` を利用できる。\n"
"これにはもちろん、[Graphviz](http://www.graphviz.org)と `dot` が必要となる。\n"
"デフォルトでこれは、Graphvizのサポートできる最高のURL2表記で\n"
"クラスやモジュールの図を生成する。しかし、記載されたメソッドは生成しない。\n"
"`-- full` オプションを用いメソッドと属性が記述される。\n"
"mixinで含んでいるものを一覧する為に `--dependencies` オプションもある。\n"
"標準出力やファイルに出力したり、また `dot` に直接パイプできる。\n"
"同じpublic,protectedとprivateの可視性規則は、 `yard-graph` に適用される。\n"
"詳細なオプションは、 `yard-graph --help` とタイプすることによって見ることができる。\n"
"次に例がある:"

#: ../README.md:284
msgid "    $ yard graph --protected --full --dependencies"
msgstr "    $ yard graph --protected --full --dependencies"

#: ../README.md:287
msgid "## Changelog"
msgstr "## Changelog"

#: ../README.md:289
msgid ""
"- **June.9.12**: 0.8.2.1 release\n"
"    - Fix a set of regressions in yard server search and dynamic generation"
msgstr ""
"- **June.9.12**: 0.8.2.1 release\n"
"    - Fix a set of regressions in yard server search and dynamic generation"

#: ../README.md:292
msgid ""
"- **June.7.12**: 0.8.2 release\n"
"    - Added progress style output in tty terminals\n"
"    - Embedded mixins should ignore methods defined on module (#539)\n"
"    - Fixed permalinks for embedded mixins in `yard server` (#540)\n"
"    - Improve parsing in CRuby code (#543)\n"
"    - Ensure Registry.resolve picks module when parsing mixins (#545)\n"
"    - Fixed regression that caused various commands to not show output "
"(#548)\n"
"    - Respect current visibility when parsing class conditions (#551)"
msgstr ""
"- **June.7.12**: 0.8.2 release\n"
"    - Added progress style output in tty terminals\n"
"    - Embedded mixins should ignore methods defined on module (#539)\n"
"    - Fixed permalinks for embedded mixins in `yard server` (#540)\n"
"    - Improve parsing in CRuby code (#543)\n"
"    - Ensure Registry.resolve picks module when parsing mixins (#545)\n"
"    - Fixed regression that caused various commands to not show output (#548)\n"
"    - Respect current visibility when parsing class conditions (#551)"

#: ../README.md:301
msgid ""
"- **May.2.12**: 0.8.1 release\n"
"    - Added `--[no-]api` switch to generate docs for API sets (see {file:"
"docs/WhatsNew.md} for details) (#532)\n"
"    - The `yard list` command now uses cache by default (#533)\n"
"    - Fix `yardoc` generating incorrectly named method list file (#528)\n"
"    - Fix HTML output occasionally showing trailing mdash on options list "
"(#522)"
msgstr ""
"- **May.2.12**: 0.8.1 release\n"
"    - Added `--[no-]api` switch to generate docs for API sets (see {file:docs/WhatsNew.md} for details) (#532)\n"
"    - The `yard list` command now uses cache by default (#533)\n"
"    - Fix `yardoc` generating incorrectly named method list file (#528)\n"
"    - Fix HTML output occasionally showing trailing mdash on options list (#522)"

#: ../README.md:307
msgid ""
"- **April.30.12**: 0.8.0 release\n"
"    - See {file:docs/WhatsNew.md} for a list of added features\n"
"    - Over 20 bug fixes:\n"
"      - Properly filter hidden setter/getter attributes (#394)\n"
"      - Fix test failures in Linux environments (#397, #472, #473, #512, "
"#513)\n"
"      - Fix attribute inheritance and @private (#432)\n"
"      - Fix attribute parsing (#435)\n"
"      - Allow aliases for attributes (#436)\n"
"      - Fix namespace fetching in `handle_alias()` (#437)\n"
"      - Fix overwritten attributes marked as inherited (#442)\n"
"      - Fix documenting constants defined from C code with `rb_define_const()"
"` (#443)\n"
"      - Do not escape snippets twice (#445)\n"
"      - Ajax method/class search should not fire when a non-printable "
"character is pressed (#446)\n"
"      - Fix yard server crashing when RDoc is not installed (#456)\n"
"      - Fix tags ignored when `(see #foo)` is used (#457)\n"
"      - Fix three \"Returns\" for two `@overload` tags (#458)\n"
"      - Do not auto-detect DSL methods as method objects if parameter name "
"is not a valid method name (#464)\n"
"      - Fix attaching of macros to Object (#465)\n"
"      - Fix handling of `%w()` source in `[]/[]=` parsed context. (#461, "
"pull in #468)\n"
"      - Don't add default `@return` if `@overload` has `@return`. (#458, "
"pull in #469)\n"
"      - Don't discard tags by (see ...). (#457, pull in #470)\n"
"      - Fix constants listed as inherited when overwritten (#474)\n"
"      - Fix `yardoc --asset` behaving differently on first and subsequent "
"calls. (#477)\n"
"      - `!!!lang` code blocks should set the lang in `<pre>`'s class. (#478, "
"#479)\n"
"      - Fix \"File List\" search tab error. (#502)\n"
"      - Fix search bar not redirecting to method page. (#509)\n"
"      - Fix server returning exception message bodies as String (#518)"
msgstr ""
"- **April.30.12**: 0.8.0 release\n"
"    - See {file:docs/WhatsNew.md} for a list of added features\n"
"    - Over 20 bug fixes:\n"
"      - Properly filter hidden setter/getter attributes (#394)\n"
"      - Fix test failures in Linux environments (#397, #472, #473, #512, #513)\n"
"      - Fix attribute inheritance and @private (#432)\n"
"      - Fix attribute parsing (#435)\n"
"      - Allow aliases for attributes (#436)\n"
"      - Fix namespace fetching in `handle_alias()` (#437)\n"
"      - Fix overwritten attributes marked as inherited (#442)\n"
"      - Fix documenting constants defined from C code with `rb_define_const()` (#443)\n"
"      - Do not escape snippets twice (#445)\n"
"      - Ajax method/class search should not fire when a non-printable character is pressed (#446)\n"
"      - Fix yard server crashing when RDoc is not installed (#456)\n"
"      - Fix tags ignored when `(see #foo)` is used (#457)\n"
"      - Fix three \"Returns\" for two `@overload` tags (#458)\n"
"      - Do not auto-detect DSL methods as method objects if parameter name is not a valid method name (#464)\n"
"      - Fix attaching of macros to Object (#465)\n"
"      - Fix handling of `%w()` source in `[]/[]=` parsed context. (#461, pull in #468)\n"
"      - Don't add default `@return` if `@overload` has `@return`. (#458, pull in #469)\n"
"      - Don't discard tags by (see ...). (#457, pull in #470)\n"
"      - Fix constants listed as inherited when overwritten (#474)\n"
"      - Fix `yardoc --asset` behaving differently on first and subsequent calls. (#477)\n"
"      - `!!!lang` code blocks should set the lang in `<pre>`'s class. (#478, #479)\n"
"      - Fix \"File List\" search tab error. (#502)\n"
"      - Fix search bar not redirecting to method page. (#509)\n"
"      - Fix server returning exception message bodies as String (#518)"

#: ../README.md:335
msgid ""
"- **January.31.12**: 0.7.5 release\n"
"    - Various minor bug fixes"
msgstr ""
"- **January.31.12**: 0.7.5 release\n"
"    - Various minor bug fixes"

#: ../README.md:338
msgid ""
"- **December.2.11**: 0.7.4 release\n"
"    - Redcarpet is now the default Markdown formatting library. GFM now "
"works out-of-box (#404)\n"
"    - Fix server side searching for elements that are marked private (#420)\n"
"    - Add 'textile_strict' and 'pre' markup types, reorganize text and none "
"(#416)\n"
"    - Improve encoding line detection (#415)\n"
"    - Add support for `rb_define_alias` in CRuby code (#413)\n"
"    - Fix rendering of some keywords in source view (#410)\n"
"    - Add support for RDoc 3.10+ (#406, #407)\n"
"    - Fix typewriter text being processed in code blocks (#403)\n"
"    - Improve support for has_rdoc in RubyGems 1.8.x (#401)\n"
"    - See the {file:docs/WhatsNew.md} document for details on added features"
msgstr ""
"- **December.2.11**: 0.7.4 release\n"
"    - Redcarpet is now the default Markdown formatting library. GFM now works out-of-box (#404)\n"
"    - Fix server side searching for elements that are marked private (#420)\n"
"    - Add 'textile_strict' and 'pre' markup types, reorganize text and none (#416)\n"
"    - Improve encoding line detection (#415)\n"
"    - Add support for `rb_define_alias` in CRuby code (#413)\n"
"    - Fix rendering of some keywords in source view (#410)\n"
"    - Add support for RDoc 3.10+ (#406, #407)\n"
"    - Fix typewriter text being processed in code blocks (#403)\n"
"    - Improve support for has_rdoc in RubyGems 1.8.x (#401)\n"
"    - See the {file:docs/WhatsNew.md} document for details on added features"

#: ../README.md:350
msgid ""
"- **October.15.11**: 0.7.3 release\n"
"    - Improve support for parsing under Ruby 1.9.2p290 and 1.9.3 (#365, "
"#370)\n"
"    - Add support for SWIG generated CRuby code (#369)\n"
"    - Add support for `rb_define_attr` calls in CRuby code (#362)\n"
"    - Handle file pointers in CRuby code (#358)"
msgstr ""
"- **October.15.11**: 0.7.3 release\n"
"    - Improve support for parsing under Ruby 1.9.2p290 and 1.9.3 (#365, #370)\n"
"    - Add support for SWIG generated CRuby code (#369)\n"
"    - Add support for `rb_define_attr` calls in CRuby code (#362)\n"
"    - Handle file pointers in CRuby code (#358)"

#: ../README.md:356
msgid ""
"- **June.14.11**: 0.7.2 release\n"
"    - Fix `yard --help` not showing proper output\n"
"    - YARD now expands path to `.yardoc` file in daemon mode for server "
"(#328)\n"
"    - Fix `@overload` tag linking to wrong method (#330)\n"
"    - Fix incorrect return type when using `@macro` (#334)\n"
"    - YARD now requires 'thread' to support RubyGems 1.7+ (#338)\n"
"    - Fix bug in constant documentation when using `%w()` (#348)\n"
"    - Fix YARD style URL links when using autolinking markdown (#353)"
msgstr ""
"- **June.14.11**: 0.7.2 release\n"
"    - Fix `yard --help` not showing proper output\n"
"    - YARD now expands path to `.yardoc` file in daemon mode for server (#328)\n"
"    - Fix `@overload` tag linking to wrong method (#330)\n"
"    - Fix incorrect return type when using `@macro` (#334)\n"
"    - YARD now requires 'thread' to support RubyGems 1.7+ (#338)\n"
"    - Fix bug in constant documentation when using `%w()` (#348)\n"
"    - Fix YARD style URL links when using autolinking markdown (#353)"

#: ../README.md:365
msgid ""
"- **May.18.11**: 0.7.1 release\n"
"    - Fixes a bug in `yard server` not displaying class list properly."
msgstr ""
"- **May.18.11**: 0.7.1 release\n"
"    - Fixes a bug in `yard server` not displaying class list properly."

#: ../README.md:368
msgid ""
"- **May.17.11**: 0.7.0 release\n"
"    - See the {file:docs/WhatsNew.md} document for details on added "
"features\n"
"    - Make sure that Docstring#line_range is filled when possible (#243)\n"
"    - Set #verifier in YardocTask (#282)\n"
"    - Parse BOM in UTF-8 files (#288)\n"
"    - Fix instance attributes not showing up in method list (#302)\n"
"    - Fix rendering of %w() literals in constants (#306)\n"
"    - Ignore keyboard shortcuts when an input is active (#312)\n"
"    - And more..."
msgstr ""
"- **May.17.11**: 0.7.0 release\n"
"    - See the {file:docs/WhatsNew.md} document for details on added features\n"
"    - Make sure that Docstring#line_range is filled when possible (#243)\n"
"    - Set #verifier in YardocTask (#282)\n"
"    - Parse BOM in UTF-8 files (#288)\n"
"    - Fix instance attributes not showing up in method list (#302)\n"
"    - Fix rendering of %w() literals in constants (#306)\n"
"    - Ignore keyboard shortcuts when an input is active (#312)\n"
"    - And more..."

#: ../README.md:378
msgid ""
"- **April.14.11**: 0.6.8 release\n"
"    - Fix regression in RDoc 1.x markup loading\n"
"    - Fix regression in loading of markup libraries for `yard server`"
msgstr ""
"- **April.14.11**: 0.6.8 release\n"
"    - Fix regression in RDoc 1.x markup loading\n"
"    - Fix regression in loading of markup libraries for `yard server`"

#: ../README.md:382
msgid ""
"- **April.6.11**: 0.6.7 release\n"
"    - Fix has_rdoc gem specification issue with new RubyGems plugin API "
"(oops!)"
msgstr ""
"- **April.6.11**: 0.6.7 release\n"
"    - Fix has_rdoc gem specification issue with new RubyGems plugin API (oops!)"

#: ../README.md:385
msgid ""
"- **April.6.11**: 0.6.6 release\n"
"    - Fix error message when RDoc is not present (#270)\n"
"    - Add markup type 'none' to perform basic HTML translation (fallback "
"when RDoc is not present)\n"
"    - Add support for RubyGems 1.7.x (#272)\n"
"    - Fix rendering of `{url description}` syntax when description contains "
"newline"
msgstr ""
"- **April.6.11**: 0.6.6 release\n"
"    - Fix error message when RDoc is not present (#270)\n"
"    - Add markup type 'none' to perform basic HTML translation (fallback when RDoc is not present)\n"
"    - Add support for RubyGems 1.7.x (#272)\n"
"    - Fix rendering of `{url description}` syntax when description contains newline"

#: ../README.md:391
msgid ""
"- **March.13.11**: 0.6.5 release\n"
"    - Support `ripper` gem in Ruby 1.8.7\n"
"    - Upgrade jQuery to 1.5.1\n"
"    - Fix handling of alias statements with quoted symbols (#262)\n"
"    - Add CSS styles (#260)\n"
"    - Unhandled exception in YARD::Handlers::Ruby::MixinHandler indexing "
"documentation for eventmachine (#248)\n"
"    - Splice any alias references on method re-definitions into separate "
"methods (#247)\n"
"    - Fix \"yard graph\" (#245)\n"
"    - Don't process ++ typewriter text inside of HTML attributes (#244)\n"
"    - Prioritize loading of Kramdown before Maruku (#241)\n"
"    - Skip shebang encoding in docstrings (#238)\n"
"    - Fix truncation of references in @deprecated (#232)\n"
"    - Show @api private note when no other tags are present (#231)\n"
"    - Detect docstrings starting with \"##\" as `Docstring#hash_flag` "
"(#230)\n"
"    - Remove trailing whitespace from freeform tags (#229)\n"
"    - Fix line through for deprecated methods (#225)\n"
"    - Mistake in Tags.md (#223)\n"
"    - Improve database storage by being more efficient with filesystem usage "
"(#222)\n"
"    - Make Registry thread local (#221)\n"
"    - Support `private_constant` class method for 1.9.3 (#219)\n"
"    - Do not assume RDoc is installed (#214)"
msgstr ""
"- **March.13.11**: 0.6.5 release\n"
"    - Support `ripper` gem in Ruby 1.8.7\n"
"    - Upgrade jQuery to 1.5.1\n"
"    - Fix handling of alias statements with quoted symbols (#262)\n"
"    - Add CSS styles (#260)\n"
"    - Unhandled exception in YARD::Handlers::Ruby::MixinHandler indexing documentation for eventmachine (#248)\n"
"    - Splice any alias references on method re-definitions into separate methods (#247)\n"
"    - Fix \"yard graph\" (#245)\n"
"    - Don't process ++ typewriter text inside of HTML attributes (#244)\n"
"    - Prioritize loading of Kramdown before Maruku (#241)\n"
"    - Skip shebang encoding in docstrings (#238)\n"
"    - Fix truncation of references in @deprecated (#232)\n"
"    - Show @api private note when no other tags are present (#231)\n"
"    - Detect docstrings starting with \"##\" as `Docstring#hash_flag` (#230)\n"
"    - Remove trailing whitespace from freeform tags (#229)\n"
"    - Fix line through for deprecated methods (#225)\n"
"    - Mistake in Tags.md (#223)\n"
"    - Improve database storage by being more efficient with filesystem usage (#222)\n"
"    - Make Registry thread local (#221)\n"
"    - Support `private_constant` class method for 1.9.3 (#219)\n"
"    - Do not assume RDoc is installed (#214)"

#: ../README.md:413
msgid ""
"- **December.21.10**: 0.6.4 release\n"
"    - Fix yri tool crashing with new Config class (gh-217)\n"
"    - Fix support for ::TopLevelConstants (gh-216)\n"
"    - YARD's test suite is now RSpec2 compatible (gh-215)\n"
"    - Improved documentation for YARD::Server features (gh-207)\n"
"    - Fix displaying of collaped method summary lists (gh-204)\n"
"    - Fix automatic loading of markup providers (gh-206)\n"
"    - Fix keyboard shortcuts for Chrome (gh-203)\n"
"    - Disallow `extend self` inside of a class (gh-202)\n"
"    - Constants now recognized in C extensions (gh-201)"
msgstr ""
"- **December.21.10**: 0.6.4 release\n"
"    - Fix yri tool crashing with new Config class (gh-217)\n"
"    - Fix support for ::TopLevelConstants (gh-216)\n"
"    - YARD's test suite is now RSpec2 compatible (gh-215)\n"
"    - Improved documentation for YARD::Server features (gh-207)\n"
"    - Fix displaying of collaped method summary lists (gh-204)\n"
"    - Fix automatic loading of markup providers (gh-206)\n"
"    - Fix keyboard shortcuts for Chrome (gh-203)\n"
"    - Disallow `extend self` inside of a class (gh-202)\n"
"    - Constants now recognized in C extensions (gh-201)"

#: ../README.md:424
msgid ""
"- **November.21.10**: 0.6.3 release\n"
"    - Fixed regression that caused `yardoc --markup` to silently exit"
msgstr ""
"- **November.21.10**: 0.6.3 release\n"
"    - Fixed regression that caused `yardoc --markup` to silently exit"

#: ../README.md:427
msgid ""
"- **November.15.10**: 0.6.2 release\n"
"    - **Plugins no longer automatically load, use `--plugin` to load a "
"plugin**\n"
"    - Added YARD::Config and ~/.yard/config YAML configuration file\n"
"    - Added `yard config` command to view/edit YARD configuration file\n"
"    - Fixes for YARD in 1.8.6 (gh-178)\n"
"    - Various HTML template adjustments and fixes (gh-198,199,200)\n"
"    - Improved `yard server -m` multi-project stability (gh-193)\n"
"    - Fixed handling of `yardoc --no-private` with missing class definitions "
"(gh-197)\n"
"    - Added support for constants defined in C extensions (gh-177)\n"
"    - Added support for Structs defined as \"Klass = Struct.new"
"(...)\" (gh-187)\n"
"    - Improved parsing support for third-party gems (gh-174,180)\n"
"    - Improved support for JRuby 1.6.4+. YARD now passes all specs in JRuby "
"(gh-185)\n"
"    - Improved YARD documentation (gh-172,191,196)"
msgstr ""
"- **November.15.10**: 0.6.2 release\n"
"    - **Plugins no longer automatically load, use `--plugin` to load a plugin**\n"
"    - Added YARD::Config and ~/.yard/config YAML configuration file\n"
"    - Added `yard config` command to view/edit YARD configuration file\n"
"    - Fixes for YARD in 1.8.6 (gh-178)\n"
"    - Various HTML template adjustments and fixes (gh-198,199,200)\n"
"    - Improved `yard server -m` multi-project stability (gh-193)\n"
"    - Fixed handling of `yardoc --no-private` with missing class definitions (gh-197)\n"
"    - Added support for constants defined in C extensions (gh-177)\n"
"    - Added support for Structs defined as \"Klass = Struct.new(...)\" (gh-187)\n"
"    - Improved parsing support for third-party gems (gh-174,180)\n"
"    - Improved support for JRuby 1.6.4+. YARD now passes all specs in JRuby (gh-185)\n"
"    - Improved YARD documentation (gh-172,191,196)"

#: ../README.md:441
msgid ""
"- **September.06.10**: 0.6.1 release\n"
"    - Fixed TOC showing on top of class/method list in no-frames view\n"
"    - A message now displays when running `yard server` with Rack/Mongrel "
"installed\n"
"    - Improved performance of JS inline search for large class/method lists\n"
"    - Improved link titles for relative object links\n"
"    - Removed `String#camelcase` and `String#underscore` for better Rails "
"compat.\n"
"    - Fixed support for loading .yardoc files under Windows\n"
"    - Fixed inheritance tree arrows not displaying in certain environments"
msgstr ""
"- **September.06.10**: 0.6.1 release\n"
"    - Fixed TOC showing on top of class/method list in no-frames view\n"
"    - A message now displays when running `yard server` with Rack/Mongrel installed\n"
"    - Improved performance of JS inline search for large class/method lists\n"
"    - Improved link titles for relative object links\n"
"    - Removed `String#camelcase` and `String#underscore` for better Rails compat.\n"
"    - Fixed support for loading .yardoc files under Windows\n"
"    - Fixed inheritance tree arrows not displaying in certain environments"

#: ../README.md:450
msgid ""
"- **August.29.10**: 0.6.0 release\n"
"    - Added dynamic local documentation server\n"
"    - Added @group/@endgroup declarations to organize methods into groups\n"
"    - Added `yard` executable to serve as main CLI tool with pluggable "
"commands\n"
"    - Added `--asset` switch to `yardoc` to copy files/dirs to output dir\n"
"    - Added ability to register/manipulate tags via CLI (`--tag`, etc.)\n"
"    - Added `yard diff` command\n"
"    - Added statistics to `yardoc` output (and `yard stats` command)\n"
"    - Added Javascript generated Table of Contents to file pages\n"
"    - Updated various APIs\n"
"    - Removed `yard-graph` executable\n"
"    - See more changes in the {file:docs/WhatsNew.md what's new document}"
msgstr ""
"- **August.29.10**: 0.6.0 release\n"
"    - Added dynamic local documentation server\n"
"    - Added @group/@endgroup declarations to organize methods into groups\n"
"    - Added `yard` executable to serve as main CLI tool with pluggable commands\n"
"    - Added `--asset` switch to `yardoc` to copy files/dirs to output dir\n"
"    - Added ability to register/manipulate tags via CLI (`--tag`, etc.)\n"
"    - Added `yard diff` command\n"
"    - Added statistics to `yardoc` output (and `yard stats` command)\n"
"    - Added Javascript generated Table of Contents to file pages\n"
"    - Updated various APIs\n"
"    - Removed `yard-graph` executable\n"
"    - See more changes in the {file:docs/WhatsNew.md what's new document}"

#: ../README.md:463
msgid ""
"- **June.22.10**: 0.5.8 release\n"
"    - Merge fix from 0.6 branch for --no-private visibility checking"
msgstr ""
"- **June.22.10**: 0.5.8 release\n"
"    - Merge fix from 0.6 branch for --no-private visibility checking"

#: ../README.md:466
msgid ""
"- **June.21.10**: 0.5.7 release\n"
"    - Fixed visibility flag parsing in `yardoc`\n"
"    - Updated Parser Architecture documentation with new SourceParser API\n"
"    - Improved Registry documentation for new load commands\n"
"    - Fix loading of .yardoc file as cache (and preserving aliases)\n"
"    - Fix \"lib\" directory missing when running YARD on installed gems"
msgstr ""
"- **June.21.10**: 0.5.7 release\n"
"    - Fixed visibility flag parsing in `yardoc`\n"
"    - Updated Parser Architecture documentation with new SourceParser API\n"
"    - Improved Registry documentation for new load commands\n"
"    - Fix loading of .yardoc file as cache (and preserving aliases)\n"
"    - Fix \"lib\" directory missing when running YARD on installed gems"

#: ../README.md:473
msgid ""
"- **June.12.10**: 0.5.6 release\n"
"    - Bug fixes for RubyGems plugin, `has_rdoc=false` should now work\n"
"    - New API for registering custom parsers. See {file:docs/WhatsNew.md}"
msgstr ""
"- **June.12.10**: 0.5.6 release\n"
"    - Bug fixes for RubyGems plugin, `has_rdoc=false` should now work\n"
"    - New API for registering custom parsers. See {file:docs/WhatsNew.md}"

#: ../README.md:477
msgid ""
"- **May.22.10**: 0.5.5 release\n"
"    - Various bug fixes"
msgstr ""
"- **May.22.10**: 0.5.5 release\n"
"    - Various bug fixes"

#: ../README.md:480
msgid ""
"- **March.22.10**: 0.5.4 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"
msgstr ""
"- **March.22.10**: 0.5.4 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"

#: ../README.md:483
msgid ""
"- **January.11.10**: 0.5.3 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"
msgstr ""
"- **January.11.10**: 0.5.3 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"

#: ../README.md:486
msgid ""
"- **December.16.09**: 0.5.2 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"
msgstr ""
"- **December.16.09**: 0.5.2 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"

#: ../README.md:489
msgid ""
"- **December.15.09**: 0.5.1 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"
msgstr ""
"- **December.15.09**: 0.5.1 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"

#: ../README.md:492
msgid ""
"- **December.13.09**: 0.5.0 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"
msgstr ""
"- **December.13.09**: 0.5.0 release\n"
"    - See {file:docs/WhatsNew.md what's new document} for changes"

#: ../README.md:495
msgid ""
"- **November.15.09**: 0.4.0 release\n"
"    - Added new templating engine based on [tadpole](http://github.com/"
"lsegal/tadpole)\n"
"    - Added YARD queries (`--query` CLI argument to yardoc)\n"
"    - Greatly expanded YARD documentation\n"
"    - Added plugin support\n"
"    - New `@abstract` and `@private` tags\n"
"    - Changed default rake task to `rake yard`\n"
"    - Read about changes in {file:docs/WhatsNew.md}"
msgstr ""
"- **November.15.09**: 0.4.0 release\n"
"    - Added new templating engine based on [tadpole](http://github.com/lsegal/tadpole)\n"
"    - Added YARD queries (`--query` CLI argument to yardoc)\n"
"    - Greatly expanded YARD documentation\n"
"    - Added plugin support\n"
"    - New `@abstract` and `@private` tags\n"
"    - Changed default rake task to `rake yard`\n"
"    - Read about changes in {file:docs/WhatsNew.md}"

#: ../README.md:504
msgid ""
"- **August.13.09**: 0.2.3.5 release\n"
"    - Minor bug fixes."
msgstr ""
"- **August.13.09**: 0.2.3.5 release\n"
"    - Minor bug fixes."

#: ../README.md:507
msgid ""
"- **August.07.09**: 0.2.3.4 release\n"
"    - Minor bug fixes."
msgstr ""
"- **August.07.09**: 0.2.3.4 release\n"
"    - Minor bug fixes."

#: ../README.md:510
msgid ""
"- **July.26.09**: 0.2.3.3 release\n"
"    - Minor bug fixes."
msgstr ""
"- **July.26.09**: 0.2.3.3 release\n"
"    - Minor bug fixes."

#: ../README.md:513
msgid ""
"- **July.06.09**: 0.2.3.2 release\n"
"    - Fix Textile hard-break issues\n"
"    - Add description for @see tag to use as link title in HTML docs.\n"
"    - Add --title CLI option to specify a title for HTML doc files.\n"
"    - Add custom.css file that can be overridden with various custom\n"
"      styelsheet declarations. To use this, simply add `default/fulldoc/html/"
"custom.css`\n"
"      inside your code directory and use the `-t` template directory yardoc "
"CLI\n"
"      option to point to that template directory (the dir holding "
"'default').\n"
"    - Add support in `yardoc` CLI to specify extra files (formerly --files)\n"
"      by appending \"- extra files here\" after regular source files. "
"Example:"
msgstr ""
"- **July.06.09**: 0.2.3.2 release\n"
"    - Fix Textile hard-break issues\n"
"    - Add description for @see tag to use as link title in HTML docs.\n"
"    - Add --title CLI option to specify a title for HTML doc files.\n"
"    - Add custom.css file that can be overridden with various custom\n"
"      styelsheet declarations. To use this, simply add `default/fulldoc/html/custom.css`\n"
"      inside your code directory and use the `-t` template directory yardoc CLI\n"
"      option to point to that template directory (the dir holding 'default').\n"
"    - Add support in `yardoc` CLI to specify extra files (formerly --files)\n"
"      by appending \"- extra files here\" after regular source files. Example:"

#: ../README.md:524
msgid "            yardoc --private lib/**/*.rb - FAQ LICENSE"
msgstr "            yardoc --private lib/**/*.rb - FAQ LICENSE"

#: ../README.md:526
msgid ""
"- **Jun.13.09**: 0.2.3.1 release.\n"
"    - Add a RubyGems 1.3.2+ plugin to generate YARD documentation instead "
"of\n"
"      RDoc. To take advantage of this plugin, set `has_rdoc = 'yard'` in "
"your\n"
"      .gemspec file."
msgstr ""
"- **Jun.13.09**: 0.2.3.1 release.\n"
"    - Add a RubyGems 1.3.2+ plugin to generate YARD documentation instead of\n"
"      RDoc. To take advantage of this plugin, set `has_rdoc = 'yard'` in your\n"
"      .gemspec file."

#: ../README.md:531
msgid ""
"- **Jun.07.09**: 0.2.3 release. See the {file:docs/WhatsNew.md} file for a\n"
"  list of important new features."
msgstr ""
"- **Jun.07.09**: 0.2.3 release. See the {file:docs/WhatsNew.md} file for a\n"
"  list of important new features."

#: ../README.md:534
msgid ""
"- **Jun.16.08**: 0.2.2 release. This is the largest changset since yard's\n"
"  conception and involves a complete overhaul of the parser and API to make "
"it\n"
"  more robust and far easier to extend and use for the developer."
msgstr ""
"- **Jun.16.08**: 0.2.2 release. This is the largest changset since yard's\n"
"  conception and involves a complete overhaul of the parser and API to make it\n"
"  more robust and far easier to extend and use for the developer."

#: ../README.md:538
msgid "- **Feb.20.08**: 0.2.1 release."
msgstr "- **Feb.20.08**: 0.2.1 release."

#: ../README.md:540
msgid ""
"- **Feb.24.07**: Released 0.1a experimental version for testing. The goal "
"here is\n"
"  to get people testing YARD on their code because there are too many "
"possible\n"
"  code styles to fit into a sane amount of test cases. It also demonstrates "
"the\n"
"  power of YARD and what to expect from the syntax (Yardoc style meta tags)."
msgstr ""
"- **Feb.24.07**: Released 0.1a experimental version for testing. The goal here is\n"
"  to get people testing YARD on their code because there are too many possible\n"
"  code styles to fit into a sane amount of test cases. It also demonstrates the\n"
"  power of YARD and what to expect from the syntax (Yardoc style meta tags)."

#: ../README.md:546
msgid "## Contributors"
msgstr "## 貢献者へ"

#: ../README.md:548
msgid ""
"Special thanks to all contributors for submitting patches. A full list of\n"
"contributors including their patches can be found at:"
msgstr ""
"パッチの申請をした全ての貢献者へ本当に感謝する。\n"
"これらのパッチを投げた全ての貢献者のリストは次で見れる:"

#: ../README.md:551
msgid "http://github.com/lsegal/yard/contributors"
msgstr "http://github.com/lsegal/yard/contributors"

#: ../README.md:553
msgid "## Copyright"
msgstr "## Copyright"

#: ../README.md:555
msgid ""
"YARD &copy; 2007-2012 by [Loren Segal](mailto:lsegal@soen.ca). YARD is\n"
"licensed under the MIT license except for some files which come from the\n"
"RDoc/Ruby distributions. Please see the {file:LICENSE} and {file:LEGAL}\n"
"documents for more information."
msgstr ""
"YARD &copy; 2007-2012 by [Loren Segal](mailto:lsegal@soen.ca). YARD is\n"
"licensed under the MIT license except for some files which come from the\n"
"RDoc/Ruby distributions. Please see the {file:LICENSE} and {file:LEGAL}\n"
"documents for more information."

# title
#: ../docs/CodeObjects.md:1
msgid "CodeObjects Architecture"
msgstr "コードオブジェクト構造"

#: ../docs/CodeObjects.md:3
msgid "# CodeObjects Architecture"
msgstr "# コードオブジェクト構造"

#: ../docs/CodeObjects.md:5
msgid ""
"Code objects are Ruby objects that describe the code being documented. For "
"instance,\n"
"all classes, modules, methods, etc. are all extracted from the Ruby source "
"as code\n"
"objects. All of these code objects extend from the {YARD::CodeObjects::Base} "
"class, which\n"
"provides basic attributes like source location, source code, name and path."
msgstr ""
"コードオブジェクトは記述されているコードの用途を説明するRubyオブジェクトとな"
"る。\n"
"例えば、全てのクラス,モジュール,メソッド等は、\n"
"コードオブジェクトのようにRubyのソースから全て抽出される。\n"
"これらコードオブジェクトの全ては、{YARD::CodeObjects::Base}クラスから拡張す"
"る。\n"
"そして、ソースの位置や,ソースコードや,名前や,パスのように基本属性を提供する。"

#: ../docs/CodeObjects.md:10
msgid "## CodeObjects Organization"
msgstr "## コードオブジェクト機構"

#: ../docs/CodeObjects.md:12
msgid ""
"Code objects are divided into two basic types. {YARD::CodeObjects::"
"NamespaceObject NamespaceObjects}\n"
"and non-namespace objects. A namespace object refers to any object in Ruby "
"that can have\n"
"other objects defined inside of it. In the context of Ruby, this "
"specifically means\n"
"modules and classes (both of which are subclasses of `NamespaceObject`). "
"These objects\n"
"act like tree structures, maintaining a list of all of their direct "
"children. All non\n"
"namespace objects are simply subclasses of the Base class. The {YARD::"
"CodeObjects::RootObject RootObject}\n"
"is a special kind of `NamespaceObject` which refers to the top level "
"namespace in Ruby.\n"
"Methods that accept a namespace object as a parameter should also accept the "
"symbol\n"
"`:root` as a shortcut for the root object."
msgstr ""
"コードオブジェクトは二つの基本的な方に分割される。\n"
"それは{YARD::CodeObjects::NamespaceObject NamespaceObjects}とnamespaceではないオブジェクトである。\n"
"namespace オブジェクトは\n"
"その内部で定義された他のオブジェクトを持つ事ができる任意のRubyのオブジェクトを参照する。\n"
"これは特にモジュールとクラスを意味する。\n"
"( `NamespaceObject` のサブクラスのどちらとも)\n"
"これらのオブジェクトはツリー構造のように振る舞い、これらの直接の子全てのリストを維持している。\n"
"namespaceではない全てのオブジェクトは単純にベースクラスのサブクラスである。\n"
"{YARD::CodeObjects::RootObject RootObject} は\n"
"特別な `NamespaceObject` ともいえ、Rubyの中のトップレベルnamespaceを参照する。\n"
"パラメータとして namespace オブジェクトを受け入れるメソッドは、\n"
"root オブジェクト用のショートカットとして `:root` シンボルも受け入れる。"

#: ../docs/CodeObjects.md:22
msgid ""
"The following is an overview of the classes within the `CodeObjects` "
"namespace:"
msgstr "以下は `CodeObjects` のnamespaceの中で用いられるクラスの概要となる。"

#: ../docs/CodeObjects.md:24
msgid "![CodeObjects Class Diagram](images/code-objects-class-diagram.png)"
msgstr "![CodeObjects Class Diagram](images/code-objects-class-diagram.png)"

#: ../docs/CodeObjects.md:26
msgid "## Unique Path Representation"
msgstr ""
"## ユニークパス表現\n"
"## Unique Path Representation"

#: ../docs/CodeObjects.md:28
msgid ""
"All CodeObjects are uniquely defined by their implementation of {YARD::"
"CodeObjects::Base#path}.\n"
"This path is used to locate or store a code object in the {YARD::Registry}. "
"It is therefore\n"
"essential that any Base subclass return a unique String value for #path so "
"that the\n"
"object may co-exist with other objects in the Registry."
msgstr ""
"全てのコードオブジェクトは\n"
"これらの{YARD::CodeObjects::Base#path}の実装によって個別に定義される。\n"
"このパスは場所を示すためや {YARD::Registry} の中でコードオブジェクトを登録するため利用される\n"
"それ故、任意の基本サブクラスが個別の#pathメソッド用の文字列値を返す必要がある。\n"
"オブジェクトはレジストリーの中で他のオブジェクトと一緒に共存する事になる。"

#: ../docs/CodeObjects.md:33
msgid ""
"In practice, a path is simply the conventional Ruby representation of a "
"class,\n"
"module, constant, class variable or method. For example, the following "
"objects\n"
"would have the following respective paths:"
msgstr ""
"実際のパスは、単純に慣習的なRubyの\n"
"クラス,モジュール,定数,クラス変数,メソッドの表現となる。\n"
"例えば、次のオブジェクトは、後に続く個別のパスを持っている。"

#: ../docs/CodeObjects.md:37
msgid ""
"* Class `Klass` inside module `Mod`: `Mod::Klass`\n"
"* Instance method `bar` inside class `Foo`: `Foo#bar`\n"
"* Class method `bar` inside class `Foo`: `Foo.bar`\n"
"* Constant `VERSION` inside class `YARD`: `YARD::VERSION`\n"
"* Class variable `@@abc` inside class `A`: `A::@@abc`"
msgstr ""
"* `Mod` モジュールの内部の `Klass` クラス: `Mod::Klass`\n"
"* `Foo` クラスの内部の `bar` インスタンスメソッド: `Foo#bar`\n"
"* `Foo` クラスの内部の `bar` クラスメソッド: `Foo.bar`\n"
"* `YARD` クラス内部の `VARSION` 定数: `YARD::VERSION`\n"
"* `A` クラス内部の `@@abc` クラス変数: `A::@@abc`"

#: ../docs/CodeObjects.md:43
msgid "## Registry"
msgstr "## レジストリー"

#: ../docs/CodeObjects.md:45
msgid ""
"CodeObjects classes are coupled with the {YARD::Registry} class which keeps "
"track of\n"
"all instantiated code objects. This is an explicit design choice to allow "
"objects\n"
"to be fetched, cached, imported and exported from a centralized location. As "
"mentioned\n"
"above, this coupling is a result of the fact that each object is uniquely "
"identified by\n"
"its path, which is used to implement lookups. You can read more about the "
"registry\n"
"in the {YARD::Registry} class."
msgstr ""
"コードオブジェクトクラスは {YARD::Registry} クラスを用い組み合わされ、\n"
"そしてインスタンス化されたコードオブジェクトのトラックを保持する。\n"
"これは集中化される場所から、\n"
"フェッチ,キャッシュ,インポート,エクスポートされるオブジェクトを許可するための\n"
"選択を明確に設計する。\n"
"上で言われた、\n"
"この組み合わせは個々のオブジェクトの要素の結果がそのパスによって独自に識別され,\n"
"検索を実装するために利用される。\n"
"レジストリーの詳細については、 {YARD::Registry} クラスの中で読むことができる。"

#: ../docs/CodeObjects.md:52
msgid "## Identity Map"
msgstr "## Identity Map"

#: ../docs/CodeObjects.md:54
msgid ""
"Code objects are instantiated using an identity-map like implementation that "
"guarantees\n"
"only one unique Ruby object exists for an object described by a specific "
"path. This\n"
"allows developers to create a code object without checking if it already "
"exists in\n"
"the {YARD::Registry}. The following example will only create one object:"
msgstr ""
"コードオブジェクトはidentity-mapによってインスタンス化される。\n"
"これは、特定のパスによって説明されるオブジェクトが\n"
"固有のRubyオブジェクトだと保証する実装のようなものである。\n"
"既に{YARD::Registry}の中に存在する場合\n"
"確認無しでコードオブジェクトを作成する為に開発者達を受け入れる\n"
"次の例は一つのオブジェクトだけ作成する。"

#: ../docs/CodeObjects.md:59
msgid ""
"    id = ClassObject.new(:root, \"MyClass\").object_id #=> 13352\n"
"    ClassObject.new(:root, \"MyClass\").object_id #=> 13352"
msgstr ""
"    id = ClassObject.new(:root, \"MyClass\").object_id #=> 13352\n"
"    ClassObject.new(:root, \"MyClass\").object_id #=> 13352"

#: ../docs/CodeObjects.md:62
msgid "## Proxy Objects"
msgstr "## プロキシ オブジェクト"

#: ../docs/CodeObjects.md:64
msgid ""
"In addition to providing access to existing objects, a {YARD::CodeObjects::"
"Proxy}\n"
"class exists which can represent an object at a path that may or may not "
"have been\n"
"created. This is necessary to represent a reference to an object in code "
"that is\n"
"never defined in the same body of source code, or perhaps defined later. If "
"any\n"
"attributes of a proxy are accessed, it will immediately be resolved to the "
"object\n"
"at its declared path. In the case where such an object exists, it will act "
"as\n"
"a delegate to the object. However, if the object does not exist, a warning "
"will\n"
"be raised. Whenever arbitrary code objects are used, care should be taken "
"in\n"
"order to make sure attributes are not accessed on unresolvable proxies. An\n"
"unresolvable proxy will return a class name of `Proxy` and #type of `:"
"proxy`,\n"
"for example:"
msgstr ""
"さらに現在のオブジェクトにアクセスを提供するには、\n"
"{YARD::CodeObjects::Proxy} クラスがある。\n"
"それは作成されるかどうかはわからないがパスでオブジェクトを表せる。\n"
"これは同じソースコード内で定義されないコードでオブジェクトへの参照を表す為や、\n"
"ことによると後で定義される時に必要となる。\n"
"任意プロキシの属性がアクセスされる場合、\n"
"すぐに宣言されたパスでオブジェクトの為に解決される。\n"
"オブジェクトが存在する場合、オブジェクトに委譲するように振る舞う。\n"
"しかしながら、オブジェクトが存在しなかった場合は、警告が出るだろう。\n"
"任意のコードオブジェクトが利用される時はいつでも、\n"
"属性が未解決のプロキシ上でアクセスしないか確認する為に\n"
"順番にされるので注意しなければならない。\n"
"未解決のプロキシは `Proxy` のクラス名と `:proxy` の#typeメソッドを返す。\n"
"例えば以下のように:"

#: ../docs/CodeObjects.md:76
msgid ""
"    P(:InvalidObject).type == :proxy  #=> true\n"
"    P(:InvalidObject).is_a?(Proxy)    #=> true"
msgstr ""
"    P(:InvalidObject).type == :proxy  #=> true\n"
"    P(:InvalidObject).is_a?(Proxy)    #=> true"

#: ../docs/CodeObjects.md:79
msgid "## Adding Data to Code Objects"
msgstr "## コードオブジェクトにデータを追加する。"

#: ../docs/CodeObjects.md:81
msgid ""
"Code objects act as hash-like structures that allow any arbitrary value to "
"be set.\n"
"This allows easy extending of existing objects without creating custom "
"subclasses.\n"
"For instance, to add a timestamp to a method object (when it was modified, "
"maybe),\n"
"it is possible to simply do:"
msgstr ""
"コードオブジェクトは設定される為の任意の値を受け入れるハッシュ構造のように振"
"る舞う。\n"
"これは、カスタムサブクラスを作成すること無しで、既存のオブジェクトの簡単な拡"
"張を受け入れる。\n"
"例えば、メソッドオブジェクトにtimestampを追加する為には、\n"
"以下の様に単純にする事が可能。"

#: ../docs/CodeObjects.md:86
msgid ""
"    object = MethodObject.new(:root, \"my_method\")\n"
"    object[:modified_at] = Time.now"
msgstr ""
"    object = MethodObject.new(:root, \"my_method\")\n"
"    object[:modified_at] = Time.now"

#: ../docs/CodeObjects.md:89
msgid ""
"This value can now be retrieved on this object both by the hash `[]` syntax "
"as\n"
"well as like any other method:"
msgstr ""
"この値はハッシュのような `[]` 構文でも以下のような\n"
"メソッド呼び出しでも取り出す事が出来る。"

#: ../docs/CodeObjects.md:92
msgid "    object.modified_at #=> 2009-06-03 20:08:46 -0400"
msgstr "    object.modified_at #=> 2009-06-03 20:08:46 -0400"

#: ../docs/CodeObjects.md:94
msgid "## Creating a Custom CodeObject"
msgstr "## カスタムコードオブジェクトを作成する"

#: ../docs/CodeObjects.md:96
msgid ""
"It should first be mentioned that creating a custom code object should not "
"be\n"
"necessary in most cases, except when functionality that cannot be "
"represented\n"
"by classical Ruby objects is added. A good example *might* be a test class,\n"
"which although is technically a Ruby class, has a significantly different "
"purpose\n"
"in documentation and needs a different set of metadata, as well as its own\n"
"representation in documentation."
msgstr ""
"カスタムコードオブジェクトを作成する前に、最初に言及すべきこととして、\n"
"大抵の場合、カスタムコードオブジェクトを作成する事は必須ではないはずであ"
"る。\n"
"この項は標準的なRubyオブジェクトの追加によって表現できない機能がある時の事を"
"予期する。\n"
"いい例は、testクラスかもしれない、\n"
"それは、形の上ではRubyのクラスだけれども、\n"
"中のドキュメントやメタデータの入った異なる設定を必要とし\n"
"かなり異なる目的をもっている。\n"
"それ自身もドキュメントの中を表している。"

#: ../docs/CodeObjects.md:103
msgid ""
"The {YARD::CodeObjects::Base#path} implementation is the most important part "
"of the\n"
"code object architecture. The first thing any custom code object must "
"guarantee is\n"
"that its path value is unique among all other objects. The recommended way "
"to do this\n"
"with custom objects is to add a descriptive prefix to the path. For example, "
"the\n"
"following is an implementation of the path for a hypothetical `FooObject`:"
msgstr ""
"{YARD::CodeObjects::Base#path}の実装がコードオブジェクト構造の最も重要な部分である。\n"
"どのカスタムコードオブジェクトでも最初に保証されなければならない事は、\n"
"パスの値が他の全てのオブジェクトとの間で固有でなければならない。\n"
"これを行うのに推奨される方法は、\n"
"カスタムオブジェクトがパスに説明のプレフィックス(接頭語)を\n"
"追加する方法である。\n"
"例えば、次は仮の `FooObject` 用のパスの実装となる。"

#: ../docs/CodeObjects.md:109
msgid ""
"    def path\n"
"      \"__FooPrefix\" + sep + super\n"
"    end"
msgstr ""
"    def path\n"
"      \"__FooPrefix\" + sep + super\n"
"    end"

#: ../docs/CodeObjects.md:113
msgid ""
"Note that if our FooObject is a `NamespaceObject`, meaning if it can have "
"child\n"
"FooObjects defined inside of it, you may need to verify that the prefix is "
"only\n"
"applied once."
msgstr ""
"次の事に留意する。\n"
"もし例のFooObjectが、 `NamespaceObject` の場合、\n"
"FooObjectがそれの内部で定義される子を持てるかどうか意味している。\n"
"一度だけ適用されるプレフィックスを確認する為に必要な場合がある。"

# title
#: ../docs/GettingStarted.md:1
msgid "Getting Started Guide"
msgstr "導入の案内"

#: ../docs/GettingStarted.md:3
msgid "# Getting Started with YARD"
msgstr "# YARDを使い始めるには"

#: ../docs/GettingStarted.md:5
msgid ""
"There are a few ways which YARD can be of use to you or your project. This\n"
"document will cover the most common ways to use YARD:"
msgstr ""
"YARDにはプロジェクトの助けとなるいくつかの使用方法があるが、\n"
"このドキュメントでは以下の目次で一般的なYARDの使い方について説明する。"

#: ../docs/GettingStarted.md:8
msgid ""
"* [Documenting Code with YARD](#docing)\n"
"* [Using YARD to Generate Documentation](#using)\n"
"* [Configuring YARD](#config)\n"
"* [Extending YARD](#extending)\n"
"* [Templating YARD](#templating)\n"
"* [Plugin Support](#plugins)"
msgstr ""
"* [YARDで文書を作る](#docing)\n"
"* [ドキュメントを生成するYARDの使い方](#using)\n"
"* [YARDの構成する](#config)\n"
"* [YARDの拡張する](#extending)\n"
"* [YARDのテンプレートを作成する](#templating)\n"
"* [プラグインサポート](#plugins)"

#: ../docs/GettingStarted.md:15
msgid "<a name=\"docing\"></a>"
msgstr "<a name=\"docing\"></a>"

#: ../docs/GettingStarted.md:17
msgid "## Documenting Code with YARD"
msgstr "## YARDで文書を作る"

#: ../docs/GettingStarted.md:19
msgid ""
"By default, YARD is compatible with the same RDoc syntax most Ruby "
"developers\n"
"are already familiar with. However, one of the biggest advantages of YARD "
"is\n"
"the extended meta-data syntax, commonly known as \"tags\", that you can use\n"
"to express small bits of information in a structured and formal manner. "
"While\n"
"RDoc syntax expects you to describe your method in a completely free-form\n"
"manner, YARD recommends declaring your parameters, return types, etc. with\n"
"the `@tag` syntax, which makes outputting the documentation more consistent\n"
"and easier to read. Consider the RDoc documentation for a method to_format:"
msgstr ""
"デフォルトで、YARDは多くのRuby開発者たちがすでによく知っている\n"
"RDoc構文と両立できる。\n"
"しかしながら、\n"
"YARDの最も大きな利点の一つは、拡張できるメタデータ構文となる。\n"
"それは、一般的に知られる\"タグ\"のように、\n"
"小さくて構造化された情報の中を明確にする為や\n"
"形式的な方法で記述する為に利用できる。\n"
"さらに、RDoc構文はメソッドを説明する為に全てフリーフォームマナーで要求するが、\n"
"YARDは宣言しているパラメータ、リターンタイプなどを `@tag` 構文を用いて、\n"
"一貫した表現で簡単に読む為のドキュメント作りを推奨する。\n"
"RDocのドキュメントのto_formatメソッドについて考えてみる。"

#: ../docs/GettingStarted.md:28
msgid ""
"    # Converts the object into textual markup given a specific `format`\n"
"    # (defaults to `:html`)\n"
"    #\n"
"    # == Parameters:\n"
"    # format::\n"
"    #   A Symbol declaring the format to convert the object to. This\n"
"    #   can be `:text` or `:html`.\n"
"    #\n"
"    # == Returns:\n"
"    # A string representing the object in a specified\n"
"    # format.\n"
"    #\n"
"    def to_format(format = :html)\n"
"      # format the object\n"
"    end"
msgstr ""
"    # 原文のマークアップの与えられた特定の `format` へオブジェクトを変換する\n"
"    # (defaults to `:html`)\n"
"    #\n"
"    # == Parameters:\n"
"    # format::\n"
"    #   A Symbol declaring the format to convert the object to. This\n"
"    #   can be `:text` or `:html`.\n"
"    #\n"
"    # == Returns:\n"
"    # A string representing the object in a specified\n"
"    # format.\n"
"    #\n"
"    def to_format(format = :html)\n"
"      # format the object\n"
"    end"

#: ../docs/GettingStarted.md:44
msgid ""
"While this may seem easy enough to read and understand, it's hard for a "
"machine\n"
"to properly pull this data back out of our documentation. Also we've tied "
"our\n"
"markup to our content, and now our documentation becomes hard to maintain "
"if\n"
"we decide later to change our markup style (maybe we don't want the \":\" "
"suffix\n"
"on our headers anymore)."
msgstr ""
"これは読んだり理解するには簡単と思われるかもしれないが、\n"
"機械にとっては例のドキュメントを取消しデータを適切に再配置\n"
"するのは大変である。(フリーフォームなので)\n"
"内容と紐付いたマークアップになっているので、\n"
"マークアップスタイルを変更するのが後で決まった場合、\n"
"例のドキュメントはすぐに維持するのが大変になる\n"
"(恐らく、私達は例の見出しのサフィックス\":\"を望んでいない。)"

#: ../docs/GettingStarted.md:50
msgid "In YARD, we would simply define our method as:"
msgstr "YARDの中で、私達は例のメソッドを単純に定義する。"

#: ../docs/GettingStarted.md:52
msgid ""
"    # Converts the object into textual markup given a specific format.\n"
"    #\n"
"    # @param [Symbol] format the format type, `:text` or `:html`\n"
"    # @return [String] the object converted into the expected format.\n"
"    def to_format(format = :html)\n"
"      # format the object\n"
"    end"
msgstr ""
"    # 原文のマークアップの与えられた特定のフォーマットへオブジェクトを変換する\n"
"    #\n"
"    # @param [Symbol] format the format type, `:text` or `:html`\n"
"    # @return [String] the object converted into the expected format.\n"
"    def to_format(format = :html)\n"
"      # format the object\n"
"    end"

#: ../docs/GettingStarted.md:60
msgid ""
"Using tags we can add semantic metadata to our code without worrying about\n"
"presentation. YARD will handle presentation for us when we decide to "
"generate\n"
"documentation later."
msgstr ""
"タグを用いることによって、\n"
"私達は(フリーフォームでの)見栄えを気にすることなく\n"
"意味のあるメタデータを追加することができる。\n"
"そしてYARDは後でドキュメントを生成すると決めた時、\n"
"見栄えを処理できる。"

#: ../docs/GettingStarted.md:64
msgid "## Which Markup Format?"
msgstr "## どのマークアップフォーマット?"

#: ../docs/GettingStarted.md:66
msgid ""
"YARD does not impose a specific markup. The above example uses standard "
"RDoc\n"
"markup formatting, but YARD also supports textile and markdown via the\n"
"command-line switch or `.yardopts` file (see below). This means that you "
"are\n"
"free to use whatever formatting you like. This guide is actually written\n"
"using markdown. YARD, however, does add a few important syntaxes that are\n"
"processed no matter which markup formatting you use, such as tag support\n"
"and inter-document linking. These syntaxes are discussed below."
msgstr ""
"YARDは特定のマークアップを強要しない。\n"
"上の例は標準のRDocマークアップ書式を例として使ったが、\n"
"それだけではなく、\n"
"コマンドラインや `.yardopts` ファイル経由でtexttileとmarkdownもサポートする(以下参照)\n"
"これが意味することは、\n"
"あなたが好きなどんな書式を使おうとも自由である。\n"
"このガイドは実際にmarkdownを使って書かれている。\n"
"ともあれYARDにはいくつかの重要な構文を追加された。\n"
"それは、\n"
" 1. あなた使うマークアップ書式で問題なく処理される\n"
" 2. タグの様なサポート\n"
" 3. ドキュメント内部のリンク\n"
"である。\n"
"これらの構文は以降で説明される。"

#: ../docs/GettingStarted.md:74
msgid "## Adding Tags to Documentation"
msgstr "## ドキュメントにつけられているタグ"

#: ../docs/GettingStarted.md:76
msgid ""
"The tag syntax that YARD uses is the same @tag-style syntax you may have "
"seen\n"
"if you've ever coded in Java, Python, PHP, Objective-C or a myriad of other\n"
"languages. The following tag adds an author tag to your class:"
msgstr ""
"YARDが使うタグ構文は,もしあなたが今まで\n"
"Java, Python, PHP, Objective-Cや無数の他の言語をプログラミングした事があれば\n"
"既にあなたが見たことがある@tagスタイルと同じ構文である\n"
"次のタグはauthorタグをあなたのクラスに追加する:"

#: ../docs/GettingStarted.md:80
msgid ""
"    # @author Loren Segal\n"
"    class MyClass\n"
"    end"
msgstr ""
"    # @author Loren Segal\n"
"    class MyClass\n"
"    end"

#: ../docs/GettingStarted.md:84
msgid ""
"To allow for large amounts of text, the @tag syntax will recognize any "
"indented\n"
"lines following a tag as part of the tag data. For example:"
msgstr ""
"大量のテキストを受け入れる為に、\n"
"タグ構文は続くインデントされた行をタグデータの一部として認識するだろう。\n"
"例えば以下の様になる。"

#: ../docs/GettingStarted.md:87
msgid ""
"    # @deprecated Use {#my_new_method} instead of this method because\n"
"    #   it uses a library that is no longer supported in Ruby 1.9.\n"
"    #   The new method accepts the same parameters.\n"
"    def mymethod\n"
"    end"
msgstr ""
"    # @deprecated Use {#my_new_method} instead of this method because\n"
"    #   it uses a library that is no longer supported in Ruby 1.9.\n"
"    #   The new method accepts the same parameters.\n"
"    def mymethod\n"
"    end"

#: ../docs/GettingStarted.md:93
msgid "### List of Tags"
msgstr "### タグのリスト"

#: ../docs/GettingStarted.md:95
msgid "A list of tags can be found in {file:docs/Tags.md#taglist}"
msgstr "タグのリストは {file:docs/Tags.md#taglist} で見つけられる。"

#: ../docs/GettingStarted.md:97 ../docs/Tags.md:230
msgid "### Reference Tags"
msgstr "### 参照タグ"

#: ../docs/GettingStarted.md:99
msgid ""
"To reduce the amount of duplication in writing documentation for repetitive\n"
"code, YARD introduces \"reference tags\", which are not quite tags, but not\n"
"quite docstrings either. In a sense, they are tag (and docstring) "
"modifiers.\n"
"Basically, any docstring (or tag) that begins with \"(see OTHEROBJECT)\" "
"will\n"
"implicitly link the docstring or tag to the \"OTHEROBJECT\", copying any "
"data\n"
"from that docstring/tag into your current object. Consider the example:"
msgstr ""
"繰り返しの多いドキュメント中の重複の総量を減少させるために、\n"
"YARDはタグでもdocstringsでもない\"参照タグ\"を導入する。\n"
"ある意味で、それらのタグ(とdocstring)の修飾となる。\n"
"基本的には、\"(see OTHEROBJECT)\"から始まるdocstring(又はタグ)は\n"
"\"OTHEROBJECT\"に暗黙的にリンクされる。これによって\n"
"何らかのデータをdocstringやタグからあなたの作業オブジェクトの中へコピーするこ"
"とができる。\n"
"例を考えてみる。"

#: ../docs/GettingStarted.md:106
msgid ""
"    class MyWebServer\n"
"      # Handles a request\n"
"      # @param [Request] request the request object\n"
"      # @return [String] the resulting webpage\n"
"      def get(request) \"hello\" end"
msgstr ""
"    class MyWebServer\n"
"      # リクエストを操作する\n"
"      # @param [Request] request the request object\n"
"      # @return [String] the resulting webpage\n"
"      def get(request) \"hello\" end"

#: ../docs/GettingStarted.md:112
msgid ""
"      # (see #get)\n"
"      def post(request) \"hello\" end\n"
"    end"
msgstr ""
"      # (see #get)\n"
"      def post(request) \"hello\" end\n"
"    end"

#: ../docs/GettingStarted.md:116
msgid ""
"The above `#post` method takes the docstring and all tags (`param` and "
"`return`)\n"
"of the `#get` method. When you generate HTML documentation, you will see "
"this\n"
"duplication automatically, so you don't have to manually type it out. We "
"can\n"
"also add our own custom docstring information below the \"see\" reference, "
"and\n"
"whatever we write will be appended to the docstring:"
msgstr ""
"上の `#post` メソッドは `#get` メソッドのdocstrigと\n"
"全てのタグ( `param` 及び `return` )を取得する。\n"
"HTMLドキュメントを生成する時には、\n"
"`#get` メソッドのタグの内容が自動的に複製されるので、\n"
"あなたが手でタイプする必要は無い。\n"
"また\"see\"の参照の下に、自分でカスタマイズしたdocstring情報を追加できる。\n"
"そして、以下の例の様に、\n"
"私達が書くものがどんなものでも、docstringに追加される。"

#: ../docs/GettingStarted.md:122
msgid ""
"    # (see #get)\n"
"    # @note This method may modify our application state!\n"
"    def post(request) self.state += 1; \"hello\" end"
msgstr ""
"    # (see #get)\n"
"    # @note このメソッドはアプリケーションの状態が変更されるかもしれない\n"
"    def post(request) self.state += 1; \"hello\" end"

#: ../docs/GettingStarted.md:126
msgid ""
"Here we added another tag, but we could have also added plain text. The\n"
"text must be appended *after* the `(see ...)` statement, preferably on\n"
"a separate line."
msgstr ""
"ここでは他のタグ(@note)を追加したが、他に簡単なテキストを持つこともできる。\n"
"その時はできればテキストを、`(see ...)`ステートメントの次の行に追加すべきである。"

#: ../docs/GettingStarted.md:130
msgid ""
"Note that we don't have to \"refer\" the whole docstring. We can also link\n"
"individual tags instead. Since \"get\" and \"post\" actually have different\n"
"descriptions, a more accurate example would be to only refer our parameter\n"
"and return tags:"
msgstr ""
"次の事に留意する。\n"
"必ずしもdocstring全体を\"参照\"する必要はなく、\n"
"代わりに個々のタグをリンクすることができる。\n"
"実際に異なる説明を持っている\"get\"と\"post\"から、\n"
"より正確な例はパラメータやリターンタグ参照だけになる。"

#: ../docs/GettingStarted.md:135
msgid ""
"    class MyWebServer\n"
"      # Handles a GET request\n"
"      # @param [Request] request the request object\n"
"      # @return [String] the resulting webpage\n"
"      def get(request) \"hello\" end"
msgstr ""
"    class MyWebServer\n"
"      # GETリクエストを操作する\n"
"      # @param [Request] request the request object\n"
"      # @return [String] the resulting webpage\n"
"      def get(request) \"hello\" end"

#: ../docs/GettingStarted.md:141
msgid ""
"      # Handles a POST request\n"
"      # @note This method may modify our application state!\n"
"      # @param (see #get)\n"
"      # @return (see #get)\n"
"      def post(request) self.state += 1; \"hello\" end\n"
"    end"
msgstr ""
"      # POSTリクエストを操作する\n"
"      # @note This method may modify our application state!\n"
"      # @param (see #get)\n"
"      # @return (see #get)\n"
"      def post(request) self.state += 1; \"hello\" end\n"
"    end"

#: ../docs/GettingStarted.md:148
msgid ""
"The above copies all of the param and return tags from `#get`. Note that "
"you\n"
"cannot copy individual tags of a specific type with this syntax."
msgstr ""
"上の構文は、 `#get` から@paramタグと@returnタグの全ての情報をコピーする。\n"
"次の事に留意する。\n"
"この構文を用いても特定の型の個々のタグをコピーできない。"

#: ../docs/GettingStarted.md:151
msgid "## Declaring Types"
msgstr "## 型を宣言する"

#: ../docs/GettingStarted.md:153
msgid ""
"Some tags also have an optional \"types\" field which let us declare a list "
"of\n"
"types associated with the tag. For instance, a return tag can be declared\n"
"with or without a types field."
msgstr ""
"いくつかのタグは省略可能な\"型\"フィールドも持つ。\n"
"それは関連する型のリストを宣言する場所となる。\n"
"例えば、@returnタグは、\n"
"型フィールドがあってもなくても宣言できる。"

#: ../docs/GettingStarted.md:157
msgid ""
"    # @return [String, nil] the contents of our object or nil\n"
"    #   if the object has not been filled with data.\n"
"    def validate; end"
msgstr ""
"    # @return [String, nil] オブジェクトやnilとなる。\n"
"    #   nilはデータと共に内容が入っていない場合になる。(ここまでreturnのコメ"
"ント)\n"
"    def validate; end"

#: ../docs/GettingStarted.md:161
msgid ""
"    # We don't care about the \"type\" here:\n"
"    # @return the object\n"
"    def to_obj; end"
msgstr ""
"    # 以下の様に\"型\"を気にする必要はない\n"
"    # @return the object\n"
"    def to_obj; end"

#: ../docs/GettingStarted.md:165
msgid ""
"The list of types is in the form `[type1, type2, ...]` and is mostly free-"
"form,\n"
"so we can also specify duck-types or constant values. For example:"
msgstr ""
"この型のリストは `[type1, type2, ...]` の形式である。\n"
"そして大部分はフリーフォームとなる。\n"
"したがってダックタイプ、又は、定数を指定する。\n"
"例えば、"

#: ../docs/GettingStarted.md:168
msgid ""
"    # @param [#to_s] argname any object that responds to `#to_s`\n"
"    # @param [true, false] argname only true or false"
msgstr ""
"    # @param [#to_s] argname any object that responds to `#to_s`\n"
"    # @param [true, false] argname only true or false"

#: ../docs/GettingStarted.md:171
msgid ""
"Note the latter example can be replaced by the meta-type \"Boolean\".\n"
"Another meta-type is \"void\", which stands for \"no meaningful value\"\n"
"and is used for return values. These meta-types are by convention\n"
"only, but are recommended."
msgstr ""
"次の事に留意する。\n"
"後の例は、メタタイプの\"Boolean\"によって置換される。\n"
"他のメタタイプは\"void\"で\"意味のない値\"用であり、戻り値用に利用される。\n"
"これらのメタタイプは慣習で利用されるだけだが推奨される。"

#: ../docs/GettingStarted.md:176
msgid ""
"List types can be specified in the form `CollectionClass<ElementType, ..."
">`.\n"
"For instance, consider the following Array that holds a set of Strings and\n"
"Symbols:"
msgstr ""
"型のリストは、`CollectionClass<ElementType, ...>`形式の中で指定されることができる。\n"
"例として、以下のArrayはStringそしてSymbolのセットをもっていると考える。"

#: ../docs/GettingStarted.md:180
msgid ""
"    # @param [Array<String, Symbol>] list the list of strings and symbols."
msgstr "    # @param [Array<String, Symbol>] list the list of strings and symbols."

#: ../docs/GettingStarted.md:182
msgid ""
"We mentioned that these type fields are \"mostly\" free-form. In truth, "
"they\n"
"are defined \"by convention\". To view samples of common type "
"specifications\n"
"and recommended conventions for writing type specifications, see\n"
"[http://yardoc.org/types.html](http://yardoc.org/types.html). Note that "
"these\n"
"conventions may change every now and then, although we are working on a "
"more\n"
"\"formal\" type specification proposal."
msgstr ""
"我々が述べてきたこれらのフィールドの型は殆どがフリーフォームである。\n"
"実のところ,それらは慣習によって定義される。\n"
"型の指定用に一般的な型指定の例や推奨される慣習を調べるには、\n"
"[http://yardoc.org/types.html](http://yardoc.org/types.html)を参照\n"
"これらの慣習はいつの日か変更されるかもしれない、\n"
"けれども我々はより正式な型指定の提案に取りかかっている。"

#: ../docs/GettingStarted.md:189
msgid "## Documenting DSL Methods"
msgstr "## DSLメソッドを記述する"

#: ../docs/GettingStarted.md:191
msgid ""
"Application code in Ruby often makes use of DSL style metaprogrammed "
"methods.\n"
"The most common is the `attr_accessor` method, which of course has built-in\n"
"support in YARD. However, frameworks and libraries often expose custom\n"
"methods that perform similar metaprogramming tasks, and it is often useful\n"
"to document their functionality in your application. Consider the "
"`property`\n"
"method in a project like [DataMapper](http://datamapper.org), which creates\n"
"a typed attribute for a database model. The code might look like:"
msgstr ""
"Rubyの中のアプリケーションコードは、\n"
"DSLスタイルのメタプログラミングしたメソッドをよく利用する。\n"
"最も一般的なのは、 `attr_accessor` メソッドで、\n"
"もちろんYARDの中でビルトインサポートされている。\n"
"とはいうものの、フレームワークやライブラリでは、\n"
"大抵似たようなメタプログラミング作業を実行するカスタムメソッドを目にする。\n"
"そして、それはアプリケーションの中にある機能を記述する為に便利である。\n"
"[DataMapper](http://datamapper.org)のようにプロジェクトの中の `property` メソッドを考え、\n"
"そして、データベースモデル用の属性の型を作成すると\n"
"コー​​ドは次のようになる。"

#: ../docs/GettingStarted.md:199 ../docs/GettingStarted.md:209
#: ../docs/GettingStarted.md:263 ../docs/GettingStarted.md:293
msgid ""
"    class Post\n"
"      include DataMapper::Resource"
msgstr ""
"    class Post\n"
"      include DataMapper::Resource"

#: ../docs/GettingStarted.md:202
msgid ""
"      property :title, String\n"
"    end"
msgstr ""
"      property :title, String\n"
"    end"

#: ../docs/GettingStarted.md:205
msgid ""
"As of version 0.7.0, YARD will automatically pick up on these basic methods "
"if\n"
"you document them with a docstring. Therefore, simply adding some comments "
"to\n"
"the code will cause it to generate documentation:"
msgstr ""
"0.7.0版の時点で、もしあなたが今まで紹介した例のdocstringを記述した場合、\n"
"YARDは組み込みの基本メソッドによって自動的に取得するだろう。\n"
"したがって、簡単にドキュメントを生成しいくつかのコメントを追加するには、\n"
"以下の様に記述できる。"

#: ../docs/GettingStarted.md:212
msgid ""
"      # @return [String] the title property of the post\n"
"      property :title, String\n"
"    end"
msgstr ""
"      # @return [String] the title property of the post\n"
"      property :title, String\n"
"    end"

#: ../docs/GettingStarted.md:216
msgid ""
"Note that YARD uses the first argument in the method call to determine the\n"
"method name. In some cases, this would not be the method name, and you "
"would\n"
"need to declare it manually. You can do so with the `@!method` directive:"
msgstr ""
"次の事に留意する。\n"
"YARDはメソッド名を決定するのに、メソッド呼び出しの最初に引数を使う。\n"
"もし、これがメソッド名でない場合、手動で宣言する必要がある。\n"
"下の`@method`タグで宣言を行うことができる。"

#: ../docs/GettingStarted.md:220
msgid ""
"    # @!method foo\n"
"    create_a_foo_method"
msgstr ""
"    # @!method foo\n"
"    create_a_foo_method"

#: ../docs/GettingStarted.md:223
msgid ""
"The @!method directive can also accept a full method signature with "
"parameters:"
msgstr ""
"@!method 命令は\n"
"完全なメソッドのシグネチャ受け入れる事もできる。"

#: ../docs/GettingStarted.md:225
msgid ""
"    # @!method foo(name, opts = {})\n"
"    create_a_foo_method"
msgstr ""
"    # @!method foo(name, opts = {})\n"
"    create_a_foo_method"

#: ../docs/GettingStarted.md:228
msgid ""
"You can also set visibility and scope, or modify the method signature with\n"
"extra tags. The following adds documentation for a private class method:"
msgstr ""
"あなたは可視性やスコープも設定できたり、\n"
"追加のタグを用いメソッド用法を変更できる。\n"
"以下は、privateクラスメソッドに対してドキュメントに追加する。"

#: ../docs/GettingStarted.md:231
msgid ""
"    # @!method foo(opts = {})\n"
"    # The foo method!\n"
"    # @!scope class\n"
"    # @!visibility private\n"
"    create_a_private_foo_class_method"
msgstr ""
"    # @!method foo(opts = {})\n"
"    # The foo method!\n"
"    # @!scope class\n"
"    # @!visibility private\n"
"    create_a_private_foo_class_method"

#: ../docs/GettingStarted.md:237
msgid ""
"Finally, you can tag a method as an attribute by replacing the @!method\n"
"tag with @!attribute. The @!attribute directive allows for the flags [r], "
"[w],\n"
"or [rw] to declare a readonly, writeonly, or readwrite attribute, "
"respectively."
msgstr ""
"最終的に、@!attributeタグを用い@!methodタグを\n"
"置換する事によって属性の様にメソッドのタグが出来る。\n"
"読み込み専用,書込み専用,読み書きOK,個々に指定を宣言する為に\n"
"@!attribute指令は[r], [w], [rw]フラグ用に受け入れる\n"

#: ../docs/GettingStarted.md:241
msgid ""
"    # @!attribute [w]\n"
"    # The writeonly foo attribute!\n"
"    a_writeonly_attribute :foo"
msgstr ""
"    # @!attribute [w]\n"
"    # The writeonly foo attribute!\n"
"    a_writeonly_attribute :foo"

#: ../docs/GettingStarted.md:245
msgid ""
"(Note that if the name can be automatically detected, you do not need to\n"
"specify it in the @!method or @!attribute directives)"
msgstr ""
"(次のことに留意する。\n"
"名前が自動で認められる場合、@!methodや@!attributeタグの記入を\n"
"必要としないことに注意する。)"

#: ../docs/GettingStarted.md:248
msgid "However, you will notice a few drawbacks with this basic support:"
msgstr ""
"とはいうものの、あなたはこの基本サポートの備えるいくつかの欠点に気づくだろ"
"う。"

#: ../docs/GettingStarted.md:250
msgid ""
"1. There is a fair bit of duplication in such documentation. Specifically, "
"we\n"
"   repeat the term String and title twice in the property example.\n"
"2. We must write a code comment for this property to show up in the "
"documentation.\n"
"   If we do not write a comment, it is ignored."
msgstr ""
"1. このようなドキュメントでは重複を少し整形する。\n"
"   具体的には、繰り返しのString用語やproperty例の中の2度目のタイトル\n"
"2. 私達はドキュメントに表示する為、propertyでコードのコメントを書かなければな"
"らない。\n"
"   コメントを書かない場合、それは無視される。"

#: ../docs/GettingStarted.md:255
msgid "### Macros"
msgstr "### マクロ"

#: ../docs/GettingStarted.md:257
msgid ""
"Fortunately YARD 0.7.0 also adds macros, a powerful way to add support for\n"
"these DSL methods on the fly without writing extra plugins. Macros allow\n"
"you to interpolate arguments from the method call inside the docstring,\n"
"reducing duplication. If we re-wrote the `property` example from above\n"
"using a macro, it might look like:"
msgstr ""
"幸運にも、YARD 0.7.0はマクロも追加する。\n"
"これらのDSLメソッドは余計なプラグインを記述することなく\n"
"オンザフライでサポートを追加する為の強力な方法となる。\n"
"マクロは重複を減らしたり、docstring内部のメソッド\n"
"呼び出しから引数を挿入することを可能にする。\n"
"もし私達が、例の`property`をマクロを用いて書き直した場合は、\n"
"次のようになる。"

#: ../docs/GettingStarted.md:266
msgid ""
"      # @!macro dm.property\n"
"      # @return [$2] the $1 $0 of the post\n"
"      property :title, String\n"
"    end"
msgstr ""
"      # @!macro dm.property\n"
"      # @return [$2] the $1 $0 of the post\n"
"      property :title, String\n"
"    end"

#: ../docs/GettingStarted.md:271
msgid ""
"(Note that $0 represents the method call, in this case `property`. The rest\n"
"are arguments in the method call.)"
msgstr ""
"(次の事に留意する。\n"
"$0はメソッド呼び出しを表す、この場合は`property`となる。\n"
"残りはメソッド呼び出しの引数となる。)"

#: ../docs/GettingStarted.md:274
msgid ""
"The above example is equivalent to the first version shown in the previous\n"
"section. There is also some extra benefit to using this macro, in that we\n"
"can re-apply it to any other property in our class by simply calling on\n"
"the macro. The following:"
msgstr ""
"上の例は、前項の中の最初の訳文と等しい。\n"
"このマクロを使うことによっていくつかの特別な恩恵もある。\n"
"それは、マクロを簡単に呼び出すことによって、\n"
"例のクラスの中の他のpropertyに最適用できる。\n"
"以下の例は、"

#: ../docs/GettingStarted.md:279
msgid ""
"    # @!macro dm.property\n"
"    property :view_count, Integer"
msgstr ""
"    # @!macro dm.property\n"
"    property :view_count, Integer"

#: ../docs/GettingStarted.md:282
msgid "Would be equivalent to:"
msgstr "下と同等になる。"

#: ../docs/GettingStarted.md:284
msgid ""
"    # @return [Integer] the view_count property of the post\n"
"    property :view_count, Integer"
msgstr ""
"    # @return [Integer] the view_count property of the post\n"
"    property :view_count, Integer"

#: ../docs/GettingStarted.md:287
msgid ""
"Finally, macros can be \"attached\" to method calls, allowing them to be "
"implicitly\n"
"activated every time the method call is seen in the source code of the "
"class,\n"
"or an inheriting class. By simply adding the `[attach]` flag, the macro\n"
"becomes implicit on future calls. All of the properties below get "
"documented\n"
"by using this snippet:"
msgstr ""
"最終的に、メソッド呼び出しの為に\"追加\"されるマクロは、\n"
"クラスや継承クラスのソースコードの中で見られるメソッド呼び出しを\n"
"いつでも起動できる様に実装される。\n"
"単に `[attach]` フラグを追加することで、\n"
"そのマクロは将来の呼び出しで暗黙的に呼び出される。\n"
"下記のすべてのpropertyは、このスニペットを使用してドキュメントになる。"

#: ../docs/GettingStarted.md:296
msgid ""
"      # @!macro [attach] dm.property\n"
"      # @return [$2] the $1 $0 of the post\n"
"      property :title, String\n"
"      property :view_count, Integer\n"
"      property :email, String\n"
"    end"
msgstr ""
"      # @!macro [attach] dm.property\n"
"      # @return [$2] the $1 $0 of the post\n"
"      property :title, String\n"
"      property :view_count, Integer\n"
"      property :email, String\n"
"    end"

#: ../docs/GettingStarted.md:303
msgid ""
"You can read more about macros in the {file:docs/Tags.md Tags Overview} "
"document."
msgstr ""
"もっとマクロについて知りたい場合は\n"
"{file:docs/Tags.md Tags Overview}ドキュメントの中で読むことができる。"

#: ../docs/GettingStarted.md:305
msgid "## Customized YARD Markup"
msgstr "## YARDマークアップのカスタマイズ"

#: ../docs/GettingStarted.md:307
msgid ""
"YARD supports a special syntax to link to other code objects, URLs, files,\n"
"or embed docstrings between documents. This syntax has the general form\n"
"of `{Name OptionalTitle}` (where `OptionalTitle` can have spaces, but "
"`Name`\n"
"cannot)."
msgstr ""
"YARDは他のコードオブジェクト、URL、ファイル、\n"
"ドキュメントの間で組み込むdocstringへのリンクの特別な構文をサポートする。\n"
"この構文は、`{Name OptionalTitle}`の一般的な型を持っている。\n"
"(`OptionalTitle`内でスペースを入れることはできるが、\n"
" `Name`は入れることができない)"

#: ../docs/GettingStarted.md:312
msgid "### Linking Objects `{...}`"
msgstr "### オブジェクトのリンク `{...}`"

#: ../docs/GettingStarted.md:314
msgid ""
"To link another \"object\" (class, method, module, etc.), use the format:"
msgstr ""
"他の\"オブジェクト\"(クラス、メソッド、モジュール、 etc.)へのリンクには、\n"
"以下の書式を使う:"

#: ../docs/GettingStarted.md:316
msgid ""
"    {ObjectName#method OPTIONAL_TITLE}\n"
"    {Class::CONSTANT My constant's title}\n"
"    {#method_inside_current_namespace}"
msgstr ""
"    {ObjectName#method OPTIONAL_TITLE}\n"
"    {Class::CONSTANT My constant's title}\n"
"    {#method_inside_current_namespace}"

#: ../docs/GettingStarted.md:320
msgid ""
"Without an explicit title, YARD will use the relative path to the object as\n"
"the link name. Note that you can also use relative paths inside the object\n"
"path to refer to an object inside the same namespace as your current "
"docstring."
msgstr ""
"明確なタイトルが無い時、YARDはオブジェクトのリンク名に相対パスを使う。\n"
"次の事に留意する。\n"
"現在のdocstringのように同じnamespace内にあるオブジェクトを参照する為に、\n"
"そのオブジェクトパス内で相対パスを使える。"

#: ../docs/GettingStarted.md:324
msgid ""
"Note that the `@see` tag automatically links its data. You should not use\n"
"the link syntax in this tag:"
msgstr ""
"次の事に留意する。`@see`タグは自動リンクとなるので、\n"
"このタグのなかでリンク構文を使うべきではない。"

#: ../docs/GettingStarted.md:327
msgid ""
"    # @see #methodname   <- Correct.\n"
"    # @see {#methodname} <- Incorrect."
msgstr ""
"    # @see #methodname   <- 正.\n"
"    # @see {#methodname} <- 誤."

#: ../docs/GettingStarted.md:330
msgid "If you want to use a Hash, prefix the first { with \"!\":"
msgstr ""
"もしあなたがハッシュを使う為にプレフィックスに、\n"
"最初の{がほしい場合\"!\"を一緒につける。"

#: ../docs/GettingStarted.md:332
msgid "   # !{ :some_key => 'value' }"
msgstr "   # !{ :some_key => 'value' }"

#: ../docs/GettingStarted.md:334
msgid "### Linking URLs `{http://...}`"
msgstr "### URLのリンク `{http://...}`"

#: ../docs/GettingStarted.md:336
msgid "URLs are also linked using this `{...}` syntax:"
msgstr "URLはこの`{...}`構文を用いリンクされる。"

#: ../docs/GettingStarted.md:338
msgid ""
"    {http://example.com Optional Title}\n"
"    {mailto:email@example.com}"
msgstr ""
"    {http://example.com Optional Title}\n"
"    {mailto:email@example.com}"

#: ../docs/GettingStarted.md:341
msgid "### Linking Files `{file:...}`"
msgstr "### ファイルのリンク `{file:...}`"

#: ../docs/GettingStarted.md:343
msgid ""
"Files can also be linked using this same syntax but by adding the `file:`\n"
"prefix to the object name. Files refer to extra readme files you added\n"
"via the command-line. Consider the following examples:"
msgstr ""
"ファイルも同じ構文を使ってリンクされる、\n"
"しかし、オブジェクト名のプレフィックスに`file:`が追加される。\n"
"ファイルはあなたがコマンドライン経由で追加した特別なreadmeファイルを参照す"
"る。\n"
"次の例を考えてみる。"

#: ../docs/GettingStarted.md:347
msgid ""
"    {file:docs/GettingStarted.md Getting Started}\n"
"    {file:mypage.html Name#anchor}"
msgstr ""
"    {file:docs/GettingStarted.md Getting Started}\n"
"    {file:mypage.html Name#anchor}"

#: ../docs/GettingStarted.md:350
msgid ""
"As shown, you can also add an optional `#anchor` if the page is an HTML link."
msgstr ""
"上のように、\n"
"そのページがHTMLリンク可能な場合は省略可能な`#anchor`を追加できる。"

#: ../docs/GettingStarted.md:352
msgid "### Embedding Docstrings `{include:...}`"
msgstr "### Docstringの組み込み `{include:...}`"

#: ../docs/GettingStarted.md:354
msgid ""
"We saw the `(see ...)` syntax above, which allowed us to link an entire "
"docstring\n"
"with another. Sometimes, however, we just want to copy docstring text "
"without\n"
"tags. Using the same `{...}` syntax, but using the `include:` prefix, we "
"can\n"
"embed a docstring (minus tags) at a specific point in the text."
msgstr ""
"私達は上の`{see ...}`構文を見たが、\n"
"それは他と一緒にdocstring丸ごとリンクすることを可能にした。\n"
"とはいうものの、タグなしでdocstringのテキストコピーのみ欲しい場合がある。\n"
"そこで、同じ`{...}`構文と`include:`プレフィックスを用いると、\n"
"テキストの特定の場所で、タグなしのdocstringを組み込むことができる。"

#: ../docs/GettingStarted.md:359
msgid ""
"    # This class is cool\n"
"    # @abstract\n"
"    class Foo; end"
msgstr ""
"    # This class is cool\n"
"    # @abstract\n"
"    class Foo; end"

#: ../docs/GettingStarted.md:363
msgid ""
"    # This is another class. {include:Foo} too!\n"
"    class Bar; end"
msgstr ""
"    # This is another class. {include:Foo} too!\n"
"    class Bar; end"

#: ../docs/GettingStarted.md:366
msgid "The docstring for Bar becomes:"
msgstr "docstringは次のようになる。"

#: ../docs/GettingStarted.md:368
msgid "    \"This is another class. This class is cool too!\""
msgstr "    \"This is another class. This class is cool too!\""

#: ../docs/GettingStarted.md:370
msgid "### Embedding Files `{include:file:...}`"
msgstr "### ファイルの埋め込み `{include:file:...}`"

#: ../docs/GettingStarted.md:372
msgid ""
"You can embed the contents of files using `{include:file:path/to/file}`,\n"
"similar to the `{include:OBJECT}` tag above. If the file uses a specific "
"markup\n"
"type, it will be applied and embedded as marked up text. The following\n"
"shows how the tag can be used inside of comments:"
msgstr ""
"`{include:file:path/to/file}`は上の`{include:OBJECT}`タグと同様に\n"
"使う事によってファイルの内容を埋め込む事ができる。\n"
"ファイルが特定のマークアップの型を使う場合は,\n"
"マークアップテキストとして埋め込まれ適用される。\n"
"次はコメントの内部で利用されるタグにどのようなものがあるか一覧する。"

#: ../docs/GettingStarted.md:377
msgid ""
"    # Here is an example of a highlighted Ruby file:\n"
"    #\n"
"    # {include:file:examples/test.rb}"
msgstr ""
"    # これはハイライトされたRubyのファイルの例である\n"
"    #\n"
"    # {include:file:examples/test.rb}"

#: ../docs/GettingStarted.md:381
msgid "### Rendering Objects `{render:...}`"
msgstr "### オブジェクトのレンダリング `{render:...}`"

#: ../docs/GettingStarted.md:383
msgid ""
"Entire objects can also be rendered in place in documentation. This can be\n"
"used for guide-style documentation which does not document the entire "
"source\n"
"tree, but instead selectively renders important classes or methods. "
"Consider\n"
"the following documentation inside of a README file:"
msgstr ""
"全てのオブジェクトはドキュメントの適当な位置に表示される。\n"
"{render:...}はガイドスタイルドキュメント用に使われるが\n"
"それは全てのソースツリーを記述しない。\n"
"しかし、代わりに重要なクラスやメソッドを選択的に表示する。\n"
"以下のREADMEファイルの内部のドキュメントを考えてみる。"

#: ../docs/GettingStarted.md:388
msgid ""
"    !!!plain\n"
"    = igLatinPay!"
msgstr ""
"    !!!plain\n"
"    = igLatinPay!"

#: ../docs/GettingStarted.md:391
msgid ""
"    This library adds pig latin methods to the string class, allowing you\n"
"    to transform sentences into pig latin."
msgstr ""
"    このライブラリはstring classの為にpig latinメソッドを追加する。\n"
"    pig latinへ文を変換する事を可能にする。"

#: ../docs/GettingStarted.md:394
msgid "    {render:String#pig_latin}"
msgstr "    {render:String#pig_latin}"

#: ../docs/GettingStarted.md:396
msgid "    You can also un-pig-latin-ify a word or sentence:"
msgstr "    あなたは単語や文を以下の様にpig-latinにしないこともできる。"

#: ../docs/GettingStarted.md:398
msgid "    {render:String#de_pig_latin}"
msgstr "    {render:String#de_pig_latin}"

#: ../docs/GettingStarted.md:400
msgid ""
"The above would render the methods in place inside the README document,\n"
"allowing you to summarize a small library in a single file."
msgstr ""
"上のように書くと、READMEドキュメント内部の{}の中のメソッドを表示する。\n"
"これによって、一つのファイルの中にライブラリの説明を要約できる。"

#: ../docs/GettingStarted.md:403
msgid "<a name=\"using\"></a>"
msgstr "<a name=\"using\"></a>"

#: ../docs/GettingStarted.md:405
msgid "## Using YARD to Generate Documentation"
msgstr "## ドキュメントを生成するYARDの使い方"

#: ../docs/GettingStarted.md:407
msgid "### `yard` Executable"
msgstr "### 実行可能な`yard`コマンド"

#: ../docs/GettingStarted.md:409
msgid ""
"YARD ships with a single executable aptly named `yard`. In addition to\n"
"generating standard documentation for your project, you would use this tool\n"
"if you wanted to:"
msgstr ""
"YARDは単一で適切に実行可能な'yard'コマンドとして送り出す。\n"
"あなたのプロジェクトの為の標準のドキュメントを生成することに加え、\n"
"次のツールも使える。"

#: ../docs/GettingStarted.md:413
msgid ""
"* Document all installed gems\n"
"* Run a local documentation server\n"
"* Generate UML diagrams using [Graphviz][graphviz]\n"
"* View `ri`-style documentation\n"
"* Diff your documentation\n"
"* Analyze documentation statistics."
msgstr ""
"* 全てのインストール済のジェムを記述する\n"
"* ローカルドキュメントサーバーを起動する\n"
"* [Graphviz][graphviz]によってUML図を生成する\n"
"* `ri`スタイルドキュメントを一覧する\n"
"* あなたのドキュメントの差分を見る\n"
"* ドキュメントの統計を解析する"

#: ../docs/GettingStarted.md:420
msgid ""
"The following commands are available in YARD 0.6.x (see `yard help` for a\n"
"full list):"
msgstr ""
"以下のコマンドは、YARD 0.6.xで利用できる。\n"
"(`yard help`コマンドで全てのリストが見れる)"

#: ../docs/GettingStarted.md:423
msgid "    Usage: yard <command> [options]"
msgstr ""
"    !!!plain\n"
"    Usage: yard <コマンド> [オプション...]"

#: ../docs/GettingStarted.md:425
msgid ""
"    Commands:\n"
"    config   Views or edits current global configuration\n"
"    diff     Returns the object diff of two gems or .yardoc files\n"
"    doc      Generates documentation\n"
"    gems     Builds YARD index for gems\n"
"    graph    Graphs class diagram using Graphviz\n"
"    help     Retrieves help for a command\n"
"    ri       A tool to view documentation in the console like `ri`\n"
"    server   Runs a local documentation server\n"
"    stats    Prints documentation statistics on a set of files"
msgstr ""
"    Commands:\n"
"    config   設定を見るか、現在の全体的な構成を編集する\n"
"    diff     2つのgemsまたは、'.yardoc'ファイルのオブジェクトの差分を返す\n"
"    doc      ドキュメントを生成する\n"
"    gems     gemsにYARDのインデックスを組み込む\n"
"    graph    Graphvizを用いてクラス図を図示する\n"
"    help     ヘルプコマンド\n"
"    ri       `ri`のようにコンソールの中でドキュメントを作成する\n"
"    server   ローカルなドキュメント作成サーバーを起動する\n"
"    stats    設定したファイルのドキュメントのステータスを出力する"

#: ../docs/GettingStarted.md:436
msgid ""
"Note that `yardoc` is an alias for `yard doc`, and `yri` is an alias for\n"
"`yard ri`. These commands are maintained for backwards compatibility."
msgstr ""
"次の事に留意する。\n"
"`yardoc`は、`yard doc`コマンドのエイリアスで,\n"
"`yri`は`yard ri`コマンドのエイリアスとなる。\n"
"これらのコマンドは、後方互換が維持されている。"

#: ../docs/GettingStarted.md:439
msgid "### `.yardopts` Options File"
msgstr "### `.yardopts` 設定ファイル"

#: ../docs/GettingStarted.md:441
msgid ""
"Unless your documentation is very small, you'll end up needing to run "
"`yardoc`\n"
"with many options.  The `yardoc` tool will use the options found in this "
"file.\n"
"It is recommended to check this in to your repository and distribute it "
"with\n"
"your source. This file is placed at the root of your project (in the "
"directory\n"
"you run `yardoc` from) and contains all of arguments you would otherwise "
"pass\n"
"to the command-line tool. For instance, if you often type:"
msgstr ""
"ドキュメントが小さくない限り、\n"
"結局`yardoc`コマンドと一緒にたくさんの設定を必要としているだろう。\n"
"`yardoc`コマンドは.yardoptsファイルの中で見つけた設定を使う。\n"
"その為、あなたのリポジトリに入れてソースと一緒に配布することを推奨する。\n"
"このファイルはあなたのプロジェクトのルートに位置する。\n"
"(あなたが`yardoc`を起動するディレクトリの中からの)\n"
"そして、全ての引数を含んでなければコマンドラインではパスしないだろう。\n"
"例えば、以下をよくタイプするならば、"

#: ../docs/GettingStarted.md:448
msgid "    yardoc --no-private --protected app/**/*.rb - README LEGAL COPYING"
msgstr "    yardoc --no-private --protected app/**/*.rb - README LEGAL COPYING"

#: ../docs/GettingStarted.md:450
msgid "You can place the following into your `.yardopts`:"
msgstr "下の内容を`.yardopts`の中へ書くことで設定できる。"

#: ../docs/GettingStarted.md:452
msgid "    --no-private --protected app/**/*.rb - README LEGAL COPYING"
msgstr "    --no-private --protected app/**/*.rb - README LEGAL COPYING"

#: ../docs/GettingStarted.md:454
msgid "This way, you only need to type:"
msgstr "この方法を用いると、以下をタイプするだけでよい。"

#: ../docs/GettingStarted.md:456
msgid "    yardoc"
msgstr "    yardoc"

#: ../docs/GettingStarted.md:458
msgid ""
"Any extra switches passed to the command-line now will be appended to your\n"
"`.yardopts` options."
msgstr "あなたの`.yardopts`設定にコマンドラインに渡された引数は追加される。"

#: ../docs/GettingStarted.md:461
msgid ""
"Note that options for `yardoc` are discussed in the {file:README.md "
"README},\n"
"and a full overview of the `.yardopts` file can be found in {YARD::CLI::"
"Yardoc}."
msgstr ""
"次の事に留意する。\n"
"`yardoc`用のオプションは {file:README.md README} の中で説明される。\n"
"全ての`.yardopts`ファイルの概要は {YARD::CLI::Yardoc} の中で見つけられる。"

#: ../docs/GettingStarted.md:464
msgid "### Documenting Extra Files"
msgstr "### 追加のファイルを記述する"

#: ../docs/GettingStarted.md:466
msgid ""
"\"Extra files\" are extra guide style documents that help to give a brief "
"overview\n"
"of how to use your library/framework, as well as any extra information that\n"
"might be vital for your users. The most common \"extra file\" is the "
"README,\n"
"which is automatically detected by YARD if found in the root of your "
"project\n"
"(any file starting with `README*`). You can specify extra files on the "
"command\n"
"line (or in the `.yardopts` file) by listing them after the '-' separator:"
msgstr ""
"\"Extra files\"はライブラリやフレームワークで使うのにも、\n"
"ユーザーにとっての何らかの特別な情報にも、\n"
"簡単な概要を提供することを助ける\n"
"追加のガイドスタイルドキュメントとなる。\n"
"最も一般的な\"extra file\"はREADMEで、\n"
"それは、もしあなたのプロジェクトのルートの中で見つけた場合、YARDによって自動"
"で検出する。\n"
"(`README*`で始まる何らかのファイル)\n"
"以下の用に、追加のファイルの前に'-'セパレータを記述することによって\n"
"コマンドライン上で(又は,`.yardopts`ファイル内で)指定できる。"

#: ../docs/GettingStarted.md:473
msgid "    yardoc lib/**/*.rb ext/**/*.c - LICENSE.txt"
msgstr "    yardoc lib/**/*.rb ext/**/*.c - LICENSE.txt"

#: ../docs/GettingStarted.md:475
msgid ""
"Note that the README will automatically be picked up, so you do not need to\n"
"specify it. If you don't want to modify the default file globs, you can "
"ignore\n"
"the first set of arguments:"
msgstr ""
"次の事に留意する。\n"
"READMEは、自動で選択される。\n"
"従って、それを指定する必要はない。\n"
"もしデフォルトのファイルglobを変更しないなら\n"
"最初に設定する引数は無視できる。"

#: ../docs/GettingStarted.md:479
msgid "    yardoc - LICENSE.txt"
msgstr "    yardoc - LICENSE.txt"

#: ../docs/GettingStarted.md:481
msgid ""
"Below you can read about how to customize the look of these extra files, "
"both\n"
"with markup and pretty titles."
msgstr ""
"以降は追加のファイルをカスタマイズする方法について読むことができる。\n"
"これによってマークアップやいいタイトル両方を使用できる。"

#: ../docs/GettingStarted.md:484
msgid "#### Adding Meta-Data to Extra Files"
msgstr "#### 追加のファイルにメタデータを追加する"

#: ../docs/GettingStarted.md:486
msgid ""
"You can add YARD-style `@tag` metadata to the top of any extra file if "
"prefixed\n"
"by a `#` hash comment. YARD allows for arbitrary meta-data, but pays "
"special\n"
"attention to the tags `@markup`, `@encoding`, and `@title`. Note that there\n"
"cannot be any whitespace before the tags. Here is an example of some tag "
"data\n"
"in a README:"
msgstr ""
"`#`のハッシュコメントによってプレフィックスした場合、\n"
"任意の追加のファイルのトップにYARDスタイルの`@tag`メタデータを追加できる。\n"
"YARDは任意のメタデータを受け入れる。\n"
"しかし`@markup`,`@encoding`,`@title`タグには特別な注意を払わなければならない。\n"
"次の事に留意する。\n"
"タグの前に空白があってはならない。\n"
"これはREADMEの中のいくつかのタグデータの例:"

#: ../docs/GettingStarted.md:492
msgid ""
"    # @markup markdown\n"
"    # @title The Best Library in the World!\n"
"    # @author The Author Name"
msgstr ""
"    # @markup markdown\n"
"    # @title The Best Library in the World!\n"
"    # @author The Author Name"

#: ../docs/GettingStarted.md:496
msgid "    This is the best library you will ever meet. Lipsum ..."
msgstr "    これはあなたが出会う最高のライブラリとなる。以下略..."

#: ../docs/GettingStarted.md:498
msgid ""
"The `@markup` tag allows you to specify a markup format to use for the "
"file,\n"
"including \"markdown\", \"textile\", \"rdoc\", \"ruby\", \"text\", \"html\", "
"or \"none\"\n"
"(no markup). This can be used when the markup cannot be auto-detected using\n"
"the extension of the filename, if the file has no extension, or if you want\n"
"to override the auto-detection."
msgstr ""
"`@markup`タグは、\"markdown\", \"textile\", \"rdoc\", \"ruby\", \n"
"\"text\", \"html\", \"none\"(no markup)を含んでいるファイルを扱えるよう、\n"
"マークアップ書式の指定を可能にする。\n"
"このマークアップはファイル名の拡張子を自動検出できなかった時や、\n"
"ファイル名の拡張子がない時や、\n"
"あなたが(拡張子の)自動検出を上書きしたい時に使われる。"

#: ../docs/GettingStarted.md:504
msgid ""
"By using `@encoding` you can specify a non-standard encoding. Note that\n"
"`yardoc --charset` sets the global encoding (for all comments / files),\n"
"so if you are using unicode across all your files, you can specify it "
"there.\n"
"Using the `@encoding` tag might be used to override the default global\n"
"charset, say, if you had a localized `README.jp` file with SJIS data.\n"
"Also note that this only affects Ruby 1.9.x, as Ruby 1.8 is not properly\n"
"encoding aware."
msgstr ""
"`@encoding`を使用することによって、\n"
"あなたは非標準のエンコーディングを指定できる。\n"
"次の事に留意する。\n"
"`yardoc --charset`は全体のエンコーディングを設定する(全てのコメント/ファイル)、\n"
"なので、もしあなたが全てのファイルでユニコードを使っているならこれを指定できる。\n"
"例えば、ローカライズした`README.jp`ファイルとSJISデータをもっていたら\n"
"`@encoding`タグを使うことによって、default global charsetを上書きする為に\n"
"使うことができる。\n"
"又、これはRuby1.9.xにだけ作用する、\n"
"Ruby1.8については適切なエンコーディングになっていない。"

#: ../docs/GettingStarted.md:512
msgid ""
"The `@title` tag allows you to specify a full title name for the document.\n"
"By default, YARD uses the filename as the title of the document and lists\n"
"it in the file list in the index and file menu. In some cases, the file "
"name\n"
"might not be descriptive enough, so YARD allows you to specify a full title:"
msgstr ""
"`@title`タグはそのドキュメントでフルタイトル名による指定を許可する。\n"
"デフォルトでは、YARDはドキュメントのタイトルにファイル名を使う。\n"
"そして、ファイルリストの中のインデックスやファイルメニューを列挙する。\n"
"一部の例では、ファイル名は十分に説明できないかもしれない、\n"
"その為、YARDはあなたがフルタイトルを指定することを認めている。"

#: ../docs/GettingStarted.md:517
msgid ""
"    contents of TITLE.txt:\n"
"    # @title The Title of The Document"
msgstr ""
"    contents of TITLE.txt:\n"
"    # @title The Title of The Document"

#: ../docs/GettingStarted.md:520
msgid ""
"Currently all other meta-data is hidden from view, though accessible\n"
"programmatically using the {YARD::CodeObjects::ExtraFileObject} class."
msgstr ""
"現在の全ての他のメタデータは一覧から隠される。そうはいうものの、\n"
"{YARD::CodeObjects::ExtraFileObject}クラスによってプログラムにアクセス可能である。"

#: ../docs/GettingStarted.md:523
msgid "<a name=\"config\"></a>"
msgstr "<a name=\"config\"></a>"

#: ../docs/GettingStarted.md:525
msgid "## Configuring YARD"
msgstr "## YARDを構成する"

#: ../docs/GettingStarted.md:527
msgid ""
"YARD (0.6.2+) supports a global configuration file stored in `~/.yard/"
"config`.\n"
"This file is stored as a YAML file and can contain arbitrary keys and "
"values\n"
"that can be used by YARD at run-time. YARD defines specific keys that are "
"used\n"
"to control various features, and they are listed in {YARD::Config::"
"DEFAULT_CONFIG_OPTIONS}.\n"
"A sample configuration file might look like:"
msgstr ""
"YARD (0.6.2)以降は`~/.yard/config`の中に格納した全体構成ファイルをサポートす"
"る。\n"
"このファイルはYAMLファイルのように格納され、\n"
"任意のキーと実行時にYARDによって利用できる値を含むことができる。\n"
"YARDは様々な機能を制御する為に使われるので特定のキーを定義する。\n"
"それは{YARD::Config::DEFAULT_CONFIG_OPTIONS}の中で列挙される。\n"
"サンプルの設定ファイルは次のようになる。"

#: ../docs/GettingStarted.md:533 ../docs/WhatsNew.md:759
msgid ""
"    :load_plugins: false\n"
"    :ignored_plugins:\n"
"      - my_plugin\n"
"      - my_other_plugin\n"
"    :autoload_plugins:\n"
"      - my_autoload_plugin\n"
"    :safe_mode: false"
msgstr ""
"    :load_plugins: false\n"
"    :ignored_plugins:\n"
"      - my_plugin\n"
"      - my_other_plugin\n"
"    :autoload_plugins:\n"
"      - my_autoload_plugin\n"
"    :safe_mode: false"

#: ../docs/GettingStarted.md:541
msgid ""
"You can also view and edit these configuration options from the commandline\n"
"using the `yard config` command. To list your configuration, use `yard "
"config --list`.\n"
"To view a key, use `yard config ITEM`, and to set it, use `yard config ITEM "
"VALUE`."
msgstr ""
"`yard config`コマンドを使って調べたり、構成設定を編集することもできる。\n"
"構成をリストするには、`yard config --list`を使う。\n"
"キーを調べるには、`yard config ITEM`, や、その値を設定する為に`yard config "
"ITEM VALUE`を使う。"

#: ../docs/GettingStarted.md:545
msgid "<a name=\"extending\"></a>"
msgstr "<a name=\"extending\"></a>"

#: ../docs/GettingStarted.md:547
msgid "## Extending YARD"
msgstr "## YARDを拡張する"

#: ../docs/GettingStarted.md:549
msgid ""
"There are many ways to extend YARD to support non-standard Ruby syntax "
"(DSLs),\n"
"add new meta-data tags or programmatically access the intermediate metadata\n"
"and documentation from code. An overview of YARD's full architecture can be\n"
"found in the {file:docs/Overview.md} document."
msgstr ""
"非標準のRuby構文(DSL)をサポートするのにYARDを拡張するための沢山の方法がある。\n"
"新しいメタデータタグの追加や\n"
"プログラム的に中間のメタデータにアクセスする方法、\n"
"コードから記述する方法など。\n"
"YARDの全体構造の概要は、\n"
"{file:docs/Overview.md}ドキュメントの中で見つけられる。"

#: ../docs/GettingStarted.md:554
msgid ""
"For information on adding support for Ruby DSLs, see the {file:docs/Handlers."
"md}\n"
"and {file:docs/Parser.md} architecture documents."
msgstr ""
"RubyDSLサポートを追加する方法については、\n"
"{file:docs/Handlers.md}や{file:docs/Parser.md}構造のドキュメントを参照。"

#: ../docs/GettingStarted.md:557
msgid "For information on adding extra tags, see {file:docs/Tags.md}."
msgstr "特別なタグを追加する方法は{file:docs/Tags.md}を参照。"

#: ../docs/GettingStarted.md:559
msgid ""
"For information on accessing the data YARD stores about your documentation,\n"
"look at the {file:docs/CodeObjects.md} architecture document."
msgstr ""
"あなたのドキュメントについて格納したYARDのデータがアクセスする方法は、\n"
"{file:docs/CodeObjects.md}構造ドキュメント参照。"

#: ../docs/GettingStarted.md:562
msgid "<a name=\"templating\"></a>"
msgstr "<a name=\"templating\"></a>"

#: ../docs/GettingStarted.md:564
msgid "## Templating YARD"
msgstr "## YARDのテンプレートを作る"

#: ../docs/GettingStarted.md:566
msgid ""
"In many cases you may want to change the style of YARD's templates or add "
"extra\n"
"information after extending it. The {file:docs/Templates.md} architecture\n"
"document covers the basics of how YARD's templating system works."
msgstr ""
"多くの場合、あなたがYARDテンプレートのスタイルを変える為や\n"
"特別な情報を後で拡張し追加する為に必要だろう。\n"
"{file:docs/Templates.md}構造ドキュメントは、\n"
"YARDテンプレートシステム作業の基本をカバーする。"

#: ../docs/GettingStarted.md:570
msgid "<a name=\"plugins\"></a>"
msgstr "<a name=\"plugins\"></a>"

#: ../docs/GettingStarted.md:572
msgid "## Plugin Support"
msgstr "## プラグインサポート"

#: ../docs/GettingStarted.md:574
msgid ""
"As of 0.4, YARD will automatically load any gem named with the prefix of\n"
"`yard-` or `yard_`. You can use this to load a custom plugin that\n"
"[extend](#extending) YARD's functionality. A good example of this\n"
"is the [yard-rspec][yard-rspec] plugin, which adds [RSpec][rspec] "
"specifications\n"
"to your documentation (`yardoc` and `yri`). You can try it out by "
"installing\n"
"the gem or cloning the project and trying the example:"
msgstr ""
"0.4以降、YARDは`yard-`や `yard_`から始まる名前のgemを\n"
"自動でロードするだろう。あなたはカスタムプラグインをロードする為に\n"
"YARDの機能の[extend](#extending)を使える。\n"
"これの良い例は[yard-rspec][yard-rspec] プラグインで、\n"
"ドキュメント(`yardoc` and `yri`)に[RSpec][rspec]の仕様を追加する。\n"
"gemをインストールすることによって、\n"
"またはプロジェクトをクローンすることで試すことができる。\n"
"例を以下に示す。"

#: ../docs/GettingStarted.md:581
msgid ""
"    $ gem install yard-rspec -s http://gemcutter.org\n"
"    or\n"
"    $ git clone git://github.com/lsegal/yard-spec-plugin"
msgstr ""
"    $ gem install yard-rspec -s http://gemcutter.org\n"
"    or\n"
"    $ git clone git://github.com/lsegal/yard-spec-plugin"

#: ../docs/GettingStarted.md:585
msgid ""
"YARD also provides a way to temporarily disable plugins on a per-user "
"basis.\n"
"To disable a plugin create the file `~/.yard/ignored_plugins` with a list\n"
"of plugin names separated by newlines. Note that the `.yard` directory "
"might\n"
"not exist, so you may need to create it."
msgstr ""
"YARDはユーザーごとの基本のプラグインを\n"
"一時的に無効にする方法も提供する。\n"
"プラグインを無効にする為には、\n"
"`~/.yard/ignored_plugins`ファイルを作り\n"
"改行によって区切られた、プラグイン名をリストする。\n"
"次の事に留意する。\n"
"`.yard`ディレクトリは存在しない場合、\n"
"作成する必要がある。"

#: ../docs/GettingStarted.md:590
msgid ""
"[graphviz]:http://www.graphviz.org\n"
"[yard-rspec]:http://github.com/lsegal/yard-spec-plugin\n"
"[rspec]:http://rspec.info"
msgstr ""
"[graphviz]:http://www.graphviz.org\n"
"[yard-rspec]:http://github.com/lsegal/yard-spec-plugin\n"
"[rspec]:http://rspec.info"

# title
#: ../docs/Handlers.md:1
msgid "Handlers Architecture"
msgstr "ハンドラー構造"

#: ../docs/Handlers.md:3
msgid "# Handlers Architecture"
msgstr "# ハンドラー構造"

#: ../docs/Handlers.md:5
msgid ""
"Handlers allow the processing of parsed source code. Handling is done after\n"
"parsing to abstract away the implementation details of lexical and semantic\n"
"analysis on source and to only deal with the logic regarding recognizing\n"
"source statements as {file:docs/CodeObjects.md code objects}."
msgstr ""
"ハンドラーは、ソースコードを解析した処理を受け入れる。\n"
"これの処理は、実行する単語の詳細の抽象化を解析の後で行う。\n"
"そして、意味のあるソースの分析や、\n"
"ロジックに関しては{file:docs/CodeObjects.md code objects}のような\n"
"ソースステートメントの受け入れだけで扱う。"

#: ../docs/Handlers.md:10
msgid ""
"![Handlers Architecture Class Diagram](images/handlers-class-diagram.png)"
msgstr "![Handlers Architecture Class Diagram](images/handlers-class-diagram.png)"

#: ../docs/Handlers.md:12
msgid "## The Pipeline"
msgstr "## パイプライン"

#: ../docs/Handlers.md:14
msgid ""
"After the {file:docs/Parser.md parser component} finishes analyzing the\n"
"source, it is handed off for post-processing to the {YARD::Handlers::"
"Processor}\n"
"class, which is responsible for traversing the set of statements given by\n"
"the parser and delegating them to matching handlers. Handlers match when "
"the\n"
"{YARD::Handlers::Base.handles?} method returns true for a given statement.\n"
"The handler can then perform any action after being invoked by the "
"`process`\n"
"method."
msgstr ""
"{file:docs/Parser.md parser component}がソースを解析すると、\n"
"後処理する為に{YARD::Handlers::Processor} クラスに渡す。\n"
"そしてパーサーによって与えるステートメントの設定を辿ったり、\n"
"ハンドラーがマッチしているステートメントを委譲する責任がある。\n"
"{YARD::Handlers::Base.handles?}メソッドがtrueを返す時、\n"
"ハンドラーがマッチしているステートメントを与える。\n"
"ハンドラーは`process`メソッドによって呼び出した後で任意の処理を実行できる。"

#: ../docs/Handlers.md:22
msgid "## The Processor Class"
msgstr "## プロセッサークラス"

#: ../docs/Handlers.md:24
msgid ""
"The main purpose of the processor, as mentioned above, is to traverse "
"through\n"
"the list of statements given to it by the parser. The processor also keeps\n"
"state about what is being processed. For instance, the processor is what "
"keeps\n"
"track of the current namespace (the module or class an object is being "
"defined\n"
"in), scope (class or instance), file and owner. The owner refers to the "
"object\n"
"that is most directly responsible for the source statement being processed. "
"This\n"
"is most often the same as the namespace, except when parsing the body of a "
"method,\n"
"where the namespace would be the class/module the method is defined in and "
"the\n"
"owner would be the method object itself."
msgstr ""
"主なプロセッサーの目的は、上で述べたように、\n"
"パーサーによって与えるステートメントのリストを通じて辿ることである。\n"
"プロセッサーは処理されている状態について管理する。\n"
"例えば、プロセッサーは現在の\n"
"ネームスペース(モジュールやオブジェクトのクラスが定義される)、\n"
"スコープ(クラスやインスタンス)、ファイルとオーナー\n"
"を追跡する。\n"
"オーナーは、オブジェクトを参照する。\n"
"そのオブジェクトは処理されるソースステートメントに最も直接的な責任を持つ。\n"
"これは(参照するオブジェクトの対象は)、多くの場合ネームスペースと同じで、\n"
"メソッドの本体を解析した時を除き、\n"
"そのネームスペースでは、クラスやモジュール,メソッドが定義される。\n"
"そしてオーナーはメソッドオブジェクト自体となる。"

#: ../docs/Handlers.md:34
msgid "## Implementing a Handler"
msgstr "## ハンドラーを実装する"

#: ../docs/Handlers.md:36
msgid ""
"This section covers the basics of implementing a *new-style* Ruby handler. "
"For\n"
"details on implementing a legacy handler, see the \"API Differences\" "
"section below."
msgstr ""
"このセクションは *新しいスタイル* Rubyハンドラー処理の基本をカバーする。\n"
"レガシーなハンドラーの詳細は、\"API Differences\" セクション以下を参照。"

#: ../docs/Handlers.md:39
msgid ""
"a Ruby handler can be implemented simply by subclassing the {YARD::Handlers::"
"Ruby::Base}\n"
"class and declaring what node types or source to process with the {YARD::"
"Handlers::Base.handles handles}\n"
"class method. A very simple handler that handles a module definition would "
"be:"
msgstr ""
"Rubyハンドラーは処理の為に、\n"
"{YARD::Handlers::Base.handles handles}クラスメソッドを用い、\n"
"{YARD::Handlers::Ruby::Base}サブクラスや、\n"
"ノードタイプやソースを宣言することによって実行される。\n"
"モジュール定義の処理は次のような非常に簡単なハンドラーである。"

#: ../docs/Handlers.md:43
msgid ""
"    class MyModuleHandler < YARD::Handlers::Ruby::Base\n"
"      handles :module"
msgstr ""
"    class MyModuleHandler < YARD::Handlers::Ruby::Base\n"
"      handles :module"

#: ../docs/Handlers.md:46
msgid ""
"      def process\n"
"        puts \"Handling a module named #{statement[0].source}\"\n"
"      end\n"
"    end"
msgstr ""
"      def process\n"
"        puts \"Handling a module named #{statement[0].source}\"\n"
"      end\n"
"    end"

#: ../docs/Handlers.md:51
msgid ""
"For details on what nodes are, and what node types are, see the\n"
"{file:docs/Parser.md parser architecture document}."
msgstr ""
"ノードやノードの型の詳細については、\n"
"{file:docs/Parser.md パーサー構造のドキュメント}を参照。"

#: ../docs/Handlers.md:54
msgid ""
"In this case the node type being handled is the `:module` type. More than "
"one\n"
"node type or `handles` declarations may describe a single handler, for "
"instance,\n"
"a handler that handles class definitions should handle the `:class` and `:"
"sclass`\n"
"node types respectively (the latter refers to classes defined as `class << "
"Something`).\n"
"The {YARD::Handlers::Base#statement statement} attribute refers to the "
"current\n"
"node (or statement) that is being handled by the handler."
msgstr ""
"このケースの場合、処理されるノードタイプは `:module` タイプである。\n"
"複数のノードタイプや `handles` 宣言は一つのハンドラーを記述する。\n"
"例えば、ハンドラーはhandlesクラス定義が `:class` や\n"
"`:sclass` ノードタイプそれぞれを処理する。\n"
"(後者の:sclassは `class << Something` のようにクラス定義を参照する。)\n"
"{YARD::Handlers::Base#statement statement}属性は、\n"
"ハンドラーによって処理される現在のノード(やステートメントを)参照する。"

#: ../docs/Handlers.md:61
msgid "### Handling a Method Call"
msgstr "### メソッド呼び出しの処理"

#: ../docs/Handlers.md:63
msgid ""
"In some cases, a developer might need to handle a method call. The parser "
"can\n"
"express a method call in many AST forms, so to simplify this process, a "
"method\n"
"call can be handled by declaring the following in a `handles` statement:"
msgstr ""
"場合によって開発者は、メソッド呼び出し操作を必要とするかもしれない。\n"
"パーサーは多くのAST型(Abstract Syntax Tree)の中で、\n"
"メソッド呼び出しを表現できる。そして、この処理を簡素化する為に、\n"
"メソッド呼び出しは、次のような`handles`ステートメントの中で宣言される事によって処理される。"

#: ../docs/Handlers.md:67
msgid ""
"    class MyHandler < YARD::Handlers::Ruby::Base\n"
"      handles method_call(:describe)"
msgstr ""
"    class MyHandler < YARD::Handlers::Ruby::Base\n"
"      handles method_call(:describe)"

#: ../docs/Handlers.md:70
msgid ""
"      def process\n"
"        # Process the method call\n"
"      end\n"
"    end"
msgstr ""
"      def process\n"
"        # メソッド呼び出しを処理する\n"
"      end\n"
"    end"

#: ../docs/Handlers.md:75
msgid ""
"In this case we handle any of the method calls to method name `describe` "
"with\n"
"the following syntaxes:"
msgstr ""
"このケースでは、私達はメソッド名`describe`メソッドの呼び出しを\n"
"次の構文のように処理できる。"

#: ../docs/Handlers.md:78
msgid ""
"    describe(something)\n"
"    describe arg1, arg2, arg3\n"
"    describe(something) { perform_a_block }\n"
"    describe \"Something\" do\n"
"      a_block\n"
"    end"
msgstr ""
"    describe(something)\n"
"    describe arg1, arg2, arg3\n"
"    describe(something) { perform_a_block }\n"
"    describe \"Something\" do\n"
"      a_block\n"
"    end"

#: ../docs/Handlers.md:85
msgid "### Creating a new Code Object"
msgstr "### 新しいコードオブジェクトを作成する"

#: ../docs/Handlers.md:87
msgid ""
"Usually (but not always) handling is performed to create new code objects to "
"add\n"
"to the registry (for information about code objects, see {file:docs/"
"CodeObjects.md this document}).\n"
"Code objects should simply be created and added to the existing `namespace`. "
"This\n"
"will be enough to add them to the registry. There is also a convenience\n"
"{YARD::Handlers::Base#register register} method which quickly sets standard "
"attributed\n"
"on the newly created object, such as the file, line, source and docstring of "
"the\n"
"object. This method will be seen in the next example."
msgstr ""
"通常(しかし、いつもではない)の処理は、\n"
"レジストリーを追加する新しいコードオブジェクトの作成する為に実行される。\n"
"(コードオブジェクトについては{file:docs/CodeObjects.md このドキュメント}を参照)\n"
"コードオブジェクトは単純に既存の `namespace` に作成され追加される。\n"
"これは、レジストリにそれらを追加するために十分である。\n"
"便利な{YARD::Handlers::Base#register register}メソッドがあり、\n"
"これは新たに作成されるオブジェクト、ファイル、行、\n"
"ソースやオブジェクトのdocstringのような標準属性を素早く設定する。\n"
"このメソッドは次の例の中で見られるだろう。"

#: ../docs/Handlers.md:95
msgid "### Handling an Inner Block"
msgstr "### 内部のブロックの操作"

#: ../docs/Handlers.md:97
msgid ""
"By default, the parser gives the processor class a list of all the top "
"level\n"
"statements and the processor parses only those top level statements. If an "
"inner\n"
"block of a module, class, method declaration or even a block passed to a "
"method call\n"
"needs to be handled, the {YARD::Handlers::Base#parse_block parse_block} "
"method must be called on the list of statements\n"
"to parse. This will send the list to the processor to continue processing on "
"that\n"
"statement list. The source tree can be selectively parsed in this manner by "
"parsing\n"
"only the inner blocks that are relevant to documentation."
msgstr ""
"デフォルトでパーサーは全てのトップレベルステートメントから、\n"
"プロセッサークラスのリストを与える。\n"
"そして、プロセッサーは、トップレベルステートメントだけ解析する。\n"
"モジュール、クラス、メソッド内でブロックが宣言される場合や、\n"
"ブロックが処理されるメソッド呼び出しを解析した場合でさえ、\n"
"{YARD::Handlers::Base#parse_block parse_block}メソッドは、\n"
"解析の為にステートメントのリストを呼び出さなければならない。\n"
"これはステートメントのリストの処理を継続するプロセッサーにリストを送信する。\n"
"ソースツリーは、ドキュメント作成に関連したブロック内だけ解析することによって、\n"
"この形式の中で選択され抜粋される。"

#: ../docs/Handlers.md:105
msgid ""
"For example, the module handler parses the inner body of a module by "
"performing\n"
"the following commands:"
msgstr ""
"例えばモジュールハンドラーは、\n"
"以下のコマンドを実行することによってモジュールから内部の本体を解析する。"

#: ../docs/Handlers.md:108
msgid ""
"    class YARD::Handlers::Ruby::ModuleHandler < YARD::Handlers::Ruby::Base\n"
"      handles :module"
msgstr ""
"    class YARD::Handlers::Ruby::ModuleHandler < YARD::Handlers::Ruby::Base\n"
"      handles :module"

#: ../docs/Handlers.md:111
msgid ""
"      def process\n"
"        modname = statement[0].source\n"
"        mod = register ModuleObject.new(namespace, modname)\n"
"        parse_block(statement[1], :namespace => mod)\n"
"      end\n"
"    end"
msgstr ""
"      def process\n"
"        modname = statement[0].source\n"
"        mod = register ModuleObject.new(namespace, modname)\n"
"        parse_block(statement[1], :namespace => mod)\n"
"      end\n"
"    end"

#: ../docs/Handlers.md:118
msgid ""
"In this case `statement[1]` refers to a list of extra statements, the block "
"we\n"
"wish to parse. Note here that when parsing objects like modules and "
"classes,\n"
"we set the namespace for the duration of the block parsing by setting "
"options\n"
"on the `parse_block` method."
msgstr ""
"この場合`statement[1]`は追加のステートメントで、\n"
"私達が解析するブロックのリストを参照する。\n"
"ここにあるように、\n"
"モジュールやクラスのようにオブジェクトを解析する時、\n"
"私達は`parse_block`メソッドのオプションが設定されることによって\n"
"解析しているブロックの範囲をネームスペースに設定する。"

#: ../docs/Handlers.md:123
msgid "### API Differences for Legacy Handler"
msgstr "### Legacy Handler用のAPIの相違点"

#: ../docs/Handlers.md:125
msgid ""
"Because the legacy handler uses the legacy parser and therefore a different "
"kind\n"
"of AST, there are subtle differences in the handler API. Most importantly, "
"the\n"
"`handles` method usually deals with either lexical tokens or source code as "
"a string\n"
"or RegExp object. The statement object, similarly, is made up of lexical "
"tokens instead\n"
"of semantically parsed nodes (this is described in the {file:docs/Parser.md "
"parser document})."
msgstr ""
"レガシーハンドラーはレガシーパーサーを使い,\n"
"それに伴い異る種類のASTがあるのでハンドラーAPIに微妙な違いがある。\n"
"最も重要なことだが、 `handles` メソッドは通常、\n"
"単語のトークンやソースコード、文字列やRegExpオブジェクトと共に処理する。\n"
"ステートメントのオブジェクトと同様、意味のある解析されるノードの代わりに、\n"
"単語のトークンから構成される。\n"
"(これは{file:docs/Parser.md パーサーのドキュメント}の中で記述される)"

#: ../docs/Handlers.md:131
msgid ""
"The module example above can be rewritten as a legacy handler as follows:"
msgstr ""
"上記のモジュール例は、次のようなレガシーハンドラーによって再書込みされる。"

#: ../docs/Handlers.md:133
msgid ""
"    class YARD::Handlers::Ruby::Legacy::ModuleHandler < YARD::Handlers::"
"Ruby::Legacy::Base\n"
"      handles TkMODULE"
msgstr ""
"    class YARD::Handlers::Ruby::Legacy::ModuleHandler < YARD::Handlers::Ruby::Legacy::Base\n"
"      handles TkMODULE"

#: ../docs/Handlers.md:136
msgid ""
"      def process\n"
"        modname = statement.tokens.to_s[/^module\\s+(#{NAMESPACEMATCH})/, "
"1]\n"
"        mod = register ModuleObject.new(namespace, modname)\n"
"        parse_block(:namespace => mod)\n"
"      end\n"
"    end"
msgstr ""
"      def process\n"
"        modname = statement.tokens.to_s[/^module\\s+(#{NAMESPACEMATCH})/, 1]\n"
"        mod = register ModuleObject.new(namespace, modname)\n"
"        parse_block(:namespace => mod)\n"
"      end\n"
"    end"

#: ../docs/Handlers.md:143
msgid "A few notes on the differences:"
msgstr "標準のハンドラーとの違いに関するいくつかの注意。"

#: ../docs/Handlers.md:145
msgid ""
"  * We inherit from `Legacy::Base` instead of the standard Ruby Base handler "
"class.\n"
"  * We exchange node type `:module` for `TkMODULE`, which represents the\n"
"    first token in the statement.\n"
"  * We perform direct string manipulation to get the module name.\n"
"  * `parse_block` does not take a list of statements. In the old parser "
"API,\n"
"    each statement has a `block` attribute which defines the list of\n"
"    statements within that statement, if any. Therefore, `parse_block` will\n"
"    always parse the `statement.block` if it exists."
msgstr ""
"  * 標準のRubyBaseハンドラークラスの代わりに `Legacy::Base` から継承する。\n"
"  * ノードタイプ `:module` を `TkMODULE` へ交換する、\n"
"    それは、ステートメントの中の最初のトークンを表す。\n"
"  * モジュール名を取得する為に直接文字列操作を実行する。\n"
"  * `parse_block`はステートメントのリストを取得しない。\n"
"    古いパーサーの中のAPIで、\n"
"    それぞれのステートメントは `block` 属性を持っていたら\n"
"    ステートメントの中にステートメントのリストを定義する、\n"
"    従って、 `parse_block` は、 `statement.block` が存在すれば解析する。"

# title
#: ../docs/Overview.md:1
msgid "Architecture Overview"
msgstr "基本設計概念の概要"

#: ../docs/Overview.md:3
msgid "# Architecture Overview"
msgstr "# 基本設計概念の概要"

#: ../docs/Overview.md:5
msgid ""
"YARD is separated in three major components, each of which allows YARD to "
"be\n"
"extended for a separate purpose. The split also emphasizes YARD's design "
"choice\n"
"to explicitly separate data gathering from HTML document generation, "
"something\n"
"that tools like RDoc do not do. These components are:"
msgstr ""
"YARDは主な構成として三つに分けられる。\n"
"いずれも、目的毎に拡張される為にYARDに受け入れられる。\n"
"これは、HTMLドキュメント生成から集めるデータを明確に分ける為に\n"
"YARD設計上の選択を重視する。"

#: ../docs/Overview.md:10
msgid ""
"* [Code Parsing & Processing Component](#parsing)\n"
"* [Data Storage Component](#storage)\n"
"* [Post Processing & Templating System](#templates)"
msgstr ""
"* [Code Parsing & Processing Component](#parsing)\n"
"* [Data Storage Component](#storage)\n"
"* [Post Processing & Templating System](#templates)"

#: ../docs/Overview.md:14
msgid ""
"This separation is a major goal of the project, and means that YARD is not "
"*just*\n"
"a tool to generate HTML output. The expectation is that any subset of "
"YARD's\n"
"major components may be used, extended or modified independently. YARD may "
"be\n"
"used just as a data gathering tool (to parse and audit code), just as a "
"data\n"
"source (a webserver containing raw unformatted data about code), or just as "
"a\n"
"conventional HTML documentation generation tool (like RDoc)."
msgstr ""
"この区分は、プロジェクトの主要な目的であり、\n"
"YARDがHTMLの出力を生成するただの道具では無い事を意味している。\n"
"期待することはYARDのメジャーな構成のサブセットが独自に利用,拡張,変更される事である。\n"
"YARDはデータ収集ツール(コードを解析,検査),\n"
"データの元(ウェブサーバーはコードについてフォーマットされて無い生のデータを含んでいる),\n"
"便利なHTMLドキュメント作成ツール(RDocのような)として利用される。"

#: ../docs/Overview.md:21
msgid ""
"The important classes and dependencies of these components are shown in the\n"
"following class diagram:"
msgstr "重要なクラスやこれらの構成の依存関係は、次のクラス図の中で表示される。"

#: ../docs/Overview.md:24
msgid "![Overview Class Diagram](images/overview-class-diagram.png)"
msgstr "![Overview Class Diagram](images/overview-class-diagram.png)"

#: ../docs/Overview.md:26
msgid "<a name=\"parsing\"></a>"
msgstr "<a name=\"parsing\"></a>"

#: ../docs/Overview.md:28
msgid "## Code Parsing & Processing Component"
msgstr "## コードの解析と処理の構成"

#: ../docs/Overview.md:30
msgid ""
"This component is made up of four sub-components, each of which have "
"separate\n"
"tasks during the data gathering process (*note: the tag architecture is "
"not*\n"
"*shown in the class diagram*). These sub-components are:"
msgstr ""
"この構成は、4つの下位構成を作り上げる、\n"
"いずれも、\n"
"データ収集処理の間,別々のタスクを持つ。\n"
"(*注意: タグ構造はクラス図)\n"
"下位構成は以下のようになる。"

#: ../docs/Overview.md:34
msgid ""
"  * {file:docs/Parser.md}\n"
"  * {file:docs/Handlers.md}\n"
"  * {file:docs/CodeObjects.md}\n"
"  * {file:docs/Tags.md}"
msgstr ""
"  * {file:docs/Parser.md}\n"
"  * {file:docs/Handlers.md}\n"
"  * {file:docs/CodeObjects.md}\n"
"  * {file:docs/Tags.md}"

#: ../docs/Overview.md:39
msgid ""
"The parser component reads source files and converts it into a set of "
"statements\n"
"which the handlers then process, creating code objects which in turn create "
"tags\n"
"(meta-data) attached to the objects. These objects are all added to the "
"{YARD::Registry},\n"
"the data store component."
msgstr ""
"パーサーの構成は、ソースファイルを読み込み、\n"
"ステートメントのグループの中へそれを変換する\n"
"コードオブジェクトを作成し,\n"
"順番にオブジェクトを追加されたタグ(メタデータ)を作成する。\n"
"これらのオブジェクトは {YARD::Registry} に全て追加される。\n"
"データは構成を記録する。"

#: ../docs/Overview.md:44
msgid "<a name=\"storage\"></a>"
msgstr "<a name=\"storage\"></a>"

#: ../docs/Overview.md:46
msgid "## Data Storage Component"
msgstr "## データの記録内容"

#: ../docs/Overview.md:48
msgid ""
"This component is currently implemented as a simple Ruby marshalled flat "
"namespace\n"
"of object. The implementation is found in the single class {YARD::Registry}, "
"which\n"
"is the centralized repository for all data being parsed, stored and "
"accessed. There\n"
"are future plans to improve this storage mechanism to be backend agnostic "
"and allow\n"
"for more robust storage."
msgstr ""
"この内容は現在の所、\n"
"単純にRubyの整理されたフラットなオブジェクトのnamespaceのように実装されている。\n"
"実装はシングルクラスの{YARD::Registry}の中で見つけられる。\n"
"始めに解析し,記憶,アクセスされる全てのデータ用に集中化されたリポジトリとなる。\n"
"寛容なバックエンドにこのストレージのメカニズムを修正し、\n"
"そして更なる堅牢なストレージを受け入れる為の将来の計画がある。"

#: ../docs/Overview.md:54
msgid "<a name=\"templates\"></a>"
msgstr "<a name=\"templates\"></a>"

#: ../docs/Overview.md:56
msgid "## Post Processing & Templating System"
msgstr "## 後処理とテンプレートシステム"

#: ../docs/Overview.md:58
msgid ""
"This component handles processing of objects from the registry through a "
"templating\n"
"engine that allows output to a variety of formats. Practically speaking, "
"this is\n"
"where templates can be implemented to change the design, output or structure "
"of\n"
"the data. See {file:docs/Templates.md Templates Architecture} for a complete "
"overview."
msgstr ""
"この構成は\n"
"レジストリーから多様な書式を出力可能なテンプレートエンジンまで\n"
"オブジェクトの処理を操作する。\n"
"実際の話をすると、これは、設計や出力やデータの構造を変更する為に\n"
"テンプレートが実装される場所となる。\n"
"テンプレートの詳細な説明は\n"
"{file:docs/Templates.md Templates Architecture}参照。"

# title
#: ../docs/Parser.md:1
msgid "Parser Architecture"
msgstr "パーサー構造"

#: ../docs/Parser.md:3
msgid "# Parser Architecture"
msgstr "# パーサー構造"

#: ../docs/Parser.md:5
msgid ""
"The parser component of YARD is the first component in the data processing "
"pipeline\n"
"that runs before any handling is done on the source. The parser is meant to "
"translate\n"
"the source into a set of statements that can be understood by the {file:docs/"
"Handlers.md Handlers}\n"
"that run immediately afterwards."
msgstr ""
"YARDのパーサーの構成要素は、\n"
"何らかの処理がソース上で行われる前に実行され\n"
"パイプラインのデータ処理の中の最初の構成要素となる。\n"
"パーサーはソースを、\n"
"後ですぐ実行する{file:docs/Handlers.md Handlers}によって理解され\n"
"ステートメントのグループの中へ変換するよう意図されている。"

#: ../docs/Parser.md:10
msgid ""
"The important classes are described in the class diagram of the entire "
"parser\n"
"system below:"
msgstr "重要なクラスは、以下のパーサーの全体のシステムのクラス図表の中で記述する。"

#: ../docs/Parser.md:13
msgid "![Parser Class Diagram](images/parser-class-diagram.png)"
msgstr "![Parser Class Diagram](images/parser-class-diagram.png)"

#: ../docs/Parser.md:15
msgid "(Note: the RubyToken classes are omitted from the diagram)"
msgstr "(注意: RubyTokenクラスは、図表から省略されます。)"

#: ../docs/Parser.md:17
msgid "## SourceParser"
msgstr "## ソースパーサー"

#: ../docs/Parser.md:19
msgid ""
"The main class {YARD::Parser::SourceParser} acts as a factory class, "
"instantiating\n"
"the correct parser class, an implementation of {YARD::Parser::Base}. The "
"selected parser\n"
"is chosen based on either the file extension or by selecting it explicitly "
"(as an argument\n"
"to parsing methods). YARD supports Ruby and C source files, but custom "
"parsers can\n"
"be implemented and registered for various other languages by subclassing "
"`Parser::Base`\n"
"and registering the parser with {YARD::Parser::SourceParser."
"register_parser_type}."
msgstr ""
"主なクラス{YARD::Parser::SourceParser}は、ファクトリークラスのように振る舞"
"う。\n"
"そして正確なパーサークラスをインスタンス化する。これは{YARD::Parser::Base}か"
"ら実装する。\n"
"選ばれるパーサーは、\n"
"ファイル拡張子かパーサータイプを明確に指定する事によってベースが選ばれる。\n"
"(メソッドの解析の為の引数のように)\n"
"YARDはRubyやCのソースファイルをサポートするが。\n"
"カスタムパーサーが\n"
"`Parser::Base`をサブクラス化し\n"
"{YARD::Parser::SourceParser.register_parser_type}を用い登録する事によって\n"
"様々な他の言語用に実装され、登録される。"

#: ../docs/Parser.md:26
msgid ""
"This factory class should always be used when parsing source files rather "
"than\n"
"the individual parser classes since it initiates the pipeline that runs the\n"
"handlers on the parsed source. The parser used must also match the "
"handlers,\n"
"and this is coordinated by the `SourceParser` class as well."
msgstr ""
"このファクトリークラスは、個々のパーサークラスを解析する時より\n"
"ソースファイルを解析する時に毎回利用される。\n"
"なので解析されたソース上でハンドラーを起動するパイプラインを開始する。\n"
"利用されるパーサーはハンドラーにマッチしなければならない、\n"
"これは `SourceParser` クラスによって同様にコーディネートされる。"

#: ../docs/Parser.md:31
msgid "## Using the SourceParser Class"
msgstr "## ソースパーサークラスを使うには"

#: ../docs/Parser.md:33
msgid ""
"The `SourceParser` class API is optimized for parsing globs of files. As "
"such,\n"
"the main method to use the class is the `parse` class method, which takes "
"an\n"
"array of file globs or a single file glob."
msgstr ""
"`SourceParser` クラスAPIは、ファイルのglobを解析する為に最適化される。\n"
"クラスを使う為の主なメソッドは、 `parse` クラスメソッドとなる。\n"
"そして、ファイルの配列や単一のファイルglobを取る。"

#: ../docs/Parser.md:37
msgid ""
"    YARD::Parser::SourceParser.parse('spec_*.rb')\n"
"    YARD::Parser::SourceParser.parse(['spec_*.rb', '*_helper.rb'])"
msgstr ""
"    YARD::Parser::SourceParser.parse('spec_*.rb')\n"
"    YARD::Parser::SourceParser.parse(['spec_*.rb', '*_helper.rb'])"

#: ../docs/Parser.md:40
msgid "This is equivalent to the convenience method {YARD.parse}:"
msgstr "これは以下の便宜的なメソッド{YARD.parse}と同等である。"

#: ../docs/Parser.md:42
msgid "    YARD.parse('lib/**/*.rb')"
msgstr "    YARD.parse('lib/**/*.rb')"

#: ../docs/Parser.md:44
msgid ""
"In some cases (ie. for testing), it may be more helpful to parse a string of "
"input\n"
"directly. In such a case, the method {YARD::Parser::SourceParser."
"parse_string} should be\n"
"used:"
msgstr ""
"場合によっては(つまりテストの為)、\n"
"それは直接入力の文字列を解析するのにとても役立つだろう。\n"
"このような場合には、\n"
"以下の{YARD::Parser::SourceParser.parse_string}メソッドが使われる。"

#: ../docs/Parser.md:48
msgid "    YARD::Parser::SourceParser.parse_string(\"def method(a, b) end\")"
msgstr "    YARD::Parser::SourceParser.parse_string(\"def method(a, b) end\")"

#: ../docs/Parser.md:50
msgid "You can also provide the parser type explicitly as the second argument:"
msgstr "あなたは、パーサーの型を第2引数のように提供できる。"

#: ../docs/Parser.md:52
msgid ""
"    # Parses a string of C\n"
"    YARD::Parser::SourceParser.parse_string(\"int main() { }\", :c)"
msgstr ""
"    # C言語の文字列を解析する\n"
"    YARD::Parser::SourceParser.parse_string(\"int main() { }\", :c)"

#: ../docs/Parser.md:55
msgid ""
"Note that these two methods are aliased as {YARD.parse} and {YARD."
"parse_string} for\n"
"convenience."
msgstr ""
"以下の事に留意する。\n"
"これらの二つのメソッドは、便利に使う為の\n"
"{YARD.parse}や{YARD.parse_string}のような別名となる。"

#: ../docs/Parser.md:58
msgid "## Implementing and Registering a Custom Parser"
msgstr "## カスタムパーサーを実装及び登録する"

#: ../docs/Parser.md:60
msgid ""
"To implement a custom parser, subclass {YARD::Parser::Base}. Documentation "
"on which\n"
"abstract methods should be implemented are documented in that class. After "
"the class\n"
"is implemented, it is registered with the {YARD::Parser::SourceParser} "
"factory class\n"
"to be called when a file of the right extension needs to be parsed, or when "
"a user\n"
"selects that parser type explicitly. To register your new parser class, call "
"the\n"
"method {YARD::Parser::SourceParser.register_parser_type}:"
msgstr ""
"カスタムパーサーを実装するには、{YARD::Parser::Base}をサブクラス化する。\n"
"抽象的なメソッドのドキュメントはクラスの中で記述され実装される。\n"
"クラスが実装されたあとで、\n"
"正しい拡張子のファイルが解析される為に必要となる時や\n"
"ユーザーが明示的にパーサーのタイプを選択する時に\n"
"呼び出される為に{YARD::Parser::SourceParser}ファクトリークラスを用い記録される。\n"
"あなたの新しいパーサークラスを登録するには、\n"
"以下の様に{YARD::Parser::SourceParser.register_parser_type}メソッドを呼び出す。"

#: ../docs/Parser.md:67
msgid ""
"    SourceParser.register_parser_type(:my_parser, MyParser, 'my_parser_ext')"
msgstr "    SourceParser.register_parser_type(:my_parser, MyParser, 'my_parser_ext')"

#: ../docs/Parser.md:69
msgid ""
"The last argument can be a single extension, a list of extensions (Array), a "
"single Regexp, or a\n"
"list of Regexps. Do not include the '.' in the extension."
msgstr ""
"最後の引数は、単一の拡張か、拡張のリストか、単独の正規表現か、正規表現のリス"
"トになる。\n"
"拡張する中に'.'を含めることはできない。"

#: ../docs/Parser.md:73
msgid "## The Two Ruby Parser Types"
msgstr "## 2つのRubyパーサーの型"

#: ../docs/Parser.md:75
msgid ""
"When parsing Ruby, the SourceParser can either instantiate the new {YARD::"
"Parser::Ruby::RubyParser}\n"
"class or the {YARD::Parser::Ruby::Legacy::StatementList} class. The first of "
"the\n"
"two, although faster, more robust and more efficient, is only available for\n"
"Ruby 1.9. The legacy parser parser is available in both 1.8.x and 1.9, if\n"
"compatibility is required. The choice of parser will affect which handlers\n"
"ultimately get used, since new handlers can only use the new parser and the\n"
"same requirement applies to the legacy parser & handlers."
msgstr ""
"Rubyを処理している時、\n"
"SourceParserは、{YARD::Parser::Ruby::RubyParser}クラスまたは、\n"
"{YARD::Parser::Ruby::Legacy::StatementList}クラスをインスタンス化する。\n"
"2つの内の最初の、{YARD::Parser::Ruby::RubyParser}は、\n"
"高速で、最も堅牢で最も効率的だが、Ruby 1.9のみ利用可能。\n"
"もし互換性が必要な場合、2番目のlegacy parserパーサーなら、\n"
"1.8.xと1.9の両方で利用可能。\n"
"パーサーの選択は、ハンドラーが最終的に取得する所で影響する。\n"
"だから、新しいハンドラーは新しいパーサーだけを使える。\n"
"その条件はレガシーパーサーとハンドラーも同様である。"

#: ../docs/Parser.md:83
msgid "## Switching to Legacy Parser"
msgstr "## レガシーパーサーに切替える"

#: ../docs/Parser.md:85
msgid ""
"By default, running YARD under Ruby 1.9 will automatically select the new "
"parser\n"
"and new handlers by extension. Although YARD supports both handler styles, "
"plugins\n"
"may choose to only implement one of the two (though this is not "
"recommended). If\n"
"only the legacy handlers are implemented, the `SourceParser` class should "
"force\n"
"the use of the legacy parser by setting the `parser_type` attribute as such:"
msgstr ""
"デフォルトで、稼動中のRuby1.9以下のバージョンで使われるYARDは、\n"
"拡張によって新しいパーサーと新しいハンドラーを自動で選択する。\n"
"YARDがどちらのハンドラースタイルもサポートするけれども、\n"
"プラグインは2つの内一つだけを実装する事を選択する事もできる。\n"
"(このような考えは推奨されない)\n"
"もし、レガシーハンドラーのみ実装する場合、\n"
"`SourceParser`クラスはレガシーパーサーの使用を\n"
"強制すべきである。\n"
"例として、以下の様に`parser_type`属性を設定する。"

#: ../docs/Parser.md:91
msgid "    YARD::Parser::SourceParser.parser_type = :ruby18"
msgstr "    YARD::Parser::SourceParser.parser_type = :ruby18"

#: ../docs/Parser.md:93
msgid ""
"The default value is `:ruby`. Note that this cannot be forced the other way "
"around,\n"
"a parser type of `:ruby` cannot be set under Ruby 1.8.x as the new parser is "
"not\n"
"supported under 1.8."
msgstr ""
"デフォルトの値は、`:ruby`となる。\n"
"次の事に留意する。`:ruby`にしても強制されるわけではない。\n"
"何故なら`:ruby`のパーサーの型はRipperライブラリが未定義の場合、\n"
"新しいパーサーが1.8.以下をサポートしない様にするので、\n"
"Ruby 1.8.x以下には設定されないからである。"

#: ../docs/Parser.md:97
msgid "## RubyParser (the New Parser)"
msgstr "## Rubyパーサー(新しいパーサー)"

#: ../docs/Parser.md:99
msgid ""
"The new Ruby parser uses the Ripper library that is packaged as part of "
"stdlib\n"
"in Ruby 1.9. Because of this, it can generate an AST from a string of Ruby "
"input\n"
"that is similar to the style of other sexp libraries (such as ParseTree). "
"Each\n"
"node generated in the tree is of the base type {YARD::Parser::Ruby::"
"AstNode},\n"
"which has some subclasses for common node types."
msgstr ""
"新しいRubyパーサーはRuby1.9の中のRipperライブラリを使用する。\n"
"これは標準ライブラリの一部としてパッケージされる。\n"
"そんな訳で、Rubyの入力文字列からのASTを生成することが出来る。\n"
"これは、他のS式ライブラリのスタイルと同様である。\n"
"ツリーの中のそれぞれの生成したノードは、\n"
"基準の型{YARD::Parser::Ruby::AstNode}となる。\n"
"そして、一般的なノードの型用のいくつかのサブクラスを\n"
"持っている。"

#: ../docs/Parser.md:105
msgid "### AstNode Basics"
msgstr "### AstNodeの基本"

#: ../docs/Parser.md:107
msgid ""
"The `AstNode` class behaves like a standard Array class in which all of its "
"data\n"
"make up the list of elements in the array. Unlike other sexp style "
"libraries, however,\n"
"the node type is not the first element of the list. Instead, the node type "
"is defined\n"
"by the `#type` method. The following examples show some of the basic uses of "
"`AstNode`:"
msgstr ""
"AstNodeクラスは、全てのデータが配列の中の要素のリストを\n"
"作り上げる所で標準の配列クラスのように振る舞う。\n"
"他のS式スタイルのライブラリとは異なっている。しかしながら、\n"
"ノードタイプは、リストの最初の要素では無い。\n"
"むしろ、ノードタイプは`#type`メソッドによって定義される。\n"
"以下の例は、いくつかの`AstNode`の基本的な使用法を表す。"

#: ../docs/Parser.md:112
msgid ""
"    # The sexp defines the statement `hello if 1`\n"
"    node = s(:if_mod, s(:int, \"1\"), s(:var_ref, s(:ident, \"hello\")))\n"
"    node.type  #=> :if_mod\n"
"    node[0]    #=> s(:int, \"1\")\n"
"    node[0][0] #=> \"1\""
msgstr ""
"    # S式は `hello if 1` ステートメントを定義する\n"
"    node = s(:if_mod, s(:int, \"1\"), s(:var_ref, s(:ident, \"hello\")))\n"
"    node.type  #=> :if_mod\n"
"    node[0]    #=> s(:int, \"1\")\n"
"    node[0][0] #=> \"1\""

#: ../docs/Parser.md:118
msgid ""
"(Note the `s()` syntax is shorthand for `AstNode.new(...)`. `s()` with no "
"type\n"
"is shorthand for a node of type `:list`)"
msgstr ""
"(注意 `s()`構文は`AstNode.new(...)`用の縮めた表記となる。\n"
"型がない`s()`は`:list`型のノード用の縮めた表記となる。)"

#: ../docs/Parser.md:121
msgid ""
"As shown, not all of the elements are AstNodes in themselves, some are "
"String\n"
"objects containing values. A list of only the AstNodes within a node can be\n"
"accessed via the {YARD::Parser::Ruby::AstNode#children #children} method. "
"Using\n"
"the sexp declared above, we can do:"
msgstr ""
"示されたように、要素の全てがそれら自身の中のAstNodeでは無く、\n"
"いくつかは、値を含んでいるStringオブジェクトとなる。\n"
"ノード内部AstNodeだけのリストは、\n"
"{YARD::Parser::Ruby::AstNode#children #children}メソッド経由でアクセスされる。\n"
"上で宣言されたS式によって以下のようにできる。"

#: ../docs/Parser.md:126
msgid ""
"    node.children #=> [s(:int, \"1\"), s(:var_ref, s(:ident, \"hello\"))]"
msgstr "    node.children #=> [s(:int, \"1\"), s(:var_ref, s(:ident, \"hello\"))]"

#: ../docs/Parser.md:128
msgid "### AstNode#source and #line"
msgstr "### AstNode#source and #line"

#: ../docs/Parser.md:130
msgid ""
"Every node defines the `#source` method which returns the source code that "
"the\n"
"node represents. One of the most common things to do with a node is to grab "
"its\n"
"source. The following example shows how this can be done:"
msgstr ""
"全てのノードは`#source`メソッドを定義する。\n"
"そして、ノードが意味するソースコードを返す。\n"
"ノードを用いた最も一般的な事は、ソースを取得する事となる。\n"
"以下の例は、これがどのように実行されるかを表す。"

#: ../docs/Parser.md:134
msgid ""
"    source = \"if 1 == 1 then\\n  raise Exception\\n end\"\n"
"    ast = YARD::Parser::Ruby::RubyParser.parse(source).root\n"
"    ast[0].condition.source  #=> \"1 == 1\"\n"
"    ast[0].then_block.source #=> \"raise Exception\""
msgstr ""
"    source = \"if 1 == 1 then\\n  raise Exception\\n end\"\n"
"    ast = YARD::Parser::Ruby::RubyParser.parse(source).root\n"
"    ast[0].condition.source  #=> \"1 == 1\"\n"
"    ast[0].then_block.source #=> \"raise Exception\""

#: ../docs/Parser.md:139
msgid ""
"Note that this only works on source parsed from the RubyParser, not sexps\n"
"declared using the `s()` syntax. This is because no source code is "
"generated\n"
"or stored by nodes. Instead, only the character ranges are stored, which "
"are\n"
"then looked up in the original full source string object. For example:"
msgstr ""
"次の事に留意する。\n"
"RubyParserから解析されるソース上だけで働き、\n"
"S式が`s()`構文によって宣言される時は働かない。\n"
"これは何故かというとノードによってソースコードは生成や格納されないからであ"
"る。\n"
"代わりに、文字列の範囲だけ格納され、\n"
"元の全てのソースのcharacterオブジェクトの中で検索される。\n"
"以下の様になる。"

#: ../docs/Parser.md:144
msgid ""
"    # Following the code snippet above\n"
"    ast[0].then_block.source_range #=> 17..31"
msgstr ""
"    # 上のコードは次のようになる。(raise Exception部分のレンジ)\n"
"    ast[0].then_block.source_range #=> 17..31"

#: ../docs/Parser.md:147
msgid "We can also get the line and line ranges in a similar fashion:"
msgstr "私達は以下の方法の様に、行や行の範囲を取得できる。\n"

#: ../docs/Parser.md:149
msgid ""
"    ast[0].type       #=> :if\n"
"    ast[0].line       #=> 1\n"
"    ast[0].line_range #=> 1..3 (note the newlines in the source)"
msgstr ""
"    ast[0].type       #=> :if\n"
"    ast[0].line       #=> 1\n"
"    ast[0].line_range #=> 1..3 (ソース中の改行に注意)"

#: ../docs/Parser.md:153
msgid "### AstNode#jump"
msgstr "### AstNode#jump"

#: ../docs/Parser.md:155
msgid ""
"Often the AST will be such that the node we care about might be buried "
"arbitrarily\n"
"deep in a node's hierarchy. The {YARD::Parser::Ruby::AstNode#jump} method "
"exists\n"
"to quickly get at a node of a specific type in such a situation:"
msgstr ""
"多くの場合AST処理の中でノードに対し私達が気を付ける事は、\n"
"任意でノードの階層の中深くに埋められるかもしれないという事である。\n"
"{YARD::Parser::Ruby::AstNode#jump}メソッドは、以下の状況において特定の型の\n"
"ノードに素早く到達する為に存在する。"

#: ../docs/Parser.md:159
msgid ""
"    # Get the first identifier in the statement\n"
"    ast = s(s(:int, \"1\"), s(s(:var_ref, s(:ident, \"hello\"))))\n"
"    ast.jump(:ident)[0] #=> \"hello\""
msgstr ""
"    # Get the first identifier in the statement\n"
"    ast = s(s(:int, \"1\"), s(s(:var_ref, s(:ident, \"hello\"))))\n"
"    ast.jump(:ident)[0] #=> \"hello\""

#: ../docs/Parser.md:163
msgid ""
"Multiple types can be searched for at once. If none are found, the original "
"root\n"
"node is returned so that it may be chained."
msgstr ""
"複数のタイプは、すぐに検索される。\n"
"もし、見つからなかった場合、オリジナルのルートノードは、連鎖されるように返さ"
"れる。"

#: ../docs/Parser.md:166
msgid "## The Legacy Parser"
msgstr "## レガシーパーサー"

#: ../docs/Parser.md:168
msgid ""
"The goal of the legacy parser is much the same as the new parser, but it is "
"far\n"
"more simplistic. Instead of a full-blown AST, the legacy parser simply "
"groups\n"
"together lists of \"statements\" called a {YARD::Parser::Ruby::Legacy::"
"StatementList}.\n"
"These statement lists are made up of {YARD::Parser::Ruby::Legacy::Statement} "
"objects.\n"
"A statement is any method call condition, loop, or declaration. Each "
"statement\n"
"may or may not have a block. In the case of a condition or loop, the block "
"is\n"
"the inner list of statements; in the case of a method call, the block is a "
"do\n"
"block (if provided). The statements themselves are made up of tokens, so "
"instead\n"
"of being semantic in nature like the new parser, statements are tied "
"directly\n"
"to the lexical tokens that make them up. To convert a statement into source, "
"you\n"
"simply join all the tokens together (this is done through the use of "
"`#to_s`)."
msgstr ""
"レガシーパーサーの目的は、新しいパーサーと殆んど同様であるが、\n"
"しかし、それははるかに単純である。\n"
"完璧なASTの代わりに、\n"
"レガシーパーサーは、単純に\n"
"{YARD::Parser::Ruby::Legacy::StatementList}で呼び出される\"ステートメント\"のリストの\n"
"グループを作る。\n"
"これらのステートメントのリストは、{YARD::Parser::Ruby::Legacy::Statement}\n"
"オブジェクトで構成されている。\n"
"ステートメントは任意のメソッドで条件,ループ,宣言を呼び出す。\n"
"それぞれのステートメントはブロックを持っているかわからない。\n"
"条件やループの場合、ブロックはステートメントの内部のリストになる。\n"
"メソッド呼び出しの場合、ブロックはブロックを実行する。(もし提供されるなら)\n"
"ステートメントそれ自体は、トークンで構成されている。\n"
"その為、新しいパーサーのように自然な意味になる代わりに、\n"
"ステートメントはそれらを作り上げる単語のトークンに直接紐付けられる。\n"
"ステートメントをソースに変換する為には、\n"
"全てのトークンと共に単純に加えればいい。\n"
"(これは`#to_s`メソッドを使用し行われる。)"

#: ../docs/Parser.md:180
msgid ""
"Note that because there is little semantic parsing, the legacy parser is "
"less\n"
"able to deal with certain Ruby syntaxes. Specifically, the `:if_mod` syntax\n"
"seen above (\"hello if 1\") would be considered two statements with the new "
"parser,\n"
"but using the legacy parser it is only one statement:"
msgstr ""
"次の事に留意する。\n"
"意味のある解析がほとんどないので、\n"
"レガシーパーサーは、特定のRuby構文と共に扱う事ができない。\n"
"具体的にいうと、\n"
"上の(\"hello if 1\")で見た`:if_mod`構文は、\n"
"新しいパーサーを用いた二つのステートメントと考えられる。\n"
"しかし、レガシーパーサーを使うと以下の一つのステートメントだけになる。"

#: ../docs/Parser.md:185
msgid ""
"    stmts = ARD::Parser::Ruby::Legacy::StatementList.new(\"hello if 1\")\n"
"    stmts[0].block       #=> nil\n"
"    stmts[0].tokens.to_s #=> \"hello if 1\""
msgstr ""
"    stmts = ARD::Parser::Ruby::Legacy::StatementList.new(\"hello if 1\")\n"
"    stmts[0].block       #=> nil\n"
"    stmts[0].tokens.to_s #=> \"hello if 1\""

#: ../docs/Parser.md:189
msgid ""
"In addition, this means that most handling still needs to be done via "
"string\n"
"manipulation and regular expression matching, making it considerably more\n"
"difficult to use in edge case scenarios."
msgstr ""
"さらに、ほとんどの処理は文字列操作や正規表現マッチ経由で行う\n"
"必要がある事を意味している。\n"
"それに合わせて作るには、極端なシナリオで利用する場合、大幅に難しくなる。"

# title
#: ../docs/Tags.md:1
msgid "Tags Overview"
msgstr "タグの概要"

#: ../docs/Tags.md:3
msgid "# Tags Overview"
msgstr "# タグの概要"

#: ../docs/Tags.md:5
msgid ""
"Tags represent meta-data as well as behavioural data that can be added to\n"
"documentation through the `@tag` style syntax. As mentioned, there are two\n"
"basic types of tags in YARD, \"meta-data tags\" and \"behavioural tags\", "
"the\n"
"latter is more often known as \"directives\". These two tag types can be\n"
"visually identified by their prefix. Meta-data tags have a `@` prefix,\n"
"while directives have a prefix of `@!` to indicate that the directive\n"
"performs some potentially mutable action on or with the docstring. The\n"
"two tag types would be used in the following way, respectively:"
msgstr ""
"タグは`@tag`スタイルの構文からドキュメントを\n"
"作成するために追加されるデータの行動(behavioural)としてメタデータを表す。\n"
"上で述べた、\n"
"YARDの中でタグには基本的な2つの方があり、\n"
"\"メタデータタグ\"と\"行動(behavioural)タグ\"がある。\n"
"後者は、\"ディレクティブ\"としてよく知られている。\n"
"これらの2つのタグの型は\n"
"これらのプレフィックス(接頭辞)によって視覚的に指定される。\n"
"ディレクティブがdocstringと一緒に\n"
"幾つかの潜在的に変更可能なアクションを実行する指示をする為に\n"
"`@!`のプレフィックスを持つ間、\n"
"メタデータタグは`@`プレフィックスを持つ。\n"
"2つのタグの型はそれぞれ次の方法で利用される:"

#: ../docs/Tags.md:14
msgid ""
"    # @meta_data_tag some data\n"
"    # @!directive_tag some data\n"
"    class Foo; end"
msgstr ""
"    # @meta_data_tag some data\n"
"    # @!directive_tag some data\n"
"    class Foo; end"

#: ../docs/Tags.md:18
msgid ""
"This document describes how tags can be specified, how they affect your\n"
"documentation, and how to use specific built-in tags in YARD, as well\n"
"as how to define custom tags."
msgstr ""
"このドキュメントはタグについて\n"
"どのように指定されるか、\n"
"あなたのドキュメントにどれほど影響するか、\n"
"YARDの指定の組み込みタグをどのように使うのか、\n"
"どのようにカスタムタグを定義するのかを説明する"

#: ../docs/Tags.md:22
msgid "## Meta-Data Tags"
msgstr "## メタデータタグ"

#: ../docs/Tags.md:24
msgid ""
"Meta-data tags are useful to add arbitrary meta-data about a documented\n"
"object. These tags simply add data to objects that can be looked up later,\n"
"either programmatically, or displayed in templates. The benefit to "
"describing\n"
"objects using meta-data tags is that your documentation can be organized\n"
"semantically. Rather than having a huge listing of text with no distinction\n"
"of what each paragraph is discussing, tags allow you to focus in on "
"specific\n"
"elements of your documentation."
msgstr ""
"メタデータタグは記述されたオブジェクトについて\n"
"任意のメタデータを追加するのに便利である。\n"
"これらのタグは\n"
"簡単に後で検索でき、全てプログラムでき、テンプレートで表示できるように\n"
"オブジェクトにデータを追加する。\n"
"メタデータタグを使う事によるオブジェクトの説明の利点は、\n"
"あなたのドキュメントが意味を持って整理されることである。\n"
"個々の段落がどこで議論されるか\n"
"区別しないで巨大なテキストでの記述するより、\n"
"タグはあなたがあなたのドキュメントの特定の属性に集中するのを\n"
"考慮している。"

#: ../docs/Tags.md:32
msgid ""
"For example, describing parameters of a method can often be important to "
"your\n"
"documentation, but should not be mixed up with the documentation that "
"describes\n"
"what the method itself does. In this case, separating the parameter "
"documentation\n"
"into {tag:param} tags can yield much better organized documentation, both "
"in\n"
"source and in your output, without having to manually format the data using\n"
"standard markup."
msgstr ""
"例えば、\n"
"メソッドのパラメータの説明は\n"
"あなたのドキュメントでしばしば必要になるが、\n"
"そのメソッド自体が何をするのか説明する\n"
"ドキュメントと一緒にごちゃ混ぜにすべきではない。\n"
"この場合は{tag:param}タグへドキュメントのパラメータを区切る事で\n"
"よりよく整理されたドキュメントにyieldでき、\n"
"ソースとあなたの出力両方で,\n"
"手動でなくても標準のマークアップでデータをフォーマットする。"

#: ../docs/Tags.md:39
msgid ""
"All of this meta-data can be easily parsed by tools and used both in your "
"templates\n"
"as well as in code checker tools. An example of how you can leverage tags\n"
"programmatically is shown in the {tag:todo} tag, which lists a small snippet "
"of\n"
"Ruby code that can list all of your TODO items, if they are properly tagged."
msgstr ""
"このメタデータの全ては\n"
"ツールによって簡単に解析され、\n"
"それはあなたのテンプレートとコードチェッカーツールの両方で利用される。\n"
"プログラムでどのタグを利用できるかの例は{tag:todo}タグで一覧でき、\n"
"これらが適切にタグ付けられれば、\n"
"あなたの全てのTODOの項目をリストされ小さいRubyのコードのスニペットを記述する。"

#: ../docs/Tags.md:44
msgid ""
"Custom meta-data tags can be added either programmatically or via the YARD\n"
"command-line. This is discussed in the \"[Adding Custom Tags]"
"(#Adding_Custom_Tags)\"\n"
"section."
msgstr ""
"カスタムメタデータタグはプログラムかYARDのコマンドラインで追加される。\n"
"これは\"[カスタムタグの追加](#Adding_Custom_Tags)\"の項の中で議論される。"

#: ../docs/Tags.md:48
msgid ""
"A list of built-in meta-data tags are found below in the [Tag List]"
"(#Tag_List)."
msgstr "組み込みのメタデータタグのリストは下の [タグリスト](#Tag_List) で見つけられる。"

#: ../docs/Tags.md:50
msgid "## Directives"
msgstr "## ディレクティブ"

#: ../docs/Tags.md:52
msgid ""
"Directives are similar to meta-data tags in the way they are specified, but "
"they\n"
"do not add meta-data to the object directly. Instead, they affect the "
"parsing\n"
"context and objects themselves, allowing a developer to create objects\n"
"(like methods) outright, rather than simply add text to an existing object.\n"
"Directives have a `@!` prefix to differentiate these tags from meta-data "
"tags,\n"
"as well as to indicate that the tag may modify or create new objects when\n"
"it is called."
msgstr ""
"ディレクティブはメタデータタグが指定される方法と似ているが、\n"
"これは直接オブジェクトにメタデータを追加しない。\n"
"代わりに、\n"
"これらは解析のコンテキストとそれ自身のオブジェクトに影響し、\n"
"既存のオブジェクトにテキストを単純に追加するより、\n"
"完全なオブジェクト(メソッドのような)を作成する開発者を受け入れる。\n"
"ディレクティブは、メタデータタグからこれらのタグを識別するためや\n"
"タグが変更される示すためや\n"
"呼び出される時に新しいオブジェクトを作成するに\n"
"`@!`プレフィックスを持つ。"

#: ../docs/Tags.md:60
msgid ""
"A list of built-in directives are found below in the [Directive List]"
"(#Directive_List)."
msgstr ""
"組み込みのディレクティブのリストは\n"
"以下の [ディレクティブリスト](#Directive_List) メソッドの中で定義される。"

#: ../docs/Tags.md:62
msgid "## Tag Syntax"
msgstr "## タグ構文"

#: ../docs/Tags.md:64
msgid ""
"Tags begin with the `@` or `@!` prefix at the start of a comment line, "
"followed\n"
"immediately by the tag name, and then optional tag data (if the tag requires "
"it).\n"
"Unless otherwise specified by documentation for the tag, all \"description\" "
"text\n"
"is considered free-form data and can include any arbitrary textual data."
msgstr ""
"タグはコメント行の始めで`@`や`@!`のプレフィックスと共に始まり、\n"
"すぐ次にタグ名、そして任意のタグデータ(もしタグにそれが必要なら)\n"
"別に必要ない場合は\n"
"タグ用のドキュメントを指定し、\n"
"全ての\"説明\"のテキストはフリーフォームのデータと見なされ、\n"
"任意の原文のデータを含む事ができる。"

#: ../docs/Tags.md:69
msgid "### Multi-line Tags"
msgstr "### 複数行のタグ"

#: ../docs/Tags.md:71
msgid ""
"Tags can span multiple lines if the subsequent lines are indented by more "
"than\n"
"one space. The typical convention is to indent subsequent lines by 2 "
"spaces.\n"
"In the following example, `@tagname` will have the text *\"This is indented "
"tag data\"*:"
msgstr ""
"タグは後続の行が一つ以上のスペースでインデントされる場合、複数の行に渡る事もできる。\n"
"一般的な慣習は2つのスペースによって続く行をする。\n"
"次の例の`@tagname`は *\"This is indented tag data\"* のテキストを持つ:"

#: ../docs/Tags.md:75
msgid ""
"    # @tagname This is\n"
"    #   indented tag data\n"
"    # but this is not"
msgstr ""
"    # @tagname This is\n"
"    #   indented tag data\n"
"    # but this is not"

#: ../docs/Tags.md:79
msgid ""
"For most tags, newlines and indented data are not significant and do not "
"impact\n"
"the result of the tag. In other words, you can decide to span a tag onto "
"multiple\n"
"lines at any point by creating an indented block. However, some tags like\n"
"{tag:example}, {tag:overload}, {tag:!macro}, {tag:!method}, and {tag:!"
"attribute}\n"
"rely on the first line for special information about the tag, and you "
"cannot\n"
"split this first line up. For instance, the {tag:example} tag uses the first "
"line\n"
"to indicate the example's title."
msgstr ""
"殆どのタグで、改行とインデントされたデータは\n"
"重要でないしタグの結果に影響しない。\n"
"つまり、あなたは\n"
"インデントされたブロックを作成する事によって全てのポイントで\n"
"複数行の上のタグに渡すのを決定できる。\n"
"しかしながら、\n"
"{tag:example}, {tag:overload}, {tag:!macro}, {tag:!method}, {tag:!attribute}のような、\n"
"いくつかのタグはタグについて特別な情報用に最初の行を頼り、\n"
"あなたはこの最初の行を分割できない。\n"
"例えば、{tag:example} タグは例のタイトルを指示するために最初の行を使う。"

#: ../docs/Tags.md:87
msgid "### Common Tag Syntaxes"
msgstr "### 一般的なタグ構文"

#: ../docs/Tags.md:89
msgid ""
"Although custom tags can be parsed in any way, the built-in tags follow a "
"few\n"
"common syntax structures by convention in order to simplify the syntax. The\n"
"following syntaxes are available:"
msgstr ""
"カスタムタグはどの方法でも解析され、\n"
"ビルトインタグは、構文を簡単にする為に定められた\n"
"いくつかの共通する構文構造に従う。\n"
"次の構文が用意されている。"

#: ../docs/Tags.md:93
msgid ""
"1. **Freeform data** &mdash; In this case, any amount of textual data is "
"allowed,\n"
"  including no data. In some cases, no data is necessary for the tag.\n"
"2. **Freeform data with a types specifier list** &mdash; Mostly freeform "
"data\n"
"  beginning with an *optional* types specifier list surrounded in `[brackets]"
"`.\n"
"  Note that for extensibility, other bracket types are allowed, such as "
"`<>`,\n"
"  `()` and `{}`. The contents of the list are discussed in detail below.\n"
"3. **Freeform data with a name and types specifier list** &mdash; freeform\n"
"  data beginning with an *optional* types list, as well as a name key. The\n"
"  name key is *required*. Note that for extensibility, the name can be "
"placed\n"
"  *before* the types list, like: `name [Types] description`. In this case,\n"
"  a separating space is not required between the name and types, and you\n"
"  can still use any of the other brackets that the type specifier list "
"allows.\n"
"4. **Freeform data with title** &mdash; freeform data where the first line "
"cannot\n"
"  be split into multiple lines. The first line must also always refer to "
"the\n"
"  \"title\" portion, and therefore, if there is no title, the first line "
"must\n"
"  be blank. The \"title\" might occasionally be listed by another name in "
"tag\n"
"  documentation, however, you can identify this syntax by the existence of\n"
"  a multi-line signature with \"Indented block\" on the second line."
msgstr ""
"1. **フリーフォームデータ** &mdash; この場合は全ての単語のデータの総量は許可され、\n"
"データを含まない。場合によってはデータ無しではタグを必要としない。\n"
"2. **型指定のリストを用いたフリーフォームデータ** &mdash; 大抵のフリーフォームデータは\n"
"*optional(任意の)* の`[brackets(括弧)]`で囲まれた型指定のリストを用いて始まっている。\n"
"拡張用に留意する事として、\n"
"`<>`、`()`、`{}`などとして他のブラケットの型は許可される。\n"
"リストの内容は下の詳細で議論される。    \n"
"3. **名前と型指定のリストを用いたフリーフォームデータ** &mdash; フリーフォームデータは\n"
"*optional(任意の)*型のリストもキーの名前も用い始まるデータ。\n"
"キーの名前は *必須* である。\n"
"拡張性について次のことに留意する。\n"
"名前は型のリストの前に置く事ができる:`name [Types] description`。\n"
"この場合は、区切りのスペースはnameとtypesの間に必要ではない。\n"
"そしてあなた型指定のリストの許可の他のbracket(括弧)の何かを使う事ができる。\n"
"4. **タイトルを用いたフリーフォームデータ** &mdash; 最初の行のところのフリーフォームデータは\n"
"複数の行へ分割できない。\n"
"最初の行は常に\"title\"の場所とそれ自身を参照しなければならない。\n"
"タイトル無しの場合は、\n"
"最初の行はブランクにしなければならない。\n"
"\"title\"は時々、タグのドキュメントの中で他の名前によって記述される。\n"
"しかしながら、あなたは2番目の行の\"インデントされたブロック\"を用い\n"
"複数行のシグネチャの存在によってこの構文を認証できる"

#: ../docs/Tags.md:112
msgid ""
"In the tag list below, the term \"description\" implies freeform data, `"
"[Types]`\n"
"implies a types specifier list, \"name\" implies a name key, and \"title\" "
"implies\n"
"the first line is a newline significant field that cannot be split into "
"multiple\n"
"lines."
msgstr ""
"下のタグのリストでは、\n"
"\"description\"の用語はフリーフォームデータを意味し、\n"
"`[Types]`は型指定のリストを意味する。\n"
"\"name\"はキーの名前を意味し、\n"
"最初の行を意味する\"title\"は改行で複数行へ分割できない特殊なフィールドである"

#: ../docs/Tags.md:117
msgid "### Types Specifier List"
msgstr "### 型指定のリスト"

#: ../docs/Tags.md:119
msgid ""
"In some cases, a tag will allow for a \"types specifier list\"; this will be "
"evident\n"
"from the use of the `[Types]` syntax in the tag signature. A types specifier "
"list\n"
"is a comma separated list of types, most often classes or modules, but "
"occasionally\n"
"literals. For example, the following {tag:return} tag lists a set of types "
"returned\n"
"by a method:"
msgstr ""
"幾つかの場合、タグは\"型指定のリスト\"用に許可する。\n"
"これはタグのシグネチャの中の`Types`の構文の利用から明らかである。\n"
"型指定のリストはコンマで区切られた型のリストである。\n"
"ほとんどはクラスやモジュールで、時々、リテラルである。\n"
"例えば、次の{tag:return}タグのリストはメソッドによって返された型のグループを記述する:"

#: ../docs/Tags.md:125
msgid ""
"    # Finds an object or list of objects in the db using a query\n"
"    # @return [String, Array<String>, nil] the object or objects to\n"
"    #   find in the database. Can be nil.\n"
"    def find(query) finder_code_here end"
msgstr ""
"    # queryによってdbの中のオブジェクトやオブジェクトのリストを見つける\n"
"    # @return [String, Array<String>, nil] the object or objects to\n"
"    #   find in the database. Can be nil.\n"
"    def find(query) finder_code_here end"

#: ../docs/Tags.md:130
msgid ""
"A list of conventions for type names is specified below. Typically, "
"however,\n"
"any Ruby literal or class/module is allowed here. Duck-types (method names\n"
"prefixed with \"#\") are also allowed."
msgstr ""
"型の名前用の慣習的なリストは下で指定される。\n"
"しかしながら一般的にRubyのリテラルやクラス/モジュールはここで許可される。\n"
"ダックタイピング(プレフィックスされたメソッド名を用いた\"#\")も許可される。"

#: ../docs/Tags.md:134
msgid ""
"Note that the type specifier list is always an optional field and can be "
"omitted\n"
"when present in a tag signature. This is the reason why it is surrounded by\n"
"brackets. It is also a freeform list, and can contain any list of values, "
"though\n"
"a set of conventions for how to list types is described below."
msgstr ""
"留意する事として次の事がある。\n"
"型指定のリストは常に任意のフィールドとなり\n"
"タグのシグネチャを示す時にタグ構文の中で残される。\n"
"これがbracket(括弧)によってとりかこまれる理由である。\n"
"フリーフォームのリストも、任意のリストの値を含む事ができる。\n"
"どんな型をリストにするかの慣習のグループは下で説明される。"

#: ../docs/Tags.md:139
msgid "### Type List Conventions"
msgstr "### 型のリストの慣習"

#: ../docs/Tags.md:141
msgid ""
"<p class=\"note\">\n"
"  A list of examples of common type listings and what they translate into "
"is\n"
"  available at <a href=\"http://yardoc.org/types\">http://yardoc.org/types</"
"a>.\n"
"</p>"
msgstr ""
"<p class=\"note\">\n"
"  A list of examples of common type listings and what they translate into is\n"
"  available at <a href=\"http://yardoc.org/types\">http://yardoc.org/types</a>.\n"
"</p>"

#: ../docs/Tags.md:146
msgid ""
"Typically, a type list contains a list of classes or modules that are "
"associated\n"
"with the tag. In some cases, however, certain special values are allowed or "
"required\n"
"to be listed. This section discusses the syntax for specifying Ruby types "
"inside of\n"
"type specifier lists, as well as the other non-Ruby types that are accepted "
"by\n"
"convention in these lists."
msgstr ""
"一般的に、型のリストはタグに関連付けられるクラスやモジュールのリストを含んでいる。\n"
"しかしながら、幾つかの特別な値は記述される為に許可され,受入られる。\n"
"このセクションは型の指定のリストの内部のRubyの型の指定用の構文も、\n"
"これらのリストの中の慣例によって認められる他のRubyではない型も議論する。"

#: ../docs/Tags.md:152
msgid ""
"It's important to realize that the conventions listed here may not always "
"adequately\n"
"describe every type signature, and is not meant to be a complete syntax. "
"This is\n"
"why the types specifier list is freeform and can contain any set of values. "
"The\n"
"conventions defined here are only conventions, and if they do not work for "
"your\n"
"type specifications, you can define your own appropriate conventions."
msgstr ""
"ここで慣例で記述されたものは常に\n"
"全ての型のシグネチャを説明しないのと\n"
"完璧な構文であるというのは意味しないという事を\n"
"理解するのが重要である。\n"
"型の指定のリストがフリーフォームなのは任意の値のグループを含むことができるからである。\n"
"ここで定義された慣例はここだけの慣例で、これはあなたの型の指定用には動作しない。\n"
"あなたは自身の適切な慣例を定義できる。"

#: ../docs/Tags.md:158
msgid ""
"Note that a types specifier list might also be used for non-Type values. In "
"this\n"
"case, the tag documentation will describe what values are allowed within "
"the\n"
"type specifier list."
msgstr ""
"次の事に留意する。\n"
"型の指定のリストは型ではない値にも使われるかもしれない。\n"
"この場合は,タグのドキュメントは\n"
"どの値が型の指定のリストの中で許可されるのかを説明する。"

#: ../docs/Tags.md:162
msgid "#### Class or Module Types"
msgstr "#### クラスやモジュールの型"

#: ../docs/Tags.md:164
msgid ""
"Any Ruby type is allowed as a class or module type. Such a type is simply "
"the name\n"
"of the class or module."
msgstr ""
"Rubyの型はクラスやモジュールを受け入れる。\n"
"タイプなどは単純にクラスやモジュールの名前である。"

#: ../docs/Tags.md:167
msgid ""
"Note that one extra type that is accepted by convention is the `Boolean` "
"type,\n"
"which represents both the `TrueClass` and `FalseClass` types. This type does "
"not\n"
"exist in Ruby, however."
msgstr ""
"次の事に留意する。\n"
"`Boolean`の型は慣例によって受入れられる追加の型で\n"
"`TrueClass`と`FalseClass`の型の両方を表す。\n"
"この型はRubyの中に存在しない。"

#: ../docs/Tags.md:171
msgid "#### Parametrized Types"
msgstr "#### パラメータ化された型"

#: ../docs/Tags.md:173
msgid ""
"In addition to basic types (like String or Array), YARD conventions allow "
"for\n"
"a \"generics\" like syntax to specify container objects or other "
"parametrized types.\n"
"The syntax is `Type<SubType, OtherSubType, ...>`. For instance, an Array "
"might\n"
"contain only String objects, in which case the type specification would be\n"
"`Array<String>`. Multiple parametrized types can be listed, separated by "
"commas."
msgstr ""
"基本の型(StringやArrayのような)に更に、YARDの慣例は\n"
"コンテナオブジェクトや他のパラメータ化された型を指定するための構文のような\n"
"\"generics(総称的な)\"の為に許可する。\n"
"構文は`Type<SubType, OtherSubType, ...>`となる\n"
"例えば、配列は文字列オブジェクトだけを含んでいるかもしれない。\n"
"その場合の型の指定は`Array<String>`になる。\n"
"複数のパラメータ化された型はカンマによって区切られ記述される。"

#: ../docs/Tags.md:179
msgid ""
"Note that parametrized types are typically not order-dependent, in other "
"words,\n"
"a list of parametrized types can occur in any order inside of a type. An "
"array\n"
"specified as `Array<String, Fixnum>` can contain any amount of Strings or "
"Fixnums,\n"
"in any order. When the order matters, use \"order-dependent lists\", "
"described below."
msgstr ""
"次のことに留意する。\n"
"パラメータ化された型は一般的に順番に依存せず、\n"
"いいかえれば、パラメータ化された型のリストは\n"
"型の内部で好きなの順番におく事ができる。\n"
"`Array<String, Fixnum>` などとして指定された配列はStringやFixnumの総量を\n"
"任意の順番で含む事ができる。\n"
"順番が問題になる時は、\n"
"下で説明される\"order-dependent lists(順番依存のリスト)\"を使う:"

#: ../docs/Tags.md:184
msgid "#### Duck-Types"
msgstr "#### ダックタイピング"

#: ../docs/Tags.md:186
msgid ""
"Duck-types are allowed in type specifier lists, and are identified by "
"method\n"
"names beginning with the \"#\" prefix. Typically, duck-types are "
"recommended\n"
"for {tag:param} tags only, though they can be used in other tags if needed.\n"
"The following example shows a method that takes a parameter of any type\n"
"that responds to the \"read\" method:"
msgstr ""
"ダックタイピングは型指定のリストを受入れ、\n"
"\"#\"プレフィックス(接頭辞)を用いた最初のメソッド名によってインデントされる。\n"
"一般的にダックタイピングは {tag:param} タグだけに推奨されているが、\n"
"必要なら他のタグで利用する事もできる。\n"
"次の例は\"read\"メソッドに返事をする任意の型のパラメータを\n"
"取得するメソッドを一覧できる:"

#: ../docs/Tags.md:192
msgid ""
"    # Reads from any I/O object.\n"
"    # @param [#read] io the input object to read from\n"
"    def read(io) io.read end"
msgstr ""
"    # 任意のI/O オブジェクトから読み込む\n"
"    # @param [#read] io the input object to read from\n"
"    def read(io) io.read end"

#: ../docs/Tags.md:196
msgid "#### Hashes"
msgstr "#### ハッシュ"

#: ../docs/Tags.md:198
msgid ""
"Hashes can be specified either via the parametrized type discussed above,\n"
"in the form `Hash<KeyType, ValueType>`, or using the hash specific syntax:\n"
"`Hash{KeyTypes=>ValueTypes}`. In the latter case, KeyTypes or ValueTypes "
"can\n"
"also be a list of types separated by commas."
msgstr ""
"ハッシュは上で議論されたパラメータ化された型、\n"
"`Hash<KeyType, ValueType>` 形式経由か\n"
"もしくは次の指定のハッシュ構文を使う:\n"
"`Hash{KeyTypes=>ValueTypes}` \n"
"後者の場合、KeyTypesやValueTypesはカンマで区切られた型のリストにもできる。"

#: ../docs/Tags.md:203
msgid "#### Order-Dependent Lists"
msgstr "#### Order-Dependent Lists(順番依存のリスト)"

#: ../docs/Tags.md:205
msgid ""
"An order dependent list is a set of types surrounded by \"()\" and separated "
"by\n"
"commas. This list must contain exactly those types in exactly the order "
"specified.\n"
"For instance, an Array containing a String, Fixnum and Hash in that order "
"(and\n"
"having exactly those 3 elements) would be listed as: `Array<(String, Fixnum, "
"Hash)>`."
msgstr ""
"順番依存のリストは\"()\"によって囲われた型のグループであり、\n"
"カンマによって区切られる。\n"
"このリストは正確に順番の指定された中で正確にそれらの型を含まなければならない。\n"
"例えばString,Fixnum,Hashの順番の(それは3つの属性をもっている)配列は、\n"
"`Array<(String, Fixnum, Hash)>` として記述される。"

#: ../docs/Tags.md:210
msgid "#### Literals"
msgstr "#### リテラル"

#: ../docs/Tags.md:212
msgid ""
"Some literals are accepted by virtue of being Ruby literals, but also by "
"YARD\n"
"conventions. Here is a non-exhaustive list of certain accepted literal "
"values:"
msgstr ""
"幾つかのリテラルはRubyのリテラルにある利点を受け入れるが、\n"
"YARDによる慣例もある。\n"
"ここで紹介するのは明確に受入れられたリテラルの網羅的なリストではない。"

#: ../docs/Tags.md:215
msgid ""
"* `true`, `false`, `nil` &mdash; used when a method returns these explicit "
"literal\n"
"  values. Note that if your method returns both `true` or `false`, you "
"should use\n"
"  the `Boolean` conventional type instead.\n"
"* `self` &mdash; has the same meaning as Ruby's \"self\" keyword in the "
"context of\n"
"  parameters or return types. Recommended mostly for {tag:return} tags that "
"are\n"
"  chainable.\n"
"* `void` &mdash; indicates that the type for this tag is explicitly "
"undefined.\n"
"  Mostly used to specify {tag:return} tags that do not care about their "
"return\n"
"  value. Using a `void` return tag is recommended over no type, because it "
"makes\n"
"  the documentation more explicit about what the user should expect. YARD "
"will\n"
"  also add a note for the user if they have undefined return types, making "
"things\n"
"  clear that they should not use the return value of such a method."
msgstr ""
"* `true`, `false`, `nil` &mdash; メソッドがこれらの明確なリテラル値を返す時に\n"
"  利用される。次の事に留意する。\n"
"  あなたのメソッドが `true` や `false` 両方を返す場合、\n"
"  代わりにあなたは `Boolean` の慣例の型を使わなければならない。\n"
"* `self` &mdash; パラメータや戻りの型のコンテキストでRubyの\"self\"キーワードのように\n"
"  同じ意味を持つ。\n"
"  大体はチェーン可能な {tag:return} タグが推奨される。\n"
"* `void` &mdash; このタグが明確に未定義とされる型を指示する。\n"
"  一般的にそれらの戻り値について気にしない {tag:return} タグに利用される。\n"
"  `void` return タグを使う事によって、型がない事を知らせ、\n"
"  ユーザーが期待する事についての明確な情報のドキュメントを作れる。\n"
"  未定義の戻りの型を持つ場合、YARDはユーザーの為に注釈も追加し、\n"
"  それらのメソッドなどの戻り値を使わないものを明らかにする。"

#: ../docs/Tags.md:228
msgid "<a name=\"reftags\"></a>"
msgstr "<a name=\"reftags\"></a>"

#: ../docs/Tags.md:232
msgid ""
"<p class=\"note\">\n"
"  Reference tag syntax applies only to meta-data tags, not directives.\n"
"</p>"
msgstr ""
"<p class=\"note\">\n"
"  Reference tag syntax applies only to meta-data tags, not directives.\n"
"</p>"

#: ../docs/Tags.md:236
msgid ""
"If a tag's data begins with `(see OBJECT)` it is considered a \"reference tag"
"\".\n"
"A reference tag literally copies the tag data by the given tag name from "
"the\n"
"specified OBJECT. For instance, a method may copy all {tag:param} tags from\n"
"a given object using the reference tag syntax:"
msgstr ""
"`(see OBJECT)` を用い始まるタグデータの場合\"参照タグ\"と見なす。\n"
"参照タグは文字通り指定されたオブジェクトから与えられたタグ名によって\n"
"タグデータをコピーする。\n"
"例えばメソッドは次の参照タグ構文によって\n"
"与えられたオブジェクトから全ての {tag:param} タグをコピーする。"

#: ../docs/Tags.md:241
msgid ""
"    # @param [String] user the username for the operation\n"
"    # @param [String] host the host that this user is associated with\n"
"    # @param [Time] time the time that this operation took place\n"
"    def clean(user, host, time = Time.now) end"
msgstr ""
"    # @param [String] user the username for the operation\n"
"    # @param [String] host the host that this user is associated with\n"
"    # @param [Time] time the time that this operation took place\n"
"    def clean(user, host, time = Time.now) end"

#: ../docs/Tags.md:246
msgid ""
"    # @param (see #clean)\n"
"    def activate(user, host, time = Time.now) end"
msgstr ""
"    # @param (see #clean)\n"
"    def activate(user, host, time = Time.now) end"

#: ../docs/Tags.md:249
msgid "## Adding Custom Tags"
msgstr "## Adding Custom Tags"

#: ../docs/Tags.md:251
msgid ""
"<p class=\"note\">If a tag is specific to a given project, consider "
"namespacing\n"
"  it by naming it in the form <tt>projectname.tagname</tt>, ie.,\n"
"  <tt>yard.tag_signature</tt>.</p>"
msgstr ""
"<p class=\"note\">If a tag is specific to a given project, consider namespacing\n"
"  it by naming it in the form <tt>projectname.tagname</tt>, ie.,\n"
"  <tt>yard.tag_signature</tt>.</p>"

#: ../docs/Tags.md:255
msgid ""
"Custom tags can be added to YARD either via the command-line or "
"programmatically.\n"
"The programmatic method is not discussed in this document, but rather in "
"the\n"
"{file:docs/TagsArch.md} document."
msgstr ""
"カスタムタグはコマンドラインかプログラム経由でYARDに追加される。\n"
"プログラム的なメソッドはこのドキュメントの中で議論しないが、\n"
"{file:docs/TagsArch.md} のドキュメントで参照できる。"

#: ../docs/Tags.md:259
msgid ""
"To add a custom tag via the command-line or .yardopts file, you can use the\n"
"`--*-tag` options. A few different options are available for the common tag\n"
"syntaxes described above. For example, to add a basic freeform tag, use:"
msgstr ""
"コマンドラインや.yardoptsファイル経由でカスタムタグを追加するには、\n"
"`--*-tag` オプションを使う事ができる。\n"
"少数の異なるオプションは上で議論された一般的なタグ構文用に利用可能である。\n"
"例えば、基本のフリーフォームタグに追加するには次のようになる:"

#: ../docs/Tags.md:263
msgid ""
"    !!!sh\n"
"    $ yard doc --tag rest_url:\"REST URL\""
msgstr ""
"    !!!sh\n"
"    $ yard doc --tag rest_url:\"REST URL\""

#: ../docs/Tags.md:266
msgid ""
"This will register the `@rest_url` tag for use in your documentation and "
"display\n"
"this tag in HTML output wherever it is used with the heading \"REST URL\".\n"
"Note that the tag title should follow the tag name with a colon (`:`). "
"Other\n"
"tag syntaxes exist, such as the type specifier list freeform tag\n"
"(`--type-tag`), or a named key tag with types (`--type-name-tag`)."
msgstr ""
"これはあなたのドキュメントで利用するため `@rest_url` タグが追加され、\n"
"\"REST URL\"の表題と一緒にHTML出力でこのタグを表示する。\n"
"次の事に留意する。\n"
"タグタイトルは次のコロンを用いた(`:`)タグ名にしなければならない。\n"
"他のタグ構文は型指定のリストのフリーフォームタグの(`--type-tag`)や\n"
"(`--type-name-tag`)の型を用いるキー名のタグなどが存在する。"

#: ../docs/Tags.md:272
msgid ""
"If you want to create a tag but not display it in output (it is only for\n"
"programmatic use), add `--hide-tag tagname` after the definition:"
msgstr ""
"あなたがタグを作成する為にほしい場合\n"
"しかしその出力で表示しない場合(プログラム的にだけ利用する)\n"
"定義の後で `--hide-tag tagname` を追加する:"

#: ../docs/Tags.md:275
msgid ""
"    !!!sh\n"
"    $ yard doc --tag complexity:\"McCabe Complexity\" --hide-tag complexity"
msgstr ""
"    !!!sh\n"
"    $ yard doc --tag complexity:\"McCabe Complexity\" --hide-tag complexity"

#: ../docs/Tags.md:278
msgid ""
"Note that you might not need a tag title if you are hiding it. The title\n"
"part can be omitted."
msgstr ""
"次の事に留意する。\n"
"あなたはタグタイトル隠す場合は必要としないかもしれない。\n"
"タイトルの一部は除外できる。"

#: ../docs/Tags.md:281
msgid "{yard:include_tags}"
msgstr "{yard:include_tags}"

# title
#: ../docs/TagsArch.md:1
msgid "Tags Architecture"
msgstr "タグ構造"

#: ../docs/TagsArch.md:3
msgid "# Tags Architecture"
msgstr "# タグ構造"

#: ../docs/TagsArch.md:5
msgid "## Programmatic API"
msgstr "## プログラムのAPI"

#: ../docs/TagsArch.md:7
msgid "### Accessing Tag Information"
msgstr "### タグの情報を使う"

#: ../docs/TagsArch.md:9
msgid ""
"Tag metadata is added when a {YARD::Docstring} is added to a {file:docs/"
"CodeObjects.md code object}\n"
"using the {YARD::CodeObjects::Base#docstring=} attribute. In addition to "
"adding\n"
"conventional comments, tags are parsed and associated with the object. The "
"easiest\n"
"way to access tags on an object is to use the {YARD::CodeObjects::Base#tag} "
"and `#tags`\n"
"methods, for example:"
msgstr ""
"タグのメタデータは{YARD::Docstring}が\n"
"{YARD::CodeObjects::Base#docstring=} 属性を用い\n"
"{file:docs/CodeObjects.md コードオブジェクト} の為に追加される時、追加される。\n"
"通常型のコメントをつけることに加えて、タグは解析され、オブジェクトと関係付けられる。\n"
"オブジェクトのタグにアクセスするのに最も簡単な方法は、\n"
"{YARD::CodeObjects::Base#tag} や `#tags` メソッドを利用することである。\n"
"例えば:"

#: ../docs/TagsArch.md:15
msgid ""
"    # Using the Foo class object from above\n"
"    obj.tags(:tagname).first.text #=> \"some data\""
msgstr ""
"    # 上からFooクラスオブジェクトを使う\n"
"    obj.tags(:tagname).first.text #=> \"some data\""

#: ../docs/TagsArch.md:18
msgid ""
"Because multiple tags can be stored with the same name, they are stored as a "
"list\n"
"of tags. The `#tag` method is an alias for the first item in the list of "
"tags.\n"
"Also note that the `#tag`, `#tags` and `#has_tag?` methods are all "
"convenience\n"
"methods that delegate to the {YARD::Docstring} object described above."
msgstr ""
"同じ名前の複数のタグが格納されることもあるので、\n"
"それらはタグのリストとなっている。\n"
"`#tag` メソッドはタグのリストにおける最初のアイテムのエイリアスである。\n"
"また、the `#tag`についても述べておく。\n"
"`#tags` と `#has_tag?` のメソッドは上で記述された{YARD::Docstring}\n"
"オブジェクトを委譲する便利なメソッドである。"

#: ../docs/TagsArch.md:23
msgid "### Adding Custom Tags"
msgstr "### カスタムタグを付ける"

#: ../docs/TagsArch.md:25
msgid ""
"The `@tagname` tag used in the above examples is clearly not part of the "
"tags\n"
"that come with YARD. If such a tag would actually be part of documentation "
"under\n"
"a default install, YARD would raise a warning that the tag does not exist. "
"It is,\n"
"however, trivial to add this tag to be recognized by YARD."
msgstr ""
"前記の例などで使われている@tagnemeタグは明らかにYARDに存在するタグの一部では"
"ない。\n"
"もしそのようなタグがデフォルトでインストールされたドキュメントの一部であれ"
"ば、\n"
"YARDはそのようなタグは存在していないという警告を出すだろう。\n"
"つまり、YARDによって認識されるためのタグを付けることは、\n"
"重要ではない。"

#: ../docs/TagsArch.md:30
msgid ""
"All tags in YARD are added to the {YARD::Tags::Library tag library} which "
"makes\n"
"use of a tag factory class to parse the data inside the tags. To simply add "
"a\n"
"tag that stores simple text like our `@tagname` tag above, use:"
msgstr ""
"YARDのすべてのタグは{YARD::Tags::Library tag library}に追加される。\n"
"{YARD::Tags::Library tag library}はタグの中のデータを解析する為に、\n"
"タグファクトリークラスを利用している。\n"
"@tagnameタグのように単純なテキストを収納したタグを追加するなら、\n"
"次のようになる:"

#: ../docs/TagsArch.md:34
msgid "    YARD::Tags::Library.define_tag(\"A Sample Tag\", :tagname)"
msgstr "    YARD::Tags::Library.define_tag(\"A Sample Tag\", :tagname)"

#: ../docs/TagsArch.md:36
msgid ""
"This will now allow YARD to add the metadata from `@tagname` to the "
"docstring."
msgstr "docstringに`@tagname`からメタデータをつけることをYARDに許可する。"

#: ../docs/TagsArch.md:38
msgid "## Tag Factory Architecture"
msgstr "## タグファクトリー構造"

#: ../docs/TagsArch.md:40
msgid ""
"Recognizing a tag is one part of the process. Parsing the tag contents is "
"the\n"
"second step. YARD has a tag architecture that allows developers to add or "
"completely\n"
"change the way tags contents can be parsed."
msgstr ""
"タグを認識することはプロセスの一部である。\n"
"タグの中身を解析するのは第二段階となる。\n"
"YARDはタグの構造を持っている。\n"
"タグの構造によって、\n"
"開発者は中身が解析可能なタグを加えたり変更したりすることができる。\n"

#: ../docs/TagsArch.md:44
msgid ""
"The separation of registration and tag creation can be seen in the "
"following\n"
"class diagram:"
msgstr "登録の分離やタグ作成は次の表の通り。"

#: ../docs/TagsArch.md:47
msgid "![Tags Architecture Class Diagram](images/tags-class-diagram.png)"
msgstr "![Tags Architecture Class Diagram](images/tags-class-diagram.png)"

#: ../docs/TagsArch.md:49
msgid "### DefaultFactory"
msgstr "### デフォルトファクトリー"

#: ../docs/TagsArch.md:51
msgid ""
"By default, YARD has a few standard syntaxes that can be parsed for tags. "
"These\n"
"are all implemented by the {YARD::Tags::DefaultFactory} class. These "
"syntaxes\n"
"are:"
msgstr ""
"デフォルトで、YARDはタグを解析するいくつかの標準の構文を持っている。\n"
"それらはすべて {YARD::Tags::DefaultFactory}クラスで実装されている。\n"
"これらの構文は以下のとおり。\n"

#: ../docs/TagsArch.md:55
msgid ""
"  * Standard text: no parsing is done, but text is stripped of newlines and\n"
"    multiple spaces."
msgstr ""
"  * Standard text: 解析されていない。\n"
"    しかしテキストは新しい行や多重のスペースが取り除かれている。"

#: ../docs/TagsArch.md:58
msgid ""
"  * Raw text: does no parsing at all, no stripping of newlines or spaces. "
"This\n"
"    is best used for code snippets."
msgstr ""
"  * Raw text: まったく解析していない、新しい行やスペースは取り除かれていない。\n"
"    これはコードスニペットによく使われる。"

#: ../docs/TagsArch.md:61
msgid ""
"  * Raw text with title: does no parsing on the text but extracts the first "
"line\n"
"    of the metadata as the \"title\", useful for tags such as `@example`:"
msgstr ""
"  * Raw text with title: テキストの上では解析していないが、\n"
"    メタデータの最初の行を\"title\"として抽出する。以下の `@example` のようなタグで便利である:"

#: ../docs/TagsArch.md:64
msgid ""
"        # @example Inspect an element\n"
"        #   myobj.inspect #=> #<Object:0x123525>"
msgstr ""
"        # @example Inspect an element\n"
"        #   myobj.inspect #=> #<Object:0x123525>"

#: ../docs/TagsArch.md:67
msgid ""
"  * Text with types: parses a list of types at the beginning of the text. "
"Types\n"
"    are optional. The standard syntax is in the form `[type1, type2, ...]`,\n"
"    for example:"
msgstr ""
"  * Text with types: テキストの最初の部分で型のリストを解析する。型は任意で指定できる。\n"
"標準的な構文は`[type1, type2, ...]`という型をしている。例えば:"

#: ../docs/TagsArch.md:71
msgid ""
"        # @return [String, Symbol] a description here\n"
"        # @return description here with no types"
msgstr ""
"        # @return [String, Symbol] a description here\n"
"        # @return description here with no types"

#: ../docs/TagsArch.md:74
msgid ""
"  * Text with types and a name: parses a list of types at the beginning of "
"text\n"
"    followed by a name and extra descriptive text. For example:"
msgstr ""
"  * Text with types and a name: 名前や説明文が続くテキストの最初の部分で\n"
"型のリストを解析する。例えば:"

#: ../docs/TagsArch.md:77
msgid ""
"        # @param [String] str the string to reverse\n"
"        def reverse(str) '...' end"
msgstr ""
"        # @param [String] str the string to reverse\n"
"        def reverse(str) '...' end"

#: ../docs/TagsArch.md:80
msgid ""
"As mentioned above, this syntax is implemented by the `DefaultFactory` which "
"can\n"
"be swapped out for any factory. In some cases, a developer may want to "
"change\n"
"the type declaration syntax to be in the form:"
msgstr ""
"上述のように、この構文はDefaultFactoryで実装されている。\n"
"DefaultFactoryは任意のfactoryに交換されることができる。\n"
"時には、開発者はfactory構造の型宣言構文を変えることができる。"

#: ../docs/TagsArch.md:84
msgid "    # @tagname name <Types, here> description"
msgstr "    # @tagname 名前 <型..., here> 説明"

#: ../docs/TagsArch.md:86
msgid ""
"This can be done by simply implementing a new factory that parses the data "
"in\n"
"this form."
msgstr ""
"このフォームの中でデータを解析する新しいファクトリーを実装するだけでよい。"

#: ../docs/TagsArch.md:89
msgid "### Implementing a Factory"
msgstr "### ファクトリー実装する"

#: ../docs/TagsArch.md:91
msgid ""
"Factories should implement the method `parse_tag` as well as any "
"`parse_tag_SUFFIX`\n"
"method where SUFFIX refers to the suffix added when declaring the tag. For "
"example,\n"
"a tag can also be declared as follows:"
msgstr ""
"ファクトリーはタグが宣言される時に、 `parse_tag_SUFFIX` メソッドのように\n"
"`parse_tag` メソッドが実装される。例えば、次のようにタグを定義できる。"

#: ../docs/TagsArch.md:95
msgid "    YARD::Tags::Library.define_tag \"Parameter\", :param, :with_types"
msgstr "    YARD::Tags::Library.define_tag \"Parameter\", :param, :with_types"

#: ../docs/TagsArch.md:97
msgid ""
"In such a case, the factory will be called with method "
"`parse_tag_with_types`. In\n"
"all cases, the method should return a new {YARD::Tags::Tag} object. "
"Generally,\n"
"the `parse_tag` methods take 2 or 3 parameters. A simple tag can be "
"implemented\n"
"as:"
msgstr ""
"上のようなケースでは、ファクトリーは `parse_tag_with_types` とともに呼び出される。\n"
"メソッドは新しい{YARD::Tags::Tag}オブジェクトを必ず返さなければならない。\n"
"一般に、 `parse_tag` メソッドは2つか3つの引数を取得する。\n"
"単純なタグは次のように実装することができる。"

#: ../docs/TagsArch.md:102
msgid ""
"    def parse_tag(tag_name, text)\n"
"      Tag.new(tag_name, text)\n"
"    end"
msgstr ""
"    def parse_tag(tag_name, text)\n"
"      Tag.new(tag_name, text)\n"
"    end"

#: ../docs/TagsArch.md:106
msgid ""
"The text parameter contains pre-parsed text with extra spaces and newlines "
"removed.\n"
"If required, the method could also be declared with a third parameter "
"containing\n"
"unmodified raw text:"
msgstr ""
"テキストパラメータは、\n"
"余分な空白と改行を削除するよう事前解析したテキストが含まれている。\n"
"もし必要なら以下のように、\n"
"3つ目の引数を用いて修正されていない生テキストを含めて宣言できる。"

#: ../docs/TagsArch.md:110
msgid ""
"    def parse_tag_with_raw_text(tag_name, text, raw_text)\n"
"      Tag.new(tag_name, raw_text)\n"
"    end"
msgstr ""
"    def parse_tag_with_raw_text(tag_name, text, raw_text)\n"
"      Tag.new(tag_name, raw_text)\n"
"    end"

#: ../docs/TagsArch.md:114
msgid ""
"Note that this method would be invoked for a tag declared with the `:"
"with_raw_text`\n"
"suffix."
msgstr ""
"次の事に留意する。\n"
"このメソッドはwith_raw_text suffixとともに宣言されたタグのために呼び出され"
"る。"

#: ../docs/TagsArch.md:117
msgid "### Changing the Factory"
msgstr "### ファクトリーを変更する"

#: ../docs/TagsArch.md:119
msgid ""
"To change the factory, set the {YARD::Tags::Library.default_factory} "
"attribute:"
msgstr ""
"ファクトリーを変更する為には、\n"
"以下の様に{YARD::Tags::Library.default_factory}属性を設定する。"

#: ../docs/TagsArch.md:121
msgid "    YARD::Tags::Library.default_factory = MyFactory"
msgstr "    YARD::Tags::Library.default_factory = MyFactory"

#: ../docs/TagsArch.md:123
msgid ""
"This must be done before any parsing is done, or the factory will not be "
"used."
msgstr ""
"これは解析が完了する前にしなければならない、でなければfactoryは使えない。"

# title
#: ../docs/Templates.md:1
msgid "Templates Architecture"
msgstr "テンプレート構造"

#: ../docs/Templates.md:3
msgid "# Templates Architecture"
msgstr "# テンプレート構造"

#: ../docs/Templates.md:5
msgid ""
"Templates are the main component in the output rendering process of YARD,\n"
"which is invoked when conventional HTML/text output needs to be rendered\n"
"for a set of code objects."
msgstr ""
"テンプレートは、YARDの処理を表示出力するのが主な内容となる。\n"
"そして、コードオブジェクトの集まりを表示する為に\n"
"従来のHTML/text出力が必要な時呼び出される。"

#: ../docs/Templates.md:9
msgid "## Design Goals"
msgstr "## 設計目標"

#: ../docs/Templates.md:11
msgid ""
"The general design attempts to be as abstracted from actual content and "
"templates\n"
"as possible. Unlike RDoc which uses one file to describe the entire "
"template,\n"
"YARD splits up the rendering of code objects into small components, "
"allowing\n"
"template modification for smaller subsets of a full template without having "
"to\n"
"duplicate the entire template itself. This is necessary because of YARD's "
"support\n"
"for plugins. YARD is designed for extensibility by external plugins, and "
"because\n"
"of this, no one plugin can be responsible for the entire template because "
"no\n"
"one plugin knows about the other plugins being used. For instance, if an "
"RSpec\n"
"plugin was added to support and document specifications in class templates,\n"
"this information would need to be transparently added to the template to "
"work\n"
"in conjunction with any other plugin that performed similar template "
"modifications.\n"
"The design goals can be summarized as follows:"
msgstr ""
"おおまかな設計目標は\n"
"テンプレートで、できるかぎり実際の内容から抽象化するのを試みる事である。\n"
"RDocとは違って、\n"
"YARDは、全てのテンプレートを説明する為に一つのファイルを利用し、\n"
"コードオブジェクトの表示を分割し小さい構成とする。\n"
"そして、テンプレートは\n"
"全てのテンプレートが重複無しに\n"
"最小のテンプレートの部分毎の修正を受け入れる\n"
"これは、プラグインのYARDのサポートの為に\n"
"必須となります。\n"
"YARDは、外部のプラグインによる拡張性を考え設計されている。\n"
"そんなわけで、プラグイン無しで全てのテンプレートを実行することが出来る。\n"
"何故なら、プラグインが無い場合は、\n"
"他のプラグインが利用される事について\n"
"識別するからである。\n"
"例えば、RSpecプラグインの場合、\n"
"サポートが追加されたり、\n"
"クラステンプレートの中の仕様が記述される。\n"
"同様のテンプレートの改良を施した\n"
"他のどんなプラグインを用いても、\n"
"連携するできるよう、テンプレートが\n"
"透過的に追加されることを必要とする。\n"
"設計目標は、以下の様に要約される。"

#: ../docs/Templates.md:24
msgid ""
"  1. Output should be able to be rendered for any arbitrary format with "
"little\n"
"     modification to YARD's source code. The addition of extra templates "
"should\n"
"     be sufficient.\n"
"  2. The output rendered for an object should independently rendered data\n"
"     from arbitrary sources. These independent components are called "
"\"sections\".\n"
"  3. Sections should be able to be inserted into any object without "
"affecting\n"
"     any existing sections in the document. This allows for easy "
"modification\n"
"     of templates by plugins."
msgstr ""
"  1. 出力はYARDのソースコードへの少ない変更で\n"
"     全て任意のフォーマット用に表示可能にすべきである。\n"
"     テンプレートの追加は充分なものにすべきである。\n"
"\n"
"  2. オブジェクト用に表示される出力は、任意のソースから独自にデータを\n"
"     表示するべきである。\n"
"     これらの独自構成は\"sections\"を呼び出す。\n"
"\n"
"  3. セクションはドキュメントの中の任意の存在するセクションへの影響無しで\n"
"     任意のオブジェクトに挿入される事を可能にするべきである。\n"
"     これはプラグインによるテンプレートの簡単な変更を受け入れる。"

#: ../docs/Templates.md:33
msgid "## Templates"
msgstr "## テンプレート"

#: ../docs/Templates.md:35
msgid ""
"Template modules are the objects used to orchestrate the design goals "
"listed\n"
"above. Specifically, they organize the sections and render the template "
"contents\n"
"depending on the format."
msgstr ""
"テンプレートモジュールは上で記述した設計目標を実現する為に利用されるオブジェクトとなる。\n"
"具体的にいうと、セクションを組織化したり、\n"
"フォーマットに依存するテンプレートの内容を表示する。"

#: ../docs/Templates.md:39
msgid "## Engine"
msgstr "## エンジン"

#: ../docs/Templates.md:41
msgid ""
"The Engine class orchestrates the creation and rendering of Template modules "
"and\n"
"handles serialization or specific rendering scenarios (like HTML). To "
"create\n"
"a template, use the {YARD::Templates::Engine.template template} method. The "
"two most\n"
"common methods used to initiate output are the {YARD::Templates::Engine."
"render render}\n"
"and {YARD::Templates::Engine.generate generate} methods which generate and\n"
"optionally serialize output to a file. The latter, `#generate`, is used\n"
"specially to generate HTML documentation and copy over assets that may be\n"
"needed. For instance, an object may be rendered with:"
msgstr ""
"エンジンクラスは、\n"
"作成とテンプレートモジュールの表示やシリアライズ処理や\n"
"特定の表示(HTMLのような)を統合する。\n"
"テンプレートを作成する為には、\n"
"{YARD::Templates::Engine.template template}メソッドを使用する。\n"
"出力を開始するために使われる二つの一般的なメソッドは\n"
"{YARD::Templates::Engine.render render} と\n"
"{YARD::Templates::Engine.generate generate} メソッドで\n"
"生成しファイルに任意で出力をシリアライズする。\n"
"その後で、 `#generate` メソッドは、\n"
"HTMLドキュメントを生成するための特別に使用され,\n"
"必要とされる資産をコピーする。\n"
"例えば,オブジェクトが次の例を用い表示される場合:"

#: ../docs/Templates.md:50
msgid "    YARD::Templates::Engine.render(:object => myobject)"
msgstr "    YARD::Templates::Engine.render(:object => myobject)"

#: ../docs/Templates.md:52
msgid "A set of objects may be rendered into HTML documentation by using:"
msgstr ""
"オブジェクトの設定は、以下の記法を用いる事によってHTMLドキュメントで表示され"
"る。"

#: ../docs/Templates.md:54
msgid ""
"    # all_objects is an array of module and class objects\n"
"    # options includes a :serializer key to copy output to the file system\n"
"    YARD::Templates::Engine.generate(all_objects, options)"
msgstr ""
"    # all_objects はモジュールの配列やクラスオブジェクトとなる\n"
"    # options はファイルシステムにコピー出力するの為に:serializerキーを含んで"
"いる。\n"
"    YARD::Templates::Engine.generate(all_objects, options)"

#: ../docs/Templates.md:58
msgid ""
"Note that these methods should not be called directly. The {YARD::"
"CodeObjects::Base}\n"
"class has a {YARD::CodeObjects::Base#format #format} helper method to render "
"an\n"
"object. For instance, the above render example is equivalent to the simple\n"
"call `myobject.format`. The `generate` method is a special kind of render\n"
"and is called from the {YARD::CLI::Yardoc} command line utility."
msgstr ""
"次の事に留意する。\n"
"これらのメソッドは、直接呼び出されるべきではない。\n"
"{YARD::CodeObjects::Base}クラスは\n"
"オブジェクトを表示する為の\n"
"{YARD::CodeObjects::Base#format #format} helper メソッドを\n"
"持っている。\n"
"例えば、上の表示の例は、\n"
"単純な`myobject.format`呼び出しと同等である。\n"
"`generate`メソッドは、特別な表示をし、\n"
"そしてそれは、{YARD::CLI::Yardoc}コマンドラインから呼び出せる。"

#: ../docs/Templates.md:64
msgid "## Template Options"
msgstr "## テンプレートオプション"

#: ../docs/Templates.md:66
msgid ""
"A template keeps state when it is rendering output. This state is kept in\n"
"an options hash which is initially passed to it during instantiation. Some\n"
"default options set the template style (`:template`), the output format (`:"
"format`),\n"
"and the serializer to use (`:serializer`). This options hash is modifiable\n"
"from all methods seen above. For example, initializing a template to output "
"as\n"
"HTML instead of text can be done as follows:"
msgstr ""
"テンプレートはそれが出力表示の時に状態を保持する。\n"
"この状態はハッシュのオプションの中で保持される。\n"
"そしは最初にインスタンス化される間に渡される。\n"
"幾つかのデフォルトのオプションはテンプレートスタイル(`:template`)\n"
"と出力フォーマット(`:format`)と(`:serializer`)を使うためのシリアライザーを設定する。\n"
"このハッシュのオプションは上で見られた全てのメソッドから変更可能\n"
"例えばテキストの代わりにHTMLとして出力するためにテンプレートを初期するには、次の様にできる。"

#: ../docs/Templates.md:73
msgid "    myobject.format(:format => :html)"
msgstr "    myobject.format(:format => :html)"

#: ../docs/Templates.md:75
msgid "## Serializer"
msgstr "## シリアライザー"

#: ../docs/Templates.md:77
msgid ""
"This class abstracts the logic involved in deciding how to serialize data "
"to\n"
"the expected endpoint. For instance, there is both a {YARD::Serializers::"
"StdoutSerializer StdoutSerializer}\n"
"and {YARD::Serializers::FileSystemSerializer FileSystemSerializer} class "
"for\n"
"outputting to console or to a file respectively. When endpoints with "
"locations\n"
"are used (like files or URLs), the serializer implements the {YARD::"
"Serializers::Base#serialized_path #serialized_path}\n"
"method. This allows the translation from a code object to its path at the "
"endpoint,\n"
"which enables inter-document linking."
msgstr ""
"このクラスは期待された出力先へ\n"
"データをシリアライズする為に、\n"
"決定方法,関連するロジックを抽象化する。\n"
"例えば、コンソールや個々のファイルの為の出力用の\n"
"{YARD::Serializers::StdoutSerializer StdoutSerializer}と、\n"
"{YARD::Serializers::FileSystemSerializer FileSystemSerializer} クラスがあ"
"る。\n"
"出力先が指定される時(ファイルやURLのような)、\n"
"シリアライザーは、{YARD::Serializers::Base#serialized_path #serialized_path}"
"メソッドを実装する。\n"
"これは、コードオブジェクトから出力先のパスまでの翻訳を受け入れ、\n"
"そして、内部のドキュメントのリンクを可能にする。"

#: ../docs/Templates.md:85
msgid ""
"Rendered objects are automatically serialized using the object if present,\n"
"otherwise the rendered object is returned as a string to its parent. Nested\n"
"Templates automatically set the serializer to nil so that they return\n"
"as a String to their parent."
msgstr ""
"表示されるオブジェクトが存在する場合は,\n"
"オブジェクトによって自動的にシリアライズされる。\n"
"それ以外の場合,表示されるオブジェクトはその親に文字列として返される。\n"
"ネストされたテンプレートはnilに自動的にシリアライザーを設定する。\n"
"なのでこれはそれらの親に文字列として返される。"

#: ../docs/Templates.md:90
msgid "## Creating a Template"
msgstr "## テンプレート作成"

#: ../docs/Templates.md:92
msgid ""
"Templates are represented by a directory inside the {YARD::Templates::Engine."
"template_paths}\n"
"on disk. A standard template directory looks like the following tree:"
msgstr ""
"テンプレートは\n"
"ディスク上の{YARD::Templates::Engine.template_paths}の中のディレクトリによって表される。\n"
"標準的なテンプレートは次の木構造のようになる。"

#: ../docs/Templates.md:95
msgid ""
"    (Assuming templates/ is a template path)\n"
"    templates\n"
"    `-- default\n"
"        |-- class\n"
"        |   |-- dot\n"
"        |   |   |-- setup.rb\n"
"        |   |   `-- superklass.erb\n"
"        |   |-- html\n"
"        |   |   |-- constructor_details.erb\n"
"        |   |   |-- setup.rb\n"
"        |   |   `-- subclasses.erb\n"
"        |   |-- setup.rb\n"
"        |   `-- text\n"
"        |       |-- setup.rb\n"
"        |       `-- subclasses.erb\n"
"        |-- docstring\n"
"        |   |-- html\n"
"        |   |   |-- abstract.erb\n"
"        |   |   |-- deprecated.erb\n"
"        |   |   |-- index.erb\n"
"        |   |   `-- text.erb\n"
"        |   |-- setup.rb\n"
"        |   `-- text\n"
"        |       |-- abstract.erb\n"
"        |       |-- deprecated.erb\n"
"        |       |-- index.erb\n"
"        |       `-- text.erb"
msgstr ""
"    (Assuming templates/ is a template path)\n"
"    templates\n"
"    `-- default\n"
"        |-- class\n"
"        |   |-- dot\n"
"        |   |   |-- setup.rb\n"
"        |   |   `-- superklass.erb\n"
"        |   |-- html\n"
"        |   |   |-- constructor_details.erb\n"
"        |   |   |-- setup.rb\n"
"        |   |   `-- subclasses.erb\n"
"        |   |-- setup.rb\n"
"        |   `-- text\n"
"        |       |-- setup.rb\n"
"        |       `-- subclasses.erb\n"
"        |-- docstring\n"
"        |   |-- html\n"
"        |   |   |-- abstract.erb\n"
"        |   |   |-- deprecated.erb\n"
"        |   |   |-- index.erb\n"
"        |   |   `-- text.erb\n"
"        |   |-- setup.rb\n"
"        |   `-- text\n"
"        |       |-- abstract.erb\n"
"        |       |-- deprecated.erb\n"
"        |       |-- index.erb\n"
"        |       `-- text.erb"

#: ../docs/Templates.md:123
msgid ""
"The path `default` refers to the template style (:template key in options "
"hash)\n"
"and the directories at the next level (such as `class`) refer to template\n"
"`:type` (options hash key) for a template. The next directory refers to the\n"
"output format being used defined by the `:format` template option."
msgstr ""
"パスの `default` はテンプレートスタイル(:template key in options hash)を参照し\n"
"次の階層でディレクトリは(例えば `class` など)\n"
"テンプレート用のテンプレートの `:type` (ハッシュのオプションキー)を参照する。\n"
"次のディレクトリは\n"
"`:format` テンプレートオプションによって定義され、\n"
"利用される出力フォーマットを参照する。"

#: ../docs/Templates.md:128
msgid ""
"As we saw in the above example, the format option can be set to `:html`, "
"which\n"
"would use the `html/` directory instead of `text/`. Finally, the individual ."
"erb\n"
"files are the sections that make up the template."
msgstr ""
"だれもが上の例で見た通り、\n"
"フォーマットオプションは `:html` に設定でき、\n"
"`text/` の代わりに `html/` ディレクトリを利用する。\n"
"最終的に個々の.erbファイルは、テンプレートを作り上げるセクションである。"

#: ../docs/Templates.md:132
msgid ""
"Note that the subdirectory `html/` is also its own \"template\" that "
"inherits\n"
"from the parent directory. We will see more on this later."
msgstr ""
"次の事に留意する。\n"
"`html/` サブディレクトリは\n"
"それ自身が親ディレクトリから継承する\"テンプレート\"でもある。\n"
"この後の項で詳細がされる。"

#: ../docs/Templates.md:135
msgid "## setup.rb"
msgstr "## setup.rb"

#: ../docs/Templates.md:137
msgid ""
"Every template should have at least one `setup.rb` file that defines the\n"
"{YARD::Templates::Template#init #init} method to set the\n"
"{YARD::Templates::Template#sections #sections} used by the template. If\n"
"a setup.rb is not defined in the template itself, there should be a "
"template\n"
"that is inherited (via parent directory or explcitly) that sets the "
"sections\n"
"on a newly created template."
msgstr ""
"常にテンプレートは少なくとも\n"
"テンプレートによって利用した{YARD::Templates::Template#sections #sections}を設定するために\n"
"{YARD::Templates::Template#init #init}メソッドを定義する\n"
"`setup.rb` ファイルを持つ。\n"
"setup.rbがテンプレートの中で未定義の場合は、\n"
"新規に作成されたテンプレート上のセクションを設定し、\n"
"継承される(親のディレクトリや明示的に)テンプレートになるべきである。"

#: ../docs/Templates.md:144
msgid "A standard setup.rb file looks like:"
msgstr "標準的なsetup.rbファイルは以下のように見える。"

#: ../docs/Templates.md:146
msgid ""
"    def init\n"
"      sections :section1, :section2, :section3\n"
"    end"
msgstr ""
"    def init\n"
"      sections :section1, :section2, :section3\n"
"    end"

#: ../docs/Templates.md:150
msgid "## Sections"
msgstr "## セクション"

#: ../docs/Templates.md:152
msgid ""
"Sections are smaller components that correlate to template\n"
"fragments. Practically speaking, a section can either be a template "
"fragment\n"
"(a conventional .erb file or other supported templating language), a method\n"
"(which returns a String) or another {YARD::Templates::Template} (which in "
"turn has its own\n"
"list of sections)."
msgstr ""
"セクションはテンプレートフラグに関連するより小さい構成要素である。\n"
"事実上、セクションはいづれかの\n"
"テンプレートの\n"
"フラグ(慣習で.erbファイルや他にサポートされたテンプレート言語),\n"
"メソッド(文字列を返す)やそれ以外{YARD::Templates::Template}にできる\n"
"(言い換えればセクションの自身のリストを持つ)"

#: ../docs/Templates.md:158
msgid "## Nested Sections"
msgstr "## ネストしたセクション"

#: ../docs/Templates.md:160
msgid ""
"Sections often require the ability to encapsulate a set of sub-sections in "
"markup\n"
"(HTML, for instance). Rather than use heavier Template subclass objects, a "
"more\n"
"lightweight solution is to nest a set of sub-sections as a list that "
"follows\n"
"a section, for example:"
msgstr ""
"セクションは時々マークアップで\n"
"サブセクションのグループを要約するのに能力を必要とする。(例えばHTML)\n"
"サブクラスオブジェクトのより重いテンプレートを使うより、\n"
"より軽い答えが\n"
"次のセクションのリストとしてサブセクションのグループをネストする事である。\n"
"例えば:"

#: ../docs/Templates.md:165
msgid ""
"    def init\n"
"      sections :header, [:section_a, :section_b]\n"
"    end"
msgstr ""
"    def init\n"
"      sections :header, [:section_a, :section_b]\n"
"    end"

#: ../docs/Templates.md:169
msgid ""
"The above example nests `section_a` and `section_b` within the `header` "
"section.\n"
"Practically speaking, these sections can be placed in the result by "
"`yield`ing\n"
"to them. A sample header.erb template might contain:"
msgstr ""
"上の例は、 `header` セクションの中に\n"
"`section_a` と `section_b` をネストする。\n"
"具体的には、これらのセクションは、\n"
"`yield` する事によってその結果の中に置かれる。\n"
"例のheader.erbテンプレートは以下を含んでいる"

#: ../docs/Templates.md:173
msgid ""
"    <h2>Header</h2>\n"
"    <div id=\"contents\">\n"
"      <%= yieldall %>\n"
"    </div>"
msgstr ""
"    <h2>Header</h2>\n"
"    <div id=\"contents\">\n"
"      <%= yieldall %>\n"
"    </div>"

#: ../docs/Templates.md:178
msgid ""
"This template code would place the output of `section_a` and `section_b` "
"within\n"
"the above div element. Using `yieldall`, we can also change the object that "
"is being\n"
"rendered. For example, we may want to yield the first method of the class.\n"
"We can do this like so:"
msgstr ""
"このテンプレートのコードは、\n"
"上のdiv属性の中で `section_a` と `section_b` の\n"
"出力ををセットする。\n"
"`yieldall` によって私達は、\n"
"表示されるオブジェクトを変更もできる。\n"
"例えばクラスの最初のメソッドをyieldの為にしたいとすると、\n"
"以下のようにできる。"

#: ../docs/Templates.md:183
msgid ""
"    <h2>First method</h2>\n"
"    <%= yieldall :object => object.meths.first %>"
msgstr ""
"    <h2>First method</h2>\n"
"    <%= yieldall :object => object.meths.first %>"

#: ../docs/Templates.md:186
msgid ""
"This would run the nested sections for the method object instead of the "
"class."
msgstr ""
"これは、クラスの代わりにメソッドオブジェクト用のネストされたセクションを起動"
"する。"

#: ../docs/Templates.md:188
msgid ""
"Note that `yieldall` yields to all subsections, whereas `yield` will yield\n"
"to each individually (in order) until there are no more left to yield to.\n"
"In the vast majority of cases, you'd want to use `yieldall`, since `yield`\n"
"makes it hard for users to override your template."
msgstr ""
"次の事に留意する。\n"
"`yieldall` は全ての下位セクションをyieldするのに対して、\n"
"`yield` は、要素が無くなるまで個々に(順番に)yieldする。\n"
"多くの場合あなたは `yieldall` を使いたいと思っただろう。\n"
"`yield` はユーザーがあなたのテンプレートを上書きする為に\n"
"確実に実行するからである。"

#: ../docs/Templates.md:193
msgid "## Inheriting Templates"
msgstr "## 継承するテンプレート"

#: ../docs/Templates.md:195
msgid ""
"Parent directory templates are automatically inherited (or mixed in, to be\n"
"more accurate) by the current template. This means that the 'default/class/"
"html'\n"
"template automatically inherits from 'default/class'. This also means that "
"anything\n"
"defined in 'default/class/setup.rb' can be overridden by 'default/class/html/"
"setup.rb'."
msgstr ""
"親のディレクトリのテンプレートは\n"
"現在のテンプレートによって自動的に継承される。\n"
"(または、正確にはmix-inされる)\n"
"つまり 'default/class/html' テンプレートは、\n"
"'default/class'から自動的に継承する。\n"
"そして 'default/class/setup.rb' の中に定義されるもの全ては、\n"
"'default/class/html/setup.rb' によって上書きされることも意味する。\n"
"(yard/lib以下の話ではなくyard/templates以下の話)"

#: ../docs/Templates.md:200
msgid ""
"Since the Template module is a module, and not a class, they can be mixed "
"in\n"
"explicitly (via include/extend) from other templates, which allows "
"templates\n"
"to share erb files or helper logic. The 'default/class' template explicitly\n"
"mixes in the 'default/module' template, since it uses much of the same "
"sections.\n"
"This is done with the helper {YARD::Templates::Template::ClassMethods#T T} "
"method, which\n"
"is simply a shorthand for {YARD::Templates::Engine.template Engine."
"template}.\n"
"It can then override (using standard inheritance) the sections from the "
"module\n"
"template and insert sections pertaining to classes. This is one of the "
"design\n"
"goals described above."
msgstr ""
"Templateモジュールはモジュールであり,クラスではない。\n"
"他のテンプレートから(include/extend経由)明示的に混ぜられ、\n"
"erbファイルやヘルパーロジックを共有するためにテンプレートを受け入れる。\n"
"'default/class'テンプレートは明示的に'default/module'テンプレートの中で混ぜられ、\n"
"同じセクションを使う。\n"
"これはヘルパーメソッドの {YARD::Templates::Template::ClassMethods#T T} を用い完了し、\n"
"それは単純に{YARD::Templates::Engine.template Engine.template}用の略記法で、\n"
"その時モジュールのテンプレートからセクションを上書き(標準の継承を使う事によって)できる\n"
"そしてクラスに付随するセクションを挿入する。\n"
"これは上で説明された設計目標の一つである。"

#: ../docs/Templates.md:210
msgid "For instance, the first line in `default/class/html/setup.rb` is:"
msgstr "例えば `default/class/html/setup.rb` の中の最初の行は以下のように:"

#: ../docs/Templates.md:212
msgid "    include T('default/module/html')"
msgstr "    include T('default/module/html')"

#: ../docs/Templates.md:214
msgid ""
"This includes the 'default/module/html', which means it also includes "
"'default/module'\n"
"by extension. This allows class to make use of any of module's erb files."
msgstr ""
"この'default/module/html'のincludeは、\n"
"拡張によって'default/module'を含める意味となる。\n"
"この拡張は任意でerbモジュールのファイルから利用するクラスを受け入れる。"

#: ../docs/Templates.md:217
msgid "## Inserting and Traversing Sections"
msgstr "## 挿入とトラバース(辿る)セクション"

#: ../docs/Templates.md:219
msgid ""
"The ability to insert sections was mentioned above. The class template, for\n"
"instance, will modify the #init method to insert class specific sections:"
msgstr ""
"挿入セクションの機能は上で述べた。\n"
"テンプレートクラス、例えば、\n"
"以下のクラスの特定のセクションを挿入する為に#initメソッドを変更する:"

#: ../docs/Templates.md:222
msgid ""
"    def init\n"
"      super\n"
"      sections.place(:subclasses).before(:children)\n"
"      sections.delete(:children)\n"
"      sections.place([:constructor_details, [T('method_details')]]).before(:"
"methodmissing)\n"
"    end"
msgstr ""
"    def init\n"
"      super\n"
"      sections.place(:subclasses).before(:children)\n"
"      sections.delete(:children)\n"
"      sections.place([:constructor_details, [T('method_details')]]).before(:methodmissing)\n"
"    end"

#: ../docs/Templates.md:229
msgid ""
"Observe how sections has been modified after the super method was called "
"(the\n"
"super method would have been defined in `default/module/setup.rb`). The\n"
"`sections` object is of the {YARD::Templates::Section} class and allows "
"sections to be inserted\n"
"before or after another section using {Array#place} by it's given name "
"rather\n"
"than index. This allows the overriding of templates in a way that does not\n"
"depend on where the section is located (since it may have been overridden by\n"
"another module)."
msgstr ""
"superメソッドが呼び出された後でセクションが変更されたか確認する。\n"
"(superメソッドは `default/module/setup.rb` で定義されている)\n"
"`sections`オブジェクトは{YARD::Templates::Section}クラスのであり、\n"
"インデックスより与えられた名前によって\n"
"{Array#place}を使う事によって\n"
"他のセクションの前後で挿入されるセクションを受け入れる\n"
"これはセクションが示されるところに依存しない方法で\n"
"テンプレートの上書きを受け入れる。\n"
"(なので他のモジュールによって上書きされるかもしれない)"

#: ../docs/Templates.md:237
msgid ""
"You can also use `sections[:name]` to find the first child section named `:"
"name`.\n"
"For instance, with the following sections declaration:"
msgstr ""
"あなたは、 `:name` と名付けられた最初の子のセクション名を探す為に\n"
"`sections[:name]` を利用できる。\n"
"例えば、次のようなセクション宣言を用いる。"

#: ../docs/Templates.md:240
msgid "    sections :a, [:b, :c, [:d]]"
msgstr "    sections :a, [:b, :c, [:d]]"

#: ../docs/Templates.md:242
msgid "You can get to the :d section with:"
msgstr "次のようにすると、:dセクションを取得できる。"

#: ../docs/Templates.md:244
msgid "    sections[:a][:c][:d]"
msgstr "    sections[:a][:c][:d]"

#: ../docs/Templates.md:246
msgid ""
"You can use this to insert a section inside a nested set without using "
"indexed\n"
"access. The following command would result in `[:a, [:b, :c, [:d, :e]]]`:"
msgstr ""
"アクセスを索引しないで、\n"
"ネストした集合の内部の\n"
"セクションを挿入する為に\n"
"これを利用できる。<\n"
"次のコマンドは `[:a, [:b, :c, [:d, :e]]]` の様な結果になる。"

#: ../docs/Templates.md:249
msgid "    sections[:a][:c].place(:e).after(:d)"
msgstr "    sections[:a][:c].place(:e).after(:d)"

#: ../docs/Templates.md:251
msgid ""
"There are also two methods, {Insertion#before_any} and "
"{Insertion#after_any},\n"
"which allow you to insert sections before or after the first matching "
"section name\n"
"recursively. The above example could simply be rewritten as:"
msgstr ""
"二つのメソッド、{Insertion#before_any}と{Insertion#after_any}がある。\n"
"これは、再帰的に最初にマッチするセクション名の前後のセクションへの挿入を可能"
"にする。\n"
"上の例は、単純に次のように書き換えできた。"

#: ../docs/Templates.md:255
msgid "    sections.place(:e).after_any(:d)"
msgstr "    sections.place(:e).after_any(:d)"

#: ../docs/Templates.md:257
msgid "## Overriding Templates by Registering a Template Path"
msgstr "## テンプレートパスを記録しテンプレートを上書き"

#: ../docs/Templates.md:259
msgid ""
"Inheriting templates explicitly is useful when creating a customized "
"template\n"
"that wants to take advantage of code re-use. However, most users who want\n"
"to customize YARD templates will want to override existing behaviour "
"without\n"
"creating a template from scratch."
msgstr ""
"明示的に継承するテンプレートは、\n"
"再利用したいコードのテンプレートを\n"
"カスタマイズし作成する時に便利である。\n"
"しかしながら、一般的なYARDテンプレートをカスタマイズしたいユーザーは、\n"
"下書きからテンプレートの作成無しで既存の挙動を上書きしたいだろう。"

#: ../docs/Templates.md:264
msgid ""
"YARD solves this problem by allowing other template paths to be registered.\n"
"Because template modules are represented by a relative path such as 'default/"
"class',\n"
"they can be found within any of the registered template paths. A new "
"template\n"
"path is registered as:"
msgstr ""
"YARDは記録される他のテンプレートパスを\n"
"受け入れる事によってこの問題を解決する。\n"
"何故なら、テンプレートモジュールは、\n"
"'default/class'のような、相対パスによって表される。\n"
"それは、テンプレートパスの記録される全ての中で見られる\n"
"新しいテンプレートは、次のように記録される。"

#: ../docs/Templates.md:269
msgid ""
"    YARD::Templates::Engine.register_template_path '/path/to/mytemplates'"
msgstr "    YARD::Templates::Engine.register_template_path '/path/to/mytemplates'"

#: ../docs/Templates.md:271
msgid ""
"At this point, any time the 'default/class' template is loaded, the "
"template\n"
"will first be looked for inside the newly registered template path. If "
"found,\n"
"it will be used as the template module, with the modules from the other\n"
"template paths implicitly mixed in."
msgstr ""
"この場所で、毎回、'default/class'テンプレートは、ロードされる。\n"
"テンプレートは\n"
"新しく記録したテンプレートパス内部に最初に固定される。\n"
"もし見つかった場合、\n"
"暗黙の内にmix-inされる他のテンプレートパスからモジュールと共に、\n"
"テンプレートモジュールのように利用される。"

#: ../docs/Templates.md:276
msgid ""
"Therefore, by using the same directory structure as a builtin YARD "
"template,\n"
"a user can customize or override individual templates as if the old ones "
"were\n"
"inherited. A real world example would further modify the 'default/class' "
"template\n"
"seen above by creating such a path in our '/path/to/mytemplates' custom "
"template\n"
"path:"
msgstr ""
"従って組み込みのYARDのテンプレートとして同じディレクトリ構造体を\n"
"使うことによってユーザーはカスタマイズできたり、\n"
"古いものが継承される場合など個々のテンプレートを上書きできる。\n"
"実際の例は、\n"
"更に例の'/path/to/mytemplates'のカスタムテンプレートパスの中のパスなど作成することによって\n"
"上で見た'default/class'テンプレートを変更する。"

#: ../docs/Templates.md:282
msgid ""
"    /path/to/mytemplates/:\n"
"    |-- class\n"
"    |   |-- html\n"
"    |   |   |-- customsection.erb\n"
"    |   |-- setup.rb"
msgstr ""
"    /path/to/mytemplates/:\n"
"    |-- class\n"
"    |   |-- html\n"
"    |   |   |-- customsection.erb\n"
"    |   |-- setup.rb"

#: ../docs/Templates.md:288
msgid "The `setup.rb` file would look like:"
msgstr "`setup.rb` ファイルは次の様になる。"

#: ../docs/Templates.md:290
msgid ""
"    def init\n"
"      super\n"
"      sections.push :customsection\n"
"    end"
msgstr ""
"    def init\n"
"      super\n"
"      sections.push :customsection\n"
"    end"

#: ../docs/Templates.md:295
msgid ""
"Now, when a class object is formatted as HTML, our customsection.erb will "
"be\n"
"appended to the rendered data."
msgstr ""
"クラスオブジェクトがHTMLとしてフォーマットされる時は、\n"
"例のcustomsection.erbは表示されるデータに適用される。"

#: ../docs/Templates.md:299
msgid "### Overriding Stylesheets and Javascripts"
msgstr "### スタイルシートとJavascriptsを上書きする。"

#: ../docs/Templates.md:301
msgid ""
"Template authors can override existing stylesheets and javascripts by "
"creating\n"
"a file with the same name as existing files within the `fulldoc` template. "
"The\n"
"documentation output will utilize the new replacement file."
msgstr ""
"テンプレートの著者は\n"
"`fulldoc` テンプレートの中で既存のファイルのような同じ名前を用い、\n"
"ファイルを作成する事によって\n"
"既存のスタイルシートとjavascriptを\n"
"上書きできる。\n"
"ドキュメント出力は新しく置換するファイルを利用する。"

#: ../docs/Templates.md:305
msgid "YARD's `fulldoc` template defines three stylesheets:"
msgstr "YARDの `fulldoc` テンプレートはツリーのスタイルシートを定義する。"

#: ../docs/Templates.md:307
msgid ""
"    /yard/templates/default/:\n"
"    |-- fulldoc\n"
"    |   |-- html\n"
"    |   |   |-- css\n"
"    |   |   |   |-- common.css\n"
"    |   |   |   |-- full_list.css\n"
"    |   |   |   |-- style.css"
msgstr ""
"    /yard/templates/default/:\n"
"    |-- fulldoc\n"
"    |   |-- html\n"
"    |   |   |-- css\n"
"    |   |   |   |-- common.css\n"
"    |   |   |   |-- full_list.css\n"
"    |   |   |   |-- style.css"

#: ../docs/Templates.md:315
msgid "The `style.css` is the primary stylesheet for the HTML output."
msgstr "`style.css` は、HTML出力用の主要なスタイルシートとなる。"

#: ../docs/Templates.md:317
msgid ""
"The `full_list.css` is an additional stylesheet loaded specifically for the\n"
"search field menus (i.e. class list, method list, and file list)."
msgstr ""
"追加のスタイルシートの `full_list.css` は、厳密にいえば検索フィールドメニューの為にロードされる。\n"
"(すなわち、クラスリスト、メソッドリスト、ファイルリスト)"

#: ../docs/Templates.md:320
msgid ""
"The `common.css` is an empty css file that an template author can easily "
"override\n"
"to provide custom styles for their plugin. However, if a user installs "
"multiple\n"
"plugins that utilize this same file to deliver styles, it is possible that "
"they\n"
"will be overridden."
msgstr ""
"`common.css` は、\n"
"テンプレートの著者がプラグイン用の\n"
"カスタムスタイルを提供する為に\n"
"簡単に上書きする空のcssファイルとなる。\n"
"しかしながらユーザーがスタイルを実行するのに、\n"
"同じファイルを利用する複数のプラグインをインストールした場合、\n"
"上書きされる事が問題になる。"

#: ../docs/Templates.md:325
msgid "YARD's `fulldoc` template defines three javascript files:"
msgstr "YARDの `fulldoc` テンプレートは次の様にツリー上のjavascriptファイルを定義する。"

#: ../docs/Templates.md:327
msgid ""
"    /yard/templates/default/:\n"
"    |-- fulldoc\n"
"    |   |-- html\n"
"    |   |   |-- js\n"
"    |   |   |   |-- app.js\n"
"    |   |   |   |-- full_list.js\n"
"    |   |   |   |-- jquery.js"
msgstr ""
"    /yard/templates/default/:\n"
"    |-- fulldoc\n"
"    |   |-- html\n"
"    |   |   |-- js\n"
"    |   |   |   |-- app.js\n"
"    |   |   |   |-- full_list.js\n"
"    |   |   |   |-- jquery.js"

#: ../docs/Templates.md:335
msgid "The `app.js` is the primary javascript file for the HTML output."
msgstr "`app.js` はHTML出力用の主要なjavascriptファイルとなる。"

#: ../docs/Templates.md:337
msgid ""
"The `full_list.js` defines additional javascript loaded specifically for "
"the\n"
"search field menus (i.e. class list, method list, and file list)."
msgstr ""
"追加のjavascriptを定義する `full_list.js` は、\n"
"厳密にいえば検索フィールドメニュー用にロードされる。\n"
"(すなわち、クラスリスト、メソッドリスト、ファイルリスト)"

#: ../docs/Templates.md:340
msgid "The `jquery.js` is copy of the jquery javascript library."
msgstr "`jquery.js` はjquery javascriptライブラリをコピーする。"

#: ../docs/Templates.md:342
msgid "### Adding a Custom Stylesheet or Javascript"
msgstr "### カスタムスタイルシートとJavascritpを追加する"

#: ../docs/Templates.md:344
msgid ""
"To load additional stylesheets and javascripts with every page (except the "
"search\n"
"field menus) generated from the base `layout` template:"
msgstr ""
"基本の `layout` テンプレートから生成した\n"
"全てのページと共に、\n"
"追加のスタイルシートとjavascriptをロードするには\n"
"(但し、検索フィールドメニューを除く):\n"

#: ../docs/Templates.md:347
msgid ""
"  1. Define your own custom stylesheet and/or javascript file\n"
"     (default/ is the default template name inside of the /template root "
"directory):"
msgstr ""
"  1. 自分のカスタムスタイルシートやjavascriptファイルを定義する。\n"
"     (デフォルトのディレクトリは/templateルートディレクトリの内部のデフォルトのテンプレート名である):"

#: ../docs/Templates.md:350
msgid ""
"        /template/default/:\n"
"        |-- fulldoc\n"
"        |   |-- html\n"
"        |   |   |-- css\n"
"        |   |   |   |-- custom.css\n"
"        |   |   |-- js\n"
"        |   |   |   |-- custom.js"
msgstr ""
"          /template/default/:\n"
"          |-- fulldoc\n"
"          |   |-- html\n"
"          |   |   |-- css\n"
"          |   |   |   |-- custom.css\n"
"          |   |   |-- js\n"
"          |   |   |   |-- custom.js"

#: ../docs/Templates.md:358
msgid ""
"  2. Create a `setup.rb` in the `layout` template directory and override the "
"methods\n"
"     `stylesheets` and `javascripts`. The path to the template would be:"
msgstr ""
"  2. `layout` テンプレートディレクトリの中の `setup.rb` を作成して\n"
"     `javascripts` と `stylesheets` メソッドを上書きする。\n"
"     テンプレートのパスは次の様になる:"

#: ../docs/Templates.md:361
msgid ""
"        /template/default/:\n"
"        |-- layout\n"
"        |   |-- html\n"
"        |   |   |-- setup.rb"
msgstr ""
"          /template/default/:\n"
"          |-- layout\n"
"          |   |-- html\n"
"          |   |   |-- setup.rb"

#: ../docs/Templates.md:366
msgid "      And the code would look like:"
msgstr "      そしてコードは次のようになる。"

#: ../docs/Templates.md:368
msgid ""
"        def stylesheets\n"
"          # Load the existing stylesheets while appending the custom one\n"
"          super + %w(css/custom.css)\n"
"        end"
msgstr ""
"          def stylesheets\n"
"            # カスタムのcssが追加される間、存在するスタイルシートをロードする\n"
"            super + %w(css/custom.css)\n"
"          end"

#: ../docs/Templates.md:373
msgid ""
"        def javascripts\n"
"          # Load the existing javascripts while appending the custom one\n"
"          super + %w(js/custom.js)\n"
"        end"
msgstr ""
"          def javascripts\n"
"            # カスタムのjavascriptが追加される間、存在するスタイルシートをロードする\n"
"            super + %w(js/custom.js)\n"
"          end"

#: ../docs/Templates.md:379
msgid ""
"To load additional stylesheets and javascripts for the search menus loaded "
"from\n"
"the `fulldoc` template:"
msgstr ""
"`fulldoc` テンプレートからロードされた検索メニュー用の\n"
"追加のスタイルシートとjavascriptをロードするには:"

#: ../docs/Templates.md:382
msgid "  1. Define your own custom stylesheet and/or javascript file."
msgstr "  1. 自分のカスタムスタイルシートとjavascriptファイルを定義する。"

#: ../docs/Templates.md:384
msgid ""
"        /path/to/mytemplates/:\n"
"        |-- fulldoc\n"
"        |   |-- html\n"
"        |   |   |-- css\n"
"        |   |   |   |-- custom_full_menu.css\n"
"        |   |   |-- js\n"
"        |   |   |   |-- custom_full_menu.js"
msgstr ""
"          /path/to/mytemplates/:\n"
"          |-- fulldoc\n"
"          |   |-- html\n"
"          |   |   |-- css\n"
"          |   |   |   |-- custom_full_menu.css\n"
"          |   |   |-- js\n"
"          |   |   |   |-- custom_full_menu.js"

#: ../docs/Templates.md:393
msgid ""
"  3. Override the methods `stylesheets_full_list` and "
"`javascripts_full_list`\n"
"     in the `setup.rb` file inside fulldoc/html."
msgstr ""
"  3. fulldoc/html内の `setup.rb` ファイルの中の\n"
"  `stylesheets_full_list` と `javascripts_full_list` メソッドを上書きする。"

#: ../docs/Templates.md:396
msgid ""
"        def stylesheets_full_list\n"
"          # Load the existing stylesheets while appending the custom one\n"
"          super + %w(css/custom.css)\n"
"        end"
msgstr ""
"        def stylesheets_full_list\n"
"          # カスタムのcssが追加される間、存在するスタイルシートをロードする\n"
"          super + %w(css/custom.css)\n"
"        end"

#: ../docs/Templates.md:401
msgid ""
"        def javascripts_full_list\n"
"          # Load the existing javascripts while appending the custom one\n"
"          super + %w(js/custom.js)\n"
"        end"
msgstr ""
"        def javascripts_full_list\n"
"          # カスタムのjavascriptが追加される間、存在するスタイルシートをロードする\n"
"          # Load the existing javascripts while appending the custom one\n"
"          super + %w(js/custom.js)\n"
"        end"

#: ../docs/Templates.md:406
msgid "### Overriding Search Menus"
msgstr "### 検索メニューを上書きする。"

#: ../docs/Templates.md:408 ../docs/Templates.md:443
msgid "By default YARD's `fulldoc` template generates three search fields:"
msgstr "デフォルトでYARDの `fulldoc` テンプレートは次のような検索フィールドのツリーを生成する。"

#: ../docs/Templates.md:410 ../docs/Templates.md:445
msgid ""
"  * Class List\n"
"  * Method List\n"
"  * File List"
msgstr ""
"  * Class List\n"
"  * Method List\n"
"  * File List"

#: ../docs/Templates.md:414
msgid "Their contents are rendered in methods within the `fulldoc` template:"
msgstr "その内容は、 `fulldoc` テンプレートの中でメソッドの中を表示する。"

#: ../docs/Templates.md:416
msgid ""
"  * `generate_class_list`\n"
"  * `generate_method_list`\n"
"  * `generate_file_list`"
msgstr ""
"  * `generate_class_list`\n"
"  * `generate_method_list`\n"
"  * `generate_file_list`"

#: ../docs/Templates.md:420
msgid "To override these lists you will need to:"
msgstr "これらのリスト上書きするには:"

#: ../docs/Templates.md:422
msgid ""
"  1. Create a `setup.rb` in the `fulldoc` template directory and override "
"the\n"
"     particular method."
msgstr ""
"  1. `fulldoc` テンプレートディレクトリの中の `setup.rb` を作成し、\n"
"  メソッドの詳細を上書きする。"

#: ../docs/Templates.md:425 ../docs/Templates.md:477
msgid ""
"         /path/to/mytemplates/:\n"
"         |-- fulldoc\n"
"         |   |-- html\n"
"         |   |   |-- setup.rb"
msgstr ""
"         /path/to/mytemplates/:\n"
"         |-- fulldoc\n"
"         |   |-- html\n"
"         |   |   |-- setup.rb"

#: ../docs/Templates.md:430
msgid ""
"         def generate_method_list\n"
"           @items = prune_method_listing(Registry.all(:method), false)\n"
"           @items = @items.reject {|m| m.name.to_s =~ /=$/ && m."
"is_attribute? }"
msgstr ""
"         def generate_method_list\n"
"           @items = prune_method_listing(Registry.all(:method), false)\n"
"           @items = @items.reject {|m| m.name.to_s =~ /=$/ && m.is_attribute? }"

#: ../docs/Templates.md:434
msgid ""
"           # Here we changed the functionality to reverse the order of "
"displayed methods\n"
"           @items = @items.sort_by {|m| m.name.to_s }.reverse\n"
"           @list_title = \"Method List\"\n"
"           @list_type = \"methods\"\n"
"           asset('method_list.html', erb(:full_list))\n"
"         end"
msgstr ""
"         # ここでメソッドを表示する順番を逆にする為の機能を変更する\n"
"           @items = @items.sort_by {|m| m.name.to_s }.reverse\n"
"           @list_title = \"Method List\"\n"
"           @list_type = \"methods\"\n"
"           asset('method_list.html', erb(:full_list))\n"
"         end"

#: ../docs/Templates.md:441
msgid "### Adding Additional Search Menus"
msgstr "### 追加の検索メニューを追加する。"

#: ../docs/Templates.md:449
msgid ""
"These are defined in the `layout` template method `menu_lists` and pulled "
"into\n"
"the `fulldoc` template through a similarly named method."
msgstr ""
"これらは `layout` テンプレートメソッドの中の `menu_lists` を定義される。\n"
"そして同様に名付けられたメソッドを通じて `fulldoc` テンプレートに置かれる。"

#: ../docs/Templates.md:452
msgid "To load an additional menu item:"
msgstr "追加のメニュー項目をロードするには次のようになる:"

#: ../docs/Templates.md:455
msgid ""
"  1. Create a `setup.rb` in the `layout` template directory and override the "
"methods\n"
"   `menu_lists`. The `type` informs the search field the name of the file.\n"
"    The `title` is the name that appears above the section when viewed in "
"frames.\n"
"    The `search_title` is the name that appears in the search field tab on "
"the page."
msgstr ""
"  1. `layout` テンプレートディレクトリの中で `setup.rb` を作成し `menu_lists` メソッドを上書きする。\n"
"   `type` はファイルの検索フィールド名通知する。\n"
"   `title` はフレームのなかで表示された時に上のセクションに登場する名前である。\n"
"   `search_title` はページの検索フィールドタブの中で登場する名前である。"

#: ../docs/Templates.md:461
msgid ""
"        /path/to/mytemplates/:\n"
"        |-- layout\n"
"        |   |-- html\n"
"        |   |   |-- setup.rb"
msgstr ""
"        /path/to/mytemplates/:\n"
"        |-- layout\n"
"        |   |-- html\n"
"        |   |   |-- setup.rb"

#: ../docs/Templates.md:466
msgid ""
"        def menu_lists\n"
"          # Load the existing menus\n"
"          super + [ { :type => 'feature', :title => 'Features', :"
"search_title => 'Feature List' } ]\n"
"        end"
msgstr ""
"        def menu_lists\n"
"          # 既存のメニューをロードする\n"
"          super + [ { :type => 'feature', :title => 'Features', :search_title => 'Feature List' } ]\n"
"        end"

#: ../docs/Templates.md:471
msgid ""
"  2. Create a `setup.rb` in the `fulldoc` template directory and create a "
"method\n"
"     to generate a menu for the specified `type`.\n"
"     The method `generate_assets` will look for a function with a signature "
"prefixed\n"
"     with `generate`, the type value specified, and the suffix `list`. "
"Within that\n"
"     method you can configure and load the specific objects you wish to "
"display."
msgstr ""
"  2. `fulldoc` のテンプレートディレクトリの中で `setup.rb` を作成し、\n"
"     指定された `type` 用にメニューを生成するためのメソッドを作成する\n"
"     `generate_assets` メソッドは、 `generate` で始まり,間に固有の値,末尾が `list` のシグネチャを探す。\n"
"     メソッドの中をあなたが構成でき、表示するためにあなたが望む特定のオブジェクトをロードする。"

#: ../docs/Templates.md:482
msgid "         def generate_feature_list"
msgstr "         def generate_feature_list"

#: ../docs/Templates.md:484
msgid ""
"           # load all the features from the Registry\n"
"           @items = Registry.all(:feature)\n"
"           @list_title = \"Feature List\"\n"
"           @list_type = \"feature\""
msgstr ""
"           # レジストリーから全ての機能をロードす\n"
"           @items = Registry.all(:feature)\n"
"           @list_title = \"Feature List\"\n"
"           @list_type = \"feature\""

#: ../docs/Templates.md:489
msgid ""
"           # optional: the specified stylesheet class\n"
"           # when not specified it will default to the value of @list_type\n"
"           @list_class = \"class\""
msgstr ""
"           # optional: the specified stylesheet class\n"
"           # when not specified it will default to the value of @list_type\n"
"           @list_class = \"class\""

#: ../docs/Templates.md:493
msgid ""
"           # Generate the full list html file with named feature_list.html\n"
"           # @note this file must be match the name of the type\n"
"           asset('feature_list.html', erb(:full_list))\n"
"         end"
msgstr ""
"           # feature_list.htmlの名前と共に完全なHTMLファイルのリストを作成する\n"
"           # @note this file must be match the name of the type\n"
"           asset('feature_list.html', erb(:full_list))\n"
"         end"

# title
#: ../docs/WhatsNew.md:1
msgid "What's New?"
msgstr "What's New?"

#: ../docs/WhatsNew.md:3
msgid "# What's New in 0.8.x?"
msgstr "# What's New in 0.8.x?"

#: ../docs/WhatsNew.md:5
msgid ""
"1. **Directives (new behavioural tag syntax)** (0.8.0)\n"
"2. **Added `--embed-mixin(s)` to embed mixins into class docs** (0.8.0)\n"
"3. **Internationalization (I18n) support for translating docs** (0.8.0)\n"
"4. **New C parser / handlers architecture** (0.8.0)\n"
"5. **YARD will now warn if `@param` name not in method params** (0.8.0)\n"
"6. **Added support for `module_function` calls in Ruby code** (0.8.0)\n"
"7. **Greatly improved tag documentation using custom template** (0.8.0)\n"
"8. **Tags can now contain '.' for namespacing** (0.8.0)\n"
"9. **Added \"frames\" links for non-framed pages for better nav** (0.8.0)\n"
"10. **Added Gemfile support to YARD server for local gem sets** (0.8.0)\n"
"11. **Server now displays README on index route like static docs** (0.8.0)\n"
"12. **Added line numbers to `yard stats --list-undoc --compact`** (0.8.0)\n"
"13. **Single object db now default (multi-object db unsupported)** (0.8.0)\n"
"14. **Added `--api` tag to generate documentation for API sets** (0.8.1)"
msgstr ""
"1. **ディレクティブ (タグ構文の新しい行動)** (0.8.0)\n"
"2. **クラスのドキュメントの中にmixinを埋め込むのに `--embed-mixin(s)` が追加された** (0.8.0)\n"
"3. **翻訳ドキュメント用の国際化 (I18n) サポート** (0.8.0)\n"
"4. **新しい C パーサー / ハンドラー アーキテクチャ** (0.8.0)\n"
"5. **YARDはメソッドのパラメータの中に`@param`名が無い場合、警告を出すようになった。\n"
"6. **`module_function` がRubyのコードを呼び出すサポートが追加された** (0.8.0)\n"
"7. **カスタムテンプレートによって大きくタグドキュメントが修正された** (0.8.0)\n"
"8. **タグがネームスペース用の '.' を含むようになった** (0.8.0)\n"
"9. **より良いナビをするのにフレームでないページ用に\"フレーム\"のリンクが追加された** (0.8.0)\n"
"10. **ローカルのgemのグループ用にYARDサーバーにGemfileのサポートが追加された** (0.8.0)\n"
"11. **サーバーは静的なドキュメントのようにルートのインデックス上のREADMEを表示するようになった** (0.8.0)\n"
"12. **`yard stats --list-undoc --compact`に行数が追加された** (0.8.0)\n"
"13. **単一のオブジェクトdbがデフォルトになった (マルチオブジェクトdbは未サポート)** (0.8.0)\n"
"14. **API用のグループのドキュメントを生成するのに `--api` タグが追加された** (0.8.1)"

#: ../docs/WhatsNew.md:20
msgid "## Directives (new behavioural tag syntax) (0.8.0)"
msgstr "## ディレクティブ (タグ構文の新しい行動) (0.8.0)"

#: ../docs/WhatsNew.md:22
msgid ""
"<p class=\"note\">\n"
"  The tags {tag:!macro}, {tag:!method}, {tag:!attribute}, {tag:!group},\n"
"  {tag:!endgroup}, {tag:!scope} and {tag:!visibility} have been changed\n"
"  from meta-data tags to directives. This means they should now be called\n"
"  with the \"@!\" prefix instead of \"@\". Note however that for <strong>\n"
"  backward compatibility</strong>, the old \"@macro\", \"@method\", etc.,\n"
"  syntax for all of these tags will still work and is supported.\n"
"</p>"
msgstr ""
"<p class=\"note\">\n"
"  The tags {tag:!macro}, {tag:!method}, {tag:!attribute}, {tag:!group},\n"
"  {tag:!endgroup}, {tag:!scope} and {tag:!visibility} have been changed\n"
"  from meta-data tags to directives. This means they should now be called\n"
"  with the \"@!\" prefix instead of \"@\". Note however that for <strong>\n"
"  backward compatibility</strong>, the old \"@macro\", \"@method\", etc.,\n"
"  syntax for all of these tags will still work and is supported.\n"
"</p>"

#: ../docs/WhatsNew.md:31
msgid ""
"<p class=\"note\">\n"
"  Some <strong>backwards incompatible</strong> changes were made to {tag:!"
"macro} syntax.\n"
"  Please read this section carefully if you are using this tag.\n"
"</p>"
msgstr ""
"<p class=\"note\">\n"
"  Some <strong>backwards incompatible</strong> changes were made to {tag:!macro} syntax.\n"
"  Please read this section carefully if you are using this tag.\n"
"</p>"

#: ../docs/WhatsNew.md:36
msgid ""
"YARD 0.8.0 adds a new tag syntax called \"directives\" using the `@!`\n"
"prefix. These directive tags can be used to modify parser state while\n"
"processing objects, or even create new objects on the fly. A plugin\n"
"API is available similar to tags, and directives should be registered\n"
"in the {YARD::Tags::Library} class using {YARD::Tags::Library."
"define_directive}."
msgstr ""
"YARD 0.8.0で追加された新しいタグ構文は\n"
"`@!` プレフィックス(接頭辞)によって\"directives(ディレクティブ)\"を呼び出す。\n"
"これらのディレクティブタグは、\n"
"オブジェクトを処理している間やオンザフライで新しくオブジェクトを作成する時でさえ、\n"
"パーサーの状態を変更するのに利用できる。\n"
"プラグインAPIはタグ同様に可能で、\n"
"ディレクティブは {YARD::Tags::Library.define_directive} によって\n"
"{YARD::Tags::Library} クラスのなかに登録される。"

#: ../docs/WhatsNew.md:42
msgid ""
"To use a directive, simply call it the same way as any tag. Tag syntax\n"
"is documented in {file:docs/Tags.md}."
msgstr ""
"ディレクティブを使うには、単純にタグなどと同じ方法で呼び出す。\n"
"タグ構文は {file:docs/Tags.md} で記述される。"

#: ../docs/WhatsNew.md:45
msgid "### Notable features of directives"
msgstr "### 著名なディレクティブの機能"

#: ../docs/WhatsNew.md:47
msgid "#### Directives do not need to be attached to object docstrings"
msgstr "#### ディレクティブはオブジェクトのdocstringに追加するのに必要ない"

#: ../docs/WhatsNew.md:49
msgid ""
"Unlike meta-data tags which apply to created objects, directives\n"
"do not need to be attached to an object in order to be used. This\n"
"means you can have free-standing comments with directives, such as:"
msgstr ""
"メタデータタグとは違って作成されたオブジェクトに追加され、\n"
"ディレクティブは利用される順番で追加される必要はない。\n"
"これは次のようなディレクティブを用い自由な位置にコメントできる事を意味する:"

#: ../docs/WhatsNew.md:53
msgid ""
"    # @macro mymacro\n"
"    #   A new macro, not attached to any docstring"
msgstr ""
"    # @macro mymacro\n"
"    #   A new macro, not attached to any docstring"

#: ../docs/WhatsNew.md:56
msgid "    # ...other Ruby code here..."
msgstr "    # ...other Ruby code here..."

#: ../docs/WhatsNew.md:58
msgid ""
"    # Using the macro:\n"
"    # @macro mymacro\n"
"    def mymethod; end"
msgstr ""
"    # 上のマクロを呼び出す:\n"
"    # @macro mymacro\n"
"    def mymethod; end"

#: ../docs/WhatsNew.md:62
msgid ""
"You can do the same to define methods and attributes, as discussed\n"
"below."
msgstr ""
"下の項で議論されるように\n"
"あなたはメソッドと属性を定義するのを同じようにできる。"

#: ../docs/WhatsNew.md:65
msgid "#### `@!method` and `@!attribute` directives improved"
msgstr "#### 改良された `@!method` と `@!attribute` ディレクティブ"

#: ../docs/WhatsNew.md:67
msgid ""
"The method and attribute directives can now be used to create multiple\n"
"objects in a single docstring. Previously a `@method` or `@attribute`\n"
"tag would only create one method per docstring. In 0.8.0, you could\n"
"attach multiple methods to the same block of Ruby source, such as:"
msgstr ""
"メソッドと属性(attribute)のディレクティブは\n"
"単一のdocstringで複数のオブジェクトを作成するのに利用できるようになった。\n"
"以前は `@method` や `@attribute` タグは\n"
"メソッド一つで個々のdocstringだけ作成していた。\n"
"0.8.0ではRubyのソースの同じブロックに複数のメソッドを追加できる。\n"
"次のようになる:"

#: ../docs/WhatsNew.md:72
msgid ""
"    # @!method foo(a, b, c)\n"
"    # @!method bar(x, y, z)\n"
"    # Docstring for code\n"
"    some_ruby_source"
msgstr ""
"    # @!method foo(a, b, c)\n"
"    # @!method bar(x, y, z)\n"
"    # コード用のdocstring\n"
"    some_ruby_source"

#: ../docs/WhatsNew.md:77
msgid ""
"The above creates #foo and #bar and the source listing for both will\n"
"be `some_ruby_source` with \"Docstring for code\" as the docstring."
msgstr ""
"上の例は\n"
"両方がdocstringとして\"コード用のdocstring\"と一緒に\n"
"`some_ruby_source` の説明になるように、\n"
"#fooメソッドと#barメソッドとソースのリストを作成する。"

#: ../docs/WhatsNew.md:80
msgid ""
"The attribute directive can take advantage of this functionality as well.\n"
"Note that these directives also do not need to be attached to a line of\n"
"code to be recognized; they can be in free-standing comments if the\n"
"methods are defined dynamically and not associated with any code."
msgstr ""
"属性のディレクティブはさらにこの機能の平均を取得できる。\n"
"次の事に留意する。\n"
"これらのディレクティブは認識されるのにコードの行に追加される必要もない。\n"
"つまり、これはメソッドが動的に定義される場合\n"
"自由な場所にコメントでき、任意のコードと一緒に関連づけられない。"

#: ../docs/WhatsNew.md:85
msgid "#### New `@!parse` directive to parse Ruby code"
msgstr "#### Rubyのコードを解析する為の新しい `@!parse` ディレクティブ"

#: ../docs/WhatsNew.md:87
msgid ""
"A new {tag:!parse} directive was added that allows a developer to have\n"
"YARD parse code that might not necessarily be parsable in its original\n"
"form. This is useful when using `instance_eval` and other dynamic\n"
"meta-programming techniques to define methods or perform functionality.\n"
"For instance, a common case of the \"self.included\" callback in module\n"
"to extend a module on a class might be in the form:"
msgstr ""
"新しい {tag:!parse} ディレクティブは\n"
"YARDが元の形式で解析する必要はないコードの解析を開発者に\n"
"許可するのに追加された。\n"
"これはメソッドを定義する時や機能を実行する時に\n"
" `instance_eval` と他の動的なメタプログラミングのテクニックを使う時に便利である。\n"
"例えば、次の形式でクラス上でモジュールを拡張するのに\n"
"モジュールの中の\"self.included\"コールバックの一般的なケース:"

#: ../docs/WhatsNew.md:94
msgid ""
"    def self.included(mod)\n"
"      mod.extend(self)\n"
"    end"
msgstr ""
"    def self.included(mod)\n"
"      mod.extend(self)\n"
"    end"

#: ../docs/WhatsNew.md:98
msgid ""
"Unfortunately, this does not get picked up by YARD, but on the original\n"
"class, we can add:"
msgstr ""
"あいにく、これはYARDによって取得できないが、\n"
"元のクラス上で次のように追加できる:"

#: ../docs/WhatsNew.md:101
msgid ""
"    class MyClass\n"
"      # @!parse extend TheDynamicModule\n"
"      include TheDynamicModule\n"
"    end"
msgstr ""
"    class MyClass\n"
"      # @!parse extend TheDynamicModule\n"
"      include TheDynamicModule\n"
"    end"

#: ../docs/WhatsNew.md:106
msgid ""
"YARD will then parse the code `extend TheDynamicModule` as if\n"
"it were in the source file."
msgstr ""
"それがソースファイルの中だった場合など\n"
"YARDが `extend TheDynamicModule` のコードを解析する時"

#: ../docs/WhatsNew.md:109
msgid ""
"You can also use this technique to register regular methods as\n"
"attributes, if you did not define them with `attr_*` methods:"
msgstr ""
"これらの `attr_*` メソッドを用いて定義しなかった場合、\n"
"あなたは属性として標準のメソッドを登録するのにこのテクニックを使う事ができる。"

#: ../docs/WhatsNew.md:112
msgid ""
"    def foo; @foo end\n"
"    def foo=(v) @foo = v end"
msgstr ""
"    def foo; @foo end\n"
"    def foo=(v) @foo = v end"

#: ../docs/WhatsNew.md:115
msgid ""
"    # Register them as methods:\n"
"    # @!parse attr_accessor :foo"
msgstr ""
"    # メソッドとしてそれらを登録する\n"
"    # @!parse attr_accessor :foo"

#: ../docs/WhatsNew.md:118
msgid "### Backward incompatible changes to `@!macro` directive"
msgstr "### 後方互換性のない `@!macro` ディレクティブに変更する"

#: ../docs/WhatsNew.md:120
msgid ""
"Unfortunately, in order to create the new directives architecture,\n"
"some previously supported syntax in `@macro` tags are no longer supported.\n"
"Specifically, macros can no longer expand text on an entire docstring.\n"
"Instead, macros only expand the data that is indented inside of the tag\n"
"text."
msgstr ""
"あいにく、新しいディレクティブアーキテクチャを作成する為の順番、\n"
"`@macro` タグの中でいくつか前にサポートされた構文は、もうサポートされない。\n"
"すなわち、マクロは全てのdocstring上のテキストを展開することはできない。\n"
"代わりに、マクロはタグのテキストの内部のインデントされたデータだけ展開する。"

#: ../docs/WhatsNew.md:126
msgid "This syntax is **no longer supported**:"
msgstr "This syntax is **no longer supported**:"

#: ../docs/WhatsNew.md:128
msgid ""
"    # @macro mymacro\n"
"    # Expanding text $1 $2 $3\n"
"    property :a, :b, :c"
msgstr ""
"    # @macro mymacro\n"
"    # Expanding text $1 $2 $3\n"
"    property :a, :b, :c"

#: ../docs/WhatsNew.md:132
msgid ""
"In 0.7.0 to 0.7.5, the above would have created a method with the docstring\n"
"\"Expanding text a b c\". This will not work in 0.8.0. Instead, you must\n"
"indent all the macro expansion data so that it is part of the `@macro`\n"
"tag as follows:"
msgstr ""
"0.7.0 ~ 0.7.5で、\n"
"上はの例はdocstring \"Expanding text a b c\"と一緒に作成されたメソッドを持つ。\n"
"これは、0.8.0では動かない。\n"
"代わりに、あなたは全てのマクロ展開のデータをインデントしなければならない。\n"
"つまり `@macro` タグの一部を次のようにする:"

#: ../docs/WhatsNew.md:137
msgid ""
"    # @!macro mymacro\n"
"    #   Expanding text $1 $2 $3\n"
"    property :a, :b, :c"
msgstr ""
"    # @!macro mymacro\n"
"    #   Expanding text $1 $2 $3\n"
"    property :a, :b, :c"

#: ../docs/WhatsNew.md:141
msgid ""
"Note that we also use the recommended `@!macro` syntax, though `@macro`\n"
"is still supported."
msgstr ""
"次の事に留意する。\n"
"我々は推奨された `@!macro` 構文を使うけれども、\n"
"`@macro` はまだサポートされている。"

#: ../docs/WhatsNew.md:144
msgid "## Added `--embed-mixin(s)` to embed mixins into class docs (0.8.0)"
msgstr "## クラスのドキュメントにmixinを埋め込むのに `--embed-mixin(s)` が追加された (0.8.0)"

#: ../docs/WhatsNew.md:146
msgid ""
"Methods from mixins can now be embedded directly into the documentation\n"
"output for a class by using `--embed-mixin ModuleName`, or `--embed-mixins`\n"
"for all mixins. This enables a documentation writer to refactor methods\n"
"into modules without worrying about them showing up in separate files\n"
"in generated documentation. When mixin methods are embedded, they\n"
"show up in both the original module page and the pages of the classes\n"
"they are mixed into. A note is added to the method signature telling the\n"
"user where the method comes from."
msgstr ""
"mixinからのメソッドは\n"
"全てのmixin用に `--embed-mixin ModuleName` や `--embed-mixins` 用の\n"
"ドキュメント出力の中へ直接埋め込まれるようになった。\n"
"これは生成されたドキュメントの中の分割されたファイルのなかの\n"
"その時の一覧について警告無しでモジュールの中の\n"
"メソッドをリファクタリングする為にドキュメントを書ける。\n"
"mixinメソッドが埋め込まれた時、\n"
"これは元のモジュールのページとこれらの混じったクラスのページの両方を一覧する。\n"
"noteはメソッドのシグネチャがメソッドがどこからくるかユーザーに知らせるのに追加された。"

#: ../docs/WhatsNew.md:155
msgid ""
"The `--embed-mixin` command-line option can also take wildcard values\n"
"in order to match specific namespaces. For instance, you can embed\n"
"only mixins inside of a \"Foo::Bar\" namespace by doing:"
msgstr ""
"`--embed-mixin` コマンドラインオプションは、\n"
"指定のネームスペースにマッチするのにワイルドカードの値も取得できる。\n"
"例えば、次の様にする事によって\n"
"\"Foo::Bar\"ネームスペースの内部にmixinだけ埋め込むことができる。"

#: ../docs/WhatsNew.md:159
msgid ""
"    !!!sh\n"
"    $ yard doc --embed-mixin \"Foo::Bar::*\""
msgstr ""
"    !!!sh\n"
"    $ yard doc --embed-mixin \"Foo::Bar::*\""

#: ../docs/WhatsNew.md:162
msgid "## Internationalization (I18n) support for translating docs"
msgstr "## 翻訳ドキュメント用の国際化(I18n)サポート"

#: ../docs/WhatsNew.md:164
msgid ""
"YARD now ships with the beginnings of internationalization support\n"
"for translating documentation into multiple languages. The\n"
"`yard i18n` command now allows you to generate \".pot\" and ultimately\n"
"\".po\" files for translation with [gettext](http://www.gnu.org/software/"
"gettext)."
msgstr ""
"YARDは複数の言語に翻訳したドキュメント用に国際化サポートを送りだすことになった。\n"
"`yard i18n` コマンドは\n"
"あなたが[gettext](http://www.gnu.org/software/gettext)を用いた翻訳用の\n"
"\".pot\"と最後に\".po\"ファイルを生成するのを許可するようになった。"

#: ../docs/WhatsNew.md:169
msgid ""
"Note that this tool is a small step in the larger transition for\n"
"proper I18n support in YARD. We still have to add proper gettext\n"
"support to our templates for proper generation in multiple languages,\n"
"but this tool allows you to get started in translating your\n"
"documents. Improved I18n support will come throughout the 0.8.x series."
msgstr ""
"次の事に留意する。\n"
"このツールはYARDの正当なI18nサポートの小さな一歩である。\n"
"我々はまだ複数の言語の適切な生成の為に、\n"
"例のテンプレートに適切なgettextサポートを追加する仕事が残っている。\n"
"だがこのツールはあなたが翻訳ドキュメントを始めるのを受け入れる。\n"
"改良されたI18nサポートは0.8.xシリーズに至る中で登場するだろう。"

#: ../docs/WhatsNew.md:175
msgid "## New C parser / handlers architecture (0.8.0)"
msgstr "## 新しい Cパーサー / ハンドラー構造 (0.8.0)"

#: ../docs/WhatsNew.md:177
msgid ""
"The C parser was completely rewritten to take advantage of YARD's\n"
"parser and handler architecture. This means more YARD will be more robust\n"
"when parsing failures occur, tags and directives will now work consistently\n"
"across Ruby and CRuby files ({tag:!group} will now work, for instance),\n"
"and developers can now write custom handlers that target CRuby source files."
msgstr ""
"YARDパーサーの平均とハンドラーアーキテクチャを取得するのに\n"
"C パーサーは完全に書き直された。\n"
"これはYARDが解析異常が起きた時にさらに堅牢になる事を意味し\n"
"タグとディレクティブはRubyとCRubyのファイル(例えば {tag:!group} が動くようになった)\n"
"全域で堅実に動く様になった。\n"
"そして、開発者はCRubyのソースファイルを目的にするカスタムハンドラーを書ける様になった。\n"

#: ../docs/WhatsNew.md:183
msgid "## YARD will now warn if `@param` name not in method params (0.8.0)"
msgstr "## YARDはメソッドパラメーターの中に`@param`名がない場合、警告を出すようになった(0.8.0)"

#: ../docs/WhatsNew.md:185
msgid ""
"YARD will now give you a warning if you use a `@param` tag in your\n"
"source but give an invalid parameter name. This should catch a lot of\n"
"common documentation errors and help keep your documentation consistent."
msgstr ""
"YARDはあなたのソースの中の `@param` タグを使う場合、あなたが警告を出せるようになった。\n"
"しかし有効なパラメータ名を与える。\n"
"これは沢山の一般的なドキュメントエラーをキャッチし、\n"
"あなたの一貫したドキュメントの保守を助ける。"

#: ../docs/WhatsNew.md:189
msgid "## Added support for `module_function` calls in Ruby code (0.8.0)"
msgstr "## `module_function` がRubyのコードの中で呼び出されるサポートが追加された (0.8.0)"

#: ../docs/WhatsNew.md:191
msgid ""
"The `module_function` command in Ruby is now supported in Ruby files.\n"
"It defines two separate methods, one class and one instance method,\n"
"both having the exact same docstring, and marks the instance method\n"
"as private."
msgstr ""
"Rubyの `module_function` コマンドは\n"
"Rubyのファイルでサポートされるようになった。\n"
"それは\"区切られたメソッド\"と\n"
"\"一つのクラスと一つのインスタンスメソッド\"二つを定義し、\n"
"正確な同じdocstring両方、\n"
"privateとしてインスタンスメソッドをマークする。"

#: ../docs/WhatsNew.md:196
msgid "## Greatly improved tag documentation using custom template (0.8.0)"
msgstr "## カスタムテンプレートによって大きく改良されたタグのドキュメント (0.8.0)"

#: ../docs/WhatsNew.md:198
msgid ""
"We have completely revamped the {docs/Tags.md} to include documentation\n"
"for each meta-data tag and directive with at least one useful example\n"
"for each one. This was done using template customization and extension\n"
"available within YARD."
msgstr ""
"我々は個々のメタデータタグとディレクティブ用の\n"
"ドキュメントを含めるのに {docs/Tags.md} を\n"
"少なくとも各々一つ便利な例を用い完全に刷新しました。\n"
"これはYARDの中でテンプレートのカスタマイズと拡張が可能になる事によって\n"
"行なわれた。"

#: ../docs/WhatsNew.md:203
msgid "## Tags can now contain '.' for namespacing (0.8.0)"
msgstr "## タグはネームスペース用の '.' を含める事できるようになった (0.8.0)"

#: ../docs/WhatsNew.md:205
msgid ""
"Prior to 0.8.0, tags could only contain alphanumeric characters and\n"
"underscore. YARD now allows the '.' character in tag names, and it\n"
"is now recommended for namespacing project-specific custom tags.\n"
"YARD has its own set of custom tags that are namespaced in this\n"
"way (using the \"yard.tagname\" namespace). The namespace recommendation\n"
"is to use \"projectname.tagname\", or \"projectname.component.tagname\"."
msgstr ""
"0.8.0以前のタグはアルファベット文字列とアンダースコアだけ含める事ができた。\n"
"YARDはタグ名で '.' の文字を受け入れるようになり、\n"
"プロジェクトの指定のカスタムタグのネームスペース用に推奨する。\n"
"YARDは自身のカスタム\n"
"この方法でネームスペース(名前付け)されるタグのグループを持つ。\n"
"おすすめのネームスペースは\n"
"\"projectname.tagname\" や \"projectname.component.tagname\"を使う"

#: ../docs/WhatsNew.md:212
msgid "## Added \"frames\" links for non-framed pages for better nav (0.8.0)"
msgstr "## ナビの改良の為フレームのないページ用にフレームのリンクが追加された (0.8.0)"

#: ../docs/WhatsNew.md:214
msgid ""
"Frames navigation has always had a \"(no frames)\" link to get rid\n"
"of the frameset. YARD 0.8.0 introduces a \"(frames)\" link on non-framed\n"
"pages to reverse this, allowing you to navigate between framed and\n"
"frameless pages seamlessly."
msgstr ""
"フレームのナビゲーションは\n"
"フレームセットを取り除くのを取得するのに常に\"(no frames)\"のリンクを持っていた。\n"
"YARD 0.8.0はこれを置き換えるのにフレームの無いページで\n"
"\"(frames)\"のリンクを導入する\n"
"フレームとフレーム無しのページ間を\n"
"シームレスにナビゲートするのに許可される。"

#: ../docs/WhatsNew.md:219
msgid "## Added Gemfile support to YARD server for local gem sets (0.8.0)"
msgstr "## ローカルgemのグループ用にYARDサーバーにGemfileのサポートが追加された (0.8.0)"

#: ../docs/WhatsNew.md:221
msgid ""
"The `yard server` command now supports `--gemfile` to serve gems\n"
"from a Gemfile.lock, instead of all system-wide gems."
msgstr ""
"全てのシステム側のgemの代わりにGemfile.lockからgemを提供するのに、\n"
"`yard server` コマンドは、`--gemfile` をサポートするようになった。"

#: ../docs/WhatsNew.md:224
msgid "## Server now displays README on index route like static docs (0.8.0)"
msgstr "## サーバーは静的なドキュメントのようなルートのインデックス上でREADMEを表示する(0.8.0)"

#: ../docs/WhatsNew.md:226
msgid ""
"The `yard server` command will now behave like static docs regarding\n"
"the index action for a project, listing the README file if present\n"
"before displaying the alphabetic index. Note that the route for\n"
"the alphabetic index page has now moved to the explicit '/index' action."
msgstr ""
"`yard server` コマンドは\n"
"プロジェクト用のインデックスの動作について\n"
"静的なドキュメントのような挙動になり、\n"
"アルファベットのインデックスを表示する前に与える場合、\n"
"READMEファイルを記述する。\n"
"次の事に留意する。\n"
"アルファベット順のインデックスページ用のルートは\n"
"明示的な '/index' の動作に移るようになった。"

#: ../docs/WhatsNew.md:231
msgid "## Added line numbers to `yard stats --list-undoc --compact` (0.8.0)"
msgstr "## `yard stats --list-undoc --compact` に行数が追加された (0.8.0)"

#: ../docs/WhatsNew.md:233
msgid ""
"Line numbers are now listed in the compact listing of undocumented objects\n"
"so that they can be more easily located in the files."
msgstr ""
"行数はコンパクトなアンドキュメントなオブジェクトのリストで記述されるようになった。\n"
"なのでこれらはさらに簡単にファイルの中を示す事ができる。"

#: ../docs/WhatsNew.md:236
msgid "## Single object db now default (multi-object db unsupported) (0.8.0)"
msgstr ""

#: ../docs/WhatsNew.md:238
msgid ""
"YARD previously would split the .yardoc db into multiple marshal files\n"
"for load-time performance reasons if it grew past a specific number of\n"
"objects. This check is now disabled, and YARD will never automatically\n"
"switch to a multi-object DB. YARD will now always use the single object\n"
"db unless explicitly set with `--no-single-db`. If YARD is taking a\n"
"long time to load your .yardoc database, you can try using this\n"
"option to split your database into multiple files, but note that this\n"
"can cause problems with certain codebases (specifically, if you\n"
"have class methods using the same name as a module/class)."
msgstr ""

#: ../docs/WhatsNew.md:248
msgid "## Added `--api` tag to generate documentation for API sets (0.8.1)"
msgstr ""

#: ../docs/WhatsNew.md:250
msgid ""
"You can now use `yardoc --api APINAME` to generate documentation only\n"
"for objects with the `@api APINAME` tag (or any parent namespace objects,\n"
"since this tag is transitive). Multiple `--api` switches may be used to\n"
"generate documentation for multiple APIs together. The following generates\n"
"documentation for both the \"public\" and \"developer\" APIs, also "
"including\n"
"any objects with undefined API (via `--no-api`):"
msgstr ""

#: ../docs/WhatsNew.md:257
msgid "    $ yard doc --api public --api developer --no-api"
msgstr "    $ yard doc --api public --api developer --no-api"

#: ../docs/WhatsNew.md:259
msgid ""
"Note that if you use `--api`, you must ensure that you also add `@api`\n"
"tags to your namespace objects (modules and classes), not just your "
"methods.\n"
"If you do not want to do this, you can also include all objects with *no*\n"
"`@api` tag by using `--no-api` as shown above."
msgstr ""

#: ../docs/WhatsNew.md:264
msgid ""
"Remember that applying an `@api` tag to a class or module will apply it\n"
"to all children that do not have this tag already defined, so you can\n"
"declare an entire class public by applying it to the class itself. Note\n"
"also that these tags can be overridden by child elements if the tag is\n"
"re-applied to the individual object."
msgstr ""

#: ../docs/WhatsNew.md:270
msgid ""
"This feature is a simplified version of the more powerful `--query`\n"
"switch. The query to display the same API documentation as the\n"
"above example would be:"
msgstr ""

#: ../docs/WhatsNew.md:274
msgid "    $ yard doc --query '!@api || @api.text =~ /^(public|private)$/'"
msgstr "    $ yard doc --query '!@api || @api.text =~ /^(public|private)$/'"

#: ../docs/WhatsNew.md:276
msgid ""
"But note that `--query` does not work when YARD is in \"safe mode\"\n"
"due to security concerns, whereas `--api` works in either mode.\n"
"This enables `--api` to function on remote documentation sites like\n"
"[rubydoc.info](http://rubydoc.info)."
msgstr ""

#: ../docs/WhatsNew.md:282
msgid "# What's New in 0.7.x?"
msgstr "# What's New in 0.7.x?"

#: ../docs/WhatsNew.md:284
msgid ""
"1. **Macro support and detection of DSL methods** (0.7.0)\n"
"2. **Inherited attributes now show in HTML output** (0.7.0)\n"
"3. **The 'app' directory is now parsed by default** (0.7.0)\n"
"4. **Added support for metadata (@title, @markup) in extra files/readmes** "
"(0.7.0)\n"
"5. **Added `yard list` command (alias for `yardoc --list`)** (0.7.0)\n"
"6. **Added Git support in `yard diff`** (0.7.0)\n"
"7. **Added `{include:file:FILENAME}` syntax** (0.7.0)\n"
"8. **Added `{render:OBJECT}` syntax to embed object docs in extra files** "
"(0.7.0)\n"
"9. **Added improved templates API for custom CSS/JS/menus** (0.7.0)\n"
"10. **Added Ruby markup type (`-m ruby`)** (0.7.0)\n"
"11. **Added state tracking variables to Parser/Handler architecture** "
"(0.7.0)\n"
"12. **Added before/after callbacks to SourceParser** (0.7.0)\n"
"13. **Can now use `--yardopts FILE` to specify a custom yardopts file** "
"(0.7.0)\n"
"14. **Added new `-t guide` template for guide based docs** (0.7.0)\n"
"15. **Github Flavoured Markdown now works out-of-box** (0.7.4)\n"
"16. **Added `-m textile_strict` and `-m pre` markup types** (0.7.4)\n"
"17. **Reorganized markup types 'text' and 'none'** (0.7.4)\n"
"18. **Add support for `rb_define_alias`** (0.7.4)"
msgstr ""
"1. **マクロのサポートとDSLメソッドの検知** (0.7.0)\n"
"2. **継承された属性はすぐHTML出力で一覧できる** (0.7.0)\n"
"3. **'app'ディレクトリは、すぐデフォルトで解析される** (0.7.0)\n"
"4. **追加のファイル/readmesでメタデータ用(@title,@markup)のサポートが追加され"
"た** (0.7.0)\n"
"5. **`yard list`コマンドが追加された(`yardoc --list`用のエイリアス)** "
"(0.7.0)\n"
"6. **`yard diff`でGitサポートが追加された** (0.7.0)\n"
"7. **`{include:file:FILENAME}`構文** (0.7.0)\n"
"8. **追加のファイルでオブジェクトのdocsを組み込む為の`{render:OBJECT}`構文が"
"追加された** (0.7.0)\n"
"9. **カスタムCSS/JS/メニュー用の改良されたテンプレートAPIが追加された** "
"(0.7.0)\n"
"10. **Rubyのマークアップの型(`-m ruby`)が追加された** (0.7.0)\n"
"11. **パーサー/ハンドラーのアーキテクチャにトラッキングの状態変数が追加された"
"** (0.7.0)\n"
"12. **SourceParserにbefore/afterのコールバックが追加された** (0.7.0)\n"
"13. **カスタムyardoptsファイルを指定するのに、`--yardopts FILE`ですぐに、使う"
"事が出来る** (0.7.0)\n"
"14. **基底となるdocstringをガイドするのに、`-t guide`テンプレートを新しく追加"
"する** (0.7.0)<\n"
"15. **Github風のMarkdownが常識破りの仕事をするようになった** (0.7.4)\n"
"16. **`-m textile_strict`と`-m pre`マークアップの型が追加された** (0.7.4)\n"
"17. **'text'と'none'のマークアップ型が再編成された** (0.7.4)\n"
"18. **`rb_define_alias`用のサポートが追加された** (0.7.4)"

#: ../docs/WhatsNew.md:303
msgid "## Macro support and detection of DSL methods (0.7.0)"
msgstr "## マクロのサポートとDSLメソッドの検知 (0.7.0)"

#: ../docs/WhatsNew.md:305
msgid ""
"YARD will now automatically detect class level method calls, similar to the\n"
"way it knows what an `attr_accessor` is. By simply adding documentation to\n"
"your class level declarations, YARD can automatically detect them as "
"methods\n"
"or attributes in your class. Consider DataMapper's \"property\" declaration:"
msgstr ""
"YARDは自動でクラスレベルメソッドの呼び出しを検知するようになった。\n"
"'attr_accessor'何なのか知るのと似ている。\n"
"簡単にあなたのクラスレベル宣言にドキュメントを追加する。\n"
"DataMapperの\"property\"宣言を考慮する。"

#: ../docs/WhatsNew.md:310
msgid ""
"    class Post\n"
"      # @attribute\n"
"      # @return [String] the title of the post\n"
"      property :title, String\n"
"    end"
msgstr ""
"    class Post\n"
"      # @attribute\n"
"      # @return [String] the title of the post\n"
"      property :title, String\n"
"    end"

#: ../docs/WhatsNew.md:316
msgid ""
"The above declaration would be created as the `Post#title`. The optional\n"
"`@attribute` tag tells YARD that the property is an \"attribute\", and not "
"just\n"
"a regular method."
msgstr ""
"上の宣言は、`Post#title`メソッドとして作成されるだろう。\n"
"任意の`@attribute`タグがYARDの\"property\"に伝えるのは、\"attribute\"であ"
"り、\n"
"それは正規のメソッドではない。"

#: ../docs/WhatsNew.md:320
msgid ""
"In addition to basic DSL method detection, YARD also supports macros to "
"create\n"
"docstrings that can be copies to other objects; these macros can also be\n"
"\"attached\" to class level methods to create implicit documentation for "
"macros."
msgstr ""
"更に基本のDSLメソッド検知に加えて、\n"
"YARDは他のオブジェクトにコピーできるdocstringを作成するマクロもサポートする。\n"
"これらのマクロはマクロ用に暗黙のドキュメントを作成するために\n"
"クラスレベルメソッドに\"追加\"(attached)もできる。"

#: ../docs/WhatsNew.md:324
msgid ""
"Macros and DSL method detection are discussed in much more detail in the\n"
"{file:docs/GettingStarted.md}, so you should read about them there if "
"you're\n"
"interested in this feature."
msgstr ""
"マクロとDSLメソッド宣言の詳細は{file:docs/GettingStarted.md}で説明されるので、\n"
"あなたがこの機能に興味がある場合、そこで読む事ができる。"

#: ../docs/WhatsNew.md:328
msgid "## Inherited attributes now show in HTML output (0.7.0)"
msgstr "## 継承された属性をHTML出力ですぐに調べられるようになった (0.7.0)"

#: ../docs/WhatsNew.md:330
msgid ""
"Inherited attributes will now show up in HTML documentation using the "
"default\n"
"template in the same manner that inherited methods do."
msgstr ""
"継承された属性は、\n"
"継承されたメソッドと同じ形式で\n"
"デフォルトのテンプレートによって\n"
"HTMLドキュメントですぐに現れるだろう。"

#: ../docs/WhatsNew.md:333
msgid "## The 'app' directory is now parsed by default (0.7.0)"
msgstr "## デフォルトで'app'ディレクトリはすぐに解析される (0.7.0)"

#: ../docs/WhatsNew.md:335
msgid ""
"YARD tries to follow the \"It Just Works\" attitude in writing developer "
"tools,\n"
"and therefore has added `app/**/*.rb` to the default list of globs that it\n"
"searches for code in. You no longer need to create a `.yardopts` just to\n"
"list your app directory when documenting your code on rubydoc.info.\n"
"We should have done this a while ago! And don't worry, YARD still checks\n"
"lib and ext by default, too."
msgstr ""
"YARDは開発者のツールで書かれている\\\"ちゃんと動く\\\"姿勢をフォローしようとする、\n"
"従って、それがコード用に検索するglobのデフォルトのリストに\n"
"追加された`app/**/*.rb`を持つ\n"
"あなたはもはやrubydoc.infoであなたのコードを記述する時に\n"
"あなたのアプリのディレクトリ記述するのに`.yardopts`を作成する必要はない。\n"
"ちょっと前にこれが完成したが、心配しないで、\n"
"YARDはまだデフォルトでlibとextもチェックする。"

#: ../docs/WhatsNew.md:342
msgid ""
"## Added support for metadata (@title, @markup) in extra files/readmes "
"(0.7.0)"
msgstr ""
"## 追加のファイルとREADMEの中でメタデータ(@title,@markup)用のサポートが追加さ"
"れた(0.7.0)"

#: ../docs/WhatsNew.md:344
msgid ""
"Extra files (READMEs, ChangeLogs, LICENSE files, and other guides) now "
"support\n"
"metadata tags, just like docstrings in code comments. By adding @tag values\n"
"to the top of a file (no whitespace preceding it) inside of a `# comment` "
"line,\n"
"YARD will detect and parse these tags and store it for later usage."
msgstr ""
"追加のファイル(README,ChangeLogs,LICENSEファイルや他のガイド)は、\n"
"すぐに、メタデータタグをサポートする(コードのコメント中のdocstringのよう"
"に)。\n"
"`# comment`行の中のファイルの最初に@tagの値を追加する事で、\n"
"YARDは、このタグを検知,解析し、最新の方法でそれを記録するだろう。"

#: ../docs/WhatsNew.md:349
msgid ""
"Tags can contain arbitrary data as well as arbitrary tag names, however the\n"
"tag names @title and @markup are reserved to specify the document title and\n"
"markup format respectively. The title will be used in the file list menu,\n"
"index page, as well as any linking of the file via the `{file:Filename}`\n"
"syntax. An example of a document with metadata would be:"
msgstr ""
"タグは任意のデータも任意のタグ名も含める事ができる、\n"
"しかしながら、タグ名の@titleと@markupは、\n"
"ドキュメントのタイトルとマークアップフォーマットを個別に指定する為に用意される。\n"
"タイトルはファイルリストメニューや\n"
"index pageも`{file:Filename}`構文経由の任意のファイルへのリンクでも利用される。\n"
"次はメタデータを用いたドキュメントの例:"

#: ../docs/WhatsNew.md:355
msgid ""
"    # @title The Best Project Ever!\n"
"    # @markup rdoc\n"
"    # @author Foo Bar (custom tag, does not display in templates)"
msgstr ""
"    # @title The Best Project Ever!\n"
"    # @markup rdoc\n"
"    # @author Foo Bar (custom tag, does not display in templates)"

#: ../docs/WhatsNew.md:359
msgid "    = This Project Rules"
msgstr "    = This Project Rules"

#: ../docs/WhatsNew.md:361
msgid "    == Contents"
msgstr "    == Contents"

#: ../docs/WhatsNew.md:363
msgid "    ..."
msgstr "    ..."

#: ../docs/WhatsNew.md:365
msgid ""
"Note that previous versions of YARD recommended specifying the markup of an\n"
"extra file with the `#!markup` shebang, but the `@markup` metadata tag is "
"now\n"
"the \"best practice\" for specifying the markup format of an extra file."
msgstr ""
"次の事に留意する。\n"
"YARDの前のバージョンは、\n"
"`#!markup`のshebangを用いた追加のファイルのマークアップの指定が\n"
"推奨された。\n"
"しかし、今は`@markup`メタデータタグが、\n"
"追加のファイルのマークアップフォーマットを指定するのに最善の方法である。"

#: ../docs/WhatsNew.md:369
msgid "## Added `yard list` command (alias for `yardoc --list`) (0.7.0)"
msgstr ""
"## `yard list`コマンドを追加する。(`yardoc --list`用のエイリアス) (0.7.0)"

#: ../docs/WhatsNew.md:371
msgid ""
"The `yardoc --list` command is used to list objects that are parsed from\n"
"a codebase. This can be used to grep methods/classes in a codebase from the\n"
"command line. `yard list` now calls `yardoc --list` as a convenience command."
msgstr ""
"`yardoc --list`コマンドはソースコードから解析されるリストオブジェクトの為に利"
"用される。\n"
"これは、ソースコードの中でメソッド/クラスをgrepする為に利用できる。\n"
"`yard list`は、便利なメソッドとして`yardoc --list`を呼び出すようになった。"

#: ../docs/WhatsNew.md:375
msgid ""
"Note that the `yardoc --list` command may eventually be replaced by a more\n"
"feature-filled `yard list` command, so `yard list` should be used instead "
"of\n"
"`yardoc --list` when possible."
msgstr ""
"次の事に留意する。`yardoc --list`コマンドは、\n"
"将来、より多くの機能で満たされた`yard list`コマンドに切り替わるだろう。\n"
"なので可能であれば`yardoc --list`の代わりに、`yard list`を利用する方がよい。"

#: ../docs/WhatsNew.md:379
msgid "## Added Git support in `yard diff` (0.7.0)"
msgstr "## `yard diff`でGitのサポートが追加された (0.7.0)"

#: ../docs/WhatsNew.md:381
msgid ""
"The `yard diff` command can now perform object diffing on git repositories.\n"
"Provide the `--git` switch to `yard diff` with 2 commit/branches like so:"
msgstr ""
"`yard diff`コマンドは、すぐに、gitリポジトリ上でオブジェクトのdiffを実行す"
"る。\n"
"`yard diff`に切り替える`--git`を提供する。\n"
"次のように、2つのcommitとbrancheを切り替える。"

#: ../docs/WhatsNew.md:384
msgid ""
"    $ yard diff --git HEAD~5 HEAD\n"
"    Added objects:"
msgstr ""
"    $ yard diff --git HEAD~5 HEAD\n"
"    Added objects:"

#: ../docs/WhatsNew.md:387
msgid ""
"      YARD::Parser::SourceParser#contents\n"
"      YARD::Parser::SourceParser#globals\n"
"      ..."
msgstr ""
"      YARD::Parser::SourceParser#contents\n"
"      YARD::Parser::SourceParser#globals\n"
"      ..."

#: ../docs/WhatsNew.md:391
msgid "## Added `{include:file:FILENAME}` syntax (0.7.0)"
msgstr "## `{include:file:FILENAME}`構文 (0.7.0)"

#: ../docs/WhatsNew.md:393
msgid ""
"You can now use the `{include:file:FILENAME}` syntax to embed the contents\n"
"of an extra file marked up in its markup format. This syntax supports "
"embedding\n"
"Ruby source files and performing syntax highlighting on the code."
msgstr ""
"あなたはすぐに、\n"
"マークアップされた追加のファイルの内容を埋め込む為の\n"
"`{include:file:FILENAME}`構文を利用できる。\n"
"この構文は、Rubyのソースファイルの埋め込みと構文のコードハイライトの実行をサ"
"ポートする。"

#: ../docs/WhatsNew.md:397
msgid ""
"## Added `{render:OBJECT}` syntax to embed object docs in extra files (0.7.0)"
msgstr ""
"## 追加のファイルでdocsオブジェクトを埋め込む為に`{render:OBJECT}`構文を追加"
"した (0.7.0)"

#: ../docs/WhatsNew.md:399
msgid ""
"You can now use the `{render:Object}` syntax to embed the documentation\n"
"rendering of an entire object (method, class, module) inside of an extra "
"file.\n"
"This is useful when writing non-API based guides that might require listing\n"
"a few helper methods or classes. The {file:docs/GettingStarted.md} "
"discussed\n"
"this syntax in more detail (with example usage)."
msgstr ""
"あなたは、追加のファイルの中の全てのオブジェクト(メソッド,クラス,モジュール)のドキュメント表示を\n"
"埋め込む為に`{render:Object}`構文を利用できる。\n"
"これはいくつかのヘルパーメソッドや\n"
"クラスを記述する必要があるAPIベースではないガイドを書く時に便利である。\n"
"この構文の更なる詳細(例や使用法)は、\n"
"{file:docs/GettingStarted.md}で説明される。"

#: ../docs/WhatsNew.md:405
msgid "## Added improved templates API for custom CSS/JS/menus (0.7.0)"
msgstr "## CSS/JS/メニュー用に改良されたテンプレートAPIが追加された (0.7.0)"

#: ../docs/WhatsNew.md:407
msgid ""
"Plugin & template developers can now more easily insert custom stylesheet\n"
"or JavaScript files in their customized templates, thanks to an abstraction\n"
"of the template API. This is documented in the {docs/Templates.md} "
"document.\n"
"In addition to custom CSS/JS, developers can also create custom menu tabs\n"
"in both the framed and non framed version of the default theme."
msgstr ""
"プラグインとテンプレートの開発者は、\n"
"template APIの抽象化のおかげで、\n"
"カスタマイズされたテンプレートで\n"
"スタイルシートやJavaScriptのファイルを挿入できるようになった。\n"
"これは、{docs/Templates.md}ドキュメントの中で記述される。\n"
"さらに、カスタムCSS/JSで、開発者は、\n"
"フレーム有とデフォルトテーマのフレーム無しの両方のカスタムメニュータブを\n"
"作成する事もできる。"

#: ../docs/WhatsNew.md:413
msgid "## Added Ruby markup type (`-m ruby`) (0.7.0)"
msgstr "## Rubyマークアップ型(`-m ruby`)が追加された (0.7.0)"

#: ../docs/WhatsNew.md:415
msgid ""
"The Ruby markup type (`-m ruby`) will now use syntax highlighting for all\n"
"formatting. This is probably not useful as a global switch, but can be used\n"
"on individual extra files using the metadata markup specification discussed\n"
"above."
msgstr ""
"Rubyマークアップ型の(`-m ruby`)は、すぐに、\n"
"全てのフォーマット用に構文のハイライトを利用する。\n"
"これは全体の切り替えとしては、恐らく便利ではないが、\n"
"上で説明されたメタデータマークアップの指定によって\n"
"個々の追加のファイル上で利用できる。"

#: ../docs/WhatsNew.md:420
msgid ""
"## Added state tracking variables to Parser/Handler architecture (0.7.0)"
msgstr ""
"## Parser/Handlerアーキテクチャにトラッキング変数の状態が追加された (0.7.0)"

#: ../docs/WhatsNew.md:422
msgid ""
"The parser and handler architecture now contain state variables\n"
"{YARD::Handlers::Base#extra_state} and {YARD::Handlers::Processor#globals}\n"
"to share data across handlers and the entire processing phase. "
"`#extra_state`\n"
"provided a place to store per-file data, while `#globals` gives the "
"developer\n"
"access to inter-file state when parsing multiple files at once."
msgstr ""
"パーサーとハンドラーのアーキテクチャは、\n"
"ハンドラーと全ての処理段階に渡って共有する為に\n"
"{YARD::Handlers::Base#extra_state} と {YARD::Handlers::Processor#globals}の\n"
"変数の状態を含むようになった。\n"
"`#extra_state`メソッドは、ファイル毎にデータを記録する為の場所を提供し、\n"
"`#globals`メソッドは、一気に複数のファイルを解析する時に内部のファイルの状態に\n"
"開発者がアクセスする事を許可する。"

#: ../docs/WhatsNew.md:428
msgid "## Added before/after callbacks to SourceParser (0.7.0)"
msgstr "## SourceParserにbeforeとafterのコールバックが追加された (0.7.0)"

#: ../docs/WhatsNew.md:430
msgid ""
"The {YARD::Parser::SourceParser} class can now register callbacks to "
"execute\n"
"code before and after parsing of file globs, as well as before and after\n"
"parsing of individual files. This allows plugin developers to perform\n"
"setup/teardown (and set global state or update the {YARD::Registry})."
msgstr ""
"{YARD::Parser::SourceParser}クラスは、\n"
"ファイルグロブの解析の前後のコードも個々のファイルの解析の前後も\n"
"実行する為にすぐにコールバックを記録できる。\n"
"これは、セットアップ/開発(全体の状態や{YARD::Registry}の更新)を実行する為、\n"
"開発者のプラグインを受入れる。"

#: ../docs/WhatsNew.md:435
msgid "See the documentation for the following methods:"
msgstr "次のメソッド用のドキュメントを参照:"

#: ../docs/WhatsNew.md:437
msgid ""
"* {YARD::Parser::SourceParser.before_parse_list}\n"
"* {YARD::Parser::SourceParser.after_parse_list}\n"
"* {YARD::Parser::SourceParser.before_parse_file}\n"
"* {YARD::Parser::SourceParser.after_parse_file}"
msgstr ""
"* {YARD::Parser::SourceParser.before_parse_list}\n"
"* {YARD::Parser::SourceParser.after_parse_list}\n"
"* {YARD::Parser::SourceParser.before_parse_file}\n"
"* {YARD::Parser::SourceParser.after_parse_file}"

#: ../docs/WhatsNew.md:442
msgid ""
"## Can now use `--yardopts FILE` to specify a custom yardopts file (0.7.0)"
msgstr ""
"## カスタムyardoptsファイルを指定するのに、`--yardopts FILE`を利用できるよう"
"になった (0.7.0)"

#: ../docs/WhatsNew.md:444
msgid ""
"The `yardoc` command now supports `--yardopts FILE` to specify custom ."
"yardopts\n"
"options files. This is useful if you have multiple documentation sets, such\n"
"as a guide documentation set and an API documentation set."
msgstr ""
"`yardoc`コマンドは、すぐに\n"
"カスタム.yardopts設定ファイルを指定するのに、\n"
"`--yardopts FILE`をサポートする。\n"
"これは、ガイドキュメントやAPIドキュメントのような\n"
"複数のドキュメントのグループを持っている場合、便利である。"

#: ../docs/WhatsNew.md:448
msgid "## Added new `-t guide` template for guide based docs (0.7.0)"
msgstr ""
"## docstringベースのガイド用に`-t guide`テンプレートが新しく追加された "
"(0.7.0)"

#: ../docs/WhatsNew.md:450
msgid ""
"You can now write guide style documentation using a new 'guide' template "
"that\n"
"only generates documentation for extra files. You would use it in the form:"
msgstr ""
"あなたは、追加のファイル用のドキュメントだけ生成する\n"
"新しく追加された'guide'テンプレートによって\n"
"すぐにガイドスタイルドキュメントを書く事ができる。\n"
"あなたは、次のような形式で利用できる。"

#: ../docs/WhatsNew.md:453
msgid "    yardoc -t guide - README GettingStarted FAQ TroubleShooting LICENSE"
msgstr "    yardoc -t guide - README GettingStarted FAQ TroubleShooting LICENSE"

#: ../docs/WhatsNew.md:455
msgid ""
"This creates the sections for the readme, a getting started, frequently "
"asked\n"
"questions, trouble shooting and license page."
msgstr ""
"これは、README,GettingStarted,FAQ,トラブルシューティング,ライセンスページ用の"
"セクションを生成する。"

#: ../docs/WhatsNew.md:458
msgid ""
"If you need to refer to class / method documentation, you can embed API "
"documentation\n"
"using the `{render:Object}` tag discussed above."
msgstr ""
"クラスとメソッドドキュメントに参照する必要がある場合、\n"
"APIドキュメントを上で説明された`{render:Object}`タグによって埋め込む事が出来"
"る。"

#: ../docs/WhatsNew.md:461
msgid "## Github Flavoured Markdown now works out-of-box (0.7.4)"
msgstr ""

#: ../docs/WhatsNew.md:463
msgid ""
"Due to the growing popularity of Github-Flavoured-Markdown (GFM), YARD now "
"uses\n"
"the Redcarpet library as the default Markdown formatting library with GFM "
"fenced\n"
"code blocks enabled. This means that you can use fenced code blocks inside "
"of\n"
"Markdown files with redcarpet installed without any extra code. Previously, "
"users\n"
"who wanted GFM in their Markdown would have to specify `-m markdown -M "
"redcarpet`,\n"
"but this is now the default behaviour for YARD."
msgstr ""

#: ../docs/WhatsNew.md:470
msgid ""
"Note that you can still specify language types in code blocks without GFM in "
"YARD\n"
"by using the \"!!!lang\" prefix syntax. For example (plain means no markup):"
msgstr ""

#: ../docs/WhatsNew.md:473
msgid ""
"    !!!plain\n"
"    !!!plain\n"
"    Some code\n"
"    block here."
msgstr ""
"    !!!plain\n"
"    !!!plain\n"
"    Some code\n"
"    block here."

#: ../docs/WhatsNew.md:478
msgid "The GFM version would be:"
msgstr ""

#: ../docs/WhatsNew.md:480
msgid ""
"    !!!plain\n"
"    ```plain\n"
"    Some code\n"
"    block here.\n"
"    ```"
msgstr ""
"    !!!plain\n"
"    ```plain\n"
"    Some code\n"
"    block here.\n"
"    ```"

#: ../docs/WhatsNew.md:486
msgid "## Added `-m textile_strict` and `-m pre` markup types (0.7.4)"
msgstr ""

#: ../docs/WhatsNew.md:488
msgid ""
"A new \"textile_strict\" markup type was added which behaves exactly like "
"\"textile\"\n"
"except it enables hard breaks, so newlines behave as line breaks in the "
"HTML\n"
"(using `<br>` tags). This option is added for users who want the classic "
"textile\n"
"behaviour."
msgstr ""

#: ../docs/WhatsNew.md:493
msgid "## Reorganized markup types 'text' and 'none' (0.7.4)"
msgstr ""

#: ../docs/WhatsNew.md:495
msgid ""
"Due to the new pre markup type, the behaviour for text and none were "
"slightly\n"
"reorganized to be more intuitive. The following behaviours now represent "
"these\n"
"markup types:"
msgstr ""

#: ../docs/WhatsNew.md:499
msgid ""
" * pre: Used to wrap text inside `<pre>` tags\n"
" * text: No formatting except for hard breaks (`<br>`) on newlines\n"
" * none: No formatting at all."
msgstr ""

#: ../docs/WhatsNew.md:503
msgid ""
"In all cases, HTML is escaped from input. If you want no HTML escaping, use "
"the\n"
"html markup type."
msgstr ""

#: ../docs/WhatsNew.md:506
msgid "## Add support for `rb_define_alias` (0.7.4)"
msgstr "## `rb_define_alias`用のサポートが追加された (0.7.4)"

#: ../docs/WhatsNew.md:508
msgid ""
"CRuby code can now make use of the `rb_define_alias` function. "
"Documentation\n"
"for aliases is not supported, however."
msgstr ""

#: ../docs/WhatsNew.md:511
msgid "# What's New in 0.6.x?"
msgstr ""

#: ../docs/WhatsNew.md:513
msgid ""
"1. **Local documentation server for RubyGems or projects (`yard server`)** "
"(0.6.0)\n"
"2. **Groups support for method listing** (0.6.0)\n"
"3. **Single file template (`--one-file`) support** (0.6.0)\n"
"4. **`yard` CLI executable with pluggable commands** (0.6.0)\n"
"5. **`yard diff` command to object-diff two versions of a project** (0.6.0)\n"
"6. **Added `--asset` option to `yardoc`** (0.6.0)\n"
"7. **New template API** (0.6.0)\n"
"8. **HTML template now adds inline Table of Contents for extra files pages** "
"(0.6.0)\n"
"9. **Removed `--incremental` in favour of `--use-cache`** (0.6.0)\n"
"10. **Ad-hoc tag registration via `yardoc` CLI (`--tag`, etc.)** (0.6.0)\n"
"11. **Added `--transitive-tags` to register transitive tags** (0.6.0)\n"
"12. **`yardoc` now displays RDoc-like statistics (`--no-stats` to hide)** "
"(0.6.0)\n"
"13. **`yri` now works on constants** (0.6.0)\n"
"14. **Plugins are no longer auto-loaded (added `--plugin` switch)** (0.6.2)\n"
"15. **Added `YARD::Config` API and `~/.yard/config` configuration file** "
"(0.6.2)\n"
"16. **Added `yard config` command to view/edit configuration** (0.6.2)\n"
"17. **Added `yard server -t` template path switch** (0.6.2)\n"
"18. **Added `YARD::Server.register_static_path` for static server assets** "
"(0.6.2)\n"
"19. **YARD::Registry is now thread local** (0.6.5)\n"
"20. **Support for ripper gem in Ruby 1.8.7** (0.6.5)"
msgstr ""
"1. **RubyGemsやプロジェクト用のローカルドキュメントサーバー(`yard server`)** "
"(0.6.0)\n"
"2. **メソッド記述用のサポートをグループ化する** (0.6.0)\n"
"3. **単一のファイルのテンプレートのサポート(`--one-file`)** (0.6.0)\n"
"4. **`yard` のコマンドは、プラグインコマンドを用い実行可能となる** (0.6.0)\n"
"5. **プロジェクトの二つのバージョンのオブジェクトのdiffを見る為の`yard diff`"
"コマンド** (0.6.0)\n"
"6. **`yardoc`に`--asset`オプションが追加された** (0.6.0)\n"
"7. **新しいテンプレートAPI** (0.6.0)\n"
"8. **HTMLテンプレートは追加のファイルのページの内容のインラインテーブルを追加"
"する** (0.6.0)\n"
"9. **`--use-cache`のおかげで`--incremental`は削除された** (0.6.0)\n"
"10. **`yardoc`CLI経由で臨時のタグの記録(`--tag`, etc.)** (0.6.0)\n"
"11. **過渡的なタグを記録する為に、`--transitive-tags`が追加された** (0.6.0)\n"
"12. **`yardoc`がRDocのように統計値を表示するようになった(隠すには、`--no-"
"stats`)**\n"
"13. **`yri`定数で働くようになった** (0.6.0)\n"
"14. **プラグインは、自動ロードされなくなった(`--plugin`引数が追加された)** "
"(0.6.2)\n"
"15. **`YARD::Config`APIと`~/.yard/config`設定ファイルが追加された** (0.6.2)\n"
"16. **設定の調査/編集の為の`yard config`コマンドが追加された** (0.6.2)\n"
"17. **`yard server -t`テンプレートのパスの引数が追加された** (0.6.2)\n"
"18. **静的なサーバー資源用に`YARD::Server.register_static_path`が追加された"
"** (0.6.2)\n"
"19. **YARD::Registryがスレッドローカルになった** (0.6.5)\n"
"20. **Ruby 1.8.7でgemのripper用のサポート** (0.6.5)"

#: ../docs/WhatsNew.md:534
msgid ""
"## Local documentation server for RubyGems or projects (`yard server`) "
"(0.6.0)"
msgstr ""
"## RubyGems又はプロジェクト用のローカルドキュメントサーバー(`yard server`) "
"(0.6.0)"

#: ../docs/WhatsNew.md:536
msgid ""
"The new `yard server` command spawns a documentation server that can serve\n"
"either documentation for a local project or installed RubyGems. The server\n"
"will host (by default) on http://localhost:8808."
msgstr ""
"新しい`yard server`コマンドは\n"
"ローカルプロジェクトや既存のRubyGems用の全てのドキュメントを提供できる\n"
"ドキュメントサーバーを生みだす。\n"
"サーバーはhttp://localhost:8808のホスト(デフォルトで)になる。"

#: ../docs/WhatsNew.md:540
msgid ""
"To serve documentation for the active project (in the current directory):"
msgstr ""
"アーカイブのプロジェクト用にドキュメントを提供するには、(現在のディレクトリの"
"中の)"

#: ../docs/WhatsNew.md:544
msgid ""
"The server can also run in \"incremental\" mode for local projects. In this\n"
"situation, any modified sources will immediately be updated at each "
"request,\n"
"ensuring that the server always serve the code exactly as it is on disk.\n"
"Documenting your code in this fashion essentially gives you an efficient a\n"
"live preview without running a separate command everytime you make a "
"change.\n"
"To serve documentation for the active project in incremental mode:"
msgstr ""
"サーバーはローカルプロジェクト用の \"incremental\" モードでも起動できる。\n"
"この場合、任意の変更されるソースは個々のリクエストですぐに更新され、\n"
"サーバーが常にディスク上で確実にコードを提供することを保証する。\n"
"基本的にこのやり方であなたののコードのドキュメントは\n"
"毎回あなたが変更するたびに\n"
"区切られたコマンド無しで効率的に動いたままプレビューできる。\n"
"インクリメンタルモードで\n"
"アクティブなプロジェクトのためにドキュメントを提供するには:"

#: ../docs/WhatsNew.md:551
msgid "    $ yard server --reload"
msgstr "    $ yard server --reload"

#: ../docs/WhatsNew.md:553
msgid ""
"<span class=\"note\">Note that in incremental mode, objects or method "
"groupings\n"
"  cannot be removed. If you have removed objects or modified groupings, you\n"
"  will need to flush the cache by deleting `.yardoc` and (optionally)\n"
"  restarting the server.</span>"
msgstr ""
"<span class=\"note\">Note that in incremental mode, objects or method groupings\n"
"  cannot be removed. If you have removed objects or modified groupings, you\n"
"  will need to flush the cache by deleting `.yardoc` and (optionally)\n"
"  restarting the server.</span>"

#: ../docs/WhatsNew.md:558
msgid ""
"The documentation server can also serve documentation for all installed "
"gems\n"
"on your system, similar to `gem server`, but using YARD's functionality and\n"
"templates. To serve documentation for installed gems:"
msgstr ""
"ドキュメントサーバーはあなたのシステムで\n"
"`gem server`と同様にYARDの機能とテンプレートを使う事によって\n"
"既存の全てのgem用のドキュメントも提供できる\n"
"既存のgem用にドキュメントを提供するには:"

#: ../docs/WhatsNew.md:564
msgid ""
"<span class=\"note\">Documentation for the gem need not be previously "
"generated\n"
"  at install-time. If documentation for the gem has not been generated, "
"YARD\n"
"  will do this for you on-the-fly. It is therefore possible to speed up "
"your\n"
"  gem installs by using `gem install GEMNAME --no-rdoc` without "
"repercussion.\n"
"  You can also add this switch to your `~/.gemrc` file so that you don't "
"need\n"
"   to re-type it each time. See [this link](http://stackoverflow.com/"
"questions/1789376/how-do-i-make-no-ri-no-rdoc-the-default-for-gem-install)\n"
"   for exact instructions.</span>"
msgstr ""
"<span class=\"note\">Documentation for the gem need not be previously generated\n"
"  at install-time. If documentation for the gem has not been generated, YARD\n"
"  will do this for you on-the-fly. It is therefore possible to speed up your\n"
"  gem installs by using `gem install GEMNAME --no-rdoc` without repercussion.\n"
"  You can also add this switch to your `~/.gemrc` file so that you don't need\n"
"   to re-type it each time. See [this link](http://stackoverflow.com/questions/1789376/how-do-i-make-no-ri-no-rdoc-the-default-for-gem-install)\n"
"   for exact instructions.</span>"

#: ../docs/WhatsNew.md:572
msgid "## Groups support for method listing (0.6.0)"
msgstr "## メソッドの記述用のサポートをグループ化する (0.6.0)"

#: ../docs/WhatsNew.md:574
msgid ""
"You can now organize methods in a class/module into logical separated "
"groups.\n"
"These groups apply lexically and are listed in the order they are defined.\n"
"For instance, to define a group:"
msgstr ""
"あなたは論理的に分けられたグループへ\n"
"class/moduleの中のメソッドをまとめられるようになった。\n"
"これらのグループは単語的に適用され、\n"
"これらの命令が定義される中で記述される。\n"
"例えばグループを定義するには:"

#: ../docs/WhatsNew.md:578
msgid "    # @group Rendering an Object"
msgstr "    # @group Rendering an Object"

#: ../docs/WhatsNew.md:580
msgid ""
"    # Documentation here\n"
"    def foo; end"
msgstr ""
"    # Documentation here\n"
"    def foo; end"

#: ../docs/WhatsNew.md:583
msgid ""
"    # Extra documentation...\n"
"    def bar; end"
msgstr ""
"    # Extra documentation...\n"
"    def bar; end"

#: ../docs/WhatsNew.md:586
msgid "    # @group Another Group"
msgstr "    # @group Another Group"

#: ../docs/WhatsNew.md:588
msgid "    def aaa; end"
msgstr "    def aaa; end"

#: ../docs/WhatsNew.md:590
msgid ""
"<span class=\"note\">Note that these `@group` and `@endgroup` declarations "
"are\n"
"  not \"tags\" and should always be separated with at least 1 line of "
"whitespace\n"
"  from any other documentation or code.</span>"
msgstr ""
"<span class=\"note\">Note that these `@group` and `@endgroup` declarations are\n"
"  not \"tags\" and should always be separated with at least 1 line of whitespace\n"
"  from any other documentation or code.</span>"

#: ../docs/WhatsNew.md:594
msgid ""
"In the above example, \"Rendering an Object\" will be listed with \"foo\" "
"and\n"
"\"bar\" above \"Another Group\", even though \"aaa\" comes before the two "
"other\n"
"methods, alphabetically. To end a group, use `@endgroup`. It is not "
"necessary\n"
"to end a group to start a new one, only if there is an object following the\n"
"group that should not belong in any group."
msgstr ""
"上の例で \"表示されるオブジェクトは\"\n"
"\"Another Group\" の上の \"foo\" と \"bar\"の\n"
"二つの他のメソッドが前にあるけれども\n"
"実際にはアルファベット順で\"aaa\"が来て記述される。\n"
"グループを終りには`@endgroup`を使う。\n"
"これは新しくグループを作るのにグループを終了する必要はない。\n"
"任意のグループの中に所属すべきではないグループに続くオブジェクトがある場合だけである。"

#: ../docs/WhatsNew.md:600
msgid "    # @group Group 1"
msgstr "    # @group Group 1"

#: ../docs/WhatsNew.md:602
msgid "    def foo; end"
msgstr "    def foo; end"

#: ../docs/WhatsNew.md:604
msgid "    # @endgroup"
msgstr "    # @endgroup"

#: ../docs/WhatsNew.md:606
msgid ""
"    # This method should not be listed in any group\n"
"    def bar; end"
msgstr ""
"    # This method should not be listed in any group\n"
"    def bar; end"

#: ../docs/WhatsNew.md:609
msgid "## Single file template (`--one-file`) support (0.6.0)"
msgstr "## 単一のファイルのテンプレート (`--one-file`)のサポート (0.6.0)"

#: ../docs/WhatsNew.md:611
msgid ""
"`yardoc` now has the `--one-file` option to generate a single-file template\n"
"for small scripts and libraries. In this case, any comments at the top of\n"
"the script file will be recognized as a README."
msgstr ""
"`yardoc`は、小さいスクリプトやライブラリ用の\n"
"単一のファイルのテンプレートを生成する`--one-file`オプションが追加された。\n"
"この場合、任意の内容の\n"
"スクリプトファイルのトップでの任意のコメントは、READMEとして認識される。"

#: ../docs/WhatsNew.md:615
msgid "## `yard` CLI executable with pluggable commands (0.6.0)"
msgstr "## `yard` CLI がプラグイン可能なコマンドとして実行可能になる (0.6.0)"

#: ../docs/WhatsNew.md:617
msgid ""
"<span class=\"note\">The `yardoc` and `yri` commands are not deprecated and "
"can\n"
"  continue to be used. They are shortcuts for `yard doc` and `yard ri`\n"
"  respectively. However, `yard-graph` has been removed.</span>"
msgstr ""
"<span class=\"note\">The `yardoc` and `yri` commands are not deprecated and can\n"
"  continue to be used. They are shortcuts for `yard doc` and `yard ri`\n"
"  respectively. However, `yard-graph` has been removed.</span>"

#: ../docs/WhatsNew.md:621
msgid ""
"YARD now has a `yard` executable which combines all pre-existing and new\n"
"commands into a single pluggable command that is both easier to remember "
"and\n"
"access. To get a list of commands, type `yard --help`."
msgstr ""
"YARDは既存のものと新たなコマンドを一体化し、\n"
"思い出しとアクセスすることを簡単に両立する単一の付け外し自由な\n"
"`yard`コマンドを持つようになった。\n"
"コマンドのリストを取得するには`yard --help`とタイプする。"

#: ../docs/WhatsNew.md:625
msgid ""
"If you are a plugin developer, you can create your own `yard` command by "
"first\n"
"subclassing the {YARD::CLI::Command} class and then registering this class\n"
"with the {YARD::CLI::CommandParser.commands} list. For instance:"
msgstr ""
"あなたがプラグイン開発者なら、\n"
"先に {YARD::CLI::Command} クラスをサブクラス化する事によって`yard`コマンドを\n"
"あなた自身の手によって作成できる。\n"
"その時 {YARD::CLI::CommandParser.commands} のリストを用いこのクラスを登録する。\n"
"例えば:"

#: ../docs/WhatsNew.md:629
msgid "    YARD::CLI::CommandParser.commands[:my_command] = MyCommandClass"
msgstr "    YARD::CLI::CommandParser.commands[:my_command] = MyCommandClass"

#: ../docs/WhatsNew.md:631
msgid ""
"The above line will enable the user to execute `yard my_command [options]`."
msgstr ""
"上の行で、ユーザーが`yard my_command [options]`を実行する事が可能となる。"

#: ../docs/WhatsNew.md:633
msgid "## `yard diff` command to object-diff two versions of a project (0.6.0)"
msgstr ""
"## プロジェクトの二つのバージョンをオブジェクトのdiffするコマンド、`yard "
"diff` (0.6.0)"

#: ../docs/WhatsNew.md:635
msgid ""
"One of the built-in commands that comes with the new `yard` executable is "
"the\n"
"ability to do object-oriented diffing across multiple versions of the same\n"
"project, either by 2 versions of a gem, or 2 working copies. Just like\n"
"regular diffing tells you which lines have been added/removed in a file,\n"
"object diffing allows you to see what classes/methods/modules have been\n"
"added/removed between versions of a codebase."
msgstr ""
"新しく実行可能な`yard`は、\n"
"gemの二つのバージョンや、2つの作業中のコピーのような、\n"
"同じプロジェクトの複数のバージョンに渡ってオブジェクト思考のdiffをする機能で、\n"
"組み込みコマンドの一つである。\n"
"普通のdiffのように、\n"
"ファイルで追加/削除された行が表示される。\n"
"diffのオブジェクトは、\n"
"コードのバージョン間で追加/削除されたクラス/メソッド/モジュールの参照を受け入れる。"

#: ../docs/WhatsNew.md:642
msgid ""
"For an overview of how to use `yard diff`, see [YARD Object Oriented Diffing]"
"(http://gnuu.org/2010/06/26/yard-object-oriented-diffing/)."
msgstr "For an overview of how to use `yard diff`, see [YARD Object Oriented Diffing](http://gnuu.org/2010/06/26/yard-object-oriented-diffing/)."

#: ../docs/WhatsNew.md:644
msgid "## `yard stats` to display statistics and undocumented objects (0.6.0)"
msgstr ""
"## 統計値を表示する`yard stats`とそれを表示しないオブジェクトが追加された "
"(0.6.0)"

#: ../docs/WhatsNew.md:646
msgid "YARD now outputs the following statistics when `yard stats` is run:"
msgstr "YARDは、`yard stats`が起動する時に続く統計値を出力する。(次のように)"

#: ../docs/WhatsNew.md:648
msgid ""
"    Files:         125\n"
"    Modules:        35 (    4 undocumented)\n"
"    Classes:       139 (   29 undocumented)\n"
"    Constants:      53 (   20 undocumented)\n"
"    Methods:       602 (   70 undocumented)\n"
"     85.16% documented"
msgstr ""
"    Files:         125\n"
"    Modules:        35 (    4 undocumented)\n"
"    Classes:       139 (   29 undocumented)\n"
"    Constants:      53 (   20 undocumented)\n"
"    Methods:       602 (   70 undocumented)\n"
"     85.16% documented"

#: ../docs/WhatsNew.md:655
msgid ""
"Note that these statistics are based on what you have set to show in your\n"
"documentation. If you use `@private` tags and/or do not display\n"
"private/protected methods in your documentation, these will not show up as\n"
"undocumented. Therefore this metric is contextual."
msgstr ""
"次の事に留意する。\n"
"これらの統計はあなたのドキュメントの中を調べられた設定が基準となる。\n"
"`@private`タグを使う場合やあなたのドキュメントのなかでprivate/protectedメソッドを\n"
"表示しない場合は、undocumentとしてこれらは表示しない。\n"
"従ってこの計測はコンテキスト次第である。"

#: ../docs/WhatsNew.md:660
msgid ""
"You can also specifically list all undocumented objects (and their file\n"
"locations) with the `--list-undoc` option."
msgstr ""
"あなたは`--list-undoc`オプションを用い\n"
"全ての未記載のオブジェクト(とそのファイルの場所)を明示的に記述できる。"

#: ../docs/WhatsNew.md:663
msgid "## Added `--asset` option to `yardoc` (0.6.0)"
msgstr "## `yardoc`に`--asset`オプションが追加された(0.6.0)"

#: ../docs/WhatsNew.md:665
msgid ""
"The `yardoc` command can now take the `--asset` option to copy over\n"
"files/directories (recursively) to the output path after generating\n"
"documentation. The format of the argument is \"from:to\" where from is the\n"
"source path and to is the destination. For instance, YARD uses the "
"following\n"
"syntax in the `.yardopts` file to copy over image assets from the\n"
"'docs/images' directory into the 'images' directory after generating HTML:"
msgstr ""
"`yardoc`コマンドは、\n"
"ドキュメント生成の後で出力するパスに\n"
"files/directories(再帰的に)全域をコピーするための\n"
"`--asset`オプションが追加された。\n"
"引数のフォーマットは\n"
"fromがソースパスでtoが目的になる場所、\n"
"形式は\"from:to\"となる。\n"
"例えば、HTML生成の後で、\n"
"'images'ディレクトリの中へ\n"
"'docs/images'ディレクトリからイメージの資産全部をコピーするために\n"
"`.yardopts`ファイルの中に次の構文を使う:"

#: ../docs/WhatsNew.md:672
msgid "    --asset docs/images:images"
msgstr "    --asset docs/images:images"

#: ../docs/WhatsNew.md:674
msgid "## New template API (0.6.0)"
msgstr "## 新しくなったテンプレートAPI (0.6.0)"

#: ../docs/WhatsNew.md:676
msgid ""
"The new template API allows for easier insertion of sections within an\n"
"inherited template. You should no longer need to insert by index, an\n"
"error-prone process that could break when a template is updated. Instead of:"
msgstr ""
"新たなテンプレートAPIは\n"
"継承されたテンプレートの中のセクションの簡単な挿入用に許可する。\n"
"あなたはもはやindexで挿入する必要はない、\n"
"エラー傾向は\n"
"テンプレートが更新される時に中断され処理する。\n"
"代わりに:"

#: ../docs/WhatsNew.md:680
msgid "    sections.last.place(:my_section).before(:another_section)"
msgstr "    sections.last.place(:my_section).before(:another_section)"

#: ../docs/WhatsNew.md:682
msgid "use:"
msgstr "use:"

#: ../docs/WhatsNew.md:684
msgid "    sections.place(:my_section).before_any(:another_section)"
msgstr "    sections.place(:my_section).before_any(:another_section)"

#: ../docs/WhatsNew.md:686
msgid ""
"You can see more in the {file:docs/Templates."
"md#Inserting_and_Traversing_Sections}\n"
"document."
msgstr ""
"あなたは{file:docs/Templates.md#Inserting_and_Traversing_Sections}ドキュメン"
"トで、\n"
"更に詳細を見る事が出来る。"

#: ../docs/WhatsNew.md:689
msgid ""
"## HTML template now adds inline Table of Contents for extra files pages "
"(0.6.0)"
msgstr ""
"## HTML テンプレートは追加のファイルのページ用に、\n"
"その内容のインラインテーブルが追加された(0.6.0)"

#: ../docs/WhatsNew.md:691
msgid ""
"A table of contents is now generated dynamically using JavaScript for extra\n"
"file pages (such as README's, or this document). It is generated based off "
"the\n"
"headers (h1,h2,... tags) used in the document, and can be floated to the\n"
"right or listed inline on the page."
msgstr ""
"コンテンツのテーブルは追加のファイルのページ用に、\n"
"JavaScriptによって動的に生成されるようになった(READMEやこのドキュメントのように)。\n"
"これは、ドキュメントで利用されたヘッダー(h1,h2,... tags)がのぞかれた\n"
"ベースを生成し右側に添えられるか、又は、ページ上でインラインが記述される。"

#: ../docs/WhatsNew.md:696
msgid "## Ad-hoc tag registration via `yardoc` CLI (`--tag`, etc.) (0.6.0)"
msgstr "## `yardoc`CLI(`--tag`, etc.)経由での臨時のタグの記録 (0.6.0)"

#: ../docs/WhatsNew.md:698
msgid ""
"Simple meta-data tags can now be added at the command-line and registered "
"to\n"
"display in templates in a number of pre-defined ways. For instance, to "
"create\n"
"a freeform text tag, use the following:"
msgstr ""
"単純なメタデータタグは\n"
"コマンドラインで追加され、事前に定義されたいくつか方法で\n"
"テンプレートの中で表示されるために登録されるようになった。\n"
"例えばフリーフォームテキストのタグを作成するには、次のようになる:"

#: ../docs/WhatsNew.md:702
msgid "    --tag my_tag_name:\"My Tag Title\""
msgstr "    --tag my_tag_name:\"My Tag Title\""

#: ../docs/WhatsNew.md:704
msgid ""
"You can also create a \"typed\" tag (similar to `@return`), a typed named "
"tag\n"
"(similar to `@param`) as well as various combinations. The full list of\n"
"options are listed in `yardoc --help` under the \"Tag Options\" section."
msgstr ""
"あなたは\"型\"のタグ(`@return`と同様に)も\n"
"型のタグ名(`@param`と同様に)も様々な組み合わせもを作成する事もできる。\n"
"オプションの完全なリストは\n"
"`yardoc --help`の \"Tag Options\" のセクションよりで記述される。"

#: ../docs/WhatsNew.md:708
msgid ""
"If you wish to create a tag to store data but do not wish to show this data\n"
"in the templates, use the `--hide-tag` option to hide it from generated "
"output:"
msgstr ""
"あなたがデータを登録するためにタグを作成することを望むが、\n"
"テンプレートの中のこのデータを一覧したくない場合、\n"
"生成された出力からそれを隠すには`--hide-tag`オプションを使う。\n"
"\n"

#: ../docs/WhatsNew.md:711
msgid "    --hide-tag my_tag_name"
msgstr "    --hide-tag my_tag_name"

#: ../docs/WhatsNew.md:713
msgid "## Added `--transitive-tags` to register transitive tags (0.6.0)"
msgstr "## 過渡的なタグを記録するのに、`--transitive-tags`を追加された (0.6.0)"

#: ../docs/WhatsNew.md:715
msgid ""
"Transitive tags are tags that apply to all descendants of a namespace "
"(class\n"
"or module) when documented on that namespace. For instance, the `@since` "
"tag\n"
"is a transitive tag. Applying `@since` to a class will automatically apply\n"
"`@since` to all methods in the class. Creating a `@since` tag directly on a\n"
"method will override the inherited value."
msgstr ""
"transitiveタグは、namespace上(クラス又はモジュール)で記述された時、\n"
"全てのnamespaceの子孫に適用するタグである。\n"
"例えば、`@since`タグはTransitiveタグである。\n"
"クラスに`@since`タグを適用すると、\n"
"クラスの中の全てのメソッドに自動的に`@since`が適用される\n"
"メソッドで直接`@since`タグを作成すると継承された値をオーバーライドする。"

#: ../docs/WhatsNew.md:721
msgid ""
"You can specify transitive tags on the command-line by using this option. "
"Note\n"
"that the tags must already exist (built-in or created with the `--tag` "
"option)\n"
"to be specified as transitive. If you wish to do this programmatically, see\n"
"the {YARD::Tags::Library.transitive_tags} attribute."
msgstr ""
"このオプションによって\n"
"コマンドラインのタグを過渡的に指定できる\n"
"transitiveとして指定される\n"
"タグは既に存在しなければならない。\n"
"(組み込みや`--tag`オプションによって作成された)\n"
"あなたがこのプログラムを実行したいなら、 {YARD::Tags::Library.transitive_tags} 属性を参照する。"

#: ../docs/WhatsNew.md:726
msgid ""
"## `yardoc` now displays RDoc-like statistics (`--no-stats` to hide) (0.6.0)"
msgstr ""
"## `yardoc`は、RDocのような統計値の表示するようになった。(`--no-stats`で隠"
"す) (0.6.0)"

#: ../docs/WhatsNew.md:728
msgid ""
"As seen in the `yard stats` feature overview, `yardoc` displays RDoc-like\n"
"statistics when it is run. The output is equivalent to typing `yard stats`.\n"
"To hide this output when yardoc is run, use `--no-stats`."
msgstr ""
"上記のように`yard stats`機能の概要は\n"
"`yardoc`が起動する時にRDocのように統計を表示する\n"
"出力は`yard stats`をタイプするのと同様である。\n"
"yardocが起動する時にこの出力を隠すには、\n"
"`--no-stats`を使う"

#: ../docs/WhatsNew.md:732
msgid "## `yri` now works on constants (0.6.0)"
msgstr "## `yri`定数の処理をできるようになった (0.6.0)"

#: ../docs/WhatsNew.md:734
msgid ""
"Templates have now been added for text view of constants, which displays "
"any\n"
"documentation and the constant value."
msgstr ""
"テンプレートは定数の一覧を作成するため追加されるようになった。\n"
"これは任意のドキュメントと定数を表示する。"

#: ../docs/WhatsNew.md:737
msgid "## Plugins are no longer auto-loaded (added `--plugin` switch) (0.6.2)"
msgstr ""
"## プラグインは自動でロードされなくなった。(`--plugin`引数で追加できる) "
"(0.6.2)"

#: ../docs/WhatsNew.md:739
msgid ""
"This is a backwards-incompatible change that disables plugins from "
"automatically\n"
"loading when YARD starts up. From now on, you should manually declare which\n"
"plugins your project is using by adding `--plugin PLUGINNAME` to a `."
"yardopts`\n"
"file in the root of your project. You can also re-enable autoloaded plugins\n"
"by setting `load_plugins` to true in your configuration file (`yard config "
"load_plugins true`,\n"
"see next item). You can also set `autoload_plugins` to a list of plugins\n"
"to be automatically loaded on start."
msgstr ""
"これはYARDのスタートアップする時の自動的なロードから\n"
"プラグインを無効化する非後方互換な変更である。\n"
"今後はあなたは手動で宣言しなければならない、\n"
"それはあなたのプロジェクトのプラグインが\n"
"あなたのプロジェクトのrootで`.yardopts`ファイルに\n"
"`--plugin PLUGINNAME`を追加することによって利用される。\n"
"あなたの設定ファイルの中で`load_plugins`をtrueに設定する事によって\n"
"自動でロードされるプラグインを再度有効にできる。\n"
"(`yard config load_plugins true`, 事項参照)\n"
"あなたは、起動時に自動的にロードする為にプラグインのリストに\n"
"`autoload_plugins`に設定する事も出来る。"

#: ../docs/WhatsNew.md:747
msgid ""
"If you are a YARD plugin author, please make sure to inform your users of "
"these\n"
"changes."
msgstr ""
"あなたがYARDプラグインの作者の場合、\n"
"これらの変更をあなたのユーザーに通知するか確認してください。"

#: ../docs/WhatsNew.md:750
msgid ""
"Note that `--plugin` switches passed on the commandline (not via `."
"yardopts`)\n"
"are parsed before commands are loaded, and therefore can add in new CLI "
"commands."
msgstr ""
"次のことに留意する。\n"
"コマンドライン(`.yardopts`経由ではない)で渡された--pulugin引数はコマンドがロードされる前に解析され、\n"
"その結果、新しいCLIコマンドの中で追加できる。"

#: ../docs/WhatsNew.md:753
msgid ""
"## Added `YARD::Config` API and `~/.yard/config` configuration file (0.6.2)"
msgstr ""
"## `YARD::Config` APIと`~/.yard/config`設定ファイルが追加された。 (0.6.2)"

#: ../docs/WhatsNew.md:755
msgid ""
"There is a new global configuration API that can be accessed "
"programmatically\n"
"and set via the `~/.yard/config` file. The file is encoded as a YAML file,\n"
"and looks like:"
msgstr ""
"これらは、プログラムにアクセスできる新しいグローバル設定APIとなり、\n"
"`~/.yard/config`ファイル経由で設定される。\n"
"ファイルはYAMLファイルとしてエンコードされる、次のようになる"

#: ../docs/WhatsNew.md:767
msgid ""
"You can also set configuration options via the command-line (see next item)."
msgstr "あなたは、コマンドライン経由で設定オプションを設定できる。(次項参照)"

#: ../docs/WhatsNew.md:769
msgid "## Added `yard config` command to view/edit configuration (0.6.2)"
msgstr "## 設定を一覧/編集する為に`yard config` コマンドが追加された (0.6.2)"

#: ../docs/WhatsNew.md:771
msgid ""
"A new `yard config` command was created to view or edit the configuration\n"
"file via the commandline."
msgstr ""
"新しい`yard config`コマンドが、\n"
"コマンドライン経由で設定ファイルを一覧・編集する為に作成された。"

#: ../docs/WhatsNew.md:774
msgid ""
"* To view the current configuration use `yard config --list`.\n"
"* To view a specific item use `yard config ITEMNAME`\n"
"* To modify an item value use `yard config ITEMNAME VALUE`"
msgstr ""
"* 現在の設定を一覧するには、`yard config --list`を使う\n"
"* 特定の項目(item)を一覧するには、`yard config ITEMNAME`を使う\n"
"* 項目の値を変更するには、`yard config ITEMNAME VALUE`を使う"

#: ../docs/WhatsNew.md:778
msgid "## Added `yard server -t` template path switch (0.6.2)"
msgstr "## `yard server -t`テンプレートパス引数が追加された (0.6.2)"

#: ../docs/WhatsNew.md:780
msgid ""
"The `yard server` command now accepts `-t` or `--template-path` to register\n"
"a new template path for template customization."
msgstr ""
"`yard server` コマンドは、\n"
"テンプレートをカスタマイズする為に新しいテンプレートパスを記録する為、\n"
"`-t`、又は、`--template-path`を受け入れる。"

#: ../docs/WhatsNew.md:783
msgid ""
"## Added `YARD::Server.register_static_path` for static server assets (0.6.2)"
msgstr ""
"## 静的なサーバー資源用に`YARD::Sever.register_static_path`が追加された。 "
"(0.6.2)"

#: ../docs/WhatsNew.md:785
msgid ""
"The server now supports a command to register static asset paths. If you "
"are\n"
"extending the YARD::Server modules, make sure to register your asset paths\n"
"through this method."
msgstr ""
"サーバーは静的な資源のパスを記録する為のコマンドをサポートするようになっ"
"た。\n"
"あなたが、YARD::Serverモジュールを拡張する場合は、\n"
"このメソッドを通してあなたの資源のパスを記録するか確認してください。"

#: ../docs/WhatsNew.md:789
msgid "## YARD::Registry is now thread local (0.6.5)"
msgstr "## YARD::Registryはスレッドローカルとなった (0.6.5)"

#: ../docs/WhatsNew.md:791
msgid ""
"Creating a new thread will now implicitly load a new Registry that can be "
"used\n"
"to parse and process new code objects independently of the other threads. "
"Note\n"
"that this means you can no longer use the Registry across threads; you must\n"
"either access the threadlocal object directly, or synchronize threads to do\n"
"the processing in the initial registry's thread."
msgstr ""
"新しいスレッドの作成は暗黙の内に、\n"
"解析する為に利用できる新しいレジストリーをロードするだろう。\n"
"そして、他のスレッドとは独自に新しいコードオブジェクトを処理する。\n"
"次の事に留意する。\n"
"これはあなたがもう、スレッドを渡ってレジストリーを利用する必要はないことを意味する。\n"
"あなたは、スレッドのローカルオブジェクトに直接アクセスするか、又は、\n"
"スレッドのレジストリーの初期化の処理をする為にスレッドを同期しなければならない。"

#: ../docs/WhatsNew.md:797
msgid "## Support for ripper gem in Ruby 1.8.7 (0.6.5)"
msgstr "## Ruby 1.8.7 でのripper gemのサポート (0.6.5)"

#: ../docs/WhatsNew.md:799
msgid ""
"YARD now supports the Ruby 1.8.7 port of the `ripper` gem to improve "
"parsing\n"
"of source, both in terms of performance and functionality. When the "
"`ripper`\n"
"gem is available, YARD will use the \"new-style\" handlers. You can take "
"advantage\n"
"of this functionality by performing a `gem install ripper`."
msgstr ""
"パフォーマンスと機能性の両面で、\n"
"YARDはソースの解析を向上する為に`ripper`gemのRuby1.8.7の一部をサポートするよ"
"うになった。\n"
"`ripper`gemが実行可能な時、YARDは\"new-style\"のハンドラーを利用する。\n"
"`gem install ripper`を実行する事で、この機能の恩恵を受ける事ができる。"

#: ../docs/WhatsNew.md:805
msgid ""
"What's New in 0.5.x?\n"
"===================="
msgstr ""
"What's New in 0.5.x?\n"
"===================="

#: ../docs/WhatsNew.md:808
msgid ""
"1. **Support for documenting native Ruby C code** (0.5.0)\n"
"2. **Incremental parsing and output generation with `yardoc -c`** (0.5.0, "
"0.5.3)\n"
"2. **Improved `yri` support to perform lookups on installed Gems** (0.5.0)\n"
"3. **Added `yardoc --default-return` and `yardoc --hide-void-return`** "
"(0.5.0)\n"
"4. **Multiple syntax highlighting language support** (0.5.0)\n"
"5. **New .yardoc format** (0.5.0)\n"
"6. **Support for yard-doc-* gem packages as hosted .yardoc dbs** (0.5.1)\n"
"7. **Support for extra search paths in `yri`** (0.5.1)\n"
"8. **Generating HTML docs now adds frames view** (0.5.3)\n"
"9. **Tree view for class list** (0.5.3)\n"
"10. **Ability to specify markup format of extra files** (0.5.3)\n"
"11. **Keyboard shortcuts for default HTML template** (0.5.4)"
msgstr ""
"1. **RubyとCのコードのドキュメント化をサポートする** (0.5.0)\n"
"2. **`yaradoc -c`を用いたインクリメンタルな解析と出力生成ができるようになった"
"** (0.5.0, 0.5.3)\n"
"3. **`yardoc --default-return`と`yardoc --hide-void-return`が追加された** "
"(0.5.0)\n"
"4. **複数の構文のハイライトする言語をサポート** (0.5.0)\n"
"5. **新しい.yardocフォーマット** (0.5.0)\n"
"6. **ホストされた.yardoc dbsとしてyard-doc-* gem パッケージをサポートする** "
"(0.5.1)\n"
"7. **`yri`で追加の検索パスをサポートする** (0.5.1)\n"
"8. **HTMLドキュメントの生成はフレーム一覧が追加されるようになった** (0.5.3)\n"
"9. **クラスリスト用のツリービュー** (0.5.3)\n"
"10. **追加のファイルのマークアップフォーマットを指定する機能** (0.5.3)\n"
"11. **デフォルトのHTMLテンプレート用のキーボードショートカット** (0.5.4)"

#: ../docs/WhatsNew.md:821
msgid ""
"Support for documenting native Ruby C code (0.5.0)\n"
"--------------------------------------------------"
msgstr ""
"RubyとCのコードのドキュメント生成のサポート (0.5.0)\n"
"--------------------------------------------------"

#: ../docs/WhatsNew.md:824
msgid ""
"It is now possible to document native Ruby extensions with YARD with a new\n"
"C parser mostly borrowed from RDoc. This enables the ability to document\n"
"Ruby's core and stdlibs which will be hosted on http://yardoc.org/docs. In\n"
"addition, the .yardoc dump for the Ruby-core classes will become available\n"
"as an installable gem for yri support (see #3)."
msgstr ""
"大部分をRDocから取り入れた新しいCパーサーと共にYARDを用い\n"
"Rubyの拡張ドキュメントを実行可能になった。\n"
"これは、Rubyのコアと標準ライブラリを記述する事を可能にする。\n"
"そして、http://yardoc.org/docs でホスト(アクセスできる)されるだろう。\n"
"さらに、Rubyコアクラス用の.yardocのダンプは、\n"
"yriのサポートに用いるインストール可能なgemとして利用可能になるだろう。(#3 参"
"照)"

#: ../docs/WhatsNew.md:830
msgid ""
"Incremental parsing and output generation with `yardoc -c` (0.5.0, 0.5.3)\n"
"-------------------------------------------------------------------------"
msgstr ""
"`yaradoc -c`を用いたインクリメンタルな解析と出力生成 (0.5.0, 0.5.3)\n"
"-------------------------------------------------------------------------"

#: ../docs/WhatsNew.md:833
msgid ""
"<p class=\"note\">Note: in 0.5.3 and above you must use <tt>--incremental</"
"tt>\n"
"  to incrementally generate HTML, otherwise only parsing will be done\n"
"  incrementally but HTML will be generated with all objects. <tt>--"
"incremental</tt>\n"
"  implies <tt>-c</tt>, so no need to specify them both.</p>"
msgstr ""
"<p class=\"note\">Note: in 0.5.3 and above you must use <tt>--incremental</tt>\n"
"  to incrementally generate HTML, otherwise only parsing will be done\n"
"  incrementally but HTML will be generated with all objects. <tt>--incremental</tt>\n"
"  implies <tt>-c</tt>, so no need to specify them both.</p>"

#: ../docs/WhatsNew.md:838
msgid ""
"YARD now compares file checksums before parsing when using `yardoc -c`\n"
"(aka `yardoc --use-cache`) to do incremental parsing of only the files that\n"
"have changed. HTML (or other output format) generation will also only be\n"
"done on the objects that were parsed from changed files (\\*). This makes "
"doing\n"
"a documentation development cycle much faster for quick HTML previews. Just\n"
"remember that when using incremental output generation, the index will not\n"
"be rebuilt and inter-file links might not hook up right, so it is best to\n"
"perform a full rebuild at the end of such previews."
msgstr ""
"YARDはインクリメンタルに変更されたファイルだけ解析をする為に、\n"
"`yardoc -c`(別名 `yardoc --use-cache`)を使う時、解析前のファイルを比較す"
"る。\n"
"HTML(又は、他の出力フォーマット)生成は、\n"
"変更されたファイル(\\*)から解析されるオブジェクト上で実行されるだけである。\n"
"これにより迅速なHTMLプレビューの為に、より速い開発サイクルを作りあげる事がで"
"きる。\n"
"ただインクリメンタルな出力生成によって覚えておいてほしいことは、\n"
"インデックスが再構築されない事とファイル間のリンクが正しく接続されないかもし"
"れない、\n"
"なので、このようなプレビューの終了時に完全な再構築を実行することをお勧めしま"
"す。"

#: ../docs/WhatsNew.md:847
msgid ""
"(\\*) Only for versions prior to 0.5.3. For 0.5.3+, use `--incremental` for\n"
"incremental HTML output."
msgstr ""
"(\\*) 0.5.3より前のバージョンのみ、0.5.3以上の場合は、\n"
"インクリメンタルHTML出力用の`--incremental`を使う。"

#: ../docs/WhatsNew.md:850
msgid ""
"Improved `yri` support to perform lookups on installed Gems (0.5.0)\n"
"-------------------------------------------------------------------"
msgstr ""
"インストールされたgemを検索する為の`yri`のサポートが改良された。(0.5.0)\n"
"-------------------------------------------------------------------"

#: ../docs/WhatsNew.md:853
msgid ""
"The `yri` executable can now perform lookups on gems that have been parsed\n"
"by yard. Therefore, to use this command you must first parse all gems with\n"
"YARD. To parse all gems, use the following command:"
msgstr ""
"実行可能な`yri`コマンドは、YARDで解析されていたgemの検索を実行できるように"
"なった。\n"
"したがって、このコマンドを使う為には、\n"
"あなたは、最初に全てのgemをYARDで解析しなければならない。\n"
"全てのgemを解析する為には、次のコマンドを利用する:"

#: ../docs/WhatsNew.md:857
msgid "    $ sudo yardoc --build-gems"
msgstr "    $ sudo yardoc --build-gems"

#: ../docs/WhatsNew.md:859
msgid ""
"The above command builds a .yardoc file for all installed gems in the\n"
"respective gem directory. If you do not have write access to the gem path,\n"
"YARD will write the yardoc file to `~/.yard/gem_index/NAME-VERSION.yardoc`."
msgstr ""
"上のコマンドは、gemディレクトリに関係する全てのインストール済みのgem用に."
"yardocファイルをビルドする。\n"
"あなたが、gemのパスへのアクセスを書き込んでいない場合、\n"
"YARDは`~/.yard/gem_index/NAME-VERSION.yardoc`にyardocファイルを書き込むだろ"
"う。"

#: ../docs/WhatsNew.md:863
msgid ""
"Note: you can also use `--re-build-gems` to force re-parsing of all gems."
msgstr ""
"注意:あなたは、全てのgemめ強制的に再解析するのに、`--re-build-gems`を使うこと"
"もできる。"

#: ../docs/WhatsNew.md:865
msgid "You can now do lookups with yri:"
msgstr "あなたは、下のようにyriで検索できるようになった"

#: ../docs/WhatsNew.md:867
msgid "    $ yri JSON"
msgstr "    $ yri JSON"

#: ../docs/WhatsNew.md:869
msgid ""
"All lookups are cached to `~/.yard/yri_cache` for quicker lookups the "
"second\n"
"time onward."
msgstr ""
"全ての検索は、２度目の検索をより早くする為に、\n"
"`~/.yard/yri_cache`にキャッシュされる。"

#: ../docs/WhatsNew.md:872
msgid ""
"Added `yardoc --default-return` and `yardoc --hide-void-return` (0.5.0)\n"
"-----------------------------------------------------------------------"
msgstr ""
"`yardoc --default-return`と`yardoc --hide-void-return`が追加された (0.5.0)\n"
"-----------------------------------------------------------------------"

#: ../docs/WhatsNew.md:875
msgid ""
"YARD defaults to displaying (Object) as the default return type of any\n"
"method that has not declared a @return tag. To customize the default\n"
"return type, you can specify:"
msgstr ""
"YARDは@returnタグで宣言されなかった、\n"
"任意のデフォルトのメソッドの型を返し表示する事をデフォルトにする。\n"
"デフォルトの返す型をカスタマイズするには、以下のように指定する:"

#: ../docs/WhatsNew.md:879
msgid "    $ yardoc --default-return 'MyDefaultType'"
msgstr "    $ yardoc --default-return 'MyDefaultType'"

#: ../docs/WhatsNew.md:881
msgid "You can also use the empty string to list no return type."
msgstr "あなたは、返す型が無いのを記述するのに、空の文字列を利用できる。"

#: ../docs/WhatsNew.md:883
msgid ""
"In addition, you can use --hide-void-return to ignore any method that\n"
"defines itself as a void type by: `@return [void]`"
msgstr ""
"さらに、あなたは、`@return [void]`でそれ自身をvoidの型として定義する\n"
"任意のメソッドに--hide-void-returnを利用できる。"

#: ../docs/WhatsNew.md:886
msgid ""
"Multiple syntax highlighting language support (0.5.0)\n"
"-----------------------------------------------------"
msgstr ""
"複数の構文ハイライト用の言語サポート (0.5.0)\n"
"-----------------------------------------------------"

#: ../docs/WhatsNew.md:889
msgid ""
"YARD now supports the ability to specify a language type for code blocks in\n"
"docstrings. Although no actual highlighting support is added for any "
"language\n"
"but Ruby, you can add your own support by writing your own helper method:"
msgstr ""
"YARDはdocstringの中のコードブロック用に、\n"
"言語の型を指定する機能をサポートするようになった。\n"
"実際のハイライトサポートは、全ての言語に追加されているわけではないが\n"
"Rubyは、あなた自身がhelperメソッドを書くことによってサポートを追加する事ができる。"

#: ../docs/WhatsNew.md:893
msgid ""
"    # Where LANGNAME is the language:\n"
"    def html_syntax_highlight_LANGNAME(source)\n"
"      # return highlighted HTML\n"
"    end"
msgstr ""
"    # LANGNAMEがlanguageの場所:\n"
"    def html_syntax_highlight_LANGNAME(source)\n"
"      # ハイライトされたHTMLを返す\n"
"    end"

#: ../docs/WhatsNew.md:898
msgid ""
"To use this language in code blocks, prefix the block with `!!!LANGNAME`:"
msgstr ""
"コードブロックでこの言語を利用するには、次のように`!!!LANGNAME`を用い前に置"
"く。"

#: ../docs/WhatsNew.md:900
msgid ""
"    !!!plain\n"
"    !!!python\n"
"    def python_code(self):\n"
"      return self"
msgstr ""
"    !!!plain\n"
"    !!!python\n"
"    def python_code(self):\n"
"      return self"

#: ../docs/WhatsNew.md:905
msgid ""
"By the same token. you can now use `!!!plain` to ignore highlighting for\n"
"a specific code block."
msgstr ""
"同じトークンで、\n"
"あなたは特定のコードブロック用のハイライトを無視する為に`!!!plain`が利用でき"
"るようになった。"

#: ../docs/WhatsNew.md:908
msgid ""
"New .yardoc format (0.5.0)\n"
"--------------------------"
msgstr ""
"新しい.yardocフォーマット (0.5.0)\n"
"--------------------------"

#: ../docs/WhatsNew.md:911
msgid ""
"To make the above yri support possible, the .yardoc format was redesigned\n"
"to be a directory instead of a file. YARD can still load old .yardoc files,\n"
"but they will be automatically upgraded if re-saved. The new .yardoc format\n"
"does have a larger memory footprint, but this will hopefully be optimized\n"
"downward."
msgstr ""
"上のyriサポートを可能にする為に、\n"
".yardocフォーマットはファイルの代わりにディレクトリに記録される事になった。\n"
"YARDは尚、古い.yardocファイルをロードできるが、\n"
"しかし、それは、再セーブした場合、自動的に上書きされるだろう。\n"
"新しい.yaradocフォーマットは、より大きいメモリ足跡をもっているが\n"
"しかしこれは、恐らく下方修正されるだろう。"

#: ../docs/WhatsNew.md:917
msgid ""
"Support for yard-doc-* gem packages as hosted .yardoc dbs (0.5.1)\n"
"-----------------------------------------------------------------"
msgstr ""
".yardoc dbs でホストされたyard-doc-* gem パッケージ用のサポート\n"
"-----------------------------------------------------------------"

#: ../docs/WhatsNew.md:920
msgid ""
"You can now install special YARD plugin gems titled yard-doc-NAME to get\n"
"packaged a .yardoc database. This will enable yri lookups or building docs\n"
"for the gem without the code."
msgstr ""
"あなたは、パッケージされた.yardocデータベースを取得する為に\n"
"yard-doc-NAMEと名付けられた特殊なYARDプラグインのgemをインストールできるよう"
"になった。\n"
"これは、コード無しでgem用のdocstringをyriで検索、又は、ビルドを可能にするだろ"
"う。"

#: ../docs/WhatsNew.md:924
msgid ""
"One main use for this is the `yard-doc-core` package, which enabled yri\n"
"support for Ruby core classes (stdlib coming soon as `yard-doc-stdlib`).\n"
"To install it, simply:"
msgstr ""
"これの主なものとしては、`yard-doc-core`パッケージである。\n"
"これはRubyのコアクラス用のyriサポートを有効化する\n"
"(標準ライブラリは`yard-doc-stdlib`として近日登場予定)\n"
"簡単にインストールするには:"

#: ../docs/WhatsNew.md:928
msgid ""
"    $ sudo gem install yard-doc-core\n"
"    # now you can use:\n"
"    $ yri String"
msgstr ""
"    $ sudo gem install yard-doc-core\n"
"    # あなたは次のコマンドを使えるようになった:\n"
"    $ yri String"

#: ../docs/WhatsNew.md:932
msgid ""
"This will by default install the 1.9.1 core library. To install a library\n"
"for a specific version of Ruby, use the `--version` switch on gem:"
msgstr ""
"これは、1.9.1のコアライブラリをデフォルトでインストールする。\n"
"Rubyの固有のバージョンのライブラリをインストールするには、\n"
"次のように、gemで`--version`引数を利用する:"

#: ../docs/WhatsNew.md:935
msgid "    $ sudo gem install --version '= 1.8.6' yard-doc-core"
msgstr "    $ sudo gem install --version '= 1.8.6' yard-doc-core"

#: ../docs/WhatsNew.md:937
msgid ""
"Support for extra search paths in `yri` (0.5.1)\n"
"-----------------------------------------------"
msgstr ""
"`yri`で追加の検索パスをサポートされた (0.5.1)\n"
"-----------------------------------------------"

#: ../docs/WhatsNew.md:940
msgid ""
"You can now add custom paths to non-gem .yardoc files\n"
"by adding them as newline separated paths in `~/.yard/yri_search_paths`."
msgstr ""
"あなたは`~/.yard/yri_search_paths`の中に\n"
"改行に区切られたパスとして追加する事によって\n"
"gem無しの.yardocファイルに\n"
"カスタムパスを追加できるようになった。"

#: ../docs/WhatsNew.md:943
msgid ""
"Generating HTML docs now adds frames view (0.5.3)\n"
"-------------------------------------------------"
msgstr ""
"HTMLのdocstringを生成するとフレームの一覧が追加されるようになった (0.5.3)\n"
"-------------------------------------------------"

#: ../docs/WhatsNew.md:946
msgid ""
"`yardoc` will now create a `frames.html` file when generating HTML "
"documents\n"
"which allows the user to view documentation inside frames, for those users "
"who\n"
"still find frames beneficial."
msgstr ""
"`yardoc`はHTMLドキュメントを生成する時、\n"
"`frames.html`ファイルを作成できるようになった。\n"
"これは、フレームで探すのが便利だとするユーザーの為に、\n"
"フレーム内のドキュメントを一覧する為にユーザーを受け入れる。"

#: ../docs/WhatsNew.md:950
msgid ""
"Tree view for class list (0.5.3)\n"
"--------------------------------"
msgstr ""
"クラスリスト用のツリー 一覧 (0.5.3)\n"
"--------------------------------"

#: ../docs/WhatsNew.md:953
msgid ""
"The class list now displays as an expandable tree view to better organized "
"an\n"
"otherwise cluttered namespace. If you properly namespace your less "
"important\n"
"classes (like Rails timezone classes), they will not take up space in the\n"
"class list unless the user looks for them."
msgstr ""
"クラスリストは別の乱雑なnamespaceをより体型化する為に\n"
"拡張可能なツリー 一覧を表示できるようになった。\n"
"あなたが重要でないクラスをnamespaceにした場合、\n"
"(Railsのtimezome classのような)\n"
"それら(重要でないクラス)は、ユーザーが検索しなければ、\n"
"クラスリストのスペースを専有しない。"

#: ../docs/WhatsNew.md:958
msgid ""
"Ability to specify markup format of extra files (0.5.3)\n"
"-------------------------------------------------------"
msgstr ""
"追加のファイルのマークアップフォーマットを指定する為の機能 (0.5.3)\n"
"-------------------------------------------------------"

#: ../docs/WhatsNew.md:961
msgid ""
"You can now specify the markup format of an extra file (like README) at the\n"
"top of the file with a shebang-like line:"
msgstr ""
"あなたは、次のshebangのような行を用いファイルのトップで\n"
"追加のファイルの(READMEのような)固有のマークアップフォーマットを指定できるよ"
"うになった。"

#: ../docs/WhatsNew.md:964
msgid ""
"    #!textile\n"
"    contents here"
msgstr ""
"    #!textile\n"
"    contents here"

#: ../docs/WhatsNew.md:967
msgid ""
"The above file contents will be rendered with a textile markup engine\n"
"(eg. RedCloth)."
msgstr "上のファイルの内容は、textileマークアップエンジンで表示される(つまりRedCloth)。"

#: ../docs/WhatsNew.md:970
msgid ""
"Keyboard shortcuts for default HTML template (0.5.4)\n"
"----------------------------------------------------"
msgstr ""
"Keyboard shortcuts for default HTML template (0.5.4)\n"
"----------------------------------------------------"

#: ../docs/WhatsNew.md:973
msgid ""
"You can now access the \"Class List\", \"Method List\" and \"File List\" "
"with the\n"
"'c', 'm' and 'f' keyboard shortcuts in the default HTML template, allowing\n"
"for keyboard-only navigation around YARD documentation."
msgstr ""
"あなたは、\n"
"デフォルトのHTMLテンプレートで'c', 'm', 'f'のキーボードショートカットを用"
"い、\n"
"\"Class List\",\"Method List\",\"File List\"にアクセスできるようになった。\n"
"これは、YARDドキュメントの周りのキーボードだけのナビゲーションを受入れる。"

#: ../docs/WhatsNew.md:977
msgid ""
"API for registering custom parsers (0.5.6)\n"
"------------------------------------------"
msgstr ""
"カスタムパーサーの記録用API (0.5.6)\n"
"------------------------------------------"

#: ../docs/WhatsNew.md:980
msgid ""
"You can now register parsers for custom source languages by calling the\n"
"following method:"
msgstr ""
"あなたは、次のメソッドの様に呼び出される事で、\n"
"カスタムソース言語用のパーサーを記録できるようになった。"

#: ../docs/WhatsNew.md:983
msgid "    SourceParser.register_parser_type(:java, MyJavaParser, 'java')"
msgstr "    SourceParser.register_parser_type(:java, MyJavaParser, 'java')"

#: ../docs/WhatsNew.md:985
msgid ""
"The parser class MyJavaParser should be a subclass of {YARD::Parser::Base},\n"
"and the last argument is a set of extensions (string, array or regexp). You\n"
"can read more about registering parsers at the {YARD::Parser::SourceParser}\n"
"class documentation."
msgstr ""
"パーサークラスMyJavaParserは、{YARD::Parser::Base}のサブクラスになり、\n"
"最後の引数は、拡張のグループ(string, array or regexp)になる。\n"
"{YARD::Parser::SourceParser} クラスのドキュメントでパーサーを記録する方法につ"
"いて、\n"
"詳細を見る事が出来る。"

#: ../docs/WhatsNew.md:991
msgid ""
"What's New in 0.4.x?\n"
"===================="
msgstr ""
"What's New in 0.4.x?\n"
"===================="

#: ../docs/WhatsNew.md:994
msgid ""
"1. **New templating engine and templates**\n"
"2. **yardoc `--query` argument**\n"
"3. **Greatly expanded API documentation**\n"
"4. **New plugin support**\n"
"5. **New tags (@abstract, @private)**\n"
"6. **Default rake task is now `rake yard`**"
msgstr ""
"1. **新しいテンプレートエンジンとテンプレート**\n"
"2. **yardoc `--query` 引数**\n"
"3. **Greatly expanded API ドキュメント**\n"
"4. **新しいプラグインのサポート**\n"
"5. **新しいタグ(@abstract, @private)**\n"
"6. **デフォルトのrake taskは`rake yard`コマンドになった**"

#: ../docs/WhatsNew.md:1001
msgid ""
"New templating engine and templates\n"
"-----------------------------------"
msgstr ""
"新しいテンプレートエンジンとテンプレート\n"
"-----------------------------------"

#: ../docs/WhatsNew.md:1004
msgid ""
"The templates were redesigned, most notably removing the ugly frameset, "
"adding\n"
"search to the class/method lists, simplifying the layout and making things\n"
"generally prettier. You should also notice that more tags are now visible "
"in\n"
"the templates such as @todo, the new @abstract and @note tags and some "
"others\n"
"that existed but were previously omitted from the generated documentation."
msgstr ""
"テンプレートは再設計された特に汚いフレームセットを削除しなければならない、\n"
"クラス/メソッドのリストに検索を追加する。\n"
"レイアウトを簡単にしてほとんどの場合きれいに作成するようになった。\n"
"あなたがさらにタグで注意することは、\n"
"@todo,新しい@abstract,@noteタグそしていくつか存在する他のタグなどのように\n"
"テンプレートの中の可視性になった事である。\n"
"しかし既に生成されたドキュメントからは除外される。"

#: ../docs/WhatsNew.md:1010
msgid ""
"There is also a new templating engine (based on the tadpole templating "
"library)\n"
"to allow for much more user customization. You can read about it in\n"
"{file:docs/Templates.md}."
msgstr ""
"これは更なるユーザーのカスタマイズを受け入れる為の\n"
"新しいテンプレートエンジンでもある(tadpoleテンプレートライブラリベースの)\n"
"これらのについては{file:docs/Templates.md}の中で読む事ができる。"

#: ../docs/WhatsNew.md:1014
msgid ""
"yardoc `--query` argument\n"
"-------------------------"
msgstr ""
"yardoc `--query` 引数\n"
"-------------------------"

#: ../docs/WhatsNew.md:1017
msgid ""
"The yardoc command-line tool now supports queries to select which classes,\n"
"modules or methods to include in documentation based on their data or meta-"
"data.\n"
"For instance, you can now generate documentation for your \"public\" API "
"only by\n"
"adding \"@api public\" to each of your public API methods/classes and using\n"
"the following argument:"
msgstr ""
"yardocのコマンドラインツールは、\n"
"データやメタデータの基のドキュメントを組み込む為に、\n"
"そのクラス,モジュールやメソッドで選択するクエリーをサポートするようになっ"
"た。\n"
"例えば、あなたは、個々のpublic API メソッド/クラスに\n"
"\"@api public\"を追加するだけで、自分の\"public\"API用にドキュメントを生成で"
"きるようになった。\n"
"次の様に、引数を用いる:"

#: ../docs/WhatsNew.md:1023
msgid "    --query '@api.text == \"public\"'"
msgstr "    --query '@api.text == \"public\"'"

#: ../docs/WhatsNew.md:1025
msgid "More information on queries is in the {file:README.md}."
msgstr "クエリーの詳細な情報は{file:README.md}で"

#: ../docs/WhatsNew.md:1027
msgid ""
"Greatly expanded API documentation\n"
"----------------------------------"
msgstr ""
"非常に拡張されたAPIドキュメント\n"
"----------------------------------"

#: ../docs/WhatsNew.md:1030
msgid ""
"Last release focused on many how-to and architecture documents to explain\n"
"the design of YARD, but many of the actual API classes/methods were still\n"
"left undocumented. This release marks a focus on getting YARD's own "
"documentation\n"
"up to par so that it can serve as an official reference on the recommended\n"
"conventions to use when documenting code."
msgstr ""
"最後のリリースは沢山の操作手順とYARDのデザインを詳細に説明する為の\n"
"アーキテクチャドキュメントに焦点を合わせた。\n"
"しかし、実際のAPIクラス/メソッドの大部分は、いまだ記述されていない。\n"
"このリリースは、標準的なYARD独自のドキュメントの取得に焦点を当てている。\n"
"なのでこれは、コードを書く時に利用する推奨された公式のリファレンスとして提供"
"できる。"

#: ../docs/WhatsNew.md:1036
msgid ""
"New plugin support\n"
"------------------"
msgstr ""
"新しいプラグインサポート\n"
"------------------"

#: ../docs/WhatsNew.md:1039
msgid ""
"YARD now supports loading of plugins via RubyGems. Any gem named `yard-*` "
"or\n"
"`yard_*` will now be loaded when YARD starts up. Note that the '-' "
"separator\n"
"is the recommended naming scheme."
msgstr ""
"YARDは、RubyGems経由でプラグインのロードをサポートできるようになった。\n"
"`yard-*`や`yard_*`で名付けられた任意のgemは、YARDが起動する時にロードされるだ"
"ろう。\n"
"次の事に留意する。'-'区切りは、推奨された命名スキームである。"

#: ../docs/WhatsNew.md:1043
msgid ""
"To ignore plugins, add the gem names to `~/.yard/ignored_plugins` on "
"separate\n"
"lines (or separated by whitespace)."
msgstr ""
"プラグインを無視するには、\n"
"`~/.yard/ignored_plugins`ファイルで行区切り(又は、スペース区切りで)\n"
"でgem名を追加する。"

#: ../docs/WhatsNew.md:1046
msgid ""
"New tags (@abstract, @private)\n"
"------------------------------"
msgstr ""
"新しいタグ(@abstract, @private)\n"
"------------------------------"

#: ../docs/WhatsNew.md:1049
msgid ""
"Two new tags were added to the list of builtin meta-tags in YARD. "
"`@abstract`\n"
"marks a class/module/method as abstract while `@private` marks an object\n"
"as \"private\". The latter tag is used in situations where an object is "
"public\n"
"due to Ruby's own visibility limitations (constants, classes and modules\n"
"can never be private) but not actually part of your public API. You should\n"
"use this tag sparingly, as it is not meant to be an equivalent to RDoc's\n"
"`:nodoc:` tag. Remember, YARD recommends documenting private objects too.\n"
"This tag exists so that you can create a query (`--query !@private`) to\n"
"ignore all of these private objects in your documentation. You can also\n"
"use the new `--no-private` switch, which is a shortcut to the "
"aforementioned\n"
"query. You can read more about the new tags in the {file:docs/GettingStarted."
"md}\n"
"guide."
msgstr ""
"二つの新しいタグが、YARDの中の組み込みのメタタグのリストに追加された。\n"
"`@abstract`は、概要(abstract)として、class/module/methodをマークする。\n"
"さらに、`@private`は、\"private\"として、オブジェクトをマークする。\n"
"後者のタグは、\n"
"後のタグはオブジェクトがRuby自身の可視性の制約の為に\n"
"実際のあなたのpublic APIの一部ではないにしてもpublic相当の場所で利用される\n"
"(定数は、クラス、モジュールはプライベートにはできない)\n"
"あなたは、慎重にこのタグを利用すべきである。\n"
"RDocが`:nodoc:`タグと同様であるという意味ではない。\n"
"YARDはprivate オブジェクトの記述も推奨する事を覚えておいてほしい。\n"
"このタグは、あなたが、自分のドキュメントでこれらのprivateオブジェクトの全てを無視する為に\n"
"クエリー(`--query !@private`)を作成できるように存在する。\n"
"あなたは新しい`--no-private`引数を利用する事もできる。\n"
"これは前述のクエリーへのショートカットである。\n"
"さらに新しいタグについて知りたい場合は、 {file:docs/GettingStarted.md} のガイドで読むことができる。"

#: ../docs/WhatsNew.md:1062
msgid ""
"Default rake task is now `rake yard`\n"
"------------------------------------"
msgstr ""
"デフォルトのrake taskは、`rake yard`となった\n"
"------------------------------------"

#: ../docs/WhatsNew.md:1065
msgid ""
"Not a big change, but anyone using the default \"rake yardoc\" task should\n"
"update their scripts:"
msgstr ""
"大きな変更ではないが、誰もが使うデフォルトの\"rake yardoc\" taskは、\n"
"次のスクリプトに変更された。"

#: ../docs/WhatsNew.md:1068
msgid ""
"[http://github.com/lsegal/yard/commit/"
"ad38a68dd73898b06bd5d0a1912b7d815878fae0](http://github.com/lsegal/yard/"
"commit/ad38a68dd73898b06bd5d0a1912b7d815878fae0)"
msgstr "[http://github.com/lsegal/yard/commit/ad38a68dd73898b06bd5d0a1912b7d815878fae0](http://github.com/lsegal/yard/commit/ad38a68dd73898b06bd5d0a1912b7d815878fae0)"

#: ../docs/WhatsNew.md:1071
msgid ""
"What's New in 0.2.3.x?\n"
"======================"
msgstr ""
"What's New in 0.2.3.x?\n"
"======================"

#: ../docs/WhatsNew.md:1074
msgid ""
"1. **Full Ruby 1.9 support**\n"
"2. **New parser code and handler API for 1.9**\n"
"3. **A new `@overload` tag**\n"
"4. **Better documentation**\n"
"5. **Template changes and bug fixes**"
msgstr ""
"1. **完全なRuby 1.9でのサポート**\n"
"2. **1.9用の新しいパーサーのコードとハンドラーAPI**\n"
"3. **新しい `@overload` タグ**\n"
"4. **より良いドキュメント**\n"
"5. **テンプレートの変更とバグの修正**"

#: ../docs/WhatsNew.md:1080
msgid ""
"Full Ruby 1.9 support\n"
"---------------------"
msgstr ""
"完全なRuby1.9のサポート\n"
"---------------------"

#: ../docs/WhatsNew.md:1083
msgid ""
"YARD's development actually focuses primarily on 1.9 from the get-go, so it "
"is\n"
"not an afterthought. All features are first implemented for compatibility "
"with\n"
"1.9, but of course all functionality is also tested in 1.8.x. YARD 0.2.2 "
"was\n"
"mostly compatible with 1.9, but the new release improves and extends in "
"certain\n"
"areas where compatibility was lacking. The new release should be fully "
"functional\n"
"in Ruby 1.9."
msgstr ""
"YARDの開発の実際の焦点は最初から1.9上が主で、結果として1.9になった訳ではな"
"い。\n"
"全ての機能は、始めに1.9互換で実装されるが、もちろん1.8.xでもテストされてい"
"る。\n"
"YARD 0.2.2は、大部分が1.9を用い互換性があるが、\n"
"新リリースは、互換性が欠けていた所を範囲を拡張する。\n"
"新しいリリースは、Ruby 1.9で完全に機能するはずである。"

#: ../docs/WhatsNew.md:1090
msgid ""
"New parser code and handler API for 1.9\n"
"---------------------------------------"
msgstr ""
"1.9用の新しいパーサーコードとハンドラーAPI\n"
"---------------------------------------"

#: ../docs/WhatsNew.md:1093
msgid ""
"Using Ruby 1.9 also gives YARD the advantage of using the new `ripper` "
"library\n"
"which was added to stdlib. The ripper parser is Ruby's official answer to\n"
"projects like ParseTree and ruby2ruby. Ripper allows access to the AST as "
"it\n"
"is parsed by the Ruby compiler. This has some large benefits over "
"alternative\n"
"projects:"
msgstr ""
"Ruby1.9の使用で、YARDの標準ライブラリに追加された\n"
"新しい`ripper`ライブラリの利点が与えられる。\n"
"ripperパーサーは、\n"
"ParseTreeとruby2rubyのように動かす為の\n"
"Rubyの公式な回答である。\n"
"Ripperは、Rubyコンパイラによって解析されるASTとしてアクセスを受入れる。\n"
"これは、別のプロジェクトにくらべていくつかの大きな恩恵がある。"

#: ../docs/WhatsNew.md:1099
msgid ""
"  1. It is officially supported and maintained by the Ruby core team.\n"
"  2. The AST is generated directly from the exact same code that drives the\n"
"     compiler, meaning anything that compiles is guaranteed to generate the\n"
"     equivalent AST.\n"
"  3. It needs no hacks, gems or extra libs and works out of the box in 1.9.\n"
"  4. It's *fast*."
msgstr ""
"  1. 公式にRubyのコアチームによってサポートとメンテナンスされている。\n"
"  2. ASTはコンパイラを起動する同じコードから直接生成され、  \n"
"     コンパイルがASTと同様に生成する為に保証されるどんなものでも意味があ"
"る。\n"
"  3. 道具を必要としない。gemや、追加のライブラリ、1.9の箱の外の仕事を\n"
"  4. 速い"

#: ../docs/WhatsNew.md:1106
msgid ""
"Having the AST means that developers looking to extend YARD have much "
"better\n"
"access to the parsed code than in previous versions. The only caveat is "
"that\n"
"this library is not back-compatible to 1.8.x. Because of this, there are\n"
"subtle changes to the handler extension API that developers use to extend "
"YARD.\n"
"Namely, there is now a standard API for 1.9 and a \"legacy\" API that can "
"run in\n"
"both 1.8.x and 1.9 if needed. A developer can still use the legacy API to "
"write\n"
"handlers that are compatible for both 1.8.x and 1.9 in one shot, or decide "
"to\n"
"implement the handler using both APIs. Realize that the benefit of using the "
"new\n"
"API means 1.9 users will get a 2.5x parsing speed increase over running the "
"legacy\n"
"handlers (this is *in addition to* the ~1.8x speed increase of using YARV "
"over MRI)."
msgstr ""
"ASTを持つ事は、開発者が拡張されたYARDがより多くの\n"
"(前のバージョンより解析されたコードから)アクセスを持つので探す事を意味す"
"る。\n"
"\n"
"誤解を生まないよう注意するが、\n"
"このライブラリは、1.8.xの後方互換ではない。\n"
"これは何故かというと、\n"
"開発者がYARDを拡張する為に利用する\n"
"ハンドラーの拡張APIに難解な変更があるからである。\n"
"即ち、必要なら、1.8.xと1.9両方で起動できる1.9用の標準APIと\"legacy\"APIになっ"
"た。\n"
"開発者は、1.8.xと1.9の両方のハンドラーを一回で書くのに、legacyAPIを利用でき"
"る。\n"
"又、両方のAPIによってハンドラーを実装する事を決めた。\n"
"1.9ユーザーの新しいAPIの手法を使う事によっての恩恵は、\n"
"レガシーハンドラーの起動より解析するスピードが2.5x倍増大すると理解する。\n"
"(これで、 *さらに*  ~1.8xのスピードがMRIでYARVを使う事によって増大する)"

#: ../docs/WhatsNew.md:1117
msgid ""
"A new `@overload` tag\n"
"---------------------"
msgstr ""
"新しい`@overload`タグ\n"
"---------------------"

#: ../docs/WhatsNew.md:1120
msgid ""
"The new `@overload` tag enables users to document methods that take "
"multiple\n"
"parameters depending on context. This is basically equivalent to RDoc's call-"
"seq,\n"
"but with a name that is more akin to the OOP concept of method overloading\n"
"that is actually being employed. Here's an example:"
msgstr ""
"新しい`@overload`タグは、ユーザーが\n"
"文脈の中で依存する複数のパラメータを取得するメソッドを記述する事を可能にす"
"る。\n"
"これは、基本的に、RDocのcall-seqと同様であるが、\n"
"オブジェクト指向の実際に用いられるオーバーロードのメソッドの概念により類似し"
"ている。\n"
"次のような例になる:"

#: ../docs/WhatsNew.md:1125
msgid ""
"      # @overload def to_html(html, autolink = true)\n"
"      #   This docstring describes the specific overload only.\n"
"      #   @param [String] html the HTML\n"
"      #   @param [Boolean] autolink whether or not to automatically link\n"
"      #     URL references\n"
"      # @overload def to_html(html, opts = {})\n"
"      #   @param [String] html the HTML\n"
"      #   @param [Hash] opts any attributes to add to the root HTML node\n"
"      def to_html(*args)\n"
"        # split args depending on context\n"
"      end"
msgstr ""
"      # @overload def to_html(html, autolink = true)\n"
"      #   This docstring describes the specific overload only.\n"
"      #   @param [String] html the HTML\n"
"      #   @param [Boolean] autolink whether or not to automatically link\n"
"      #     URL references\n"
"      # @overload def to_html(html, opts = {})\n"
"      #   @param [String] html the HTML\n"
"      #   @param [Hash] opts any attributes to add to the root HTML node\n"
"      def to_html(*args)\n"
"        # split args depending on context\n"
"      end"

#: ../docs/WhatsNew.md:1137
msgid ""
"As you can see each overload takes its own nested tags (including a "
"docstring)\n"
"as if it were its own method. This allows \"virtual\" overloading behaviour "
"at\n"
"the API level to make Ruby look like overload-aware languages without "
"caring\n"
"about the implementation details required to add the behaviour."
msgstr ""
"上のオーバーロードは、それが独自のメソッドのように\n"
"入れ子になった自身のタグを取得する(docstringを含んでいる)。\n"
"これは、振舞いを追加するのに必要とされる詳細の実装について気にすることな"
"く、\n"
"Rubyをオーバーロードに考慮した言語のように構成する為に、\n"
"APIレベルで\"仮の\"オーバーロードの挙動も受入れる。"

#: ../docs/WhatsNew.md:1142
msgid ""
"It is still recommended practice, however, to stay away from overloading "
"when\n"
"possible and document the types of each method's real parameters. This "
"allows\n"
"toolkits making use of YARD to get accurate type information for your "
"methods,\n"
"for instance, allowing IDE autocompletion. There are, of course, situations\n"
"where overload just makes more sense."
msgstr ""
"これはまだ推奨案だが、\n"
"可能な時はオーバーロードを使わないで、実際の引数の個々のメソッドの型を記述す"
"る。\n"
"これで、貴方のメソッド用に正確な型情報を取得する為にYARDのツールキットの使用"
"が受入れられる。\n"
"例えば、IDEの自動補完をがある。\n"
"これは勿論、オーバーロードでより多くの意味を成す場合もある。"

#: ../docs/WhatsNew.md:1148
msgid ""
"Better documentation\n"
"--------------------"
msgstr ""
"より良いドキュメント\n"
"--------------------"

#: ../docs/WhatsNew.md:1151
msgid ""
"The first few iterations of YARD were very much a proof of concept. Few "
"people\n"
"were paying attention and it was really just pieced together to see what "
"was\n"
"feasible. Now that YARD is gaining interest, there are many developers that\n"
"want to take advantage of its extensibility support to do some really cool "
"stuff.\n"
"Considerable time was spent for this release documenting, at a high level, "
"what\n"
"YARD can do and how it can be done. Expect this documentation to be extended "
"and\n"
"improved in future releases."
msgstr ""
"最初のいくつかのYARDのイテレータはよくできた概念の証明である。\n"
"いくらかの人は、注意を払ったり、それが本当に可能なのか見る為に一緒に試したり"
"しただろう。\n"
"現在のYARDは関心を集めているので、\n"
"いくつかの本当にイカした拡張サポートがほしい沢山の開発者がいる。\n"
"かなりの時間、このリリースで、\n"
"YARDで何ができるのかとどのような方法が出来るのかハイレベルで記述するのに費や"
"された。\n"
"このドキュメントが拡張され、機能のリリースで改良されるよう事を期待する。"

#: ../docs/WhatsNew.md:1159
msgid ""
"Template changes and bug fixes\n"
"------------------------------"
msgstr ""
"テンプレートの変更とバグ修正\n"
"------------------------------"

#: ../docs/WhatsNew.md:1162
msgid ""
"Of course no new release would be complete without fixing the old broken "
"code.\n"
"Some tags existed but were not present in generated documentation. The "
"templates\n"
"were mostly fixed to add the major omitted tags. In addition to template "
"adjustments,\n"
"many parsing bugs were ironed out to make YARD much more stable with "
"existing projects\n"
"(Rails, HAML, Sinatra, Ramaze, etc.)."
msgstr ""
"勿論、新しいリリースで、古い壊れたコードを修正無しで仕上げられるだろう。\n"
"いくつか存在したタグが、生成されるドキュメントで存在しなくなった。\n"
"テンプレートは、メジャーだが抜かされたタグを追加する為に大部分が修正され"
"た。\n"
"テンプレートの調整に加えて、\n"
"既存のプロジェクトを用い(Rails, HAML, Sinatra, Ramaze, etc.)より安定したYARD"
"を作る為に、\n"
"多くの解析のバグは無視された。"

# YARD::ROOT
#: ../lib/yard.rb:5
msgid "The root path for YARD source libraries"
msgstr "YARDソースライブラリ用のルートパス"

# YARD::TEMPLATE_ROOT
#: ../lib/yard.rb:8
msgid "The root path for YARD builtin templates"
msgstr "YARDビルトインテンプレート用のルートパス"

# @deprecated
#: ../lib/yard.rb:11
msgid "Use {Config::CONFIG_DIR}"
msgstr "Use {Config::CONFIG_DIR}"

# YARD.parse
# YARD.parse_string
#: ../lib/yard.rb:14 ../lib/yard.rb:21
msgid "An alias to {Parser::SourceParser}'s parsing method"
msgstr "解析用の{Parser::SourceParser}メソッドへのエイリアス"

# @example Parse a glob of files
#: ../lib/yard.rb:18
msgid "YARD.parse('lib/**/*.rb')"
msgstr "YARD.parse('lib/**/*.rb')"

# @example
#: ../lib/yard.rb:18
msgid "tag|example|Parse a glob of files"
msgstr "ファイルのglobを解析する。"

# @see
#: ../lib/yard.rb:18
msgid "tag|see|Parser::SourceParser.parse"
msgstr "tag|see|Parser::SourceParser.parse"

# @example Parse a string of input
#: ../lib/yard.rb:25
msgid "YARD.parse_string('class Foo; end')"
msgstr "YARD.parse_string('class Foo; end')"

# @example
#: ../lib/yard.rb:25
msgid "tag|example|Parse a string of input"
msgstr "tag|example|入力の文字列を解析する"

# @see
#: ../lib/yard.rb:25
msgid "tag|see|Parser::SourceParser.parse_string"
msgstr "tag|see|Parser::SourceParser.parse_string"

# YARD.load_plugins
# YARD::Config.load_plugins
#: ../lib/yard.rb:30 ../lib/yard/config.rb:139
msgid ""
"Loads gems that match the name 'yard-*' (recommended) or 'yard_*' except\n"
"those listed in +~/.yard/ignored_plugins+. This is called immediately\n"
"after YARD is loaded to allow plugin support."
msgstr ""
"'yard-*'(推奨される)や'yard_*'の名前にマッチするgemをロードする。\n"
"これを除外するには、 +~/.yard/ignored_plugins+ の中に対象の名前を記述する。\n"
"これは、YARDがプラグインサポートをロードした後すぐに呼び出される。"

# YARD::CLI
#: ../lib/yard/autoload.rb:6 ../lib/yard/cli/command.rb:6
#: ../lib/yard/cli/command_parser.rb:6 ../lib/yard/cli/config.rb:6
#: ../lib/yard/cli/diff.rb:6 ../lib/yard/cli/gems.rb:6
#: ../lib/yard/cli/graph.rb:6 ../lib/yard/cli/help.rb:6
#: ../lib/yard/cli/i18n.rb:6 ../lib/yard/cli/list.rb:6
#: ../lib/yard/cli/server.rb:6 ../lib/yard/cli/stats.rb:6
#: ../lib/yard/cli/yardoc.rb:6 ../lib/yard/cli/yri.rb:6
msgid "Namespace for command-line interface components"
msgstr "コマンドラインインタフェースコンポーネント用のNamespace"

# YARD::CodeObjects
#: ../lib/yard/autoload.rb:22 ../lib/yard/code_objects/base.rb:22
#: ../lib/yard/code_objects/class_object.rb:22
#: ../lib/yard/code_objects/class_variable_object.rb:22
#: ../lib/yard/code_objects/constant_object.rb:22
#: ../lib/yard/code_objects/extended_method_object.rb:22
#: ../lib/yard/code_objects/extra_file_object.rb:22
#: ../lib/yard/code_objects/macro_object.rb:22
#: ../lib/yard/code_objects/method_object.rb:22
#: ../lib/yard/code_objects/module_object.rb:22
#: ../lib/yard/code_objects/namespace_object.rb:22
#: ../lib/yard/code_objects/proxy.rb:22
#: ../lib/yard/code_objects/root_object.rb:22
msgid ""
"A \"code object\" is defined as any entity in the Ruby language.\n"
"Classes, modules, methods, class variables and constants are the\n"
"major objects, but DSL languages can create their own by inheriting\n"
"from {CodeObjects::Base}."
msgstr ""
"\"code object\"は、Ruby言語の中の任意の構成要素が定義される。\n"
"クラスや、モジュール、メソッド、クラス変数、定数は重要なオブジェクトとな"
"る。\\n\n"
"そして、DSL言語は、{CodeObjects::Base}からの継承によって\n"
"DSL言語自身を作成できる。"

# YARD::Handlers
#: ../lib/yard/autoload.rb:58 ../lib/yard/handlers/base.rb:58
#: ../lib/yard/handlers/c/base.rb:58
#: ../lib/yard/handlers/c/handler_methods.rb:58
#: ../lib/yard/handlers/processor.rb:58 ../lib/yard/handlers/ruby/base.rb:58
#: ../lib/yard/handlers/ruby/dsl_handler.rb:58
#: ../lib/yard/handlers/ruby/dsl_handler_methods.rb:58
#: ../lib/yard/handlers/ruby/legacy/base.rb:58
#: ../lib/yard/handlers/ruby/legacy/dsl_handler.rb:58
msgid ""
"Handlers are called during the data processing part of YARD's\n"
"parsing phase. This allows YARD as well as any custom extension to\n"
"analyze source and generate {CodeObjects} to be stored for later use."
msgstr ""
"ハンドラーは、YARDの解析段階でデータの処理の間に呼び出される。\n"
"これは、ソースの解析や後で使う為に記録される{CodeObjects}を生成する為に\n"
"YARD本体も任意のカスタム拡張も受け入れる。"

# YARD::Handlers::Ruby
#: ../lib/yard/autoload.rb:62 ../lib/yard/handlers/c/base.rb:62
#: ../lib/yard/handlers/c/handler_methods.rb:62
msgid "CRuby Handlers"
msgstr "CRuby ハンドラー"

# YARD::Handlers::Ruby
#: ../lib/yard/autoload.rb:82 ../lib/yard/handlers/ruby/base.rb:82
#: ../lib/yard/handlers/ruby/dsl_handler.rb:82
#: ../lib/yard/handlers/ruby/dsl_handler_methods.rb:82
#: ../lib/yard/handlers/ruby/legacy/dsl_handler.rb:82
msgid "All Ruby handlers"
msgstr "全てのRubyハンドラー"

# YARD::Handlers::Ruby::Legacy
#: ../lib/yard/autoload.rb:83 ../lib/yard/handlers/ruby/legacy/base.rb:83
#: ../lib/yard/handlers/ruby/legacy/dsl_handler.rb:83
msgid "Handlers for old Ruby 1.8 parser"
msgstr "古いRuby1.8パーサー用のハンドラー"

# YARD::Templates
#: ../lib/yard/autoload.rb:134 ../lib/yard/i18n/locale.rb:134
#: ../lib/yard/i18n/message.rb:134 ../lib/yard/i18n/messages.rb:134
#: ../lib/yard/i18n/pot_generator.rb:134 ../lib/yard/i18n/text.rb:134
msgid "Namespace for internationalization (i18n)"
msgstr "国際化用のNamespace (i18n)"

# YARD::Parser
#: ../lib/yard/autoload.rb:144 ../lib/yard/parser/base.rb:144
#: ../lib/yard/parser/c/c_parser.rb:144
#: ../lib/yard/parser/c/comment_parser.rb:144
#: ../lib/yard/parser/c/statement.rb:144
#: ../lib/yard/parser/ruby/ast_node.rb:144
#: ../lib/yard/parser/ruby/legacy/ruby_parser.rb:144
#: ../lib/yard/parser/ruby/ruby_parser.rb:144
#: ../lib/yard/parser/source_parser.rb:144
msgid ""
"The parser namespace holds all parsing engines used by YARD.\n"
"Currently only Ruby and C (Ruby) parsers are implemented."
msgstr ""
"ParserのnamespaceはYARDによって利用される全てのパーサーエンジンをサポートす"
"る。\n"
"今の所、RubyとC(Ruby)パーサーだけ実装されている。"

# YARD::Parser::Ruby
#: ../lib/yard/autoload.rb:147 ../lib/yard/parser/c/c_parser.rb:147
#: ../lib/yard/parser/c/comment_parser.rb:147
#: ../lib/yard/parser/c/statement.rb:147
msgid "CRuby Parsing components"
msgstr "CRubyのパーサーの構成"

# YARD::Parser::Ruby
#: ../lib/yard/autoload.rb:156 ../lib/yard/parser/ruby/ast_node.rb:156
#: ../lib/yard/parser/ruby/legacy/ruby_parser.rb:156
#: ../lib/yard/parser/ruby/ruby_parser.rb:156
msgid "Ruby parsing components."
msgstr "Rubyのパーサーの構成"

# YARD::Parser::Ruby::Legacy
#: ../lib/yard/autoload.rb:157 ../lib/yard/parser/ruby/legacy/ruby_lex.rb:157
#: ../lib/yard/parser/ruby/legacy/ruby_parser.rb:157
#: ../lib/yard/parser/ruby/legacy/statement.rb:157
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:157
#: ../lib/yard/parser/ruby/legacy/token_list.rb:157
msgid "Handles Ruby parsing in Ruby 1.8."
msgstr "Ruby1.8で利用されるパーサー処理"

# YARD::Rake
#: ../lib/yard/autoload.rb:176 ../lib/yard/rake/yardoc_task.rb:176
msgid "Holds Rake tasks used by YARD"
msgstr "YARDによって利用されるRake taskを持つ"

# YARD::Serializers
#: ../lib/yard/autoload.rb:180 ../lib/yard/serializers/base.rb:180
#: ../lib/yard/serializers/file_system_serializer.rb:180
#: ../lib/yard/serializers/process_serializer.rb:180
#: ../lib/yard/serializers/stdout_serializer.rb:180
#: ../lib/yard/serializers/yardoc_serializer.rb:180
msgid "Namespace for components that serialize to various endpoints"
msgstr "様々な出力でシリアライズする構成用のNamespace"

# YARD::Server
#: ../lib/yard/autoload.rb:188 ../lib/yard/server.rb:188
#: ../lib/yard/server/adapter.rb:188 ../lib/yard/server/commands/base.rb:188
#: ../lib/yard/server/commands/display_file_command.rb:188
#: ../lib/yard/server/commands/display_object_command.rb:188
#: ../lib/yard/server/commands/frames_command.rb:188
#: ../lib/yard/server/commands/library_command.rb:188
#: ../lib/yard/server/commands/library_index_command.rb:188
#: ../lib/yard/server/commands/list_command.rb:188
#: ../lib/yard/server/commands/search_command.rb:188
#: ../lib/yard/server/commands/static_file_command.rb:188
#: ../lib/yard/server/doc_server_helper.rb:188
#: ../lib/yard/server/doc_server_serializer.rb:188
#: ../lib/yard/server/library_version.rb:188
#: ../lib/yard/server/rack_adapter.rb:188 ../lib/yard/server/router.rb:188
#: ../lib/yard/server/static_caching.rb:188
#: ../lib/yard/server/webrick_adapter.rb:188
msgid ""
"Namespace for classes and modules that handle serving documentation over HTTP"
msgstr "HTTP経由でドキュメント作成の提供するクラスやモジュールの為のNamespace"

# YARD::Server
#: ../lib/yard/autoload.rb:190 ../lib/yard/server.rb:190
#: ../lib/yard/server/adapter.rb:190 ../lib/yard/server/commands/base.rb:190
#: ../lib/yard/server/commands/display_file_command.rb:190
#: ../lib/yard/server/commands/display_object_command.rb:190
#: ../lib/yard/server/commands/frames_command.rb:190
#: ../lib/yard/server/commands/library_command.rb:190
#: ../lib/yard/server/commands/library_index_command.rb:190
#: ../lib/yard/server/commands/list_command.rb:190
#: ../lib/yard/server/commands/search_command.rb:190
#: ../lib/yard/server/commands/static_file_command.rb:190
#: ../lib/yard/server/doc_server_helper.rb:190
#: ../lib/yard/server/doc_server_serializer.rb:190
#: ../lib/yard/server/library_version.rb:190
#: ../lib/yard/server/rack_adapter.rb:190 ../lib/yard/server/router.rb:190
#: ../lib/yard/server/static_caching.rb:190
#: ../lib/yard/server/webrick_adapter.rb:190
msgid ""
"== Implementing a Custom Server\n"
"To customize the YARD server, see the {Adapter} and {Router} classes."
msgstr ""
"== カスタムサーバーの実装\n"
"YARDサーバーをカスタマイズするには、{Adapter}や{Router}クラス参照。"

# YARD::Server
#: ../lib/yard/autoload.rb:193 ../lib/yard/server.rb:193
#: ../lib/yard/server/adapter.rb:193 ../lib/yard/server/commands/base.rb:193
#: ../lib/yard/server/commands/display_file_command.rb:193
#: ../lib/yard/server/commands/display_object_command.rb:193
#: ../lib/yard/server/commands/frames_command.rb:193
#: ../lib/yard/server/commands/library_command.rb:193
#: ../lib/yard/server/commands/library_index_command.rb:193
#: ../lib/yard/server/commands/list_command.rb:193
#: ../lib/yard/server/commands/search_command.rb:193
#: ../lib/yard/server/commands/static_file_command.rb:193
#: ../lib/yard/server/doc_server_helper.rb:193
#: ../lib/yard/server/doc_server_serializer.rb:193
#: ../lib/yard/server/library_version.rb:193
#: ../lib/yard/server/rack_adapter.rb:193 ../lib/yard/server/router.rb:193
#: ../lib/yard/server/static_caching.rb:193
#: ../lib/yard/server/webrick_adapter.rb:193
msgid ""
"== Rack Middleware\n"
"If you want to use the YARD server as a Rack middleware, see the "
"documentation\n"
"in {RackMiddleware}."
msgstr ""
"== Rack Middleware\n"
"あなたがRack MiddlewareのようにYARDサーバーを使いたい場合、\n"
"{RackMiddleware}ドキュメントを参照。"

# YARD::Server::Commands
#: ../lib/yard/autoload.rb:201 ../lib/yard/server/commands/base.rb:201
#: ../lib/yard/server/commands/display_file_command.rb:201
#: ../lib/yard/server/commands/display_object_command.rb:201
#: ../lib/yard/server/commands/frames_command.rb:201
#: ../lib/yard/server/commands/library_command.rb:201
#: ../lib/yard/server/commands/library_index_command.rb:201
#: ../lib/yard/server/commands/list_command.rb:201
#: ../lib/yard/server/commands/search_command.rb:201
#: ../lib/yard/server/commands/static_file_command.rb:201
msgid ""
"Commands implement specific kinds of server responses which are routed\n"
"to by the {Router} class. To implement a custom command, subclass {Commands::"
"Base}."
msgstr ""
"コマンドは特定のサーバーの応答のような実装。\n"
"そして、{Router}クラスによって送られる。\n"
"カスタムコマンドを実装する為には、{Commands::Base}サブクラス参照。"

# YARD::Tags
#: ../lib/yard/autoload.rb:229 ../lib/yard/tags/default_factory.rb:229
#: ../lib/yard/tags/default_tag.rb:229 ../lib/yard/tags/directives.rb:229
#: ../lib/yard/tags/library.rb:229 ../lib/yard/tags/option_tag.rb:229
#: ../lib/yard/tags/overload_tag.rb:229 ../lib/yard/tags/ref_tag.rb:229
#: ../lib/yard/tags/ref_tag_list.rb:229 ../lib/yard/tags/tag.rb:229
#: ../lib/yard/tags/tag_format_error.rb:229
msgid "Namespace for Tag components"
msgstr "タグの構成の為のNamespace"

# YARD::Templates
#: ../lib/yard/autoload.rb:249 ../lib/yard/templates/engine.rb:249
#: ../lib/yard/templates/erb_cache.rb:249
#: ../lib/yard/templates/helpers/html_syntax_highlight_helper.rb:249
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:249
#: ../lib/yard/templates/helpers/module_helper.rb:249
#: ../lib/yard/templates/helpers/text_helper.rb:249
#: ../lib/yard/templates/section.rb:249 ../lib/yard/templates/template.rb:249
#: ../lib/yard/templates/template_options.rb:249
msgid "Namespace for templating system"
msgstr "テンプレートシステム用のNamespace"

# YARD::Templates::Helpers
#: ../lib/yard/autoload.rb:251
#: ../lib/yard/templates/helpers/base_helper.rb:251
#: ../lib/yard/templates/helpers/filter_helper.rb:251
#: ../lib/yard/templates/helpers/html_helper.rb:251
#: ../lib/yard/templates/helpers/html_syntax_highlight_helper.rb:251
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:251
#: ../lib/yard/templates/helpers/markup_helper.rb:251
#: ../lib/yard/templates/helpers/method_helper.rb:251
#: ../lib/yard/templates/helpers/module_helper.rb:251
#: ../lib/yard/templates/helpers/text_helper.rb:251
#: ../lib/yard/templates/helpers/uml_helper.rb:251
msgid "Namespace for template helpers"
msgstr "テンプレートへルパー用のNamespace"

# YARD::Templates::Helpers::Markup
#: ../lib/yard/autoload.rb:252
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:252
msgid "Namespace for markup providers"
msgstr "マークアップを提供する為のNamespace"

# YARD::CLI::Command
#: ../lib/yard/cli/command.rb:6
msgid ""
"Abstract base class for CLI utilities. Provides some helper methods for\n"
"the option parser"
msgstr ""
"CLIユーティリティ用の抽象的なベースクラス。\n"
"オプションパーサー用のいくつかのヘルパーメソッドを提供する。"

# YARD::CLI::YRI.run
# YARD::CLI::Command.run
#: ../lib/yard/cli/command.rb:12 ../lib/yard/cli/yri.rb:27
msgid "Helper method to run the utility on an instance."
msgstr "インスタンス上のユーティリティを起動する為のヘルパーメソッド。"

# @see
#: ../lib/yard/cli/command.rb:13 ../lib/yard/cli/yri.rb:28
#: ../lib/yard/server/commands/base.rb:33
msgid "tag|see|#run"
msgstr "tag|see|#run"

# YARD::CLI::Command#common_options
#: ../lib/yard/cli/command.rb:20
msgid "Adds a set of common options to the tail of the OptionParser"
msgstr "OptionParserの末尾に一般的なオプションのグループを追加する。"

# @param [Hash]
# @param [OptionParser]
# @param [Hash{String => String}]
# @param [Hash, nil]
#: ../lib/yard/cli/command.rb:23 ../lib/yard/cli/command.rb:54
#: ../lib/yard/code_objects/class_object.rb:63
#: ../lib/yard/code_objects/class_object.rb:98
#: ../lib/yard/code_objects/namespace_object.rb:113
#: ../lib/yard/code_objects/namespace_object.rb:144
#: ../lib/yard/code_objects/namespace_object.rb:164
#: ../lib/yard/handlers/base.rb:355
#: ../lib/yard/handlers/ruby/legacy/base.rb:34 ../lib/yard/options.rb:108
#: ../lib/yard/options.rb:122 ../lib/yard/parser/ruby/ast_node.rb:152
#: ../lib/yard/serializers/base.rb:27
#: ../lib/yard/serializers/file_system_serializer.rb:27
#: ../lib/yard/server/adapter.rb:71 ../lib/yard/server/commands/base.rb:74
#: ../lib/yard/server/rack_adapter.rb:26
#: ../lib/yard/templates/helpers/html_helper.rb:536
#: ../lib/yard/templates/template.rb:230 ../lib/yard/templates/template.rb:256
msgid "tag|param|opts"
msgstr "tag|param|opts"

# @param [OptionParser] opts
#: ../lib/yard/cli/command.rb:23 ../lib/yard/cli/command.rb:54
msgid "the option parser object"
msgstr "パーサーオブジェクトのオプション"

# YARD::CLI::Command#parse_options
#: ../lib/yard/cli/command.rb:49
msgid "Parses the option and gracefully handles invalid switches"
msgstr "オプションを解析し、無効な引数を処理する。"

# @since
#: ../lib/yard/cli/command.rb:54 ../lib/yard/cli/diff.rb:201
#: ../lib/yard/cli/gems.rb:59 ../lib/yard/cli/graph.rb:66
#: ../lib/yard/cli/help.rb:8 ../lib/yard/cli/server.rb:109
#: ../lib/yard/cli/stats.rb:179 ../lib/yard/cli/yardoc.rb:193
#: ../lib/yard/cli/yardoc.rb:197 ../lib/yard/cli/yardoc.rb:201
#: ../lib/yard/cli/yardoc.rb:388 ../lib/yard/cli/yardoc.rb:498
#: ../lib/yard/cli/yardoc.rb:742 ../lib/yard/cli/yri.rb:24
#: ../lib/yard/code_objects/base.rb:149
#: ../lib/yard/code_objects/method_object.rb:132
#: ../lib/yard/code_objects/namespace_object.rb:12
#: ../lib/yard/core_ext/insertion.rb:30 ../lib/yard/core_ext/insertion.rb:34
#: ../lib/yard/handlers/processor.rb:24 ../lib/yard/handlers/processor.rb:31
#: ../lib/yard/handlers/processor.rb:33 ../lib/yard/serializers/base.rb:61
#: ../lib/yard/server/commands/display_object_command.rb:47
#: ../lib/yard/tags/directives.rb:98 ../lib/yard/tags/directives.rb:121
#: ../lib/yard/tags/library.rb:100 ../lib/yard/tags/library.rb:128
#: ../lib/yard/tags/library.rb:137
#: ../lib/yard/templates/helpers/base_helper.rb:19
#: ../lib/yard/templates/helpers/base_helper.rb:102
#: ../lib/yard/templates/helpers/html_helper.rb:57
#: ../lib/yard/templates/helpers/html_helper.rb:73
#: ../lib/yard/templates/helpers/html_helper.rb:83
#: ../lib/yard/templates/helpers/html_helper.rb:91
#: ../lib/yard/templates/helpers/html_helper.rb:101
#: ../lib/yard/templates/helpers/html_helper.rb:109
#: ../lib/yard/templates/helpers/html_helper.rb:123
#: ../lib/yard/templates/helpers/markup_helper.rb:52
#: ../lib/yard/templates/helpers/markup_helper.rb:122
#: ../lib/yard/templates/helpers/markup_helper.rb:140
#: ../lib/yard/templates/section.rb:85 ../lib/yard/templates/template.rb:133
msgid "0.6.0"
msgstr "0.6.0"

# @param [Array<String>]
# @param [Array<Symbol, String, Template, Array>]
#: ../lib/yard/cli/command.rb:54 ../lib/yard/cli/gems.rb:17
#: ../lib/yard/cli/graph.rb:50 ../lib/yard/cli/graph.rb:66
#: ../lib/yard/cli/list.rb:12 ../lib/yard/cli/stats.rb:33
#: ../lib/yard/cli/stats.rb:165 ../lib/yard/cli/yardoc.rb:243
#: ../lib/yard/cli/yardoc.rb:281 ../lib/yard/cli/yardoc.rb:507
#: ../lib/yard/cli/yri.rb:49 ../lib/yard/cli/yri.rb:189
#: ../lib/yard/docstring.rb:37 ../lib/yard/templates/template.rb:204
msgid "tag|param|args"
msgstr "tag|param|args"

# @param [Array<String>] args
#: ../lib/yard/cli/command.rb:54
msgid ""
"the arguments passed from input. This\n"
"array will be modified."
msgstr ""
"引数は入力から解析される。\n"
"この配列は、変更されるだろう。"

# YARD::CLI::Command#load_script
#: ../lib/yard/cli/command.rb:63
msgid ""
"Loads a Ruby script. If <tt>Config.options[:safe_mode]</tt> is enabled,\n"
"this method will do nothing."
msgstr ""
"Rubyスクリプトをロードする。 <tt>Config.options[:safe_mode]</tt> が有効の場合、\n"
"このメソッドは、何もしないだろう。"

# @since
#: ../lib/yard/cli/command.rb:67 ../lib/yard/cli/config.rb:90
#: ../lib/yard/cli/server.rb:20 ../lib/yard/cli/server.rb:24
#: ../lib/yard/config.rb:263 ../lib/yard/handlers/base.rb:228
#: ../lib/yard/handlers/base.rb:235 ../lib/yard/server.rb:7
msgid "0.6.2"
msgstr "0.6.2"

# @param [String]
# @param [String, nil]
#: ../lib/yard/cli/command.rb:67 ../lib/yard/code_objects/base.rb:260
#: ../lib/yard/core_ext/file.rb:53 ../lib/yard/registry.rb:118
#: ../lib/yard/registry.rb:132 ../lib/yard/registry.rb:158
#: ../lib/yard/registry_store.rb:113 ../lib/yard/registry_store.rb:130
#: ../lib/yard/registry_store.rb:164
#: ../lib/yard/templates/helpers/base_helper.rb:110
msgid "tag|param|file"
msgstr "tag|param|file"

# @param [String] file
#: ../lib/yard/cli/command.rb:67
msgid "the path to the script to load"
msgstr "ロードするスクリプトの為のパス"

# YARD::CLI::CommandParser
#: ../lib/yard/cli/command_parser.rb:4
msgid ""
"This class parses a command name out of the +yard+ CLI command and calls\n"
"that command in the form:"
msgstr ""
"このクラスは、 +yard+ CLIコマンド出力のコマンド名を解析する。\n"
"以下の形式のコマンド呼び出しとなる。"

# YARD::CLI::CommandParser
#: ../lib/yard/cli/command_parser.rb:7
msgid "  $ yard command_name [options]"
msgstr "  $ yard command_name [options]"

# YARD::CLI::CommandParser
#: ../lib/yard/cli/command_parser.rb:9
msgid ""
"If no command or arguments are specified, or if the arguments immediately\n"
"begin with a +--opt+ (not +--help+), the {default_command} will be used\n"
"(which itself defaults to +:doc+)."
msgstr ""
"コマンドが無い場合や、引数が指定される場合、\n"
"又は、引数が直後に +--opt+ ( +--help+ ではない)で始まる場合、\n"
"{default_command}が利用される。(そして自身の +:doc+ をデフォルトにする)"

# YARD::CLI::CommandParser
#: ../lib/yard/cli/command_parser.rb:13
msgid "== Adding a Command"
msgstr "== コマンドを追加する"

# YARD::CLI::CommandParser
#: ../lib/yard/cli/command_parser.rb:15
msgid ""
"To add a custom command via plugin, create a mapping in {commands} from\n"
"the Symbolic command name to the {Command} class that implements the\n"
"command. To implement a command, see the documentation for the {Command}\n"
"class."
msgstr ""
"プラグイン経由でカスタムコマンドを追加するには、\n"
"そのコマンド名の象徴から\n"
"コマンドを実装する{Command}クラスに\n"
"{commands}のマッピングを作成する。\n"
"コマンドを実装するには、{Command}クラス用のドキュメントを参照。"

# @see
#: ../lib/yard/cli/command_parser.rb:22
msgid "tag|see|Command"
msgstr "tag|see|Command"

# @see
#: ../lib/yard/cli/command_parser.rb:22
msgid "tag|see|commands"
msgstr "tag|see|commands"

# @see
#: ../lib/yard/cli/command_parser.rb:22
msgid "tag|see|default_command"
msgstr "tag|see|default_command"

# @return [Hash{Symbol => Command}]
#: ../lib/yard/cli/command_parser.rb:26
msgid ""
"the mapping of command names to\n"
"command classes to parse the user command."
msgstr "ユーザーコマンドを解析するコマンドクラスの為のコマンド名のマッピング"

# @return [Symbol]
#: ../lib/yard/cli/command_parser.rb:30
msgid ""
"the default command name to use when no options\n"
"are specified or"
msgstr "オプションが指定されない時に利用するデフォルトのコマンド名"

# YARD::CLI::CommandParser.run
#: ../lib/yard/cli/command_parser.rb:50
msgid "Convenience method to create a new CommandParser and call {#run}"
msgstr ""
"新しいCommandParserを作成し、{#run}メソッドを呼び出す為の便利メソッド。"

# @return [CommandParser]
#: ../lib/yard/cli/command_parser.rb:53
msgid "a new instance of CommandParser"
msgstr "CommandParserの新しいインスタンス"

# YARD::CLI::CommandParser#run
#: ../lib/yard/cli/command_parser.rb:58
msgid ""
"Runs the {Command} object matching the command name of the first\n"
"argument."
msgstr "最初の引数のコマンド名にマッチする{Command}オブジェクトを起動する。"

# YARD::CLI::Config
#: ../lib/yard/cli/config.rb:4
msgid "CLI command to view or edit configuration options"
msgstr ""
"CLIコマンドを調べる。\n"
"又は、設定オプションを編集する。"

# @return [Symbol, nil]
#: ../lib/yard/cli/config.rb:7
msgid "the key to view/edit, if any"
msgstr "調べたり、編集する為のkey"

# @return [Array, nil]
#: ../lib/yard/cli/config.rb:10
msgid "the list of values to set (or single value), if modifying"
msgstr "変更する場合、セットする値のリストを返す(又は、単一の値)"

# @return [Boolean]
#: ../lib/yard/cli/config.rb:13
msgid "whether to reset the {#key}"
msgstr "{#key}をリセットするかどうか"

# @return [Boolean]
#: ../lib/yard/cli/config.rb:16
msgid "whether the value being set should be inside a list"
msgstr "設定される値がリストの内部になるかどうか"

# @return [Boolean]
#: ../lib/yard/cli/config.rb:19
msgid "whether to append values to existing key"
msgstr "既存のkeyに値を追加するかどうか"

# @return [Config]
#: ../lib/yard/cli/config.rb:21
msgid "a new instance of Config"
msgstr "Configの新しいインスタンス"

# YARD::CLI::Diff
#: ../lib/yard/cli/diff.rb:8
msgid ""
"CLI command to return the objects that were added/removed from 2 versions\n"
"of a project (library, gem, working copy)."
msgstr ""
"プロジェクトの2つのバージョンから追加や削除された所のオブジェクトを返す為の"
"CLIコマンド。\n"
"(library, gem, working copy)"

# @return [Diff]
#: ../lib/yard/cli/diff.rb:11
msgid "a new instance of Diff"
msgstr "Diffの新しいインスタンス"

# @return [Gems]
#: ../lib/yard/cli/gems.rb:5
msgid "a new instance of Gems"
msgstr "Gemsの新しいインスタンス"

# YARD::CLI::Gems#run
#: ../lib/yard/cli/gems.rb:13
msgid ""
"Runs the commandline utility, parsing arguments and generating\n"
"YARD indexes for gems."
msgstr ""
"コマンドラインユーティリティを起動し、引数を解析し、gem用のYARDインデックスを"
"生成する。"

# @param [Array<String>] args
#: ../lib/yard/cli/gems.rb:17 ../lib/yard/cli/stats.rb:33
#: ../lib/yard/cli/yardoc.rb:281
msgid "the list of arguments"
msgstr "引数のリスト"

# YARD::CLI::Gems#build_gems
#: ../lib/yard/cli/gems.rb:26
msgid "Builds .yardoc files for all non-existing gems"
msgstr "存在しないgem用に.yardocファイルをビルドする。"

# @param [Array]
#: ../lib/yard/cli/gems.rb:27
msgid "tag|param|gems"
msgstr "tag|param|gems"

# YARD::CLI::Gems#optparse
#: ../lib/yard/cli/gems.rb:59
msgid "Parses options"
msgstr "オプションを解析する。"

# YARD::Rake::YardocTask#options
# YARD::Rake::YardocTask#options=
#: ../lib/yard/cli/graph.rb:4
msgid "Options to pass to the {Graph} CLI."
msgstr "{Graph} CLIに渡す為のオプション"

# @param [String] text
#: ../lib/yard/cli/graph.rb:6
msgid "the default output format"
msgstr "デフォルトの出力フォーマット"

# @param [Boolean] link
#: ../lib/yard/cli/graph.rb:9
msgid "whether to list the full class diagram"
msgstr "全てのクラス図をリストするかどうか"

# @return [Boolean]
#: ../lib/yard/cli/graph.rb:12
msgid "whether to show the object dependencies"
msgstr "オブジェクトの依存関係を調べるかどうか"

# @param [Hash] opts
#: ../lib/yard/cli/graph.rb:15
msgid "any contents to pass to the digraph"
msgstr "図に渡す内容"

# YARD::CLI::Graph
#: ../lib/yard/cli/graph.rb:19
msgid ""
"A command-line utility to generate Graphviz graphs from\n"
"a set of objects"
msgstr ""
"オブジェクトのグループからGraphvizのグラフを生成する為のコマンドラインユー"
"ティリティ"

# @see
#: ../lib/yard/cli/graph.rb:23
msgid "tag|see|Graph#run"
msgstr "tag|see|Graph#run"

# YARD::CLI::Graph#options
#: ../lib/yard/cli/graph.rb:25
msgid ""
"The options parsed out of the commandline.\n"
"Default options are:\n"
"  :format => :dot"
msgstr ""
"optionsはコマンドラインの出力を解析する。\n"
"optionsのデフォルトは:\n"
"  :format => dot"

# YARD::CLI::Graph#objects
#: ../lib/yard/cli/graph.rb:30
msgid "The set of objects to include in the graph."
msgstr "graphでインクルードする為のオブジェクトのグループ"

# YARD::CLI::Graph#initialize
#: ../lib/yard/cli/graph.rb:33
msgid "Creates a new instance of the command-line utility"
msgstr "コマンドラインユーティリティの新しいインスタンスを作成する。"

# @return [Graph]
#: ../lib/yard/cli/graph.rb:33
msgid "a new instance of Graph"
msgstr "Graphの新しいインスタンス"

# YARD::CLI::YRI#run
# YARD::CLI::Graph#run
#: ../lib/yard/cli/graph.rb:45 ../lib/yard/cli/yri.rb:45
msgid "Runs the command-line utility."
msgstr "コマンドラインユーティリティを起動する。"

# @param [Array<String>] args
#: ../lib/yard/cli/graph.rb:50 ../lib/yard/cli/graph.rb:66
#: ../lib/yard/cli/stats.rb:165 ../lib/yard/cli/yardoc.rb:507
#: ../lib/yard/cli/yri.rb:49 ../lib/yard/cli/yri.rb:189
msgid "each tokenized argument"
msgstr "個々にトークナイズされた引数"

# @example 
#: ../lib/yard/cli/graph.rb:50
msgid ""
"grapher = Graph.new\n"
"grapher.run('--private')"
msgstr ""
"grapher = Graph.new\n"
"grapher.run('--private')"

# YARD::CLI::YRI#optparse
# YARD::CLI::Graph#optparse
# YARD::CLI::Stats#optparse
# YARD::CLI::Yardoc#optparse
#: ../lib/yard/cli/graph.rb:65 ../lib/yard/cli/stats.rb:164
#: ../lib/yard/cli/yardoc.rb:506 ../lib/yard/cli/yri.rb:188
msgid "Parses commandline options."
msgstr "コマンドラインオプションを解析する。"

# YARD::CLI::Help
#: ../lib/yard/cli/help.rb:4
msgid "Handles help for commands"
msgstr "コマンド用のヘルプを操作する。"

# YARD::CLI::I18n
#: ../lib/yard/cli/i18n.rb:6
msgid ""
"CLI command to support internationalization (a.k.a. i18n).\n"
"I18n feature is based on gettext technology.\n"
"This command generates .pot file from docstring and extra\n"
"documentation."
msgstr ""

# @todo
#: ../lib/yard/cli/i18n.rb:12
msgid "Support msgminit and msgmerge features?"
msgstr ""

# @return [YRI]
#: ../lib/yard/cli/i18n.rb:13
msgid "a new instance of I18n"
msgstr "I18nの新しいインスタンス"

# @since
#: ../lib/yard/cli/i18n.rb:60 ../lib/yard/code_objects/base.rb:233
#: ../lib/yard/code_objects/base.rb:531
#: ../lib/yard/code_objects/method_object.rb:83
#: ../lib/yard/docstring_parser.rb:268 ../lib/yard/handlers/base.rb:411
#: ../lib/yard/handlers/base.rb:424 ../lib/yard/handlers/base.rb:433
#: ../lib/yard/handlers/base.rb:456 ../lib/yard/handlers/base.rb:470
#: ../lib/yard/handlers/base.rb:483 ../lib/yard/handlers/base.rb:495
#: ../lib/yard/handlers/base.rb:506 ../lib/yard/handlers/base.rb:520
#: ../lib/yard/handlers/c/override_comment_handler.rb:27
#: ../lib/yard/i18n/pot_generator.rb:258 ../lib/yard/registry_store.rb:94
#: ../lib/yard/registry_store.rb:103 ../lib/yard/tags/directives.rb:73
#: ../lib/yard/tags/directives.rb:519 ../lib/yard/tags/library.rb:113
#: ../lib/yard/templates/helpers/html_helper.rb:364
#: ../lib/yard/templates/helpers/html_helper.rb:372
msgid "0.8.0"
msgstr ""

# YARD::CLI::List
#: ../lib/yard/cli/list.rb:4
msgid ""
"Lists all constant and method names in the codebase. Uses {Yardoc} --list."
msgstr ""
"全ての定数とコードベースの中のメソッド名を記述する。{yardoc} --list で利用す"
"る。"

# YARD::CLI::List#run
#: ../lib/yard/cli/list.rb:8
msgid ""
"Runs the commandline utility, parsing arguments and displaying a\n"
"list of objects"
msgstr ""
"コマンドラインユーティリティを起動し、引数を解析する。\n"
"そして、オブジェクトのリストを表示する。"

# @param [Array<String>] args
#: ../lib/yard/cli/list.rb:12
msgid "the list of arguments."
msgstr "引数のリスト"

# YARD::CLI::Server
#: ../lib/yard/cli/server.rb:4
msgid "A local documentation server"
msgstr "ローカルドキュメントサーバー"

# @return [Hash]
#: ../lib/yard/cli/server.rb:7
msgid "a list of options to pass to the doc server"
msgstr "ドキュメントサーバーに渡す為のオプションのリスト"

# @return [Hash]
#: ../lib/yard/cli/server.rb:10
msgid "a list of options to pass to the web server"
msgstr "webサーバーに渡す為のオプションのリスト"

# @return [Hash]
#: ../lib/yard/cli/server.rb:13
msgid "a list of library names and yardoc files to serve"
msgstr "ライブラリ名のリストと提供する為のyardocファイル"

# @return [Adapter]
#: ../lib/yard/cli/server.rb:16
msgid "the adapter to use for loading the web server"
msgstr "ロードするwebサーバー用に利用されるアダプタ"

# @return [Array<String>]
#: ../lib/yard/cli/server.rb:20
msgid "a list of scripts to load"
msgstr "ロードする為のスクリプトのリスト"

# @return [Array<String>]
#: ../lib/yard/cli/server.rb:24
msgid "a list of template paths to register"
msgstr "登録するテンプレートのパスのリスト"

# YARD::CLI::Yardoc#initialize
#: ../lib/yard/cli/server.rb:27
msgid "Creates a new instance of the Server command line utility"
msgstr "サーバーコマンドラインユーティリティの新しいインスタンスを作成する。"

# @return [Verifier]
#: ../lib/yard/cli/server.rb:27
msgid "a new instance of Server"
msgstr "サーバーの新しいインスタンス"

# YARD::CLI::Stats::STATS_ORDER
#: ../lib/yard/cli/stats.rb:8
msgid ""
"Maintains the order in which +stats_for_+ statistics methods should be\n"
"printed."
msgstr ""
"オーダーを継続する。そして統計用の +stats_for_+ メソッドは、プリントされるべ"
"きである。"

# @see
#: ../lib/yard/cli/stats.rb:11
msgid "tag|see|#print_statistics"
msgstr ""

# @return [Boolean]
#: ../lib/yard/cli/stats.rb:14
msgid "whether to parse and load registry"
msgstr "解析するかレジストリーをロードするかどうか"

# @return [Stats]
#: ../lib/yard/cli/stats.rb:17
msgid "a new instance of Stats"
msgstr "Statsの新しいインスタンス"

# @param [Boolean]
#: ../lib/yard/cli/stats.rb:17
msgid "tag|param|parse"
msgstr ""

# @param [Boolean] parse
#: ../lib/yard/cli/stats.rb:17
msgid "whether to parse and load registry (see {#parse})"
msgstr "解析するかレジストリーがロードされるかどうか(see {#parse})"

# YARD::CLI::Stats#run
# YARD::CLI::Yardoc#run
#: ../lib/yard/cli/stats.rb:29 ../lib/yard/cli/yardoc.rb:238
msgid ""
"Runs the commandline utility, parsing arguments and generating\n"
"output if set."
msgstr ""
"コマンドラインユーティリティを起動し、引数を解析する。\n"
"そしてグループの場合、出力を生成する。"

# YARD::CLI::Stats#print_statistics
#: ../lib/yard/cli/stats.rb:48
msgid "Prints statistics for different object types"
msgstr "色々なオブジェクト型用に統計値をプリントする。"

# YARD::CLI::Stats#print_statistics
#: ../lib/yard/cli/stats.rb:50
msgid ""
"To add statistics for a specific type, add a method +#stats_for_TYPE+\n"
"to this class that calls {#output}."
msgstr ""
"特定の型用に統計値を追加するには、\n"
"{#output}メソッドに呼び出されるこのクラスに +#stats_for_TYPE+ メソッドを追加"
"する。"

# YARD::CLI::Stats#print_undocumented_objects
#: ../lib/yard/cli/stats.rb:71
msgid "Prints list of undocumented objects"
msgstr "記述されなかったオブジェクトのリストをプリントする。"

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/cli/stats.rb:99
msgid ""
"all the parsed objects in the registry,\n"
"removing any objects that are not visible (private, protected) depending\n"
"on the arguments passed to the command."
msgstr ""
"レジストリーの中の全ての解析されたオブジェクト,\n"
"コマンドに渡された引数に応じて不可視(private,protected)のオブジェクトを削除している。"

# YARD::CLI::Stats#stats_for_files
#: ../lib/yard/cli/stats.rb:104
msgid "Statistics for files"
msgstr "ファイル用の統計値"

# YARD::CLI::Stats#stats_for_modules
#: ../lib/yard/cli/stats.rb:111
msgid "Statistics for modules"
msgstr "モジュール用の統計値"

# YARD::CLI::Stats#stats_for_classes
#: ../lib/yard/cli/stats.rb:116
msgid "Statistics for classes"
msgstr "クラス用の統計値"

# YARD::CLI::Stats#stats_for_constants
#: ../lib/yard/cli/stats.rb:121
msgid "Statistics for constants"
msgstr "定数用の統計値"

# YARD::CLI::Stats#stats_for_methods
#: ../lib/yard/cli/stats.rb:126
msgid "Statistics for methods"
msgstr "メソッド用の統計値"

# YARD::CLI::Stats#output
#: ../lib/yard/cli/stats.rb:135
msgid ""
"Prints a statistic to standard out. This method is optimized for\n"
"getting Integer values, though it allows any data to be printed."
msgstr ""
"標準出力に統計値をプリントする。このメソッドは、\n"
"Integerの値の取得用に最適化され、プリントされる為に任意のデータを受入れる。"

# @param [Integer, nil] undoc
#: ../lib/yard/cli/stats.rb:143
msgid "number of undocumented objects for the type"
msgstr "型によって記述されなかったオブジェクトの数"

# @param [String]
# @param [Integer, String]
#: ../lib/yard/cli/stats.rb:143
#: ../lib/yard/code_objects/extra_file_object.rb:47
#: ../lib/yard/code_objects/macro_object.rb:39 ../lib/yard/registry.rb:323
#: ../lib/yard/serializers/base.rb:41 ../lib/yard/serializers/base.rb:77
#: ../lib/yard/server/commands/base.rb:159
#: ../lib/yard/templates/helpers/uml_helper.rb:33
msgid "tag|param|data"
msgstr ""

# @param [String]
# @param [Symbol, String]
# @param [String, Symbol]
# @param [Object]
# @param [#to_s]
#: ../lib/yard/cli/stats.rb:143 ../lib/yard/cli/yri.rb:109
#: ../lib/yard/cli/yri.rb:141 ../lib/yard/code_objects/base.rb:207
#: ../lib/yard/code_objects/method_object.rb:33 ../lib/yard/config.rb:154
#: ../lib/yard/config.rb:247 ../lib/yard/docstring.rb:237
#: ../lib/yard/docstring.rb:245 ../lib/yard/docstring.rb:255
#: ../lib/yard/docstring.rb:263 ../lib/yard/handlers/ruby/base.rb:21
#: ../lib/yard/handlers/ruby/base.rb:83 ../lib/yard/i18n/locale.rb:20
#: ../lib/yard/rake/yardoc_task.rb:46 ../lib/yard/registry.rb:270
#: ../lib/yard/registry.rb:368 ../lib/yard/server/library_version.rb:120
#: ../lib/yard/tags/tag.rb:43
msgid "tag|param|name"
msgstr ""

# @param [Integer, nil]
#: ../lib/yard/cli/stats.rb:143
msgid "tag|param|undoc"
msgstr ""

# @param [Integer, String] data
#: ../lib/yard/cli/stats.rb:143
msgid ""
"the numeric (or any) data representing\n"
"the statistic. If +data+ is an Integer, it should represent the\n"
"total objects of a type."
msgstr ""
"数(又は何か)のデータを表す統計値。\n"
"+data+ がIntegerの場合、型の全体のオブジェクトを表すはずである。"

# @param [String] name
#: ../lib/yard/cli/stats.rb:143
msgid "the statistic name"
msgstr "統計値の名前"

# YARD::CLI::YardocOptions
#: ../lib/yard/cli/yardoc.rb:7
msgid "Default options used in +yard doc+ command."
msgstr ""

# @return [Array<ConstantObject>]
#: ../lib/yard/cli/yardoc.rb:10
msgid "the list of extra files rendered along with objects"
msgstr "オブジェクトと一緒に表示される追加のファイルのリスト"

# @return [String]
#: ../lib/yard/cli/yardoc.rb:13
msgid "the default title appended to each generated page"
msgstr ""

# @return [Verifier]
#: ../lib/yard/cli/yardoc.rb:16
msgid "the default verifier object to filter queries"
msgstr ""

# @return [Serializers::Base]
#: ../lib/yard/cli/yardoc.rb:20
msgid ""
"the default serializer for generating output\n"
"to disk."
msgstr ""

# @return [String]
#: ../lib/yard/cli/yardoc.rb:23
msgid "the default output format (:html)."
msgstr "デフォルト出力フォーマット (:html)"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:27
msgid ""
"whether the data should be rendered in a single page,\n"
"if the template supports it."
msgstr ""

# @return [CodeObjects::ExtraFileObject]
#: ../lib/yard/cli/yardoc.rb:31
msgid ""
"the README file object rendered\n"
"along with objects"
msgstr ""

# @return [Array<NamespaceObject>]
#: ../lib/yard/cli/yardoc.rb:35
msgid ""
"the list of code objects to render\n"
"the templates with."
msgstr "リストと共にテンプレートを表示する為のコードオブジェクトのリスト"

# @return [Numeric]
#: ../lib/yard/cli/yardoc.rb:38
msgid "An index value for rendering sequentially related templates"
msgstr ""

# @return [CodeObjects::Base]
#: ../lib/yard/cli/yardoc.rb:42
msgid ""
"an extra item to send to a template that is not\n"
"the main rendered object"
msgstr ""

# @return [CodeObjects::ExtraFileObject]
#: ../lib/yard/cli/yardoc.rb:47
msgid ""
"the file object being rendered.\n"
"The +object+ key is not used so that a file may be rendered in the context\n"
"of an object's namespace (for generating links)."
msgstr ""

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:51
msgid ""
"Yardoc is the default YARD CLI command (+yard doc+ and historic +yardoc+\n"
"executable) used to generate and output (mainly) HTML documentation given\n"
"a set of source files."
msgstr ""
"Yardocは、デフォルトのYARD CLIコマンドとなり( +yard doc+ と省略表記の +yardoc"
"+ が実行可能)、\n"
"生成し、与えられたソースファイルのグループのHTMLドキュメントの出力(主な機能)"
"の為に利用される。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:55 ../lib/yard/i18n/pot_generator.rb:38
msgid "== Usage"
msgstr "== 使用法"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:57
msgid "Main usage for this command is:"
msgstr "このコマンドの主な使用法は次のようになる:"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:59
msgid "  $ yardoc [options] [source_files [- extra_files]]"
msgstr ""

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:61
msgid "See +yardoc --help+ for details on valid options."
msgstr "有効なオプションの詳細は +yardoc --help+ で参照できる。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:63
msgid "== Options File (+.yardopts+)"
msgstr "== オプションファイル (+.yardopts+)"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:65
msgid ""
"If a +.yardopts+ file is found in the source directory being processed,\n"
"YARD will use the contents of the file as arguments to the command,\n"
"treating newlines as spaces. You can use shell-style quotations to\n"
"group space delimited arguments, just like on the command line."
msgstr ""
"+.yardopts+ ファイルが、処理されるソースディレクトリで見つかった場合、\n"
"YARDは、コマンドに引数としてファイルの内容を利用し、改行をスペースとして処理"
"する。\n"
"あなたはスペースで区切られた引数のグループに、\n"
"コマンドラインのようなシェルスタイルの引用を利用できる。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:70
msgid "A valid +.yardopts+ file might look like:"
msgstr "有効な +.yardopts+ ファイルは、次のようになる。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:72
msgid ""
"  --no-private\n"
"  --title \"My Title\"\n"
"  --exclude foo --exclude bar\n"
"  lib/**/*.erb\n"
"  lib/**/*.rb -\n"
"  HACKING.rdoc LEGAL COPYRIGHT"
msgstr ""

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:79
msgid ""
"Note that Yardoc also supports the legacy RDoc style +.document+ file,\n"
"though this file can only specify source globs to parse, not options."
msgstr ""
"次の事に留意する。Yardocは、レガシーなRDocスタイルの +.document+ ファイルもサ"
"ポートするけれども、\n"
"このファイルは、オプションはなしで、解析の為にソースのglobだけ指定できる。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:82
msgid "== Queries (+--query+)"
msgstr "== クエリー (+--query+)"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:84
msgid ""
"Yardoc supports queries to select specific code objects for which to\n"
"generate documentation. For example, you might want to generate\n"
"documentation only for your public API. If you've documented your public\n"
"methods with +@api public+, you can use the following query to select\n"
"all of these objects:"
msgstr ""
"Yardocは、ドキュメントを生成する時に、\n"
"特定のコードオブジェクトを選択する為にクエリーをサポートする。\n"
"例えば、あなたが、\n"
"自分のpublic APIの為だけにドキュメント生成したいかもしれない。\n"
"あなたが、 +@api public+ を用いて記述されたpublicメソッドを持っていた場合、\n"
"これらのオブジェクトの全てを選択する為に、次の様なクエリーを利用できる:"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:90
msgid "  --query '@api.text == \"public\"'"
msgstr ""

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:92
msgid ""
"Note that the syntax for queries is mostly Ruby with a few syntactic\n"
"simplifications for meta-data tags. See the {Verifier} class for an\n"
"overview of this syntax."
msgstr ""
"次の事に留意する。クエリー用の構文は、\n"
"主にRuby構文で、メタデータタグ用のいくつかの構文の簡単にしたものも用いてい"
"る。\n"
"この構文の概要は、{Verifier}クラス参照。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:96
msgid "== Adding Custom Ad-Hoc Meta-data Tags (+--tag+)"
msgstr "== カスタムした特別なメタデータタグ(+--tag+)を追加する"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:98
msgid ""
"YARD allows specification of {file:docs/Tags.md meta-data tags}\n"
"programmatically via the {YARD::Tags::Library} class, but often this is not\n"
"practical for users writing documentation. To make adding custom tags\n"
"easier, Yardoc has a few command-line switches for creating basic tags\n"
"and displaying them in generated HTML output."
msgstr ""
"YARDは、{YARD::Tags::Library}クラス経由でプラグラムされた{file:docs/Tags.md "
"meta-data tags}の仕様を受入れるが、時々これは、ユーザーが書いているドキュメン"
"トとはそぐわない場合がある。\n"
"簡単なカスタムタグを作成するには、\n"
"Yardocが基本的なタグ作成用にいくつかのコマンドライン引数を持っており、\n"
"それをHTML出力し表示できる。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:104
msgid ""
"To specify a custom tag to be displayed in output, use any of the\n"
"following:"
msgstr "出力に表示されるカスタムタグを指定するには、次のように利用できる。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:107
msgid ""
"* +--tag+ TAG:TITLE\n"
"* +--name-tag+ TAG:TITLE\n"
"* +--type-tag+ TAG:TITLE\n"
"* +--type-name-tag+ TAG:TITLE\n"
"* +--title-tag+ TAG:TITLE"
msgstr ""

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:113
msgid "\"TAG:TITLE\" is of the form: name:\"Display Title\", for example:"
msgstr ""
"以下のように\"TAG:TITLE\" は、 形式: 名前:\"表示されるタイトル\" とする。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:115
msgid "  --tag overload:\"Overloaded Method\""
msgstr ""

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:117
msgid "See +yardoc --help+ for a description of the various options."
msgstr "様々なオプションの説明は +yardoc --help+ 参照。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:119
msgid ""
"Tags added in this way are automatically displayed in output. To add\n"
"a meta-data tag that does not show up in output, use +--hide-tag TAG+.\n"
"Note that you can also use this option on existing tags to hide\n"
"builtin tags, for instance."
msgstr ""
"この方法で追加したタグは、自動的に出力で表示される。\n"
"出力に表示しないでメタデータタグを追加するには、 +--hide-tag TAG+ を使う。\n"
"次の事に留意する。あなたは、\n"
"組み込みタグを隠す為に既存のタグ上でこのオプションも利用できる。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:124
msgid "== Processed Data Storage (+.yardoc+ directory)"
msgstr "== 処理されたデータストレージ (+.yardoc+ ディレクトリ)"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:126
msgid ""
"When Yardoc parses a source directory, it creates a +.yardoc+ directory\n"
"(by default, override with +-b+) at the root of the project. This directory\n"
"contains marshal dumps for all raw object data in the source, so that\n"
"you can access it later for various commands (+stats+, +graph+, etc.).\n"
"This directory is also used as a cache for any future calls to +yardoc+\n"
"so as to process only the files which have changed since the last call."
msgstr ""
"Yardocがソースディレクトリを解析する時、プロジェクトのルートで +.yardoc+ ディ"
"レクトリを作成する。\n"
"(デフォルトで、 +-b+ と共に上書きする)\n"
"このディレクトリは、\n"
"全てのソースの生のオブジェクトデータ用に整理されたダンプを含んでいるので、\n"
"後で様々なコマンド用(+stats+, +graph+ 等)にアクセスできる。\n"
"このディレクトリは、いつか +yardoc+ を呼び出す為にもキャッシュとして利用す"
"る。\n"
"最後の呼び出しから変更した所のファイルだけ処理する為に。"

# YARD::CLI::Yardoc
#: ../lib/yard/cli/yardoc.rb:133
msgid ""
"When Yardoc uses the cache in subsequent calls to +yardoc+, methods\n"
"or classes that have been deleted from source since the last parsing\n"
"will not be erased from the cache (YARD never deletes objects). In such\n"
"a case, you should wipe the cache and do a clean parsing of the source "
"tree.\n"
"You can do this by deleting the +.yardoc+ directory manually, or running\n"
"Yardoc without +--use-cache+ (+-c+)."
msgstr ""
"Yardocが +yardoc+ 呼び出しに続くキャッシュを使う時、\n"
"最後に解析しているのでソースから削除されているメソッドやクラスは、\n"
"キャッシュから削除されない。(YARDはオブジェクトを決して削除しない)\n"
"このような場合、あなたは、キャッシュを一掃し、クリーンなソースツリーの解析に"
"するべきである。\n"
"+.yardoc+ ディレクトリを手動で削除する事に上記の事ができる。\n"
"又は、yardoc の +--use-cache+ (+-c+)無しで起動する。"

# @see
#: ../lib/yard/cli/yardoc.rb:141 ../lib/yard/rake/yardoc_task.rb:38
msgid "tag|see|Verifier"
msgstr ""

# YARD::CLI::Yardoc::DEFAULT_YARDOPTS_FILE
#: ../lib/yard/cli/yardoc.rb:143
msgid "The configuration filename to load extra options from"
msgstr "追加のオプションをロードする設定ファイル名"

# @see
#: ../lib/yard/cli/yardoc.rb:147 ../lib/yard/code_objects/base.rb:463
msgid "tag|see|Templates::Engine#render"
msgstr ""

# @return [Hash]
#: ../lib/yard/cli/yardoc.rb:147
msgid "the hash of options passed to the template."
msgstr "テンプレートに解析された、optionsのハッシュ"

# @return [Array<String>]
#: ../lib/yard/cli/yardoc.rb:150
msgid "list of Ruby source files to process"
msgstr "処理する為のRubyソースファイルのリスト"

# @since
#: ../lib/yard/cli/yardoc.rb:154 ../lib/yard/code_objects/base.rb:430
#: ../lib/yard/code_objects/method_object.rb:91
#: ../lib/yard/code_objects/method_object.rb:98
#: ../lib/yard/code_objects/method_object.rb:104
#: ../lib/yard/core_ext/file.rb:62 ../lib/yard/parser/source_parser.rb:469
#: ../lib/yard/templates/helpers/html_helper.rb:430
#: ../lib/yard/templates/helpers/html_helper.rb:542
msgid "0.5.3"
msgstr ""

# @return [Array<String>]
#: ../lib/yard/cli/yardoc.rb:154
msgid "list of excluded paths (regexp matches)"
msgstr "除外されたパス(正規表現にマッチする)のリスト"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:159
msgid ""
"whether to use the existing yardoc db if the\n"
".yardoc already exists. Also makes use of file checksums to\n"
"parse only changed files."
msgstr ""
".yardocが既に存在する場合、既存のyardoc dbを利用するかどうか。\n"
"従って、変更されたファイルだけ解析する為にファイルチェックサムを活用する。"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:162
msgid "whether to parse options from .yardopts"
msgstr ".yardoptsから、オプションを解析するかどうか"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:165
msgid "whether to parse options from .document"
msgstr ".documentからオプションを解析するかどうか"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:168
msgid "whether objects should be serialized to .yardoc db"
msgstr "オブジェクトが.yardoc dbにシリアライズされるかどうか"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:171
msgid "whether to generate output"
msgstr "出力を生成するかどうか"

# @since
#: ../lib/yard/cli/yardoc.rb:175 ../lib/yard/cli/yardoc.rb:402
#: ../lib/yard/handlers/ruby/legacy/class_condition_handler.rb:28
#: ../lib/yard/handlers/ruby/legacy/class_condition_handler.rb:67
#: ../lib/yard/handlers/ruby/legacy/class_condition_handler.rb:72
#: ../lib/yard/templates/helpers/base_helper.rb:149
msgid "0.5.5"
msgstr ""

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:175
msgid "whether to print a list of objects"
msgstr "オブジェクトのリストをプリントするかどうか"

# YARD::CLI::Yardoc#options_file
# YARD::CLI::Yardoc#options_file=
#: ../lib/yard/cli/yardoc.rb:178
msgid "The options file name (defaults to {DEFAULT_YARDOPTS_FILE})"
msgstr "ファイル名のオプション(デフォルトでは{DEFAULT_YARDOPTS_FILE}になる)"

# @return [String]
#: ../lib/yard/cli/yardoc.rb:179
msgid "the filename to load extra options from"
msgstr "追加のオプションをロードする為のファイル名"

# YARD::CLI::Yardoc#visibilities
# YARD::CLI::Yardoc#visibilities=
#: ../lib/yard/cli/yardoc.rb:182
msgid "Keep track of which visibilities are to be shown"
msgstr "visibilitiesで示されるその中で手順を維持する。"

# @since
#: ../lib/yard/cli/yardoc.rb:184 ../lib/yard/cli/yardoc.rb:281
#: ../lib/yard/cli/yardoc.rb:476 ../lib/yard/cli/yri.rb:74
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:133
#: ../lib/yard/parser/base.rb:51
#: ../lib/yard/parser/ruby/legacy/ruby_parser.rb:26
#: ../lib/yard/parser/source_parser.rb:150
#: ../lib/yard/parser/source_parser.rb:152
#: ../lib/yard/parser/source_parser.rb:158
#: ../lib/yard/parser/source_parser.rb:160
#: ../lib/yard/parser/source_parser.rb:168
#: ../lib/yard/parser/source_parser.rb:512 ../lib/yard/verifier.rb:36
#: ../lib/yard/verifier.rb:57
msgid "0.5.6"
msgstr ""

# @return [Array<Symbol>]
#: ../lib/yard/cli/yardoc.rb:184
msgid "a list of visibilities"
msgstr "visibilitiesのリスト"

# YARD::CLI::Yardoc#visibilities
# YARD::CLI::Yardoc#visibilities=
#: ../lib/yard/cli/yardoc.rb:187
msgid "Keep track of which APIs are to be shown"
msgstr "そのAPIが表示される経過を追う"

# @since
#: ../lib/yard/cli/yardoc.rb:189 ../lib/yard/cli/yardoc.rb:484
#: ../lib/yard/i18n/message.rb:48 ../lib/yard/i18n/messages.rb:52
#: ../lib/yard/i18n/pot_generator.rb:69
msgid "0.8.1"
msgstr ""

# @return [Array<String>]
#: ../lib/yard/cli/yardoc.rb:189
msgid "a list of APIs"
msgstr "APIのリスト"

# @return [Array<Symbol>]
#: ../lib/yard/cli/yardoc.rb:193
msgid "a list of tags to hide from templates"
msgstr "テンプレートから隠すタグのリスト"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:197
msgid "whether to print statistics after parsing"
msgstr "解析の後で統計値をプリントするかどうか"

# @return [Array<String>]
#: ../lib/yard/cli/yardoc.rb:201
msgid "a list of assets to copy after generation"
msgstr "生成の後でコピーする資産のリスト"

# @since
#: ../lib/yard/cli/yardoc.rb:205 ../lib/yard/docstring.rb:138
#: ../lib/yard/docstring.rb:186 ../lib/yard/docstring.rb:263
#: ../lib/yard/docstring.rb:272 ../lib/yard/parser/source_parser.rb:68
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
#: ../lib/yard/parser/source_parser.rb:292
#: ../lib/yard/parser/source_parser.rb:321
#: ../lib/yard/parser/source_parser.rb:328
#: ../lib/yard/parser/source_parser.rb:335
#: ../lib/yard/parser/source_parser.rb:342
#: ../lib/yard/parser/source_parser.rb:349
#: ../lib/yard/parser/source_parser.rb:393
#: ../lib/yard/parser/source_parser.rb:397 ../lib/yard/tags/directives.rb:318
#: ../lib/yard/tags/directives.rb:393 ../lib/yard/tags/directives.rb:489
#: ../lib/yard/tags/directives.rb:553 ../lib/yard/tags/directives.rb:583
#: ../lib/yard/templates/helpers/base_helper.rb:110
#: ../lib/yard/templates/helpers/html_helper.rb:134
msgid "0.7.0"
msgstr ""

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:205
msgid "whether markup option was specified"
msgstr "マークアップオプションが指定されたかどうか"

# YARD::CLI::Yardoc#initialize
#: ../lib/yard/cli/yardoc.rb:208
msgid "Creates a new instance of the commandline utility"
msgstr "コマンドラインユーティリティの新しいインスタンスを作成する。"

# @return [Yardoc]
#: ../lib/yard/cli/yardoc.rb:208
msgid "a new instance of Yardoc"
msgstr "Yardocの新しいインスタンス"

# @param [Array<String>] args
#: ../lib/yard/cli/yardoc.rb:243
msgid ""
"the list of arguments. If the list only\n"
"contains a single nil value, skip calling of {#parse_arguments}"
msgstr ""
"引数のリスト。リストがnilだけの場合、\n"
"{#parse_arguments}メソッドを呼び出しスキップする。"

# YARD::CLI::Yardoc#parse_arguments
#: ../lib/yard/cli/yardoc.rb:278
msgid "Parses commandline arguments"
msgstr "コマンドライン引数を解析する"

# @return [Boolean]
#: ../lib/yard/cli/yardoc.rb:281
msgid "whether or not arguments are valid"
msgstr "引数が有効かどうか"

# YARD::CLI::Yardoc#all_objects
#: ../lib/yard/cli/yardoc.rb:317
msgid ""
"The list of all objects to process. Override this method to change\n"
"which objects YARD should generate documentation for."
msgstr ""
"処理する上での全てのオブジェクトのリスト。\n"
"変更するたびに、このメソッドは上書きするので、\n"
"YARDのオブジェクトは、ドキュメントを生成するべきである。"

# @deprecated
#: ../lib/yard/cli/yardoc.rb:321
msgid "To hide methods use the +@private+ tag instead."
msgstr "メソッドを隠すには、代わりに、 +@private+ タグを使う"

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/cli/yardoc.rb:321
msgid "a list of code objects to process"
msgstr "処理する為のコードオブジェクトのリスト"

# YARD::CLI::Yardoc#yardopts
#: ../lib/yard/cli/yardoc.rb:326
msgid "Parses the .yardopts file for default yard options"
msgstr "デフォルトのyardオプション用に.yardoptsファイルを解析する。"

# @return [Array<String>]
#: ../lib/yard/cli/yardoc.rb:327
msgid "an array of options parsed from .yardopts"
msgstr ".yardoptsから解析されたオプションの配列"

# YARD::CLI::Yardoc#run_generate
#: ../lib/yard/cli/yardoc.rb:337
msgid "Generates output for objects"
msgstr "オブジェクト用の出力を生成する"

# @since
#: ../lib/yard/cli/yardoc.rb:340 ../lib/yard/cli/yri.rb:14
#: ../lib/yard/cli/yri.rb:180 ../lib/yard/registry.rb:132
#: ../lib/yard/registry.rb:147 ../lib/yard/registry_store.rb:130
msgid "0.5.1"
msgstr ""

# @param [Hash, nil] checksums
#: ../lib/yard/cli/yardoc.rb:340
msgid "if supplied, a list of checksums for files."
msgstr "提供する場合は、ファイルの為のチェックサムのリスト"

# @param [Hash, nil]
#: ../lib/yard/cli/yardoc.rb:340
msgid "tag|param|checksums"
msgstr ""

# YARD::CLI::Yardoc#verify_markup_options
#: ../lib/yard/cli/yardoc.rb:361
msgid ""
"Verifies that the markup options are valid before parsing any code.\n"
"Failing early is better than failing late."
msgstr ""
"任意のコードを解析する前に、有効なマークアップオプションを認証する。\n"
"(早期に失敗が分かるほうが、後で失敗するよりいいので)"

# YARD::CLI::Yardoc#copy_assets
#: ../lib/yard/cli/yardoc.rb:386
msgid "Copies any assets to the output directory"
msgstr "出力ディレクトリに任意の資産をコピーする。"

# YARD::CLI::Yardoc#print_list
#: ../lib/yard/cli/yardoc.rb:400
msgid "Prints a list of all objects"
msgstr "全てのオブジェクトのリストをプリントする"

# YARD::CLI::Yardoc#parse_yardopts_options
#: ../lib/yard/cli/yardoc.rb:411
msgid "Parses out the yardopts/document options"
msgstr "yardopts/documentオプションの出力を解析する"

# YARD::CLI::Yardoc#support_rdoc_document_file!
#: ../lib/yard/cli/yardoc.rb:426
msgid "Reads a .document file in the directory to get source file globs"
msgstr ""
"ソースファイルのglobを取得する為にディレクトリの中の.documentファイルをロード"
"する"

# @return [Array<String>]
#: ../lib/yard/cli/yardoc.rb:427
msgid "an array of files parsed from .document"
msgstr ".documentから解析されたファイルの配列"

# YARD::CLI::Yardoc#add_extra_files
#: ../lib/yard/cli/yardoc.rb:435
msgid "Adds a set of extra documentation files to be processed"
msgstr "処理される追加のドキュメントファイルのグループを追加する"

# @param [Array<String>]
# @param [String, Array]
#: ../lib/yard/cli/yardoc.rb:436 ../lib/yard/cli/yardoc.rb:456
#: ../lib/yard/i18n/pot_generator.rb:102
#: ../lib/yard/parser/source_parser.rb:32
#: ../lib/yard/parser/source_parser.rb:361 ../lib/yard/registry.rb:97
msgid "tag|param|files"
msgstr ""

# @param [Array<String>] files
#: ../lib/yard/cli/yardoc.rb:436
msgid "the set of documentation files"
msgstr "ドキュメントファイルのグループ"

# YARD::CLI::Yardoc#parse_files
#: ../lib/yard/cli/yardoc.rb:448
msgid ""
"Parses the file arguments into Ruby files and extra files, which are\n"
"separated by a '-' element."
msgstr ""
"Rubyのファイルと追加のファイルをfilesの引数として解析する。\n"
"それは、'-'要素によって区切られる。"

# @example Parses a set of Ruby files with a separator and extra files
#: ../lib/yard/cli/yardoc.rb:456
msgid "parse_files %w(file1 file2 - extrafile1 extrafile2)"
msgstr ""

# @example Parses a set of Ruby source files
#: ../lib/yard/cli/yardoc.rb:456
msgid "parse_files %w(file1 file2 file3)"
msgstr ""

# @example
#: ../lib/yard/cli/yardoc.rb:456
msgid "tag|example|Parses a set of Ruby files with a separator and extra files"
msgstr "Rubyのファイルと区切りを用いた追加のファイルのグループを解析する"

# @example
#: ../lib/yard/cli/yardoc.rb:456
msgid "tag|example|Parses a set of Ruby source files"
msgstr "Rubyソースファイルのグループを解析する"

# @param [Array<String>] files
#: ../lib/yard/cli/yardoc.rb:456 ../lib/yard/parser/source_parser.rb:32
msgid "the list of files to parse"
msgstr "解析するファイルのリスト"

# YARD::CLI::Yardoc#add_visibility_verifier
#: ../lib/yard/cli/yardoc.rb:474
msgid "Adds verifier rule for visibilities"
msgstr "visibilities用に認証ルールを追加する"

# YARD::CLI::Yardoc#add_visibility_verifier
#: ../lib/yard/cli/yardoc.rb:482
msgid "Adds verifier rule for APIs"
msgstr "API用に認証ルールを追加する"

# YARD::CLI::Yardoc#run_verifier
# YARD::Templates::Helpers::BaseHelper#run_verifier
#: ../lib/yard/cli/yardoc.rb:494
#: ../lib/yard/templates/helpers/base_helper.rb:24
msgid ""
"Runs a list of objects against the {Verifier} object passed into the\n"
"template and returns the subset of verified objects."
msgstr ""
"テンプレートへ渡された{Verifier}オブジェクトに対してオブジェクトのリストを起"
"動する。\n"
"そして、認証されたオブジェクトのサブセットを返す。"

# YARD::CLI::Yardoc#general_options
#: ../lib/yard/cli/yardoc.rb:532
msgid "Adds general options"
msgstr "全体的なオプションを追加する。"

# YARD::CLI::Yardoc#yardopts_options
#: ../lib/yard/cli/yardoc.rb:573
msgid "Adds --[no-]yardopts / --[no-]document"
msgstr ""

# @since
#: ../lib/yard/cli/yardoc.rb:592
msgid "0.2.1"
msgstr ""

# YARD::CLI::Yardoc#output_options
#: ../lib/yard/cli/yardoc.rb:592
msgid "Adds output options"
msgstr "オプションの出力を追加する。"

# YARD::CLI::Yardoc#tag_options
#: ../lib/yard/cli/yardoc.rb:741
msgid "Adds tag options"
msgstr "タグのオプションを追加する。"

# YARD::CLI::YRI
#: ../lib/yard/cli/yri.rb:6
msgid "A tool to view documentation in the console like `ri`"
msgstr "`ri`のようなコンソールでドキュメントを調べる為のツール"

# YARD::CLI::YRI::CACHE_FILE
#: ../lib/yard/cli/yri.rb:8
msgid ""
"The location in {YARD::CONFIG_DIR} where the YRI cache file is loaded\n"
"from."
msgstr "YRIキャッシュファイルがロードされる、{YARD::CONFIG_DIR}の中の場所"

# YARD::CLI::YRI::SEARCH_PATHS_FILE
#: ../lib/yard/cli/yri.rb:12
msgid ""
"A file containing all paths, delimited by newlines, to search for\n"
"yardoc databases."
msgstr ""
"ファイルは、改行によって区切られたyardocデータベース用の検索する為の\n"
"全てのパスを含んでいる。"

# YARD::CLI::YRI::DEFAULT_SEARCH_PATHS
#: ../lib/yard/cli/yri.rb:17
msgid ""
"Default search paths that should be loaded dynamically into YRI. These "
"paths\n"
"take precedence over all other paths ({SEARCH_PATHS_FILE} and RubyGems\n"
"paths). To add a path, call:"
msgstr ""
"デフォルトでは、YRIへ動的にロードされるべきパスを検索する。\n"
"これらのパスは、他のパス全てより優先して取得する({SEARCH_PATHS_FILE}と"
"RubyGemsパス)。\n"
"パスを追加するには、次のように呼び出す。"

# YARD::CLI::YRI::DEFAULT_SEARCH_PATHS
#: ../lib/yard/cli/yri.rb:21
msgid "  DEFAULT_SEARCH_PATHS.push(\"/path/to/.yardoc\")"
msgstr ""

# @return [Array<String>]
#: ../lib/yard/cli/yri.rb:24
msgid "a list of extra search paths"
msgstr "追加の検索パスのリスト"

# @return [YRI]
#: ../lib/yard/cli/yri.rb:30
msgid "a new instance of YRI"
msgstr "YRIの新しいインスタンス"

# @example 
#: ../lib/yard/cli/yri.rb:49
msgid "YRI.new.run('String#reverse')"
msgstr ""

# YARD::CLI::YRI#print_usage
#: ../lib/yard/cli/yri.rb:72
msgid "Prints the command usage"
msgstr "コマンドの使用法をプリントする。"

# YARD::CLI::YRI#cache_object
#: ../lib/yard/cli/yri.rb:80
msgid ""
"Caches the .yardoc file where an object can be found in the {CACHE_FILE}"
msgstr ""
"オブジェクトが{CACHE_FILE}の中を見つけられる場合、\n"
".yardocファイルをキャッシュする。"

# @param [CodeObjects::Base, nil]
# @param [CodeObjects::Base]
# @param [Base, Proxy, String, Symbol, nil]
# @param [Proxy, CodeObjects::Base]
# @param [CodeObjects::Base, String]
# @param [CodeObjects::Base, CodeObjects::ExtraFileObject, String]
#: ../lib/yard/cli/yri.rb:94 ../lib/yard/code_objects/class_object.rb:122
#: ../lib/yard/docstring.rb:74 ../lib/yard/docstring.rb:99
#: ../lib/yard/docstring_parser.rb:106 ../lib/yard/handlers/base.rb:411
#: ../lib/yard/handlers/base.rb:424 ../lib/yard/handlers/base.rb:433
#: ../lib/yard/handlers/base.rb:456 ../lib/yard/handlers/base.rb:470
#: ../lib/yard/handlers/base.rb:483 ../lib/yard/handlers/base.rb:495
#: ../lib/yard/handlers/base.rb:506 ../lib/yard/handlers/base.rb:520
#: ../lib/yard/handlers/base.rb:544 ../lib/yard/registry.rb:174
#: ../lib/yard/registry.rb:182 ../lib/yard/serializers/base.rb:41
#: ../lib/yard/serializers/base.rb:50 ../lib/yard/serializers/base.rb:61
#: ../lib/yard/serializers/file_system_serializer.rb:48
#: ../lib/yard/serializers/file_system_serializer.rb:69
#: ../lib/yard/server/commands/base.rb:138 ../lib/yard/templates/engine.rb:114
#: ../lib/yard/templates/helpers/base_helper.rb:102
#: ../lib/yard/templates/helpers/base_helper.rb:119
#: ../lib/yard/templates/helpers/base_helper.rb:179
#: ../lib/yard/templates/helpers/base_helper.rb:193
#: ../lib/yard/templates/helpers/html_helper.rb:288
#: ../lib/yard/templates/helpers/uml_helper.rb:8
#: ../lib/yard/templates/helpers/uml_helper.rb:19 ../lib/yard/verifier.rb:75
msgid "tag|param|object"
msgstr ""

# @return [String]
#: ../lib/yard/cli/yri.rb:94
msgid "the formatted output for an object."
msgstr "オブジェクト用にフォーマットされた出力"

# @param [CodeObjects::Base] object
#: ../lib/yard/cli/yri.rb:94
msgid "the object to print."
msgstr "プリントする為のオブジェクト"

# YARD::CLI::YRI#find_object
#: ../lib/yard/cli/yri.rb:104
msgid ""
"Locates an object by name starting in the cached paths and then\n"
"searching through any search paths."
msgstr ""
"キャッシュされたパスで始まる名前のオブジェクトを示し、\n"
"その時、任意の検索パスを通して検索する。"

# @return [CodeObjects::Base]
#: ../lib/yard/cli/yri.rb:109
msgid "an object if found"
msgstr "見つかった場合は、オブジェクト"

# @return [nil]
#: ../lib/yard/cli/yri.rb:109 ../lib/yard/registry.rb:235
msgid "if no object is found"
msgstr "オブジェクトが見つからない場合"

# @param [String] name
#: ../lib/yard/cli/yri.rb:109
msgid "the full name of the object"
msgstr "オブジェクトのフルネーム"

# YARD::CLI::YRI#try_load_object
#: ../lib/yard/cli/yri.rb:134
msgid ""
"Tries to load the object with name. If successful, caches the object\n"
"with the cache_path"
msgstr ""

# @param [String]
# @param [Array<String, Symbol>]
# @param [String, :root]
#: ../lib/yard/cli/yri.rb:141
msgid "tag|param|cache_path"
msgstr ""

# @param [String] cache_path
#: ../lib/yard/cli/yri.rb:141
msgid ""
"the location of the yardoc\n"
"db containing the object to cache for future lookups.\n"
"No caching is done if this is nil."
msgstr ""

# @return [CodeObjects::Base]
#: ../lib/yard/cli/yri.rb:141
msgid "the object path"
msgstr "オブジェクトパス"

# YARD::CLI::YRI#load_cache
#: ../lib/yard/cli/yri.rb:151
msgid "Loads {CACHE_FILE}"
msgstr "{CACHE_FILE}をロードする"

# YARD::CLI::YRI#add_gem_paths
#: ../lib/yard/cli/yri.rb:161
msgid "Adds all RubyGems yardoc files to search paths"
msgstr "パスを検索する為に全てのRubyGemsyardocファイルを追加する\n"

# YARD::CLI::YRI#add_default_paths
#: ../lib/yard/cli/yri.rb:179
msgid "Adds paths in {SEARCH_PATHS_FILE}"
msgstr "{SEARCH_PATHS_FILE}の中のパスを追加する。"

# YARD::CodeObjects::CodeObjectList
#: ../lib/yard/code_objects/base.rb:4
msgid ""
"A list of code objects. This array acts like a set (no unique items)\n"
"but also disallows any {Proxy} objects from being added."
msgstr ""
"コードオブジェクトのリスト、この配列はグループ(固有の物ではない)のように振る"
"舞う。\n"
"しかしながら、追加される任意の{Proxy}オブジェクトを拒否する。"

# YARD::CodeObjects::CodeObjectList#initialize
#: ../lib/yard/code_objects/base.rb:7
msgid "Creates a new object list associated with a namespace"
msgstr "namespaceに関連付けられた新しいオブジェクトのリストを作成する。"

# @param [NamespaceObject]
#: ../lib/yard/code_objects/base.rb:10
msgid "tag|param|owner"
msgstr ""

# @param [NamespaceObject] owner
#: ../lib/yard/code_objects/base.rb:10
msgid "the namespace the list should be associated with"
msgstr "リストで関連付けられるべき、namespace"

# YARD::CodeObjects::CodeObjectList#push
# YARD::CodeObjects::CodeObjectList#<<
#: ../lib/yard/code_objects/base.rb:15 ../lib/yard/code_objects/base.rb:28
msgid "Adds a new value to the list"
msgstr "リストに新しく値を追加する"

# @param [Base] value
#: ../lib/yard/code_objects/base.rb:18
msgid "a code object to add"
msgstr "追加するコードオブジェクト"

# @return [CodeObjectList]
# @return [Proxy]
# @return [SymbolHash]
#: ../lib/yard/code_objects/base.rb:18 ../lib/yard/code_objects/proxy.rb:28
#: ../lib/yard/core_ext/symbol_hash.rb:65
msgid "self"
msgstr ""

# @param
# @param [Base]
# @param [Object]
# @param [String]
# @param [CodeObjects::Base]
#: ../lib/yard/code_objects/base.rb:18 ../lib/yard/code_objects/base.rb:325
#: ../lib/yard/code_objects/extra_file_object.rb:7
#: ../lib/yard/code_objects/extra_file_object.rb:8
#: ../lib/yard/code_objects/extra_file_object.rb:9
#: ../lib/yard/code_objects/extra_file_object.rb:10
#: ../lib/yard/code_objects/namespace_object.rb:6
#: ../lib/yard/code_objects/namespace_object.rb:7
#: ../lib/yard/code_objects/namespace_object.rb:8
#: ../lib/yard/core_ext/insertion.rb:13 ../lib/yard/core_ext/symbol_hash.rb:41
#: ../lib/yard/handlers/base.rb:311 ../lib/yard/handlers/base.rb:314
#: ../lib/yard/handlers/base.rb:317 ../lib/yard/handlers/base.rb:320
#: ../lib/yard/handlers/base.rb:333 ../lib/yard/handlers/base.rb:335
#: ../lib/yard/handlers/base.rb:337 ../lib/yard/handlers/base.rb:339
#: ../lib/yard/logging.rb:20 ../lib/yard/logging.rb:30
#: ../lib/yard/options.rb:99 ../lib/yard/parser/c/statement.rb:5
#: ../lib/yard/parser/c/statement.rb:6 ../lib/yard/parser/c/statement.rb:7
#: ../lib/yard/parser/c/statement.rb:13 ../lib/yard/parser/c/statement.rb:39
#: ../lib/yard/parser/c/statement.rb:43 ../lib/yard/parser/c/statement.rb:44
#: ../lib/yard/parser/c/statement.rb:45 ../lib/yard/parser/c/statement.rb:51
#: ../lib/yard/parser/c/statement.rb:52 ../lib/yard/parser/c/statement.rb:53
#: ../lib/yard/parser/ruby/ast_node.rb:41
#: ../lib/yard/parser/ruby/ast_node.rb:42
#: ../lib/yard/parser/ruby/ast_node.rb:48
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:485
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:486
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:487
#: ../lib/yard/parser/ruby/legacy/statement.rb:5
#: ../lib/yard/parser/ruby/legacy/statement.rb:11
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:6
#: ../lib/yard/registry_store.rb:52 ../lib/yard/tags/option_tag.rb:4
#: ../lib/yard/tags/ref_tag.rb:4 ../lib/yard/tags/ref_tag_list.rb:4
#: ../lib/yard/templates/helpers/base_helper.rb:4
#: ../lib/yard/templates/helpers/base_helper.rb:206
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:23
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:68
#: ../lib/yard/templates/template.rb:6 ../lib/yard/templates/template.rb:59
msgid "tag|param|value"
msgstr ""

# YARD::CodeObjects::NSEP
#: ../lib/yard/code_objects/base.rb:32
msgid "Namespace separator"
msgstr "Namespace separator(ネームスペース区切り)"

# YARD::CodeObjects::NSEPQ
#: ../lib/yard/code_objects/base.rb:35
msgid "Regex-quoted namespace separator"
msgstr ""
"Regex-quoted namespace separator(クオートされた正規表現ネームスペース区切り)"

# YARD::CodeObjects::ISEP
#: ../lib/yard/code_objects/base.rb:38
msgid "Instance method separator"
msgstr "Instance method separator(インスタンスメソッドの区切り)"

# YARD::CodeObjects::ISEPQ
#: ../lib/yard/code_objects/base.rb:41
msgid "Regex-quoted instance method separator"
msgstr ""
"Regex-quoted instance method separator(正規表現でクオートされたインスタンスメ"
"ソッド区切り)"

# YARD::CodeObjects::CSEP
#: ../lib/yard/code_objects/base.rb:44
msgid "Class method separator"
msgstr "Class method separator(クラスメソッド区切り)"

# YARD::CodeObjects::CSEPQ
#: ../lib/yard/code_objects/base.rb:47
msgid "Regex-quoted class method separator"
msgstr ""
"Regex-quoted class method separator(正規表現でクオートされたクラスメソッド区"
"切り)"

# YARD::CodeObjects::CONSTANTMATCH
#: ../lib/yard/code_objects/base.rb:50
msgid "Regular expression to match constant name"
msgstr "Regular expression to match constant name(定数名にマッチする正規表現)"

# YARD::CodeObjects::NAMESPACEMATCH
#: ../lib/yard/code_objects/base.rb:53
msgid "Regular expression to match namespaces (const A or complex path A::B)"
msgstr "namespaceにマッチする正規表現(const A or complex path A::B)"

# YARD::CodeObjects::METHODNAMEMATCH
#: ../lib/yard/code_objects/base.rb:56
msgid "Regular expression to match a method name"
msgstr "メソッド名にマッチする正規表現"

# YARD::CodeObjects::METHODMATCH
#: ../lib/yard/code_objects/base.rb:59
msgid ""
"Regular expression to match a fully qualified method def (self.foo, Class."
"foo)."
msgstr "全てに有効なメソッド定義(self.foo Class.fooなど)にマッチする正規表現"

# YARD::CodeObjects::BUILTIN_EXCEPTIONS
#: ../lib/yard/code_objects/base.rb:62
msgid "All builtin Ruby exception classes for inheritance tree."
msgstr "継承ツリー用の全ての組み込みRuby例外クラス"

# YARD::CodeObjects::BUILTIN_CLASSES
#: ../lib/yard/code_objects/base.rb:68
msgid "All builtin Ruby classes for inheritance tree."
msgstr "継承ツリー用の全てのRubyクラス"

# @note
#: ../lib/yard/code_objects/base.rb:69
msgid "MatchingData is a 1.8.x legacy class"
msgstr "マッチデータが1.8以降のレガシーケースの場合\n"

# YARD::CodeObjects::BUILTIN_MODULES
#: ../lib/yard/code_objects/base.rb:74
msgid "All builtin Ruby modules for mixin handling."
msgstr "mixin操作用の全てのRuby組み込みモジュール"

# YARD::CodeObjects::BUILTIN_ALL
#: ../lib/yard/code_objects/base.rb:77
msgid "All builtin Ruby classes and modules."
msgstr "全ての組み込みRubyクラスやモジュール"

# YARD::CodeObjects::BUILTIN_EXCEPTIONS_HASH
#: ../lib/yard/code_objects/base.rb:80
msgid ""
"Hash of {BUILTIN_EXCEPTIONS} as keys and true as value (for O(1) lookups)"
msgstr "{BUILTIN_EXCEPTIONS}のキーと,値がtrueのハッシュ,(for O(1) lookups)"

# YARD::CodeObjects::Base
#: ../lib/yard/code_objects/base.rb:83
msgid ""
"+Base+ is the superclass of all code objects recognized by YARD. A code\n"
"object is any entity in the Ruby language (class, method, module). A\n"
"DSL might subclass +Base+ to create a new custom object representing\n"
"a new entity type."
msgstr ""
"+Base+ は、YARDによって表される全てのコードオブジェクトのスーパークラスとな"
"る。\n"
"コードオブジェクトは、Ruby言語の中の何らかの(class,method,module)構成要素とな"
"る。\n"
"DSLは新しい構成要素の型で表されるカスタムオブジェクトを作成する為に、\n"
"+Base+ をサブクラスとするかもしれない。\n"

# YARD::CodeObjects::Base
#: ../lib/yard/code_objects/base.rb:88
msgid ""
"== Registry Integration\n"
"Any created object associated with a namespace is immediately registered\n"
"with the registry. This allows the Registry to act as an identity map\n"
"to ensure that no object is represented by more than one Ruby object\n"
"in memory. A unique {#path} is essential for this identity map to work\n"
"correctly."
msgstr ""
"== レジストリーの統合\n"
"namespaceと共に関連付けられ作成される任意のオブジェクトは、レジストリーと共に直ぐに記録される。\n"
"これは、メモリの中で一つ以上のRubyオブジェクトによって表される事を保証し、\n"
"レジストリーが独自のマップの様に振る舞う事を受け入れる。\n"
"固有の{#path}メソッドは、この独自のマップを正常に機能させる為に必須のものである。"

# YARD::CodeObjects::Base
#: ../lib/yard/code_objects/base.rb:95
msgid ""
"== Custom Attributes\n"
"Code objects allow arbitrary custom attributes to be set using the\n"
"{#[]=} assignment method."
msgstr ""

# YARD::CodeObjects::Base
#: ../lib/yard/code_objects/base.rb:99
msgid ""
"== Namespaces\n"
"There is a special type of object called a \"namespace\". These are "
"subclasses\n"
"of the {NamespaceObject} and represent Ruby entities that can have\n"
"objects defined within them. Classically these are modules and classes,\n"
"though a DSL might create a custom {NamespaceObject} to describe a\n"
"specific set of objects."
msgstr ""
"== Namespaces\n"
"\"namespace\"に呼び出されるオブジェクトの特別な型がある。\n"
"これらは{NamespaceObject}をサブクラス化し、\n"
"それらの中で定義されるオブジェクトが持つ事が出来るRubyの構成要素を表す。\n"
"オーソドックスなこれらのモジュールやクラスは、\n"
"DSLが特定のオブジェクトのグループを説明する為に、\n"
"カスタム{NamespaceObject}を作成するかもしれない。\n"

# @abstract
#: ../lib/yard/code_objects/base.rb:111
msgid ""
"This class should not be used directly. Instead, create a\n"
"subclass that implements {#path}, {#sep} or {#type}."
msgstr ""
"このクラスは、直接利用するべきではない。\n"
"代わりに、{#path}, {#sep} , {#type}メソッドを実装するサブクラスを作成する。"

# @see
#: ../lib/yard/code_objects/base.rb:111 ../lib/yard/code_objects/base.rb:312
msgid "tag|see|#[]="
msgstr ""

# @see
#: ../lib/yard/code_objects/base.rb:111
msgid "tag|see|#path"
msgstr ""

# @see
#: ../lib/yard/code_objects/base.rb:111
msgid "tag|see|NamespaceObject"
msgstr ""

# @see
#: ../lib/yard/code_objects/base.rb:111 ../lib/yard/registry_store.rb:8
msgid "tag|see|Registry"
msgstr ""

# YARD::CodeObjects::Base#files
#: ../lib/yard/code_objects/base.rb:113
msgid "The files the object was defined in. To add a file, use {#add_file}."
msgstr ""
"中で定義されたオブジェクトから成るファイル、\n"
"ファイルを追加するには、{#add_file}メソッドを使う。"

# @return [Array<String>]
#: ../lib/yard/code_objects/base.rb:115 ../lib/yard/rake/yardoc_task.rb:24
msgid "a list of files"
msgstr "ファイルのリスト"

# @see
#: ../lib/yard/code_objects/base.rb:115
msgid "tag|see|#add_file"
msgstr ""

# YARD::CodeObjects::Base#namespace
# YARD::CodeObjects::Base#parent
#: ../lib/yard/code_objects/base.rb:118 ../lib/yard/code_objects/base.rb:496
msgid ""
"The namespace the object is defined in. If the object is in the\n"
"top level namespace, this is {Registry.root}"
msgstr ""
"中で定義されるオブジェクトから成るnamespace,オブジェクトがtop level namespace"
"の場合、\n"
"これは、{Registry.root}になる。"

# @return [NamespaceObject]
#: ../lib/yard/code_objects/base.rb:120
msgid "the namespace object"
msgstr "namespaceオブジェクト"

# YARD::CodeObjects::Base#source
#: ../lib/yard/code_objects/base.rb:123
msgid "The source code associated with the object"
msgstr "オブジェクトに関連付けられたソースコード"

# @return [String, nil]
#: ../lib/yard/code_objects/base.rb:124
msgid "source, if present, or nil"
msgstr "存在する場合はソース,そうでなけば、nil"

# YARD::CodeObjects::Base#source_type
# YARD::CodeObjects::Base#source_type=
#: ../lib/yard/code_objects/base.rb:127
msgid ""
"Language of the source code associated with the object. Defaults to\n"
"+:ruby+."
msgstr ""
"オブジェクトと共に関連付けられたソースコードの言語。\n"
"デフォルトは +:ruby+ 。"

# @return [Symbol]
#: ../lib/yard/code_objects/base.rb:130
msgid "the language type"
msgstr "言語の型"

# YARD::CodeObjects::Base#signature
# YARD::CodeObjects::Base#signature=
#: ../lib/yard/code_objects/base.rb:133
msgid ""
"The one line signature representing an object. For a method, this will\n"
"be of the form \"def meth(arguments...)\". This is usually the first\n"
"source line."
msgstr ""
"オブジェクトを一行の用法で表している。メソッド用、\n"
"これは、\"def meth(arguments...)\"のような形式になるだろう。\n"
"普通は、最初のソースの最初の行となる。"

# @return [String]
#: ../lib/yard/code_objects/base.rb:137
msgid "a line of source"
msgstr "ソースの行"

# YARD::CodeObjects::Base#docstring
#: ../lib/yard/code_objects/base.rb:140
msgid "The documentation string associated with the object"
msgstr "オブジェクトに関連付けられたドキュメント文字列"

# @return [Docstring]
#: ../lib/yard/code_objects/base.rb:141 ../lib/yard/code_objects/base.rb:367
msgid "the documentation string"
msgstr "ドキュメント文字列(docstring)"

# YARD::CodeObjects::Base#dynamic
# YARD::CodeObjects::Base#dynamic=
#: ../lib/yard/code_objects/base.rb:144
msgid "Marks whether or not the method is conditionally defined at runtime"
msgstr "メソッドが実行時に定義された条件となるか、マークする。"

# @return [Boolean]
#: ../lib/yard/code_objects/base.rb:145
msgid "true if the method is conditionally defined at runtime"
msgstr "メソッドが実行時に定義された条件となる場合、true"

# @return [String]
#: ../lib/yard/code_objects/base.rb:149
msgid "the group this object is associated with"
msgstr "このオブジェクトに関連付けられたグループ"

# YARD::CodeObjects::Base#dynamic?
#: ../lib/yard/code_objects/base.rb:152
msgid "Is the object defined conditionally at runtime?"
msgstr "オブジェクトが実行時に条件が定義されたか?"

# @see
#: ../lib/yard/code_objects/base.rb:153
msgid "tag|see|#dynamic"
msgstr ""

# @return [Symbol]
#: ../lib/yard/code_objects/base.rb:156 ../lib/yard/code_objects/base.rb:158
msgid "the visibility of an object (:public, :private, :protected)"
msgstr "オブジェクトの可視性(:public, :private, :protected)"

# YARD::CodeObjects::Base.new
#: ../lib/yard/code_objects/base.rb:162
msgid "Allocates a new code object"
msgstr "新しいコードオブジェクトを割り当てる。"

# @see
#: ../lib/yard/code_objects/base.rb:164
#: ../lib/yard/code_objects/extended_method_object.rb:21
msgid "tag|see|#initialize"
msgstr ""

# YARD::CodeObjects::Base.===
#: ../lib/yard/code_objects/base.rb:185
msgid "Compares the class with subclasses"
msgstr "サブクラスとクラスを比較する"

# @param [Object]
# @param [Base, Proxy]
# @param [Base, String]
# @param [Docstring, String]
#: ../lib/yard/code_objects/base.rb:188 ../lib/yard/code_objects/base.rb:233
#: ../lib/yard/code_objects/base.rb:292 ../lib/yard/code_objects/base.rb:430
#: ../lib/yard/docstring.rb:112 ../lib/yard/i18n/message.rb:48
#: ../lib/yard/i18n/messages.rb:44
msgid "tag|param|other"
msgstr ""

# @param [Object] other
#: ../lib/yard/code_objects/base.rb:188
msgid "the other object to compare classes with"
msgstr "クラスと比較する他のオブジェクト"

# @return [Boolean]
#: ../lib/yard/code_objects/base.rb:188
msgid "true if other is a subclass of self"
msgstr "otherが自身のサブクラスの場合、true"

# YARD::CodeObjects::Base#initialize
#: ../lib/yard/code_objects/base.rb:194
msgid "Creates a new code object"
msgstr "新しいコードオブジェクトを作成する。"

# @example Create a method in the root namespace
#: ../lib/yard/code_objects/base.rb:207
msgid "CodeObjects::Base.new(:root, '#method') # => #<yardoc method #method>"
msgstr ""

# @example Create class Z inside namespace X::Y
#: ../lib/yard/code_objects/base.rb:207
msgid ""
"CodeObjects::Base.new(P(\"X::Y\"), :Z) # or\n"
"CodeObjects::Base.new(Registry.root, \"X::Y\")"
msgstr ""

# @yield [self]
#: ../lib/yard/code_objects/base.rb:207
msgid "a block to perform any extra initialization on the object"
msgstr "オブジェクト上で任意の追加のイニシャライズを実行するblock"

# @example
#: ../lib/yard/code_objects/base.rb:207
msgid "tag|example|Create a method in the root namespace"
msgstr "root namespaceの中にメソッドを作成する"

# @example
#: ../lib/yard/code_objects/base.rb:207
msgid "tag|example|Create class Z inside namespace X::Y"
msgstr "namespace X::Yの中にZクラスを作成する。"

# @param [NamespaceObject]
# @param [CodeObjects::NamespaceObject, nil]
# @param [CodeObjects::NamespaceObject]
#: ../lib/yard/code_objects/base.rb:207
#: ../lib/yard/code_objects/method_object.rb:33 ../lib/yard/registry.rb:270
#: ../lib/yard/registry.rb:368
msgid "tag|param|namespace"
msgstr "namespace"

# @yieldparam [Base]
#: ../lib/yard/code_objects/base.rb:207
msgid "tag|yieldparam|self"
msgstr "self"

# @param [Symbol, String] name
#: ../lib/yard/code_objects/base.rb:207
msgid "the name (or complex path) of the object."
msgstr "オブジェクトの名前(又は、complex path)"

# @param [NamespaceObject] namespace
#: ../lib/yard/code_objects/base.rb:207
msgid ""
"the namespace the object belongs in,\n"
"{Registry.root} or :root should be provided if it is associated with\n"
"the top level namespace."
msgstr ""
"その中でオブジェクトの属するnamespace,\n"
"top level namespaceと共に、\n"
"{Registry.root} と :rootは、提供されるべきである。"

# @return [Base]
# @return [MacroObject]
#: ../lib/yard/code_objects/base.rb:207
#: ../lib/yard/code_objects/macro_object.rb:39
msgid "the newly created object"
msgstr "新たに作成されたオブジェクト"

# @yieldparam [Base] self
#: ../lib/yard/code_objects/base.rb:207
msgid "the newly initialized code object"
msgstr "新たにinitializeされるコードオジェクト"

# YARD::CodeObjects::Base#copy_to
#: ../lib/yard/code_objects/base.rb:228
msgid ""
"Copies all data in this object to another code object, except for\n"
"uniquely identifying information (path, namespace, name, scope)."
msgstr ""

# @return [CodeObjects::Base]
#: ../lib/yard/code_objects/base.rb:233
msgid "the object to copy data to"
msgstr "オブジェクトにデータをコピーする為のオブジェクト"

# @return [CodeObjects::RootObject]
#: ../lib/yard/code_objects/base.rb:233
msgid "the other object"
msgstr "他のオブジェクト"

# YARD::CodeObjects::Base#name
# YARD::CodeObjects::Proxy#name
#: ../lib/yard/code_objects/base.rb:243 ../lib/yard/code_objects/proxy.rb:71
msgid "The name of the object"
msgstr "オブジェクトの名前"

# @return [Symbol]
#: ../lib/yard/code_objects/base.rb:248
msgid "if prefix is false, the symbolized name"
msgstr "prefixがfalseの場合、シンボル化される名前"

# @return [String]
#: ../lib/yard/code_objects/base.rb:248
msgid ""
"if prefix is true, prefix + the name as a String.\n"
"This must be implemented by the subclass."
msgstr ""
"prefixがtrueの場合、prefix + 名前の文字列となる。\n"
"これは、サブクラスによって実装されなければならない。"

# @param [Boolean]
#: ../lib/yard/code_objects/base.rb:248
#: ../lib/yard/code_objects/method_object.rb:170
msgid "tag|param|prefix"
msgstr "prefix"

# @param [Boolean] prefix
#: ../lib/yard/code_objects/base.rb:248
msgid ""
"whether to show a prefix. Implement\n"
"this in a subclass to define how the prefix is showed."
msgstr ""
"prefixを見せるかどうか。\n"
"prefixがどのようにみせられるか定義する為に、\n"
"このサブクラスの中で実装する。"

# YARD::CodeObjects::Base#add_file
#: ../lib/yard/code_objects/base.rb:253
msgid ""
"Associates a file with a code object, optionally adding the line where it "
"was defined.\n"
"By convention, '<stdin>' should be used to associate code that comes form "
"standard input."
msgstr ""
"コードオブジェクトと共に、ファイルを関連付け、\n"
"定義された場所で任意で行を追加する。\n"
"慣習で、'<stdin>'は、標準入力形式で入って来るコードに関連付けて利用されるべき"
"である。"

# @param [Boolean]
#: ../lib/yard/code_objects/base.rb:260
msgid "tag|param|has_comments"
msgstr "has_comments"

# @param [Fixnum, nil]
#: ../lib/yard/code_objects/base.rb:260 ../lib/yard/i18n/message.rb:34
msgid "tag|param|line"
msgstr "param|line"

# @param [String] file
#: ../lib/yard/code_objects/base.rb:260
msgid "the filename ('<stdin>' for standard input)"
msgstr "ファイル名('<stdin>' は標準入力用)"

# @param [Fixnum, nil] line
#: ../lib/yard/code_objects/base.rb:260
msgid "the line number where the object lies in the file"
msgstr "ファイルの中でオブジェクトが位置する,行数"

# @param [Boolean] has_comments
#: ../lib/yard/code_objects/base.rb:260
msgid ""
"whether or not the definition has comments associated. This\n"
"will allow {#file} to return the definition where the comments were made "
"instead\n"
"of any empty definitions that might have been parsed before (module "
"namespaces for instance)."
msgstr ""
"定義が関連付けられたコメントを持っているかどうか。\n"
"これは、解析される前に(例えば、module namespace)、空の定義の代わりに任意の作"
"られたコメントで、\n"
"定義を返す為に、{#file}メソッドを受け入れる。"

# YARD::CodeObjects::Base#file
#: ../lib/yard/code_objects/base.rb:273
msgid ""
"Returns the filename the object was first parsed at, taking\n"
"definitions with docstrings first."
msgstr ""
"オブジェクトが、最初に解析された所で、\n"
"最初のdocstringと共に、定義を取ってくるファイル名を返す"

# @return [String]
#: ../lib/yard/code_objects/base.rb:276
msgid "a filename"
msgstr "ファイル名"

# YARD::CodeObjects::Base#line
#: ../lib/yard/code_objects/base.rb:281
msgid "Returns the line the object was first parsed at (or nil)"
msgstr "オブジェクトが、最初に解析された所(又は、nil)の行を返す"

# @return [nil]
#: ../lib/yard/code_objects/base.rb:284
msgid "if there is no line associated with the object"
msgstr "オブジェクトと共に関連付けられた行がない場合"

# @return [Fixnum]
#: ../lib/yard/code_objects/base.rb:284
msgid "the line where the object was first defined."
msgstr "オブジェクトが最初に定義された所の行"

# YARD::CodeObjects::Base#equal?
# YARD::CodeObjects::Base#==
# YARD::CodeObjects::Base#eql?
#: ../lib/yard/code_objects/base.rb:289 ../lib/yard/code_objects/base.rb:300
#: ../lib/yard/code_objects/base.rb:301
msgid "Tests if another object is equal to this, including a proxy"
msgstr "他のオブジェクトがBaseとイコールかProxyを含んでいるかテストする。"

# @param [Base, Proxy] other
#: ../lib/yard/code_objects/base.rb:292
msgid ""
"if other is a {Proxy}, tests if\n"
"the paths are equal"
msgstr ""
"pathがイコールの場合、\n"
"otherが{Proxy}か、テストする。\n"

# @return [Boolean]
#: ../lib/yard/code_objects/base.rb:292
msgid "whether or not the objects are considered the same"
msgstr "オブジェクトが同じものかどうか判断する"

# @return [Integer]
#: ../lib/yard/code_objects/base.rb:303 ../lib/yard/code_objects/proxy.rb:138
msgid "the object's hash value (for equality checking)"
msgstr "オブジェクトのハッシュ値(イコールかチェック用)"

# @return [nil]
#: ../lib/yard/code_objects/base.rb:306
msgid "this object does not turn into an array"
msgstr "このオブジェクトは配列にはできない"

# YARD::CodeObjects::Base#[]
#: ../lib/yard/code_objects/base.rb:309
msgid "Accesses a custom attribute on the object"
msgstr "オブジェクト上のカスタム属性にアクセスする"

# @param [#to_s]
# @param [String, Symbol]
# @param [#to_sym]
#: ../lib/yard/code_objects/base.rb:312 ../lib/yard/code_objects/base.rb:325
#: ../lib/yard/core_ext/symbol_hash.rb:41
#: ../lib/yard/core_ext/symbol_hash.rb:48
#: ../lib/yard/core_ext/symbol_hash.rb:53
#: ../lib/yard/core_ext/symbol_hash.rb:58 ../lib/yard/options.rb:79
#: ../lib/yard/options.rb:90 ../lib/yard/options.rb:99
#: ../lib/yard/options.rb:204 ../lib/yard/registry_store.rb:31
#: ../lib/yard/registry_store.rb:52 ../lib/yard/registry_store.rb:72
msgid "tag|param|key"
msgstr "key"

# @return [Object, nil]
#: ../lib/yard/code_objects/base.rb:312
msgid "the custom attribute or nil if not found."
msgstr "カスタム属性や見つからなかった場合はnilを返す"

# @param [#to_s] key
#: ../lib/yard/code_objects/base.rb:312 ../lib/yard/code_objects/base.rb:325
msgid "the name of the custom attribute"
msgstr "カスタム属性の名前"

# YARD::CodeObjects::Base#[]=
#: ../lib/yard/code_objects/base.rb:321
msgid "Sets a custom attribute on the object"
msgstr "オブジェクトにカスタム属性を設定する"

# @see
#: ../lib/yard/code_objects/base.rb:325
msgid "tag|see|#[]"
msgstr ""

# @param [Object] value
#: ../lib/yard/code_objects/base.rb:325
msgid "the value to associate"
msgstr "関連する値"

# @overload
#: ../lib/yard/code_objects/base.rb:342
msgid "tag|overload|dynamic_attr_name"
msgstr "dynamic_attr_name"

# @overload
#: ../lib/yard/code_objects/base.rb:342
msgid "tag|overload|dynamic_attr_name="
msgstr "dynamic_attr_name="

# YARD::CodeObjects::Base#source=
#: ../lib/yard/code_objects/base.rb:353
msgid "Attaches source code to a code object with an optional file location"
msgstr ""
"任意のファイルの場所と共にコードオブジェクトの為にソースコードを追加する。"

# @param [#source, String]
# @param
#: ../lib/yard/code_objects/base.rb:357 ../lib/yard/handlers/base.rb:198
#: ../lib/yard/handlers/processor.rb:149
msgid "tag|param|statement"
msgstr "statement"

# @param [#source, String] statement
#: ../lib/yard/code_objects/base.rb:357
msgid ""
"the +Parser::Statement+ holding the source code or the raw source\n"
"as a +String+ for the definition of the code object only (not the block)"
msgstr ""
"+Parser::Statement+ はソースコードや\n"
"コードオブジェクトだけの定義用に(blockではない)\n"
" +String+ のような未加工のソースを保持する。"

# YARD::CodeObjects::Base#docstring=
#: ../lib/yard/code_objects/base.rb:382
msgid ""
"Attaches a docstring to a code object by parsing the comments attached to "
"the statement\n"
"and filling the {#tags} and {#docstring} methods with the parsed information."
msgstr ""
"ステートメントに添付されたコメントを解析する事によって、\n"
"コードオブジェクトにdocstringを追加する。\n"
"そして、解析された情報と共に、{#tags}や{#docstring}メソッドを埋め込む。"

# @param [String, Array<String>, Docstring]
# @param [String]
#: ../lib/yard/code_objects/base.rb:387 ../lib/yard/docstring.rb:310
msgid "tag|param|comments"
msgstr "comments"

# @param [String, Array<String>, Docstring] comments
#: ../lib/yard/code_objects/base.rb:387
msgid ""
"the comments attached to the code object to be parsed\n"
"into a docstring and meta tags."
msgstr ""
"docstringとメタタグの中を解析する為に、コードオブジェクトに追加される,コメン"
"ト"

# YARD::CodeObjects::Base#type
#: ../lib/yard/code_objects/base.rb:402
msgid ""
"Default type is the lowercase class name without the \"Object\" suffix.\n"
"Override this method to provide a custom object type"
msgstr ""
"デフォルトの型は\"Object\"サフィックスなしの小文字のクラス名となる。\n"
"このメソッドを上書きする為にカスタムオブジェクト型を提供する。"

# @return [Symbol]
#: ../lib/yard/code_objects/base.rb:405
msgid "the type of code object this represents"
msgstr "これを表すコードオブジェクトの型"

# YARD::CodeObjects::Base#path
# YARD::CodeObjects::Base#to_s
#: ../lib/yard/code_objects/base.rb:410 ../lib/yard/code_objects/base.rb:426
msgid ""
"Represents the unique path of the object. The default implementation\n"
"joins the path of {#namespace} with {#name} via the value of {#sep}.\n"
"Custom code objects should ensure that the path is unique to the code\n"
"object by either overriding {#sep} or this method."
msgstr ""
"オブジェクトの固有のパスを表す。\n"
"デフォルトの実装は、{#sep}の値を挟んで{#namespace} と {#name}のパスを加え"
"た、\n"
"実装となる。\n"
"カスタムコードオブジェクトは、{#sep}メソッドやこのメソッドによって\n"
"固有のパスが確保されるべきである。"

# @example The path of an instance method
#: ../lib/yard/code_objects/base.rb:418
msgid "MethodObject.new(P(\"A::B\"), :c).path # => \"A::B#c\""
msgstr ""

# @example
#: ../lib/yard/code_objects/base.rb:418
msgid "tag|example|The path of an instance method"
msgstr "インスタンスメソッドのパス"

# @see
#: ../lib/yard/code_objects/base.rb:418
msgid "tag|see|#sep"
msgstr ""

# @return [String]
#: ../lib/yard/code_objects/base.rb:418
msgid "the unique path of the object"
msgstr "オブジェクトの固有のパス"

# @param [Base, String] other
#: ../lib/yard/code_objects/base.rb:430
msgid "another code object (or object path)"
msgstr "他のコードオブジェクト(又は、オブジェクトのパス)"

# @return [String]
#: ../lib/yard/code_objects/base.rb:430
msgid "the shortest relative path from this object to +other+"
msgstr "このオブジェクトから +other+ への最短の相対パス"

# YARD::CodeObjects::Base#format
#: ../lib/yard/code_objects/base.rb:451
msgid "Renders the object using the {Templates::Engine templating system}."
msgstr "{Templates::Engine templating system}によってオブジェクトを表示する。"

# @param [Hash] options
#: ../lib/yard/code_objects/base.rb:463
msgid "a set of options to pass to the template"
msgstr "テンプレートに渡すoptionのグループ"

# @example Formats a method in html with rdoc markup
#: ../lib/yard/code_objects/base.rb:463
msgid "puts P('MyClass#meth').format(:format => :html, :markup => :rdoc)"
msgstr ""

# @example Formats a class in plaintext
#: ../lib/yard/code_objects/base.rb:463
msgid "puts P('MyClass').format"
msgstr ""

# @example
#: ../lib/yard/code_objects/base.rb:463
msgid "tag|example|Formats a class in plaintext"
msgstr "プレーンテキストでクラスを書式化する"

# @example
#: ../lib/yard/code_objects/base.rb:463
msgid "tag|example|Formats a method in html with rdoc markup"
msgstr "rdocマークアップと共に、htmlで、メソッドを書式化する"

# @option
#: ../lib/yard/code_objects/base.rb:463 ../lib/yard/i18n/text.rb:11
#: ../lib/yard/templates/engine.rb:81 ../lib/yard/templates/engine.rb:140
msgid "tag|option|options"
msgstr ""

# @param [Hash]
#: ../lib/yard/code_objects/base.rb:463 ../lib/yard/i18n/text.rb:11
#: ../lib/yard/templates/engine.rb:81 ../lib/yard/templates/engine.rb:100
#: ../lib/yard/templates/engine.rb:140 ../lib/yard/templates/template.rb:37
msgid "tag|param|options"
msgstr ""

# @return [String]
#: ../lib/yard/code_objects/base.rb:463 ../lib/yard/templates/engine.rb:81
msgid "the rendered template"
msgstr "テンプレートを表示する。"

# YARD::CodeObjects::Base#inspect
#: ../lib/yard/code_objects/base.rb:469
msgid "Inspects the object, returning the type and path"
msgstr "オブジェクトを検査し、型とパスを返す。"

# @return [String]
#: ../lib/yard/code_objects/base.rb:470
msgid "a string describing the object"
msgstr "オブジェクトを説明する文字列"

# YARD::CodeObjects::Base#namespace=
# YARD::CodeObjects::Base#parent=
#: ../lib/yard/code_objects/base.rb:475 ../lib/yard/code_objects/base.rb:497
msgid "Sets the namespace the object is defined in."
msgstr "中で定義されるオブジェクトのnamespaceを設定する。"

# @param [String, CodeObjects::Base]
# @param [NamespaceObject, :root, nil]
# @param [MethodObject]
#: ../lib/yard/code_objects/base.rb:479
#: ../lib/yard/code_objects/extended_method_object.rb:16
#: ../lib/yard/templates/helpers/html_helper.rb:309
msgid "tag|param|obj"
msgstr "obj"

# @param [NamespaceObject, :root, nil] obj
#: ../lib/yard/code_objects/base.rb:479
msgid ""
"the new namespace (:root\n"
"for {Registry.root}). If obj is nil, the object is unregistered\n"
"from the Registry."
msgstr ""
"新しいnamespace({Registry.root}用の:root)\n"
"objがnilの場合、記録されたオブジェクトはレジストリから戻される。"

# YARD::CodeObjects::Base#tag
#: ../lib/yard/code_objects/base.rb:499
msgid "Gets a tag from the {#docstring}"
msgstr "{#docstring}メソッドから、取得する。"

# @see
#: ../lib/yard/code_objects/base.rb:500
msgid "tag|see|Docstring#tag"
msgstr ""

# YARD::CodeObjects::Base#tags
#: ../lib/yard/code_objects/base.rb:503
msgid "Gets a list of tags from the {#docstring}"
msgstr "{#docstring}メソッドから、タグのリストを取得する。"

# @see
#: ../lib/yard/code_objects/base.rb:504
msgid "tag|see|Docstring#tags"
msgstr ""

# YARD::CodeObjects::Base#has_tag?
#: ../lib/yard/code_objects/base.rb:507
msgid "Tests if the {#docstring} has a tag"
msgstr "{#docstring}メソッドがタグを持つ場合、テストする。"

# @see
#: ../lib/yard/code_objects/base.rb:508
msgid "tag|see|Docstring#has_tag?"
msgstr ""

# @return [Boolean]
#: ../lib/yard/code_objects/base.rb:511
msgid "whether or not this object is a RootObject"
msgstr "このオブジェクトがRootObjectかどうか"

# YARD::CodeObjects::Base#sep
#: ../lib/yard/code_objects/base.rb:514
msgid ""
"Override this method with a custom component separator. For instance,\n"
"{MethodObject} implements sep as '#' or '.' (depending on if the\n"
"method is instance or class respectively). {#path} depends on this\n"
"value to generate the full path in the form: namespace.path + sep + name"
msgstr ""
"このメソッドは、区切りのカスタム構成を上書きする。\n"
"例えば、{MethodObject}は'#'や'.'のような区切りを実装する。\n"
"(メソッドのインスタンスやクラスの関係に依存している)\n"
"{#path}メソッドは namespace.path + sep + name の形式で、\n"
"フルパスを生成する為、この値に依存している。"

# @return [String]
#: ../lib/yard/code_objects/base.rb:520
msgid ""
"the component that separates the namespace path\n"
"and the name (default is {NSEP})"
msgstr "namespace path と name で区切る構成となる。(デフォルトは{NSEP})"

# YARD::CodeObjects::Base#copyable_attributes
#: ../lib/yard/code_objects/base.rb:525
msgid ""
"Override this method if your code object subclass does not allow\n"
"copying of certain attributes."
msgstr ""

# @see
#: ../lib/yard/code_objects/base.rb:531
msgid "tag|see|#copy_to"
msgstr ""

# @return [Array<String>]
#: ../lib/yard/code_objects/base.rb:531
msgid ""
"the list of instance variable names (without\n"
"\"@\" prefix) that should be copied when {#copy_to} is called"
msgstr ""

# YARD::CodeObjects::Base#format_source
#: ../lib/yard/code_objects/base.rb:540
msgid "Formats source code by removing leading indentation"
msgstr "インデントを読み込み削除する事によってソースコードを書式化する"

# @return [String]
#: ../lib/yard/code_objects/base.rb:543
msgid "formatted source"
msgstr "書式化されたソース"

# @param [Symbol]
# @param [String]
#: ../lib/yard/code_objects/base.rb:543 ../lib/yard/parser/base.rb:25
#: ../lib/yard/server/library_version.rb:120
#: ../lib/yard/templates/helpers/html_helper.rb:134
#: ../lib/yard/templates/helpers/html_helper.rb:154
#: ../lib/yard/templates/helpers/html_helper.rb:557
#: ../lib/yard/templates/helpers/html_syntax_highlight_helper.rb:9
msgid "tag|param|source"
msgstr "source"

# @param [String] source
#: ../lib/yard/code_objects/base.rb:543
msgid "the source code to format"
msgstr "書式化するソースコード"

# YARD::CodeObjects::ClassObject
#: ../lib/yard/code_objects/class_object.rb:3
msgid ""
"A ClassObject represents a Ruby class in source code. It is a "
"{ModuleObject}\n"
"with extra inheritance semantics through the superclass."
msgstr ""
"クラスオブジェクトはソースコードの中のRubyクラスを意味する。\n"
"それは、スーパークラスを介した特別な継承の意味を持つ {ModuleObject} となる。"

# YARD::CodeObjects::ClassObject#superclass
#: ../lib/yard/code_objects/class_object.rb:6
msgid "The {ClassObject} that this class object inherits from in Ruby source."
msgstr "このクラスオブジェクトがRubyのソースから継承する{ClassObject}"

# @return [ClassObject]
#: ../lib/yard/code_objects/class_object.rb:7
msgid "a class object that is the superclass of this one"
msgstr "このクラスオブジェクトのスーパークラスとなるクラスオブジェクトを返す"

# YARD::CodeObjects::ClassObject#initialize
#: ../lib/yard/code_objects/class_object.rb:10
msgid "Creates a new class object in +namespace+ with +name+"
msgstr "+name+ と共に +namespace+ の中で新しいクラスオブジェクトを作成する。"

# @return [ClassObject]
#: ../lib/yard/code_objects/class_object.rb:12
msgid "a new instance of ClassObject"
msgstr "クラスオブジェクトの新しいインスタンス"

# @see
#: ../lib/yard/code_objects/class_object.rb:12
msgid "tag|see|Base.new"
msgstr ""

# YARD::CodeObjects::ClassObject#is_exception?
#: ../lib/yard/code_objects/class_object.rb:30
msgid "Whether or not the class is a Ruby Exception"
msgstr "Ruby Exceptionクラスかどうか"

# @return [Boolean]
#: ../lib/yard/code_objects/class_object.rb:32
msgid "whether the object represents a Ruby exception"
msgstr "Ruby exceptionクラスを表すオブジェクトかどうか"

# YARD::CodeObjects::ClassObject#inheritance_tree
#: ../lib/yard/code_objects/class_object.rb:37
msgid "Returns the inheritance tree of the object including self."
msgstr "自身を含んでいるオブジェクトの継承ツリーを返す"

# @param [Boolean]
#: ../lib/yard/code_objects/class_object.rb:42
#: ../lib/yard/code_objects/module_object.rb:9
msgid "tag|param|include_mods"
msgstr "include_mods"

# @return [Array<NamespaceObject>]
#: ../lib/yard/code_objects/class_object.rb:42
msgid ""
"the list of code objects that make up\n"
"the inheritance tree."
msgstr "継承ツリーを作り上げるコードオブジェクトのリスト"

# @param [Boolean] include_mods
#: ../lib/yard/code_objects/class_object.rb:42
msgid ""
"whether or not to include mixins in the\n"
"inheritance tree."
msgstr "継承ツリーの中でmixinを含んでいるかどうか"

# YARD::CodeObjects::ClassObject#meths
#: ../lib/yard/code_objects/class_object.rb:55
msgid ""
"Returns the list of methods matching the options hash. Returns\n"
"all methods if hash is empty."
msgstr ""
"ハッシュのオプションにマッチするメソッドのリストを返す。\n"
"(ハッシュが空の場合は、全てのメソッド)"

# @option
#: ../lib/yard/code_objects/class_object.rb:63
#: ../lib/yard/code_objects/class_object.rb:98
#: ../lib/yard/code_objects/namespace_object.rb:113
#: ../lib/yard/code_objects/namespace_object.rb:144
#: ../lib/yard/code_objects/namespace_object.rb:164
#: ../lib/yard/handlers/base.rb:355 ../lib/yard/parser/ruby/ast_node.rb:152
#: ../lib/yard/serializers/file_system_serializer.rb:27
#: ../lib/yard/server/adapter.rb:71 ../lib/yard/server/rack_adapter.rb:26
msgid "tag|option|opts"
msgstr "opts"

# @return [Array<MethodObject>]
#: ../lib/yard/code_objects/class_object.rb:63
msgid "the list of methods that matched"
msgstr "マッチしたメソッドのリスト"

# @param [Hash] opts
#: ../lib/yard/code_objects/class_object.rb:63
#: ../lib/yard/code_objects/class_object.rb:98
msgid "the options hash to match"
msgstr "マッチするハッシュのオプション"

# YARD::CodeObjects::ClassObject#inherited_meths
#: ../lib/yard/code_objects/class_object.rb:74
msgid "Returns only the methods that were inherited."
msgstr "継承したメソッドだけを返す"

# @return [Array<MethodObject>]
#: ../lib/yard/code_objects/class_object.rb:76
msgid "the list of inherited method objects"
msgstr "メソッドオブジェクトを継承したリスト"

# YARD::CodeObjects::ClassObject#constants
#: ../lib/yard/code_objects/class_object.rb:91
msgid "Returns the list of constants matching the options hash."
msgstr "ハッシュのオプションにマッチする定数のリストを返す"

# @return [Array<ConstantObject>]
#: ../lib/yard/code_objects/class_object.rb:98
msgid "the list of constant that matched"
msgstr "マッチした定数のリスト"

# YARD::CodeObjects::ClassObject#inherited_constants
#: ../lib/yard/code_objects/class_object.rb:104
msgid "Returns only the constants that were inherited."
msgstr "継承された定数だけ返す"

# @return [Array<ConstantObject>]
#: ../lib/yard/code_objects/class_object.rb:106
msgid "the list of inherited constant objects"
msgstr "定数オブジェクトを継承したリスト"

# YARD::CodeObjects::ClassObject#superclass=
#: ../lib/yard/code_objects/class_object.rb:119
msgid "Sets the superclass of the object"
msgstr "オブジェクトのスーパークラスをグループ化する。"

# @param [Base, Proxy, String, Symbol, nil] object
#: ../lib/yard/code_objects/class_object.rb:122
msgid "the superclass value"
msgstr "スーパークラスの値"

# YARD::CodeObjects::ClassVariableObject
#: ../lib/yard/code_objects/class_variable_object.rb:3
msgid ""
"Represents a class variable inside a namespace. The path is expressed\n"
"in the form \"A::B::@@classvariable\""
msgstr ""
"namespaceの内部でクラス変数を表す。\n"
"パスは、\"A::B::@@クラス変数\"形式で表される。"

# @return [String]
#: ../lib/yard/code_objects/class_variable_object.rb:6
msgid "the class variable's value"
msgstr "クラス変数の値"

# YARD::CodeObjects::ConstantObject
#: ../lib/yard/code_objects/constant_object.rb:3
msgid ""
"A +ConstantObject+ represents a Ruby constant (not a module or class).\n"
"To access the constant's (source code) value, use {#value}."
msgstr ""
"+ConstantObject+ は、Ruby定数を表す。(モジュールやクラスではない)\n"
"定数(ソースコード)の値にアクセスする為には、{#value}メソッドを利用する。"

# YARD::CodeObjects::ConstantObject#value
#: ../lib/yard/code_objects/constant_object.rb:6
msgid "The source code representing the constant's value"
msgstr "定数の値を表しているソースコード"

# @return [String]
#: ../lib/yard/code_objects/constant_object.rb:7
msgid "the value the constant is set to"
msgstr "定数を設定される値"

# YARD::CodeObjects::ExtendedMethodObject
#: ../lib/yard/code_objects/extended_method_object.rb:3
msgid ""
"Represents an instance method of a module that was mixed into the class\n"
"scope of another namespace."
msgstr ""
"他のnamespaceのクラススコープの中へ混ぜられたモジュールのインスタンスメソッド"
"を表す。"

# @see
#: ../lib/yard/code_objects/extended_method_object.rb:6
#: ../lib/yard/code_objects/extended_method_object.rb:21
msgid "tag|see|MethodObject"
msgstr ""

# @return [Symbol]
#: ../lib/yard/code_objects/extended_method_object.rb:10
msgid "always +:class+"
msgstr "常に +:class+"

# YARD::CodeObjects::ExtendedMethodObject#initialize
#: ../lib/yard/code_objects/extended_method_object.rb:13
msgid "Sets up a delegate for {MethodObject} obj."
msgstr "{MethodObject}オブジェクト用に委譲をセットアップする"

# @return [ExtendedMethodObject]
#: ../lib/yard/code_objects/extended_method_object.rb:16
msgid "a new instance of ExtendedMethodObject"
msgstr "ExtendedMethodObjectの新しいインスタンス"

# @param [MethodObject] obj
#: ../lib/yard/code_objects/extended_method_object.rb:16
msgid ""
"the instance method to treat as a mixed in\n"
"class method on another namespace."
msgstr ""
"別のnamespace上でクラスメソッドを混ぜたような処理をする,インスタンスメソッド"

# YARD::CodeObjects::ExtendedMethodObject#method_missing
#: ../lib/yard/code_objects/extended_method_object.rb:19
msgid "Sends all methods to the {MethodObject} assigned in {#initialize}"
msgstr ""
"{MethodObject}が{#initialize}メソッドを割り当てる事によって、\n"
"全てのメソッドを__send__する。"

# YARD::CodeObjects::ExtraFileObject
#: ../lib/yard/code_objects/extra_file_object.rb:3
msgid ""
"An ExtraFileObject represents an extra documentation file (README or other\n"
"file). It is not strictly a CodeObject (does not inherit from `Base`) "
"although\n"
"it implements `path`, `name` and `type`, and therefore should be "
"structurally\n"
"compatible with most CodeObject interfaces."
msgstr ""
"ExtraFileObjectは、追加のドキュメントファイル(README や 他のファイル)を表すけ"
"れど、\n"
"コードオブジェクトに限らず(`Base`から継承はできない)`path`, `name` , `type`を"
"実装できる。\n"
"従って、殆どのCodeObjectインターフェースと互換性があり、構造上両立されるべき"
"である。"

# @param value
#: ../lib/yard/code_objects/extra_file_object.rb:7
msgid "the value to set the attribute filename to."
msgstr "filename属性を設定する値"

# YARD::CodeObjects::ExtraFileObject#filename
#: ../lib/yard/code_objects/extra_file_object.rb:8
msgid "Returns the value of attribute filename"
msgstr "filename属性の値を返す"

# YARD::CodeObjects::ExtraFileObject#filename=
#: ../lib/yard/code_objects/extra_file_object.rb:8
msgid "Sets the attribute filename"
msgstr "filename属性を設定する"

# @param value
#: ../lib/yard/code_objects/extra_file_object.rb:8
msgid "the value to set the attribute attributes to."
msgstr "attributesの属性を設定する値"

# YARD::CodeObjects::ExtraFileObject#attributes
#: ../lib/yard/code_objects/extra_file_object.rb:9
msgid "Returns the value of attribute attributes"
msgstr "attributes属性の値を返す"

# YARD::CodeObjects::ExtraFileObject#attributes=
#: ../lib/yard/code_objects/extra_file_object.rb:9
msgid "Sets the attribute attributes"
msgstr "attributes属性を設定する"

# @param value
#: ../lib/yard/code_objects/extra_file_object.rb:9
#: ../lib/yard/tags/ref_tag_list.rb:4
msgid "the value to set the attribute name to."
msgstr "name属性を設定する値"

# YARD::CodeObjects::ExtraFileObject#name
# YARD::CodeObjects::ExtraFileObject#path
# YARD::Parser::Ruby::Legacy::RubyToken::TkId#name
# YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar#name
# YARD::Tags::RefTagList#name
# YARD::Templates::Section#name
#: ../lib/yard/code_objects/extra_file_object.rb:10
#: ../lib/yard/code_objects/extra_file_object.rb:24
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:79
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:114
#: ../lib/yard/tags/ref_tag_list.rb:5
msgid "Returns the value of attribute name"
msgstr "name属性の値を返す"

# YARD::CodeObjects::ExtraFileObject#name=
# YARD::Tags::RefTagList#name=
# YARD::Templates::Section#name=
#: ../lib/yard/code_objects/extra_file_object.rb:10
#: ../lib/yard/tags/ref_tag_list.rb:5
msgid "Sets the attribute name"
msgstr "name属性を設定する"

# @param value
#: ../lib/yard/code_objects/extra_file_object.rb:10
msgid "the value to set the attribute contents to."
msgstr "値に属性の内容を設定するための値"

# YARD::Parser::Ruby::Legacy::Statement#comments
# YARD::Parser::Ruby::RipperParser#comments
#: ../lib/yard/code_objects/extra_file_object.rb:11
msgid "Returns the value of attribute contents"
msgstr "属性の内容の値を返す"

# YARD::CodeObjects::NamespaceObject#constants=
#: ../lib/yard/code_objects/extra_file_object.rb:11
msgid "Sets the attribute contents"
msgstr "属性の内容を設定する"

# YARD::CodeObjects::ExtraFileObject#initialize
#: ../lib/yard/code_objects/extra_file_object.rb:13
msgid "Creates a new extra file object."
msgstr "新しく追加のファイルオブジェクトを作成する"

# @return [ExtraFileObject]
#: ../lib/yard/code_objects/extra_file_object.rb:16
msgid "a new instance of ExtraFileObject"
msgstr "ExtraFileObjectの新しいインスタンス"

# @param [String]
#: ../lib/yard/code_objects/extra_file_object.rb:16
#: ../lib/yard/templates/helpers/markup_helper.rb:122
msgid "tag|param|contents"
msgstr "contents"

# @param [String, CodeObjects::ExtraFileObject]
# @param [String]
# @param [String, Regexp]
#: ../lib/yard/code_objects/extra_file_object.rb:16
#: ../lib/yard/handlers/base.rb:228 ../lib/yard/parser/base.rb:25
#: ../lib/yard/parser/source_parser.rb:505
#: ../lib/yard/templates/helpers/base_helper.rb:149
#: ../lib/yard/templates/helpers/html_helper.rb:342
msgid "tag|param|filename"
msgstr "filename"

# @param [String] contents
#: ../lib/yard/code_objects/extra_file_object.rb:16
msgid ""
"the file contents. If not set, the contents\n"
"will be read from disk using the +filename+."
msgstr ""
"ファイルの内容となる。設定しない場合、\n"
"contentsは、 +filename+ によってディスクから読み込まれるだろう。"

# @param [String] filename
#: ../lib/yard/code_objects/extra_file_object.rb:16
msgid "the location on disk of the file"
msgstr "ファイルのディスク上の場所"

# @param [String] data
#: ../lib/yard/code_objects/extra_file_object.rb:47
msgid "the file contents"
msgstr "ファイルの内容"

# YARD::CodeObjects::MacroObject
#: ../lib/yard/code_objects/macro_object.rb:6
msgid ""
"A MacroObject represents a docstring defined through +@!macro NAME+ and can "
"be\n"
"reused by specifying the tag +@!macro NAME+. You can also provide the\n"
"+attached+ type flag to the macro definition to have it attached to the\n"
"specific DSL method so it will be implicitly reused."
msgstr ""
"マクロオブジェクトは、+@!macro NAME+ を通じて定義した docstring を表し、\n"
"+@!macro NAME+ タグを指定する事によって、再利用できる。\n"
"あなたは、固有のDSLメソッドに加えるマクロ定義の為に\n"
"+attached+ 型フラグを提供もできる。\n"
"なので、暗黙の内に再利用される。"

# YARD::CodeObjects::MacroObject
#: ../lib/yard/code_objects/macro_object.rb:11
msgid ""
"Macros are fully described in the {file:docs/Tags.md#macro Tags Overview}\n"
"document."
msgstr ""
"マクロは、{file:docs/Tags.md#macros Tags Overview}ドキュメントで詳細に説明さ"
"れている。"

# @example Creating a macro that is attached to the method call
#: ../lib/yard/code_objects/macro_object.rb:29
msgid ""
"# @!macro [attach] prop2\n"
"#   @!method $1(value)\n"
"property :foo\n"
"\n"
"# Extra data added to docstring\n"
"property :bar"
msgstr ""

# @example Creating a basic named macro
#: ../lib/yard/code_objects/macro_object.rb:29
msgid ""
"# @!macro prop\n"
"#   @!method $1(${3-})\n"
"#   @return [$2] the value of the $0\n"
"property :foo, String, :a, :b\n"
"\n"
"# @!macro prop\n"
"property :bar, Numeric, :value"
msgstr ""

# @example
#: ../lib/yard/code_objects/macro_object.rb:29
msgid "tag|example|Creating a basic named macro"
msgstr "一般的なマクロを作成"

# @example
#: ../lib/yard/code_objects/macro_object.rb:29
msgid "tag|example|Creating a macro that is attached to the method call"
msgstr "メソッド呼び出しの為に加えられるマクロを作成する。"

# YARD::CodeObjects::MacroObject.create
#: ../lib/yard/code_objects/macro_object.rb:34
msgid "Creates a new macro and fills in the relevant properties."
msgstr "関連したプロパティのファイルと新しいマクロを作成する。"

# @param [CodeObjects::Base] method_object
#: ../lib/yard/code_objects/macro_object.rb:39
msgid ""
"an object to attach this\n"
"macro to. If supplied, {#attached?} will be true"
msgstr ""
"このマクロに加えるオブジェクト。もし提供された場合、\n"
"{#attached?}はtrueになる。"

# @param [String]
#: ../lib/yard/code_objects/macro_object.rb:39
#: ../lib/yard/code_objects/macro_object.rb:50
#: ../lib/yard/code_objects/macro_object.rb:70
msgid "tag|param|macro_name"
msgstr "macro_name"

# @param [CodeObjects::Base]
#: ../lib/yard/code_objects/macro_object.rb:39
#: ../lib/yard/code_objects/macro_object.rb:70
msgid "tag|param|method_object"
msgstr "method_object"

# @param [String] data
#: ../lib/yard/code_objects/macro_object.rb:39
msgid "the data the macro should expand when re-used"
msgstr "再利用された時、マクロが展開するであろうデータ"

# @param [String] macro_name
#: ../lib/yard/code_objects/macro_object.rb:39
msgid "the name of the macro, must be unique."
msgstr "マクロの名前、固有のものにしなければならない"

# YARD::CodeObjects::MacroObject.find
#: ../lib/yard/code_objects/macro_object.rb:47
msgid "Finds a macro using +macro_name+"
msgstr "+macro_name+ のマクロを見つける"

# @return [MacroObject]
#: ../lib/yard/code_objects/macro_object.rb:50
msgid "if a macro is found"
msgstr "マクロが見つかった場合"

# @return [nil]
#: ../lib/yard/code_objects/macro_object.rb:50
msgid "if there is no registered macro by that name"
msgstr "マクロの名前が記録されない場合"

# @return [String]
#: ../lib/yard/code_objects/macro_object.rb:50
#: ../lib/yard/code_objects/macro_object.rb:70
msgid "the name of the macro"
msgstr "マクロの名前"

# YARD::CodeObjects::MacroObject.find_or_create
# YARD::CodeObjects::MacroObject.create_docstring
#: ../lib/yard/code_objects/macro_object.rb:55
#: ../lib/yard/code_objects/macro_object.rb:78
msgid ""
"Parses a given docstring and determines if the macro is \"new\" or\n"
"not. If the macro has $variable names or if it has a @!macro tag\n"
"with the [new] or [attached] flag, it is considered new."
msgstr ""
"与えらたdocstringを解析しマクロが新しく作成されるものかどうか決める。\n"
"もしマクロが$variable名を持っていた場合や\n"
"[new]や[attached]フラグと一緒に@!macroタグを持っていた場合、\n"
"新規に作成されるものとみなされる。"

# YARD::CodeObjects::MacroObject.find_or_create
# YARD::CodeObjects::MacroObject.create_docstring
#: ../lib/yard/code_objects/macro_object.rb:59
#: ../lib/yard/code_objects/macro_object.rb:82
msgid ""
"If a new macro is found, the macro is created and registered. Otherwise\n"
"the macro name is searched and returned. If a macro is not found,\n"
"nil is returned."
msgstr ""
"新しいマクロが見つかった場合、作成され記録される。\n"
"その他の場合、マクロ名が検索され返される。\n"
"マクロが見つからなかった場合は、nilが返される。"

# @param [CodeObjects::Base] method_object
#: ../lib/yard/code_objects/macro_object.rb:70
msgid ""
"an optional method to attach\n"
"the macro to. Only used if the macro is being created, otherwise\n"
"this argument is ignored."
msgstr ""
"マクロを加える為の任意のメソッド\n"
"マクロが作成される場合、利用されるだけである。\n"
"さもなければ、この引数は無視される。"

# @return [nil]
#: ../lib/yard/code_objects/macro_object.rb:70
msgid ""
"if the +data+ has no macro tag or if the macro is\n"
"not new and no macro by the macro name is found."
msgstr ""
"+data+ がマクロタグを持っていないか、\n"
"マクロが、\"new\"でなかったり、\n"
"macro name is foundによって、マクロ自体が無い場合、nilを返す。"

# @return [MacroObject]
#: ../lib/yard/code_objects/macro_object.rb:70
msgid ""
"the newly created or existing macro, depending\n"
"on whether the @!macro tag was a new tag or not."
msgstr ""
"新たに作成された、又は、既存のマクロを返す。\n"
"@!macroタグはnewタグかそうでないかに依存する。"

# YARD::CodeObjects::MacroObject.expand
#: ../lib/yard/code_objects/macro_object.rb:80
msgid "Expands +macro_data+ using the interpolation parameters."
msgstr "補完の引数によって、 +macro_data+ を展開する。"

# YARD::CodeObjects::MacroObject.expand
#: ../lib/yard/code_objects/macro_object.rb:82
msgid ""
"Interpolation rules:\n"
"* $0, $1, $2, ... = the Nth parameter in +call_params+\n"
"* $* = the full statement source (excluding block)\n"
"* Also supports $!{N-M} ranges, as well as negative indexes on N or M\n"
"* Use \\$ to escape the variable name in a macro."
msgstr ""
"補完のルール:\n"
"* $0, $1, $2, ... = +call_params+ の中のN番目の引数\n"
"* $* = 完全なステートメントのソース(blockを除外する)\n"
"* $!{N-M}の範囲もサポートし,マイナスのインデックスも利用できる\n"
"* マクロの中の変数名のエスケープには\\$を使う"

# @param [String]
#: ../lib/yard/code_objects/macro_object.rb:96
msgid "tag|param|macro_data"
msgstr "マクロデータ"

# @param [String] macro_data
#: ../lib/yard/code_objects/macro_object.rb:96
msgid "the macro data to expand (taken from {#macro_data})"
msgstr "拡張する為のマクロデータ({#macro_data}メソッドから取得する)"

# YARD::CodeObjects::MacroObject.apply
#: ../lib/yard/code_objects/macro_object.rb:114
msgid ""
"Applies a macro on a docstring by creating any macro data inside of\n"
"the docstring first. Equivalent to calling {find_or_create} and "
"{apply_macro}\n"
"on the new macro object."
msgstr ""
"最初にdocstringの内部の何らかのマクロデータを作成する事によって\n"
"docstring上のマクロを適用する。\n"
"{find_or_create}と、\n"
"新しいマクロオブジェクト上で{apply_macro}を呼び出すのは同様である。"

# @param [Docstring]
#: ../lib/yard/code_objects/macro_object.rb:120
msgid "tag|param|docstring"
msgstr "docstring"

# @see
#: ../lib/yard/code_objects/macro_object.rb:120
msgid "tag|see|find_or_create"
msgstr ""

# @param [Docstring] docstring
#: ../lib/yard/code_objects/macro_object.rb:120
msgid "the docstring to create a macro out of"
msgstr "マクロの出力を作成する為のdocstrng"

# YARD::CodeObjects::MacroObject.apply_macro
#: ../lib/yard/code_objects/macro_object.rb:131
msgid ""
"Applies a macro to a docstring, interpolating the macro's data on the\n"
"docstring and appending any extra local docstring data that was in\n"
"the original +docstring+ object."
msgstr ""
"docstringにmacroが適用され、\n"
"docstring上のマクロデータを補完する。\n"
"そして、元の +docstring+ オブジェクトの中の\n"
"任意で加えられるローカルなdocstringのデータを適用する。\n"

# @param [MacroObject]
# @param [CodeObjects::MacroObject]
#: ../lib/yard/code_objects/macro_object.rb:136
msgid "tag|param|macro"
msgstr "macro"

# @param [MacroObject] macro
#: ../lib/yard/code_objects/macro_object.rb:136
msgid "the macro object"
msgstr "マクロオブジェクト"

# @return [String]
#: ../lib/yard/code_objects/macro_object.rb:142
msgid "the macro data stored on the object"
msgstr "マクロ上で記録されるデータ"

# @return [CodeObjects::Base]
#: ../lib/yard/code_objects/macro_object.rb:146
msgid ""
"the method object that this macro is\n"
"attached to."
msgstr "このマクロが追加されるメソッドオブジェクト\n"

# @return [Boolean]
#: ../lib/yard/code_objects/macro_object.rb:149
msgid "whether this macro is attached to a method"
msgstr "このマクロがメソッドに加えられるかどうか"

# YARD::CodeObjects::MacroObject#path
#: ../lib/yard/code_objects/macro_object.rb:152
msgid "Overrides {Base#path} so the macro path is \".macro.MACRONAME\""
msgstr ""

# YARD::CodeObjects::MacroObject#sep
#: ../lib/yard/code_objects/macro_object.rb:155
msgid "Overrides the separator to be '.'"
msgstr ""

# YARD::CodeObjects::MacroObject#expand
#: ../lib/yard/code_objects/macro_object.rb:158
msgid "Expands the macro using"
msgstr "マクロによって展開される"

# @param [Array<String>] call_params
#: ../lib/yard/code_objects/macro_object.rb:167
msgid ""
"a list of tokens that are passed\n"
"to the method call"
msgstr "メソッド呼び出しに渡されるトークンのリスト"

# @example Expanding a Macro
#: ../lib/yard/code_objects/macro_object.rb:167
msgid ""
"macro.expand(%w(property foo bar), 'property :foo, :bar', '') #=>\n"
"  \"...macro data interpolating this line of code...\""
msgstr ""

# @example
#: ../lib/yard/code_objects/macro_object.rb:167
msgid "tag|example|Expanding a Macro"
msgstr "マクロを展開する"

# @param [String]
#: ../lib/yard/code_objects/macro_object.rb:167
msgid "tag|param|block_source"
msgstr "block_source"

# @param [Array<String>]
#: ../lib/yard/code_objects/macro_object.rb:167
msgid "tag|param|call_params"
msgstr "call_params"

# @param [String]
#: ../lib/yard/code_objects/macro_object.rb:167
msgid "tag|param|full_source"
msgstr "full_source"

# @see
#: ../lib/yard/code_objects/macro_object.rb:167
msgid "tag|see|expand"
msgstr ""

# @param [String] full_source
#: ../lib/yard/code_objects/macro_object.rb:167
msgid "the full method call (not including the block)"
msgstr "全てのメソッド呼び出し(blockを含んでいない)"

# @param [String] block_source
#: ../lib/yard/code_objects/macro_object.rb:167
msgid ""
"the source passed in the block of the method\n"
"call, if there is a block."
msgstr "ブロックがある場合、メソッド呼び出しのブロックの中で解析されたソース。"

# YARD::CodeObjects::MethodObject
#: ../lib/yard/code_objects/method_object.rb:3
msgid "Represents a Ruby method in source"
msgstr "ソースの中のRubyメソッドを表す。"

# YARD::CodeObjects::MethodObject#scope
#: ../lib/yard/code_objects/method_object.rb:5
msgid "The scope of the method (+:class+ or +:instance+)"
msgstr "メソッドのスコープ( +:class+ や +:instance+ )"

# @return [Symbol]
#: ../lib/yard/code_objects/method_object.rb:7
msgid "the scope"
msgstr "スコープ"

# YARD::CodeObjects::MethodObject#explicit
# YARD::CodeObjects::MethodObject#explicit=
#: ../lib/yard/code_objects/method_object.rb:10
msgid ""
"Whether the object is explicitly defined in source or whether it was\n"
"inferred by a handler. For instance, attribute methods are generally\n"
"inferred and therefore not explicitly defined in source."
msgstr ""
"オブジェクトがソースの中で明確に定義されるかどうかや、\n"
"それがハンドラーによって推察されたかどうか。\n"
"例えば、大抵メソッドの属性は推察されるが、\n"
"ソースの中で明確に定義されない場合、マーカーはどこも示せない。"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:14
msgid "whether the object is explicitly defined in source."
msgstr "オブジェクトがソースの中で明確に定義されたかどうか"

# YARD::CodeObjects::MethodObject#parameters
# YARD::CodeObjects::MethodObject#parameters=
#: ../lib/yard/code_objects/method_object.rb:17
msgid ""
"Returns the list of parameters parsed out of the method signature\n"
"with their default values."
msgstr ""
"メソッドの用法のデフォルトの値と共に、その出力の解析された引数のリストを返"
"す。"

# @return [Array<Array(String, String)>]
#: ../lib/yard/code_objects/method_object.rb:21
msgid ""
"a list of parameter names followed\n"
"by their default values (or nil)"
msgstr "引数名のデフォルトの値をフォローする(又は、nil)"

# YARD::CodeObjects::MethodObject#initialize
#: ../lib/yard/code_objects/method_object.rb:24
msgid ""
"Creates a new method object in +namespace+ with +name+ and an instance\n"
"or class +scope+"
msgstr ""
"+name+ とインスタンスや +scope+ クラスと共に、\n"
"+namespace+の中で新しいメソッドオブジェクトを作成する。"

# YARD::CodeObjects::MethodObject#initialize
#: ../lib/yard/code_objects/method_object.rb:27
msgid ""
"If scope is +:module+, this object is instantiated as a public\n"
"method in +:class+ scope, but also creates a new (empty) method\n"
"as a private +:instance+ method on the same class or module."
msgstr ""

# @param [Symbol] scope
#: ../lib/yard/code_objects/method_object.rb:33
msgid "+:instance+, +:class+, or +:module+"
msgstr "+:instance+ や +:class+ や +:module+"

# @return [MethodObject]
#: ../lib/yard/code_objects/method_object.rb:33
msgid "a new instance of MethodObject"
msgstr "メソッドオブジェクトの新しいインスタンス"

# @param [Symbol]
#: ../lib/yard/code_objects/method_object.rb:33
msgid "tag|param|scope"
msgstr ""

# @param [String, Symbol] name
#: ../lib/yard/code_objects/method_object.rb:33
msgid "the method name"
msgstr "メソッド名"

# @param [NamespaceObject] namespace
#: ../lib/yard/code_objects/method_object.rb:33
msgid "the namespace"
msgstr "namespace"

# YARD::CodeObjects::MethodObject#scope=
#: ../lib/yard/code_objects/method_object.rb:53
msgid "Changes the scope of an object from :instance or :class"
msgstr ":instanceや:classからオブジェクトのスコープを変更する。"

# @param [Symbol]
#: ../lib/yard/code_objects/method_object.rb:54
msgid "tag|param|v"
msgstr "v"

# @param [Symbol] v
#: ../lib/yard/code_objects/method_object.rb:54
msgid "the new scope"
msgstr "新しいスコープ"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:76
msgid "whether or not the method is the #initialize constructor method"
msgstr "メソッドが#initialize,コンストラクタメソッドかどうか"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:83
msgid ""
"whether or not this method was created as a module\n"
"function"
msgstr "このメソッドがモジュール関数として作成されたかどうか"

# YARD::CodeObjects::MethodObject#attr_info
#: ../lib/yard/code_objects/method_object.rb:88
msgid "Returns the read/writer info for the attribute if it is one"
msgstr "属性がひとつだけの場合、読み/書きする為の情報を返す。"

# @return [nil]
#: ../lib/yard/code_objects/method_object.rb:91
msgid "if the method is not an attribute"
msgstr "メソッドが属性で無い場合"

# @return [SymbolHash]
#: ../lib/yard/code_objects/method_object.rb:91
msgid "if there is information about the attribute"
msgstr "属性についての情報がある場合"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:98
msgid "whether the method is a writer attribute"
msgstr "メソッドがwriter属性かどうか"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:104
msgid "whether the method is a reader attribute"
msgstr "メソッドがreader属性かどうか"

# YARD::CodeObjects::MethodObject#is_attribute?
#: ../lib/yard/code_objects/method_object.rb:109
msgid "Tests if the object is defined as an attribute in the namespace"
msgstr "オブジェクトがnamespaceの中でその属性を定義される場合、テストする。"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:110
msgid "whether the object is an attribute"
msgstr "オブジェクトが属性かどうか"

# YARD::CodeObjects::MethodObject#is_alias?
#: ../lib/yard/code_objects/method_object.rb:116
msgid "Tests if the object is defined as an alias of another method"
msgstr ""
"オブジェクトが別のメソッドがそのエイリアスに定義される場合、テストする。"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:117
msgid "whether the object is an alias"
msgstr "オブジェクトがエイリアスかどうか"

# YARD::CodeObjects::MethodObject#is_explicit?
#: ../lib/yard/code_objects/method_object.rb:123
msgid "Tests boolean {#explicit} value."
msgstr "ブールの{#explicit}メソッドの値をテストする。"

# @return [Boolean]
#: ../lib/yard/code_objects/method_object.rb:125
msgid "whether the method is explicitly defined in source"
msgstr "メソッドがソースの中で明確に定義されるかどうか"

# @return [nil]
#: ../lib/yard/code_objects/method_object.rb:132
msgid "if it does not override a method"
msgstr "メソッドが上書きされない場合"

# @return [MethodObject]
#: ../lib/yard/code_objects/method_object.rb:132
msgid "the object that this method overrides"
msgstr "このメソッドが上書きするオブジェクト"

# YARD::CodeObjects::MethodObject#aliases
#: ../lib/yard/code_objects/method_object.rb:139
msgid "Returns all alias names of the object"
msgstr "オブジェクトの全てのエイリアスの名前を返す"

# @return [Array<Symbol>]
#: ../lib/yard/code_objects/method_object.rb:140
msgid "the alias names"
msgstr "エイリアスの名前"

# YARD::CodeObjects::MethodObject#path
#: ../lib/yard/code_objects/method_object.rb:150
msgid ""
"Override path handling for instance methods in the root namespace\n"
"(they should still have a separator as a prefix)."
msgstr ""
"root namespaseの中のインスタンスメソッド用に操作するパスを上書きする。\n"
"(root namespaseはプレフィックスとして区切りが必要である)"

# @return [String]
#: ../lib/yard/code_objects/method_object.rb:152
msgid "the path of a method"
msgstr "メソッドのパス"

# YARD::CodeObjects::MethodObject#name
#: ../lib/yard/code_objects/method_object.rb:161
msgid "Returns the name of the object."
msgstr "オブジェクトの名前を返す"

# @example The name of a class method (with prefix)
#: ../lib/yard/code_objects/method_object.rb:170
msgid "a_class_method.name(true) # => \"mymethod\""
msgstr ""

# @example The name of an instance method (with prefix)
#: ../lib/yard/code_objects/method_object.rb:170
msgid "an_instance_method.name(true) # => \"#mymethod\""
msgstr ""

# @return [String]
#: ../lib/yard/code_objects/method_object.rb:170
msgid ""
"returns {#sep} + +name+ for an instance method if\n"
"prefix is true"
msgstr ""
"プレフィックスがtrueの場合、インスタンスメソッド用に{#sep} + +name+ を返す"

# @example
#: ../lib/yard/code_objects/method_object.rb:170
msgid "tag|example|The name of a class method (with prefix)"
msgstr "クラスメソッドの名前(プレフィックスを用いる)"

# @example
#: ../lib/yard/code_objects/method_object.rb:170
msgid "tag|example|The name of an instance method (with prefix)"
msgstr "インスタンスメソッドの名前(プレフィックスを用いる)"

# @return [Symbol]
#: ../lib/yard/code_objects/method_object.rb:170
msgid "the name without {#sep} if prefix is set to false"
msgstr "プレフィックスにfalseを設定する場合、{#sep}メソッド無しの名前となる。"

# @param [Boolean] prefix
#: ../lib/yard/code_objects/method_object.rb:170
msgid "whether or not to show the prefix"
msgstr "プレフィックスを見せるかどうか"

# YARD::CodeObjects::MethodObject#sep
#: ../lib/yard/code_objects/method_object.rb:175
msgid ""
"Override separator to differentiate between class and instance\n"
"methods."
msgstr "インスタンスメソッドとクラスの間で区別する為に区切りを上書きする。"

# @return [String]
#: ../lib/yard/code_objects/method_object.rb:177
msgid "\"#\" for an instance method, \".\" for class"
msgstr "インスタンスメソッド用の\"#\"、クラス用の\".\"。"

# YARD::CodeObjects::ModuleObject
#: ../lib/yard/code_objects/module_object.rb:3
msgid "Represents a Ruby module."
msgstr "Rubyモジュールを表す。"

# YARD::CodeObjects::ModuleObject#inheritance_tree
#: ../lib/yard/code_objects/module_object.rb:5
msgid "Returns the inheritance tree of mixins."
msgstr "mixinの継承ツリーを返す"

# @return [Array<NamespaceObject>]
#: ../lib/yard/code_objects/module_object.rb:9
msgid "a list of namespace objects"
msgstr "オブジェクトのnamespaceのリスト"

# @param [Boolean] include_mods
#: ../lib/yard/code_objects/module_object.rb:9
msgid ""
"if true, will include mixed in\n"
"modules (which is likely what is wanted)."
msgstr ""
"trueの場合、mixinされるモジュールを含んでいる(それが何ができそうであるか)"

# YARD::CodeObjects::NamespaceObject
#: ../lib/yard/code_objects/namespace_object.rb:3
msgid ""
"A \"namespace\" is any object that can store other objects within itself.\n"
"The two main Ruby objects that can act as namespaces are modules\n"
"({ModuleObject}) and classes ({ClassObject})."
msgstr ""
"namespaceはそれ自身の中で他のオブジェクトを記録できる任意のオブジェクトとな"
"る。\n"
"namespaceがモジュール({ModuleObject})とクラス({ClassObject})のように振る舞え"
"るオブジェクトとなる。"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:6
msgid "the value to set the attribute child to."
msgstr "child属性を設定する値"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:6
msgid "the value to set the attribute constants to."
msgstr "属性の定数を設定する値"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:6
msgid "the value to set the attribute cvars to."
msgstr "cvars(クラス変数)の属性を設定する値"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:6
msgid "the value to set the attribute meths to."
msgstr "meths(メソッド)属性を設定する値"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:6
msgid "the value to set the attribute mixins to."
msgstr "mixinの属性を設定する値"

# YARD::CodeObjects::NamespaceObject#child=
#: ../lib/yard/code_objects/namespace_object.rb:7
msgid "Sets the attribute child"
msgstr "child属性を設定する"

# YARD::CodeObjects::NamespaceObject#constants=
#: ../lib/yard/code_objects/namespace_object.rb:7
msgid "Sets the attribute constants"
msgstr "定数の属性を設定する"

# YARD::CodeObjects::NamespaceObject#cvars=
#: ../lib/yard/code_objects/namespace_object.rb:7
msgid "Sets the attribute cvars"
msgstr "cvarsの属性を設定する"

# YARD::CodeObjects::NamespaceObject#meths=
#: ../lib/yard/code_objects/namespace_object.rb:7
msgid "Sets the attribute meths"
msgstr "meths属性を設定する"

# YARD::CodeObjects::NamespaceObject#mixins=
#: ../lib/yard/code_objects/namespace_object.rb:7
msgid "Sets the attribute mixins"
msgstr "mixinの属性を設定する"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:7
msgid "the value to set the attribute class_attributes to."
msgstr "class_attributes属性を設定する値"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:7
msgid "the value to set the attribute instance_attributes to."
msgstr "instance_attributes属性を設定する値"

# YARD::CodeObjects::NamespaceObject#class_attributes=
#: ../lib/yard/code_objects/namespace_object.rb:8
msgid "Sets the attribute class_attributes"
msgstr "class_attributes属性を設定する"

# YARD::CodeObjects::NamespaceObject#instance_attributes=
#: ../lib/yard/code_objects/namespace_object.rb:8
msgid "Sets the attribute instance_attributes"
msgstr "instance_attributes属性を設定する"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:8
msgid "the value to set the attribute included_constants to."
msgstr "included_constants属性を設定する値"

# @param value
#: ../lib/yard/code_objects/namespace_object.rb:8
msgid "the value to set the attribute included_meths to."
msgstr "included_meths属性を設定する値"

# YARD::CodeObjects::NamespaceObject#included_constants=
#: ../lib/yard/code_objects/namespace_object.rb:9
msgid "Sets the attribute included_constants"
msgstr "included_constants属性を設定する"

# YARD::CodeObjects::NamespaceObject#included_meths=
#: ../lib/yard/code_objects/namespace_object.rb:9
msgid "Sets the attribute included_meths"
msgstr "included_meths属性を設定する"

# @return [Array<String>]
#: ../lib/yard/code_objects/namespace_object.rb:12
msgid "a list of ordered group names inside the namespace"
msgstr "namespace内部の名前のグループへの命令の入ったリスト"

# YARD::CodeObjects::NamespaceObject#children
#: ../lib/yard/code_objects/namespace_object.rb:15
msgid "The list of objects defined in this namespace"
msgstr "このnamespaceの中で定義されたオブジェクトのリスト"

# @return [Array<Base>]
#: ../lib/yard/code_objects/namespace_object.rb:16
msgid "a list of objects"
msgstr "オブジェクトのリスト"

# YARD::CodeObjects::NamespaceObject#attributes
#: ../lib/yard/code_objects/namespace_object.rb:19
msgid ""
"A hash containing two keys, class and instance, each containing\n"
"the attribute name with a { :read, :write } hash for the read and\n"
"write objects respectively."
msgstr ""
"ハッシュはクラスとインスタンスの二つのキーを含んでいる,\n"
"読み書きオブジェクトそれぞれ{:read, :write}ハッシュと共に\n"
"属性の名前をそれぞれ含んでいる。"

# @example The attributes of an object
#: ../lib/yard/code_objects/namespace_object.rb:39
msgid ""
">> Registry.at('YARD::Docstring').attributes\n"
"=> {\n"
"      :class => { },\n"
"      :instance => {\n"
"        :ref_tags => {\n"
"          :read => #<yardoc method YARD::Docstring#ref_tags>,\n"
"          :write => nil\n"
"        },\n"
"        :object => {\n"
"          :read => #<yardoc method YARD::Docstring#object>,\n"
"          :write => #<yardoc method YARD::Docstring#object=>\n"
"         },\n"
"         ...\n"
"      }\n"
"    }"
msgstr ""

# @return [Hash]
# @param [Array<CodeObjects::Base>] list
#: ../lib/yard/code_objects/namespace_object.rb:39
#: ../lib/yard/code_objects/namespace_object.rb:44
#: ../lib/yard/templates/helpers/module_helper.rb:10
msgid "a list of methods"
msgstr "メソッドのリスト"

# @example
#: ../lib/yard/code_objects/namespace_object.rb:39
msgid "tag|example|The attributes of an object"
msgstr "オブジェクトの属性"

# YARD::CodeObjects::NamespaceObject#aliases
#: ../lib/yard/code_objects/namespace_object.rb:42
msgid ""
"A hash containing two keys, :class and :instance, each containing\n"
"a hash of objects and their alias names."
msgstr ""
"二つのキーを含んでいるハッシュで,クラスとインスタンスはそれぞれ、\n"
"オブジェクトのハッシュと、そのエイリアスの名前を含んでいる。"

# YARD::CodeObjects::NamespaceObject#class_mixins
#: ../lib/yard/code_objects/namespace_object.rb:47
msgid "Class mixins"
msgstr "mixinのクラス"

# @return [Array<ModuleObject>]
#: ../lib/yard/code_objects/namespace_object.rb:48
#: ../lib/yard/code_objects/namespace_object.rb:52
#: ../lib/yard/code_objects/namespace_object.rb:194
msgid "a list of mixins"
msgstr "mixinのリスト"

# YARD::CodeObjects::NamespaceObject#instance_mixins
#: ../lib/yard/code_objects/namespace_object.rb:51
msgid "Instance mixins"
msgstr "mixinのインスタンス"

# YARD::CodeObjects::NamespaceObject#initialize
#: ../lib/yard/code_objects/namespace_object.rb:55
msgid "Creates a new namespace object inside +namespace+ with +name+."
msgstr ""
"+name+ と共に、 +namespace+ の内部で新しいnamespaceオブジェクトを作成する。"

# @return [NamespaceObject]
#: ../lib/yard/code_objects/namespace_object.rb:56
msgid "a new instance of NamespaceObject"
msgstr "NamespaceObjectの新しいインスタンス"

# @see
#: ../lib/yard/code_objects/namespace_object.rb:56
msgid "tag|see|Base#initialize"
msgstr ""

# YARD::CodeObjects::NamespaceObject#class_attributes
#: ../lib/yard/code_objects/namespace_object.rb:67
msgid "Only the class attributes"
msgstr "クラス属性だけ"

# @return [Hash]
#: ../lib/yard/code_objects/namespace_object.rb:69
#: ../lib/yard/code_objects/namespace_object.rb:76
msgid "a list of method names and their read/write objects"
msgstr "メソッド名のリストとそれを読み/書きするオブジェクト"

# @see
#: ../lib/yard/code_objects/namespace_object.rb:69
#: ../lib/yard/code_objects/namespace_object.rb:76
msgid "tag|see|#attributes"
msgstr ""

# YARD::CodeObjects::NamespaceObject#instance_attributes
#: ../lib/yard/code_objects/namespace_object.rb:74
msgid "Only the instance attributes"
msgstr "インスタンス属性だけ"

# YARD::CodeObjects::NamespaceObject#child
#: ../lib/yard/code_objects/namespace_object.rb:81
msgid "Looks for a child that matches the attributes specified by +opts+."
msgstr "+opts+に指定された属性にマッチする子を検索する"

# @example Finds a child by name and scope
#: ../lib/yard/code_objects/namespace_object.rb:86
msgid ""
"namespace.child(:name => :to_s, :scope => :instance)\n"
"# => #<yardoc method MyClass#to_s>"
msgstr ""

# @example
#: ../lib/yard/code_objects/namespace_object.rb:86
msgid "tag|example|Finds a child by name and scope"
msgstr "名前とスコープの子を検索する"

# @return [Base, nil]
#: ../lib/yard/code_objects/namespace_object.rb:86
msgid "the first matched child object, or nil"
msgstr "最初にマッチした子のオブジェクト、又はnil"

# YARD::CodeObjects::NamespaceObject#meths
#: ../lib/yard/code_objects/namespace_object.rb:100
msgid ""
"Returns all methods that match the attributes specified by +opts+. If\n"
"no options are provided, returns all methods."
msgstr ""
"+opts+に指定された属性にマッチする全てのメソッドを返す。\n"
"optionが提供されない場合は、全てのメソッドを返す。"

# @param [Hash] opts
#: ../lib/yard/code_objects/namespace_object.rb:113
#: ../lib/yard/code_objects/namespace_object.rb:144
#: ../lib/yard/code_objects/namespace_object.rb:164
#: ../lib/yard/handlers/base.rb:355 ../lib/yard/i18n/text.rb:11
#: ../lib/yard/serializers/file_system_serializer.rb:27
#: ../lib/yard/server/rack_adapter.rb:26
msgid "a customizable set of options"
msgstr "カスタマイズ可能なオプションのグループ"

# @return [Array<MethodObject>]
#: ../lib/yard/code_objects/namespace_object.rb:113
msgid "a list of method objects"
msgstr "オブジェクトのメソッドのリスト"

# @example Finds all private and protected class methods
#: ../lib/yard/code_objects/namespace_object.rb:113
msgid ""
"namespace.meths(:visibility => [:private, :protected], :scope => :class)\n"
"# => [#<yardoc method MyClass.privmeth>, #<yardoc method MyClass.protmeth>]"
msgstr ""

# @example
#: ../lib/yard/code_objects/namespace_object.rb:113
msgid "tag|example|Finds all private and protected class methods"
msgstr "全てのprivateとクラスメソッドのprotectedを検索する"

# YARD::CodeObjects::NamespaceObject#included_meths
#: ../lib/yard/code_objects/namespace_object.rb:133
msgid ""
"Returns methods included from any mixins that match the attributes\n"
"specified by +opts+. If no options are specified, returns all included\n"
"methods."
msgstr ""
"+opts+で指定された属性にマッチする任意のmixinから含んでいるメソッドを返す\n"
"オプションが指定されない場合、全ての含んでいるメソッドを返すmethods."

# @see
#: ../lib/yard/code_objects/namespace_object.rb:144
msgid "tag|see|#meths"
msgstr ""

# YARD::CodeObjects::NamespaceObject#constants
#: ../lib/yard/code_objects/namespace_object.rb:160
msgid "Returns all constants in the namespace"
msgstr "namespaceの中の全ての定数を返す"

# @return [Array<ConstantObject>]
#: ../lib/yard/code_objects/namespace_object.rb:164
#: ../lib/yard/code_objects/namespace_object.rb:172
msgid "a list of constant objects"
msgstr "定数オブジェクトのリスト"

# YARD::CodeObjects::NamespaceObject#included_constants
#: ../lib/yard/code_objects/namespace_object.rb:171
msgid "Returns constants included from any mixins"
msgstr "任意のmixinから、含んでいる定数を返す"

# YARD::CodeObjects::NamespaceObject#cvars
#: ../lib/yard/code_objects/namespace_object.rb:185
msgid "Returns class variables defined in this namespace."
msgstr "このnamespaseの中で定義されたクラス変数を返す"

# @return [Array<ClassVariableObject>]
#: ../lib/yard/code_objects/namespace_object.rb:186
msgid "a list of class variable objects"
msgstr "オブジェクトのクラス変数のリスト"

# YARD::CodeObjects::NamespaceObject#mixins
#: ../lib/yard/code_objects/namespace_object.rb:191
msgid ""
"Returns for specific scopes. If no scopes are provided, returns all mixins."
msgstr "固有のスコープを返す。スコープが提供されない場合、全てのmixinを返す"

# @param [Array<Symbol>] scopes
#: ../lib/yard/code_objects/namespace_object.rb:194
msgid ""
"a list of scopes (:class, :instance) to\n"
"return mixins for. If this is empty, all scopes will be returned."
msgstr ""
"mixinを返す為のスコープのリスト(:class, :instance).\n"
"これが空の場合、全てのスコープが、返されるだろう。"

# @param [Array<Symbol>]
#: ../lib/yard/code_objects/namespace_object.rb:194
msgid "tag|param|scopes"
msgstr "scopes"

# YARD::CodeObjects::ProxyMethodError
#: ../lib/yard/code_objects/proxy.rb:4
msgid "A special type of +NoMethodError+ when raised from a {Proxy}"
msgstr "{Proxy}から、例外が上げられる時の、+NoMethodError+の特別な型"

# YARD::CodeObjects::Proxy
#: ../lib/yard/code_objects/proxy.rb:7
msgid ""
"The Proxy class is a way to lazily resolve code objects in\n"
"cases where the object may not yet exist. A proxy simply stores\n"
"an unresolved path until a method is called on the object, at which\n"
"point it does a lookup using {Registry.resolve}. If the object is\n"
"not found, a warning is raised and {ProxyMethodError} might be raised."
msgstr ""
"Proxyクラスは、オブジェクトがまだ存在しないかもしれないケースで、\n"
"コードオブジェクトを簡単に解決する為の方法である。\n"
"単純にproxyは、メソッドが解決されなかったパスを記録し、\n"
"オブジェクト上で呼び出され{Registry.resolve}によって検索する。\n"
"オブジェクトが見つからない場合、警告がでたり、{ProxyMethodError}が出るかもし"
"れない。"

# @example Creates a Proxy to the String class from a module
#: ../lib/yard/code_objects/proxy.rb:18
msgid ""
"# When the String class is parsed this method will\n"
"# begin to act like the String ClassObject.\n"
"Proxy.new(mymoduleobj, \"String\")"
msgstr ""

# @example
#: ../lib/yard/code_objects/proxy.rb:18
msgid "tag|example|Creates a Proxy to the String class from a module"
msgstr "モジュールからStringクラスの為のProxyを作成する"

# @see
#: ../lib/yard/code_objects/proxy.rb:18
msgid "tag|see|ProxyMethodError"
msgstr ""

# @see
#: ../lib/yard/code_objects/proxy.rb:18
msgid "tag|see|Registry.resolve"
msgstr ""

# YARD::CodeObjects::Proxy#namespace
# YARD::CodeObjects::Proxy#parent
#: ../lib/yard/code_objects/proxy.rb:22 ../lib/yard/code_objects/proxy.rb:23
#: ../lib/yard/handlers/base.rb:315 ../lib/yard/handlers/base.rb:335
msgid "Returns the value of attribute namespace"
msgstr "namespaxe属性の値を返す"

# YARD::CodeObjects::Proxy#initialize
#: ../lib/yard/code_objects/proxy.rb:25
msgid "Creates a new Proxy"
msgstr "新しいProxyを返す"

# @raise [ArgumentError]
#: ../lib/yard/code_objects/proxy.rb:28
msgid "if namespace is not a NamespaceObject"
msgstr "namespaceがNamespaceObjectでない場合"

# YARD::CodeObjects::Proxy#inspect
#: ../lib/yard/code_objects/proxy.rb:76
msgid "Returns a text representation of the Proxy"
msgstr "Proxyのテキスト表現を返す"

# @return [String]
#: ../lib/yard/code_objects/proxy.rb:77
msgid "the object's #inspect method or P(OBJECTPATH)"
msgstr "#inspectメソッドやP(OBJECTPATH)のオブジェクト"

# YARD::CodeObjects::Proxy#path
# YARD::CodeObjects::Proxy#to_s
# YARD::CodeObjects::Proxy#to_str
#: ../lib/yard/code_objects/proxy.rb:86 ../lib/yard/code_objects/proxy.rb:98
#: ../lib/yard/code_objects/proxy.rb:99
msgid ""
"If the proxy resolves to an object, returns its path, otherwise\n"
"guesses at the correct path using the original namespace and name."
msgstr ""
"proxyがオブジェクトを解決する場合、パスを返す。\n"
"他の場合、\n"
"元のnamespaceとnameによって正しいパスを推測する"

# @return [String]
#: ../lib/yard/code_objects/proxy.rb:90
msgid ""
"the assumed path of the proxy (or the real path\n"
"of the resolved object)"
msgstr "proxyのパスを装う(又は、解決したオブジェクトの実際のパス)"

# YARD::CodeObjects::Proxy#class
#: ../lib/yard/code_objects/proxy.rb:141
msgid ""
"Returns the class name of the object the proxy is mimicking, if\n"
"resolved. Otherwise returns +Proxy+."
msgstr ""
"解決した場合、proxyが模倣するオブジェクトのクラス名を返す。\n"
"他の場合、+Proxy+を返す。"

# @return [Class]
#: ../lib/yard/code_objects/proxy.rb:143
msgid "the resolved object's class or +Proxy+"
msgstr "解決したオブジェクトのクラスや +Proxy+"

# YARD::CodeObjects::Proxy#type
#: ../lib/yard/code_objects/proxy.rb:152
msgid ""
"Returns the type of the proxy. If it cannot be resolved at the\n"
"time of the call, it will either return the inferred proxy type\n"
"(see {#type=}) or +:proxy+"
msgstr ""
"proxyの型を返す。呼び出される時間で解決できない場合、\n"
"予想されるproxyの型(see {#type=})や +:proxy+ を返す。"

# @see
#: ../lib/yard/code_objects/proxy.rb:156
msgid "tag|see|#type="
msgstr ""

# @return [Symbol]
#: ../lib/yard/code_objects/proxy.rb:156
msgid "the Proxy's type"
msgstr "Proxyの型"

# YARD::CodeObjects::Proxy#type=
#: ../lib/yard/code_objects/proxy.rb:165
msgid "Allows a parser to infer the type of the proxy by its path."
msgstr "パスによってproxyの型を推測する為に、パーサーを受け入れる。"

# @param [#to_sym]
# @param [Symbol]
#: ../lib/yard/code_objects/proxy.rb:167 ../lib/yard/handlers/ruby/base.rb:102
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:16
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:37
#: ../lib/yard/parser/ruby/ast_node.rb:110
#: ../lib/yard/parser/ruby/ast_node.rb:152
#: ../lib/yard/parser/source_parser.rb:139
#: ../lib/yard/parser/source_parser.rb:181 ../lib/yard/registry.rb:270
#: ../lib/yard/registry.rb:368 ../lib/yard/registry_store.rb:94
#: ../lib/yard/registry_store.rb:103
#: ../lib/yard/templates/helpers/html_helper.rb:154
#: ../lib/yard/templates/helpers/html_helper.rb:364
#: ../lib/yard/templates/helpers/markup_helper.rb:149
#: ../lib/yard/templates/helpers/markup_helper.rb:159
msgid "tag|param|type"
msgstr "type"

# @param [#to_sym] type
#: ../lib/yard/code_objects/proxy.rb:167
msgid "the proxy's inferred type"
msgstr "推察されたproxyの型"

# YARD::CodeObjects::Proxy#method_missing
#: ../lib/yard/code_objects/proxy.rb:189
msgid "Dispatches the method to the resolved object."
msgstr "解決したオブジェクトにメソッドを送る"

# @raise [ProxyMethodError]
#: ../lib/yard/code_objects/proxy.rb:191
msgid "if the proxy cannot find the real object"
msgstr "proxyが実際のオブジェクトを見つけられない場合"

# YARD::CodeObjects::Proxy#root?
#: ../lib/yard/code_objects/proxy.rb:213
msgid "This class is never a root object"
msgstr "このクラスrootオブジェクトにはならない"

# @note
#: ../lib/yard/code_objects/proxy.rb:218
msgid "this method fixes a bug in 1.9.2: http://gist.github.com/437136"
msgstr ""
"このメソッドはバグを修正する。\n"
"(in 1.9.2: http://gist.github.com/4371369)"

# YARD::CodeObjects::Proxy#to_obj
#: ../lib/yard/code_objects/proxy.rb:221
msgid ""
"Attempts to find the object that this unresolved object\n"
"references by checking if any objects by this name are\n"
"registered all the way up the namespace tree."
msgstr ""
"この名前によって任意のオブジェクトが\n"
"namespaceツリーの変更を記録する場合、\n"
"これがチェックするオブジェクトの参照が\n"
"未解決だったオブジェクトを見つける為に試みる。"

# @return [Base, nil]
#: ../lib/yard/code_objects/proxy.rb:225
msgid "the registered code object or nil"
msgstr "記録されるコードオブジェクト、又は、nil"

# YARD::CodeObjects::RootObject
#: ../lib/yard/code_objects/root_object.rb:4
msgid ""
"Represents the root namespace object (the invisible Ruby module that\n"
"holds all top level modules, class and other objects)."
msgstr ""
"root namespaceオブジェクトを表す(全てのtop levelのモジュール,クラス,他のオブ"
"ジェクトを把握する隠れたRubyモジュール)"

# YARD::Config
#: ../lib/yard/config.rb:3
msgid ""
"This class maintains all system-wide configuration for YARD and handles\n"
"the loading of plugins. To access options call {options}, and to load\n"
"a plugin use {load_plugin}. All other public methods are used by YARD\n"
"during load time."
msgstr ""
"このクラスは\n"
"YARDとプラグインのロードを操作するシステム全体の設定を維持する。\n"
"設定を呼び出す{options}にアクセスする為や、\n"
"プラグインを使う{load_plugin}をロードする事を目的に、\n"
"全ての他のpublicなメソッドが、\n"
"ロード中にYARDによって利用される。"

# YARD::Config
#: ../lib/yard/config.rb:8
msgid "== User Configuration Files"
msgstr "== ユーザー設定ファイル"

# YARD::Config
#: ../lib/yard/config.rb:10
msgid ""
"Persistent user configuration files can be stored in the file\n"
"+~/.yard/config+, which is read when YARD first loads. The file should\n"
"be formatted as YAML, and should contain a map of keys and values."
msgstr ""
"persistent(長く使った)ユーザーの設定ファイルは、+~/.yard/config+ ファイルの中"
"に記録される。\n"
"そして、YARDが最初にロードする時に、読み出される。\n"
"このファイルはYAMLのように書式化される、\n"
"そして、キーや値のマップを含んでいるはずである。"

# YARD::Config
#: ../lib/yard/config.rb:14
msgid ""
"Although you can specify any key-value mapping in the configuration file,\n"
"YARD defines special keys specified in {DEFAULT_CONFIG_OPTIONS}."
msgstr ""
"あなたは、設定ファイルの中に任意のキーや値のマッピングを指定できるけれど"
"も、\n"
"YARDは{DEFAULT_CONFIG_OPTIONS}の中の規定の特別なキーを定義する。"

# YARD::Config
#: ../lib/yard/config.rb:17
msgid "An example of a configuration file is listed below:"
msgstr "設定ファイルの例は次のよう記述される。"

# YARD::Config
#: ../lib/yard/config.rb:19
msgid ""
"    !!!yaml\n"
"    load_plugins: true # Auto-load plugins when YARD starts\n"
"    ignored_plugins:\n"
"      - yard-broken\n"
"      - broken2 # yard- prefix not necessary\n"
"    autoload_plugins:\n"
"      - yard-rspec"
msgstr ""

# YARD::Config
#: ../lib/yard/config.rb:27
msgid "== Automatic Loading of Plugins"
msgstr "== プラグインの自動ロード"

# YARD::Config
#: ../lib/yard/config.rb:29
msgid ""
"YARD 0.6.2 will no longer automatically load all plugins by default. This\n"
"option can be reset by setting 'load_plugins' to true in the configuration\n"
"file. In addition, you can specify a set of specific plugins to load on\n"
"load through the 'autoload_plugins' list setting. This setting is\n"
"independent of the 'load_plugins' value and will always be processed."
msgstr ""
"YARD 0.6.2からは、デフォルトで全てのプラグインを自動ロードしない。\n"
"この設定は、設定ファイルの中の'load_plugins'をtrueに設定する事によってリセッ"
"トできる。\n"
"さらに、あなたは、\n"
"'autoload_plugins'リストのセッティングを通して、\n"
"ロード毎に特定のプラグインの設定を指定できる。\n"
"特定のプラグインのグループを指定できる。\n"
"この設定は、'load_plugins'の独自の値となり、そして常に処理されるだろう。"

# YARD::Config
#: ../lib/yard/config.rb:35
msgid "== Ignored Plugins File"
msgstr "== プラグインファイルを無視する"

# YARD::Config
#: ../lib/yard/config.rb:37
msgid ""
"YARD 0.5 and below used a +~/.yard/ignored_plugins+ file to specify\n"
"plugins to be ignored at load time. Ignored plugins in 0.6.2 and above\n"
"should now be specified in the main configuration file, though YARD\n"
"will support the +ignored_plugins+ file until 0.7.x."
msgstr ""
"YARD 0.5やそれ以下では、\n"
"ロード時間で無視されるプラグインを指定する為に\n"
"+~/.yard/ignored_plugins+ ファイルを利用した。\n"
"0.6.2以上で無視されるプラグインは、\n"
"現在、主に設定ファイルの中で規定されるはずである。\n"
"とはいえ,YARDは +ignored_pluginis+ ファイルを0.7.xまで、サポートする。"

# YARD::Config
#: ../lib/yard/config.rb:42
msgid "== Safe Mode"
msgstr "== セーフモード"

# YARD::Config
#: ../lib/yard/config.rb:44
msgid ""
"YARD supports running in safe-mode. By doing this, it will avoid executing\n"
"any user code such as require files or queries. Plugins will still be\n"
"loaded with safe mode on, because plugins are properly namespaced with\n"
"a 'yard-' prefix, must be installed as a gem, and therefore cannot be\n"
"touched by the user. To specify safe mode, use the +safe_mode+ key."
msgstr ""
"YARDはセーフモードでの起動をサポートする。\n"
"これを行うことにより、requireファイルやクエリーのような\n"
"任意のユーザーコードの実行を無効にする。\n"
"しかし、プラグインはセーフモードの実行と共にロードされる。\n"
"何故なら、プラグインは、'yard-'プレフィックスと共に、\n"
"適切にnamespaceが設定され,\n"
"gemのようにインストールされるはずである,\n"
"そして、これ自身の設定はユーザーによって変更できない。\n"
"セーフモードを指定するには、 +safe_mode+ キーを利用する。"

# YARD::Config
#: ../lib/yard/config.rb:50
msgid "== Plugin Specific Configuration"
msgstr "== プラグインの詳細な設定"

# YARD::Config
#: ../lib/yard/config.rb:52
msgid ""
"Additional settings can be defined within the configuration file\n"
"specifically to provide configuration for a plugin. A plugin that utilizes\n"
"the YARD configuration is strongly encouraged to utilize namespacing of\n"
"their configuration content."
msgstr ""
"追加の設定は\n"
"プラグイン用の設定を提供する為に、\n"
"明確に設定ファイルの中で\n"
"定義される。\n"
"YARDの設定を利用するプラグインは、\n"
"その設定内容のnamespaceを利用する為に\n"
"強力に後押しされる。"

# YARD::Config
#: ../lib/yard/config.rb:57
msgid ""
"    !!!yaml\n"
"    load_plugins: true # Auto-load plugins when YARD starts\n"
"    ignored_plugins:\n"
"      - yard-broken\n"
"      - broken2 # yard- prefix not necessary\n"
"    autoload_plugins:\n"
"      - yard-rspec\n"
"    # Plugin Specific Configuration\n"
"    yard-sample-plugin:\n"
"      show-results-inline: true"
msgstr ""

# YARD::Config
#: ../lib/yard/config.rb:68
msgid ""
"As the configuration is available system wide, it can be\n"
"accessed within the plugin code."
msgstr ""
"この設定はシステム全体に及び、\n"
"プラグインのコードの中で、アクセスできる。"

# YARD::Config
#: ../lib/yard/config.rb:72
msgid ""
"    if YARD::Config.options['yard-sample-plugin'] and\n"
"      YARD::Config.options['yard-sample-plugin']['show-results-inline']\n"
"      # ... perform the action that places the results inline ...\n"
"    else\n"
"      # ... do the default behavior of not showing the results inline ...\n"
"    end"
msgstr ""

# YARD::Config
#: ../lib/yard/config.rb:79
msgid ""
"When accessing the configuration, be aware that this file is user managed\n"
"so configuration keys and values may not be present. Make no assumptions "
"and\n"
"instead ensure that you check for the existence of keys before proceeding "
"to\n"
"retrieve values."
msgstr ""
"設定にアクセスする時、\n"
"このファイルはユーザーが扱う事に注意する。\n"
"なので、キーや値の設定は見つからないかもしれない。\n"
"勝手に作成しない代わりに、\n"
"あなたが値を取り出す手続きをする前にキーの存在の管理する事を保証する。"

# @see
#: ../lib/yard/config.rb:85
msgid "tag|see|options"
msgstr ""

# YARD::Config.options
# YARD::Config.options=
#: ../lib/yard/config.rb:88
msgid "The system-wide configuration options for YARD"
msgstr "YARD用のシステム全体の設定オプション"

# @return [SymbolHash]
#: ../lib/yard/config.rb:90
msgid "a map a key-value pair settings."
msgstr "キー,値のペア設定のマップ"

# @see
#: ../lib/yard/config.rb:90
msgid "tag|see|DEFAULT_CONFIG_OPTIONS"
msgstr ""

# YARD::Config::CONFIG_DIR
#: ../lib/yard/config.rb:94
msgid "The location where YARD stores user-specific settings"
msgstr "YARDがユーザー固有の設定を記録する場所"

# YARD::Config::CONFIG_FILE
#: ../lib/yard/config.rb:97
msgid "The main configuration YAML file."
msgstr "YAMLファイルの主な設定"

# YARD::Config::IGNORED_PLUGINS
#: ../lib/yard/config.rb:100
msgid "File listing all ignored plugins"
msgstr "ファイルに記述する、無視されるプラグイン"

# @deprecated
#: ../lib/yard/config.rb:101
msgid "Set `ignored_plugins` in the {CONFIG_FILE} instead."
msgstr "{CONFIG_FILE}の代わりに、`ignored_plugins`を設定する。"

# YARD::Config::DEFAULT_CONFIG_OPTIONS
#: ../lib/yard/config.rb:104
msgid "Default configuration options"
msgstr "デフォルトの設定オプション"

# YARD::Config::YARD_PLUGIN_PREFIX
#: ../lib/yard/config.rb:112
msgid ""
"The prefix used for YARD plugins. Name your gem with this prefix\n"
"to allow it to be used as a plugin."
msgstr ""
"プレフィックスは、YARDプラグイン用に利用される。\n"
"あなたのgemがプラグインの様に利用される為に、\n"
"このプレフィックスと共に名付ける。"

# YARD::Config.load
#: ../lib/yard/config.rb:116
msgid ""
"Loads settings from {CONFIG_FILE}. This method is called by YARD at\n"
"load time and should not be called by the user."
msgstr ""
"{CONFIG_FILE}からの設定をロードする。\n"
"これメソッドは、ロード時間でYARDによって呼び出される。\n"
"そして、ユーザーによって呼び出されないはずである。"

# YARD::Config.save
#: ../lib/yard/config.rb:132
msgid "Saves settings to {CONFIG_FILE}."
msgstr "{CONFIG_FILE}の為の設定を保存する。"

# @deprecated
#: ../lib/yard/config.rb:143
msgid "Use {Config.load_plugins}"
msgstr ""

# @return [Boolean]
#: ../lib/yard/config.rb:143
msgid "true if all plugins loaded successfully, false otherwise."
msgstr "全てのプラグインが正しくロードした場合、true、そうでなければ、false"

# YARD::Config.load_plugin
#: ../lib/yard/config.rb:150
msgid ""
"Loads an individual plugin by name. It is not necessary to include the\n"
"+yard-+ plugin prefix here."
msgstr ""
"名前によって、個々のプラグインをロードする。\n"
"ここで +yard-+ プラグインのプレフィックスを含む必要は無い。"

# @param [String] name
#: ../lib/yard/config.rb:154
msgid "the name of the plugin (with or without +yard-+ prefix)"
msgstr "プラグインの名前( +yard-+ プレフィックスの有無にかかわらず)"

# @return [Boolean]
#: ../lib/yard/config.rb:154
msgid "whether the plugin was successfully loaded"
msgstr "プラグインがロードに成功したかどうか"

# YARD::Config.load_gem_plugins
#: ../lib/yard/config.rb:168
msgid "Load gem plugins if :load_plugins is true"
msgstr ":load_pluginsがtrueの場合、gemプラグインをロードする"

# YARD::Config.load_autoload_plugins
#: ../lib/yard/config.rb:188
msgid "Load plugins set in :autoload_plugins"
msgstr ":autoload_pluginsの中のグループのプラグインをロードする。"

# YARD::Config.load_commandline_plugins
#: ../lib/yard/config.rb:193
msgid "Load plugins from {#arguments}"
msgstr "(#arguments)メソッドからプラグインをロードする。"

# YARD::Config.load_commandline_safemode
#: ../lib/yard/config.rb:203
msgid "Check for command-line safe_mode switch in {#arguments}"
msgstr ""

# YARD::Config.load_plugin_failed
#: ../lib/yard/config.rb:212
msgid "Print a warning if the plugin failed to load"
msgstr "ロードに失敗したプラグインの場合、警告をプリントする。"

# YARD::Config.add_ignored_plugins_file
#: ../lib/yard/config.rb:220
msgid "Legacy support for {IGNORED_PLUGINS}"
msgstr "{IGNORED_PLUGINS}用のレガシーサポート"

# YARD::Config.translate_plugin_names
#: ../lib/yard/config.rb:227
msgid "Translates plugin names to add yard- prefix."
msgstr "yard-プレフィックスを追加する為にプラグイン名を翻訳する。"

# YARD::Config.read_config_file
#: ../lib/yard/config.rb:233
msgid "Loads the YAML configuration file into memory"
msgstr "メモリの中にYAML設定ファイルをロードする。"

# @see
#: ../lib/yard/config.rb:235
msgid "tag|see|CONFIG_FILE"
msgstr ""

# @return [Hash]
#: ../lib/yard/config.rb:235
msgid "the contents of the YAML file from disk"
msgstr "ディスクからのYAMLファイルの内容"

# YARD::Config.translate_plugin_name
#: ../lib/yard/config.rb:245
msgid "Sanitizes and normalizes a plugin name to include the 'yard-' prefix."
msgstr "'yard-'プレフィックスを含んでいるプラグイン名を正規化する。"

# @param [String] name
#: ../lib/yard/config.rb:247
msgid "the plugin name"
msgstr "プラグイン名"

# @return [String]
#: ../lib/yard/config.rb:247
msgid "the sanitized and normalized plugin name."
msgstr "正規化されるプラグイン名"

# YARD::Config.with_yardopts
#: ../lib/yard/config.rb:254
msgid "Temporarily loads .yardopts file into @yardopts"
msgstr "@yardoptsの中に、.yardoptsファイルを一時的にロードする。"

# @return [Array<String>]
#: ../lib/yard/config.rb:263
msgid "arguments from commandline and yardopts file"
msgstr "コマンドラインやyardoptsファイルからの引数"

# Array#place
#: ../lib/yard/core_ext/array.rb:3
msgid ""
"Places values before or after another object (by value) in\n"
"an array. This is used in tandem with the before and after\n"
"methods of the {Insertion} class."
msgstr ""
"配列の前後に他のオブジェクト(値として)の値を置く\n"
"これは、前後に{Insertion}クラスのメソッドを用いている。"

# @example Places an item before another
#: ../lib/yard/core_ext/array.rb:14
msgid "[1, 2, 3].place(4).before(3) # => [1, 2, 4, 3]"
msgstr ""

# @example Places an item after another
#: ../lib/yard/core_ext/array.rb:14
msgid "[:a, :b, :c].place(:x).after(:a) # => [:a, :x, :b, :c]"
msgstr ""

# @return [Insertion]
#: ../lib/yard/core_ext/array.rb:14
msgid "an insertion object to"
msgstr "挿入されたオブジェクト"

# @example
#: ../lib/yard/core_ext/array.rb:14
msgid "tag|example|Places an item after another"
msgstr "後ろに別の要素を置く"

# @example
#: ../lib/yard/core_ext/array.rb:14
msgid "tag|example|Places an item before another"
msgstr "前に別の要素を置く"

# @param [Array]
#: ../lib/yard/core_ext/array.rb:14
msgid "tag|param|values"
msgstr "values"

# @see
#: ../lib/yard/core_ext/array.rb:14
msgid "tag|see|Insertion#after"
msgstr ""

# @see
#: ../lib/yard/core_ext/array.rb:14
msgid "tag|see|Insertion#before"
msgstr ""

# @param [Array] values
#: ../lib/yard/core_ext/array.rb:14
msgid "value to insert"
msgstr "挿入する値"

# File.relative_path
#: ../lib/yard/core_ext/file.rb:10
msgid ""
"Turns a path +to+ into a relative path from starting\n"
"point +from+. The argument +from+ is assumed to be\n"
"a filename. To treat it as a directory, make sure it\n"
"ends in +File::SEPARATOR+ ('/' on UNIX filesystems)."
msgstr ""
"+from+ で始まる場所から、相対パスの情報へパスを変える。\n"
"+from+ の引数は、ファイル名になるように処理される。\n"
"ディレクトリとして取得するには、 +File::SEPARATOR+ で終わる必要がある。\n"
"(UNIX上のファイルシステムなら、'/')"

# File.relative_path
# File.cleanpath
#: ../lib/yard/core_ext/file.rb:18 ../lib/yard/core_ext/file.rb:35
msgid "Manipulating Paths"
msgstr "パスを操作する"

# @param [String]
#: ../lib/yard/core_ext/file.rb:18
msgid "tag|param|from"
msgstr "from"

# @param [String]
#: ../lib/yard/core_ext/file.rb:18
msgid "tag|param|to"
msgstr "to"

# @param [String] to
#: ../lib/yard/core_ext/file.rb:18
msgid "the final path that should be made relative."
msgstr "対応して作られる最後のパス"

# @return [String]
#: ../lib/yard/core_ext/file.rb:18
msgid "the relative path from +from+ to +to+."
msgstr "+from+ から +to+ への相対パス"

# @param [String] from
#: ../lib/yard/core_ext/file.rb:18
msgid ""
"the starting filename\n"
"(or directory with +from_isdir+ set to +true+)."
msgstr ""
"ファイル名(又は +from_isdir+ を +true+ を設定した場合はディレクトリ)の文字列"

# File.cleanpath
#: ../lib/yard/core_ext/file.rb:30
msgid "Cleans a path by removing extraneous '..', '.' and '/' characters"
msgstr "無関係の '..', '.', '/' 文字を削除し、パスをきれいにする。"

# @example Clean a path
#: ../lib/yard/core_ext/file.rb:35
msgid "File.cleanpath('a/b//./c/../e') # => \"a/b/e\""
msgstr ""

# @example
#: ../lib/yard/core_ext/file.rb:35
msgid "tag|example|Clean a path"
msgstr "pathをきれいにする"

# @param [String]
# @param [Array<String, Symbol>]
# @param [String, :root]
#: ../lib/yard/core_ext/file.rb:35 ../lib/yard/i18n/message.rb:34
#: ../lib/yard/registry.rb:235 ../lib/yard/server.rb:7
#: ../lib/yard/server/doc_server_helper.rb:65
#: ../lib/yard/templates/engine.rb:20 ../lib/yard/templates/engine.rb:34
#: ../lib/yard/templates/engine.rb:52 ../lib/yard/templates/engine.rb:160
#: ../lib/yard/templates/engine.rb:175 ../lib/yard/templates/template.rb:182
msgid "tag|param|path"
msgstr "path"

# @param [String] path
#: ../lib/yard/core_ext/file.rb:35
msgid "the path to clean"
msgstr "きれいにするパス"

# @return [String]
#: ../lib/yard/core_ext/file.rb:35
msgid "the sanitized path"
msgstr "きれいにされたパス"

# File.open!
#: ../lib/yard/core_ext/file.rb:51
msgid ""
"Forces opening a file (for writing) by first creating the file's directory"
msgstr ""
"最初にファイルのディレクトリを作成する事によって、開くファイル(書込み用)を強"
"制する。"

# @since
#: ../lib/yard/core_ext/file.rb:53
msgid "0.5.2"
msgstr ""

# File.open!
# File.read_binary
#: ../lib/yard/core_ext/file.rb:53 ../lib/yard/core_ext/file.rb:62
msgid "Reading Files"
msgstr "ファイルを読み込む"

# @param [String] file
#: ../lib/yard/core_ext/file.rb:53
msgid "the filename to open"
msgstr "展開するファイル名"

# File.read_binary
#: ../lib/yard/core_ext/file.rb:60
msgid "Reads a file with binary encoding"
msgstr "バイナリコードにしてファイルを読み込む"

# @return [String]
#: ../lib/yard/core_ext/file.rb:62
msgid "the ascii-8bit encoded data"
msgstr "ascii-8bitにエンコードされたデータ"

# Insertion
#: ../lib/yard/core_ext/insertion.rb:2
msgid ""
"The Insertion class inserts a value before or after another\n"
"value in a list."
msgstr "Insertionクラスはリストの中の前後に他の値を挿入する。"

# @example 
#: ../lib/yard/core_ext/insertion.rb:6
msgid "Insertion.new([1, 2, 3], 4).before(3) # => [1, 2, 4, 3]"
msgstr ""

# Insertion#initialize
#: ../lib/yard/core_ext/insertion.rb:8
msgid ""
"Creates an insertion object on a list with a value to be\n"
"inserted. To finalize the insertion, call {#before} or\n"
"{#after} on the object."
msgstr ""
"挿入される値と共にリスト上のinsertionオブジェクトを作成する。\n"
"最終的にinsertionは、オブジェクト上の{#before}や{#after}メソッドを呼び出す。"

# @return [Insertion]
#: ../lib/yard/core_ext/insertion.rb:13
msgid "a new instance of Insertion"
msgstr "Insertionの新しいインスタンス"

# @param [Array<CodeObjects::Base>]
# @param [Array<String>]
# @param [Array]
#: ../lib/yard/core_ext/insertion.rb:13 ../lib/yard/core_ext/insertion.rb:45
#: ../lib/yard/templates/helpers/base_helper.rb:29
#: ../lib/yard/templates/helpers/base_helper.rb:165
#: ../lib/yard/templates/helpers/module_helper.rb:10
#: ../lib/yard/verifier.rb:90
msgid "tag|param|list"
msgstr "list"

# @param [Array] list
#: ../lib/yard/core_ext/insertion.rb:13
msgid "the list to perform the insertion on"
msgstr "insertionで実行するリスト"

# @param [Object] value
# @param [Object] val
#: ../lib/yard/core_ext/insertion.rb:13 ../lib/yard/core_ext/insertion.rb:45
msgid "the value to insert"
msgstr "挿入する値"

# Insertion#before
#: ../lib/yard/core_ext/insertion.rb:16
msgid "Inserts the value before +val+"
msgstr "+val+ の前に値を挿入する"

# @param [Boolean] recursive
#: ../lib/yard/core_ext/insertion.rb:18 ../lib/yard/core_ext/insertion.rb:26
#: ../lib/yard/core_ext/insertion.rb:45
msgid "look inside sublists"
msgstr "ネストした配列の内部をみるかどうか"

# @param [Boolean]
#: ../lib/yard/core_ext/insertion.rb:18 ../lib/yard/core_ext/insertion.rb:26
#: ../lib/yard/core_ext/insertion.rb:45
msgid "tag|param|recursive"
msgstr "recursive"

# @param [Object]
#: ../lib/yard/core_ext/insertion.rb:18 ../lib/yard/core_ext/insertion.rb:26
#: ../lib/yard/core_ext/insertion.rb:45
msgid "tag|param|val"
msgstr "val"

# @param [Object] val
#: ../lib/yard/core_ext/insertion.rb:18
msgid "the object the value will be inserted before"
msgstr "値が前に挿入される,オブジェクト"

# Insertion#after
#: ../lib/yard/core_ext/insertion.rb:21
msgid "Inserts the value after +val+."
msgstr "+val+ の前に値を挿入する"

# @example If subsections are ignored
#: ../lib/yard/core_ext/insertion.rb:26
msgid "Insertion.new([1, [2], 3], :X).after(1) # => [1, [2], :X, 3]"
msgstr ""

# @example
#: ../lib/yard/core_ext/insertion.rb:26
msgid "tag|example|If subsections are ignored"
msgstr "ネストした配列が無視される場合"

# @param [Object] val
#: ../lib/yard/core_ext/insertion.rb:26
msgid "the object the value will be inserted after"
msgstr "値が前に挿入される,オブジェクト"

# Insertion#before_any
#: ../lib/yard/core_ext/insertion.rb:29
msgid "Alias for {#before} with +recursive+ set to true"
msgstr "+recursive+ にtrueを設定する{#before}メソッド用のエイリアス"

# Insertion#after_any
#: ../lib/yard/core_ext/insertion.rb:33
msgid "Alias for {#after} with +recursive+ set to true"
msgstr "+recursive+ にtrueを設定する{#after}メソッド用のエイリアス"

# Insertion#insertion
#: ../lib/yard/core_ext/insertion.rb:39
msgid "This method performs the actual insertion"
msgstr "このメソッドが、実際にinsertionを実行する。"

# @param [Fixnum]
#: ../lib/yard/core_ext/insertion.rb:45
msgid "tag|param|rel"
msgstr "rel"

# @param [Array] list
#: ../lib/yard/core_ext/insertion.rb:45
msgid "the list to place objects into"
msgstr "オブジェクトの情報を置く為のリスト"

# @param [Fixnum] rel
#: ../lib/yard/core_ext/insertion.rb:45
msgid ""
"the relative index (0 or 1) of where the object\n"
"should be placed"
msgstr "オブジェクトが置かれる所の相対インデックス(0又は1)"

# Module#class_name
#: ../lib/yard/core_ext/module.rb:3
msgid "Returns the class name of a full module namespace path"
msgstr "モジュールの完全なnamespaceパスのクラス名を返す"

# @example 
#: ../lib/yard/core_ext/module.rb:7
msgid "module A::B::C; class_name end # => \"C\""
msgstr ""

# @return [String]
#: ../lib/yard/core_ext/module.rb:7
msgid "the last part of a module path"
msgstr "モジュールパスの最後の部分"

# @return [String]
#: ../lib/yard/core_ext/module.rb:16
msgid "the namespace minus the class/module name"
msgstr "クラス/モジュール名を引いたnamespace"

# String#shell_split
#: ../lib/yard/core_ext/string.rb:3
msgid ""
"Splits text into tokens the way a shell would, handling quoted\n"
"text as a single token. Use '\\\"' and \"\\'\" to escape quotes and\n"
"'\\\\' to escape a backslash."
msgstr ""
"シェルの場合テキスト情報のトークンを分割し、\n"
"単一のトークンとしてクオートされたテキストを操作する。\n"
"エスケープをクオートするには、'\\\"'と\"\\'\"、\n"
"バックスラッシュをエスケープするには'\\\\'を使う。"

# @return [Array]
#: ../lib/yard/core_ext/string.rb:7
msgid "an array representing the tokens"
msgstr "トークンを表す配列"

# SymbolHash
#: ../lib/yard/core_ext/symbol_hash.rb:2
msgid ""
"A subclass of Hash where all keys are converted into Symbols, and\n"
"optionally, all String values are converted into Symbols."
msgstr ""
"全てのキーがSymbolsに変換される所のハッシュのサブクラス、\n"
"自由に全てのStringの値をSymblosに変換できる。"

# SymbolHash#initialize
#: ../lib/yard/core_ext/symbol_hash.rb:5
msgid "Creates a new SymbolHash object"
msgstr "新しいSymbolHashオブジェクトを作成する"

# @return [SymbolHash]
#: ../lib/yard/core_ext/symbol_hash.rb:8
msgid "a new instance of SymbolHash"
msgstr "SymbolHashの新しいインスタンス"

# @param [Boolean] symbolize_value
#: ../lib/yard/core_ext/symbol_hash.rb:8
msgid ""
"converts any String values into Symbols\n"
"if this is set to +true+."
msgstr ""
"この設定がtrueの場合、\n"
"全てのStringの値をSymbolへ変換する。"

# @param [Boolean]
#: ../lib/yard/core_ext/symbol_hash.rb:8
msgid "tag|param|symbolize_value"
msgstr "symbolize_value"

# @overload
#: ../lib/yard/core_ext/symbol_hash.rb:27
msgid "tag|overload|[]"
msgstr ""

# SymbolHash#[]=
#: ../lib/yard/core_ext/symbol_hash.rb:38
msgid "Assigns a value to a symbolized key"
msgstr "シンボル化されたキーに値を割り当てる"

# @param [#to_sym] key
#: ../lib/yard/core_ext/symbol_hash.rb:41
msgid "the key"
msgstr "キー"

# @param [Object] value
#: ../lib/yard/core_ext/symbol_hash.rb:41
msgid ""
"the value to be assigned. If this is a String and\n"
"values are set to be symbolized, it will be converted into a Symbol."
msgstr ""
"割り当てられる値。\n"
"これが、文字列の場合には、値がシンボル化される為に設定され、\n"
"シンボルへ変換されるだろう。"

# SymbolHash#[]
#: ../lib/yard/core_ext/symbol_hash.rb:46
msgid "Accessed a symbolized key"
msgstr "シンボル化されるキーにアクセスされる"

# @param [#to_sym] key
#: ../lib/yard/core_ext/symbol_hash.rb:48
msgid "the key to access"
msgstr "アクセスする為のキー"

# @return [Object]
#: ../lib/yard/core_ext/symbol_hash.rb:48
msgid "the value associated with the key"
msgstr "キーに関連付けられた値"

# SymbolHash#delete
#: ../lib/yard/core_ext/symbol_hash.rb:51
msgid "Deleted a key and value associated with it"
msgstr "関連付けられたキーと値が削除される"

# @param [#to_sym] key
#: ../lib/yard/core_ext/symbol_hash.rb:53 ../lib/yard/registry_store.rb:72
msgid "the key to delete"
msgstr "削除するキー"

# SymbolHash#has_key?
#: ../lib/yard/core_ext/symbol_hash.rb:56
msgid "Tests if a symbolized key exists"
msgstr "シンボル化されたキーがあるかテストする"

# @param [#to_sym] key
#: ../lib/yard/core_ext/symbol_hash.rb:58
msgid "the key to test"
msgstr "テストするキー"

# @return [Boolean]
#: ../lib/yard/core_ext/symbol_hash.rb:58
msgid "whether the key exists"
msgstr "キーが存在するかどうか"

# SymbolHash#update
# SymbolHash#merge!
#: ../lib/yard/core_ext/symbol_hash.rb:61
#: ../lib/yard/core_ext/symbol_hash.rb:67
msgid ""
"Updates the object with the contents of another Hash object.\n"
"This method modifies the original SymbolHash object"
msgstr ""
"他のハッシュオブジェクトの内容と共にオブジェクトを更新する。\n"
"このメソッドは元のSymbolHashオブジェクトを変更する。"

# @param [Hash]
#: ../lib/yard/core_ext/symbol_hash.rb:65
#: ../lib/yard/core_ext/symbol_hash.rb:72
msgid "tag|param|hash"
msgstr ""

# @param [Hash] hash
#: ../lib/yard/core_ext/symbol_hash.rb:65
msgid "the hash object to copy the values from"
msgstr "ハッシュオブジェクトから値をコピーする,ハッシュ"

# SymbolHash#merge
#: ../lib/yard/core_ext/symbol_hash.rb:69
msgid "Merges the contents of another hash into a new SymbolHash object"
msgstr "新しいSymbolHashオブジェクトへ他のハッシュの内容をマージする。"

# @return [SymbolHash]
#: ../lib/yard/core_ext/symbol_hash.rb:72
msgid "a new SymbolHash containing the merged data"
msgstr "マージされたデータを含んでいる新しいSymbolHash"

# @param [Hash] hash
#: ../lib/yard/core_ext/symbol_hash.rb:72
msgid "the hash of objects to copy"
msgstr "コピーするオブジェクトのハッシュ"

# YARD::Docstring
#: ../lib/yard/docstring.rb:3
msgid ""
"A documentation string, or \"docstring\" for short, encapsulates the\n"
"comments and metadata, or \"tags\", of an object. Meta-data is expressed\n"
"in the form +@tag VALUE+, where VALUE can span over multiple lines as\n"
"long as they are indented. The following +@example+ tag shows how tags\n"
"can be indented:"
msgstr ""
"documentation stringを略して\"docstring\"は、\n"
"コメントやメタデータ,オブジェクトのタグをカプセル化する。\n"
"メタデータは +@tag VALUE+ から\n"
"VALUEがインデントされる間の複数行に渡って表される。\n"
"次の +@example+ タグは\n"
"タグがどのようにインデントされるか表す。"

# YARD::Docstring
#: ../lib/yard/docstring.rb:9
msgid ""
"  # @example My example\n"
"  #   a = \"hello world\"\n"
"  #   a.reverse\n"
"  # @version 1.0"
msgstr ""

# YARD::Docstring
#: ../lib/yard/docstring.rb:14
msgid ""
"Tags can be nested in a documentation string, though the {Tags::Tag}\n"
"itself is responsible for parsing the inner tags."
msgstr ""
"タグはドキュメント文字列の中でネストされ、{Tags::Tag}自身は、\n"
"中のタグを解析する責任がある。"

# @note
#: ../lib/yard/docstring.rb:27
msgid ""
"Plugin developers should make sure to reset this value\n"
"after parsing finishes. This can be done via the\n"
"{Parser::SourceParser.after_parse_list} callback. This will\n"
"ensure that YARD can properly parse multiple projects in\n"
"the same process."
msgstr ""

# @param [Docstring]
#: ../lib/yard/docstring.rb:27
msgid "tag|see|DocstringParser"
msgstr ""

# @see
#: ../lib/yard/docstring.rb:27
msgid "tag|see|Parser::SourceParser.after_parse_list"
msgstr ""

# @return [Class<DocstringParser>]
#: ../lib/yard/docstring.rb:27
msgid ""
"the parser class used to parse\n"
"text and optional meta-data from docstrings. Defaults to\n"
"{DocstringParser}."
msgstr ""

# YARD::Docstring.parser
#: ../lib/yard/docstring.rb:30
msgid ""
"Creates a parser object using the current {default_parser}.\n"
"Equivalent to:\n"
"  Docstring.default_parser.new(*args)"
msgstr ""

# @param args
#: ../lib/yard/docstring.rb:37
msgid ""
"arguments are passed to the {DocstringParser}\n"
"class. See {DocstringParser#initialize} for details on\n"
"arguments."
msgstr ""

# @return [Object, nil]
#: ../lib/yard/docstring.rb:37
msgid ""
"the parser object used to parse a\n"
"docstring."
msgstr "docstringを解析する為に利用したパーサーオブジェクト。"

# @return [Array<Tags::RefTag>]
#: ../lib/yard/docstring.rb:43
msgid "the list of reference tags"
msgstr "参照タグのリスト"

# @return [CodeObjects::Base]
#: ../lib/yard/docstring.rb:46
msgid "the object that owns the docstring."
msgstr "docstring自身のオブジェクト"

# @return [Range]
#: ../lib/yard/docstring.rb:49
msgid "line range in the {#object}'s file where the docstring was parsed from"
msgstr "解析されるdocstringの{#object}ファイルの中のline range"

# @return [String]
#: ../lib/yard/docstring.rb:52
msgid "the raw documentation (including raw tag text)"
msgstr "未加工のドキュメント(未加工のタグテキストを含んでいる)"

# @return [Boolean]
#: ../lib/yard/docstring.rb:55
msgid "whether the docstring was started with \"##\""
msgstr "docstringが\"##\"と共に記録される"

# YARD::Docstring::META_MATCH
#: ../lib/yard/docstring.rb:59
msgid "Matches a tag at the start of a comment line"
msgstr "コメント行の始まりでタグにマッチする。"

# @deprecated
#: ../lib/yard/docstring.rb:60
msgid "Use {DocstringParser::META_MATCH}"
msgstr ""

# YARD::Docstring.new!
#: ../lib/yard/docstring.rb:65
msgid ""
"Creates a new docstring without performing any parsing through\n"
"a {DocstringParser}. This method is called by +DocstringParser+\n"
"when creating the new docstring object."
msgstr ""

# YARD::Docstring#initialize
# YARD::Docstring#+
# YARD::Docstring#replace
# YARD::Docstring#dup
#: ../lib/yard/docstring.rb:74 ../lib/yard/docstring.rb:99
#: ../lib/yard/docstring.rb:112 ../lib/yard/docstring.rb:123
#: ../lib/yard/docstring.rb:129 ../lib/yard/docstring.rb:138
msgid "Creating a Docstring Object"
msgstr "Docstringオブジェクトを作成する"

# @param [String]
#: ../lib/yard/docstring.rb:74
msgid "tag|param|raw_data"
msgstr ""

# @param [Tags::Tag, Tags::RefTag]
#: ../lib/yard/docstring.rb:74 ../lib/yard/docstring.rb:214
msgid "tag|param|tags"
msgstr ""

# @param [String]
#: ../lib/yard/docstring.rb:74 ../lib/yard/parser/ruby/legacy/ruby_lex.rb:48
#: ../lib/yard/serializers/stdout_serializer.rb:25
#: ../lib/yard/tags/default_factory.rb:12
#: ../lib/yard/tags/default_factory.rb:21
#: ../lib/yard/tags/default_factory.rb:32
#: ../lib/yard/tags/default_factory.rb:44
#: ../lib/yard/tags/default_factory.rb:56
#: ../lib/yard/tags/default_factory.rb:98 ../lib/yard/tags/tag.rb:43
#: ../lib/yard/templates/helpers/html_helper.rb:16
#: ../lib/yard/templates/helpers/html_helper.rb:24
#: ../lib/yard/templates/helpers/html_helper.rb:36
#: ../lib/yard/templates/helpers/html_helper.rb:57
#: ../lib/yard/templates/helpers/html_helper.rb:73
#: ../lib/yard/templates/helpers/html_helper.rb:83
#: ../lib/yard/templates/helpers/html_helper.rb:91
#: ../lib/yard/templates/helpers/html_helper.rb:101
#: ../lib/yard/templates/helpers/html_helper.rb:109
#: ../lib/yard/templates/helpers/html_helper.rb:123
#: ../lib/yard/templates/helpers/html_helper.rb:180
#: ../lib/yard/templates/helpers/uml_helper.rb:26
msgid "tag|param|text"
msgstr ""

# @param [String] raw_data
#: ../lib/yard/docstring.rb:74
msgid ""
"the complete docstring, including all\n"
"original formatting and any unparsed tags/directives."
msgstr ""

# YARD::CodeObjects::Base#tags
#: ../lib/yard/docstring.rb:74
msgid "the list of tag objects in the docstring"
msgstr "docstringの中のタグオブジェクトのリスト"

# @param [CodeObjects::Base] object
#: ../lib/yard/docstring.rb:74
msgid ""
"the object associated with the\n"
"docstring. May be nil."
msgstr "docstringと共に関連したオブジェクト, nilになるかもしれない。"

# @return [CodeObjects::Base]
#: ../lib/yard/docstring.rb:74
msgid "the textual portion of the docstring"
msgstr "docstringの原文の一部"

# YARD::Docstring#initialize
#: ../lib/yard/docstring.rb:84
msgid ""
"Creates a new docstring with the raw contents attached to an optional\n"
"object. Parsing will be done by the {DocstringParser} class."
msgstr ""
"任意のオブジェクトに追加された未加工のコンテンツを用い新しいdocstringを作成する。\n"
"解析は {DocstringParser} クラスによって完了する。"

# @example 
#: ../lib/yard/docstring.rb:99
msgid "Docstring.new(\"hello world\\n@return Object return\", someobj)"
msgstr ""

# @note
#: ../lib/yard/docstring.rb:99
msgid ""
"To properly parse directives with proper parser context within\n"
"handlers, you should not use this method to create a Docstring.\n"
"Instead, use the {parser}, which takes a handler object that\n"
"can pass parser state onto directives. If a Docstring is created\n"
"with this method, directives do not have access to any parser\n"
"state, and may not function as expected."
msgstr ""

# @return [Docstring]
#: ../lib/yard/docstring.rb:99
msgid "a new instance of Docstring"
msgstr "Docstringの新しいインスタンス"

# @param [CodeObjects::Base] object
#: ../lib/yard/docstring.rb:99
msgid ""
"an object to associate the docstring\n"
"with."
msgstr "docstringと関連するオブジェクト"

# @param [TokenList, String]
# @param [String]
# @param [String, #read, Object]
#: ../lib/yard/docstring.rb:99 ../lib/yard/docstring.rb:123
#: ../lib/yard/docstring_parser.rb:106 ../lib/yard/docstring_parser.rb:123
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:16
#: ../lib/yard/parser/source_parser.rb:116
#: ../lib/yard/parser/source_parser.rb:125
#: ../lib/yard/parser/source_parser.rb:416
#: ../lib/yard/parser/source_parser.rb:460
msgid "tag|param|content"
msgstr "内容"

# @param [String] content
#: ../lib/yard/docstring.rb:99
msgid ""
"the raw comments to be parsed into a docstring\n"
"and associated meta-data."
msgstr "docstring,関連するメタデータの中で解析される未加工の内容,"

# YARD::Docstring#+
#: ../lib/yard/docstring.rb:108
msgid "Adds another {Docstring}, copying over tags."
msgstr "別の{Docstring}を追加し、タグをコピーする。"

# @return [Docstring]
#: ../lib/yard/docstring.rb:112
msgid "a new docstring with both docstrings combines"
msgstr "docstring化し,一体化(別のdocstringと)した、新しいdocstring"

# @param [Docstring, String] other
#: ../lib/yard/docstring.rb:112
msgid ""
"the other docstring (or string) to\n"
"add."
msgstr "他の追加するdocstring(やstring)"

# YARD::Docstring#replace
# YARD::Docstring#all=
#: ../lib/yard/docstring.rb:122 ../lib/yard/docstring.rb:130
msgid "Replaces the docstring with new raw content. Called by {#all=}."
msgstr ""
"{#all=}メソッドが呼ばれる事によって、新しい整形前の内容にdocstringを置換す"
"る。"

# @param [String] content
#: ../lib/yard/docstring.rb:123
msgid "the raw comments to be parsed"
msgstr "解析される未加工のコメント"

# YARD::Docstring#dup
#: ../lib/yard/docstring.rb:132
msgid "Deep-copies a docstring"
msgstr "docstringを深い階層までコピーする。"

# @note
#: ../lib/yard/docstring.rb:138
msgid ""
"This method creates a new docstring with new tag lists, but does\n"
"not create new individual tags. Modifying the tag objects will still\n"
"affect the original tags."
msgstr ""
"このメソッドは新しいタグリストと共に新しいdocstringを作成する。\n"
"しかし、新しい個々のタグは作成できない。\n"
"タグオブジェクトを変更すると、元のタグに影響するだろう。"

# @return [Docstring]
#: ../lib/yard/docstring.rb:138
msgid "a new copied docstring"
msgstr "新しくコピーされたdocstring"

# @return [nil]
#: ../lib/yard/docstring.rb:151
msgid "if there is no associated {#line_range}"
msgstr "{#line_range}メソッドに関係ない場合"

# @return [Fixnum]
#: ../lib/yard/docstring.rb:151
msgid "the first line of the {#line_range}"
msgstr "{#line_range}メソッドの最初の行"

# YARD::Docstring#summary
#: ../lib/yard/docstring.rb:156
msgid ""
"Gets the first line of a docstring to the period or the first paragraph."
msgstr ""
"ピリオドや最初の段落の為に、\n"
"docstringの最初の行を取得する。"

# @return [String]
#: ../lib/yard/docstring.rb:157
msgid ""
"The first line or paragraph of the docstring; always ends with a period."
msgstr "docstringの最初の行や段落、そして常にperiodと共に終わる。"

# YARD::Docstring#to_raw
#: ../lib/yard/docstring.rb:181
msgid ""
"Reformats and returns a raw representation of the tag data using the\n"
"current tag and docstring data, not the original text."
msgstr ""
"再書式化し返す、\n"
"現在のタグやdocstringデータによって\n"
"未加工のタグデータで表される。\n"
"しかし元のテキストではない。"

# @todo
#: ../lib/yard/docstring.rb:186
msgid "Add Tags::Tag#to_raw and refactor"
msgstr "Tags::Tag#to_rawメソッドや再編集を追加する"

# @return [String]
#: ../lib/yard/docstring.rb:186
msgid "the updated raw formatted docstring data"
msgstr "更新され書式化される未加工のdocstringのデータ"

# YARD::Docstring#add_tag
#: ../lib/yard/docstring.rb:209
msgid ""
"Adds a tag or reftag object to the tag list. If you want to parse\n"
"tag data based on the {Tags::DefaultFactory} tag factory, use\n"
"{DocstringParser} instead."
msgstr ""
"タグのリストにタグや参照タグオブジェクトを追加する。\n"
"あなたが、 {Tags::DefaultFactory} タグファクトリーを元にしたタグデータを解析したい場合\n"
"代わりに {DocstringParser} を使う。"

# YARD::Docstring#create_tag
# YARD::Docstring#add_tag
# YARD::Docstring#tag
# YARD::Docstring#tags
# YARD::Docstring#has_tag?
# YARD::Docstring#delete_tags
# YARD::Docstring#delete_tag_if
# YARD::Docstring#blank?
#: ../lib/yard/docstring.rb:214 ../lib/yard/docstring.rb:237
#: ../lib/yard/docstring.rb:245 ../lib/yard/docstring.rb:255
#: ../lib/yard/docstring.rb:263 ../lib/yard/docstring.rb:272
#: ../lib/yard/docstring.rb:282 ../lib/yard/docstring.rb:297
#: ../lib/yard/docstring.rb:310
msgid "Creating and Accessing Meta-data"
msgstr "メタデータを作成しアクセスする。"

# @param [Tags::Tag, Tags::RefTag] tags
#: ../lib/yard/docstring.rb:214
msgid "list of tag objects to add"
msgstr "追加のタグオブジェクトのリスト"

# YARD::Docstring#tag
#: ../lib/yard/docstring.rb:229
msgid ""
"Convenience method to return the first tag\n"
"object in the list of tag objects of that name"
msgstr ""
"タグオブジェクトのリストのような名前の中の、\n"
"最初のタグオブジェクトを返す為の便利なメソッド。"

# @example 
#: ../lib/yard/docstring.rb:237
msgid ""
"doc = Docstring.new(\"@return zero when nil\")\n"
"doc.tag(:return).text  # => \"zero when nil\""
msgstr ""

# @return [Tags::Tag]
#: ../lib/yard/docstring.rb:237
msgid "the first tag in the list of {#tags}"
msgstr "{#tags}メソッドのリストの中の、最初のタグ"

# @param [#to_s] name
#: ../lib/yard/docstring.rb:237
msgid "the tag name to return data for"
msgstr "データを返す為のタグ名"

# YARD::Docstring#tags
#: ../lib/yard/docstring.rb:242
msgid ""
"Returns a list of tags specified by +name+ or all tags if +name+ is not "
"specified."
msgstr ""
"+name+ が指定されない場合、\n"
"+name+ やallタグによって指定されたタグのリストを返す"

# @return [Array<Tags::Tag>]
#: ../lib/yard/docstring.rb:245
msgid "the list of tags by the specified tag name"
msgstr "指定されたタグ名によってタグのリストとなる。"

# @param [#to_s] name
#: ../lib/yard/docstring.rb:245
msgid "the tag name to return data for, or nil for all tags"
msgstr "データからタグ名を返す、又は、nilの場合、全てのタグ。"

# YARD::Docstring#has_tag?
#: ../lib/yard/docstring.rb:252
msgid "Returns true if at least one tag by the name +name+ was declared"
msgstr "宣言されるnameのタグ名が1つでもあれば、trueを返す。"

# @param [String] name
#: ../lib/yard/docstring.rb:255
msgid "the tag name to search for"
msgstr "検索の為のタグ名"

# @return [Boolean]
#: ../lib/yard/docstring.rb:255
msgid "whether or not the tag +name+ was declared"
msgstr "タグ +name+が宣言されるかどうか\n"

# YARD::Docstring#delete_tags
#: ../lib/yard/docstring.rb:260
msgid "Delete all tags with +name+"
msgstr "全てのタグ +name+ を用いた削除する。"

# @param [Symbol] tag
# @param [String] tag_name
# @param [String] name
#: ../lib/yard/docstring.rb:263 ../lib/yard/docstring_parser.rb:185
#: ../lib/yard/tags/library.rb:100
msgid "the tag name"
msgstr "タグ名"

# YARD::Docstring#delete_tag_if
#: ../lib/yard/docstring.rb:268
msgid "Deletes all tags where the block returns true"
msgstr "ブロックがtrueを返す所で全てのタグを削除する。"

# @yieldparam [Tags::Tag]
#: ../lib/yard/docstring.rb:272
msgid "tag|yieldparam|tag"
msgstr "tag"

# @yieldparam [Tags::Tag] tag
#: ../lib/yard/docstring.rb:272
msgid "the tag that is being tested"
msgstr "試されるタグ"

# @yieldreturn [Boolean]
#: ../lib/yard/docstring.rb:272
msgid "true if the tag should be deleted"
msgstr "タグが削除される場合、true"

# YARD::Docstring#blank?
#: ../lib/yard/docstring.rb:278
msgid ""
"Returns true if the docstring has no content that is visible to a template."
msgstr "docstringがテンプレートの為、明確な内容を持たない場合、trueを返す。"

# @param [Boolean]
#: ../lib/yard/docstring.rb:282
msgid "tag|param|only_visible_tags"
msgstr "only_visible_tags"

# @param [Boolean] only_visible_tags
#: ../lib/yard/docstring.rb:282
msgid ""
"whether only {Tags::Library.visible_tags}\n"
"should be checked, or if all tags should be considered."
msgstr ""
"{Tags::Library.visible_tags}が、チェックされるかどうか、\n"
"又は、全てのタグが考慮される場合"

# @return [Boolean]
#: ../lib/yard/docstring.rb:282
msgid "whether or not the docstring has content"
msgstr "docstringが内容を持っているかどうか"

# YARD::Docstring#convert_ref_tags
#: ../lib/yard/docstring.rb:295
msgid "Maps valid reference tags"
msgstr "有効な参照タグをマップする"

# @return [Array<Tags::RefTag>]
#: ../lib/yard/docstring.rb:297
msgid "the list of valid reference tags"
msgstr "有効な参照タグのリストを返す"

# YARD::Docstring#parse_comments
#: ../lib/yard/docstring.rb:303
msgid "Parses out comments split by newlines into a new code object"
msgstr "新しいコードオブジェクトの中の改行によって分割されるコメントを解析する"

# @param [String] comments
#: ../lib/yard/docstring.rb:310
msgid ""
"the newline delimited array of comments. If the comments\n"
"are passed as a String, they will be split by newlines."
msgstr ""
"コメントの配列を改行で区切る。\n"
"コメントが文字列の様に解析される場合、改行によって分割される。"

# @return [String]
#: ../lib/yard/docstring.rb:310
msgid ""
"the non-metadata portion of the comments to\n"
"be used as a docstring"
msgstr "docstringのように利用される為のコメントのメタデータではない部分"

# YARD::DocstringParser
#: ../lib/yard/docstring_parser.rb:5
msgid ""
"Parses text and creates a {Docstring} object to represent documentation\n"
"for a {CodeObjects::Base}. To create a new docstring, you should initialize\n"
"the parser and call {#parse} followed by {#to_docstring}."
msgstr ""

# YARD::DocstringParser
#: ../lib/yard/docstring_parser.rb:9
msgid "== Subclassing Notes"
msgstr ""

# YARD::DocstringParser
#: ../lib/yard/docstring_parser.rb:11
msgid ""
"The DocstringParser can be subclassed and substituted during parsing by\n"
"setting the {Docstring.default_parser} attribute with the name of the\n"
"subclass. This allows developers to change the way docstrings are\n"
"parsed, allowing for completely different docstring syntaxes."
msgstr ""

# @example Creating a Custom DocstringParser
#: ../lib/yard/docstring_parser.rb:29
msgid ""
"# Parses docstrings backwards!\n"
"class ReverseDocstringParser\n"
"  def parse_content(content)\n"
"    super(content.reverse)\n"
"  end\n"
"end\n"
"\n"
"# Set the parser as default when parsing\n"
"YARD::Docstring.default_parser = ReverseDocstringParser"
msgstr ""

# @example Creating a Docstring with a DocstringParser
#: ../lib/yard/docstring_parser.rb:29
msgid "DocstringParser.new.parse(\"text here\").to_docstring"
msgstr ""

# @example
#: ../lib/yard/docstring_parser.rb:29
msgid "tag|example|Creating a Custom DocstringParser"
msgstr "tag|example|カスタムDocstringParserを作成する"

# @example
#: ../lib/yard/docstring_parser.rb:29
msgid "tag|example|Creating a Docstring with a DocstringParser"
msgstr "tag|example|DocstringParserを用いDocstringを作成する"

# @param [TokenList, String]
# @param [String]
# @param [String, #read, Object]
#: ../lib/yard/docstring_parser.rb:29
msgid "tag|see|#parse_content"
msgstr ""

# @param [String] tag_buf
#: ../lib/yard/docstring_parser.rb:32
msgid ""
"the parsed text portion of the docstring,\n"
"with tags removed."
msgstr "解析されたdocstringのテキストの一部,  削除されたタグと一緒"

# @param [String] content
#: ../lib/yard/docstring_parser.rb:35
msgid "the complete input string to the parser."
msgstr "パーサーの為の完全な入力文字列"

# @return [Array<Tags::Tag>]
#: ../lib/yard/docstring_parser.rb:39
msgid ""
"the list of meta-data tags identified\n"
"by the parser"
msgstr "パーサーに認証されたメタデータタグのリスト"

# @return [Array<Directive>]
#: ../lib/yard/docstring_parser.rb:44
msgid ""
"a list of directives identified\n"
"by the parser. This list will not be passed on to the\n"
"Docstring object."
msgstr ""

# @return [OpenStruct]
#: ../lib/yard/docstring_parser.rb:50
msgid ""
"any arbitrary state to be passed between\n"
"tags during parsing. Mainly used by directives to coordinate\n"
"behaviour (so that directives can be aware of other directives\n"
"used in a docstring)."
msgstr ""

# @return [CodeObjects::Base, nil]
#: ../lib/yard/docstring_parser.rb:55
msgid ""
"the object associated with\n"
"the docstring being parsed. May be nil if the docstring is\n"
"not attached to any object."
msgstr ""

# @return [Handlers::Base, nil]
#: ../lib/yard/docstring_parser.rb:60
msgid ""
"the handler parsing this\n"
"docstring. May be nil if this docstring parser is not\n"
"initialized through"
msgstr ""

# @return [Tags::Library]
#: ../lib/yard/docstring_parser.rb:64
msgid ""
"the tag library being used to\n"
"identify registered tags in the docstring."
msgstr ""

# YARD::CodeObjects::CONSTANTMATCH
#: ../lib/yard/docstring_parser.rb:67
msgid "The regular expression to match the tag syntax"
msgstr "タグ構文にマッチする為の正規表現"

# YARD::Server::Router#initialize
#: ../lib/yard/docstring_parser.rb:72
msgid "Creates a new parser to parse docstring data"
msgstr "docstringのデータを解析する為の新しいパーサーを作成する"

# YARD::Docstring#create_tag
# YARD::Docstring#add_tag
# YARD::Docstring#tag
# YARD::Docstring#tags
# YARD::Docstring#has_tag?
# YARD::Docstring#delete_tags
# YARD::Docstring#delete_tag_if
# YARD::Docstring#blank?
#: ../lib/yard/docstring_parser.rb:75 ../lib/yard/docstring_parser.rb:88
msgid "Creation and Conversion Methods"
msgstr "作成、変換メソッド"

# @return [Docstring]
#: ../lib/yard/docstring_parser.rb:75
msgid "a new instance of DocstringParser"
msgstr "DocstringParserの新しいインスタンス"

# @param [Tags::Library] library
#: ../lib/yard/docstring_parser.rb:75
msgid ""
"a tag library for recognizing\n"
"tags."
msgstr ""

# @param [LibraryVersion]
#: ../lib/yard/docstring_parser.rb:75 ../lib/yard/server/adapter.rb:88
#: ../lib/yard/server/router.rb:122
msgid "tag|param|library"
msgstr ""

# YARD::Docstring#initialize
# YARD::Docstring#+
# YARD::Docstring#replace
# YARD::Docstring#dup
#: ../lib/yard/docstring_parser.rb:88
msgid ""
"translates parsed text into\n"
"a Docstring object."
msgstr "Docstringオブジェクトへ解析されたテキストを変換する"

# YARD::DocstringParser#parse
#: ../lib/yard/docstring_parser.rb:95
msgid "Parses all content and returns itself."
msgstr ""

# YARD::Server::Router#parse_library_from_path
# YARD::Server::Router#route
# YARD::Server::Router#route_docs
# YARD::Server::Router#route_index
# YARD::Server::Router#route_list
# YARD::Server::Router#route_search
#: ../lib/yard/docstring_parser.rb:106 ../lib/yard/docstring_parser.rb:123
msgid "Parsing Methods"
msgstr "解析メソッド"

# @param [Parser::Ruby::AstNode]
#: ../lib/yard/docstring_parser.rb:106
msgid "tag|param|handler"
msgstr ""

# @param [Docstring]
#: ../lib/yard/docstring_parser.rb:106
msgid "tag|see|#to_docstring"
msgstr ""

# @param [String, #read, Object] content
#: ../lib/yard/docstring_parser.rb:106
msgid "the docstring text to parse"
msgstr "解析の為のdocstringのテキスト"

# @param [Handlers::Base, nil] handler
#: ../lib/yard/docstring_parser.rb:106
msgid ""
"the handler object that is\n"
"parsing this object. May be nil if this parser is not being\n"
"called from a {Parser::SourceParser} context."
msgstr ""

# @param [CodeObjects::Base] object
#: ../lib/yard/docstring_parser.rb:106
msgid ""
"the object that the docstring\n"
"is attached to. Will be passed to directives to act on\n"
"this object."
msgstr ""

# @return [self]
#: ../lib/yard/docstring_parser.rb:106
msgid ""
"the parser object. To get the docstring,\n"
"call {#to_docstring}."
msgstr ""

# YARD::Parser::SourceParser.parse_string
#: ../lib/yard/docstring_parser.rb:119
msgid "Parses a given block of text."
msgstr "テキストの与えられたブロックを解析する"

# YARD::Handlers::Base#process
#: ../lib/yard/docstring_parser.rb:123
msgid ""
"Subclasses can override this method to perform custom\n"
"parsing of content data."
msgstr ""
"サブクラスは内容のデータのカスタム解析を実行する為に\n"
"このメソッドを上書きできる"

# @yieldreturn [String]
#: ../lib/yard/docstring_parser.rb:123
msgid "the content to parse"
msgstr "解析する為の内容"

# YARD::Docstring#create_tag
#: ../lib/yard/docstring_parser.rb:179
msgid "Creates a tag from the {Tags::DefaultFactory tag factory}."
msgstr "{Tags::DefaultFactory tag factory}から、タグを作成する。"

# YARD::Docstring#create_tag
#: ../lib/yard/docstring_parser.rb:181
msgid "To add an already created tag object, append it to {#tags}."
msgstr "既に作成されたタグオブジェクトを追加するには、{#tags}メソッドを追加する。"

# File.relative_path
# File.cleanpath
#: ../lib/yard/docstring_parser.rb:185 ../lib/yard/docstring_parser.rb:202
#: ../lib/yard/docstring_parser.rb:208 ../lib/yard/docstring_parser.rb:228
msgid "Tag Manipulation Methods"
msgstr "タグ操作メソッド"

# @return [Tags::Tag, Tags::RefTag]
#: ../lib/yard/docstring_parser.rb:185
msgid "a tag"
msgstr "タグ"

# @param [String]
#: ../lib/yard/docstring_parser.rb:185 ../lib/yard/tags/library.rb:290
msgid "tag|param|tag_buf"
msgstr "tag_buf"

# @param [#to_s]
# @param
# @param [String]
#: ../lib/yard/docstring_parser.rb:185 ../lib/yard/tags/default_factory.rb:12
#: ../lib/yard/tags/default_factory.rb:21
#: ../lib/yard/tags/default_factory.rb:32
#: ../lib/yard/tags/default_factory.rb:44
#: ../lib/yard/tags/default_factory.rb:56 ../lib/yard/tags/library.rb:267
#: ../lib/yard/tags/library.rb:280 ../lib/yard/tags/library.rb:290
#: ../lib/yard/tags/tag.rb:43
msgid "tag|param|tag_name"
msgstr "tag_name"

# @param [String] tag_buf
#: ../lib/yard/docstring_parser.rb:185
msgid "the text attached to the tag with newlines removed."
msgstr "空白文字が削除されたタグを追加したテキスト"

# YARD::Docstring#create_ref_tag
#: ../lib/yard/docstring_parser.rb:202
msgid "Creates a {Tags::RefTag}"
msgstr "{Tags::RefTag}を作成する"

# YARD::Registry.register
#: ../lib/yard/docstring_parser.rb:207
msgid "Creates a new directive using the registered {#library}"
msgstr "記録された{#library}メソッドを使って新しい命令を作成する"

# @return [OpenStruct]
#: ../lib/yard/docstring_parser.rb:208
msgid "the directive object that is created"
msgstr "作成される命令オブジェクト"

# YARD::DocstringParser#tag_is_directive?
#: ../lib/yard/docstring_parser.rb:227
msgid ""
"Backward compatibility to detect old tags that should be specified\n"
"as directives in 0.8 and onward."
msgstr ""

# YARD::DocstringParser#call_directives_after_parse
#: ../lib/yard/docstring_parser.rb:238
msgid ""
"Calls the {Directive#after_parse} callback on all the\n"
"created directives."
msgstr ""

# YARD::Parser::SourceParser.before_parse_list
# YARD::Parser::SourceParser.after_parse_list
# YARD::Parser::SourceParser.before_parse_file
# YARD::Parser::SourceParser.after_parse_file
# YARD::Parser::SourceParser.before_parse_list_callbacks
# YARD::Parser::SourceParser.after_parse_list_callbacks
# YARD::Parser::SourceParser.before_parse_file_callbacks
# YARD::Parser::SourceParser.after_parse_file_callbacks
#: ../lib/yard/docstring_parser.rb:239 ../lib/yard/docstring_parser.rb:246
#: ../lib/yard/docstring_parser.rb:263 ../lib/yard/docstring_parser.rb:268
msgid "Parser Callback Methods"
msgstr "パーサーコールバックメソッド"

# YARD::DocstringParser#call_after_parse_callbacks
#: ../lib/yard/docstring_parser.rb:246
msgid "Calls all {after_parse} callbacks"
msgstr ""

# YARD::DocstringParser.after_parse
#: ../lib/yard/docstring_parser.rb:255
msgid ""
"Creates a callback that is called after a docstring is successfully\n"
"parsed. Use this method to perform sanity checks on a docstring's\n"
"tag data, or add any extra tags automatically to a docstring."
msgstr ""

# @return [Proc]
#: ../lib/yard/docstring_parser.rb:263
msgid "a block to be called after a docstring is parsed"
msgstr "docstringが解析された後で呼び出されるためのブロック"

# @yieldparam [SourceParser]
#: ../lib/yard/docstring_parser.rb:263 ../lib/yard/parser/source_parser.rb:292
#: ../lib/yard/parser/source_parser.rb:321
msgid "tag|yieldparam|parser"
msgstr "parser"

# @yieldparam [DocstringParser] parser
#: ../lib/yard/docstring_parser.rb:263
msgid ""
"the docstring parser object\n"
"with all directives and tags created."
msgstr ""

# @return [Array<Proc>]
#: ../lib/yard/docstring_parser.rb:268
msgid "the {after_parse} callback proc objects"
msgstr ""

# #P
#: ../lib/yard/globals.rb:4
msgid "Shortcut for creating a YARD::CodeObjects::Proxy via a path"
msgstr ""

# #P
# #log
#: ../lib/yard/globals.rb:7 ../lib/yard/globals.rb:16
msgid "Global Convenience Methods"
msgstr "グローバルな便利メソッド"

# @see
#: ../lib/yard/globals.rb:7
msgid "tag|see|YARD::CodeObjects::Proxy"
msgstr ""

# @see
#: ../lib/yard/globals.rb:7
msgid "tag|see|YARD::Registry.resolve"
msgstr ""

# #log
#: ../lib/yard/globals.rb:13
msgid "The global {YARD::Logger} instance"
msgstr ""

# @see
#: ../lib/yard/globals.rb:16
msgid "tag|see|YARD::Logger"
msgstr ""

# @return [YARD::Logger]
#: ../lib/yard/globals.rb:16
msgid "the global {YARD::Logger} instance"
msgstr ""

# YARD::Handlers::NamespaceMissingError
#: ../lib/yard/handlers/base.rb:4
msgid ""
"Raised during processing phase when a handler needs to perform\n"
"an operation on an object's namespace but the namespace could\n"
"not be resolved."
msgstr ""
"ハンドラーがnamespaceオブジェクトの演算を実行する必要がある時、\n"
"処理している間に例外を上げる。しかし、namespaceは解決されない。"

# YARD::Handlers::NamespaceMissingError#object
# YARD::Handlers::NamespaceMissingError#object=
#: ../lib/yard/handlers/base.rb:8
msgid "The object the error occurred on"
msgstr "エラーが生じたコードオブジェクトを返す。"

# @return [CodeObjects::Base]
#: ../lib/yard/handlers/base.rb:9
msgid "a code object"
msgstr "コードオブジェクト"

# @return [NamespaceMissingError]
#: ../lib/yard/handlers/base.rb:11
msgid "a new instance of NamespaceMissingError"
msgstr "NamespaceMissingErrorの新しいインスタンス"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:15
msgid ""
"Handlers are pluggable semantic parsers for YARD's code generation\n"
"phase. They allow developers to control what information gets\n"
"generated by YARD, giving them the ability to, for instance, document\n"
"any Ruby DSLs that a customized framework may use. A good example\n"
"of this would be the ability to document and generate meta data for\n"
"the 'describe' declaration of the RSpec testing framework by simply\n"
"adding a handler for such a keyword. Similarly, any Ruby API that\n"
"takes advantage of class level declarations could add these to the\n"
"documentation in a very explicit format by treating them as first-\n"
"class objects in any outputted documentation."
msgstr ""
"ハンドラーは、YARDがコード生成段階で、\n"
"プラグイン可能という意味のパーサーである。\n"
"ハンドラーは、YARDによって生成される情報や、\n"
"その情報に機能を与える為や、\n"
"例えば、利用するかもしれない\n"
"カスタマイズされたフレームワークの何らかのRuby DSLを記述すること等を\n"
"制御する為に開発者を受け入れる。\n"
"いい例は、キーワードのような単純なハンドラーの追加によって、\n"
"RSpec testing フレームワークの'describe'宣言のように、\n"
"ドキュメント作成やメタデータを生成する機能である。\n"
"同様に、クラスレベル宣言から利用する何らかのRubyAPIは、\n"
"出力されたドキュメントで、\n"
"最初のクラスオブジェクトとしてそれらを処理することによって、\n"
"明確な書式でドキュメントにこれらを追加できた。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:26
msgid "== Overview of a Typical Handler Scenario"
msgstr "== 標準的なハンドラーの処理概要"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:28
msgid ""
"Generally, a handler class will declare a set of statements which\n"
"it will handle using the {handles} class declaration. It will then\n"
"implement the {#process} method to do the work. The processing would\n"
"usually involve the manipulation of the {#namespace}, {#owner}\n"
"{CodeObjects::Base code objects} or the creation of new ones, in\n"
"which case they should be registered by {#register}, a method that\n"
"sets some basic attributes for the new objects."
msgstr ""
"一般的に、ハンドラークラスはステートメントのグループを宣言する。\n"
"そして、それは {handles} クラス宣言によって処理する。\n"
"それは、処理の為に {#process} メソッドを実装する。\n"
"処理中は、通常 {#namespace} , {#owner} , {CodeObjects::Base code objects} や\n"
"新規作成を含む場合に、それらは、 {#register} によって登録されるべき、\n"
"メソッドは新しいオブジェクト用にいくつかの基本的属性を設定する。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:36
msgid ""
"Handlers are usually simple and take up to a page of code to process\n"
"and register a new object or add new attributes to the current +namespace+."
msgstr ""
"ハンドラーは一般的にシンプルで、処理の為にコードのページを取り上げ、\n"
"新しいオブジェクトを登録し、現在の +namespace+ に新しい属性を追加する。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:39
msgid "== Setting up a Handler for Use"
msgstr "== ハンドラーを使う為の設定"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:41
msgid ""
"A Handler is automatically registered when it is subclassed from the\n"
"base class. The only other thing that needs to be done is to specify\n"
"which statement the handler will process. This is done with the +handles+\n"
"declaration, taking either a {Parser::Ruby::Legacy::RubyToken}, {String} or "
"`Regexp`.\n"
"Here is a simple example which processes module statements."
msgstr ""
"ハンドラーはベースクラスからサブクラス化される時に、\n"
"自動的に登録される。\n"
"必要なその他のこととしては、\n"
"ハンドラーがどのステートメントを処理するかを指定する。\n"
"これは、 +handles+ の宣言と共に、\n"
"{Parser::Ruby::Legacy::RubyToken} か {String} や `Regexp`が取得される。\n"
"これは、モジュールステートメントの処理の簡単な例です。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:47
msgid ""
"  class MyModuleHandler < YARD::Handlers::Base\n"
"    handles TkMODULE"
msgstr ""

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:50
msgid ""
"    def process\n"
"      # do something\n"
"    end\n"
"  end"
msgstr ""

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:55
msgid "== Processing Handler Data"
msgstr "== ハンドラーデータ処理"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:57
msgid ""
"The goal of a specific handler is really up to the developer, and as\n"
"such there is no real guideline on how to process the data. However,\n"
"it is important to know where the data is coming from to be able to use\n"
"it."
msgstr ""
"具体的なハンドラーの使い方は、開発者次第となる。\n"
"データ処理の方法のガイドラインは何もない。\n"
"しかしながら、データを扱う為には、\n"
"そのデータがどこから来るか知る事が重要となる。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:62
msgid "=== +statement+ Attribute"
msgstr "=== +statement+ 属性"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:64
msgid ""
"The +statement+ attribute pertains to the {Parser::Ruby::Legacy::Statement} "
"object\n"
"containing a set of tokens parsed in by the parser. This is the main set\n"
"of data to be analyzed and processed. The comments attached to the "
"statement\n"
"can be accessed by the {Parser::Ruby::Legacy::Statement#comments} method, "
"but generally\n"
"the data to be processed will live in the +tokens+ attribute. This list\n"
"can be converted to a +String+ using +#to_s+ to parse the data with\n"
"regular expressions (or other text processing mechanisms), if needed."
msgstr ""
"パーサーによって解析されたトークンの設定を\n"
"{Parser::Ruby::Legacy::Statement} オブジェクトが含んでいる為、\n"
"+statement+ 属性は関係がある。\n"
"これは解析や処理される為のデータの主な設定となる。\n"
"コメントはstatementが {Parser::Ruby::Legacy::Statement#comments} メソッドに"
"よってアクセスされる為に付加される、\n"
"しかし、処理される一般的なデータは +tokens+ 属性の中に存在する。\n"
"必要であれば、このリストは、正規表現(又は、他のテキストが処理しているメカニズ"
"ム)を用い、データを解析する為に+#to_s+メソッドによって +String+ に変換され"
"る。\n"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:72
msgid "=== +namespace+ Attribute"
msgstr "=== +namespace+ 属性"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:74
msgid ""
"The +namespace+ attribute is a {CodeObjects::NamespaceObject namespace "
"object}\n"
"which represents the current namespace that the parser is in. For instance:"
msgstr ""
"+namespace+ 属性は {CodeObjects::NamespaceObject namespace object} となる。\n"
"それは、そのパーサーの中では現在のnamespaceを表す。\n"
"例えば:"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:77
msgid ""
"  module SomeModule\n"
"    class MyClass\n"
"      def mymethod; end\n"
"    end\n"
"  end"
msgstr ""

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:83
msgid ""
"If a handler was to parse the 'class MyClass' statement, it would\n"
"be necessary to know that it belonged inside the SomeModule module.\n"
"This is the value that +namespace+ would return when processing such\n"
"a statement. If the class was then entered and another handler was\n"
"called on the method, the +namespace+ would be set to the 'MyClass'\n"
"code object."
msgstr ""
"ハンドラー処理が'class MyClass'ステートメントを解析する場合、\n"
"class My ClassがSomeModuleモジュールの内部に\n"
"属していることを知ることが必須になる。\n"
"ステートメントのような処理(class MyClassを解析)をしている時、\n"
"SomeModuleが +namespace+ 値となり返されるだろう。\n"
"もしMyClassがエントリーされたり、\n"
"他のハンドラーがメソッド上で呼び出された場合、\n"
"'MyClass'コードオブジェクトが +namespace+ に設定される。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:90
msgid "=== +owner+ Attribute"
msgstr "=== +owner+ 属性"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:92
msgid ""
"The +owner+ attribute is similar to the +namespace+ attribute in that\n"
"it also follows the scope of the code during parsing. However, a namespace\n"
"object is loosely defined as a module or class and YARD has the ability\n"
"to parse beyond module and class blocks (inside methods, for instance),\n"
"so the +owner+ attribute would not be limited to modules and classes."
msgstr ""
"+owner+ 属性は +namespace+ 属性と似ているが、\n"
"解析中のコードのスコープをフォローもする。\n"
"しかしながら、namespace オブジェクトは\n"
"モジュールやクラスのように曖昧に定義される。\n"
"その為、YARDはモジュールやクラスブロック(例えば、内部メソッド)を\n"
"越えて解析する為の機能を持つ。\n"
"なので、この +owner+ 属性は、モジュールやクラスに制限されない。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:98
msgid ""
"To put this into context, the example from above will be used. If a method\n"
"handler was added to the mix and decided to parse inside the method body,\n"
"the +owner+ would be set to the method object but the namespace would "
"remain\n"
"set to the class. This would allow the developer to process any method\n"
"definitions set inside a method (def x; def y; 2 end end) by adding them\n"
"to the correct namespace (the class, not the method)."
msgstr ""
"この文脈の中では、上の例が使われる。\n"
"ハンドラーのメソッドは、組み合わせる為に追加されたり、\n"
"メソッド本体の内部を解析する場合、\n"
"+owner+ はメソッドオブジェクトを設定する。\n"
"しかし、namespaceはクラスに設定されたままとなる。\n"
"これは開発者に以下のことを可能とする。全てのメソッド定義は、\n"
"正しいnamespaceを追加する事によって(クラスの,メソッドでは無い)、\n"
"メソッドの内部(def x; def y; 2 end end)のグループを処理する。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:105
msgid ""
"In summary, the distinction between +namespace+ and +owner+ can be thought\n"
"of as the difference between first-class Ruby objects (namespaces) and\n"
"second-class Ruby objects (methods)."
msgstr ""
"要約すると、+namespace+ と +owner+ の違いは、\n"
"ネストするクラスで考えると、:ownerは\n"
"最初のクラスのRubyオブジェクトでは(namespace)となるが、\n"
"次のネストしたクラスのRubyオブジェクトでは前のクラスのnamespaceとなる。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:109
msgid "=== +visibility+ and +scope+ Attributes"
msgstr "=== +visibility+ と +scope+ 属性"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:111
msgid ""
"Mainly needed for parsing methods, the +visibility+ and +scope+ attributes\n"
"refer to the public/protected/private and class/instance values "
"(respectively)\n"
"of the current parsing position."
msgstr ""
"大抵は解析されるメソッドの為に必要とされる、\n"
"+visibility+ と +scope+ 属性は現在の解析している場所の\n"
"public/protected/privateとclass/instanceの値(それぞれについて)を\n"
"参照する。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:115
msgid "== Parsing Blocks in Statements"
msgstr "== ステートメントの中のブロックを解析する"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:117
msgid ""
"In addition to parsing a statement and creating new objects, some\n"
"handlers may wish to continue parsing the code inside the statement's\n"
"block (if there is one). In this context, a block means the inside\n"
"of any statement, be it class definition, module definition, if\n"
"statement or classic 'Ruby block'."
msgstr ""
"ステートメントの解析や新しくオブジェクトを作成する事に加えて、\n"
"いくつかのハンドラーはステートメントのブロック(が一つでもある場合)の\n"
"内部コードの解析処理を継続するかもしれない。\n"
"このコンテキストでブロックとは、何らかのステートメントの内部を意味する。\n"
"それはステートメントやRubyで使われるblockの場合、クラス定義、モジュール定義になる。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:123
msgid ""
"For example, a class statement would be \"class MyClass\" and the block\n"
"would be a list of statements including the method definitions inside\n"
"the class. For a class handler, the programmer would execute the\n"
"{#parse_block} method to continue parsing code inside the block, with\n"
"the +namespace+ now pointing to the class object the handler created."
msgstr ""
"例えば、ステートメントのクラスが\"class MyClass\"になるかもしれない\n"
"そして、ブロックはクラスの内部でメソッドの定義を\n"
"含んでいるステートメントのリストになるかもしれない。\n"
"ハンドラーのクラス用に、\n"
"プログラマーは、{#parse_block} メソッドを実行する。\n"
"ブロックの内部のコード解析を継続する為に、\n"
"+namespace+ は、現在、ハンドラーが作成したクラスオブジェクトを指定する。"

# YARD::Handlers::Base
#: ../lib/yard/handlers/base.rb:129
msgid ""
"YARD has the ability to continue into any block: class, module, method,\n"
"even if statements. For this reason, the block parsing method must be\n"
"invoked explicitly out of efficiency sake."
msgstr ""
"YARDは何らかのブロックの中へ(クラス,モジュール,メソッド,ステートメントでさえ)\n"
"継続する特性がある。\n"
"従って、メソッドを解析するブロックは、\n"
"効率良く処理する為、明示的に呼び出されるべきである。"

# @abstract
#: ../lib/yard/handlers/base.rb:142
msgid ""
"Subclass this class to provide a handler for YARD to use\n"
"during the processing phase."
msgstr ""
"YARDが処理段階で使用するハンドラーを提供する為に、\n"
"このクラスをサブクラス化する。"

# @see
#: ../lib/yard/handlers/base.rb:142
msgid "tag|see|#namespace"
msgstr ""

# @see
#: ../lib/yard/handlers/base.rb:142
msgid "tag|see|#owner"
msgstr ""

# @see
#: ../lib/yard/handlers/base.rb:142
msgid "tag|see|#parse_block"
msgstr ""

# @see
#: ../lib/yard/handlers/base.rb:142 ../lib/yard/handlers/base.rb:290
msgid "tag|see|#register"
msgstr ""

# @see
#: ../lib/yard/handlers/base.rb:142 ../lib/yard/parser/source_parser.rb:62
msgid "tag|see|CodeObjects::Base"
msgstr ""

# @see
#: ../lib/yard/handlers/base.rb:142
msgid "tag|see|CodeObjects::NamespaceObject"
msgstr ""

# @see
#: ../lib/yard/handlers/base.rb:142 ../lib/yard/handlers/base.rb:290
msgid "tag|see|handles"
msgstr ""

# YARD::Handlers::Base.clear_subclasses
#: ../lib/yard/handlers/base.rb:151
msgid "Clear all registered subclasses. Testing purposes only"
msgstr "全ての登録されたサブクラスを消去する。テスト用"

# YARD::Handlers::Base.subclasses
#: ../lib/yard/handlers/base.rb:157
msgid "Returns all registered handler subclasses."
msgstr "全ての登録されたサブクラスのハンドラーを返す。"

# @return [Array<Base>]
#: ../lib/yard/handlers/base.rb:158
msgid "a list of handlers"
msgstr "ハンドラーのリスト"

# YARD::Handlers::Base.handles
#: ../lib/yard/handlers/base.rb:168
msgid ""
"Declares the statement type which will be processed\n"
"by this handler."
msgstr "このハンドラーによって処理されるステートメントの型を宣言する。"

# YARD::Handlers::Base.handles
#: ../lib/yard/handlers/base.rb:171
msgid ""
"A match need not be unique to a handler. Multiple\n"
"handlers can process the same statement. However,\n"
"in this case, care should be taken to make sure that\n"
"{#parse_block} would only be executed by one of\n"
"the handlers, otherwise the same code will be parsed\n"
"multiple times and slow YARD down."
msgstr ""
"ハンドラーでマッチするものは、一つでなくてもよい。\n"
"複数のハンドラーは同じステートメントを処理できる。\n"
"しかしながら、このケースの場合は、\n"
"{#parse_block}がハンドラーの一つによって実行されるだけで、\n"
"他の同じコードが複数回解析されYARDが遅くなる事に注意しなければならない。"

# @param [Parser::RubyToken, Symbol, String, Regexp] matches
#: ../lib/yard/handlers/base.rb:185
msgid ""
"statements that match the declaration will be\n"
"processed by this handler. A {String} match is\n"
"equivalent to a +/\\Astring/+ regular expression\n"
"(match from the beginning of the line), and all\n"
"token matches match only the first token of the\n"
"statement."
msgstr ""
"このハンドラーによって処理される宣言がマッチするステートメント。\n"
"A {String} のマッチは +/\\Astring/+ の正規表現と同様となる。\n"
"(行の最初からマッチ)、\n"
"そして全てのトークンのマッチは、ステートメントの最初のトークンにだけマッチする。"

# @param [Parser::RubyToken, Symbol, String, Regexp]
#: ../lib/yard/handlers/base.rb:185
msgid "tag|param|matches"
msgstr ""

# YARD::Handlers::Base.handles?
#: ../lib/yard/handlers/base.rb:190
msgid ""
"This class is implemented by {Ruby::Base} and {Ruby::Legacy::Base}.\n"
"To implement a base handler class for another language, implement\n"
"this method to return true if the handler should process the given\n"
"statement object. Use {handlers} to enumerate the matchers declared\n"
"for the handler class."
msgstr ""
"このクラスは、 {Ruby::Base} や {Ruby::Legacy::Base} によって実装される。\n"
"他の言語用のbase handlerクラスを実装する為には、\n"
"ハンドラーが与えられたステートメントオブジェクトを処理する場合、\n"
"trueを返す為にこのメソッドを実装する。\n"
"ハンドラークラス用のマッチする宣言を列挙するには、{handlers} を使用する。"

# @param statement
#: ../lib/yard/handlers/base.rb:198
msgid "a statement object or node (depends on language type)"
msgstr "オブジェクトやノードのステートメント(言語タイプに左右される)"

# @return [Boolean]
#: ../lib/yard/handlers/base.rb:198
msgid ""
"whether or not this handler object should process\n"
"the given statement"
msgstr "いずれにせよ、このハンドラーオブジェクトは指定されたステートメントを処理するべき"

# @return [Array]
#: ../lib/yard/handlers/base.rb:204
msgid "a list of matchers for the handler object."
msgstr "ハンドラーオブジェクト用の照合されるリスト"

# @see
#: ../lib/yard/handlers/base.rb:204
msgid "tag|see|handles?"
msgstr ""

# YARD::Handlers::Base.namespace_only
#: ../lib/yard/handlers/base.rb:209
msgid ""
"Declares that the handler should only be called when inside a\n"
"{CodeObjects::NamespaceObject}, not a method body."
msgstr ""
"ハンドラーが {CodeObjects::NamespaceObject} 内部の時だけ\n"
"呼び出される事を宣言する、このメソッドは本体ではない。"

# @return [Boolean]
#: ../lib/yard/handlers/base.rb:218
msgid ""
"whether the handler should only be processed inside\n"
"a namespace."
msgstr "このハンドラがnamespace内だけで処理されるかどうか"

# YARD::Handlers::Base.in_file
#: ../lib/yard/handlers/base.rb:223
msgid ""
"Declares that a handler should only be called when inside a filename\n"
"by its basename or a regex match for the full path."
msgstr ""
"ハンドラーがフルパス用のベースネームや正規表現マッチによって、\n"
"ファイルネーム内部の時だけ呼び出される事を宣言する。"

# @param [String, Regexp] filename
#: ../lib/yard/handlers/base.rb:228
msgid "a matching filename or regex"
msgstr "マッチするファイルネームや正規表現"

# @return [Boolean]
#: ../lib/yard/handlers/base.rb:235
msgid ""
"whether the filename matches the declared file\n"
"match for a handler. If no file match is specified, returns true."
msgstr ""
"ファイル名が宣言されたハンドラー用のファイルとマッチするかどうか、\n"
"ファイルがマッチしない場合は、trueを返す。"

# YARD::Handlers::Base.process
#: ../lib/yard/handlers/base.rb:251
msgid ""
"Generates a +process+ method, equivalent to +def process; ... end+.\n"
"Blocks defined with this syntax will be wrapped inside an anonymous\n"
"module so that the handler class can be extended with mixins that\n"
"override the +process+ method without alias chaining."
msgstr ""
"+process+ メソッドを生成する、 +def process; ...end+ と同等となる。\n"
"この構文を用いた定義されるブロックは、無名モジュールの内部でラップされる。\n"
"理由としては、ハンドラークラスが +procecc+ メソッドの上書きを\n"
"エイリアスチェーン無しでmixinを用い拡張できるようにする為である。"

# @since
#: ../lib/yard/handlers/base.rb:262
#: ../lib/yard/handlers/ruby/class_condition_handler.rb:11
#: ../lib/yard/parser/ruby/legacy/statement.rb:49
#: ../lib/yard/templates/erb_cache.rb:16
#: ../lib/yard/templates/helpers/html_helper.rb:510
msgid "0.5.4"
msgstr ""

# @see
#: ../lib/yard/handlers/base.rb:262
msgid "tag|see|#process"
msgstr ""

# @return [Base]
#: ../lib/yard/handlers/base.rb:269 ../lib/yard/parser/base.rb:25
#: ../lib/yard/serializers/base.rb:27 ../lib/yard/server/commands/base.rb:74
msgid "a new instance of Base"
msgstr "ベースの新しいインスタンス"

# YARD::Handlers::Base#process
#: ../lib/yard/handlers/base.rb:275
msgid ""
"The main handler method called by the parser on a statement\n"
"that matches the {handles} declaration."
msgstr ""
"主なハンドラーのメソッドは {handles} の宣言で\n"
"マッチするstatementのパーサーによって呼び出される。"

# YARD::Handlers::Base#process
#: ../lib/yard/handlers/base.rb:278
msgid ""
"Subclasses should override this method to provide the handling\n"
"functionality for the class."
msgstr ""
"サブクラスはクラス用の処理機能を提供する為に、\n"
"このメソッドを上書きする。"

# @return [Array<CodeObjects::Base>, CodeObjects::Base, Object]
#: ../lib/yard/handlers/base.rb:290
msgid ""
"If this method returns a code object (or a list of them),\n"
"they are passed to the +#register+ method which adds basic\n"
"attributes. It is not necessary to return any objects and in\n"
"some cases you may want to explicitly avoid the returning of\n"
"any objects for post-processing by the register method."
msgstr ""
"このメソッドがコードオブジェクト(やそれらのリスト)を返す場合、\n"
"それらは、+#register+ メソッドに解析され、基本属性が追加される。\n"
"何らかのオブジェクトを返すのは必須ではなく、\n"
"場合によっては、\n"
"あなたはregisterメソッドによって後処理用の\n"
"何らかのオブジェクトを返すことを明確に無視できる。"

# YARD::Handlers::Base#parse_block
#: ../lib/yard/handlers/base.rb:295
msgid "Parses the semantic \"block\" contained in the statement node."
msgstr "ステートメントノードに含まれている意味のある\"block\"を解析する。"

# @abstract
#: ../lib/yard/handlers/base.rb:297
msgid "Subclasses should call {Processor#process parser.process}"
msgstr "{Processor#process parser.process} を呼び出しサブクラス化する。"

# @return [Processor]
#: ../lib/yard/handlers/base.rb:303
msgid ""
"the processor object that manages all global state\n"
"during handling."
msgstr "全てのグローバルな状態の処理の間に扱うプロセッサーオブジェクト"

# @return [Object]
#: ../lib/yard/handlers/base.rb:308
msgid ""
"the statement object currently being processed. Usually\n"
"refers to one semantic language statement, though the strict definition\n"
"depends on the parser used."
msgstr ""
"現在の処理されるステートメントオブジェクト。\n"
"厳格な定義は使われるパーサー次第とはいえ、\n"
"一般的には、一つの意味のある言語を参照する。"

# @param value
#: ../lib/yard/handlers/base.rb:311 ../lib/yard/handlers/base.rb:333
#: ../lib/yard/tags/ref_tag.rb:4 ../lib/yard/tags/ref_tag_list.rb:4
msgid "the value to set the attribute owner to."
msgstr "owner属性を設定する為の値"

# YARD::Tags::RefTag#owner
# YARD::Tags::RefTagList#owner
#: ../lib/yard/handlers/base.rb:312 ../lib/yard/handlers/base.rb:333
#: ../lib/yard/tags/ref_tag.rb:5 ../lib/yard/tags/ref_tag_list.rb:5
msgid "Returns the value of attribute owner"
msgstr "owner属性の値を返す"

# YARD::Tags::RefTag#owner=
# YARD::Tags::RefTagList#owner=
#: ../lib/yard/handlers/base.rb:312 ../lib/yard/handlers/base.rb:334
#: ../lib/yard/tags/ref_tag.rb:5 ../lib/yard/tags/ref_tag_list.rb:5
msgid "Sets the attribute owner"
msgstr "owner属性を設定する"

# @param value
#: ../lib/yard/handlers/base.rb:314 ../lib/yard/handlers/base.rb:335
msgid "the value to set the attribute namespace to."
msgstr "値にnamespace属性を設定するための値"

# YARD::CodeObjects::ExtraFileObject#name=
# YARD::Tags::RefTagList#name=
# YARD::Templates::Section#name=
#: ../lib/yard/handlers/base.rb:315 ../lib/yard/handlers/base.rb:336
msgid "Sets the attribute namespace"
msgstr "namespace属性を設定する"

# @param value
#: ../lib/yard/handlers/base.rb:317 ../lib/yard/handlers/base.rb:337
msgid "the value to set the attribute visibility to."
msgstr "値にvisibility属性を設定するための値"

# YARD::Parser::Ruby::RipperParser#ast
# YARD::Parser::Ruby::RipperParser#root
#: ../lib/yard/handlers/base.rb:318 ../lib/yard/handlers/base.rb:337
msgid "Returns the value of attribute visibility"
msgstr "visibility属性の値を返す"

# YARD::Parser::Ruby::AstNode#file=
#: ../lib/yard/handlers/base.rb:318 ../lib/yard/handlers/base.rb:338
msgid "Sets the attribute visibility"
msgstr "visibility属性を設定する。"

# @param value
#: ../lib/yard/handlers/base.rb:320 ../lib/yard/handlers/base.rb:339
msgid "the value to set the attribute scope to."
msgstr "値にスコープ属性を設定するための値"

# YARD::Parser::Ruby::Legacy::RubyToken::TkOPASGN#op
#: ../lib/yard/handlers/base.rb:321 ../lib/yard/handlers/base.rb:339
msgid "Returns the value of attribute scope"
msgstr "スコープ属性の値を返す"

# YARD::Parser::Ruby::AstNode#source=
#: ../lib/yard/handlers/base.rb:321 ../lib/yard/handlers/base.rb:340
msgid "Sets the attribute scope"
msgstr "スコープ属性を設定する"

# YARD::Tags::Library.labels
#: ../lib/yard/handlers/base.rb:324 ../lib/yard/handlers/base.rb:341
msgid "Returns the value of attribute globals"
msgstr "globals(全体)属性の値を返す"

# YARD::Parser::Ruby::Legacy::RubyLex#lex_state
#: ../lib/yard/handlers/base.rb:327 ../lib/yard/handlers/base.rb:342
msgid "Returns the value of attribute extra_state"
msgstr "extra_state属性の値を返す"

# YARD::Handlers::Base#push_state
#: ../lib/yard/handlers/base.rb:344
msgid ""
"Executes a given block with specific state values for {#owner},\n"
"{#namespace} and {#scope}."
msgstr ""
"{#owner}, {#namespace} , {#scope}メソッド用の特定の状態値と\n"
"一緒に与えられたブロックを実行する。"

# @yield
#: ../lib/yard/handlers/base.rb:355
msgid "a block to execute with the given state values."
msgstr "状態を指定すると共に実行するブロック。"

# @param [Proc]
#: ../lib/yard/handlers/base.rb:355
msgid "tag|param|block"
msgstr ""

# @param [Proc] block
#: ../lib/yard/handlers/base.rb:355
msgid "the block to execute with specific state"
msgstr "与えられた値の状態と共に実行するブロック。"

# YARD::Handlers::Base#register
#: ../lib/yard/handlers/base.rb:378
msgid ""
"Do some post processing on a list of code objects.\n"
"Adds basic attributes to the list of objects like\n"
"the filename, line number, {CodeObjects::Base#dynamic},\n"
"source code and {CodeObjects::Base#docstring},\n"
"but only if they don't exist."
msgstr ""
"コードオブジェクトのリストのいくつかの後処理をする。\n"
"ファイル名、行数、{CodeObjects::Base#dynamic} 、ソースコード、\n"
"{CodeObjects::Base#docstring}のようなオブジェクトのリストに、\n"
"基本属性を追加する。\n"
"しかし、それらが存在しない場合だけである。"

# @return [CodeObjects::Base, Array<CodeObjects::Base>]
#: ../lib/yard/handlers/base.rb:389
msgid "returns whatever is passed in, for chainability."
msgstr "メソッドチェーンの為、解析されるものを返す"

# @param [Array<CodeObjects::Base>]
#: ../lib/yard/handlers/base.rb:389 ../lib/yard/i18n/pot_generator.rb:90
#: ../lib/yard/templates/engine.rb:100
msgid "tag|param|objects"
msgstr ""

# @param [Array<CodeObjects::Base>] objects
#: ../lib/yard/handlers/base.rb:389
msgid "the list of objects to post-process."
msgstr "後処理の為のオブジェクトのリスト"

# YARD::Handlers::Base#register_ensure_loaded
#: ../lib/yard/handlers/base.rb:406
msgid ""
"Ensures that the object's namespace is loaded before attaching it\n"
"to the namespace."
msgstr ""

# @param [CodeObjects::Base] object
#: ../lib/yard/handlers/base.rb:411 ../lib/yard/handlers/base.rb:424
#: ../lib/yard/handlers/base.rb:433 ../lib/yard/handlers/base.rb:456
#: ../lib/yard/handlers/base.rb:470 ../lib/yard/handlers/base.rb:483
#: ../lib/yard/handlers/base.rb:495 ../lib/yard/handlers/base.rb:520
#: ../lib/yard/registry.rb:174
msgid "the object to register"
msgstr "記録するオブジェクト"

# YARD::Logger#enter_level
#: ../lib/yard/handlers/base.rb:420
msgid "Registers the file/line of the declaration with the object"
msgstr "オブジェクトを用い宣言のファイル/行を登録する"

# YARD::Handlers::Base#expand_macro
#: ../lib/yard/handlers/base.rb:429
msgid "Registers any docstring found for the object and expands macros"
msgstr "オブジェクト用に見つかった任意のdocstringを登録し、マクロを拡張する"

# YARD::Registry.at
# YARD::Registry.[]
#: ../lib/yard/handlers/base.rb:452
msgid "Registers the object as being inside a specific group"
msgstr "特定のグループ内部のものとしてオブジェクトを登録する"

# YARD::CodeObjects::MethodObject#aliases
#: ../lib/yard/handlers/base.rb:466
msgid "Registers any transitive tags from the namespace on the object"
msgstr "オブジェクト上のnamespaceから全てのtransitiveタグを登録する"

# YARD::Handlers::Base#register_visibility
#: ../lib/yard/handlers/base.rb:490
msgid ""
"Registers visibility on a method object. If the object does not\n"
"respond to setting visibility, nothing is done."
msgstr ""

# @param [Array<CodeObjects::Base>]
# @param [Array<String>]
# @param [Array]
#: ../lib/yard/handlers/base.rb:495
msgid "tag|param|visibility"
msgstr ""

# @return [String]
#: ../lib/yard/handlers/base.rb:495
msgid "the visibility to set on the object"
msgstr "オブジェクトを設定するためのvisibility"

# YARD::Handlers::Base#register_module_function
#: ../lib/yard/handlers/base.rb:501
msgid ""
"Registers the same method information on the module function, if\n"
"the object was defined as a module function."
msgstr ""

# @param [CodeObjects::Base] object
#: ../lib/yard/handlers/base.rb:506
msgid ""
"the possible module function object\n"
"to copy data for"
msgstr ""

# YARD::Handlers::Base#register_dynamic
#: ../lib/yard/handlers/base.rb:515
msgid ""
"Registers the object as dynamic if the object is defined inside\n"
"a method or block (owner != namespace)"
msgstr ""

# YARD::Handlers::Base#ensure_loaded!
#: ../lib/yard/handlers/base.rb:525
msgid ""
"Ensures that a specific +object+ has been parsed and loaded into the\n"
"registry. This is necessary when adding data to a namespace, for instance,\n"
"since the namespace may not have been processed yet (it can be located\n"
"in a file that has not been handled)."
msgstr ""
"特定の +object+ は解析されて、レジストリの中へロードされる事を保証する。\n"
"例えば、namespaceは、まだ処理されないかもしれないので\n"
"(処理されないファイルの中にそれはある可能性がある。)\n"
"これはnamespaceにデータを追加する時に必要である。"

# YARD::Handlers::Base#ensure_loaded!
#: ../lib/yard/handlers/base.rb:530
msgid ""
"Calling this method defers the handler until all other files have been\n"
"processed. If the object gets resolved, the rest of the handler continues,\n"
"otherwise an exception is raised."
msgstr ""
"このメソッドの呼び出しは\n"
"他の全てのファイルが処理されるまでハンドラーを延期する。\n"
"もしオブジェクトが解決された場合、ハンドラーの残りが続き、\n"
"さもなければ、例外を上げる。"

# @example Adding a mixin to the String class programmatically
#: ../lib/yard/handlers/base.rb:544
msgid ""
"ensure_loaded! P('String')\n"
"# \"String\" is now guaranteed to be loaded\n"
"P('String').mixins << P('MyMixin')"
msgstr ""

# @raise [NamespaceMissingError]
#: ../lib/yard/handlers/base.rb:544
msgid ""
"if the object is not resolved within\n"
"+max_retries+ attempts, this exception is raised and the handler\n"
"finishes processing."
msgstr ""
"オブジェクトが +max_retries+ を試みても解決されない場合、\n"
"この例外を上げ、ハンドラーが処理を終了させる。"

# @example
#: ../lib/yard/handlers/base.rb:544
msgid "tag|example|Adding a mixin to the String class programmatically"
msgstr "Stringクラスのプログラムにmixinを追加する"

# @param [Integer]
#: ../lib/yard/handlers/base.rb:544
msgid "tag|param|max_retries"
msgstr ""

# @param [Integer] max_retries
#: ../lib/yard/handlers/base.rb:544
msgid ""
"the number of times to defer the handler\n"
"before raising a +NamespaceMissingError+."
msgstr "+NamespaceMissingError+ を上げる前にハンドラーがリトライする回数"

# @param [Proxy, CodeObjects::Base] object
#: ../lib/yard/handlers/base.rb:544
msgid "the object to resolve."
msgstr "解決したいオブジェクト"

# @abstract
#: ../lib/yard/handlers/base.rb:567
msgid ""
"Implement this method to return the parameters in a method call\n"
"statement. It should return an empty list if the statement is not a\n"
"method call."
msgstr ""
"メソッド呼び出しステートメントの中のパラメータを返す為にこのメソッドを実装する。\n"
"ステートメントがメソッド呼び出しでない場合は空のリストを返すべき。"

# YARD::Handlers::Base#call_params
# YARD::Handlers::Base#caller_method
# YARD::Handlers::Base#find_or_create_macro
# YARD::Handlers::Base#expand_macro
#: ../lib/yard/handlers/base.rb:567 ../lib/yard/handlers/base.rb:576
msgid "Macro Support"
msgstr "マクロのサポート"

# @return [Array<String>]
#: ../lib/yard/handlers/base.rb:567
msgid "a list of argument names"
msgstr "引数の名前のリスト"

# @abstract
#: ../lib/yard/handlers/base.rb:576
msgid ""
"Implement this method to return the method being called in\n"
"a method call. It should return nil if the statement is not a method\n"
"call."
msgstr ""
"メソッド呼び出しの中で呼び出されるメソッドが返す為に\n"
"このメソッドが実装する。\n"
"ステートメントがメソッド呼び出しでない場合はnilを返すべき。"

# @return [nil]
#: ../lib/yard/handlers/base.rb:576
msgid "if the statement is not a method call"
msgstr "ステートメントがメソッド呼び出しでない場合"

# @return [String]
#: ../lib/yard/handlers/base.rb:576
msgid "the method name being called"
msgstr "呼び出されるメソッド名"

# YARD::Handlers::C::AliasHandler#process
# YARD::Handlers::C::AttributeHandler#process
# YARD::Handlers::C::ClassHandler#process
# YARD::Handlers::C::ConstantHandler#process
# YARD::Handlers::C::InitHandler#process
# YARD::Handlers::C::MethodHandler#process
# YARD::Handlers::C::MixinHandler#process
# YARD::Handlers::C::ModuleHandler#process
# YARD::Handlers::C::OverrideCommentHandler#process
# YARD::Handlers::C::PathHandler#process
# YARD::Handlers::C::StructHandler#process
# YARD::Handlers::C::SymbolHandler#process
# YARD::Handlers::Ruby::AliasHandler#process
# YARD::Handlers::Ruby::AttributeHandler#process
# YARD::Handlers::Ruby::ClassConditionHandler#process
# YARD::Handlers::Ruby::ClassHandler#process
# YARD::Handlers::Ruby::ClassVariableHandler#process
# YARD::Handlers::Ruby::CommentHandler#process
# YARD::Handlers::Ruby::ConstantHandler#process
# YARD::Handlers::Ruby::DSLHandler#process
# YARD::Handlers::Ruby::ExceptionHandler#process
# YARD::Handlers::Ruby::Legacy::AliasHandler#process
# YARD::Handlers::Ruby::Legacy::AttributeHandler#process
# YARD::Handlers::Ruby::Legacy::ClassConditionHandler#process
# YARD::Handlers::Ruby::Legacy::ClassHandler#process
# YARD::Handlers::Ruby::Legacy::ClassVariableHandler#process
# YARD::Handlers::Ruby::Legacy::CommentHandler#process
# YARD::Handlers::Ruby::Legacy::ConstantHandler#process
# YARD::Handlers::Ruby::Legacy::DSLHandler#process
# YARD::Handlers::Ruby::Legacy::ExceptionHandler#process
# YARD::Handlers::Ruby::Legacy::MethodHandler#process
# YARD::Handlers::Ruby::Legacy::MixinHandler#process
# YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler#process
# YARD::Handlers::Ruby::Legacy::ModuleHandler#process
# YARD::Handlers::Ruby::Legacy::PrivateConstantHandler#process
# YARD::Handlers::Ruby::Legacy::VisibilityHandler#process
# YARD::Handlers::Ruby::Legacy::YieldHandler#process
# YARD::Handlers::Ruby::MethodConditionHandler#process
# YARD::Handlers::Ruby::MethodHandler#process
# YARD::Handlers::Ruby::MixinHandler#process
# YARD::Handlers::Ruby::ModuleFunctionHandler#process
# YARD::Handlers::Ruby::ModuleHandler#process
# YARD::Handlers::Ruby::PrivateConstantHandler#process
# YARD::Handlers::Ruby::VisibilityHandler#process
# YARD::Handlers::Ruby::YieldHandler#process
#: ../lib/yard/handlers/c/alias_handler.rb:10
#: ../lib/yard/handlers/c/attribute_handler.rb:6
#: ../lib/yard/handlers/c/class_handler.rb:19
#: ../lib/yard/handlers/c/constant_handler.rb:8
#: ../lib/yard/handlers/c/init_handler.rb:8
#: ../lib/yard/handlers/c/method_handler.rb:22
#: ../lib/yard/handlers/c/mixin_handler.rb:7
#: ../lib/yard/handlers/c/module_handler.rb:9
#: ../lib/yard/handlers/c/override_comment_handler.rb:7
#: ../lib/yard/handlers/c/path_handler.rb:6
#: ../lib/yard/handlers/c/struct_handler.rb:8
#: ../lib/yard/handlers/c/symbol_handler.rb:7
#: ../lib/yard/handlers/ruby/alias_handler.rb:7
#: ../lib/yard/handlers/ruby/attribute_handler.rb:10
#: ../lib/yard/handlers/ruby/class_condition_handler.rb:16
#: ../lib/yard/handlers/ruby/class_handler.rb:8
#: ../lib/yard/handlers/ruby/class_variable_handler.rb:7
#: ../lib/yard/handlers/ruby/comment_handler.rb:7
#: ../lib/yard/handlers/ruby/constant_handler.rb:8
#: ../lib/yard/handlers/ruby/dsl_handler.rb:11
#: ../lib/yard/handlers/ruby/exception_handler.rb:6
#: ../lib/yard/handlers/ruby/legacy/alias_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/attribute_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/class_condition_handler.rb:8
#: ../lib/yard/handlers/ruby/legacy/class_handler.rb:8
#: ../lib/yard/handlers/ruby/legacy/class_variable_handler.rb:8
#: ../lib/yard/handlers/ruby/legacy/comment_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/constant_handler.rb:9
#: ../lib/yard/handlers/ruby/legacy/dsl_handler.rb:12
#: ../lib/yard/handlers/ruby/legacy/exception_handler.rb:6
#: ../lib/yard/handlers/ruby/legacy/method_handler.rb:6
#: ../lib/yard/handlers/ruby/legacy/mixin_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/module_function_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/module_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/private_constant_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/visibility_handler.rb:7
#: ../lib/yard/handlers/ruby/legacy/yield_handler.rb:6
#: ../lib/yard/handlers/ruby/method_condition_handler.rb:6
#: ../lib/yard/handlers/ruby/method_handler.rb:6
#: ../lib/yard/handlers/ruby/mixin_handler.rb:7
#: ../lib/yard/handlers/ruby/module_function_handler.rb:8
#: ../lib/yard/handlers/ruby/module_handler.rb:7
#: ../lib/yard/handlers/ruby/private_constant_handler.rb:7
#: ../lib/yard/handlers/ruby/visibility_handler.rb:9
#: ../lib/yard/handlers/ruby/yield_handler.rb:6
msgid "Main processing callback"
msgstr ""

# @return [Boolean]
#: ../lib/yard/handlers/c/base.rb:9
msgid "whether the handler handles this statement"
msgstr "ハンドラーがこのステートメントを操作するかどうか"

# @return [CodeObjects::Base]
#: ../lib/yard/handlers/c/base.rb:36 ../lib/yard/handlers/c/base.rb:40
#: ../lib/yard/handlers/c/base.rb:44 ../lib/yard/handlers/c/base.rb:48
msgid "Registering objects"
msgstr "オブジェクトを登録する"

# YARD::Handlers::C::Base#namespace_for_variable
# YARD::Handlers::C::Base#namespaces
# YARD::Handlers::C::Base#override_comments
# YARD::Handlers::C::Base#processed_files
# YARD::Handlers::C::Base#symbols
#: ../lib/yard/handlers/c/base.rb:54 ../lib/yard/handlers/c/base.rb:58
#: ../lib/yard/handlers/c/base.rb:62 ../lib/yard/handlers/c/base.rb:68
#: ../lib/yard/handlers/c/base.rb:72
msgid "Looking up Symbol and Var Values"
msgstr ""

# YARD::Handlers::Ruby::Base#parse_block
#: ../lib/yard/handlers/c/base.rb:78 ../lib/yard/handlers/ruby/base.rb:132
msgid "Parsing an Inner Block"
msgstr "内部のブロックを解析する"

# @return [String]
#: ../lib/yard/handlers/c/base.rb:87 ../lib/yard/handlers/c/base.rb:104
msgid "Processing other files"
msgstr "他のファイルを処理する"

# YARD::Handlers::Ruby::MethodConditionHandler
#: ../lib/yard/handlers/c/init_handler.rb:2
msgid "Handles the Init_Libname() method"
msgstr "Init_Libname()メソッドを操作する"

# YARD::CLI::Yardoc#parse_arguments
#: ../lib/yard/handlers/c/override_comment_handler.rb:2
msgid "Parses comments"
msgstr "コメントを解析する"

# YARD::Handlers::C::SymbolHandler
#: ../lib/yard/handlers/c/symbol_handler.rb:2
msgid ""
"Keeps track of function bodies for symbol lookup during Ruby method "
"declarations"
msgstr ""

# YARD::Handlers::Processor
#: ../lib/yard/handlers/processor.rb:6
msgid ""
"Iterates over all statements in a file and delegates them to the\n"
"{Handlers::Base} objects that are registered to handle the statement."
msgstr ""
"ファイルの中の全てのステートメントにまたがり繰り返し、\n"
"ステートメントを操作する為に記録される{Handlers::Base}オブジェクトに委譲す"
"る。"

# YARD::Handlers::Processor
#: ../lib/yard/handlers/processor.rb:9
msgid ""
"This class is passed to each handler and keeps overall processing state.\n"
"For example, if the {#visibility} is set in a handler, all following\n"
"statements will have access to this state. This allows \"public\",\n"
"\"protected\" and \"private\" statements to be handled in classes and "
"modules.\n"
"In addition, the {#namespace} can be set during parsing to control\n"
"where objects are being created from. You can also access extra stateful\n"
"properties that any handler can set during the duration of the post\n"
"processing of a file from {#extra_state}. If you need to access state\n"
"across different files, look at {#globals}."
msgstr ""
"このクラスはそれぞれのハンドラーが渡される。\n"
"そして、総合的な処理の状態を維持する。\n"
"例えば、{#visibility}はハンドラーの中で設定される。\n"
"全ての次のステートメントは、この状態にアクセス可能である。\n"
"これは、クラスやモジュールの中で操作される\n"
"\"public\",\"protected\",\"private\"ステートメントを受け入れる。\n"
"さらに、{#namespace}メソッドは、\n"
"オブジェクトが作成される場所で、制御の為に解析している間に設定される。\n"
"あなたは、追加の処理状態を把握する属性にアクセスも出来る。\n"
"任意のハンドラーが\n"
"{#extra_state}メソッドからファイルの後処理をしている間に\n"
"設定できる。\n"
"あなたが複数のファイルに渡って状態にアクセスする必要がある場合、\n"
"{#globals}メソッドで調べられる。"

# @see
#: ../lib/yard/handlers/processor.rb:19 ../lib/yard/handlers/ruby/base.rb:62
#: ../lib/yard/parser/source_parser.rb:62
msgid "tag|see|Handlers::Base"
msgstr ""

# YARD::Handlers::Processor.register_handler_namespace
#: ../lib/yard/handlers/processor.rb:23
msgid "Registers a new namespace for handlers of the given type."
msgstr "与える型の入ったハンドラー用の記録する。"

# @return [Hash]
#: ../lib/yard/handlers/processor.rb:31 ../lib/yard/handlers/processor.rb:33
#: ../lib/yard/parser/source_parser.rb:158
#: ../lib/yard/parser/source_parser.rb:160
msgid "a list of registered parser type extensions"
msgstr "parser type extensionsが,記録されるリスト"

# @return [String]
#: ../lib/yard/handlers/processor.rb:41
msgid "the filename"
msgstr "ファイル名"

# @return [CodeObjects::NamespaceObject]
#: ../lib/yard/handlers/processor.rb:44
msgid "the current namespace"
msgstr "現在のnamespace"

# @return [Symbol]
#: ../lib/yard/handlers/processor.rb:47
msgid "the current visibility (public, private, protected)"
msgstr "現在の可視性(public,private,protected)"

# @return [Symbol]
#: ../lib/yard/handlers/processor.rb:50
msgid "the current scope (class, instance)"
msgstr "現在のスコープ(クラス,インスタンス)"

# @return [CodeObjects::Base, nil]
#: ../lib/yard/handlers/processor.rb:56
msgid ""
"unlike the namespace, the owner\n"
"is a non-namespace object that should be stored between statements.\n"
"For instance, when parsing a method body, the {CodeObjects::MethodObject}\n"
"is set as the owner, in case any extra method information is processed."
msgstr ""
"namespaceとは異なり、ownerは、\n"
"ステートメントの間に記録されるnamespaceオブジェクトを持たない。\n"
"例えば、メソッド本体を解析する時、{CodeObjects::MethodObject}は、\n"
"このownerのように設定される。この場合、何らかの追加のメソッド情報が処理され"
"る。"

# @return [Symbol]
#: ../lib/yard/handlers/processor.rb:59
msgid "the parser type (:ruby, :ruby18, :c)"
msgstr "パーサー型(:ruby, :ruby18, :c)"

# YARD::Handlers::Base#globals
# YARD::Handlers::Processor#globals
# YARD::Handlers::Processor#globals=
#: ../lib/yard/handlers/processor.rb:62
msgid ""
"Handlers can share state for the entire post processing stage through\n"
"this attribute. Note that post processing stage spans multiple files.\n"
"To share state only within a single file, use {#extra_state}"
msgstr ""
"ハンドラーはこの属性を通して全体の後処理環境用の状態を共有できる。\n"
"以下の事に留意する。\n"
"後処理の状態は、複数ファイルに渡す。\n"
"単一のファイルの中でだけ状態を共有するには、 {#extra_state} を使用する。"

# @example Sharing state among two handlers
#: ../lib/yard/handlers/processor.rb:77
msgid ""
"class Handler1 < YARD::Handlers::Ruby::Base\n"
"  handles :class\n"
"  process { globals.foo = :bar }\n"
"end\n"
"\n"
"class Handler2 < YARD::Handlers::Ruby::Base\n"
"  handles :method\n"
"  process { puts globals.foo }\n"
"end"
msgstr ""

# @return [OpenStruct]
#: ../lib/yard/handlers/processor.rb:77
msgid "global shared state for post-processing stage"
msgstr "後処理環境用に状態を共有される,global"

# @example
#: ../lib/yard/handlers/processor.rb:77
msgid "tag|example|Sharing state among two handlers"
msgstr "2つのハンドラーの間で状態を共有する"

# @see
#: ../lib/yard/handlers/processor.rb:77
msgid "tag|see|#extra_state"
msgstr ""

# YARD::Handlers::Base#extra_state
# YARD::Handlers::Processor#extra_state
# YARD::Handlers::Processor#extra_state=
#: ../lib/yard/handlers/processor.rb:80
msgid ""
"Share state across different handlers inside of a file.\n"
"This attribute is similar to {#visibility}, {#scope}, {#namespace}\n"
"and {#owner}, in that they all maintain state across all handlers\n"
"for the entire source file. Use this attribute to store any data\n"
"your handler might need to save during the parsing of a file. If\n"
"you need to save state across files, see {#globals}."
msgstr ""
"ファイルの内部の別のハンドラーの行き来の状態を共有する。\n"
"それらは全体のソースファイルの為に全てのハンドラーの行き来の状態を\n"
"全て維持するという点で {#visibility}, {#scope}, {#namespace}, {#owner}属性と"
"似ている。\n"
"この属性を使って、あなたのハンドラーが必要とするかもしれないデータを格納し\n"
"ファイルの解析中に保存する。\n"
"ファイル全体の状態の保存が必要な場合、 {#globals} を参照。"

# @return [OpenStruct]
#: ../lib/yard/handlers/processor.rb:88
msgid "an open structure that can store arbitrary data"
msgstr "任意のデータを記録できる簡単な構造体"

# @see
#: ../lib/yard/handlers/processor.rb:88
msgid "tag|see|#globals"
msgstr ""

# YARD::Handlers::Processor#initialize
#: ../lib/yard/handlers/processor.rb:91
msgid "Creates a new Processor for a +file+."
msgstr "+file+用の新しいProcessorを作成する"

# @return [Processor]
#: ../lib/yard/handlers/processor.rb:92
msgid "a new instance of Processor"
msgstr "プロセッサーの新しいインスタンス"

# @param [Array<Parser::Ruby::AstNode>]
# @param [Hash]
#: ../lib/yard/handlers/processor.rb:92 ../lib/yard/tags/directives.rb:54
#: ../lib/yard/tags/library.rb:290
msgid "tag|param|parser"
msgstr ""

# @param [Integer] char_no
#: ../lib/yard/handlers/processor.rb:92
msgid "the parser used to initialize the processor"
msgstr "プロセッサを初期化するために使ったパーサー"

# YARD::Handlers::Processor#process
#: ../lib/yard/handlers/processor.rb:106
msgid ""
"Processes a list of statements by finding handlers to process each\n"
"one."
msgstr ""
"処理の各自の処理ハンドラーが見つけることによって\n"
"処理ステートメントのリスト\n"

# @param [Array] statements
#: ../lib/yard/handlers/processor.rb:110
msgid "a list of statements"
msgstr "ステートメントのリスト"

# @param [Array]
#: ../lib/yard/handlers/processor.rb:110
msgid "tag|param|statements"
msgstr "statements"

# YARD::Handlers::Processor#parse_remaining_files
#: ../lib/yard/handlers/processor.rb:133
msgid ""
"Continue parsing the remainder of the files in the +globals.ordered_parser+\n"
"object. After the remainder of files are parsed, processing will continue\n"
"on the current file."
msgstr ""

# @see
#: ../lib/yard/handlers/processor.rb:138
msgid "tag|see|Parser::OrderedParser"
msgstr ""

# YARD::Handlers::Processor#find_handlers
#: ../lib/yard/handlers/processor.rb:146
msgid ""
"Searches for all handlers in {Base.subclasses} that match the +statement+"
msgstr ""
"+statement+ にマッチする{Base.sublasses}の中の全てのハンドラー用に検索する。"

# @return [Array<Base>]
#: ../lib/yard/handlers/processor.rb:149
msgid "a list of handlers to process the statement with."
msgstr "ステートメントと共に処理する為のハンドラーのリスト"

# @param statement
#: ../lib/yard/handlers/processor.rb:149
msgid "the statement object to match."
msgstr "オブジェクトにマッチするステートメント"

# YARD::Handlers::Processor#handler_base_class
#: ../lib/yard/handlers/processor.rb:169
msgid "Returns the handler base class"
msgstr "ハンドラーのbaseクラスを返す"

# @return [Base]
#: ../lib/yard/handlers/processor.rb:170
msgid "the base class"
msgstr ""

# YARD::Handlers::Processor#handler_base_namespace
#: ../lib/yard/handlers/processor.rb:175
msgid "The module holding the handlers to be loaded"
msgstr "ロードされるハンドラーを保持する,モジュール"

# @return [Module]
#: ../lib/yard/handlers/processor.rb:178
msgid ""
"the module containing the handlers depending on\n"
"{#parser_type}."
msgstr "{#parser_type}メソッドに依存しているハンドラーを含んでいる,モジュール"

# YARD::Handlers::Processor#load_handlers
#: ../lib/yard/handlers/processor.rb:183
msgid ""
"Loads handlers from {#handler_base_namespace}. This ensures that\n"
"Ruby1.9 handlers are never loaded into 1.8; also lowers the amount\n"
"of modules that are loaded"
msgstr ""
"{#handler_base_namespace}から、ハンドラーをロードする。\n"
"これはロードされるモジュールの量を減少させると共に\n"
"Ruby1.9ハンドラーが1.8でロードされない事を保証する。"

# YARD::Handlers::Ruby::Legacy::AliasHandler
# YARD::Handlers::Ruby::AliasHandler
#: ../lib/yard/handlers/ruby/alias_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/alias_handler.rb:2
msgid "Handles alias and alias_method calls"
msgstr "aliasを操作し、alias_methodを呼び出す。"

# YARD::Handlers::Ruby::Legacy::AttributeHandler
# YARD::Handlers::Ruby::AttributeHandler
#: ../lib/yard/handlers/ruby/attribute_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/attribute_handler.rb:2
msgid "Handles +attr_*+ statements in modules/classes"
msgstr "モジュール/クラスの中の +attr_+ ステートメントを操作する。"

# YARD::Handlers::Ruby::AttributeHandler#validated_attribute_names
#: ../lib/yard/handlers/ruby/attribute_handler.rb:65
msgid "Strips out any non-essential arguments from the attr statement."
msgstr "attrステートメントから、任意の重要ではない引数を取り除く"

# @param [Array<Parser::Ruby::AstNode>] params
#: ../lib/yard/handlers/ruby/attribute_handler.rb:70
msgid ""
"a list of the parameters\n"
"in the attr call."
msgstr "attrの中で呼ばれる引数のリスト"

# @raise [Parser::UndocumentableError]
#: ../lib/yard/handlers/ruby/attribute_handler.rb:70
msgid "if the arguments are not valid."
msgstr "引数が有効でない場合"

# @param [Array<Parser::Ruby::AstNode>]
# @param [Hash]
#: ../lib/yard/handlers/ruby/attribute_handler.rb:70
#: ../lib/yard/templates/helpers/base_helper.rb:138
msgid "tag|param|params"
msgstr "params"

# @return [Array<String>]
#: ../lib/yard/handlers/ruby/attribute_handler.rb:70
msgid "the validated attribute names"
msgstr "有効化された属性名"

# YARD::Handlers::Ruby::HandlesExtension
#: ../lib/yard/handlers/ruby/base.rb:5
msgid ""
"To implement a custom handler matcher, subclass this class and implement\n"
"{#matches?} to return whether a node matches the handler."
msgstr ""
"カスタムハンドラーのマッチャーを実装するには、このクラスをサブクラス化す"
"る。\n"
"そして、ノードがハンドラーにマッチするかどうかを返す為に{#matches?}メソッドを"
"実装する。"

# @example A Custom Handler Matcher Extension
#: ../lib/yard/handlers/ruby/base.rb:18
msgid ""
"# Implements a handler that checks for a specific string\n"
"# in the node's source.\n"
"class MyExtension < HandlesExtension\n"
"  def matches?(node) node.source.include?(name) end\n"
"end\n"
"\n"
"# This handler will handle any node where the source includes 'foo'\n"
"class MyHandler < Handlers::Ruby::Base\n"
"  handles MyExtension.new('foo')\n"
"end"
msgstr ""
"# 特定の文字列をチェックするハンドラーを実装する\n"
"# ノードのソースの中で\n"
"class MyExtension < HandlesExtension\n"
"  def matches?(node) node.source.include?(name) end\n"
"end\n"
"\n"
"# このハンドラーは'foo'を含んでいるソースの所で任意のノードを操作する。\n"
"class MyHandler < Handlers::Ruby::Base\n"
"  handles MyExtension.new('foo')\n"
"end"

# @example
#: ../lib/yard/handlers/ruby/base.rb:18
msgid "tag|example|A Custom Handler Matcher Extension"
msgstr "カスタムハンドラーのマッチャーの拡張"

# YARD::Handlers::Ruby::HandlesExtension#initialize
#: ../lib/yard/handlers/ruby/base.rb:20
msgid "Creates a new extension with a specific matcher value +name+"
msgstr "特定のマッチャーの値の +name+ と共に、新たな拡張を作成する"

# @return [HandlesExtension]
#: ../lib/yard/handlers/ruby/base.rb:21
msgid "a new instance of HandlesExtension"
msgstr "HandlesExtensionの新しいインスタンス"

# @param [Object] name
#: ../lib/yard/handlers/ruby/base.rb:21
msgid "the matcher value to check against {#matches?}"
msgstr "{#matches?}メソッドに備えて確認する,マッチャーの値"

# YARD::Handlers::Ruby::HandlesExtension#matches?
#: ../lib/yard/handlers/ruby/base.rb:24
msgid "Tests if the node matches the handler"
msgstr "ノードがハンドラーにマッチする場合、テストする。"

# @param [Parser::Ruby::AstNode] node
#: ../lib/yard/handlers/ruby/base.rb:26
msgid "a Ruby node"
msgstr "Rubyのノード"

# @param [Parser::Ruby::AstNode]
#: ../lib/yard/handlers/ruby/base.rb:26
msgid "tag|param|node"
msgstr "node"

# @return [Boolean]
#: ../lib/yard/handlers/ruby/base.rb:26
msgid "whether the +node+ matches the handler"
msgstr "+node+ がハンドラーにマッチするかどうか"

# @return [String]
#: ../lib/yard/handlers/ruby/base.rb:31
msgid "the extension matcher value"
msgstr "拡張のマッチャーの値"

# YARD::Handlers::Ruby::Base
#: ../lib/yard/handlers/ruby/base.rb:55
msgid ""
"This is the base handler class for the new-style (1.9) Ruby parser.\n"
"All handlers that subclass this base class will be used when the\n"
"new-style parser is used. For implementing legacy handlers, see\n"
"{Legacy::Base}."
msgstr ""
"これは、新しい(1.9用)Rubyパーサー用の基本ハンドラークラスとなる。\n"
"この基本クラスからサブクラス化する全てのハンドラーは、\n"
"新しいスタイルのパーサーを使う時に利用される。\n"
"レガシーハンドラーの実装には、{Legacy::Base}を参照。"

# @abstract
#: ../lib/yard/handlers/ruby/base.rb:62
msgid "See {Handlers::Base} for subclassing information."
msgstr "サブクラス化用の情報には、{Handlers::Base}を参照"

# @see
#: ../lib/yard/handlers/ruby/base.rb:62
msgid "tag|see|Legacy::Base"
msgstr ""

# YARD::Handlers::Ruby::Base.method_call
#: ../lib/yard/handlers/ruby/base.rb:69
msgid ""
"Matcher for handling any type of method call. Method calls can\n"
"be expressed by many {AstNode} types depending on the syntax\n"
"with which it is called, so YARD allows you to use this matcher\n"
"to simplify matching a method call."
msgstr ""
"任意のメソッド呼び出しの型を操作する為のマッチャー\n"
"メソッド呼び出しは、\n"
"構文から多くの{AstNode}型となって表され\n"
"呼び出す事ができる。\n"
"なので、YARDは\n"
"あなたがメソッド呼び出しのマッチを簡単にする為に\n"
"このマッチャーを使う事を許可する。"

# YARD::Handlers::Ruby::Base.method_call
# YARD::Handlers::Ruby::Base.meta_type
#: ../lib/yard/handlers/ruby/base.rb:83 ../lib/yard/handlers/ruby/base.rb:102
msgid "Statement Matcher Extensions"
msgstr "ステートメントマッチャーの拡張"

# @example Match the "describe" method call
#: ../lib/yard/handlers/ruby/base.rb:83
msgid ""
"handles method_call(:describe)\n"
"\n"
"# The following will be matched:\n"
"# describe(...)\n"
"# object.describe(...)\n"
"# describe \"argument\" do ... end"
msgstr ""

# @param [#to_s] name
#: ../lib/yard/handlers/ruby/base.rb:83
msgid "matches the method call of this name"
msgstr "この名前のメソッド呼び出しのマッチャー"

# @example
#: ../lib/yard/handlers/ruby/base.rb:83
msgid "tag|example|Match the \"describe\" method call"
msgstr "\"describe\"メソッド呼び出しにマッチする"

# YARD::Handlers::Ruby::Base.meta_type
#: ../lib/yard/handlers/ruby/base.rb:88
msgid ""
"Matcher for handling a node with a specific meta-type. An {AstNode}\n"
"has a {AstNode#type} to define its type but can also be associated\n"
"with a set of types. For instance, +:if+ and +:unless+ are both\n"
"of the meta-type +:condition+."
msgstr ""
"特定のメタタイプと共にノードを処理する為のマッチャー。\n"
"{AstNode}はAstNodeの型を定義する為に\n"
"{AstNode#type}メソッドを持っている。\n"
"しかし、型のグループと共に関連付ける事もできる。\n"
"例えば、 +:if+ と +:unless+ は、両方とも +:condition+ のメタタイプとなる。"

# YARD::Handlers::Ruby::Base.meta_type
#: ../lib/yard/handlers/ruby/base.rb:93
msgid ""
"A meta-type is any method on the {AstNode} class ending in \"?\",\n"
"though you should not include the \"?\" suffix in your declaration.\n"
"Some examples are: \"condition\", \"call\", \"literal\", \"kw\", \"token\",\n"
"\"ref\"."
msgstr ""
"メタタイプは、\"?\"で終わる{AstNode}クラスの任意のメソッドである。\n"
"なので、あなたは、自身の宣言の中で\"?\"サフィックスを含むべきではない。\n"
"いくつかの例を上げると、\"condition\", \"call\", \"literal\", \"kw\", \"token"
"\",\"ref\" となる。"

# @example Handling any conditional statement (if, unless)
#: ../lib/yard/handlers/ruby/base.rb:102
msgid "handles meta_type(:condition)"
msgstr ""

# @example
#: ../lib/yard/handlers/ruby/base.rb:102
msgid "tag|example|Handling any conditional statement (if, unless)"
msgstr "任意の条件文(if, unless)を操作する"

# @param [Symbol] type
#: ../lib/yard/handlers/ruby/base.rb:102
msgid ""
"the meta-type to match. A meta-type can be\n"
"any method name + \"?\" that {AstNode} responds to."
msgstr ""
"マッチするメタタイプ。\n"
"メタタイプは、{AstNode}に対応する任意のメソッド名 + \"?\" でできる。"

# YARD::Handlers::Ruby::Base.handles?
#: ../lib/yard/handlers/ruby/base.rb:110
msgid "Testing for a Handler"
msgstr "ハンドラー用にテストする。"

# @return [Boolean]
#: ../lib/yard/handlers/ruby/base.rb:110
msgid ""
"whether or not an {AstNode} object should be\n"
"handled by this handler"
msgstr "{AstNode}オブジェクトはこのハンドラーによって処理されるかどうか"

# YARD::Handlers::Ruby::Base#call_params
# YARD::Handlers::Ruby::Base#caller_method
#: ../lib/yard/handlers/ruby/base.rb:141 ../lib/yard/handlers/ruby/base.rb:152
msgid "Macro Handling"
msgstr "マクロを処理する"

# YARD::Handlers::Ruby::Legacy::ClassConditionHandler
# YARD::Handlers::Ruby::ClassConditionHandler
#: ../lib/yard/handlers/ruby/class_condition_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/class_condition_handler.rb:2
msgid ""
"Matches if/unless conditions inside classes and attempts to process only\n"
"one branch (by evaluating the condition if possible)."
msgstr ""
"クラス内部のif/unless条件にマッチし、一つのブランチだけを処理する。(条件を評"
"価し可能ならば)"

# @example A simple class conditional
#: ../lib/yard/handlers/ruby/class_condition_handler.rb:11
msgid ""
"class Foo\n"
"  if 0\n"
"    # This method is ignored\n"
"    def xyz; end\n"
"  end\n"
"end"
msgstr ""
"class Foo\n"
"  if 0\n"
"    # このメソッドは無視される\n"
"    def xyz; end\n"
"  end\n"
"end"

# @example
#: ../lib/yard/handlers/ruby/class_condition_handler.rb:11
msgid "tag|example|A simple class conditional"
msgstr "シンプルな条件のクラス"

# YARD::Handlers::Ruby::Legacy::ClassConditionHandler#parse_condition
# YARD::Handlers::Ruby::ClassConditionHandler#parse_condition
#: ../lib/yard/handlers/ruby/class_condition_handler.rb:31
#: ../lib/yard/handlers/ruby/legacy/class_condition_handler.rb:23
msgid "Parses the condition part of the if/unless statement"
msgstr "if/unlessステートメントの部分の条件を解析する。"

# @return [true, false, nil]
#: ../lib/yard/handlers/ruby/class_condition_handler.rb:35
#: ../lib/yard/handlers/ruby/legacy/class_condition_handler.rb:28
msgid ""
"true if the condition can be definitely\n"
"parsed to true, false if not, and nil if the condition cannot be\n"
"parsed with certainty (it's dynamic)"
msgstr ""
"条件が間違いなく解析できる場合、true\n"
"そうでない場合、falseや、\n"
"条件が完璧に解析できない場合、nilとなる。\n"
"(it's dynamic)"

# YARD::Handlers::Ruby::Legacy::ClassHandler
# YARD::Handlers::Ruby::ClassHandler
#: ../lib/yard/handlers/ruby/class_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/class_handler.rb:2
msgid "Handles class declarations"
msgstr "クラスの宣言を操作する"

# YARD::Handlers::Ruby::ClassHandler#extract_parameters
# YARD::Handlers::Ruby::ConstantHandler#extract_parameters
#: ../lib/yard/handlers/ruby/class_handler.rb:63
#: ../lib/yard/handlers/ruby/constant_handler.rb:35
msgid ""
"Extract the parameters from the Struct.new AST node, returning them as a "
"list\n"
"of strings"
msgstr ""
"パラメータをStrct.new Astノードから抽出し、文字列のリストとしてAstノードを返"
"す。"

# @param [MethodCallNode]
# @param [String]
#: ../lib/yard/handlers/ruby/class_handler.rb:67
#: ../lib/yard/handlers/ruby/constant_handler.rb:39
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:91
msgid "tag|param|superclass"
msgstr "superclass"

# @param [MethodCallNode] superclass
#: ../lib/yard/handlers/ruby/class_handler.rb:67
#: ../lib/yard/handlers/ruby/constant_handler.rb:39
msgid "the AST node for the Struct.new call"
msgstr "Struct.new呼び出し用のASTノード"

# @return [Array<String>]
#: ../lib/yard/handlers/ruby/class_handler.rb:67
#: ../lib/yard/handlers/ruby/constant_handler.rb:39
msgid "the member names to generate methods for"
msgstr "member名にメソッドを生成する,member名"

# YARD::Handlers::Ruby::Legacy::ClassVariableHandler
# YARD::Handlers::Ruby::ClassVariableHandler
#: ../lib/yard/handlers/ruby/class_variable_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/class_variable_handler.rb:2
msgid "Handles a class variable (@@variable)"
msgstr "クラス変数を操作する(@@変数)"

# YARD::Handlers::Ruby::Legacy::ConstantHandler
# YARD::Handlers::Ruby::ConstantHandler
#: ../lib/yard/handlers/ruby/comment_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/comment_handler.rb:2
msgid "Handles any lone comment statement in a Ruby file"
msgstr "Rubyのファイルの中の任意の単一のコメントステートメントを操作する"

# YARD::Handlers::Ruby::Legacy::ConstantHandler
# YARD::Handlers::Ruby::ConstantHandler
#: ../lib/yard/handlers/ruby/constant_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/constant_handler.rb:2
msgid "Handles any constant assignment"
msgstr "任意の定数割り当てを操作する"

# YARD::Handlers::Ruby::Legacy::MacroHandler
# YARD::Handlers::Ruby::MacroHandler
#: ../lib/yard/handlers/ruby/dsl_handler.rb:5
#: ../lib/yard/handlers/ruby/legacy/dsl_handler.rb:6
msgid "Handles automatic detection of dsl-style methods"
msgstr "DSLスタイルのメソッドの自動宣言を操作する"

# YARD::Handlers::Ruby::Legacy::ExceptionHandler
# YARD::Handlers::Ruby::ExceptionHandler
#: ../lib/yard/handlers/ruby/exception_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/exception_handler.rb:2
msgid "Handles 'raise' calls inside methods"
msgstr "メソッドの内部で呼び出す'raise'を操作する"

# YARD::Handlers::Ruby::Legacy::ExtendHandler
# YARD::Handlers::Ruby::ExtendHandler
#: ../lib/yard/handlers/ruby/extend_handler.rb:2
#: ../lib/yard/handlers/ruby/legacy/extend_handler.rb:2
msgid ""
"Handles 'extend' call to include modules into the class scope of another"
msgstr ""
"他のクラススコープの中へモジュールを含める為に、'extend'呼び出しを操作する。"

# @see
#: ../lib/yard/handlers/ruby/extend_handler.rb:3
msgid "tag|see|MixinHandler"
msgstr ""

# YARD::Handlers::Ruby::Legacy::Base
#: ../lib/yard/handlers/ruby/legacy/base.rb:5
msgid ""
"This is the base handler for the legacy parser. To implement a legacy\n"
"handler, subclass this class."
msgstr ""
"これは、legacy parser用のbase handlerとなる。\n"
"legacy handlerの実装には、このクラスをサブクラスにする。"

# @return [Boolean]
#: ../lib/yard/handlers/ruby/legacy/base.rb:14
msgid ""
"whether or not a {Parser::Ruby::Legacy::Statement} object should be handled\n"
"by this handler."
msgstr ""
"{Parser::Ruby::Legacy::Statement}オブジェクトが、\n"
"このハンドラーによって操作されるかどうか"

# YARD::Handlers::Ruby::Legacy::Base#parse_block
#: ../lib/yard/handlers/ruby/legacy/base.rb:28
msgid ""
"Parses a statement's block with a set of state values. If the\n"
"statement has no block, nothing happens. A description of state\n"
"values can be found at {Handlers::Base#push_state}"
msgstr ""
"値の状態のグループと共に、ブロックのステートメントを解析する。\n"
"ステートメントがブロックを持たない場合、何も起こらない。\n"
"値の状態の説明は、{Handlers::Base#push_state}で見つけられる。"

# @see Handlers::Base#push_state
#: ../lib/yard/handlers/ruby/legacy/base.rb:34
msgid "#push_state"
msgstr ""

# @param [Hash] opts
#: ../lib/yard/handlers/ruby/legacy/base.rb:34
msgid "State options"
msgstr "オプションの状態"

# @see
#: ../lib/yard/handlers/ruby/legacy/base.rb:34
msgid "tag|see|Handlers::Base#push_state"
msgstr ""

# YARD::Handlers::Ruby::Legacy::Base#extract_method_details
#: ../lib/yard/handlers/ruby/legacy/base.rb:67
msgid "Extracts method information for macro expansion only"
msgstr ""

# @todo
#: ../lib/yard/handlers/ruby/legacy/base.rb:71
msgid "This is a duplicate implementation of {MethodHandler}. Refactor."
msgstr ""

# @return [Array<String,Array<Array<String>>>]
#: ../lib/yard/handlers/ruby/legacy/base.rb:71
msgid ""
"the method name followed by method\n"
"arguments (name and optional value)"
msgstr ""

# YARD::Handlers::Ruby::Legacy::Base#tokval
#: ../lib/yard/handlers/ruby/legacy/base.rb:85
msgid ""
"The string value of a token. For example, the return value for the symbol :"
"sym\n"
"would be :sym. The return value for a string +\"foo #{ bar}\"+ would be the "
"literal\n"
"+\"foo #{ bar}\"+ without any interpolation. The return value of the "
"identifier\n"
"'test' would be the same value: 'test'. Here is a list of common types and\n"
"their return values:"
msgstr ""
"トークンの文字列の値。例えば、シンボル:sym用に返す値は、:symになる。\n"
"文字列 +\"foo #{ bar}\"+ 用に返す値は、補完を含まない +\"foo #{ bar}\"+ リテ"
"ラルになる。\n"
"'test'識別子の返す値は、'test'と同じ値になるだろう。\n"
"ここでは、一般的な型のリストやそれらの値を返す。"

# @param [Array<Class<Token>>, Symbol] accepted_types
#: ../lib/yard/handlers/ruby/legacy/base.rb:116
msgid ""
"The allowed token types that this token can be. Defaults to [{TkVal}].\n"
"A list of types would be, for example, [+TkSTRING+, +TkSYMBOL+], to return\n"
"the token's value if it is either of those types. If +TkVal+ is accepted,\n"
"+TkNode+ is also accepted.\n"
"\n"
"Certain symbol keys are allowed to specify multiple types in one fell "
"swoop.\n"
"These symbols are:\n"
"  :string       => +TkSTRING+, +TkDSTRING+, +TkDXSTRING+ and +TkXSTRING+\n"
"  :attr         => +TkSYMBOL+ and +TkSTRING+\n"
"  :identifier   => +TkIDENTIFIER, +TkFID+ and +TkGVAR+.\n"
"  :number       => +TkFLOAT+, +TkINTEGER+"
msgstr ""
"トークンにできる受け入れられるトークンの型となる。\n"
"デフォルトでは、[{TkVal}]になる。\n"
"型のリストになる、\n"
"\n"
"例えば、[+TkSTRING+, +TkSYMBOL+]は、\n"
"どちらかがこれらの型の場合、トークンの値を返す。\n"
"+TkVal+が受け入れられる場合、+TkNode+も受け入れられる。\n"
"\n"
"特定のシンボルキーは、一つで複数の型を一気に指定する為に受け入れられる。\n"
"このようなシンボルとなる:\n"
"  :string       => +TkSTRING+, +TkDSTRING+, +TkDXSTRING+ and +TkXSTRING+\n"
"  :attr         => +TkSYMBOL+ and +TkSTRING+\n"
"  :identifier   => +TkIDENTIFIER, +TkFID+ and +TkGVAR+.\n"
"  :number       => +TkFLOAT+, +TkINTEGER+"

# @param [Token] token
#: ../lib/yard/handlers/ruby/legacy/base.rb:116
msgid "The token of the class"
msgstr "クラスのトークン"

# @return [nil]
#: ../lib/yard/handlers/ruby/legacy/base.rb:116
msgid "if the token is not any of the specified accepted types"
msgstr "トークンが指定され受け入れられる型のどれでもない場合、"

# @return [Object]
#: ../lib/yard/handlers/ruby/legacy/base.rb:116
msgid ""
"if the token is one of the accepted types, in its real value form.\n"
"It should be noted that identifiers and constants are kept in String form."
msgstr ""
"トークンが受け入れられる型の一つの場合、その中は、実際の値の形式になる。\n"
"そして、識別子と定数がString形式で注釈される。"

# @param [Array<Class<Token>>, Symbol]
# @param [Array<Class<Token>>]
#: ../lib/yard/handlers/ruby/legacy/base.rb:116
#: ../lib/yard/handlers/ruby/legacy/base.rb:182
msgid "tag|param|accepted_types"
msgstr "accepted_types"

# @param [Token]
#: ../lib/yard/handlers/ruby/legacy/base.rb:116
msgid "tag|param|token"
msgstr "token"

# @example 
#: ../lib/yard/handlers/ruby/legacy/base.rb:116
msgid ""
"tokval(TokenList.new('\"foo\"').first) => \"foo\"\n"
"tokval(TokenList.new(':foo').first) => :foo\n"
"tokval(TokenList.new('CONSTANT').first, RubyToken::TkId) => \"CONSTANT\"\n"
"tokval(TokenList.new('identifier').first, RubyToken::TkId) => \"identifier"
"\"\n"
"tokval(TokenList.new('3.25').first) => 3.25\n"
"tokval(TokenList.new('/xyz/i').first) => /xyz/i"
msgstr ""

# YARD::Handlers::Ruby::Legacy::Base#tokval_list
#: ../lib/yard/handlers/ruby/legacy/base.rb:162
msgid ""
"Returns a list of symbols or string values from a statement.\n"
"The list must be a valid comma delimited list, and values\n"
"will only be returned to the end of the list only."
msgstr ""
"ステートメントから、シンボル,又は,文字列の値のリストを返す。\n"
"リストは、有効なカンマで区切られたリストでなければならない、\n"
"そして、値はリストで返されるだけにしなければならない。"

# YARD::Handlers::Ruby::Legacy::Base#tokval_list
#: ../lib/yard/handlers/ruby/legacy/base.rb:166
msgid ""
"Example:\n"
"  attr_accessor :a, 'b', :c, :d => ['a', 'b', 'c', 'd']\n"
"  attr_accessor 'a', UNACCEPTED_TYPE, 'c' => ['a', 'c']"
msgstr ""

# YARD::Handlers::Ruby::Legacy::Base#tokval_list
#: ../lib/yard/handlers/ruby/legacy/base.rb:170
msgid ""
"The tokval list of a {Parser::Ruby::Legacy::TokenList} of the above\n"
"code would be the {#tokval} value of :a, 'b',\n"
":c and :d."
msgstr ""
"上のコード{Parser::Ruby::Legacy::TokenList}のtokvalのリストは、\n"
":a, 'b', :c, :d の入った{#tokval}の値になる。"

# YARD::Handlers::Ruby::Legacy::Base#tokval_list
#: ../lib/yard/handlers/ruby/legacy/base.rb:174
msgid ""
"It should also be noted that this function stops immediately at\n"
"any ruby keyword encountered:\n"
"  \"attr_accessor :a, :b, :c if x == 5\"  => ['a', 'b', 'c']"
msgstr ""
"それは、この機能が任意のrubyキーワードが出会った所で、\n"
"直後に止めて注釈される。\n"
"  \"attr_accessor :a, :b, :c if x == 5\"  => ['a', 'b', 'c']"

# @param [TokenList] tokenlist
#: ../lib/yard/handlers/ruby/legacy/base.rb:182
msgid "The list of tokens to process."
msgstr "処理されるトークンのリスト"

# @return [Array<EMPTY>]
#: ../lib/yard/handlers/ruby/legacy/base.rb:182
msgid "if there are no symbols or Strings in the list"
msgstr "シンボルやリストの文字列がない場合"

# @param [Array<Class<Token>>] accepted_types
#: ../lib/yard/handlers/ruby/legacy/base.rb:182
msgid "passed to {#tokval}"
msgstr "{#tokval}に渡される"

# @param [TokenList]
#: ../lib/yard/handlers/ruby/legacy/base.rb:182
msgid "tag|param|tokenlist"
msgstr "tokenlist"

# @see
#: ../lib/yard/handlers/ruby/legacy/base.rb:182
msgid "tag|see|#tokval"
msgstr ""

# @return [Array<String>]
#: ../lib/yard/handlers/ruby/legacy/base.rb:182
msgid "the list of tokvalues in the list."
msgstr "リストの中のtokvaluesのリスト"

# YARD::Handlers::Ruby::Legacy::ClassHandler#extract_parameters
#: ../lib/yard/handlers/ruby/legacy/class_handler.rb:62
msgid ""
"Extracts the parameter list from the Struct.new declaration and returns it\n"
"formatted as a list of member names. Expects the user will have used "
"symbols\n"
"to define the struct member names"
msgstr ""
"Struct.new宣言から、引数のリストを抽出し、\n"
"それをメンバー名のリストとして、書式化して返す\n"
"ユーザーは、structメンバー名を定義する為に、シンボルを\n"
"利用する事を要求するだろう。"

# @return [Array<String>]
# @param [Array<String>] members
#: ../lib/yard/handlers/ruby/legacy/class_handler.rb:67
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:133
msgid "a list of member names"
msgstr "メンバー名のリスト"

# @param [String]
#: ../lib/yard/handlers/ruby/legacy/class_handler.rb:67
msgid "tag|param|superstring"
msgstr "superstring"

# @param [String] superstring
#: ../lib/yard/handlers/ruby/legacy/class_handler.rb:67
msgid "the string declaring the superclass"
msgstr "文字列で宣言しているsuperclass"

# YARD::Handlers::Ruby::Legacy::MethodHandler
# YARD::Handlers::Ruby::MethodHandler
#: ../lib/yard/handlers/ruby/legacy/method_handler.rb:2
#: ../lib/yard/handlers/ruby/method_handler.rb:2
msgid "Handles a method definition"
msgstr "メソッドの定義を操作する"

# YARD::Handlers::Ruby::Legacy::MixinHandler
# YARD::Handlers::Ruby::MixinHandler
#: ../lib/yard/handlers/ruby/legacy/mixin_handler.rb:2
#: ../lib/yard/handlers/ruby/mixin_handler.rb:2
msgid "Handles the 'include' statement to mixin a module in the instance scope"
msgstr ""
"インスタンススコープのモジュールをmixinする為に、'include'ステートメントを操"
"作する。"

# YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler
# YARD::Handlers::Ruby::ModuleFunctionHandler
#: ../lib/yard/handlers/ruby/legacy/module_function_handler.rb:2
#: ../lib/yard/handlers/ruby/module_function_handler.rb:2
msgid ""
"Handles module_function calls to turn methods into public class methods.\n"
"Also creates a private instance copy of the method."
msgstr ""

# YARD::Handlers::Ruby::Legacy::ModuleHandler
# YARD::Handlers::Ruby::ModuleHandler
#: ../lib/yard/handlers/ruby/legacy/module_handler.rb:2
#: ../lib/yard/handlers/ruby/module_handler.rb:2
msgid "Handles the declaration of a module"
msgstr "モジュールの宣言を操作する"

# YARD::Handlers::Ruby::Legacy::PrivateConstantHandler
# YARD::Handlers::Ruby::PrivateConstantHandler
#: ../lib/yard/handlers/ruby/legacy/private_constant_handler.rb:2
#: ../lib/yard/handlers/ruby/private_constant_handler.rb:2
msgid "Sets visibility of a constant (class, module, const)"
msgstr "定数の可視性を設定する(クラス,モジュール,定数)"

# YARD::Handlers::Ruby::Legacy::VisibilityHandler
# YARD::Handlers::Ruby::VisibilityHandler
#: ../lib/yard/handlers/ruby/legacy/visibility_handler.rb:2
#: ../lib/yard/handlers/ruby/visibility_handler.rb:2
msgid "Handles 'private', 'protected', and 'public' calls."
msgstr "'private', 'protected', 'public' 呼び出しを操作する。"

# YARD::Handlers::Ruby::Legacy::YieldHandler
# YARD::Handlers::Ruby::YieldHandler
#: ../lib/yard/handlers/ruby/legacy/yield_handler.rb:2
#: ../lib/yard/handlers/ruby/yield_handler.rb:2
msgid "Handles 'yield' calls"
msgstr "'yield'を呼び出し操作する"

# YARD::Handlers::Ruby::MethodConditionHandler
#: ../lib/yard/handlers/ruby/method_condition_handler.rb:2
msgid "Handles a conditional inside a method"
msgstr "メソッドの内部の条件を操作する"

# YARD::Handlers::Ruby::StructHandlerMethods
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:2
msgid "Helper methods to parse @attr_* tags on a class."
msgstr "クラスの@attr_* タグを解析する為のHelperメソッド"

# @deprecated
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:6
msgid ""
"The use of +@attr+ tags are deprecated since 0.8.0 in favour of\n"
"the +@!attribute+ directive. This module should not be relied on."
msgstr ""

# YARD::Handlers::Ruby::StructHandlerMethods#member_tag_for_member
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:10
msgid ""
"Extracts the user's defined @member tag for a given class and its member. "
"Returns\n"
"nil if the user did not define a @member tag for this struct entry."
msgstr ""
"与えられたクラスとそのメンバー用に\n"
"ユーザーの定義した@memberタグを抽出する。\n"
"この構造体の登録用の@memberタグが未定義だった場合、nilを返す。"

# @param [Symbol] type
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:16
msgid "reader method, or writer method?"
msgstr "readerメソッドかwriterメソッドか?"

# @param [ClassObject]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:16
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:25
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:37
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:61
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:76
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:103
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:120
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:133
msgid "tag|param|klass"
msgstr "klass"

# @param [String]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:16
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:37
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:61
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:76
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:103
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:120
msgid "tag|param|member"
msgstr "member"

# @param [ClassObject] klass
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:16
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:37
msgid "the class whose tags we're searching"
msgstr "検索しているタグのクラス"

# @param [String] member
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:16
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:37
msgid "the name of the struct member we need"
msgstr "必要とする構造体memberの名前"

# @return [Tags::Tag, nil]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:16
msgid "the tag matching the request, or nil if not found"
msgstr "マッチしているタグのリクエスト、見つからない場合は、nil"

# YARD::Handlers::Ruby::StructHandlerMethods#members_from_tags
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:22
msgid "Retrieves all members defined in @attr* tags"
msgstr "@attr* タグの中で定義した全てのメンバーを回収する"

# @param [ClassObject] klass
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:25
msgid "the class with the attributes"
msgstr "属性と一緒のクラス"

# @return [Array<String>]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:25
msgid "the list of members defined as attributes on the class"
msgstr "クラス上の属性として、定義したメンバーのリスト"

# YARD::Handlers::Ruby::StructHandlerMethods#create_member_method?
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:31
msgid ""
"Determines whether to create an attribute method based on the class's\n"
"tags."
msgstr "クラス上で、基底のメソッド属性を作成するかどうか、確定する。"

# @param [Symbol] type
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:37
msgid "(:read) reader method, or writer method?"
msgstr "(:read) readerメソッドか、writerメソッドか?"

# @return [Boolean]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:37
msgid "should the attribute be created?"
msgstr "属性が作成されるかどうか?"

# YARD::Handlers::Ruby::StructHandlerMethods#return_type_from_tag
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:45
msgid ""
"Gets the return type for the member in a nicely formatted string. Used\n"
"to be injected into auto-generated docstrings."
msgstr ""
"より良く書式化された文字列でmember用に返す型を取得する。\n"
"自動生成されたdocstrigの中へ入れる為に利用される"

# @param [String]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:50
msgid "tag|param|member_tag"
msgstr ""

# @param [CodeObjects::Base] object
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:50
msgid "the tag object to check for types"
msgstr "型をチェックする為のタグオブジェクト"

# @return [String]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:50
msgid ""
"the user-declared type of the struct member, or [Object] if\n"
"the user did not define a type for this member."
msgstr ""
"構造体memberの宣言されたユーザーの型、\\n\n"
"又はこのmember用にuserが、型を定義しなかった場合 [Object] となる。"

# YARD::Handlers::Ruby::StructHandlerMethods#add_reader_tags
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:55
msgid ""
"Creates the auto-generated docstring for the getter method of a struct's\n"
"member. This is used so the generated documentation will look just like "
"that\n"
"of an attribute defined using attr_accessor."
msgstr ""
"構造体memberのgetterメソッド用に自動生成されるdocstringを作成する。\n"
"これを用いて生成されるドキュメントは、attr_accessorによって定義された属性のよ"
"うに見える。"

# @return [String]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:61
msgid "a docstring to be attached to the getter method for this member"
msgstr "このmember用にgetterメソッドに加えられるdocstring"

# @param [ClassObject] klass
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:61
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:76
msgid "the class whose members we're working with"
msgstr "操作するmemberクラスに用いるクラス"

# @param [String] member
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:61
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:76
msgid "the name of the member we're generating documentation for"
msgstr "生成されるドキュメントのmemberの名前"

# YARD::Handlers::Ruby::StructHandlerMethods#add_writer_tags
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:70
msgid ""
"Creates the auto-generated docstring for the setter method of a struct's\n"
"member. This is used so the generated documentation will look just like "
"that\n"
"of an attribute defined using attr_accessor."
msgstr ""
"構造体のメンバーのsetterメソッド用に、自動生成されたdocstringを作成する。\n"
"これは、生成されたドキュメントが、\n"
"attr_accessorによって定義された属性のように見えるように利用される。"

# @return [String]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:76
msgid "a docstring to be attached to the setter method for this member"
msgstr "このメンバー用にsetterメソッドに加えられるdocstring"

# YARD::Handlers::Ruby::StructHandlerMethods#create_class
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:86
msgid ""
"Creates and registers a class object with the given name and superclass "
"name.\n"
"Returns it for further use."
msgstr ""
"与えられたクラス名、スーパークラス名と共に、\n"
"クラスオブジェクトを作成,記録する。\n"
"更に利用する為に返す。"

# @param [String]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:91
msgid "tag|param|classname"
msgstr "classname"

# @return [ClassObject]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:91
msgid "the class object for further processing/method attaching"
msgstr "処理/メソッドを加える為のクラスオブジェクト"

# @param [String] classname
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:91
msgid "the name of the class"
msgstr "クラスの名前"

# @param [String] superclass
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:91
msgid "the name of the superclass"
msgstr "スーパークラスの名前"

# YARD::Handlers::Ruby::StructHandlerMethods#create_writer
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:99
msgid ""
"Creates the setter (writer) method and attaches it to the class as an "
"attribute.\n"
"Also sets up the docstring to prettify the documentation output."
msgstr ""
"setter(writer)メソッドを作成し、属性としてクラスに追加する。\n"
"それに加え、ドキュメント出力を装飾する為にdocstringをセットアップする。"

# @param [ClassObject] klass
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:103
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:120
msgid "the class to attach the method to"
msgstr "クラスにメソッドを追加するクラス"

# @param [String] member
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:103
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:120
msgid "the name of the member we're generating a method for"
msgstr "私達がメソッド用に生成するメンバーの名前"

# YARD::Handlers::Ruby::StructHandlerMethods#create_reader
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:116
msgid ""
"Creates the getter (reader) method and attaches it to the class as an "
"attribute.\n"
"Also sets up the docstring to prettify the documentation output."
msgstr ""
"getter(reader)メソッドを作成し、属性として、クラスに追加する。\n"
"さらに、ドキュメント出力を装飾する為に、docstringをセットアップする。"

# YARD::Handlers::Ruby::StructHandlerMethods#create_attributes
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:130
msgid ""
"Creates the given member methods and attaches them to the given ClassObject."
msgstr ""
"与えられたメンバーメソッドを作成し、与えられたClassObjectにそれらを加える。"

# @param [Array<String>]
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:133
msgid "tag|param|members"
msgstr "members"

# @param [ClassObject] klass
#: ../lib/yard/handlers/ruby/struct_handler_methods.rb:133
msgid "the class to generate attributes for"
msgstr "属性を生成するクラス用のクラス"

# YARD::I18n::Locale
#: ../lib/yard/i18n/locale.rb:7
msgid ""
"+Locale+ is a unit of translation. It has {#name} and a set of\n"
"messages."
msgstr ""

# @see http://tools.ietf.org/rfc/bcp/bcp47.txt
#: ../lib/yard/i18n/locale.rb:15
msgid "BCP 47 - Tags for Identifying Languages"
msgstr ""

# @see
#: ../lib/yard/i18n/locale.rb:15
msgid "tag|see|http://tools.ietf.org/rfc/bcp/bcp47.txt"
msgstr ""

# @return [String]
#: ../lib/yard/i18n/locale.rb:15
msgid ""
"the name of the locale. It used IETF language\n"
"tag format +[language[_territory][.codeset][@modifier]]+."
msgstr ""

# YARD::Handlers::Processor#initialize
#: ../lib/yard/i18n/locale.rb:18
msgid "Creates a locale for +name+ locale."
msgstr "+name+ の言語別にlocaleを作成する"

# @return [Logger]
#: ../lib/yard/i18n/locale.rb:20
msgid "a new instance of Locale"
msgstr "Localeの新しいインスタンス"

# @return [String]
#: ../lib/yard/i18n/locale.rb:20
msgid "the locale name."
msgstr "言語名(地域名)"

# YARD::I18n::Locale#load
#: ../lib/yard/i18n/locale.rb:26
msgid "Loads translation messages from +locale_directory+/{#name}.po."
msgstr "+locale_directory+/{#name}.po.から翻訳メッセージをロードする"

# @return [Boolean]
#: ../lib/yard/i18n/locale.rb:30
msgid "+true+ if PO file exists, +false+ otherwise."
msgstr "POファイルが存在すればtrue、そうでなければ、false"

# @param [Boolean]
#: ../lib/yard/i18n/locale.rb:30
msgid "tag|param|locale_directory"
msgstr ""

# @param [String] locale_directory
#: ../lib/yard/i18n/locale.rb:30
msgid ""
"the directory path that has\n"
"{#name}.po."
msgstr ""

# @since
#: ../lib/yard/i18n/locale.rb:45 ../lib/yard/logging.rb:11
#: ../lib/yard/logging.rb:15 ../lib/yard/logging.rb:82
#: ../lib/yard/logging.rb:106 ../lib/yard/logging.rb:117
msgid "0.8.2"
msgstr ""

# @param [NamespaceObject]
# @param [CodeObjects::NamespaceObject, nil]
# @param [CodeObjects::NamespaceObject]
#: ../lib/yard/i18n/locale.rb:45
msgid "tag|param|message"
msgstr ""

# @param [CodeObjects::NamespaceObject] namespace
#: ../lib/yard/i18n/locale.rb:45
msgid "the translation target message."
msgstr "翻訳目標のメッセージ"

# @return [String]
#: ../lib/yard/i18n/locale.rb:45
msgid ""
"translated message. If translation isn't\n"
"registered, the +message+ is returned."
msgstr ""

# YARD::I18n::Message
#: ../lib/yard/i18n/message.rb:6
msgid ""
"+Message+ is a translation target message. It has message ID as\n"
"{#id} and some properties {#locations} and {#comments}."
msgstr ""

# @param tag_name
#: ../lib/yard/i18n/message.rb:11
msgid "the message ID of the translation target message."
msgstr "翻訳目標のメッセージのメッセージID"

# @param [Fixnum, nil] line
#: ../lib/yard/i18n/message.rb:14
msgid "path and line number where the message is appered."
msgstr "メッセージが現れるところのパスと行数"

# @return [Set]
#: ../lib/yard/i18n/message.rb:15
msgid "the set of locations. Location is an array of"
msgstr ""

# @return [Array<MethodObject>]
#: ../lib/yard/i18n/message.rb:18
msgid "the set of comments for the messages."
msgstr "メッセージ用のコメントのグループ"

# YARD::Handlers::Processor#initialize
#: ../lib/yard/i18n/message.rb:21
msgid "Creates a translate target message for message ID +id+."
msgstr "メッセージID +id+ 用の翻訳目標のメッセージを作成する"

# @return [Tag]
#: ../lib/yard/i18n/message.rb:23
msgid "a new instance of Message"
msgstr "メッセージの新しいインスタンス"

# @param [Fixnum]
#: ../lib/yard/i18n/message.rb:23 ../lib/yard/i18n/messages.rb:26
#: ../lib/yard/i18n/messages.rb:36
msgid "tag|param|id"
msgstr ""

# @param [String] id
#: ../lib/yard/i18n/message.rb:23
msgid "the message ID of the translate target message."
msgstr "翻訳目標のメッセージのメッセージID"

# YARD::I18n::Message#add_location
#: ../lib/yard/i18n/message.rb:30
msgid "Adds location information for the message."
msgstr "メッセージ用の地域情報を追加する"

# @param [Fixnum, nil] line
#: ../lib/yard/i18n/message.rb:34
msgid "the line number where the message appears."
msgstr "メッセージが見えるところの行数"

# @return [String]
#: ../lib/yard/i18n/message.rb:34
msgid "the path where the message appears."
msgstr "メッセージが見えるところのパス"

# YARD::I18n::Message#add_comment
#: ../lib/yard/i18n/message.rb:39
msgid "Adds a comment for the message."
msgstr "メッセージ用のコメントを追加する"

# @param [String, Array<String>, Docstring]
# @param [String]
#: ../lib/yard/i18n/message.rb:42
msgid "tag|param|comment"
msgstr ""

# @return [String]
#: ../lib/yard/i18n/message.rb:42
msgid "the comment for the message to be added."
msgstr "追加されるメッセージ用のコメント"

# @return [Boolean]
#: ../lib/yard/i18n/message.rb:48
msgid "checks whether this message is equal to another."
msgstr "このメッセージが他と同じかどうか"

# @param [String] content
#: ../lib/yard/i18n/message.rb:48
msgid "the +Message+ to be compared."
msgstr "比較される為の +message+"

# YARD::I18n::Messages
#: ../lib/yard/i18n/messages.rb:4
msgid "Acts as a container for {Message} objects."
msgstr ""

# YARD::Logger#initialize
#: ../lib/yard/i18n/messages.rb:10
msgid "Creates a new container."
msgstr "新しいコンテナを作成する"

# @return [Tag]
#: ../lib/yard/i18n/messages.rb:10
msgid "a new instance of Messages"
msgstr "メッセージの新しいインスタンス"

# YARD::I18n::Messages#each
#: ../lib/yard/i18n/messages.rb:15
msgid "Enumerates each {Message} in the container."
msgstr ""

# @yieldparam [Tags::Tag]
#: ../lib/yard/i18n/messages.rb:19
msgid "tag|yieldparam|message"
msgstr ""

# @return [CodeObjects::RootObject]
#: ../lib/yard/i18n/messages.rb:19
msgid ""
"the next message object in\n"
"the enumeration."
msgstr "配列の中の次のメッセージオブジェクト"

# @return [Message, nil]
#: ../lib/yard/i18n/messages.rb:26
msgid ""
"a registered message for the given +id+,\n"
"or nil if no message for the ID is found."
msgstr ""

# @param [String] id
#: ../lib/yard/i18n/messages.rb:26
msgid "the message ID to perform a lookup on."
msgstr ""

# YARD::I18n::Messages#register
#: ../lib/yard/i18n/messages.rb:31
msgid ""
"Registers a {Message}, the message ID of which is +id+. If\n"
"corresponding +Message+ is already registered, the previously\n"
"registered object is returned."
msgstr ""

# @param [String] path
#: ../lib/yard/i18n/messages.rb:36
msgid "the ID of the message to be registered."
msgstr "記録されるメッセージのID"

# @return [CodeObjects::Base]
#: ../lib/yard/i18n/messages.rb:36
msgid "the registered +Message+."
msgstr "記録された +Message+"

# YARD::I18n::Messages#==
#: ../lib/yard/i18n/messages.rb:41
msgid "Checks if this messages list is equal to another messages list."
msgstr ""

# @param [#to_s] tag
#: ../lib/yard/i18n/messages.rb:44
msgid "the container to compare."
msgstr "比較するためのコンテナ"

# @return [Boolean]
#: ../lib/yard/i18n/messages.rb:44
msgid "whether +self+ and +other+ is equivalence or not."
msgstr ""

# @return [Array<NamespaceObject>]
#: ../lib/yard/i18n/messages.rb:52
msgid "the set of message objects"
msgstr "メッセージオブジェクトのグループ"

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:6
msgid ""
"The +PotGenerator+ generates POT format string from\n"
"{CodeObjects::Base} and {CodeObjects::ExtraFileObject}."
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:9
msgid "== POT and PO"
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:11
msgid ""
"POT is an acronym for \"Portable Object Template\". POT is a\n"
"template file to create PO file. The extension for POT is\n"
"\".pot\". PO file is an acronym for \"Portable Object\". PO file has\n"
"many parts of message ID (msgid) that is translation target\n"
"message and message string (msgstr) that is translated message\n"
"of message ID. If you want to translate \"Hello\" in English into\n"
"\"Bonjour\" in French, \"Hello\" is the msgid ID and \"Bonjour\" is\n"
"msgstr. The extension for PO is \".po\"."
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:20
msgid "== How to extract msgids"
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:22
msgid "The +PotGenerator+ has two parse methods:"
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:24
msgid ""
"* {#parse_objects} for {CodeObjects::Base}\n"
"* {#parse_files} for {CodeObjects::ExtraFileObject}"
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:27
msgid ""
"{#parse_objects} extracts msgids from docstring and tags of\n"
"{CodeObjects::Base} objects. The docstring of\n"
"{CodeObjects::Base} object is parsed and a paragraph is\n"
"extracted as a msgid. Tag name and tag text are extracted as\n"
"msgids from a tag."
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:33
msgid ""
"{#parse_files} extracts msgids from\n"
"{CodeObjects::ExtraFileObject} objects. The file content of\n"
"{CodeObjects::ExtraFileObject} object is parsed and a paragraph\n"
"is extracted as a msgid."
msgstr ""

# YARD::I18n::PotGenerator
#: ../lib/yard/i18n/pot_generator.rb:40
msgid ""
"To create a .pot file by +PotGenerator+, instantiate a\n"
"+PotGenerator+ with a relative working directory path from a\n"
"directory path that has created .pot file, parse\n"
"{CodeObjects::Base} objects and {CodeObjects::ExtraFileObject}\n"
"objects, generate a POT and write the generated POT to a .pot\n"
"file. The relative working directory path is \"..\" when the\n"
"working directory path is \".\"  and the POT is wrote into\n"
"\"po/yard.pot\"."
msgstr ""

# @see http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html
#: ../lib/yard/i18n/pot_generator.rb:64
msgid "GNU gettext manual about details of PO file"
msgstr ""

# @example Generate a .pot file
#: ../lib/yard/i18n/pot_generator.rb:64
msgid ""
"po_file_path = \"po/yard.pot\"\n"
"po_file_directory_pathname = Pathname.new(po_file_path).directory)\n"
"working_directory_pathname = Pathname.new(\".\")\n"
"relative_base_path = working_directory_pathname.relative_path_from"
"(po_file_directory_pathname).to_s\n"
"# relative_base_path -> \"..\"\n"
"generator = YARD::I18n::PotGenerator.new(relative_base_path)\n"
"generator.parse_objects(objects)\n"
"generator.parse_files(files)\n"
"pot = generator.generate\n"
"po_file_directory_pathname.mkpath\n"
"File.open(po_file_path, \"w\") do |pot_file|\n"
"  pot_file.print(pot)\n"
"end"
msgstr ""

# @example
#: ../lib/yard/i18n/pot_generator.rb:64
msgid "tag|example|Generate a .pot file"
msgstr "tag|example|.popファイルを生成する"

# @see
#: ../lib/yard/i18n/pot_generator.rb:64
msgid ""
"tag|see|http://www.gnu.org/software/gettext/manual/html_node/PO-Files.html"
msgstr ""

# YARD::I18n::PotGenerator#messages
#: ../lib/yard/i18n/pot_generator.rb:66
msgid "Extracted messages."
msgstr ""

# YARD::I18n::PotGenerator#initialize
#: ../lib/yard/i18n/pot_generator.rb:72
msgid ""
"Creates a POT generator that uses +relative_base_path+ to\n"
"generate locations for a msgid. +relative_base_path+ is\n"
"prepended to all locations."
msgstr ""

# @return [Router]
#: ../lib/yard/i18n/pot_generator.rb:78
msgid "a new instance of PotGenerator"
msgstr "PotGeneratorの新しいインスタンス"

# @param [String] relative_base_path
#: ../lib/yard/i18n/pot_generator.rb:78
msgid ""
"a relative working\n"
"directory path from a directory path that has created .pot\n"
"file."
msgstr ""

# @param [Boolean]
#: ../lib/yard/i18n/pot_generator.rb:78
msgid "tag|param|relative_base_path"
msgstr ""

# @param [Array<CodeObjects::Base>] objects
#: ../lib/yard/i18n/pot_generator.rb:85
msgid ""
"Parses {CodeObjects::Base} objects and stores extracted msgids\n"
"into {#messages}"
msgstr ""
"{CodeObjects::Base}オブジェクトを解析し、\n"
"{#messages}メソッドの中へ抽出されたmsgidを登録する"

# @param [Array<CodeObjects::Base>] objects
#: ../lib/yard/i18n/pot_generator.rb:90
msgid ""
"a list of\n"
"{CodeObjects::Base} to be parsed."
msgstr "解析される {CodeObjects::Base} のリスト"

# @deprecated
#: ../lib/yard/i18n/pot_generator.rb:97
msgid ""
"Parses {CodeObjects::ExtraFileObject} objects and stores\n"
"extracted msgids into {#messages}."
msgstr ""
"{CodeObjects::ExtraFileObject} オブジェクトを解析し、\n"
"抽出されたmsgidを{#messages}の中へ登録する。"

# @deprecated
#: ../lib/yard/i18n/pot_generator.rb:102
msgid ""
"a list\n"
"of {CodeObjects::ExtraFileObject} objects to be parsed."
msgstr "解析される {CodeObjects::ExtraFileObject} オブジェクトのリスト"

# YARD::I18n::PotGenerator#generate
#: ../lib/yard/i18n/pot_generator.rb:109
msgid "Generates POT from +@messages+."
msgstr ""

# YARD::I18n::PotGenerator#generate
#: ../lib/yard/i18n/pot_generator.rb:111
msgid ""
"One PO file entry is generated from a +Message+ in\n"
"+@messages+."
msgstr ""

# YARD::I18n::PotGenerator#generate
#: ../lib/yard/i18n/pot_generator.rb:114
msgid ""
"Locations of the +Message+ are used to generate the reference\n"
"line that is started with \"#: \". +relative_base_path+ passed\n"
"when the generator is created is prepended to each path in location."
msgstr ""

# YARD::I18n::PotGenerator#generate
#: ../lib/yard/i18n/pot_generator.rb:118
msgid ""
"Comments of the +Message+ are used to generate the\n"
"translator-comment line that is started with \"# \"."
msgstr ""

# @return [String]
#: ../lib/yard/i18n/pot_generator.rb:121
msgid "POT format string"
msgstr ""

# YARD::I18n::Text
#: ../lib/yard/i18n/text.rb:4
msgid "Provides some convenient features for translating a text."
msgstr ""

# YARD::I18n::Text#initialize
#: ../lib/yard/i18n/text.rb:6
msgid ""
"Creates a text object that has translation related features for\n"
"the input text."
msgstr ""

# @return [Text]
#: ../lib/yard/i18n/text.rb:11
msgid "a new instance of Text"
msgstr "Textの新しいインスタンス"

# @param [String] text
#: ../lib/yard/i18n/text.rb:11
msgid "a text to be translated."
msgstr "翻訳されるテキスト"

# @param [Fixnum, nil]
#: ../lib/yard/i18n/text.rb:11
msgid "tag|param|input"
msgstr ""

# YARD::I18n::Text#extract_messages
#: ../lib/yard/i18n/text.rb:17
msgid "Extracts translation target messages from +@input+."
msgstr ""

# @yieldparam [Array<String>]
#: ../lib/yard/i18n/text.rb:34
msgid "tag|yieldparam|line_no"
msgstr ""

# @yieldparam [Tags::Tag]
#: ../lib/yard/i18n/text.rb:34
msgid "tag|yieldparam|name"
msgstr ""

# @yieldparam [Tags::Tag]
#: ../lib/yard/i18n/text.rb:34
msgid "tag|yieldparam|start_line_no"
msgstr ""

# @yieldparam [Tags::Tag]
#: ../lib/yard/i18n/text.rb:34
msgid "tag|yieldparam|text"
msgstr ""

# @yieldparam [Array<String>]
#: ../lib/yard/i18n/text.rb:34 ../lib/yard/options.rb:142
msgid "tag|yieldparam|value"
msgstr ""

# @yield [:paragraph, text, start_line_no]
#: ../lib/yard/i18n/text.rb:34
msgid ""
"the block that\n"
"receives extracted a paragraph in body. Paragraph is a text\n"
"block separated by one or more empty lines. Empty line is a\n"
"line that contains only zero or more whitespaces. It may\n"
"called many times."
msgstr ""

# @yield [:attribute, name, value, line_no]
#: ../lib/yard/i18n/text.rb:34
msgid ""
"the block that\n"
"receives extracted an attribute in header. It may called many\n"
"times."
msgstr ""

# @return [Fixnum]
#: ../lib/yard/i18n/text.rb:34
msgid ""
"the defined line number of extracted\n"
"attribute."
msgstr "抽出された属性の定義された行数"

# @param [#to_s] key
#: ../lib/yard/i18n/text.rb:34
msgid "the name of extracted attribute."
msgstr "抽出された属性の名前"

# @return [Fixnum]
#: ../lib/yard/i18n/text.rb:34
msgid ""
"the start line number of\n"
"extracted paragraph."
msgstr "抽出された段落の最初の行数"

# @param [String] text
#: ../lib/yard/i18n/text.rb:34
msgid "the text of extracted paragraph."
msgstr "抽出された段落のテキスト"

# @param value
#: ../lib/yard/i18n/text.rb:34
msgid "the value of extracted attribute."
msgstr "抽出された属性の値"

# YARD::I18n::Text#translate
#: ../lib/yard/i18n/text.rb:49
msgid "Translates into +locale+."
msgstr ""

# @param [Object]
#: ../lib/yard/i18n/text.rb:52
msgid "tag|param|locale"
msgstr ""

# @return [String]
#: ../lib/yard/i18n/text.rb:52
msgid "the translation target locale."
msgstr "翻訳目標の地域"

# @return [String]
#: ../lib/yard/i18n/text.rb:52
msgid "translated text."
msgstr "翻訳されたテキスト"

# YARD::Logger
#: ../lib/yard/logging.rb:6
msgid ""
"Handles console logging for info, warnings and errors.\n"
"Uses the stdlib Logger class in Ruby for all the backend logic."
msgstr ""
"コンソールがinfoや,警告や,エラー用にロギングし操作する。\n"
"全てのバックエンドの処理の為にRuby標準ライブラリのloggerクラスを使う。"

# YARD::Logger::PROGRESS_INDICATORS
#: ../lib/yard/logging.rb:9
msgid ""
"The list of characters displayed beside the progress bar to indicate\n"
"\"movement\"."
msgstr ""

# @return [CodeObjects::Base]
#: ../lib/yard/logging.rb:15
msgid "the IO object being logged to"
msgstr "IOオブジェクトに記録されるIOオブジェクト"

# @return [Boolean]
#: ../lib/yard/logging.rb:19
msgid ""
"whether backtraces should be shown (by default\n"
"this is on)."
msgstr ""

# @param value
#: ../lib/yard/logging.rb:20
msgid "the value to set the attribute show_backtraces to."
msgstr "show_backtraces属性を設定する値"

# YARD::Logger#show_backtraces=
#: ../lib/yard/logging.rb:21
msgid "Sets the attribute show_backtraces"
msgstr "show_backtraces属性を設定する"

# @return [Boolean]
#: ../lib/yard/logging.rb:24
msgid ""
"whether progress indicators should be shown when\n"
"logging CLIs (by default this is off)."
msgstr ""

# @param value
#: ../lib/yard/logging.rb:30
msgid "the value to set the attribute show_progress to."
msgstr "値にshow_progress属性を設定する為の値"

# YARD::Logger#show_backtraces=
#: ../lib/yard/logging.rb:31
msgid "Sets the attribute show_progress"
msgstr "show_progress属性を設定する"

# YARD::Logger.instance
#: ../lib/yard/logging.rb:33
msgid "The logger instance"
msgstr "loggerインスタンス"

# @return [Logger]
#: ../lib/yard/logging.rb:34
msgid "the logger instance"
msgstr "loggerインスタンス"

# YARD::Logger#initialize
#: ../lib/yard/logging.rb:39
msgid "Creates a new logger"
msgstr "新しいloggerを作成する"

# @return [Logger]
#: ../lib/yard/logging.rb:39
msgid "a new instance of Logger"
msgstr "Loggerの新しいインスタンス"

# YARD::Logger#debug
#: ../lib/yard/logging.rb:51
msgid ""
"Changes the debug level to DEBUG if $DEBUG is set\n"
"and writes a debugging message."
msgstr ""
"$DEBUGが設定された場合、debug levelをDEBUGに変更し、\n"
"デバッグメッセージを書き込む。"

# YARD::Logger#capture
#: ../lib/yard/logging.rb:58
msgid ""
"Captures the duration of a block of code for benchmark analysis. Also\n"
"calls {#progress} on the message to display it to the user."
msgstr ""

# @todo
#: ../lib/yard/logging.rb:66
msgid "Implement capture storage for reporting of benchmarks"
msgstr ""

# @param [String] content
#: ../lib/yard/logging.rb:66
msgid "a block of arbitrary code to benchmark"
msgstr "ベンチマークの為の任意のコードの入ったブロック"

# @param [Symbol]
# @param [#to_s]
#: ../lib/yard/logging.rb:66 ../lib/yard/logging.rb:82
#: ../lib/yard/logging.rb:117
msgid "tag|param|msg"
msgstr ""

# @param [TokenList, String]
# @param [String]
# @param [String, #read, Object]
#: ../lib/yard/logging.rb:66 ../lib/yard/logging.rb:82
msgid "tag|param|nontty_log"
msgstr ""

# @param [Symbol, nil] nontty_log
#: ../lib/yard/logging.rb:66 ../lib/yard/logging.rb:82
msgid ""
"the level to log as if the output\n"
"stream is not a TTY. Use +nil+ for no alternate logging."
msgstr ""

# @return [String]
#: ../lib/yard/logging.rb:66 ../lib/yard/logging.rb:117
msgid "the message to display"
msgstr "表示するメッセージ"

# YARD::Logger#progress
#: ../lib/yard/logging.rb:74
msgid ""
"Displays a progress indicator for a given message. This progress report\n"
"is only displayed on TTY displays, otherwise the message is passed to\n"
"the +nontty_log+ level."
msgstr ""

# @param [String, CodeObjects::ExtraFileObject] filename
# @param [String] filename
#: ../lib/yard/logging.rb:82
msgid "the message to log"
msgstr "記録するメッセージ"

# YARD::Logger#clear_progress
#: ../lib/yard/logging.rb:104
msgid "Clears the progress indicator in the TTY display."
msgstr ""

# YARD::Logger#puts
#: ../lib/yard/logging.rb:113
msgid ""
"Displays an unformatted line to the logger output stream. Similar to\n"
"the +#<<+ method, but adds a newline."
msgstr ""

# YARD::Logger#backtrace
#: ../lib/yard/logging.rb:122
msgid "Prints the backtrace +exc+ to the logger as error data."
msgstr "+exc+ のバックトレースをエラーデータとしてloggerにプリントする。"

# @param [Array<String>]
#: ../lib/yard/logging.rb:126
msgid "tag|param|exc"
msgstr "exc"

# @param [Fixnum]
#: ../lib/yard/logging.rb:126
msgid "tag|param|level_meth"
msgstr ""

# @param [Array<String>] exc
#: ../lib/yard/logging.rb:126
msgid "the backtrace list"
msgstr "バックトレースのリスト"

# @param [Array<String>] exc
#: ../lib/yard/logging.rb:126
msgid "the level to log backtrace at"
msgstr "バックトレースを記録する階層"

# YARD::Logger#warn_no_continuations
#: ../lib/yard/logging.rb:134
msgid ""
"Warns that the Ruby environment does not support continuations. Applies\n"
"to JRuby, Rubinius and MacRuby. This warning will only display once\n"
"per Ruby process."
msgstr ""
"Rubyの環境がcontinuationをサポートしない警告を出す。\n"
"JRuby,Rubinius,MacRubyに適用される。\n"
"この警告は、Rubyの処理毎に一度だけ表示されるだろう"

# @deprecated
#: ../lib/yard/logging.rb:139
msgid "Continuations are no longer needed by YARD 0.8.0+."
msgstr ""

# YARD::Logger#enter_level
#: ../lib/yard/logging.rb:143
msgid "Sets the logger level for the duration of the block"
msgstr "ブロックの継続するlogger levelを設定する。"

# @example 
#: ../lib/yard/logging.rb:151
msgid ""
"log.enter_level(Logger::ERROR) do\n"
"  YARD.parse_string \"def x; end\"\n"
"end"
msgstr ""

# @param [Fixnum]
#: ../lib/yard/logging.rb:151
msgid "tag|param|new_level"
msgstr "new_level"

# @yield
#: ../lib/yard/logging.rb:151
msgid "the block with the logger temporarily set to +new_level+"
msgstr "loggerが一時的に+new_level+を設定するブロック"

# @param [Fixnum] new_level
#: ../lib/yard/logging.rb:151
msgid ""
"the logger level for the duration of the block.\n"
"values can be found in Ruby's Logger class."
msgstr ""
"ブロックの継続するlogger level.\n"
"値はRuby loggerクラスで見つける事が出来る。"

# YARD::Logger#format_log
#: ../lib/yard/logging.rb:160
msgid "Log format (from Logger implementation). Used by Logger internally"
msgstr "ログ書式(loggerの実装から)。Loggerによって内部で利用される。"

# YARD::Options
#: ../lib/yard/options.rb:3
msgid ""
"Generalized options class for passing around large amounts of options "
"between objects."
msgstr ""

# YARD::Options
#: ../lib/yard/options.rb:5
msgid ""
"The options class exists for better visibility and documentability of "
"options being\n"
"passed through to other objects. Because YARD has parser and template "
"architectures\n"
"that are heavily reliant on options, it is necessary to make these option "
"keys easily\n"
"visible and understood by developers. Since the options class is more than "
"just a\n"
"basic Hash, the subclass can provide aliasing and convenience methods to "
"simplify\n"
"option property access, and, if needed, support backward-compatibility for "
"deprecated\n"
"key names."
msgstr ""

# YARD::Options
#: ../lib/yard/options.rb:13
msgid "== Hash and OpenStruct-like Access"
msgstr ""

# YARD::Options
#: ../lib/yard/options.rb:15
msgid ""
"Although the options class allows for Hash-like access (<tt>opts[:key]</"
"tt>), the recommended\n"
"mechanism for accessing an option key will be via standard method calls on "
"attributes"
msgstr ""

# YARD::Options
#: ../lib/yard/options.rb:18
msgid ""
"The options class can also act as an open ended key value storage structure "
"(like a\n"
"Hash or OpenStruct), and allows for setting and getting of unregistered "
"option keys.\n"
"This methodology is not recommended, however, and is only supported for "
"backward\n"
"compatibility inside YARD. Whenever possible, developers should define all "
"keys used\n"
"by an options class."
msgstr ""

# YARD::Options
#: ../lib/yard/options.rb:24
msgid "== Declaring Default Values"
msgstr ""

# YARD::Options
#: ../lib/yard/options.rb:26
msgid ""
"Note that the options class can contain default value definitions for "
"certain options,\n"
"but to initialize these defaults, {#reset_defaults} must be called manually "
"after\n"
"initialization; the options object is always created empty until defaults "
"are applied."
msgstr ""

# @abstract
#: ../lib/yard/options.rb:68
msgid ""
"Subclasses should define (and document) custom attributes that are expected\n"
"to be made available as option keys."
msgstr ""

# @example Deprecating an option while still supporting it
#: ../lib/yard/options.rb:68
msgid ""
"class TemplateOptions < YARD::Options\n"
"  # @return [Boolean] if syntax highlighting should be performed on code "
"blocks.\n"
"  #   Defaults to true.\n"
"  attr_accessor :highlight\n"
"\n"
"  # @deprecated Use {#highlight} instead.\n"
"  # @return [Boolean] if no syntax highlighting should be performs on code "
"blocks.\n"
"  #   Defaults to false.\n"
"  attr_accessor :no_highlight\n"
"  def no_highlight=(value) @highlight = !value end\n"
"  def no_highlight; !highlight end\n"
"end"
msgstr ""

# @example Defining an Options class with custom option keys
#: ../lib/yard/options.rb:68
msgid ""
"class TemplateOptions < YARD::Options\n"
"  # @return [Symbol] the output format to generate templates in\n"
"  attr_accessor :format\n"
"\n"
"  # @return [Symbol] the template to use when generating output\n"
"  attr_accessor :template\n"
"end"
msgstr ""

# @example Initializing default option values
#: ../lib/yard/options.rb:68
msgid ""
"class TemplateOptions < YARD::Options\n"
"  def reset_defaults\n"
"    super\n"
"    self.format = :html\n"
"    self.template = :default\n"
"    self.highlight = true\n"
"    # ...\n"
"  end\n"
"end"
msgstr ""

# @example Using +default_attr+ to create default attributes
#: ../lib/yard/options.rb:68
msgid ""
"class TemplateOptions < YARD::Options\n"
"  default_attr :format, :html\n"
"  default_attr :template, :default\n"
"  default_attr :highlight, true\n"
"end"
msgstr ""

# @example
#: ../lib/yard/options.rb:68
msgid "tag|example|Defining an Options class with custom option keys"
msgstr "カスタムオプションのkeyを用いたオプションクラス定義"

# @example
#: ../lib/yard/options.rb:68
msgid "tag|example|Deprecating an option while still supporting it"
msgstr "まだサポートしているけれど廃止するオプション"

# @example
#: ../lib/yard/options.rb:68
msgid "tag|example|Initializing default option values"
msgstr "tag|example|初期化されたデフォルトのオプション値"

# @example
#: ../lib/yard/options.rb:68
msgid "tag|example|Using +default_attr+ to create default attributes"
msgstr "tag|example|デフォルト属性を作成するための +default_attr+ を用いる"

# YARD::Options.default_attr
#: ../lib/yard/options.rb:70
msgid "Defines an attribute named +key+ and sets a default value for it"
msgstr ""

# @example Defining a default option key
#: ../lib/yard/options.rb:79
msgid ""
"default_attr :name, 'Default Name'\n"
"default_attr :time, lambda { Time.now }"
msgstr ""

# @example
#: ../lib/yard/options.rb:79
msgid "tag|example|Defining a default option key"
msgstr "tag|example|デフォルトのオプションキーの定義"

# @param [Object]
#: ../lib/yard/options.rb:79
msgid "tag|param|default"
msgstr ""

# @param [Object, Proc] default
#: ../lib/yard/options.rb:79
msgid ""
"the default object value. If the default\n"
"value is a proc, it is executed upon initialization."
msgstr ""

# @param [String, Symbol] section
#: ../lib/yard/options.rb:79
msgid "the option key name"
msgstr "オプションキー名"

# YARD::Options#[]
#: ../lib/yard/options.rb:85
msgid "Delegates calls with Hash syntax to actual method with key name"
msgstr ""

# @example Calling on an option key with Hash syntax
#: ../lib/yard/options.rb:90
msgid "options[:format] # equivalent to: options.format"
msgstr ""

# @example
#: ../lib/yard/options.rb:90
msgid "tag|example|Calling on an option key with Hash syntax"
msgstr "tag|example|ハッシュ構文を用いたオプションキーを呼び出す"

# @param [Hash] opts
#: ../lib/yard/options.rb:90
msgid "the option name to access"
msgstr "アクセスするためのオプション名"

# @param value
#: ../lib/yard/options.rb:90
msgid "the value of the option named +key+"
msgstr "+key+ と名付けられたオプションの値"

# YARD::Options#[]=
#: ../lib/yard/options.rb:93
msgid ""
"Delegates setter calls with Hash syntax to the attribute setter with the key "
"name"
msgstr ""

# @example Setting an option with Hash syntax
#: ../lib/yard/options.rb:99
msgid "options[:format] = :html # equivalent to: options.format = :html"
msgstr ""

# @example
#: ../lib/yard/options.rb:99
msgid "tag|example|Setting an option with Hash syntax"
msgstr "tag|example|ハッシュ構文を用いたオプションの設定"

# @param [Hash] options
#: ../lib/yard/options.rb:99
msgid "the option to set"
msgstr "設定するためのオプション"

# @param [Object] value
# @param [Object] val
#: ../lib/yard/options.rb:99
msgid "the value being set"
msgstr "設定される値"

# @param [String] title
#: ../lib/yard/options.rb:99
msgid "the value to set for the option"
msgstr "オプション用に設定するための値"

# YARD::Options#update
#: ../lib/yard/options.rb:102
msgid ""
"Updates values from an options hash or options object on this object.\n"
"All keys passed should be key names defined by attributes on the class."
msgstr ""

# @example Updating a set of options on an Options object
#: ../lib/yard/options.rb:108
msgid "opts.update(:template => :guide, :type => :fulldoc)"
msgstr ""

# @example
#: ../lib/yard/options.rb:108
msgid "tag|example|Updating a set of options on an Options object"
msgstr "tag|example|オプションオブジェクトでオプションのグループの更新"

# YARD::Options#merge
#: ../lib/yard/options.rb:117
msgid ""
"Creates a new options object and sets options hash or object value\n"
"onto that object."
msgstr ""

# @see
#: ../lib/yard/options.rb:122
msgid "tag|see|#update"
msgstr ""

# @return [Base]
# @return [MacroObject]
#: ../lib/yard/options.rb:122
msgid "the newly created options object"
msgstr "新たに作成されたオプションオブジェクト"

# @return [Hash]
#: ../lib/yard/options.rb:128
msgid ""
"Converts options object to an options hash. All keys\n"
"will be symbolized."
msgstr ""

# YARD::Options#each
#: ../lib/yard/options.rb:138
msgid "Yields over every option key and value"
msgstr ""

# @yield [key, value]
#: ../lib/yard/options.rb:142
msgid "every option key and value"
msgstr ""

# @yieldparam [Base]
#: ../lib/yard/options.rb:142
msgid "tag|yieldparam|key"
msgstr ""

# @param [Hash] options
#: ../lib/yard/options.rb:142
msgid "the option key"
msgstr "オプションのキー"

# @param [Hash] options
#: ../lib/yard/options.rb:142
msgid "the option value"
msgstr "オプションの値"

# @return [String]
#: ../lib/yard/options.rb:150
msgid "Inspects the object"
msgstr "オブジェクトを解析する"

# @return [Boolean]
#: ../lib/yard/options.rb:156
msgid ""
"whether another Options object equals the\n"
"keys and values of this options object"
msgstr ""

# YARD::Options#method_missing
#: ../lib/yard/options.rb:165
msgid ""
"Handles setting and accessing of unregistered keys similar\n"
"to an OpenStruct object."
msgstr ""

# @note
#: ../lib/yard/options.rb:169
msgid ""
"It is not recommended to set and access unregistered keys on\n"
"an Options object. Instead, register the attribute before using it."
msgstr ""

# YARD::Tags::DefaultTag#defaults
#: ../lib/yard/options.rb:182
msgid "Resets all values to their defaults."
msgstr "それらのデフォルトの全ての値をリセットする"

# @abstract
#: ../lib/yard/options.rb:187
msgid ""
"Subclasses should override this method to perform custom\n"
"value initialization if not using {default_attr}. Be sure to call\n"
"+super+ so that default initialization can take place."
msgstr ""

# YARD::Options#delete
#: ../lib/yard/options.rb:201
msgid "Deletes an option value for +key+"
msgstr ""

# @param [#to_sym] key
#: ../lib/yard/options.rb:204
msgid "the key to delete a value for"
msgstr "キー用に値を削除する為のキー"

# @param [String] data
#: ../lib/yard/options.rb:204
msgid "the value that was deleted"
msgstr "削除された値"

# YARD::Parser::Base
#: ../lib/yard/parser/base.rb:4
msgid ""
"Represents the abstract base parser class that parses source code in\n"
"a specific way. A parser should implement {#parse}, {#tokenize} and\n"
"{#enumerator}."
msgstr ""
"独自の方法でソースコードを解析する抽象的なベースパーサークラスを表す。\n"
"パーサーは{#parse}や,{#tokenize}や{#enumerator}メソッドを実装しなくてはならな"
"い。"

# YARD::Parser::Base
#: ../lib/yard/parser/base.rb:8
msgid ""
"== Registering a Custom Parser\n"
"To register a parser, see {SourceParser.register_parser_type}"
msgstr ""
"== カスタムパーサーを記録する\n"
"パーサーを記録する為には、{SourceParser.register_parser_type}を参照。"

# @see
#: ../lib/yard/parser/base.rb:15
msgid "tag|see|#enumerator"
msgstr ""

# @see
#: ../lib/yard/parser/base.rb:15
msgid "tag|see|#parse"
msgstr ""

# @see
#: ../lib/yard/parser/base.rb:15
msgid "tag|see|#tokenize"
msgstr ""

# YARD::Parser::Base.parse
#: ../lib/yard/parser/base.rb:17
msgid "Convenience method to create a new parser and {#parse}"
msgstr "新しいパーサーや(#parse)メソッドを作成する為の便利なメソッド"

# YARD::Parser::Base#initialize
#: ../lib/yard/parser/base.rb:22
msgid ""
"This default constructor does nothing. The subclass is responsible for\n"
"storing the source contents and filename if they are required."
msgstr ""
"このデフォルトのコンストラクターは何もしない。\n"
"サブクラスがソースの内容やファイル名が必要とされる場合、それらを記憶する責任"
"がある。"

# @param [String] filename
#: ../lib/yard/parser/base.rb:25
msgid "the name of the file if from disk"
msgstr "ディスクからの場合、ファイルの名前"

# @param [String] source
#: ../lib/yard/parser/base.rb:25
msgid "the source contents"
msgstr "ソースの内容"

# YARD::Parser::Base#parse
#: ../lib/yard/parser/base.rb:30
msgid ""
"This method should be implemented to parse the source and return itself."
msgstr ""
"このメソッドはソースの解析やそれ自身を返す為に\n"
"実装されなくてはならない。"

# @return [Base]
#: ../lib/yard/parser/base.rb:32
msgid "this method should return itself"
msgstr "このメソッドはそれ自身を返さなくてはならない。"

# YARD::Parser::Base#tokenize
#: ../lib/yard/parser/base.rb:37
msgid "This method should be implemented to tokenize given source"
msgstr ""
"このメソッドは与えられたソースを\n"
"トークナイズする為に実装されなければならない。"

# @return [Array]
#: ../lib/yard/parser/base.rb:39
msgid "a list/tree of lexical tokens"
msgstr "単語のトークンの入ったリストやツリー"

# YARD::Parser::Base#enumerator
#: ../lib/yard/parser/base.rb:44
msgid ""
"This method should be implemented to return a list of semantic tokens\n"
"representing the source code to be post-processed. Otherwise the method\n"
"should return nil."
msgstr ""
"後処理される為にソースコードを表している意味のあるトークンのリストを返す為"
"に\n"
"このメソッドは実装されなければならない。\n"
"そうでなければこのメソッドは、nilを返さなければならない。"

# @return [Array]
#: ../lib/yard/parser/base.rb:51
msgid ""
"a list of semantic tokens representing the source code\n"
"to be post-processed"
msgstr "後処理される為のソースコードを表す意味のあるトークンのリスト"

# @return [nil]
#: ../lib/yard/parser/base.rb:51
msgid "if no post-processing should be done"
msgstr "後処理がない場合、nilを返さなければならない。"

# @return [CParser]
#: ../lib/yard/parser/c/c_parser.rb:5
msgid "a new instance of CParser"
msgstr "Cパーサーの新しいインスタンス"

# @param value
#: ../lib/yard/parser/c/statement.rb:5 ../lib/yard/parser/ruby/ast_node.rb:42
msgid "the value to set the attribute source to."
msgstr "ソースの属性を設定する,値"

# YARD::Parser::Ruby::AstNode#to_s
#: ../lib/yard/parser/c/statement.rb:6 ../lib/yard/parser/ruby/ast_node.rb:53
msgid "Returns the value of attribute source"
msgstr "source属性の入った値を返す。"

# YARD::Parser::Ruby::AstNode#source=
#: ../lib/yard/parser/c/statement.rb:6 ../lib/yard/parser/ruby/ast_node.rb:43
msgid "Sets the attribute source"
msgstr "ソース属性を設定する。"

# @param value
#: ../lib/yard/parser/c/statement.rb:6
msgid "the value to set the attribute line to."
msgstr "値に行属性を設定するための値"

# YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader#line_num
#: ../lib/yard/parser/c/statement.rb:7
msgid "Returns the value of attribute line"
msgstr "行属性の値を返す"

# YARD::CodeObjects::ExtraFileObject#name=
# YARD::Tags::RefTagList#name=
# YARD::Templates::Section#name=
#: ../lib/yard/parser/c/statement.rb:7
msgid "Sets the attribute line"
msgstr "行属性を設定"

# @param value
#: ../lib/yard/parser/c/statement.rb:7 ../lib/yard/parser/ruby/ast_node.rb:48
msgid "the value to set the attribute file to."
msgstr "ファイル属性を設定する,値"

# YARD::Parser::Ruby::RipperParser#file
# YARD::RegistryStore#file
#: ../lib/yard/parser/c/statement.rb:8
#: ../lib/yard/parser/ruby/ruby_parser.rb:26 ../lib/yard/registry_store.rb:12
msgid "Returns the value of attribute file"
msgstr "file属性の値を返す。"

# YARD::Parser::Ruby::AstNode#file=
#: ../lib/yard/parser/c/statement.rb:8 ../lib/yard/parser/ruby/ast_node.rb:49
msgid "Sets the attribute file"
msgstr "ファイル属性を設定する。"

# @deprecated
#: ../lib/yard/parser/c/statement.rb:11 ../lib/yard/parser/ruby/ast_node.rb:46
#: ../lib/yard/parser/ruby/legacy/statement.rb:9
msgid "Groups are now defined by directives"
msgstr ""

# @see
#: ../lib/yard/parser/c/statement.rb:11 ../lib/yard/parser/ruby/ast_node.rb:46
#: ../lib/yard/parser/ruby/legacy/statement.rb:9
msgid "tag|see|Tags::GroupDirective"
msgstr ""

# @param value
#: ../lib/yard/parser/c/statement.rb:13
#: ../lib/yard/parser/ruby/legacy/statement.rb:11
msgid "the value to set the attribute comments_hash_flag to."
msgstr "comments_hash_flag属性を設定する。"

# YARD::Parser::Ruby::Legacy::Statement#comments_hash_flag
#: ../lib/yard/parser/c/statement.rb:14
#: ../lib/yard/parser/ruby/legacy/statement.rb:12
msgid "Returns the value of attribute comments_hash_flag"
msgstr "comments_hash_flag属性を返す。"

# YARD::Parser::Ruby::Legacy::Statement#comments_hash_flag=
#: ../lib/yard/parser/c/statement.rb:14
#: ../lib/yard/parser/ruby/legacy/statement.rb:12
msgid "Sets the attribute comments_hash_flag"
msgstr "comments_hash_flag属性を設定する。"

# @return [Statement]
#: ../lib/yard/parser/c/statement.rb:15
#: ../lib/yard/parser/ruby/legacy/statement.rb:13
msgid "a new instance of Statement"
msgstr "ステートメントの新しいインスタンス"

# @param value
#: ../lib/yard/parser/c/statement.rb:39 ../lib/yard/parser/c/statement.rb:45
msgid "the value to set the attribute comments to."
msgstr "値にコメント属性を設定するための値"

# YARD::Parser::Ruby::Legacy::Statement#comments
# YARD::Parser::Ruby::RipperParser#comments
#: ../lib/yard/parser/c/statement.rb:40 ../lib/yard/parser/c/statement.rb:46
#: ../lib/yard/parser/ruby/legacy/statement.rb:5
#: ../lib/yard/parser/ruby/ruby_parser.rb:26
msgid "Returns the value of attribute comments"
msgstr "コメント属性の値を返す。"

# YARD::CodeObjects::NamespaceObject#meths=
#: ../lib/yard/parser/c/statement.rb:40 ../lib/yard/parser/c/statement.rb:46
msgid "Sets the attribute comments"
msgstr "コメント属性を設定する"

# @param value
#: ../lib/yard/parser/c/statement.rb:43
msgid "the value to set the attribute block to."
msgstr "値にblock属性を設定するための値"

# YARD::Parser::Ruby::Legacy::Statement#block
#: ../lib/yard/parser/c/statement.rb:44
#: ../lib/yard/parser/ruby/legacy/statement.rb:5
msgid "Returns the value of attribute block"
msgstr "ブロック属性の値を返す。"

# YARD::Parser::Ruby::AstNode#source=
#: ../lib/yard/parser/c/statement.rb:44
msgid "Sets the attribute block"
msgstr "block属性を設定する。"

# @param value
#: ../lib/yard/parser/c/statement.rb:44
msgid "the value to set the attribute declaration to."
msgstr "値に宣言属性を設定するための値"

# YARD::Templates::Template#section
#: ../lib/yard/parser/c/statement.rb:45
msgid "Returns the value of attribute declaration"
msgstr "宣言属性の値を返す"

# YARD::Templates::Template#section=
#: ../lib/yard/parser/c/statement.rb:45
msgid "Sets the attribute declaration"
msgstr "宣言属性を設定する"

# @param value
#: ../lib/yard/parser/c/statement.rb:51
msgid "the value to set the attribute type to."
msgstr "値に型属性を設定するための値"

# YARD::Parser::Ruby::Legacy::RubyToken::TkOPASGN#op
#: ../lib/yard/parser/c/statement.rb:52
msgid "Returns the value of attribute type"
msgstr "型属性の値を返す"

# YARD::CodeObjects::ExtraFileObject#name=
# YARD::Tags::RefTagList#name=
# YARD::Templates::Section#name=
#: ../lib/yard/parser/c/statement.rb:52
msgid "Sets the attribute type"
msgstr "型属性を設定する"

# @param value
#: ../lib/yard/parser/c/statement.rb:52
msgid "the value to set the attribute overrides to."
msgstr "値にオーバーライド属性を設定するための値"

# YARD::Parser::Ruby::Legacy::RubyToken::TkNode#node
#: ../lib/yard/parser/c/statement.rb:53
msgid "Returns the value of attribute overrides"
msgstr "オーバーライド属性の値を返す"

# YARD::Tags::RefTag#owner=
# YARD::Tags::RefTagList#owner=
#: ../lib/yard/parser/c/statement.rb:53
msgid "Sets the attribute overrides"
msgstr "オーバーライド属性を設定する"

# @param value
#: ../lib/yard/parser/c/statement.rb:53
msgid "the value to set the attribute statement to."
msgstr "値にステートメント属性を設定するための値"

# YARD::CodeObjects::ExtraFileObject#name
# YARD::CodeObjects::ExtraFileObject#path
# YARD::Parser::Ruby::Legacy::RubyToken::TkId#name
# YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar#name
# YARD::Tags::RefTagList#name
# YARD::Templates::Section#name
#: ../lib/yard/parser/c/statement.rb:54
msgid "Returns the value of attribute statement"
msgstr "ステートメント属性の値を返す"

# YARD::CodeObjects::ExtraFileObject#name=
# YARD::Tags::RefTagList#name=
# YARD::Templates::Section#name=
#: ../lib/yard/parser/c/statement.rb:54
msgid "Sets the attribute statement"
msgstr "ステートメント属性を設定する"

# @return [Token]
#: ../lib/yard/parser/c/statement.rb:55
msgid "a new instance of Comment"
msgstr "コメントの新しいインスタンス"

# YARD::Parser::Ruby#s
#: ../lib/yard/parser/ruby/ast_node.rb:5
msgid ""
"Builds and s-expression by creating {AstNode} objects with\n"
"the type provided by the first argument."
msgstr ""
"最初の引数によって提供された型を用い{AstNode}オブジェクトを作成する事によって\n"
"ビルドされS式にされる。"

# @example An implicit list of keywords
#: ../lib/yard/parser/ruby/ast_node.rb:24
msgid ""
"ast = s(s(:kw, \"if\"), s(:kw, \"else\"))\n"
"ast.type # => :list"
msgstr ""

# @example A method call
#: ../lib/yard/parser/ruby/ast_node.rb:24
msgid "s(:command, s(:var_ref, \"mymethod\"))"
msgstr ""

# @example
#: ../lib/yard/parser/ruby/ast_node.rb:24
msgid "tag|example|A method call"
msgstr "メソッド呼び出し"

# @example
#: ../lib/yard/parser/ruby/ast_node.rb:24
msgid "tag|example|An implicit list of keywords"
msgstr "キーワードの暗黙のリスト"

# @overload
#: ../lib/yard/parser/ruby/ast_node.rb:24
msgid "tag|overload|s"
msgstr ""

# @see
#: ../lib/yard/parser/ruby/ast_node.rb:24
msgid "tag|see|AstNode#initialize"
msgstr ""

# YARD::Parser::Ruby::AstNode
#: ../lib/yard/parser/ruby/ast_node.rb:31
msgid ""
"An AST node is characterized by a type and a list of children. It\n"
"is most easily represented by the s-expression {#s} such as:\n"
"  # AST for \"if true; 5 end\":\n"
"  s(s(:if, s(:var_ref, s(:kw, \"true\")), s(s(:int, \"5\")), nil))"
msgstr ""
"ASTノードは型や子のリストによって特徴付けられる。\n"
"それは最も簡単にS式 {#s}メソッドによって表される。\n"
"以下の通り。\n"
"  # AST for \"if true; 5 end\":\n"
"  s(s(:if, s(:var_ref, s(:kw, \"true\")), s(s(:int, \"5\")), nil))"

# YARD::Parser::Ruby::AstNode
#: ../lib/yard/parser/ruby/ast_node.rb:36
msgid ""
"The node type is not considered part of the list, only its children.\n"
"So +ast[0]+ does not refer to the type, but rather the first child\n"
"(or object). Items that are not +AstNode+ objects can be part of the\n"
"list, like Strings or Symbols representing names. To return only\n"
"the AstNode children of the node, use {#children}."
msgstr ""
"ノードの型は、リストの一部とは考えられていない。\n"
"その為,そのリストは子だけとなる。\n"
"そして +ast[0]+ は型を参照しない、\n"
"しかし、最初の子(やオブジェクト)が選ばれる。\n"
"+AstNode+ オブジェクトではない事項は、リストの一部にでき、\n"
"文字列やシンボルのように、名前を表現している。\n"
"ノードからAstNodeの子だけ返すには、{#children}メソッドを使用する。"

# @param value
#: ../lib/yard/parser/ruby/ast_node.rb:41
msgid "the value to set the attribute docstring_hash_flag to."
msgstr "docstring_hash_flag属性を設定する,値"

# YARD::Parser::Ruby::AstNode#docstring_hash_flag
# YARD::Parser::Ruby::AstNode#comments_hash_flag
#: ../lib/yard/parser/ruby/ast_node.rb:42
#: ../lib/yard/parser/ruby/ast_node.rb:52
msgid "Returns the value of attribute docstring_hash_flag"
msgstr "docstring_hash_flag属性の値を返す。"

# YARD::Parser::Ruby::AstNode#docstring_hash_flag=
#: ../lib/yard/parser/ruby/ast_node.rb:42
msgid "Sets the attribute docstring_hash_flag"
msgstr "docstring_hash_flag属性を設定する。"

# @return [String]
#: ../lib/yard/parser/ruby/ast_node.rb:42
#: ../lib/yard/parser/ruby/ast_node.rb:88
msgid "the parse of {#full_source} that the node represents"
msgstr "ノードを表す{#full_source}の入った,parse"

# @param value
#: ../lib/yard/parser/ruby/ast_node.rb:42
msgid "the value to set the attribute docstring to."
msgstr "docstring属性を設定する,値"

# @param value
#: ../lib/yard/parser/ruby/ast_node.rb:42
msgid "the value to set the attribute docstring_range to."
msgstr "docstring_range属性を設定する,値"

# YARD::Parser::Ruby::AstNode#docstring
# YARD::Parser::Ruby::AstNode#comments
# YARD::Tags::OverloadTag#docstring
#: ../lib/yard/parser/ruby/ast_node.rb:43
#: ../lib/yard/parser/ruby/ast_node.rb:50 ../lib/yard/tags/overload_tag.rb:5
msgid "Returns the value of attribute docstring"
msgstr "docstring属性の入った値を返す。"

# YARD::Parser::Ruby::AstNode#docstring_range
# YARD::Parser::Ruby::AstNode#comments_range
#: ../lib/yard/parser/ruby/ast_node.rb:43
#: ../lib/yard/parser/ruby/ast_node.rb:51
msgid "Returns the value of attribute docstring_range"
msgstr "docstring_range属性の入った値を返す。"

# YARD::Parser::Ruby::AstNode#docstring=
#: ../lib/yard/parser/ruby/ast_node.rb:43
msgid "Sets the attribute docstring"
msgstr "docstring属性を設定する。"

# YARD::Parser::Ruby::AstNode#docstring_range=
#: ../lib/yard/parser/ruby/ast_node.rb:43
msgid "Sets the attribute docstring_range"
msgstr "docstring_range属性を設定する。"

# @param value
#: ../lib/yard/parser/ruby/ast_node.rb:48
msgid "the value to set the attribute full_source to."
msgstr "full_source属性を設定する,値"

# @param value
#: ../lib/yard/parser/ruby/ast_node.rb:48
msgid "the value to set the attribute line_range to."
msgstr "line_range属性を設定する,値"

# @param value
#: ../lib/yard/parser/ruby/ast_node.rb:48
msgid "the value to set the attribute source_range to."
msgstr "source_range属性を設定する,値"

# YARD::Parser::Ruby::AstNode#full_source=
#: ../lib/yard/parser/ruby/ast_node.rb:49
msgid "Sets the attribute full_source"
msgstr "full_source属性を設定する。"

# YARD::Parser::Ruby::AstNode#line_range=
#: ../lib/yard/parser/ruby/ast_node.rb:49
msgid "Sets the attribute line_range"
msgstr "line_range属性を設定する。"

# YARD::Parser::Ruby::AstNode#source_range=
#: ../lib/yard/parser/ruby/ast_node.rb:49
msgid "Sets the attribute source_range"
msgstr "source_range属性を設定する。"

# @return [Symbol]
#: ../lib/yard/parser/ruby/ast_node.rb:55
msgid "the node's unique symbolic type"
msgstr "独自のsymbolic型のノード群。"

# @return [AstNode, nil]
#: ../lib/yard/parser/ruby/ast_node.rb:58
msgid "the node's parent or nil if it is a root node."
msgstr "親ノード群(ルートノードの場合,nilとなる。)"

# @return [Range]
#: ../lib/yard/parser/ruby/ast_node.rb:62
msgid ""
"the character range in {#full_source} represented\n"
"by the node"
msgstr "ノードによって表される{#full_source}メソッドの中の固有の範囲。"

# @return [Range]
#: ../lib/yard/parser/ruby/ast_node.rb:69
msgid ""
"the line range in {#full_source} represented\n"
"by the node"
msgstr "ノードによって表される{#full_source}メソッドの中の行の範囲。"

# @return [String]
#: ../lib/yard/parser/ruby/ast_node.rb:75
msgid "the filename the node was parsed from"
msgstr "ノードを解析した,ファイル名"

# @return [String]
#: ../lib/yard/parser/ruby/ast_node.rb:81
msgid "the full source that the node was parsed from"
msgstr "ノードから解析されたソースの全て。"

# YARD::Parser::Ruby::AstNode::KEYWORDS
#: ../lib/yard/parser/ruby/ast_node.rb:94
msgid "List of all known keywords"
msgstr "著名なキーワードのリスト。"

# YARD::Parser::Ruby::AstNode.node_class_for
#: ../lib/yard/parser/ruby/ast_node.rb:106
msgid ""
"Finds the node subclass that should be instantiated for a specific\n"
"node type"
msgstr ""
"特定のノード型用の\n"
"インスタンス化されるべきサブクラスのノードを見つける。"

# YARD::Parser::Ruby::AstNode.node_class_for
# YARD::Parser::Ruby::AstNode#initialize
# YARD::Parser::Ruby::AstNode#==
#: ../lib/yard/parser/ruby/ast_node.rb:110
#: ../lib/yard/parser/ruby/ast_node.rb:152
#: ../lib/yard/parser/ruby/ast_node.rb:165
msgid "Creating an AstNode"
msgstr "AstNodeを作成する。"

# @return [Class]
#: ../lib/yard/parser/ruby/ast_node.rb:110
msgid "a subclass of AstNode to instantiate the node with."
msgstr "nodeをインスタンス化するAstNodeのサブクラス"

# @param [Symbol] type
#: ../lib/yard/parser/ruby/ast_node.rb:110
msgid "the node type to find a subclass for"
msgstr "ノードの型用のサブクラスを見つける,型"

# YARD::Parser::Ruby::AstNode#initialize
#: ../lib/yard/parser/ruby/ast_node.rb:140
msgid "Creates a new AST node"
msgstr "新しいASTノードを作成する。"

# @return [AstNode]
#: ../lib/yard/parser/ruby/ast_node.rb:152
msgid "a new instance of AstNode"
msgstr "AstNodeの新しいインスタンス"

# @param [Hash] opts
#: ../lib/yard/parser/ruby/ast_node.rb:152
msgid "any extra line options"
msgstr "行の為の追加の設定"

# @param [Array<AstNode>]
#: ../lib/yard/parser/ruby/ast_node.rb:152
msgid "tag|param|arr"
msgstr ""

# @param [Array<AstNode>] arr
#: ../lib/yard/parser/ruby/ast_node.rb:152
msgid "the child nodes"
msgstr "子のノード"

# @param [Symbol] type
#: ../lib/yard/parser/ruby/ast_node.rb:152
msgid "the type of node being created"
msgstr "作成されるノードのタイプ"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:165
msgid ""
"whether the node is equal to another by checking\n"
"the list and type"
msgstr "ノードがリストか型かチェックすることによって他と等しくなるかどうか"

# YARD::Parser::Ruby::AstNode#jump
#: ../lib/yard/parser/ruby/ast_node.rb:172
msgid ""
"Searches through the node and all descendants and returns the\n"
"first node with a type matching any of +node_types+, otherwise\n"
"returns the original node (self)."
msgstr ""
"ノードや,全ての子孫の中を検索する。\n"
"+node_types+ の入った型マッチと共に\n"
"最初のノードを返す。\n"
"さもなければ、(自身の)オリジナルノードを返す。"

# YARD::Parser::Ruby::AstNode#jump
# YARD::Parser::Ruby::AstNode#children
# YARD::Parser::Ruby::AstNode#traverse
#: ../lib/yard/parser/ruby/ast_node.rb:191
#: ../lib/yard/parser/ruby/ast_node.rb:197
#: ../lib/yard/parser/ruby/ast_node.rb:206
msgid "Traversing a Node"
msgstr "ノードを辿る。"

# @param [Array<Symbol>] node_types
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid "a set of node types to match"
msgstr "マッチするノードの型の設定。"

# @example If the node types are not present in the AST
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid ""
"ast = YARD.parse(\"def x; end\")\n"
"ast.jump(:def)"
msgstr ""

# @example Returns first 'def' or 'class' statement
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid ""
"ast = YARD.parse_string(\"class X; def y; end end\")\n"
"ast.jump(:def, :class).first\n"
"# =>"
msgstr ""

# @example Returns the first method definition in a block of code
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid ""
"ast = YARD.parse_string(\"if true; def x; end end\").ast\n"
"ast.jump(:def)\n"
"# => s(:def, s(:ident, \"x\"), s(:params, nil, nil, nil, nil,\n"
"#      nil), s(s(:void_stmt, )))"
msgstr ""

# @return [self]
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid "if no node was found"
msgstr "ノードが見つからなかった場合"

# @example
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid "tag|example|If the node types are not present in the AST"
msgstr "ノードの型がASTの中に渡さない場合"

# @example
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid "tag|example|Returns first 'def' or 'class' statement"
msgstr "最初の'def'や'class'ステートメントを返す。"

# @example
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid "tag|example|Returns the first method definition in a block of code"
msgstr "コードのブロックの中の最初のメソッド定義を返す。"

# @param [Array<Symbol>]
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid "tag|param|node_types"
msgstr ""

# @return [AstNode]
#: ../lib/yard/parser/ruby/ast_node.rb:191
msgid "the matching node, if one was found"
msgstr "マッチするノード(一つ見つかった場合)"

# @return [Array<AstNode>]
#: ../lib/yard/parser/ruby/ast_node.rb:197
msgid "the {AstNode} children inside the node"
msgstr "ノード内部の{AstNode}の子。"

# YARD::Parser::Ruby::AstNode#traverse
#: ../lib/yard/parser/ruby/ast_node.rb:202
msgid ""
"Traverses the object and yields each node (including descendants) in order."
msgstr ""
"オブジェクトを辿り、\n"
"順番にそれぞれのノード(子孫を含んでいる)を\n"
"yieldする。"

# @yield
#: ../lib/yard/parser/ruby/ast_node.rb:206
msgid "each descendant node in order"
msgstr "整理されたそれぞれの子孫のノード。"

# @yieldparam [AstNode] self,
#: ../lib/yard/parser/ruby/ast_node.rb:206
msgid "or a child/descendant node"
msgstr "自身や子や子孫のノード。"

# @yieldparam [AstNode]
#: ../lib/yard/parser/ruby/ast_node.rb:206
msgid "tag|yieldparam|self,"
msgstr ""

# YARD::Parser::Ruby::AstNode#token?
# YARD::Parser::Ruby::AstNode#ref?
# YARD::Parser::Ruby::AstNode#literal?
# YARD::Parser::Ruby::AstNode#kw?
# YARD::Parser::Ruby::AstNode#call?
# YARD::Parser::Ruby::AstNode#condition?
#: ../lib/yard/parser/ruby/ast_node.rb:217
#: ../lib/yard/parser/ruby/ast_node.rb:223
#: ../lib/yard/parser/ruby/ast_node.rb:228
#: ../lib/yard/parser/ruby/ast_node.rb:233
#: ../lib/yard/parser/ruby/ast_node.rb:238
#: ../lib/yard/parser/ruby/ast_node.rb:243
#: ../lib/yard/parser/ruby/ast_node.rb:248
#: ../lib/yard/parser/ruby/ast_node.rb:253
#: ../lib/yard/parser/ruby/ast_node.rb:258
msgid "Node Meta Types"
msgstr ""

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:217
msgid "whether the node is a token"
msgstr "ノードがトークンかどうか"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:223
msgid ""
"whether the node is a reference (variable,\n"
"constant name)"
msgstr "ノードが参照するかどうか(変数,定数名)"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:228
msgid "whether the node is a literal value"
msgstr "ノードがリテラル値かどうか"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:233
msgid "whether the node is a keyword"
msgstr "ノードがキーワードかどうか"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:238
msgid "whether the node is a method call"
msgstr "ノードがメソッド呼び出しかどうか"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:243
msgid "whether the node is a method definition"
msgstr "ノードがメソッド定義かどうか"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:248
msgid "whether the node is a if/elsif/else condition"
msgstr "ノードがifやelsifやelseの条件かどうか"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:253
msgid "whether the node is a loop"
msgstr "ノードがループかどうか"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:258
msgid "whether the node has a block"
msgstr "ノードがblockかどうか"

# YARD::Parser::Ruby::AstNode#has_line?
# YARD::Parser::Ruby::AstNode#line
# YARD::Parser::Ruby::AstNode#first_line
#: ../lib/yard/parser/ruby/ast_node.rb:265
#: ../lib/yard/parser/ruby/ast_node.rb:270
#: ../lib/yard/parser/ruby/ast_node.rb:275
msgid "Getting Line Information"
msgstr "行の情報を取得する。"

# @return [Boolean]
#: ../lib/yard/parser/ruby/ast_node.rb:265
msgid "whether the node has a {#line_range} set"
msgstr "ノードが{#line_range}設定を持っているかどうか"

# @return [Fixnum]
#: ../lib/yard/parser/ruby/ast_node.rb:270
msgid "the starting line number of the node"
msgstr "ノードの文字列の行数"

# @return [String]
#: ../lib/yard/parser/ruby/ast_node.rb:275
msgid "the first line of source represented by the node."
msgstr "ノードによって表されるソースの最初の行"

# YARD::Parser::Ruby::AstNode#show
# YARD::Parser::Ruby::AstNode#pretty_print
# YARD::Parser::Ruby::AstNode#inspect
#: ../lib/yard/parser/ruby/ast_node.rb:282
#: ../lib/yard/parser/ruby/ast_node.rb:287
#: ../lib/yard/parser/ruby/ast_node.rb:322
msgid "Printing a Node"
msgstr "ノードをプリントする。"

# @return [String]
#: ../lib/yard/parser/ruby/ast_node.rb:282
msgid "the first line of source the node represents"
msgstr "ノードを表すソースの最初の行"

# @return [nil]
#: ../lib/yard/parser/ruby/ast_node.rb:287
msgid "pretty prints the node"
msgstr "ノードの出力"

# @return [String]
#: ../lib/yard/parser/ruby/ast_node.rb:322
msgid "inspects the object"
msgstr "解析するオブジェクト"

# YARD::Templates::Helpers::BaseHelper#globals
#: ../lib/yard/parser/ruby/ast_node.rb:330
#: ../lib/yard/parser/ruby/ast_node.rb:340
#: ../lib/yard/parser/ruby/ast_node.rb:358
#: ../lib/yard/parser/ruby/ast_node.rb:359
#: ../lib/yard/parser/ruby/ast_node.rb:361
#: ../lib/yard/parser/ruby/ast_node.rb:365
#: ../lib/yard/parser/ruby/ast_node.rb:370
#: ../lib/yard/parser/ruby/ast_node.rb:371
#: ../lib/yard/parser/ruby/ast_node.rb:374
#: ../lib/yard/parser/ruby/ast_node.rb:375
#: ../lib/yard/parser/ruby/ast_node.rb:378
#: ../lib/yard/parser/ruby/ast_node.rb:379
#: ../lib/yard/parser/ruby/ast_node.rb:380
#: ../lib/yard/parser/ruby/ast_node.rb:381
#: ../lib/yard/parser/ruby/ast_node.rb:382
#: ../lib/yard/parser/ruby/ast_node.rb:383
#: ../lib/yard/parser/ruby/ast_node.rb:386
#: ../lib/yard/parser/ruby/ast_node.rb:387
#: ../lib/yard/parser/ruby/ast_node.rb:388
#: ../lib/yard/parser/ruby/ast_node.rb:390
#: ../lib/yard/parser/ruby/ast_node.rb:395
#: ../lib/yard/parser/ruby/ast_node.rb:404
#: ../lib/yard/parser/ruby/ast_node.rb:405
#: ../lib/yard/parser/ruby/ast_node.rb:411
#: ../lib/yard/parser/ruby/ast_node.rb:415
#: ../lib/yard/parser/ruby/ast_node.rb:420
#: ../lib/yard/parser/ruby/ast_node.rb:421
#: ../lib/yard/parser/ruby/ast_node.rb:422
#: ../lib/yard/parser/ruby/ast_node.rb:423
#: ../lib/yard/parser/ruby/ast_node.rb:425
#: ../lib/yard/parser/ruby/ast_node.rb:430
#: ../lib/yard/parser/ruby/ast_node.rb:436
#: ../lib/yard/parser/ruby/ast_node.rb:440
#: ../lib/yard/parser/ruby/ast_node.rb:445
#: ../lib/yard/parser/ruby/ast_node.rb:446
#: ../lib/yard/parser/ruby/ast_node.rb:447
#: ../lib/yard/parser/ruby/ast_node.rb:448
#: ../lib/yard/parser/ruby/ast_node.rb:450
#: ../lib/yard/parser/ruby/ast_node.rb:458
#: ../lib/yard/parser/ruby/ast_node.rb:461
#: ../lib/yard/parser/ruby/ast_node.rb:462
#: ../lib/yard/parser/ruby/ast_node.rb:463
#: ../lib/yard/parser/ruby/ast_node.rb:464
#: ../lib/yard/parser/ruby/ast_node.rb:467
#: ../lib/yard/parser/ruby/ast_node.rb:468
#: ../lib/yard/parser/ruby/ast_node.rb:469
#: ../lib/yard/parser/ruby/ast_node.rb:472
#: ../lib/yard/parser/ruby/ast_node.rb:473
#: ../lib/yard/parser/ruby/ast_node.rb:474
#: ../lib/yard/parser/ruby/ast_node.rb:475
#: ../lib/yard/parser/ruby/ast_node.rb:479
#: ../lib/yard/parser/ruby/ast_node.rb:480
#: ../lib/yard/parser/ruby/ast_node.rb:481
#: ../lib/yard/parser/ruby/ast_node.rb:482
#: ../lib/yard/parser/ruby/ast_node.rb:484
#: ../lib/yard/parser/ruby/ast_node.rb:485
msgid "Managing node state"
msgstr "ノードの状態の管理"

# YARD::Parser::Ruby::Legacy::RubyToken::TkStatementEnd
#: ../lib/yard/parser/ruby/ast_node.rb:330
msgid "Resets node state in tree"
msgstr "ツリーの中でノードの状態をリセットする"

# YARD::Parser::Ruby::AstNode#reset_line_info
#: ../lib/yard/parser/ruby/ast_node.rb:339
msgid "Resets line information"
msgstr "行情報をリセットする。"

# YARD::CodeObjects::MethodObject
#: ../lib/yard/parser/ruby/ast_node.rb:479
msgid "Represents a lone comment block in source"
msgstr "ソースの中の単一のコメントブロックを表す"

# YARD::Parser::Ruby::Legacy::RubyToken
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:7
msgid "Legacy lexical tokenizer module."
msgstr ""

# YARD::Parser::Ruby::Legacy::RubyToken::Token
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:17
msgid "Represents a token in the Ruby lexer"
msgstr "Ruby lexerの中のトークンを表す"

# @return [Integer]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:20
msgid ""
"the line number in the file/stream the token is\n"
"located."
msgstr "トークンが位置する,ファイルやストリームの中の行の数"

# @return [Integer]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:24
msgid ""
"the character number in the file/stream the token\n"
"is located."
msgstr "トークンが位置する,ファイルやストリームの中のcharacterの数"

# @return [String]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:27
msgid "the token text value"
msgstr "トークンのテキストの値"

# @return [Symbol]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:30
msgid "the lexical state at the token"
msgstr "トークンにおける単語の状態"

# YARD::Parser::Ruby::Legacy::RubyToken::Token#initialize
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:36
msgid "Creates a new Token object"
msgstr "新しいトークンオブジェクトを作成する"

# @return [Token]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:38
msgid "a new instance of Token"
msgstr "トークンの新しいインスタンス"

# @param [Integer]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:38
msgid "tag|param|char_no"
msgstr ""

# @param [Integer]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:38
msgid "tag|param|line_no"
msgstr ""

# @param [Integer] char_no
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:38
msgid "the char number to initialize the token to"
msgstr "char numberをトークンにイニシャライズする, char number"

# @param [Integer] line_no
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:38
msgid "the line number to initialize the token to"
msgstr "行数をトークンにイニシャライズする。行数"

# YARD::Parser::Ruby::Legacy::RubyToken::Token#set_text
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:45
msgid "Chainable way to sets the text attribute"
msgstr "テキスト属性を設定する為の方法を紐付ける。"

# @param [String] text
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:48
msgid "the new text"
msgstr "新しいテキスト"

# @return [Token]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:48
msgid "this token object"
msgstr "このトークンオブジェクト"

# YARD::Parser::Ruby::Legacy::RubyToken::TkBlockContents
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:55
msgid "Represents a block"
msgstr "ブロックを表す"

# YARD::Parser::Ruby::Legacy::RubyToken::TkStatementEnd
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:60
msgid "Represents an end statement"
msgstr "ステートメントの終りを表す。"

# YARD::Parser::Ruby::Legacy::RubyToken::TkNode#node
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:66
msgid "Returns the value of attribute node"
msgstr "node属性の値を返す。"

# YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:69
msgid "Represents whitespace"
msgstr "空白を表す"

# YARD::Parser::Ruby::Legacy::RubyToken::TkId
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:73
msgid "Represents a Ruby identifier"
msgstr "RubyのIDを表す。"

# @return [TkId]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:74
msgid "a new instance of TkId"
msgstr "TkIdの新しいインスタンス"

# YARD::Parser::Ruby::Legacy::RubyToken::TkKW
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:82
msgid "Represents a Ruby keyword"
msgstr "Rubyキーワードを表す。"

# YARD::Parser::Ruby::Legacy::RubyToken::TkVal
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:86
msgid "Represents a Ruby value"
msgstr "Rubyの値を表す。"

# @return [TkVal]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:87
msgid "a new instance of TkVal"
msgstr "TkValの新しいインスタンス"

# @return [TkOPASGN]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:100
msgid "a new instance of TkOPASGN"
msgstr "TkOPASGNの新しいインスタンス"

# YARD::Parser::Ruby::Legacy::RubyToken::TkOPASGN#op
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:106
msgid "Returns the value of attribute op"
msgstr "op属性の値を返す。"

# @return [TkUnknownChar]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:109
msgid "a new instance of TkUnknownChar"
msgstr "TkUnknownCharの新しいインスタンス"

# YARD::Parser::Ruby::Legacy::RubyToken::TkReading2Token
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:284
msgid ""
"{ reading => token_class }\n"
"{ reading => [token_class, *opt] }"
msgstr ""

# YARD::Parser::Ruby::Legacy::RubyLex
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:330
msgid "Lexical analyzer for Ruby source"
msgstr "Rubyソース用の単語解析"

# YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:333
msgid ""
"Read an input stream character by character. We allow for unlimited\n"
"ungetting of characters just read."
msgstr ""
"character毎にストリームの入力を読み込む。\n"
"そこで読まれたcharacterの書き戻しを無制限に許可する。"

# YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:336
msgid ""
"We simplify the implementation greatly by reading the entire input\n"
"into a buffer initially, and then simply traversing it using\n"
"pointers."
msgstr ""
"最初にバッファの中へ全ての入力を読み込む事によって\n"
"実装する事を非常に簡潔にする。\n"
"そして、それはポインターを利用する事によって簡単に辿ることができる。"

# YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:340
msgid ""
"We also have to allow for the <i>here document diversion</i>. This\n"
"little gem comes about when the lexer encounters a here\n"
"document. At this point we effectively need to split the input\n"
"stream into two parts: one to read the body of the here document,\n"
"the other to read the rest of the input line where the here\n"
"document was initially encountered. For example, we might have"
msgstr ""
"私達は <i>複数のヒアドキュメント</i> も考慮しなければならない。\n"
"この複数のヒアドキュメントは、字句解析器がヒアドキュメントに出会う時に起こ"
"る。\n"
"この時点で私達は、事実上2つの部分に入力ストリームを分割する必要がある。\n"
"一つはヒアドキュメントの本体を読み込む部分、\n"
"もう一つは、それ以外の\n"
"ヒアドキュメントが最初に出会った所から、\n"
"入力行の残りを読み込む為の部分。\n"
"例えば、"

# YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:347
msgid ""
"  do_something(<<-A, <<-B)\n"
"    stuff\n"
"    for\n"
"  A\n"
"    stuff\n"
"    for\n"
"  B"
msgstr ""

# YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:355
msgid ""
"When the lexer encounters the <<A, it reads until the end of the\n"
"line, and keeps it around for later. It then reads the body of the\n"
"here document.  Once complete, it needs to read the rest of the\n"
"original line, but then skip the here document body."
msgstr ""
"この字句解析器が<<Aと出会った時、行の終りまで読み込まれその内容を保持する。\n"
"そして、その後ヒアドキュメントの本体を読み込む。\n"
"一度Aの部分で解析が完了させ、字句解析器は元の行の残りを読み込む必要がある。\n"
"しかし、その時ヒアドキュメントの本体はスキップする。"

# YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader#line_num
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:363
msgid "Returns the value of attribute line_num"
msgstr "line_num属性の値を返す。"

# @return [BufferedReader]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:364
msgid "a new instance of BufferedReader"
msgstr "BufferedReaderの新しいインスタンス"

# YARD::Parser::Ruby::Legacy::RubyLex#continue
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:457
msgid "Returns the value of attribute continue"
msgstr "continue属性の値を返す。"

# YARD::Parser::Ruby::Legacy::RubyLex#lex_state
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:458
msgid "Returns the value of attribute lex_state"
msgstr "lex_state属性の値を返す。"

# @return [RubyLex]
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:463
msgid "a new instance of RubyLex"
msgstr "RubyLexの新しいインスタンス"

# @param value
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:485
msgid "the value to set the attribute skip_space to."
msgstr "skip_space属性を設定する,値"

# YARD::Parser::Ruby::Legacy::RubyLex#skip_space
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:486
msgid "Returns the value of attribute skip_space"
msgstr "skip_space属性を返す。"

# YARD::Parser::Ruby::Legacy::RubyLex#skip_space=
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:486
msgid "Sets the attribute skip_space"
msgstr "skip_space属性を設定する。"

# @param value
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:486
msgid "the value to set the attribute read_auto_clean_up to."
msgstr "read_auto_clean_up属性を設定する,値"

# YARD::Parser::Ruby::Legacy::RubyLex#read_auto_clean_up
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:487
msgid "Returns the value of attribute read_auto_clean_up"
msgstr "read_auto_clean_up属性の値を返す。"

# YARD::Parser::Ruby::Legacy::RubyLex#read_auto_clean_up=
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:487
msgid "Sets the attribute read_auto_clean_up"
msgstr "read_auto_clean_up属性を設定する。"

# @param value
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:487
msgid "the value to set the attribute exception_on_syntax_error to."
msgstr "exception_on_syntax_error属性を設定する,値"

# YARD::Parser::Ruby::Legacy::RubyLex#exception_on_syntax_error
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:488
msgid "Returns the value of attribute exception_on_syntax_error"
msgstr "exception_on_syntax_error属性の値を返す。"

# YARD::Parser::Ruby::Legacy::RubyLex#exception_on_syntax_error=
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:488
msgid "Sets the attribute exception_on_syntax_error"
msgstr "exception_on_syntax_error属性を設定する。"

# YARD::Parser::Ruby::Legacy::RubyLex#indent
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:490
msgid "Returns the value of attribute indent"
msgstr "indent属性の値を返す。"

# YARD::Parser::Ruby::Legacy::RubyLex#line_no
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:492
msgid "io functions"
msgstr "入出力の機能"

# YARD::Parser::Ruby::Legacy::RubyLex::DEINDENT_CLAUSE
#: ../lib/yard/parser/ruby/legacy/ruby_lex.rb:579
msgid ", \"when\""
msgstr ""

# YARD::Parser::Ruby::Legacy::RubyParser
#: ../lib/yard/parser/ruby/legacy/ruby_parser.rb:6
msgid "Legacy Ruby parser"
msgstr "レガシーRubyパーサー"

# @return [RubyParser]
#: ../lib/yard/parser/ruby/legacy/ruby_parser.rb:8
#: ../lib/yard/parser/ruby/ruby_parser.rb:11
msgid "a new instance of RubyParser"
msgstr "Rubyパーサーの新しいインスタンス"

# YARD::Parser::Ruby::Legacy::Statement#tokens
# YARD::Parser::Ruby::RipperParser#tokens
#: ../lib/yard/parser/ruby/legacy/statement.rb:5
#: ../lib/yard/parser/ruby/ruby_parser.rb:26
msgid "Returns the value of attribute tokens"
msgstr "tokens属性の値を返す。"

# @param value
#: ../lib/yard/parser/ruby/legacy/statement.rb:5
msgid "the value to set the attribute comments_range to."
msgstr "comments_range属性を設定する,値"

# YARD::Parser::Ruby::Legacy::Statement#comments_range
#: ../lib/yard/parser/ruby/legacy/statement.rb:6
msgid "Returns the value of attribute comments_range"
msgstr "comments_range属性を返す。"

# YARD::Parser::Ruby::Legacy::Statement#comments_range=
#: ../lib/yard/parser/ruby/legacy/statement.rb:6
msgid "Sets the attribute comments_range"
msgstr "comments_range属性を設定する。"

# @return [Fixnum]
#: ../lib/yard/parser/ruby/legacy/statement.rb:43
msgid "the first line of Ruby source"
msgstr "Rubyのソースの入った最初の行"

# @return [Range<Fixnum>]
#: ../lib/yard/parser/ruby/legacy/statement.rb:49
msgid "the first to last lines of Ruby source"
msgstr "Rubyのソースの入った,最初から最後までの行"

# @param value
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:6
msgid "the value to set the attribute encoding_line to."
msgstr "encoding_line属性を設定する,値"

# @param value
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:6
msgid "the value to set the attribute shebang_line to."
msgstr "shebang_line属性を設定する,値"

# YARD::Parser::Ruby::Legacy::StatementList#encoding_line
# YARD::Parser::Ruby::RipperParser#encoding_line
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:7
#: ../lib/yard/parser/ruby/ruby_parser.rb:27
msgid "Returns the value of attribute encoding_line"
msgstr "encoding_line属性を返す。"

# YARD::Parser::Ruby::Legacy::StatementList#shebang_line
# YARD::Parser::Ruby::RipperParser#shebang_line
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:7
#: ../lib/yard/parser/ruby/ruby_parser.rb:27
msgid "Returns the value of attribute shebang_line"
msgstr "shebang_line属性の値を返す。"

# YARD::Parser::Ruby::Legacy::StatementList#encoding_line=
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:7
msgid "Sets the attribute encoding_line"
msgstr "encoding_line属性を設定する。"

# YARD::Parser::Ruby::Legacy::StatementList#shebang_line=
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:7
msgid "Sets the attribute shebang_line"
msgstr "shebang_line属性を設定する。"

# YARD::Parser::Ruby::Legacy::StatementList::OPEN_BLOCK_TOKENS
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:9
msgid ""
"The following list of tokens will require a block to be opened\n"
"if used at the beginning of a statement."
msgstr ""
"続くトークンのリストは、\n"
"ステートメントの最初で使う場合、ブロックを必要とする。"

# YARD::Parser::Ruby::Legacy::StatementList#initialize
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:14
msgid "Creates a new statement list"
msgstr "新しいステートメントのリストを作成する。"

# @return [StatementList]
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:16
msgid "a new instance of StatementList"
msgstr "StatementListの新しいインスタンス"

# @param [TokenList, String] content
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:16
msgid "the tokens to create the list from"
msgstr "トークンのリストを作成する,トークン"

# YARD::Parser::Ruby::Legacy::StatementList#next_statement
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:37
msgid "Returns the next statement in the token stream"
msgstr "処理するトークンの中の次の文を返す。"

# @return [Statement]
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:39
msgid "the next statement"
msgstr "次のステートメント"

# YARD::Parser::Ruby::Legacy::StatementList#process_token
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:117
msgid "Processes a single token"
msgstr "単一のトークンを処理する。"

# @param [RubyToken::Token]
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:119
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:183
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:202
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:257
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:282
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:294
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:349
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:367
msgid "tag|param|tk"
msgstr ""

# @param [RubyToken::Token] tk
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:119
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:183
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:202
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:257
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:282
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:294
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:349
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:367
msgid "the token to process"
msgstr "処理の為のトークン"

# YARD::Parser::Ruby::Legacy::StatementList#process_block_token
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:181
msgid "Processes a token in a block"
msgstr "ブロックの中のトークンを処理する。"

# YARD::Parser::Ruby::Legacy::StatementList#process_initial_comment
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:199
msgid "Processes a comment token that comes before a statement"
msgstr "statement処理の前にトークンのコメントを処理する。"

# @return [Boolean]
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:202
msgid "whether or not +tk+ was processed as an initial comment"
msgstr ""
"+tk+ がこの#process_initial_commentメソッドが正常に処理されたかどうか。"

# YARD::Parser::Ruby::Legacy::StatementList#process_simple_block_opener
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:253
msgid ""
"Processes a simple block-opening token;\n"
"that is, a block opener such as +begin+ or +do+\n"
"that isn't followed by an expression"
msgstr ""
"後に式がない +begin+ や +do+ 等のような単純なトークンの\n"
"blockを開く処理をする。"

# YARD::Parser::Ruby::Legacy::StatementList#process_complex_block_opener
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:278
msgid ""
"Processes a complex block-opening token;\n"
"that is, a block opener such as +while+ or +for+\n"
"that is followed by an expression"
msgstr ""
"後に式が来る +while+ や +for+ 等のようなトークンの\n"
"複雑なblockを開く処理をする。"

# YARD::Parser::Ruby::Legacy::StatementList#process_statement_end
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:292
msgid "Processes a token that closes a statement"
msgstr "ステートメントを閉じるトークンを処理する。"

# YARD::Parser::Ruby::Legacy::StatementList#balances?
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:345
msgid "Handles the balancing of parentheses and blocks"
msgstr "丸括弧とブロックの両立の為の処理する。"

# @return [Boolean]
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:349
msgid ""
"whether or not the current statement's parentheses and blocks\n"
"are balanced after +tk+"
msgstr "現在のステートメントの丸括弧とブロックが +tk+ の後で両立するかどうか。"

# YARD::Parser::Ruby::Legacy::StatementList#push_token
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:364
msgid ""
"Adds a token to the current statement,\n"
"unless it's a newline, semicolon, or comment"
msgstr ""
"現在のステートメントの為にトークンを追加する。\n"
"ただし改行や、セミコロンや、コメントの場合を除く。"

# YARD::Parser::Ruby::Legacy::StatementList#peek_no_space
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:373
msgid "Returns the next token in the stream that's not a space"
msgstr "スペースの無いストリームの中の次のトークンを返す。"

# @return [RubyToken::Token]
#: ../lib/yard/parser/ruby/legacy/statement_list.rb:375
msgid "the next non-space token"
msgstr "スペースの無い次のトークン"

# @return [TokenList]
#: ../lib/yard/parser/ruby/legacy/token_list.rb:6
msgid "a new instance of TokenList"
msgstr "TokenListの新しいインスタンス"

# @param [TokenList, Token, String] tokens
#: ../lib/yard/parser/ruby/legacy/token_list.rb:25
msgid ""
"A list of tokens. If the token is a string, it\n"
"is parsed with {RubyLex}."
msgstr "トークンのリスト。トークンが文字列の場合、{RubyLex}と共に解析される。"

# @param [TokenList, Token, String]
#: ../lib/yard/parser/ruby/legacy/token_list.rb:25
msgid "tag|param|tokens"
msgstr ""

# YARD::Parser::Ruby::RubyParser
#: ../lib/yard/parser/ruby/ruby_parser.rb:7
#: ../lib/yard/parser/ruby/ruby_parser.rb:11
#: ../lib/yard/parser/ruby/ruby_parser.rb:18
#: ../lib/yard/parser/ruby/ruby_parser.rb:19
#: ../lib/yard/parser/ruby/ruby_parser.rb:20
msgid "Ruby 1.9 parser"
msgstr ""

# YARD::Parser::Ruby::RipperParser#ast
# YARD::Parser::Ruby::RipperParser#root
#: ../lib/yard/parser/ruby/ruby_parser.rb:26
#: ../lib/yard/parser/ruby/ruby_parser.rb:28
msgid "Returns the value of attribute ast"
msgstr "ast属性の値を返す。"

# YARD::Parser::Ruby::RipperParser#charno
#: ../lib/yard/parser/ruby/ruby_parser.rb:26
msgid "Returns the value of attribute charno"
msgstr "charno属性の値を返す。"

# @return [RipperParser]
#: ../lib/yard/parser/ruby/ruby_parser.rb:29
msgid "a new instance of RipperParser"
msgstr "RipperParserの新しいインスタンス"

# YARD::Parser::UndocumentableError
#: ../lib/yard/parser/source_parser.rb:7
msgid ""
"Raised when an object is recognized but cannot be documented. This\n"
"generally occurs when the Ruby syntax used to declare an object is\n"
"too dynamic in nature."
msgstr ""
"オブジェクトが認識される時に例外を上げる。\n"
"しかし、記述される事はない。\n"
"これは通常オブジェクトを宣言する為に\n"
"使われたRuby構文が動的すぎる時に起る。"

# YARD::Parser::ParserSyntaxError
#: ../lib/yard/parser/source_parser.rb:12
msgid "Raised when the parser sees a Ruby syntax error"
msgstr "パーサーがRubyの構文のエラーを発見した時、例外を上げる。"

# YARD::Parser::OrderedParser
#: ../lib/yard/parser/source_parser.rb:15
msgid ""
"Responsible for parsing a list of files in order. The\n"
"{#parse} method of this class can be called from the\n"
"{SourceParser#globals} globals state list to re-enter\n"
"parsing for the remainder of files in the list recursively."
msgstr ""

# @see
#: ../lib/yard/parser/source_parser.rb:20
#: ../lib/yard/parser/source_parser.rb:41
msgid "tag|see|Processor#parse_remaining_files"
msgstr ""

# @param [Array<String>] files
#: ../lib/yard/parser/source_parser.rb:22
msgid "the list of remaining files to parse"
msgstr "解析のための残りのファイルのリスト"

# YARD::Parser::OrderedParser#initialize
#: ../lib/yard/parser/source_parser.rb:25
msgid ""
"Creates a new OrderedParser with the global state and a list\n"
"of files to parse."
msgstr ""

# @note
#: ../lib/yard/parser/source_parser.rb:32
msgid ""
"OrderedParser sets itself as the +ordered_parser+ key on\n"
"global_state for later use in {Handlers::Processor}."
msgstr ""

# @return [CParser]
#: ../lib/yard/parser/source_parser.rb:32
msgid "a new instance of OrderedParser"
msgstr "OrderedParserの新しいインスタンス"

# @return [Processor]
#: ../lib/yard/parser/source_parser.rb:32
msgid ""
"a structure containing all global\n"
"state during parsing"
msgstr "解析中の全ての全体の状態を含んでいる構造体"

# @yieldparam [OpenStruct]
#: ../lib/yard/parser/source_parser.rb:32
msgid "tag|param|global_state"
msgstr ""

# YARD::Handlers::Ruby::Legacy::ClassConditionHandler#parse_condition
# YARD::Handlers::Ruby::ClassConditionHandler#parse_condition
#: ../lib/yard/parser/source_parser.rb:39
msgid "Parses the remainder of the {#files} list."
msgstr "{#files} のリストの残りを解析する"

# YARD::Parser::SourceParser
#: ../lib/yard/parser/source_parser.rb:51
msgid ""
"Responsible for parsing a source file into the namespace. Parsing\n"
"also invokes handlers to process the parsed statements and generate\n"
"any code objects that may be recognized."
msgstr ""
"namespaceの中のソースファイルを解析する為の責任がある。\n"
"そして解析する事は、解析されるステートメントや\n"
"認識されるかもしれないコードオブジェクトを生成する\n"
"処理の為にハンドラーも起動する。"

# YARD::Parser::SourceParser
#: ../lib/yard/parser/source_parser.rb:55
msgid ""
"== Custom Parsers\n"
"SourceParser allows custom parsers to be registered and called when\n"
"a certain filetype is recognized. To register a parser and hook it\n"
"up to a set of file extensions, call {register_parser_type}"
msgstr ""
"== カスタムパーサー\n"
"ソースパーサーによってカスタムパーサーは\n"
"明確にファイルタイプが認識される時に\n"
"記録され呼び出される。\n"
"パーサーを記録しファイル拡張子の設定をつなぐには、\n"
"{register_parser_type}を呼び出す。"

# @see
#: ../lib/yard/parser/source_parser.rb:62
msgid "tag|see|register_parser_type"
msgstr ""

# YARD::Parser::SourceParser::ENCODING_BYTE_ORDER_MARKS
#: ../lib/yard/parser/source_parser.rb:67
msgid "Byte order marks for various encodings"
msgstr "様々なエンコーディング用のバイトオーダーマーク"

# @return [Symbol]
#: ../lib/yard/parser/source_parser.rb:79
msgid "the default parser type (defaults to :ruby)"
msgstr "デフォルトのパーサータイプ(デフォルト :ruby)"

# YARD::Parser::SourceParser.parse
#: ../lib/yard/parser/source_parser.rb:86
msgid "Parses a path or set of paths"
msgstr "パスやパスの設定を解析する。"

# @param [Array<String, Regexp>] excluded
#: ../lib/yard/parser/source_parser.rb:93
msgid "a list of excluded path matchers"
msgstr "パスの照合を除外されるリスト。"

# @param [String, Array<String>] paths
#: ../lib/yard/parser/source_parser.rb:93
msgid ""
"a path, glob, or list of paths to\n"
"parse"
msgstr "パス,glob,解析の為のパスのリスト"

# @param [Array<String, Regexp>]
#: ../lib/yard/parser/source_parser.rb:93
msgid "tag|param|excluded"
msgstr "excluded"

# @param [Fixnum]
#: ../lib/yard/parser/source_parser.rb:93
msgid "tag|param|level"
msgstr "level"

# @param [Array<String>]
# @param [String, Array<String>]
#: ../lib/yard/parser/source_parser.rb:93 ../lib/yard/server/router.rb:122
msgid "tag|param|paths"
msgstr "paths"

# @param [Fixnum] level
#: ../lib/yard/parser/source_parser.rb:93
msgid ""
"the logger level to use during parsing. See\n"
"{YARD::Logger}"
msgstr ""
"解析される間、使用する為のloggerレベル。\n"
"{YARD::Logger}参照。"

# YARD::Parser::SourceParser.parse_string
#: ../lib/yard/parser/source_parser.rb:112
msgid "Parses a string +content+"
msgstr ""
"+content+ の文字列を解析する。\n"
"Parses a string +content+"

# @param [Symbol]
#: ../lib/yard/parser/source_parser.rb:116
#: ../lib/yard/parser/source_parser.rb:125
msgid "tag|param|ptype"
msgstr "ptype"

# @param [String] content
#: ../lib/yard/parser/source_parser.rb:116
msgid "the block of code to parse"
msgstr "解析する為のコードの入ったブロック。"

# @return
#: ../lib/yard/parser/source_parser.rb:116
msgid "the parser object that was used to parse +content+"
msgstr "+content+ を解析する為に利用されるパーサーオブジェクト。"

# @param [Symbol] ptype
#: ../lib/yard/parser/source_parser.rb:116
#: ../lib/yard/parser/source_parser.rb:125
msgid "the parser type to use. See {parser_type}."
msgstr "利用するパーサーの型。{parser_type}参照。"

# YARD::Parser::SourceParser.tokenize
#: ../lib/yard/parser/source_parser.rb:121
msgid "Tokenizes but does not parse the block of code"
msgstr "トークナイズする。しかしコードの入ったブロックは解析しない。"

# @return [Array]
#: ../lib/yard/parser/source_parser.rb:125
#: ../lib/yard/parser/source_parser.rb:460
msgid "a list of tokens"
msgstr "トークンの入ったリスト。"

# @param [String] content
#: ../lib/yard/parser/source_parser.rb:125
#: ../lib/yard/parser/source_parser.rb:460
msgid "the block of code to tokenize"
msgstr "トークナイズする為のコードの入ったブロック。"

# YARD::Parser::SourceParser.register_parser_type
#: ../lib/yard/parser/source_parser.rb:130
msgid "Registers a new parser type."
msgstr "新しいパーサーの型を記録する。"

# @example Registering a parser for "java" files
#: ../lib/yard/parser/source_parser.rb:139
msgid "SourceParser.register_parser_type :java, JavaParser, 'java'"
msgstr ""

# @param [Base] parser_klass
#: ../lib/yard/parser/source_parser.rb:139
msgid "a class that implements parsing and tokenization"
msgstr "解析やトークナイズを実装するクラス。"

# @param [Array<String>, String, Regexp] extensions
#: ../lib/yard/parser/source_parser.rb:139
msgid ""
"a list of extensions or a\n"
"regex to match against the file extension"
msgstr "拡張子のリストやファイル拡張子に対しマッチする正規表現。"

# @param [Symbol] type
#: ../lib/yard/parser/source_parser.rb:139
msgid "a symbolic name for the parser type"
msgstr "パーサー型用のシンボリック名。"

# @example
#: ../lib/yard/parser/source_parser.rb:139
msgid "tag|example|Registering a parser for \"java\" files"
msgstr "\"java\"ファイル用にパーサーを記録する"

# @param [Array<String>, String, Regexp]
#: ../lib/yard/parser/source_parser.rb:139
msgid "tag|param|extensions"
msgstr "extensions"

# @param [Base]
#: ../lib/yard/parser/source_parser.rb:139
msgid "tag|param|parser_klass"
msgstr "parser_klass"

# @see
#: ../lib/yard/parser/source_parser.rb:139
msgid "tag|see|Parser::Base"
msgstr ""

# @return [Hash{Symbol=>Object}]
#: ../lib/yard/parser/source_parser.rb:150
#: ../lib/yard/parser/source_parser.rb:152
msgid "a list of registered parser types"
msgstr "パーサーの型が記録されるリスト。"

# YARD::Parser::SourceParser.parser_type_for_extension
#: ../lib/yard/parser/source_parser.rb:164
msgid ""
"Finds a parser type that is registered for the extension. If no\n"
"type is found, the default Ruby type is returned."
msgstr ""
"拡張用の記録されるパーサーの型を見つける。\n"
"型が見つからない無い場合、デフォルトのRuby型が返される。"

# @return [Symbol]
#: ../lib/yard/parser/source_parser.rb:168
msgid "the parser type to be used for the extension"
msgstr "拡張用に利用されるパーサーの型。"

# YARD::Parser::SourceParser.validated_parser_type
#: ../lib/yard/parser/source_parser.rb:176
msgid ""
"Returns the validated parser type. Basically, enforces that :ruby\n"
"type is never set if the Ripper library is not available"
msgstr ""
"有効なパーサー型を返す。\n"
"基本的に、Ripperライブラリが利用不可の場合、\n"
":ruby型が設定されないよう実行される。"

# @param [Symbol] type
#: ../lib/yard/parser/source_parser.rb:181
msgid "the parser type to set"
msgstr "設定するパーサーの型。"

# @return [Symbol]
#: ../lib/yard/parser/source_parser.rb:181
msgid "the validated parser type"
msgstr "有効なパーサーの型。"

# YARD::Parser::SourceParser.before_parse_list
#: ../lib/yard/parser/source_parser.rb:188
msgid ""
"Registers a callback to be called before a list of files is parsed\n"
"via {parse}. The block passed to this method will be called on\n"
"subsequent parse calls."
msgstr ""
"{parse} 経由でファイルのリストが解析される前に呼び出されるコールバックを記録する\n"
"このメソッドに渡されるブロックはそれに続く、parse呼び出し上で呼び出される。"

# YARD::Parser::SourceParser.before_parse_list
# YARD::Parser::SourceParser.after_parse_list
# YARD::Parser::SourceParser.before_parse_file
# YARD::Parser::SourceParser.after_parse_file
# YARD::Parser::SourceParser.before_parse_list_callbacks
# YARD::Parser::SourceParser.after_parse_list_callbacks
# YARD::Parser::SourceParser.before_parse_file_callbacks
# YARD::Parser::SourceParser.after_parse_file_callbacks
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
#: ../lib/yard/parser/source_parser.rb:292
#: ../lib/yard/parser/source_parser.rb:321
#: ../lib/yard/parser/source_parser.rb:328
#: ../lib/yard/parser/source_parser.rb:335
#: ../lib/yard/parser/source_parser.rb:342
#: ../lib/yard/parser/source_parser.rb:349
#: ../lib/yard/parser/source_parser.rb:361
#: ../lib/yard/parser/source_parser.rb:384
#: ../lib/yard/parser/source_parser.rb:388
#: ../lib/yard/parser/source_parser.rb:393
#: ../lib/yard/parser/source_parser.rb:397
#: ../lib/yard/parser/source_parser.rb:404
#: ../lib/yard/parser/source_parser.rb:416
#: ../lib/yard/parser/source_parser.rb:460
#: ../lib/yard/parser/source_parser.rb:469
#: ../lib/yard/parser/source_parser.rb:490
#: ../lib/yard/parser/source_parser.rb:497
#: ../lib/yard/parser/source_parser.rb:505
#: ../lib/yard/parser/source_parser.rb:512
msgid "Parser Callbacks"
msgstr "パーサーのコールバック"

# @example Setting global state
#: ../lib/yard/parser/source_parser.rb:231
msgid ""
"SourceParser.before_parse_list do |files, globals|\n"
"  globals.method_count = 0\n"
"end\n"
"SourceParser.after_parse_list do |files, globals|\n"
"  puts \"Found #{globals.method_count} methods\"\n"
"end\n"
"class MyCountHandler < Handlers::Ruby::Base\n"
"  handles :def, :defs\n"
"  process { globals.method_count += 1 }\n"
"end\n"
"YARD.parse\n"
"# Prints: \"Found 37 methods\""
msgstr ""

# @example Installing a simple callback
#: ../lib/yard/parser/source_parser.rb:231
msgid ""
"SourceParser.before_parse_list do |files, globals|\n"
"  puts \"Starting to parse...\"\n"
"end\n"
"YARD.parse('lib/**/*.rb')\n"
"# prints \"Starting to parse...\""
msgstr ""

# @example Using a global callback to cancel parsing
#: ../lib/yard/parser/source_parser.rb:231
msgid ""
"SourceParser.before_parse_list do |files, globals|\n"
"  return false if files.include?('foo.rb')\n"
"end\n"
"\n"
"YARD.parse(['foo.rb', 'bar.rb']) # callback cancels this method\n"
"YARD.parse('bar.rb') # parses normally"
msgstr ""

# @yieldparam [OpenStruct] globals
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
msgid ""
"a global structure to store arbitrary\n"
"state for post processing (see {Handlers::Processor#globals})"
msgstr ""
"後処理用の任意の状態を格納する、globalなデータ(see {Handlers::"
"Processor#globals})"

# @yieldreturn [Boolean]
#: ../lib/yard/parser/source_parser.rb:231
msgid ""
"if the block returns +false+, parsing is\n"
"cancelled."
msgstr "ブロックが +false+ を返す場合、解析処理はキャンセルされる。"

# @example
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:292
msgid "tag|example|Installing a simple callback"
msgstr "簡単なコールバックを実装する"

# @example
#: ../lib/yard/parser/source_parser.rb:231
msgid "tag|example|Setting global state"
msgstr "globalの状態を設定する"

# @example
#: ../lib/yard/parser/source_parser.rb:231
msgid "tag|example|Using a global callback to cancel parsing"
msgstr "解析するのをキャンセルする為にコールバックにglobalを使う"

# @see
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:321
msgid "tag|see|after_parse_list"
msgstr ""

# @see
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
#: ../lib/yard/parser/source_parser.rb:321
msgid "tag|see|before_parse_file"
msgstr ""

# @yieldparam [Array<String>]
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
msgid "tag|yieldparam|files"
msgstr "files"

# @yieldparam [OpenStruct]
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
msgid "tag|yieldparam|globals"
msgstr "globals"

# @yieldparam [Array<String>] files
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
msgid "the list of files that will be parsed."
msgstr "解析されるファイルのリスト。"

# @return [Proc]
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
#: ../lib/yard/parser/source_parser.rb:292
#: ../lib/yard/parser/source_parser.rb:321
msgid "the yielded block"
msgstr "yieldされるブロック。"

# @yield [files, globals]
#: ../lib/yard/parser/source_parser.rb:231
#: ../lib/yard/parser/source_parser.rb:255
msgid ""
"the yielded block is called once before\n"
"parsing all files"
msgstr ""
"yieldされたブロックは\n"
"全てのファイルを解析する前に一度だけ呼び出される。"

# YARD::Parser::SourceParser.after_parse_list
#: ../lib/yard/parser/source_parser.rb:236
msgid ""
"Registers a callback to be called after a list of files is parsed\n"
"via {parse}. The block passed to this method will be called on\n"
"subsequent parse calls."
msgstr ""
"ファイルのリストが {parse} 経由で解析された後で呼び出される為にコールバックを記録する。\n"
"このメソッドの為に渡されるブロックはその後のparse呼び出し上で呼び出される。"

# @example Printing results after parsing occurs
#: ../lib/yard/parser/source_parser.rb:255
msgid ""
"SourceParser.after_parse_list do\n"
"  puts \"Finished parsing!\"\n"
"end\n"
"YARD.parse\n"
"# Prints \"Finished parsing!\" after parsing files"
msgstr ""

# @example
#: ../lib/yard/parser/source_parser.rb:255
msgid "tag|example|Printing results after parsing occurs"
msgstr "解析が終わった後で、結果をプリントする。"

# @see
#: ../lib/yard/parser/source_parser.rb:255
#: ../lib/yard/parser/source_parser.rb:292
msgid "tag|see|before_parse_list"
msgstr ""

# @yieldreturn [void]
#: ../lib/yard/parser/source_parser.rb:255
#: ../lib/yard/parser/source_parser.rb:321
msgid "the return value for the block is ignored."
msgstr "ブロックが無視される為の戻り値"

# YARD::Parser::SourceParser.before_parse_file
#: ../lib/yard/parser/source_parser.rb:260
msgid ""
"Registers a callback to be called before an individual file is parsed.\n"
"The block passed to this method will be called on subsequent parse\n"
"calls."
msgstr ""
"個々のファイルが解析される前に呼び出されるコールバックを記録する\n"
"blockはこのメソッドが続くparse呼び出しで呼び出されるために解析される。"

# YARD::Parser::SourceParser.before_parse_file
#: ../lib/yard/parser/source_parser.rb:264
msgid ""
"To register a callback that is called before the entire list of files\n"
"is processed, see {before_parse_list}."
msgstr ""
"全てのファイルのリストが処理される前に呼び出される\n"
"コールバックを記録する為には、{before_parse_list}参照。"

# @example Installing a simple callback
#: ../lib/yard/parser/source_parser.rb:292
msgid ""
"SourceParser.before_parse_file do |parser|\n"
"  puts \"I'm parsing #{parser.file}\"\n"
"end\n"
"YARD.parse('lib/**/*.rb')\n"
"# prints:\n"
"\"I'm parsing lib/foo.rb\"\n"
"\"I'm parsing lib/foo_bar.rb\"\n"
"\"I'm parsing lib/last_file.rb\""
msgstr ""

# @example Cancel parsing of any test_*.rb files
#: ../lib/yard/parser/source_parser.rb:292
msgid ""
"SourceParser.before_parse_file do |parser|\n"
"  return false if parser.file =~ /^test_.+\\.rb$/\n"
"end"
msgstr ""

# @yieldreturn [Boolean]
#: ../lib/yard/parser/source_parser.rb:292
msgid ""
"if the block returns +false+, parsing for\n"
"the file is cancelled."
msgstr ""
"ブロックが +false+ を返す場合、\n"
"ファイルがキャンセルされる為に解析する。"

# @example
#: ../lib/yard/parser/source_parser.rb:292
msgid "tag|example|Cancel parsing of any test_*.rb files"
msgstr "全てのtest_*.rbファイルの解析をキャンセルする"

# @see
#: ../lib/yard/parser/source_parser.rb:292
msgid "tag|see|after_parse_file"
msgstr ""

# @yieldparam [SourceParser] parser
#: ../lib/yard/parser/source_parser.rb:292
msgid ""
"the parser object that will {#parse}\n"
"the file."
msgstr "ファイルを{#parse}メソッドで解析するパーサーオブジェクト。"

# @yield [parser]
#: ../lib/yard/parser/source_parser.rb:292
msgid ""
"the yielded block is called once before each\n"
"file that is parsed. This might happen many times for a single\n"
"codebase."
msgstr ""
"yieldされるブロックは、それぞれのファイルが解析される前に一度呼び出される。\n"
"これは、単一のコードベースでは何回も起きる可能性がある。"

# YARD::Parser::SourceParser.after_parse_file
#: ../lib/yard/parser/source_parser.rb:297
msgid ""
"Registers a callback to be called after an individual file is parsed.\n"
"The block passed to this method will be called on subsequent parse\n"
"calls."
msgstr ""
"個々のファイルが解析された後で呼び出されるコールバックを登録する。\n"
"このメソッドに渡されたブロックは次のparseメソッドの呼び出しで呼び出される。"

# YARD::Parser::SourceParser.after_parse_file
#: ../lib/yard/parser/source_parser.rb:301
msgid ""
"To register a callback that is called after the entire list of files\n"
"is processed, see {after_parse_list}."
msgstr ""
"ファイルリストが全て処理された後で呼び出される。\n"
"コールバックを記録するには、{after_parse_list}参照。"

# @example Printing the length of each file after it is parsed
#: ../lib/yard/parser/source_parser.rb:321
msgid ""
"SourceParser.after_parse_file do |parser|\n"
"  puts \"#{parser.file} is #{parser.contents.size} characters\"\n"
"end\n"
"YARD.parse('lib/**/*.rb')\n"
"# prints:\n"
"\"lib/foo.rb is 1240 characters\"\n"
"\"lib/foo_bar.rb is 248 characters\""
msgstr ""

# @example
#: ../lib/yard/parser/source_parser.rb:321
msgid "tag|example|Printing the length of each file after it is parsed"
msgstr "tag|example|解析された後でそれぞれのファイルのサイズをプリントする"

# @yieldparam [SourceParser] parser
#: ../lib/yard/parser/source_parser.rb:321
msgid ""
"the parser object that parsed\n"
"the file."
msgstr "ファイルを解析した、パーサーオブジェクト。"

# @yield [parser]
#: ../lib/yard/parser/source_parser.rb:321
msgid ""
"the yielded block is called once after each file\n"
"that is parsed. This might happen many times for a single codebase."
msgstr ""
"yieldされたブロックは解析される個々のファイルの後で一度呼び出される。\n"
"これは単一のコードベースの為に何回も起る可能性がある。"

# @return [Array<Proc>]
#: ../lib/yard/parser/source_parser.rb:328
msgid ""
"the list of callbacks to be called before\n"
"parsing a list of files. Should only be used for testing."
msgstr ""
"ファイルのリストを解析する前に呼び出されるコールバックのリスト。\n"
"検査用にだけ利用されるべきである。"

# @return [Array<Proc>]
#: ../lib/yard/parser/source_parser.rb:335
msgid ""
"the list of callbacks to be called after\n"
"parsing a list of files. Should only be used for testing."
msgstr ""
"ファイルのリストを解析する前に呼び出される為のコールバックのリスト。\n"
"検査用にだけ利用されるべきである。"

# @return [Array<Proc>]
#: ../lib/yard/parser/source_parser.rb:342
msgid ""
"the list of callbacks to be called before\n"
"parsing a file. Should only be used for testing."
msgstr ""
"ファイルが解析する前に呼び出される為のコールバックのリスト。\n"
"検査用にだけ利用されるべきである。"

# @return [Array<Proc>]
#: ../lib/yard/parser/source_parser.rb:349
msgid ""
"the list of callbacks to be called after\n"
"parsing a file. Should only be used for testing."
msgstr ""
"ファイルが解析する前に呼び出される為のコールバックのリスト。\n"
"検査用にだけ利用されるべきである。"

# @param [Array<String>] files
#: ../lib/yard/parser/source_parser.rb:358
msgid "Parses a list of files in a queue."
msgstr "キューのなかのファイルのリストを解析する"

# @param [Array<String>] files
#: ../lib/yard/parser/source_parser.rb:361
msgid "a list of files to queue for parsing"
msgstr "解析用のキューの為のファイルのリスト。"

# @return [String]
#: ../lib/yard/parser/source_parser.rb:384
msgid "the filename being parsed by the parser."
msgstr "パーサーによって解析されているファイル名。"

# @return [Symbol]
#: ../lib/yard/parser/source_parser.rb:388
msgid ""
"the parser type associated with the parser instance.\n"
"This should be set by the {#initialize constructor}."
msgstr ""
"パーサーのインスタンスと共に関連付られるパーサーの型。\n"
"これは、{#initialize constructor}メソッドによって設定されるべきである。"

# @return [OpenStruct]
#: ../lib/yard/parser/source_parser.rb:393
msgid ""
"an open struct containing arbitrary global state\n"
"shared between files and handlers."
msgstr ""
"ファイルとハンドラーとの間で共有される\n"
"任意のグローバルな状態を含んでいるOpenStruct"

# @return [String]
#: ../lib/yard/parser/source_parser.rb:397
msgid "the contents of the file to be parsed"
msgstr "解析されるファイルの内容。"

# @return [SourceParser]
#: ../lib/yard/parser/source_parser.rb:404
msgid "a new instance of SourceParser"
msgstr "ソースパーサーの新しいインスタンス。"

# @overload
#: ../lib/yard/parser/source_parser.rb:404
msgid "tag|overload|initialize"
msgstr ""

# YARD::Parser::SourceParser#parse
#: ../lib/yard/parser/source_parser.rb:412
msgid ""
"The main parser method. This should not be called directly. Instead,\n"
"use the class methods {parse} and {parse_string}."
msgstr ""
"主なパーサーメソッド。これは直接呼ばれるべきではない。\n"
"代わりに、{parse}や{parse_string}クラスメソッドを利用する。"

# @return [Object, nil]
#: ../lib/yard/parser/source_parser.rb:416
msgid "the parser object used to parse the source"
msgstr "ソースを解析する為に利用されるパーサーオブジェクト。"

# @param [String, #read, Object] content
#: ../lib/yard/parser/source_parser.rb:416
msgid "the source file to parse"
msgstr "解析の為のソースファイル。"

# YARD::Parser::SourceParser#tokenize
#: ../lib/yard/parser/source_parser.rb:457
msgid ""
"Tokenizes but does not parse the block of code using the current "
"{#parser_type}"
msgstr ""
"トークナイズする。しかし、\n"
"現在の{#parser_type}メソッドを使用して、コードの入ったブロックは解析しない。"

# YARD::Parser::SourceParser#convert_encoding
#: ../lib/yard/parser/source_parser.rb:468
msgid "Searches for encoding line and forces encoding"
msgstr "エンコーディング行を検索し、エンコーディングを強制する。"

# YARD::Parser::SourceParser#post_process
#: ../lib/yard/parser/source_parser.rb:489
msgid ""
"Runs a {Handlers::Processor} object to post process the parsed statements."
msgstr "解析したステートメントの後処理の為に、{Handlers::Processor}オブジェクトを起動する。"

# YARD::Parser::SourceParser#parser_type_for_filename
#: ../lib/yard/parser/source_parser.rb:502
msgid "Guesses the parser type to use depending on the file extension."
msgstr "ファイル拡張子に応じて使用するパーサーの型を推測する。"

# @return [Symbol]
#: ../lib/yard/parser/source_parser.rb:505
msgid "a parser type that matches the filename"
msgstr "ファイル名の拡張子に応じたパーサータイプ。"

# @param [String] filename
#: ../lib/yard/parser/source_parser.rb:505
msgid "the filename to use to guess the parser type"
msgstr "パーサー型を推測する為に利用するファイル名。"

# YARD::Rake::YardocTask
#: ../lib/yard/rake/yardoc_task.rb:8
msgid "The rake task to run {CLI::Yardoc} and generate documentation."
msgstr "{CLI::Yardoc}を起動する為のrake taskとなり、ドキュメントを生成する。"

# YARD::Rake::YardocTask#name
# YARD::Rake::YardocTask#name=
#: ../lib/yard/rake/yardoc_task.rb:10
msgid "The name of the task"
msgstr "taskの名前"

# @return [String]
#: ../lib/yard/rake/yardoc_task.rb:11
msgid "the task name"
msgstr "task名"

# YARD::Rake::YardocTask#options
# YARD::Rake::YardocTask#options=
#: ../lib/yard/rake/yardoc_task.rb:14
msgid "Options to pass to {CLI::Yardoc}"
msgstr "{CLI::Yardoc}の為のパスの設定"

# @return [Hash]
#: ../lib/yard/rake/yardoc_task.rb:15
msgid "the options passed to the commandline utility"
msgstr "コマンドライン用途の為に渡される設定"

# YARD::Rake::YardocTask#files
# YARD::Rake::YardocTask#files=
#: ../lib/yard/rake/yardoc_task.rb:18
msgid ""
"The Ruby source files (and any extra documentation files separated by '-')\n"
"to process."
msgstr ""
"処理の為のRubyソースファイル(と'-'によって分割された、任意の特別なドキュメン"
"トファイル)"

# @example Task files assignment
#: ../lib/yard/rake/yardoc_task.rb:24
msgid ""
"YARD::Rake::YardocTask.new do |t|\n"
"  t.files   = ['app/**/*.rb', 'lib/**/*.rb', '-', 'doc/FAQ.md', 'doc/Changes."
"md']\n"
"end"
msgstr ""

# @example
#: ../lib/yard/rake/yardoc_task.rb:24
msgid "tag|example|Task files assignment"
msgstr "Taskのファイルを代入する"

# YARD::Rake::YardocTask#before
# YARD::Rake::YardocTask#before=
#: ../lib/yard/rake/yardoc_task.rb:27
msgid "Runs a +Proc+ before the task"
msgstr "taskの前に +Proc+ を起動する。"

# @return [Proc]
#: ../lib/yard/rake/yardoc_task.rb:28
msgid "a proc to call before running the task"
msgstr "task を起動する前に、呼び出される,proc"

# YARD::Rake::YardocTask#after
# YARD::Rake::YardocTask#after=
#: ../lib/yard/rake/yardoc_task.rb:31
msgid "Runs a +Proc+ after the task"
msgstr "taskの後で起動する +Proc+"

# @return [Proc]
#: ../lib/yard/rake/yardoc_task.rb:32
msgid "a proc to call after running the task"
msgstr "taskを起動した後で呼び出される,proc"

# @return [Verifier, Proc]
#: ../lib/yard/rake/yardoc_task.rb:38
msgid ""
"an optional {Verifier} to run against all objects\n"
"being generated. Any object that the verifier returns false for will be\n"
"excluded from documentation. This attribute can also be a lambda."
msgstr ""
"全てのオブジェクトに対して起動するための任意の {Verifier}(認証者)\n"
"verifierがドキュメントから除外される為のfalseを返す任意のオブジェクト\n"
"この属性はlmbdaにもできる。"

# YARD::Rake::YardocTask#initialize
#: ../lib/yard/rake/yardoc_task.rb:41
msgid "Creates a new task with name +name+."
msgstr "+name+ 名を用いる新しいタスクを作成する"

# @yield
#: ../lib/yard/rake/yardoc_task.rb:46
msgid "a block to allow any options to be modified on the task"
msgstr "task上で変更される為に任意のオプションを受け入れる,block"

# @return [YardocTask]
#: ../lib/yard/rake/yardoc_task.rb:46
msgid "a new instance of YardocTask"
msgstr "YardocTaskの新しいインスタンス"

# @yieldparam [YardocTask]
#: ../lib/yard/rake/yardoc_task.rb:46
msgid "tag|yieldparam|_self"
msgstr ""

# @param [String, Symbol] name
#: ../lib/yard/rake/yardoc_task.rb:46
msgid "the name of the rake task"
msgstr "rake taskの名前"

# @yieldparam [YardocTask] _self
#: ../lib/yard/rake/yardoc_task.rb:46
msgid ""
"the task object to allow any parameters\n"
"to be changed."
msgstr "変更される任意のパラメータを受け入れるtask オブジェクト"

# YARD::Rake::YardocTask#define
#: ../lib/yard/rake/yardoc_task.rb:61
msgid "Defines the rake task"
msgstr "rake taskを定義する。"

# YARD::Registry
#: ../lib/yard/registry.rb:6
msgid ""
"The +Registry+ is the centralized data store for all {CodeObjects} created\n"
"during parsing. The storage is a key value store with the object's path\n"
"(see {CodeObjects::Base#path}) as the key and the object itself as the "
"value.\n"
"Object paths must be unique to be stored in the Registry. All lookups for\n"
"objects are done on the singleton Registry instance using the {Registry.at}\n"
"or {Registry.resolve} methods."
msgstr ""
"+Registry+ は解析している間に、\n"
"全ての{CodeObjects}が作成される為の\n"
"集中データストアとなる。\n"
"ストレージは、\n"
"キーのようなオブジェクトパス(see {CodeObjects::Base#path})と\n"
"値のようなオブジェクトを用い、key valueストアとなる。\n"
"オブジェクトパスは、Registryの中で記録される為に固有でなければならない。\n"
"オブジェクト用の全ての検索は、\n"
"{Registry.at} や {Registry.resolve}メソッドによって\n"
"シングルトンレジストリインスタンスの上で行われる。\n"

# YARD::Registry
#: ../lib/yard/registry.rb:13
msgid ""
"== Saving / Loading a Registry\n"
"The registry is saved to a \"yardoc file\" (actually a directory), which "
"can\n"
"be loaded back to perform any lookups. See {Registry.load!} and\n"
"{Registry.save} for information on saving and loading of a yardoc file."
msgstr ""
"== レジストリーをセーブ/ロードする\n"
"レジストリーは\"yardoc file\"(実際はディレクトリ)にセーブされ、\n"
"任意の検索を実行する為に、ロードできる。\n"
"yardocファイルのセーブやロードの情報は、\n"
"{Registry.load!} , {Registry.save}を参照。"

# YARD::Registry
#: ../lib/yard/registry.rb:18
msgid ""
"== Threading Notes\n"
"The registry class is a singleton class that is accessed directly in many\n"
"places across YARD. To mitigate threading issues, YARD (0.6.5+) makes\n"
"the Registry thread local. This means all access to a registry for a "
"specific\n"
"object set must occur in the originating thread."
msgstr ""
"== スレッドの注意\n"
"レジストリークラスは、YARD全体で直接アクセスされるシングルトンクラスとなる。\n"
"スレッドの問題を緩和するには、YARD(0.6.5+)でthread localなレジストリーを作る。\n"
"これはスレッドの中で固有のオブジェクトのグループが生成される、\n"
"レジストリーにアクセスする全てのものを意味する。"

# @example Getting an object by a specific path
#: ../lib/yard/registry.rb:31
msgid "Registry.at('YARD::CodeObjects::Base#docstring')"
msgstr ""

# @example Loading a Registry
#: ../lib/yard/registry.rb:31
msgid ""
"Registry.load!('/path/to/yardocfile') # loads all objects into memory\n"
"Registry.at('YARD::CodeObjects::Base').docstring\n"
"# => \"+Base+ is the superclass of all code objects ...\""
msgstr ""

# @example Performing a lookup on a method anywhere in the inheritance tree
#: ../lib/yard/registry.rb:31
msgid "Registry.resolve(P('YARD::CodeObjects::Base'), '#docstring', true)"
msgstr ""

# @example
#: ../lib/yard/registry.rb:31
msgid "tag|example|Getting an object by a specific path"
msgstr "tag|example|パスによってオブジェクトを取得する"

# @example
#: ../lib/yard/registry.rb:31
msgid "tag|example|Loading the Registry"
msgstr "tag|example|レジストリーをロードする"

# @example
#: ../lib/yard/registry.rb:31
msgid ""
"tag|example|Performing a lookup on a method anywhere in the inheritance tree"
msgstr "tag|example|継承ツリーのどこでもメソッドで検索を実行する"

# YARD::Registry.yardoc_file_for_gem
#: ../lib/yard/registry.rb:41
msgid "Returns the .yardoc file associated with a gem."
msgstr "gemと共に関連した.yardocファイルを返す。"

# YARD::Registry.yardoc_file_for_gem
# YARD::Registry.yardoc_file
# YARD::Registry.yardoc_file=
#: ../lib/yard/registry.rb:51 ../lib/yard/registry.rb:73
#: ../lib/yard/registry.rb:75 ../lib/yard/registry.rb:76
msgid "Getting .yardoc File Locations"
msgstr ".yardocファイルの場所を取得する。"

# @param [String] ver_require
#: ../lib/yard/registry.rb:51
msgid "an optional Gem version requirement"
msgstr "任意のGemのバージョン要求"

# @return [String]
#: ../lib/yard/registry.rb:51
msgid ""
"if +for_writing+ is set to +true+, returns the best\n"
"location suitable to write the .yardoc file. Otherwise, the first\n"
"existing location associated with the gem's .yardoc file."
msgstr ""
"+for_writing+ にtrueをセットした場合、\n"
".yardocファイルを書き込む為に最適な場所を返す。\n"
"若しくは、.yardocファイルに関連づけられた\n"
"既存の場所になる。"

# @return [nil]
#: ../lib/yard/registry.rb:51
msgid ""
"if +for_writing+ is set to false and no yardoc file\n"
"is found, returns nil."
msgstr ""
"+for_writing+ がfalseを設定する場合と、\n"
"yardocファイルが見つからない場合は、nilを返す。"

# @param [Boolean]
#: ../lib/yard/registry.rb:51
msgid "tag|param|for_writing"
msgstr ""

# @param [String]
#: ../lib/yard/registry.rb:51
msgid "tag|param|gem"
msgstr ""

# @param [String]
#: ../lib/yard/registry.rb:51
msgid "tag|param|ver_require"
msgstr ""

# @param [String] gem
#: ../lib/yard/registry.rb:51
msgid "the name of the gem to search for"
msgstr "検索するgemの名前"

# @param [Boolean] for_writing
#: ../lib/yard/registry.rb:51
msgid ""
"whether or not the method should search\n"
"for writable locations"
msgstr "メソッドが書き込み可能な場所を検索するかどうか"

# YARD::Registry.yardoc_file
# YARD::Registry.yardoc_file=
#: ../lib/yard/registry.rb:71
msgid "Gets/sets the yardoc filename"
msgstr "yardocのファイル名を取得/設定する。"

# @see
#: ../lib/yard/registry.rb:73 ../lib/yard/registry.rb:75
#: ../lib/yard/registry.rb:76
msgid "tag|see|DEFAULT_YARDOC_FILE"
msgstr ""

# @return [String]
#: ../lib/yard/registry.rb:73 ../lib/yard/registry.rb:75
#: ../lib/yard/registry.rb:76
msgid "the yardoc filename"
msgstr "yardocのファイル名"

# YARD::Registry.load
#: ../lib/yard/registry.rb:83
msgid "Loads the registry and/or parses a list of files"
msgstr "レジストリのロードやファイルのリストを解析する"

# YARD::Registry.load
# YARD::Registry.load_yardoc
# YARD::Registry.load!
# YARD::Registry.load_all
#: ../lib/yard/registry.rb:97 ../lib/yard/registry.rb:118
#: ../lib/yard/registry.rb:132 ../lib/yard/registry.rb:147
msgid "Loading Data from Disk"
msgstr "ディスクから、データをロードする"

# @example Loads the yardoc file or parses files 'a', 'b' and 'c' (but not both)
#: ../lib/yard/registry.rb:97
msgid "Registry.load(['a', 'b', 'c'])"
msgstr ""

# @example Reparses files 'a' and 'b' regardless of whether yardoc file exists
#: ../lib/yard/registry.rb:97
msgid "Registry.load(['a', 'b'], true)"
msgstr ""

# @param [String, Array] files
#: ../lib/yard/registry.rb:97
msgid ""
"if +files+ is an Array, it should represent\n"
"a list of files that YARD should parse into the registry. If reload is\n"
"set to false and the yardoc file already exists, these files are skipped.\n"
"If files is a String, it should represent the yardoc file to load\n"
"into the registry."
msgstr ""
"+files+が配列の場合、YARDがレジストリーの中を解析するべきファイルのリストを表す。\n"
"reloadがfalseを設定された場合や、yardocファイルが既に存在する場合、\n"
"これらのファイルは、スキップされる。\n"
"ファイルがStringの場合、\n"
"レジストリーの中へロードするyardocファイルを表す。"

# @raise [ArgumentError]
#: ../lib/yard/registry.rb:97
msgid "if files is not a String or Array"
msgstr "ファイルがStringやArrayでない場合"

# @param [Boolean] reparse
#: ../lib/yard/registry.rb:97
msgid ""
"if reparse is false and a yardoc file already\n"
"exists, any files passed in will be ignored."
msgstr ""
"reparseがfalseの場合や、yardocファイルが既に存在する場合、\n"
"オプションの解析されるファイルは、無視される。"

# @example
#: ../lib/yard/registry.rb:97
msgid ""
"tag|example|Loads the yardoc file or parses files 'a', 'b' and 'c' (but not "
"both)"
msgstr ""
"yardocファイルをロードする。又は、'a','b','c'のファイルを解析する。(どちらか"
"だけ行う)"

# @example
#: ../lib/yard/registry.rb:97
msgid ""
"tag|example|Reparses files 'a' and 'b' regardless of whether yardoc file "
"exists"
msgstr ""
"yardocファイルが存在するかどうかにかかわらず、ファイル'a'と'b'を再解析する。"

# @param [Boolean]
#: ../lib/yard/registry.rb:97
msgid "tag|param|reparse"
msgstr ""

# @return [Registry]
#: ../lib/yard/registry.rb:97 ../lib/yard/registry.rb:118
#: ../lib/yard/registry.rb:132 ../lib/yard/registry.rb:147
msgid "the registry object (for chaining)"
msgstr "レジストリオブジェクト(チェーン用)"

# YARD::Registry.load_yardoc
#: ../lib/yard/registry.rb:115
msgid "Loads a yardoc file directly"
msgstr "直接yardocファイルをロードする"

# @param [String] file
#: ../lib/yard/registry.rb:118
msgid "the yardoc file to load."
msgstr "ロードするyardocファイル"

# YARD::Registry.load!
#: ../lib/yard/registry.rb:125
msgid ""
"Loads a yardoc file and forces all objects cached on disk into\n"
"memory. Equivalent to calling {load_yardoc} followed by {load_all}"
msgstr ""
"yardocファイルをロードし、\n"
"メモリの中へディスク上の全てのキャッシュされるオブジェクトを強制する。\n"
"{load_all}に続いて呼び出す{load_yardoc}と同等である。"

# @see
#: ../lib/yard/registry.rb:132 ../lib/yard/registry_store.rb:130
msgid "tag|see|#load_all"
msgstr ""

# @see
#: ../lib/yard/registry.rb:132
msgid "tag|see|#load_yardoc"
msgstr ""

# @param [String] file
#: ../lib/yard/registry.rb:132
msgid "the yardoc file to load"
msgstr "ロードするyardocファイル"

# YARD::Registry.load_all
#: ../lib/yard/registry.rb:139
msgid "Forces all objects cached on disk into memory"
msgstr "メモリの中へディスク上のキャッシュされる全てのオブジェクトを強制する"

# @example Loads all objects from disk
#: ../lib/yard/registry.rb:147
msgid ""
"Registry.load\n"
"Registry.all.count #=> 0\n"
"Registry.load_all\n"
"Registry.all.count #=> 17"
msgstr ""

# @example
#: ../lib/yard/registry.rb:147
msgid "tag|example|Loads all objects from disk"
msgstr "ディスクから全てのオブジェクトをロードする"

# YARD::Registry.save
#: ../lib/yard/registry.rb:155
msgid "Saves the registry to +file+"
msgstr "+file+ をレジストリーにセーブする"

# YARD::Registry.save
# YARD::Registry.delete_from_disk
#: ../lib/yard/registry.rb:158 ../lib/yard/registry.rb:164
msgid "Saving and Deleting Data from Disk"
msgstr "ディスクからデータをセーブ/削除する。"

# @param [String] file
#: ../lib/yard/registry.rb:158
msgid "the yardoc file to save to"
msgstr "セーブされるyardocファイル"

# @return [Boolean]
#: ../lib/yard/registry.rb:158
msgid "true if the file was saved"
msgstr "ファイルがセーブされた場合、trueを返す"

# YARD::Registry.delete_from_disk
#: ../lib/yard/registry.rb:163
msgid "Deletes the yardoc file from disk"
msgstr "ディスクからyardocファイルを削除する"

# YARD::Registry.register
#: ../lib/yard/registry.rb:171
msgid "Registers a new object with the registry"
msgstr "リジストリを用い新しいオブジェクトを記録する"

# YARD::Registry.register
# YARD::Registry.delete
# YARD::Registry.clear
#: ../lib/yard/registry.rb:174 ../lib/yard/registry.rb:182
#: ../lib/yard/registry.rb:188
msgid "Adding and Deleting Objects from the Registry"
msgstr "レジストリから、オブジェクトを追加,削除する。"

# @return [CodeObjects::Base]
#: ../lib/yard/registry.rb:174
msgid "the registered object"
msgstr "記録されたオブジェクト"

# YARD::Registry.delete
#: ../lib/yard/registry.rb:180
msgid "Deletes an object from the registry"
msgstr "レジストリーから、オブジェクトを削除する"

# @param [CodeObjects::Base] object
#: ../lib/yard/registry.rb:182
msgid "the object to remove"
msgstr "削除するオブジェクト"

# YARD::Registry.clear
#: ../lib/yard/registry.rb:187
msgid "Clears the registry"
msgstr "レジストリーを空にする"

# YARD::Registry.each
# YARD::Registry.all
# YARD::Registry.paths
# YARD::Registry.at
# YARD::Registry.[]
# YARD::Registry.root
# YARD::Registry.resolve
# YARD::Registry.partial_resolve
#: ../lib/yard/registry.rb:195 ../lib/yard/registry.rb:211
#: ../lib/yard/registry.rb:226 ../lib/yard/registry.rb:235
#: ../lib/yard/registry.rb:236 ../lib/yard/registry.rb:240
#: ../lib/yard/registry.rb:270 ../lib/yard/registry.rb:368
msgid "Accessing Objects in the Registry"
msgstr "レジストリーの中でオブジェクトにアクセスする"

# YARD::Registry.each
#: ../lib/yard/registry.rb:195
msgid "Iterates over {all} with no arguments"
msgstr "引数無しで{all}を繰り返す。"

# YARD::Registry.all
#: ../lib/yard/registry.rb:200
msgid ""
"Returns all objects in the registry that match one of the types provided\n"
"in the +types+ list (if +types+ is provided)."
msgstr ""
"+types+ リスト(タイプが供給される場合 )\n"
"供給される型の一つにマッチするレジストリーの中でオブジェクトの全てを返す"

# @example Returns all objects
#: ../lib/yard/registry.rb:211
msgid "Registry.all"
msgstr ""

# @example Returns all classes and modules
#: ../lib/yard/registry.rb:211
msgid "Registry.all(:class, :module)"
msgstr ""

# @param [Array<Symbol>] types
#: ../lib/yard/registry.rb:211
msgid ""
"an optional list of types to narrow the\n"
"objects down by. Equivalent to performing a select:\n"
"  +Registry.all.select {|o| types.include(o.type) }+"
msgstr ""
"任意の型のリストを絞り込む。次の選択と同様である。\n"
"  +Registry.all.select {|o| types.include(o.type) }+"

# @example
#: ../lib/yard/registry.rb:211
msgid "tag|example|Returns all classes and modules"
msgstr "全てのクラスとモジュールを返す"

# @example
#: ../lib/yard/registry.rb:211
msgid "tag|example|Returns all objects"
msgstr "全てのオブジェクトを返す"

# @param [Array<String>]
# @param [Array<Symbol>]
#: ../lib/yard/registry.rb:211 ../lib/yard/tags/tag.rb:43
msgid "tag|param|types"
msgstr ""

# @see
#: ../lib/yard/registry.rb:211
msgid "tag|see|CodeObjects::Base#type"
msgstr ""

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/registry.rb:211
msgid "the list of objects found"
msgstr "オブジェクトのリストをみつける"

# YARD::Registry.paths
#: ../lib/yard/registry.rb:224
msgid "Returns the paths of all of the objects in the registry."
msgstr "レジストリーの中の全てのオブジェクトのパスを返す"

# @return [Array<String>]
#: ../lib/yard/registry.rb:226
msgid "all of the paths in the registry."
msgstr "レジストリーの中のパスの全て"

# @param [Boolean]
#: ../lib/yard/registry.rb:226 ../lib/yard/registry_store.rb:80
#: ../lib/yard/registry_store.rb:88
msgid "tag|param|reload"
msgstr ""

# @param [Boolean] reload
#: ../lib/yard/registry.rb:226
msgid "whether to load entire database"
msgstr "データベース全体をロードするかどうか"

# YARD::Registry.at
# YARD::Registry.[]
#: ../lib/yard/registry.rb:231 ../lib/yard/registry.rb:237
msgid "Returns the object at a specific path."
msgstr "固有のパスでオブジェクトを返す"

# @return [CodeObjects::Base]
#: ../lib/yard/registry.rb:235
msgid "the object at path"
msgstr "パスのオブジェクト"

# @param [String, :root] path
#: ../lib/yard/registry.rb:235
msgid ""
"the pathname to look for. If +path+ is +root+,\n"
"returns the {root} object."
msgstr ""
"検索の為のパス名、 +path+ が +root+ の場合\n"
"{root}を返す。"

# YARD::Registry.root
#: ../lib/yard/registry.rb:239
msgid "The root namespace object."
msgstr "rootは名前空間オブジェクトとなる"

# @return [CodeObjects::RootObject]
#: ../lib/yard/registry.rb:240
msgid "the root object in the namespace"
msgstr "namespaceの中のrootオブジェクト"

# YARD::Registry.resolve
#: ../lib/yard/registry.rb:243
msgid ""
"Attempts to find an object by name starting at +namespace+, performing\n"
"a lookup similar to Ruby's method of resolving a constant in a namespace."
msgstr ""
"+namespace+ でnameで始まるオブジェクトが見つかるか試みる\n"
"namespaceの中で定数を解決するのに、Rubyメソッドと同様に検索を実行する。"

# @param [Boolean] inheritance
#: ../lib/yard/registry.rb:270
msgid ""
"Follows inheritance chain (mixins, superclass)\n"
"when performing name resolution if set to +true+."
msgstr ""
"+true+が設定された時、名前解決を実行する、継承のチェーン(mixin,superクラス)"

# @param [Boolean] proxy_fallback
#: ../lib/yard/registry.rb:270
msgid ""
"If +true+, returns a proxy representing\n"
"the unresolved path (namespace + name) if no object is found."
msgstr ""
"+true+の場合やオブジェクトが見つからなかった場合、\n"
"未解決のパス(namespace + name)を表すproxyを返す。"

# @example Looks for instance method #reverse starting from A::B::C
#: ../lib/yard/registry.rb:270
msgid "Registry.resolve(P(\"A::B::C\"), \"#reverse\")"
msgstr ""

# @example Looks for a complex path from a namespace
#: ../lib/yard/registry.rb:270
msgid "Registry.resolve(P('A::B'), 'B::D') # => #<yardoc class A::B::D>"
msgstr "Registry.resolve(P('A::B'), 'B::D') # => #<yardoc class A::B::D>"

# @example Looks for a constant but returns a proxy if not found
#: ../lib/yard/registry.rb:270
msgid ""
"Registry.resolve(P('A::B::C'), 'D', false, true) # => #<yardoc proxy A::B::"
"C::D>"
msgstr ""

# @example Looks for a class method respecting the inheritance tree
#: ../lib/yard/registry.rb:270
msgid "Registry.resolve(myclass, 'mymethod', true)"
msgstr ""

# @example Looks for a constant in the root namespace
#: ../lib/yard/registry.rb:270
msgid "Registry.resolve(nil, 'CONSTANT')"
msgstr ""

# @return [CodeObjects::Proxy]
#: ../lib/yard/registry.rb:270
msgid ""
"a Proxy representing the object if\n"
"+proxy_fallback+ is +true+."
msgstr "+proxy_fallback+ が +true+の場合、オブジェクトを表すproxyとなる。"

# @return [nil]
#: ../lib/yard/registry.rb:270
msgid "if +proxy_fallback+ is +false+ and no object was found."
msgstr "+proxy_fallback+ が +false+ 又は、オブジェクトが見つからなかった場合"

# @example
#: ../lib/yard/registry.rb:270
msgid "tag|example|Looks for a class method respecting the inheritance tree"
msgstr "関連する継承ツリーのクラスメソッドを探す"

# @example
#: ../lib/yard/registry.rb:270
msgid "tag|example|Looks for a complex path from a namespace"
msgstr "namespaceから複雑なパスを検索する"

# @example
#: ../lib/yard/registry.rb:270
msgid "tag|example|Looks for a constant but returns a proxy if not found"
msgstr "定数を探すが、見つからない場合は、proxyを返す。"

# @example
#: ../lib/yard/registry.rb:270
msgid "tag|example|Looks for a constant in the root namespace"
msgstr "root namespaseの中の定数をを探す"

# @example
#: ../lib/yard/registry.rb:270
msgid "tag|example|Looks for instance method #reverse starting from A::B::C"
msgstr "A::B::Cで始まる、インスタンスメソッド#reverseを探す"

# @param [Boolean]
#: ../lib/yard/registry.rb:270
msgid "tag|param|inheritance"
msgstr "継承"

# @param [Boolean]
#: ../lib/yard/registry.rb:270
msgid "tag|param|proxy_fallback"
msgstr ""

# @see
#: ../lib/yard/registry.rb:270
msgid "tag|see|P"
msgstr ""

# @param [String, Symbol] name
#: ../lib/yard/registry.rb:270
msgid ""
"the name (or complex path) to look for from\n"
"+namespace+."
msgstr "+namespace+ から検索する名前(や複雑なパス)"

# @return [CodeObjects::Base]
#: ../lib/yard/registry.rb:270
msgid "the object if it is found"
msgstr "見つかったオブジェクト"

# @param [CodeObjects::NamespaceObject, nil] namespace
#: ../lib/yard/registry.rb:270
msgid ""
"the starting namespace\n"
"(module or class). If +nil+ or +:root+, starts from the {root} object."
msgstr ""
"始まりのnamespace(モジュールやクラス)。\n"
"+nil+ や +:root+ の場合、{root}オブジェクトから始まる。"

# @param [Symbol, nil] type
#: ../lib/yard/registry.rb:270
msgid ""
"the {CodeObjects::Base#type} that the resolved\n"
"object must be equal to. No type checking if nil."
msgstr ""

# YARD::Registry.checksums
# YARD::Registry.checksum_for
#: ../lib/yard/registry.rb:317 ../lib/yard/registry.rb:323
msgid "Managing Source File Checksums"
msgstr "ソースファイルチェックサムを管理する"

# @return [Hash{String => String}]
#: ../lib/yard/registry.rb:317
msgid "a set of checksums for files"
msgstr "ファイル用のチェックサムのグループ"

# @param [String] data
#: ../lib/yard/registry.rb:323
msgid "data to checksum"
msgstr "チェックサムするデータ"

# @return [String]
#: ../lib/yard/registry.rb:323
msgid "the SHA1 checksum for data"
msgstr "データのSHA1チェックサム"

# YARD::Registry.single_object_db
# YARD::Registry.single_object_db=
#: ../lib/yard/registry.rb:330
msgid ""
"Whether or not the Registry storage should load everything into a\n"
"single object database (for disk efficiency), or spread them out\n"
"(for load time efficiency)."
msgstr ""
"レジストリーストレージは単一のオブジェクトのデータベースの中へ\n"
"毎回ロードするか、(ディスク効率の為)\n"
"又は、データベースを展開する。(ロード時間効率の為)"

# YARD::Registry.single_object_db
# YARD::Registry.single_object_db=
# YARD::Registry.proxy_types
#: ../lib/yard/registry.rb:337 ../lib/yard/registry.rb:339
#: ../lib/yard/registry.rb:340 ../lib/yard/registry.rb:346
msgid "Managing Internal State (Advanced / Testing Only)"
msgstr "内部の状態を管理する(Advanced / Testing Only)"

# @note
#: ../lib/yard/registry.rb:337 ../lib/yard/registry.rb:339
#: ../lib/yard/registry.rb:340
msgid ""
"Setting this attribute to nil will offload the decision to\n"
"the {RegistryStore storage adapter}."
msgstr ""
"この属性にnilを設定すると、{RegistryStore storage adapter}の決定をunloadす"
"る。"

# @return [Boolean, nil]
#: ../lib/yard/registry.rb:337 ../lib/yard/registry.rb:339
#: ../lib/yard/registry.rb:340
msgid ""
"if this value is set to nil, the storage\n"
"adapter will decide how to store the data."
msgstr ""
"この値にnilを設定した場合、\n"
"ストレージアダプターがデータを記録する方法を決める。"

# YARD::Registry.proxy_types
#: ../lib/yard/registry.rb:343
msgid ""
"The assumed types of a list of paths. This method is used by CodeObjects::"
"Base"
msgstr ""
"パスのリストの想定される型。このメソッドはCodeObjects::Baseによって利用され"
"る。"

# @deprecated
#: ../lib/yard/registry.rb:346
msgid "The registry no longer globally tracks proxy types."
msgstr ""

# @return [{String => Symbol}]
#: ../lib/yard/registry.rb:346
msgid "a set of unresolved paths and their assumed type"
msgstr "未解決のパスのグループやその想定される型"

# YARD::Registry.instance
#: ../lib/yard/registry.rb:353
msgid "The registry singleton instance."
msgstr "レジストリーのシングルトンインスタンス"

# YARD::Registry.instance
#: ../lib/yard/registry.rb:356
msgid "Legacy Methods"
msgstr "Legacy Methods"

# @return [Registry]
#: ../lib/yard/registry.rb:356
msgid "returns the registry instance"
msgstr "レジストリーインスタンスを返す"

# @deprecated
#: ../lib/yard/registry.rb:356
msgid "use Registry.methodname directly."
msgstr "直接Registry.methodnameを使う"

# YARD::Registry.partial_resolve
#: ../lib/yard/registry.rb:363
msgid "Attempts to resolve a name in a namespace"
msgstr "namespaceの中で名前の解決を試みる"

# @param [String] name
#: ../lib/yard/registry.rb:368
msgid "the name to look for"
msgstr "検索するname"

# @param [CodeObjects::NamespaceObject] namespace
#: ../lib/yard/registry.rb:368
msgid "the starting namespace"
msgstr "始まりのnamespace"

# @param [Symbol, nil] type
#: ../lib/yard/registry.rb:368
msgid ""
"the {CodeObjects::Base#type} that the resolved\n"
"object must be equal to"
msgstr ""

# YARD::Registry.global_yardoc_file
# YARD::Registry.local_yardoc_file
#: ../lib/yard/registry.rb:385 ../lib/yard/registry.rb:395
msgid "Retrieving yardoc File Locations"
msgstr "yardocファイルの場所を取り出す"

# @since
#: ../lib/yard/registry.rb:409 ../lib/yard/registry.rb:414
msgid "0.6.5"
msgstr ""

# YARD::Registry.thread_local_store
# YARD::Registry.thread_local_store=
#: ../lib/yard/registry.rb:409 ../lib/yard/registry.rb:414
msgid "Threading support"
msgstr "スレッドをサポート"

# YARD::RegistryStore
#: ../lib/yard/registry_store.rb:5
msgid "The data store for the {Registry}."
msgstr "{Registry}用のデータストア"

# @see
#: ../lib/yard/registry_store.rb:8
msgid "tag|see|Serializers::YardocSerializer"
msgstr ""

# YARD::Registry.instance
#: ../lib/yard/registry_store.rb:10 ../lib/yard/registry_store.rb:213
#: ../lib/yard/registry_store.rb:250 ../lib/yard/registry_store.rb:291
#: ../lib/yard/serializers/yardoc_serializer.rb:36
msgid "The registry no longer tracks proxy types"
msgstr "レジストリはプロキシタイプの追跡をしない"

# YARD::RegistryStore#checksums
#: ../lib/yard/registry_store.rb:12
msgid "Returns the value of attribute checksums"
msgstr "checksums属性の値を返す"

# @return [RegistryStore]
#: ../lib/yard/registry_store.rb:13
msgid "a new instance of RegistryStore"
msgstr "RegistryStoreの新しいインスタンス"

# YARD::RegistryStore#get
# YARD::RegistryStore#[]
#: ../lib/yard/registry_store.rb:27 ../lib/yard/registry_store.rb:67
msgid "Gets a {CodeObjects::Base} from the store"
msgstr "記録から{CodeObjects::Base}を取得する"

# @return [CodeObjects::Base, nil]
#: ../lib/yard/registry_store.rb:31
msgid "a code object or nil if none is found"
msgstr "コードオブジェクトか見つからない場合はnilを返す"

# @param [String, Symbol] key
#: ../lib/yard/registry_store.rb:31
msgid ""
"the path name of the object to look for.\n"
"If it is empty or :root, returns the {#root} object."
msgstr ""
"検索の為のオブジェクトのパス名。\n"
"空か:rootの場合、{#root}オブジェクトを返す。"

# YARD::RegistryStore#put
# YARD::RegistryStore#[]=
#: ../lib/yard/registry_store.rb:49 ../lib/yard/registry_store.rb:68
msgid "Associates an object with a path"
msgstr "パスと一緒にオブジェクトを関連付ける。"

# @return [CodeObjects::Base]
#: ../lib/yard/registry_store.rb:52
msgid "returns +value+"
msgstr "+value+ を返す"

# @param [CodeObjects::Base] value
#: ../lib/yard/registry_store.rb:52
msgid "the object to store"
msgstr "記録するオブジェクト"

# @param [String, Symbol] key
#: ../lib/yard/registry_store.rb:52
msgid "the path name (:root or '' for root object)"
msgstr "パス名(:rootやrootオブジェクト用の'')"

# YARD::RegistryStore#put
# YARD::RegistryStore#[]=
#: ../lib/yard/registry_store.rb:70
msgid "Deletes an object at a given path"
msgstr "与えられたパスでオブジェクトを削除する"

# YARD::RegistryStore#keys
#: ../lib/yard/registry_store.rb:75
msgid ""
"Gets all path names from the store. Loads the entire database\n"
"if +reload+ is +true+"
msgstr ""
"記録から全てのパス名を取得する。\n"
"+reload+ が +true+ の場合、全体のデータベースをロードする。"

# @param [Boolean] reload
#: ../lib/yard/registry_store.rb:80 ../lib/yard/registry_store.rb:88
msgid ""
"if false, does not load the entire database\n"
"before a lookup."
msgstr "falseの場合、検索の前に全体のデータベースをロードしない"

# @return [Array<Symbol>]
#: ../lib/yard/registry_store.rb:80
msgid "the path names of all the code objects"
msgstr "全てのコードオブジェクトのパス名"

# YARD::RegistryStore#values
#: ../lib/yard/registry_store.rb:83
msgid ""
"Gets all code objects from the store. Loads the entire database\n"
"if +reload+ is +true+"
msgstr ""
"記録から全てのパス名を取得する。\n"
"+reload+ が +true+ の場合、全体のデータベースをロードする。"

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/registry_store.rb:88
msgid "all the code objects"
msgstr "全てのコードオブジェクト"

# @return [Array<String>]
#: ../lib/yard/registry_store.rb:94
msgid ""
"a list of object paths with a given\n"
"{CodeObjects::Base#type}"
msgstr ""

# @param [String] name
#: ../lib/yard/registry_store.rb:94 ../lib/yard/registry_store.rb:103
msgid "the type to look for"
msgstr "型用に検索する型"

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/registry_store.rb:103
msgid ""
"a list of objects with a given\n"
"{CodeObjects::Base#type}"
msgstr ""

# @return [CodeObjects::RootObject]
#: ../lib/yard/registry_store.rb:109
msgid "the root object"
msgstr "rootオブジェクト"

# @param [String, nil] file
#: ../lib/yard/registry_store.rb:113 ../lib/yard/registry_store.rb:130
msgid "the name of the yardoc db to load"
msgstr "ロードするyardoc dbの名前"

# @return [Boolean]
#: ../lib/yard/registry_store.rb:113 ../lib/yard/registry_store.rb:130
msgid "whether the database was loaded"
msgstr "データベースがロードされたかどうか"

# YARD::RegistryStore#load!
#: ../lib/yard/registry_store.rb:124
msgid ""
"Loads the .yardoc file and loads all cached objects into memory\n"
"automatically."
msgstr ""
".yardocファイルをロードしたり、\n"
"全てのキャッシュされたオブジェクトを自動的にメモリの中へロードする。"

# YARD::RegistryStore#load_all
#: ../lib/yard/registry_store.rb:140
msgid "Loads all cached objects into memory"
msgstr "メモリの中へ全てのキャッシュされたオブジェクトをロードする"

# YARD::RegistryStore#save
#: ../lib/yard/registry_store.rb:160
msgid "Saves the database to disk"
msgstr "ディスクにデータベースをセーブする"

# @param [String, nil] file
#: ../lib/yard/registry_store.rb:164
msgid "if supplied, the name of the file to save to"
msgstr "指定された場合、セーブするファイルの名前となる"

# @param [Boolean] merge
#: ../lib/yard/registry_store.rb:164
msgid ""
"if true, merges the data in memory with the\n"
"data on disk, otherwise the data on disk is deleted."
msgstr ""
"trueの場合、ディスク上のデータと共にメモリの中のデータをマージする。\n"
"そうでなければ、ディスク上のデータは削除される。"

# @param [Boolean]
#: ../lib/yard/registry_store.rb:164
msgid "tag|param|merge"
msgstr ""

# @return [Boolean]
#: ../lib/yard/registry_store.rb:164
msgid "whether the database was saved"
msgstr "データベースがセーブされるかどうか"

# YARD::RegistryStore#destroy
#: ../lib/yard/registry_store.rb:186
msgid "Deletes the .yardoc database on disk"
msgstr "ディスク上のデータベースの.yardocの削除"

# @param [Boolean] force
#: ../lib/yard/registry_store.rb:192
msgid ""
"if force is not set to true, the file/directory\n"
"will only be removed if it ends with .yardoc. This helps with\n"
"cases where the directory might have been named incorrectly."
msgstr ""
"forceにtrueが設定されず、そのファイルの末尾に.yardocが付く場合、\n"
"ファイル/ディレクトリは削除される。\n"
"これは、ディレクトリが間違って名付けられた場合、役立つだろう。"

# @param [Boolean]
#: ../lib/yard/registry_store.rb:192
msgid "tag|param|force"
msgstr ""

# @return [Boolean]
#: ../lib/yard/registry_store.rb:192
msgid ""
"true if the .yardoc database was deleted, false\n"
"otherwise."
msgstr ""
".yardocデータベースが削除された場合、true。\n"
"それ以外はfalse。"

# YARD::Serializers::Base
#: ../lib/yard/serializers/base.rb:4
msgid ""
"The abstract base serializer. Serializers allow templates to be\n"
"rendered to various endpoints. For instance, a {FileSystemSerializer}\n"
"would allow template contents to be written to the filesystem"
msgstr ""
"これは抽象的なベースのシリアライザとなる。\n"
"シリアライザは、様々なエンドポイントで表示される\n"
"テンプレートを受け入れる。\n"
"例えば、{FileSystemSerializer}は、\n"
"ファイルシステムに書かれる内容のテンプレートを受け入れる。"

# YARD::Serializers::Base
#: ../lib/yard/serializers/base.rb:8
msgid ""
"To implement a custom serializer, override the following methods:\n"
"* {#serialize}\n"
"* {#serialized_path}"
msgstr ""
"カスタムシリアライザを実装するには、次のメソッドを上書きする。:\n"
"* {#serialize}\n"
"* {#serialized_path}"

# YARD::Serializers::Base
#: ../lib/yard/serializers/base.rb:12
msgid ""
"Optionally, a serializer can implement before and after filters:\n"
"* {#before_serialize}\n"
"* {#after_serialize}"
msgstr ""
"任意で、シリアライザはフィルターの前後に実装できる。:\n"
"* {#before_serialize}\n"
"* {#after_serialize}"

# @abstract
#: ../lib/yard/serializers/base.rb:16
msgid "Override this class to implement a custom serializer."
msgstr "カスタムシリアライザを実装する為に、このクラスを上書きする。"

# YARD::Serializers::Base#options
#: ../lib/yard/serializers/base.rb:18
msgid ""
"All serializer options are saved so they can be passed to other serializers."
msgstr ""
"全てのシリアライザのオプションはセーブされるので、他のシリアライザに渡す事が"
"出来る。"

# @return [SymbolHash]
#: ../lib/yard/serializers/base.rb:20
msgid "the serializer options"
msgstr "シリアライザのオプション"

# YARD::Serializers::Base#initialize
#: ../lib/yard/serializers/base.rb:25
msgid "Creates a new serializer with options"
msgstr "オプションと共に新しいシリアライザを作成する。"

# YARD::Serializers::Base#initialize
#: ../lib/yard/serializers/base.rb:27
msgid "Creating a New Serializer"
msgstr "新しいシリアライザを作成する。"

# @param [Hash] opts
#: ../lib/yard/serializers/base.rb:27
msgid "the options to assign to {#options}"
msgstr "{#options}メソッドに割り当てるオプション"

# YARD::Serializers::Base#serialize
#: ../lib/yard/serializers/base.rb:34
msgid "Serializes an object."
msgstr "シリアライズするオブジェクト"

# YARD::Serializers::Base#serialize
# YARD::Serializers::Base#serialized_path
# YARD::Serializers::Base#exists?
#: ../lib/yard/serializers/base.rb:41 ../lib/yard/serializers/base.rb:50
#: ../lib/yard/serializers/base.rb:61
msgid "Serializing an Object"
msgstr "シリアライズするオブジェクト"

# @abstract
#: ../lib/yard/serializers/base.rb:41
msgid ""
"This method should implement the logic that serializes\n"
"+data+ to the respective endpoint. This method should also call\n"
"the before and after callbacks {#before_serialize} and {#after_serialize}"
msgstr ""
"このメソッドはそれぞれのエンドポイントに +data+ をシリアライズするロジック"
"を\n"
"実装するべきである。\n"
"また、このメソッドは前後に{#before_serialize} と {#after_serialize}の\n"
"コールバックも呼び出すべきである。"

# @param [String] data
#: ../lib/yard/serializers/base.rb:41
msgid "the contents that should be serialized"
msgstr "シリアライズされるべき内容"

# @param [CodeObjects::Base, String] object
#: ../lib/yard/serializers/base.rb:41
msgid ""
"the object to serialize the\n"
"data for. The object can also be a string (for non-object serialization)"
msgstr ""
"オブジェクトのデータをシリアライズするオブジェクト、\n"
"このオブジェクトは文字列にもできる。(非オブジェクトをシリアライズする場合)"

# YARD::Serializers::Base#serialized_path
#: ../lib/yard/serializers/base.rb:44
msgid "The serialized path of an object"
msgstr "シリアライズされるオブジェクトのパス"

# @abstract
#: ../lib/yard/serializers/base.rb:50
msgid ""
"This method should return the path of the object on the\n"
"endpoint. For instance, for a file serializer, this should return\n"
"the filename that represents the object on disk."
msgstr ""
"このメソッドは、エンドポイント上のオブジェクトのパスを返す。\n"
"例えば、ファイルシリアライザは、ディスクの中のそのオブジェクトを表すファイル"
"名を返す。"

# @param [CodeObjects::Base] object
#: ../lib/yard/serializers/base.rb:50
msgid "the object to return a path for"
msgstr "パスを返す為のオブジェクト"

# @return [String]
#: ../lib/yard/serializers/base.rb:50
msgid "the serialized path of an object"
msgstr "シリアライズされたオブジェクトのパス"

# YARD::Serializers::Base#exists?
#: ../lib/yard/serializers/base.rb:53
msgid "Returns whether an object has been serialized"
msgstr "シリアライズされたオブジェクトかどうかを返す"

# @abstract
#: ../lib/yard/serializers/base.rb:61
msgid ""
"This method should return whether the endpoint already exists.\n"
"For instance, a file system serializer would check if the file exists\n"
"on disk. You will most likely use +#basepath+ and {#serialized_path} to\n"
"get the endpoint's location."
msgstr ""
"このメソッドは既にエンドポイントが存在するかどうかを返す。\n"
"例えば、ファイルがディスク上に存在する場合、\n"
"ファイルシステムシリアライザは、このチェックを行うだろう。\n"
"あなたは、恐らくエンドポイントの場所を取得する為に、\n"
"+#basepath+ や {#serialized_path} メソッドを使うだろう。"

# @param [CodeObjects::Base] object
#: ../lib/yard/serializers/base.rb:61
msgid "the object to check existence of"
msgstr "存在するかチェックするオブジェクト"

# @return [Boolean]
#: ../lib/yard/serializers/base.rb:61
msgid "whether the endpoint exists."
msgstr "エンドポイントが存在するかどうか"

# YARD::Serializers::Base#before_serialize
#: ../lib/yard/serializers/base.rb:66
msgid "Called before serialization."
msgstr "シリアライズする前に呼び出される"

# YARD::Serializers::Base#before_serialize
# YARD::Serializers::Base#after_serialize
#: ../lib/yard/serializers/base.rb:70 ../lib/yard/serializers/base.rb:77
msgid "Callbacks"
msgstr ""

# @abstract
#: ../lib/yard/serializers/base.rb:70
msgid ""
"Should run code before serialization. Should return false\n"
"if serialization should not occur."
msgstr ""
"シリアライズする前にコードを起動する。\n"
"シリアライズしても何も存在しない場合、falseを返す。"

# @return [Boolean]
#: ../lib/yard/serializers/base.rb:70
msgid "whether or not serialization should occur"
msgstr "シリアライズが存在するかどうか"

# YARD::Serializers::Base#after_serialize
#: ../lib/yard/serializers/base.rb:73
msgid "Called after serialization."
msgstr "後で呼び出されるシリアライズ"

# @abstract
#: ../lib/yard/serializers/base.rb:77
msgid "Should run code after serialization."
msgstr "後でシリアライズのコードを起動する"

# @param [String] data
#: ../lib/yard/serializers/base.rb:77
msgid "the data that was serialized."
msgstr "シリアライズされたデータ"

# YARD::Serializers::FileSystemSerializer
#: ../lib/yard/serializers/file_system_serializer.rb:4
msgid "Implements a serializer that reads from and writes to the filesystem."
msgstr "ファイルシステムに読み書き込みするシリアライザを実装する。"

# YARD::Serializers::FileSystemSerializer#basepath
#: ../lib/yard/serializers/file_system_serializer.rb:6
msgid "The base path to write data to."
msgstr "データに書き込む為のベースパス"

# @return [String]
#: ../lib/yard/serializers/file_system_serializer.rb:7
msgid "a base path"
msgstr "ベースパス"

# YARD::Serializers::FileSystemSerializer#extension
#: ../lib/yard/serializers/file_system_serializer.rb:14
msgid "The extension of the filename (defaults to +html+)"
msgstr "ファイル名の拡張子(デフォルトは +html+ )"

# @return [String]
#: ../lib/yard/serializers/file_system_serializer.rb:16
msgid "the extension of the file. Empty string for no extension."
msgstr "ファイルの拡張子。拡張子無しは空文字"

# YARD::Serializers::FileSystemSerializer#initialize
#: ../lib/yard/serializers/file_system_serializer.rb:23
msgid "Creates a new FileSystemSerializer with options"
msgstr "オプションと共に、新しいFileSystemSerializerを作成する。"

# @return [FileSystemSerializer]
#: ../lib/yard/serializers/file_system_serializer.rb:27
msgid "a new instance of FileSystemSerializer"
msgstr "FileSystemSerializerの新しいインスタンス"

# YARD::Serializers::FileSystemSerializer#serialize
#: ../lib/yard/serializers/file_system_serializer.rb:34
msgid ""
"Serializes object with data to its serialized path (prefixed by the "
"+#basepath+)."
msgstr ""
"パス(+#basepath+ がプレフィックスされる)をシリアライズする為、\n"
"データと共に、オブジェクトをシリアライズする。"

# @return [String]
#: ../lib/yard/serializers/file_system_serializer.rb:36
msgid "the written data (for chaining)"
msgstr "書き込まれるデータ(チェーン用)"

# YARD::Serializers::FileSystemSerializer#serialized_path
#: ../lib/yard/serializers/file_system_serializer.rb:43
msgid "Implements the serialized path of a code object."
msgstr "コードオブジェクトのシリアライズされるパスを実装する。"

# @return [String]
#: ../lib/yard/serializers/file_system_serializer.rb:48
msgid ""
"if object is a String, returns\n"
"object, otherwise the path on disk (without the basepath)."
msgstr ""
"オブジェクトがStringの場合、オブジェクトを返し、\n"
"それ以外は、ディスク上のパスを返す。(basepathを含まない)"

# @param [CodeObjects::Base, CodeObjects::ExtraFileObject, String] object
#: ../lib/yard/serializers/file_system_serializer.rb:48
msgid ""
"the object to get a path for. The path of a string is the string itself."
msgstr "パスを取得する為のオブジェクト。文字列のパスはその文字列自身を返す。"

# YARD::Serializers::FileSystemSerializer#exists?
#: ../lib/yard/serializers/file_system_serializer.rb:66
msgid "Checks the disk for an object and returns whether it was serialized."
msgstr ""
"オブジェクト用にディスクをチェックしたり、シリアライズされたかどうか返す。"

# @param [CodeObjects::Base] object
#: ../lib/yard/serializers/file_system_serializer.rb:69
msgid "the object to check"
msgstr "チェックするオブジェクト"

# @return [Boolean]
#: ../lib/yard/serializers/file_system_serializer.rb:69
msgid "whether an object has been serialized to disk"
msgstr "オブジェクトが既にディスクにシリアライズされているかどうか"

# YARD::Serializers::FileSystemSerializer#encode_path_components
#: ../lib/yard/serializers/file_system_serializer.rb:76
msgid ""
"Remove special chars from filenames.\n"
"Windows disallows \\ / : * ? \" < > | but we will just remove any\n"
"non alphanumeric (plus period, underscore and dash)."
msgstr ""

# YARD::Serializers::ProcessSerializer
#: ../lib/yard/serializers/process_serializer.rb:4
msgid "Serializes an object to a process (like less)"
msgstr "処理の為のオブジェクトをシリアライズする。(lessのような)"

# @example Serializing to a pager (less)
#: ../lib/yard/serializers/process_serializer.rb:8
msgid ""
"serializer = ProcessSerializer.new('less')\n"
"serializer.serialize(object, \"data!\")"
msgstr ""

# @example
#: ../lib/yard/serializers/process_serializer.rb:8
msgid "tag|example|Serializing to a pager (less)"
msgstr "ページャーをシリアライズする(less)"

# YARD::Serializers::ProcessSerializer#initialize
#: ../lib/yard/serializers/process_serializer.rb:10
msgid "Creates a new ProcessSerializer for the shell command +cmd+"
msgstr "シェルコマンド +cmd+ 用に新しいProcessSerializerを作成する。"

# @return [ProcessSerializer]
#: ../lib/yard/serializers/process_serializer.rb:12
msgid "a new instance of ProcessSerializer"
msgstr "ProcessSerializerの新しいインスタンス"

# @param [String]
#: ../lib/yard/serializers/process_serializer.rb:12
msgid "tag|param|cmd"
msgstr ""

# @param [String] cmd
#: ../lib/yard/serializers/process_serializer.rb:12
msgid "the command that will accept data on stdin"
msgstr "標準入力上でデータを受け入れるコマンド"

# YARD::Serializers::ProcessSerializer#serialize
#: ../lib/yard/serializers/process_serializer.rb:17
msgid ""
"Overrides serialize behaviour and writes data to standard input\n"
"of the associated command"
msgstr ""
"シリアライズの挙動を上書きし、\n"
"関連付けられたコマンドの標準入力にデータを書き込む。"

# YARD::Serializers::StdoutSerializer
#: ../lib/yard/serializers/stdout_serializer.rb:4
msgid "A serializer that writes data to standard output."
msgstr "標準出力にデータを書くシリアライザ"

# YARD::Serializers::StdoutSerializer#initialize
#: ../lib/yard/serializers/stdout_serializer.rb:6
msgid "Creates a serializer to print text to stdout"
msgstr "標準出力にテキストをプリントするシリアライザを作成する。"

# @return [StdoutSerializer]
#: ../lib/yard/serializers/stdout_serializer.rb:9
msgid "a new instance of StdoutSerializer"
msgstr "StdoutSerializerの新しいインスタンス"

# @param [Fixnum, nil] wrap
#: ../lib/yard/serializers/stdout_serializer.rb:9
msgid ""
"if wrap is a number, wraps text to +wrap+\n"
"columns, otherwise no wrapping is done."
msgstr ""
"wrapが数字の場合、+wrap+ カラムにテキストをラップする。\n"
"それ以外では、ラップは行わない。"

# @param [Fixnum, nil]
#: ../lib/yard/serializers/stdout_serializer.rb:9
msgid "tag|param|wrap"
msgstr ""

# YARD::Serializers::StdoutSerializer#serialize
#: ../lib/yard/serializers/stdout_serializer.rb:14
msgid "Overrides serialize behaviour to write data to standard output"
msgstr "標準出力にデータを書き込む為にシリアライズの挙動を上書きする。"

# YARD::Serializers::StdoutSerializer#word_wrap
#: ../lib/yard/serializers/stdout_serializer.rb:21
msgid "Wraps text to a specific column length"
msgstr "特定のカラムの長さにテキストをラップする。"

# @param [Fixnum]
#: ../lib/yard/serializers/stdout_serializer.rb:25
msgid "tag|param|length"
msgstr ""

# @param [Fixnum] length
#: ../lib/yard/serializers/stdout_serializer.rb:25
msgid "the column length to wrap to"
msgstr "ラップの為のカラムの長さ"

# @param [String] text
#: ../lib/yard/serializers/stdout_serializer.rb:25
msgid "the text to wrap"
msgstr "ラップされるテキスト"

# @return [String]
#: ../lib/yard/serializers/stdout_serializer.rb:25
msgid "the wrapped text"
msgstr "ラップされたテキスト"

# YARD::StubProxy
#: ../lib/yard/serializers/yardoc_serializer.rb:3
msgid "Stubs marshal dumps and acts a delegate class for an object by path"
msgstr ""
"引抜き、選別し、出力する。オブジェクトがパスによって委譲クラスのように振る舞"
"う"

# @return [StubProxy]
#: ../lib/yard/serializers/yardoc_serializer.rb:12
msgid "a new instance of StubProxy"
msgstr "StubProxyの新しいインスタンス"

# @return [YardocSerializer]
#: ../lib/yard/serializers/yardoc_serializer.rb:30
msgid "a new instance of YardocSerializer"
msgstr "YardocSerializerの新しいインスタンス"

# YARD::Server.register_static_path
#: ../lib/yard/server.rb:4
msgid "Registers a static path to be used in static asset lookup."
msgstr "静的な資源の検索の中で利用される静的パスを記録する。"

# @param [String] path
#: ../lib/yard/server.rb:7
msgid "the pathname to register"
msgstr "記録する為のパス名"

# YARD::Server::FinishRequest
#: ../lib/yard/server/adapter.rb:5
msgid ""
"Short circuits a request by raising an error. This exception is caught\n"
"by {Commands::Base#call} to immediately end a request and return a response."
msgstr ""
"エラーを上げることによってリクエストを省く。\n"
"この例外はすぐに、リクエストの終了とレスポンスを返す為に\n"
"{Commands::Base#call} によってキャッチされる。"

# YARD::Server::NotFoundError
#: ../lib/yard/server/adapter.rb:9
msgid ""
"Raises an error if a resource is not found. This exception is caught by\n"
"{Commands::Base#call} to immediately end a request and return a 404 "
"response\n"
"code. If a message is provided, the body is set to the exception message."
msgstr ""
"リソースが見つからない場合、エラーを上げる。\n"
"この例外は、すぐにリクエストの終りと404レスポンスコードを返す為に\n"
"{Commands::Base#call}によってキャッチされる。\n"
"メッセージが提供される場合、本体に、例外メッサージが設定される。"

# YARD::Server::Adapter
#: ../lib/yard/server/adapter.rb:14
msgid ""
"This class implements the bridge between the {Router} and the server\n"
"backend for a specific server type. YARD implements concrete adapters\n"
"for WEBrick and Rack respectively, though other adapters can be made\n"
"for other server architectures."
msgstr ""
"このクラスは {Router} と固有のサーバータイプ用にサーバーバックエンドの間の\n"
"ブリッジを実装する。\n"
"YARDはWEBrickとRackそれぞれに\n"
"具体的なアダプターを実装するけれども、\n"
"他のアダプターを、他のサーバーアーキテクチャ用に作る事も出来る。"

# YARD::Server::Adapter
#: ../lib/yard/server/adapter.rb:19
msgid ""
"== Subclassing Notes\n"
"To create a concrete adapter class, implement the {#start} method to\n"
"initiate the server backend."
msgstr ""
"== サブクラス化する注意\n"
"具体的なアダプタークラスを作成するには、\n"
"サーバーバックエンドを開始する為に{#start}メソッドを実装する。"

# @return [String]
#: ../lib/yard/server/adapter.rb:27
msgid ""
"the location where static files are located, if any.\n"
"To set this field on initialization, pass +:DocumentRoot+ to the\n"
"+server_opts+ argument in {#initialize}"
msgstr ""
"任意で、スタティックファイルが示される場所。\n"
"初期にこのフィールドを設定するには、\n"
"{#initialize}メソッドの中の +server_opts+ 引数に\n"
"+:DocumentRoot+ を渡す。"

# @see LibraryVersion
#: ../lib/yard/server/adapter.rb:32
msgid "LibraryVersion for information on building a list of libraries"
msgstr ""

# @return [Hash{String=>Array<LibraryVersion>}]
#: ../lib/yard/server/adapter.rb:32
msgid "a map of libraries."
msgstr "ライブラリのマップ"

# @see
#: ../lib/yard/server/adapter.rb:32
msgid "tag|see|#add_library"
msgstr ""

# @see
#: ../lib/yard/server/adapter.rb:32 ../lib/yard/server/library_version.rb:105
#: ../lib/yard/server/library_version.rb:111
msgid "tag|see|LibraryVersion"
msgstr ""

# @return [Hash]
#: ../lib/yard/server/adapter.rb:36
msgid ""
"options passed and processed by adapters. The actual\n"
"options mostly depend on the adapters themselves."
msgstr ""
"アダプターによって渡され、処理されたoptions。\n"
"実際のoptionsの大抵は、アダプター自身に依存する。"

# @return [Hash]
#: ../lib/yard/server/adapter.rb:40
msgid ""
"a set of options to pass to the server backend. Note\n"
"that +:DocumentRoot+ also sets the {#document_root}."
msgstr ""
"サーバーのバックエンドに渡す為のoptionsのグループ\n"
"次の事に留意する。 +:DocumentRoot+ は {#document_root} にも設定する。"

# @return [Router]
#: ../lib/yard/server/adapter.rb:43
msgid "the router object used to route URLs to commands"
msgstr "コマンドにURLを送る為に利用された、routerオブジェクト"

# YARD::Server::Adapter.setup
#: ../lib/yard/server/adapter.rb:46
msgid "Performs any global initialization for the adapter."
msgstr "アダプター用に任意で全体の初期化を実行する。"

# @note
#: ../lib/yard/server/adapter.rb:48 ../lib/yard/server/adapter.rb:56
msgid "If you subclass this method, make sure to call +super+."
msgstr ""
"あなたがこのメソッドをサブクラス化する場合、\n"
"+super+ を呼び出すか確認する事。"

# YARD::Server::Adapter.shutdown
#: ../lib/yard/server/adapter.rb:54
msgid "Performs any global shutdown procedures for the adapter."
msgstr "任意で全体的なアダプター用の手続きのシャットダウンを実行する。"

# YARD::Server::Adapter#initialize
#: ../lib/yard/server/adapter.rb:62
msgid "Creates a new adapter object"
msgstr "新しいアダプターオブジェクトを作成する。"

# @param [Hash{String=>Array<LibraryVersion>}] libs
#: ../lib/yard/server/adapter.rb:71
msgid ""
"a list of libraries,\n"
"see {#libraries} for formulating this list."
msgstr ""
"ライブラリのリスト、\n"
"このリストを公式化する為には、{#librathries}を参照。"

# @return [Adapter]
#: ../lib/yard/server/adapter.rb:71
msgid "a new instance of Adapter"
msgstr "アダプターの新しいインスタンス"

# @param [Hash] opts
#: ../lib/yard/server/adapter.rb:71
msgid "extra options to pass to the adapter"
msgstr "アダプターに渡す為の追加のoptions"

# @param [Hash{String=>Array<LibraryVersion>}]
#: ../lib/yard/server/adapter.rb:71
msgid "tag|param|libs"
msgstr ""

# YARD::Server::Adapter#add_library
#: ../lib/yard/server/adapter.rb:85
msgid "Adds a library to the {#libraries} mapping for a given library object."
msgstr ""
"与えられたライブラリオブジェクト用の{#libraries}マッピングにライブラリを追加"
"する。"

# @param [LibraryVersion] library
#: ../lib/yard/server/adapter.rb:88
msgid "a library to add"
msgstr "追加する為のライブラリ"

# @example Adding a new library to an adapter
#: ../lib/yard/server/adapter.rb:88
msgid ""
"adapter.add_library LibraryVersion.new('mylib', '1.0', '/path/to/.yardoc')"
msgstr ""

# @example
#: ../lib/yard/server/adapter.rb:88
msgid "tag|example|Adding a new library to an adapter"
msgstr "アダプターに新しいライブラリを追加する。"

# YARD::Server::Adapter#start
#: ../lib/yard/server/adapter.rb:94
msgid "Implement this method to connect your adapter to your server."
msgstr ""
"あなたのサーバーにあなたのアダプターを接続する為に、このメソッドを実装する。"

# YARD::Server::Commands::Base
#: ../lib/yard/server/commands/base.rb:7
msgid ""
"This is the base command class used to implement custom commands for\n"
"a server. A command will be routed to by the {Router} class and return\n"
"a Rack-style response."
msgstr ""
"これは、サーバー用にカスタムコマンドを実装する為に、\n"
"利用されるベースコマンドクラスである。\n"
"コマンドは、{Router}クラスによって送られ、Rackスタイルのレスポンスを返す。"

# YARD::Server::Commands::Base
#: ../lib/yard/server/commands/base.rb:11
msgid ""
"== Attribute Initializers\n"
"All attributes can be initialized via options passed into the {#initialize}\n"
"method. When creating a custom command, the {Adapter#options} will\n"
"automatically be mapped to attributes by the same name on your class."
msgstr ""
"== 初期化子の属性\n"
"全ての属性は、{#initialize}メソッドへ渡されたoptions経由でイニシャライズされ"
"る。\n"
"カスタムメソッドが作成される時、{Adapter#options}メソッドは、\n"
"あなたのクラスの属性と同じ名前で自動的にマッピングされるだろう。"

# YARD::Server::Commands::Base
#: ../lib/yard/server/commands/base.rb:16
msgid ""
"  class MyCommand < Base\n"
"    attr_accessor :myattr\n"
"  end"
msgstr ""

# YARD::Server::Commands::Base
#: ../lib/yard/server/commands/base.rb:20
msgid "  Adapter.new(libs, {:myattr => 'foo'}).start"
msgstr ""

# YARD::Server::Commands::Base
#: ../lib/yard/server/commands/base.rb:22
msgid "  # when a request comes in, cmd.myattr == 'foo'"
msgstr ""

# YARD::Server::Commands::Base
#: ../lib/yard/server/commands/base.rb:24
msgid ""
"== Subclassing Notes\n"
"To implement a custom command, override the {#run} method, not {#call}.\n"
"In your implementation, you should set the body and status for requests.\n"
"See details in the +#run+ method documentation."
msgstr ""
"== サブクラス化する時の注意\n"
"カスタムコマンドを実装するには、{#run}メソッドを上書きする({#call}メソッドで"
"はない)。\n"
"あなたの実装で、あなたがボディと、リクエスト用のステータスを設定するべきであ"
"る。\n"
"詳細は +#run+ メソッドのドキュメントを参照。"

# YARD::Server::Commands::Base
#: ../lib/yard/server/commands/base.rb:29
msgid ""
"Note that if your command deals directly with libraries, you should\n"
"consider subclassing the more specific {LibraryCommand} class instead."
msgstr ""
"次の事に留意する。あなたのコマンドが\n"
"直接ライブラリを用い処理する場合、代わりに、\n"
"サブクラス化する{LibraryCommand}クラスの詳細を考慮するべきである。"

# YARD::Server::Commands::Base#command_options
# YARD::Server::Commands::Base#command_options=
# YARD::Server::Commands::Base#adapter
# YARD::Server::Commands::Base#adapter=
# YARD::Server::Commands::Base#caching
# YARD::Server::Commands::Base#caching=
#: ../lib/yard/server/commands/base.rb:37
#: ../lib/yard/server/commands/base.rb:40
#: ../lib/yard/server/commands/base.rb:43
msgid "Basic Command and Adapter Options"
msgstr "基本的なコマンドとアダプターオプション"

# @return [Hash]
#: ../lib/yard/server/commands/base.rb:37
msgid "the options passed to the command's constructor"
msgstr "コマンドのコンストラクタに渡されたoptions"

# @return [Adapter]
#: ../lib/yard/server/commands/base.rb:40
msgid "the server adapter"
msgstr "サーバーアダプター"

# @return [Boolean]
#: ../lib/yard/server/commands/base.rb:43
msgid "whether to cache"
msgstr "キャッシュするかどうか"

# YARD::Server::Commands::Base#request
# YARD::Server::Commands::Base#request=
# YARD::Server::Commands::Base#path
# YARD::Server::Commands::Base#path=
# YARD::Server::Commands::Base#headers
# YARD::Server::Commands::Base#headers=
# YARD::Server::Commands::Base#status
# YARD::Server::Commands::Base#status=
# YARD::Server::Commands::Base#body
# YARD::Server::Commands::Base#body=
#: ../lib/yard/server/commands/base.rb:48
#: ../lib/yard/server/commands/base.rb:51
#: ../lib/yard/server/commands/base.rb:54
#: ../lib/yard/server/commands/base.rb:57
#: ../lib/yard/server/commands/base.rb:60
msgid "Attributes Set Per Request"
msgstr "リクエスト毎のグループを属性化する。"

# @return [Request]
#: ../lib/yard/server/commands/base.rb:48
msgid "request object"
msgstr "オブジェクトのリクエスト"

# @return [String]
#: ../lib/yard/server/commands/base.rb:51
msgid "the path after the command base URI"
msgstr "コマンドのベースURIの後で返す、パス"

# @return [Hash{String => String}]
#: ../lib/yard/server/commands/base.rb:54
msgid "response headers"
msgstr "ヘッダーのレスポンス"

# @return [Numeric]
#: ../lib/yard/server/commands/base.rb:57
msgid "status code. Defaults to 200 per request"
msgstr "コードの状態。デフォルトで200リクエスト毎。"

# @return [String]
#: ../lib/yard/server/commands/base.rb:60
msgid "the response body. Defaults to empty string."
msgstr "ボディのレスポンス。デフォルトでは空の文字列になる。"

# YARD::Server::Commands::Base#initialize
#: ../lib/yard/server/commands/base.rb:65
msgid ""
"Creates a new command object, setting attributes named by keys\n"
"in the options hash. After initialization, the options hash\n"
"is saved in {#command_options} for further inspection."
msgstr ""
"新しいコマンドオブジェクトを作成し、\n"
"ハッシュオプションのキーによって、名付けられた属性をセッティングする。\n"
"イニシャライズの後でハッシュのオプションは、\n"
"調査を進める為に{#command_options}メソッドの中でセーブされる。"

# YARD::Server::Commands::Base#initialize
# YARD::Server::Commands::Base#call
#: ../lib/yard/server/commands/base.rb:74
#: ../lib/yard/server/commands/base.rb:88
msgid "Instance Method Summary"
msgstr "インスタンスメソッドの概要"

# @example Creating a Command
#: ../lib/yard/server/commands/base.rb:74
msgid ""
"cmd = DisplayObjectCommand.new(:caching => true, :library => mylib)\n"
"cmd.library # => mylib\n"
"cmd.command_options # => {:caching => true, :library => mylib}"
msgstr ""

# @example
#: ../lib/yard/server/commands/base.rb:74
msgid "tag|example|Creating a Command"
msgstr "コマンドを作成する"

# @param [Hash] opts
#: ../lib/yard/server/commands/base.rb:74
msgid ""
"the options hash, saved to {#command_options}\n"
"after initialization."
msgstr ""
"ハッシュのオプション、イニシャライズされた後で、\n"
"{#command_options}にセーブされる。"

# YARD::Server::Commands::Base#call
#: ../lib/yard/server/commands/base.rb:82
msgid "The main method called by a router with a request object."
msgstr ""
"主なメソッドは、requestオブジェクトを用い\n"
"routerによって呼び出される。"

# @note
#: ../lib/yard/server/commands/base.rb:88
msgid ""
"This command should not be overridden by subclasses. Implement\n"
"the callback method {#run} instead."
msgstr ""
"このコマンドは、サブクラスによって上書きされるべきではない、\n"
"代わりにコールバックの{#run}メソッドを実装する。"

# @return [Array(Number,Hash,Array<String>)]
#: ../lib/yard/server/commands/base.rb:88
msgid ""
"a Rack-style response\n"
"of status, headers, and body wrapped in an array."
msgstr ""
"配列でラップされた\n"
"Rackスタイルのステータス、ヘッダー、ボディのレスポンス"

# @param [Adapter Dependent]
#: ../lib/yard/server/commands/base.rb:88 ../lib/yard/server/router.rb:52
msgid "tag|param|request"
msgstr ""

# @param [Adapter Dependent] request
#: ../lib/yard/server/commands/base.rb:88 ../lib/yard/server/router.rb:52
msgid "the request object"
msgstr "リクエストするオブジェクト"

# YARD::Server::Commands::Base#run
#: ../lib/yard/server/commands/base.rb:108
msgid ""
"Subclass this method to implement a custom command. This method\n"
"should set the {#status} and {#body}, and optionally modify the\n"
"{#headers}. Note that +#status+ defaults to 200."
msgstr ""
"カスタムコマンドを実装する為にこのメソッドをサブクラス化する。\n"
"このメソッドは、{#status}と{#body}を設定するべきで、\n"
"任意で、{#headers}を変更する。\n"
"留意する事として、 +#status+ はデフォルトで200になる。"

# YARD::Server::Commands::Base#run
#: ../lib/yard/server/commands/base.rb:122
msgid "Abstract Methods"
msgstr "抽象メソッド"

# @example A custom command
#: ../lib/yard/server/commands/base.rb:122
msgid ""
"class ErrorCommand < Base\n"
"  def run\n"
"    self.body = 'ERROR! The System is down!'\n"
"    self.status = 500\n"
"    self.headers['Content-Type'] = 'text/plain'\n"
"  end\n"
"end"
msgstr ""

# @example
#: ../lib/yard/server/commands/base.rb:122
msgid "tag|example|A custom command"
msgstr "カスタムコマンド"

# YARD::Server::Commands::Base#render
#: ../lib/yard/server/commands/base.rb:131
msgid ""
"Renders a specific object if provided, or a regular template rendering\n"
"if object is not provided."
msgstr ""
"提供された場合、特定のオブジェクトを表示するか、\n"
"オブジェクトが提供されない場合、規定のテンプレートが表示される。"

# YARD::Server::Commands::Base#render
# YARD::Server::Commands::Base#cache
# YARD::Server::Commands::Base#not_found
# YARD::Server::Commands::Base#redirect
#: ../lib/yard/server/commands/base.rb:138
#: ../lib/yard/server/commands/base.rb:159
#: ../lib/yard/server/commands/base.rb:174
#: ../lib/yard/server/commands/base.rb:184
msgid "Helper Methods"
msgstr "ヘルパーメソッド"

# @todo
#: ../lib/yard/server/commands/base.rb:138
msgid ""
"This method is dependent on +#options+, it should be in {LibraryCommand}."
msgstr ""
"このメソッドは、 +#options+ メソッドに依存している。\n"
"+#options+ メソッドは {LibraryCommand} にするべきである。"

# @param [CodeObjects::Base, nil] object
#: ../lib/yard/server/commands/base.rb:138
msgid ""
"calls {CodeObjects::Base#format} if\n"
"an object is provided, or {Templates::Engine.render} if object is nil. Both\n"
"receive +#options+ as an argument."
msgstr ""
"オブジェクトが提供される場合、\n"
"{CodeObjects::Base#format}を呼び出す、\n"
"又は、オブジェクトがnilの場合\n"
"{Templates::Engine.render}を呼び出す。\n"
"両者は、引数として +#options+ メソッドを受け取る。"

# @return [String]
#: ../lib/yard/server/commands/base.rb:138
msgid "the resulting output to display"
msgstr "表示する出力結果"

# YARD::Server::Commands::Base#cache
#: ../lib/yard/server/commands/base.rb:150
msgid "Override this method to implement custom caching mechanisms for"
msgstr "カスタムキャッシュメカニズムを実装する為にこのメソッドを上書きする。"

# @example Caching to memory
#: ../lib/yard/server/commands/base.rb:159
msgid ""
"$memory_cache = {}\n"
"def cache(data)\n"
"  $memory_cache[path] = data\n"
"end"
msgstr ""

# @example
#: ../lib/yard/server/commands/base.rb:159
msgid "tag|example|Caching to memory"
msgstr "メモリーにキャッシュする"

# @see
#: ../lib/yard/server/commands/base.rb:159
msgid "tag|see|StaticCaching"
msgstr ""

# @param [String] data
#: ../lib/yard/server/commands/base.rb:159
msgid "the data to cache"
msgstr "キャッシュするデータ"

# @return [String]
#: ../lib/yard/server/commands/base.rb:159
msgid "the same cached data (for chaining)"
msgstr "同じキャッシュされたデータ(メソッドチェーン用)"

# YARD::Server::Commands::Base#not_found
#: ../lib/yard/server/commands/base.rb:171
msgid ""
"Sets the body and headers (but not status) for a 404 response. Does\n"
"nothing if the body is already set."
msgstr ""
"404レスポンス用にボディとヘッダー(しかしステータスはない)を設定する。\n"
"ボディが既に設定されている場合は何もしない。"

# YARD::Server::Commands::Base#redirect
#: ../lib/yard/server/commands/base.rb:182
msgid "Sets the headers and status code for a redirection to a given URL"
msgstr ""
"与えられたURLへのリダイレクト用にヘッダーとステータスコードを設定する。"

# @raise [FinishRequest]
#: ../lib/yard/server/commands/base.rb:184
msgid "causes the request to terminate."
msgstr "打ち切る為にリクエストする。"

# @param [String]
#: ../lib/yard/server/commands/base.rb:184
#: ../lib/yard/templates/helpers/base_helper.rb:138
msgid "tag|param|url"
msgstr ""

# @param [String] url
#: ../lib/yard/server/commands/base.rb:184
msgid "the URL to redirect to"
msgstr "リダイレクトするURL"

# YARD::Server::Commands::DisplayFileCommand
#: ../lib/yard/server/commands/display_file_command.rb:5
msgid "Displays a README or extra file."
msgstr "README 又は、追加のファイルを表示する。"

# @todo
#: ../lib/yard/server/commands/display_file_command.rb:7
msgid "Implement better support for detecting binary (image) filetypes"
msgstr "バイナリ(画像)ファイルタイプを見つける為のより良いサポートを実装する。"

# YARD::Server::Commands::DisplayObjectCommand
#: ../lib/yard/server/commands/display_object_command.rb:5
msgid "Displays documentation for a specific object identified by the path"
msgstr "パスによって識別された固有のオブジェクト用にドキュメントを表示する。"

# YARD::Server::Commands::FramesCommand
#: ../lib/yard/server/commands/frames_command.rb:5
msgid "Displays an object wrapped in frames"
msgstr "フレームの中のラップされたオブジェクトを表示する。"

# YARD::Server::Commands::LibraryCommand
#: ../lib/yard/server/commands/library_command.rb:26
msgid ""
"This is the base command for all commands that deal directly with "
"libraries.\n"
"Some commands do not, but most (like {DisplayObjectCommand}) do. If your\n"
"command deals with libraries directly, subclass this class instead.\n"
"See {Base} for notes on how to subclass a command."
msgstr ""
"これは、ライブラリを用い直接処理する全てのコマンドの為のベースコマンド。\n"
"いくつかのコマンドには、用いないが({DisplayObjectCommand}のように)大抵の事は"
"行う。\n"
"あなたのコマンドが直接ライブラリを用い処理する場合、代わりにこのクラスをサブ"
"クラス化する。\n"
"コマンドをサブクラス化する為の方法については{Base}を参照。\n"

# @return [LibraryVersion]
#: ../lib/yard/server/commands/library_command.rb:33
msgid "the object containing library information"
msgstr "ライブラリの情報含んでいるオブジェクト"

# @return [Hash{Symbol => Object}]
#: ../lib/yard/server/commands/library_command.rb:36
msgid "default options for the library"
msgstr "ライブラリ用のデフォルトのoptions"

# @return [Serializers::Base]
#: ../lib/yard/server/commands/library_command.rb:39
msgid "the serializer used to perform file linking"
msgstr "ファイルリンクを実行する為に利用されるシリアライザ"

# @return [Boolean]
#: ../lib/yard/server/commands/library_command.rb:42
msgid "whether router should route for multiple libraries"
msgstr "routerが複数のライブラリ用に送るべきかどうか"

# @return [Boolean]
#: ../lib/yard/server/commands/library_command.rb:45
msgid "whether to reparse data"
msgstr "データを再解析するかどうか"

# YARD::Server::Commands::LibraryCommand::@@library_chdir_lock
#: ../lib/yard/server/commands/library_command.rb:48
msgid "Needed to synchronize threads in {#setup_yardopts}"
msgstr "{#setup_yardopts}メソッドの中で、スレッドを同期する為の必要とされる"

# @return [LibraryCommand]
#: ../lib/yard/server/commands/library_command.rb:51
msgid "a new instance of LibraryCommand"
msgstr "LibraryCommandの新しいインスタンス"

# YARD::Server::Commands::LibraryCommand#fulldoc_template
#: ../lib/yard/server/commands/library_command.rb:127
msgid ""
"Hack to load a custom fulldoc template object that does\n"
"not do any rendering/generation. We need this to access the\n"
"generate_*_list methods."
msgstr ""

# YARD::Server::Commands::LibraryIndexCommand
#: ../lib/yard/server/commands/library_index_command.rb:5
msgid "Returns the index of libraries served by the server."
msgstr "サーバーによって提供されたライブラリのインデックスを返す"

# YARD::Server::Commands::ListCommand
#: ../lib/yard/server/commands/list_command.rb:5
msgid "Returns a list of objects of a specific type"
msgstr "特定の型のオブジェクトのリストを返す"

# YARD::Server::Commands::SearchCommand
#: ../lib/yard/server/commands/search_command.rb:5
msgid ""
"Performs a search over the objects inside of a library and returns\n"
"the results as HTML or plaintext"
msgstr ""
"ライブラリの内部オブジェクトの検索を実行し、\n"
"HTMLやプレーンテキストとして結果を返す。"

# YARD::Server::Commands::StaticFileCommand
#: ../lib/yard/server/commands/static_file_command.rb:7
msgid "Serves static content when no other router matches a request"
msgstr "リクエストにマッチする他のrouterが無い時、静的な内容を提供する。"

# YARD::Server::Commands::StaticFileCommand::STATIC_PATHS
#: ../lib/yard/server/commands/static_file_command.rb:13
msgid ""
"Defines the paths used to search for static assets. To define an\n"
"extra path, use {YARD::Server.register_static_path} rather than\n"
"modifying this constant directly. Also note that files in the\n"
"document root will always take precedence over these paths."
msgstr ""
"静的な資産用に検索に利用されるパスを定義する。\n"
"追加のパスを定義するには、直接この定数を変更するよりも\n"
"{YARD::Server.register_static_path}を利用する。\n"
"尚、ドキュメントのrootのファイルは常時これらのパスより優先する。"

# YARD::Server::Commands::StaticFileCommand#favicon?
#: ../lib/yard/server/commands/static_file_command.rb:39
msgid ""
"Return an empty favicon.ico if it does not exist so that\n"
"browsers don't complain."
msgstr ""
"favicon.icoが存在しない場合、空のfavicon.icoを返す。\n"
"その為、ブラウザに問題は発生しない。"

# YARD::Server::DocServerHelper
#: ../lib/yard/server/doc_server_helper.rb:4
msgid ""
"A module that is mixed into {Templates::Template} in order to customize\n"
"certain template methods."
msgstr ""
"テンプレートメソッドをカスタマイズする為に、\n"
"{Templates::Template}へmixinされるモジュール。"

# YARD::Server::DocServerHelper#url_for
#: ../lib/yard/server/doc_server_helper.rb:7
msgid ""
"Modifies {Templates::Helpers::HtmlHelper#url_for} to return a URL instead\n"
"of a disk location."
msgstr ""
"ディスクの上の場所の代わりにURLを返す{Templates::Helpers::HtmlHelper#url_for}"
"を変更する。"

# YARD::Server::DocServerHelper#url_for_file
#: ../lib/yard/server/doc_server_helper.rb:18
msgid ""
"Modifies {Templates::Helpers::HtmlHelper#url_for_file} to return a URL "
"instead\n"
"of a disk location."
msgstr ""
"ディスク上の場所の代わりにURLを返す{Templates::Helpers::"
"HtmlHelper#url_for_file}を変更する。"

# YARD::Server::DocServerHelper#url_for_file
#: ../lib/yard/server/doc_server_helper.rb:30
msgid ""
"Modifies {Templates::Helpers::HtmlHelper#url_for_list} to return a URL\n"
"based on the list prefix instead of a HTML filename."
msgstr ""
"HTMLファイル名の代わりにリストのプレフィックス基準のURLを返すには、\n"
"{Templates::Helpers::HtmlHelper#url_for_list} を変更する"

# YARD::CodeObjects::MethodObject#name
#: ../lib/yard/server/doc_server_helper.rb:38
msgid "Returns the frames URL for the page"
msgstr "ページ用のフレームのURLを返す"

# YARD::Server::DocServerHelper#url_for_main
#: ../lib/yard/server/doc_server_helper.rb:46
msgid ""
"Returns the main URL, first checking a readme and then linking to the index"
msgstr "メインのURLを返し、最初にreadmeをチェックしその時インデックスにリンクする。"

# YARD::Templates::Helpers::HtmlHelper#url_for_file
#: ../lib/yard/server/doc_server_helper.rb:56
#: ../lib/yard/templates/helpers/html_helper.rb:385
msgid "Returns the URL for the alphabetic index page"
msgstr "アルファベット順のインデックスのページ用にURLを返す"

# @example The base path for a library 'foo'
#: ../lib/yard/server/doc_server_helper.rb:65
msgid "base_path('docs') # => 'docs/foo'"
msgstr ""

# @example
#: ../lib/yard/server/doc_server_helper.rb:65
msgid "tag|example|The base path for a library 'foo'"
msgstr "'foo'ライブラリ用のベースパス"

# @return [String]
#: ../lib/yard/server/doc_server_helper.rb:65
msgid "the base URI for a library with an extra +path+ prefix"
msgstr "追加の +path+ のプレフィックスを用いたライブラリ用のベースURI"

# @param [String] path
#: ../lib/yard/server/doc_server_helper.rb:65
msgid "the path prefix for a base path URI"
msgstr "URIベースパス用のパスのプレフィックス"

# @return [Router]
#: ../lib/yard/server/doc_server_helper.rb:71
msgid "convenience method for accessing the router"
msgstr "routerにアクセスする為の便利メソッド"

# YARD::Server::DocServerSerializer
#: ../lib/yard/server/doc_server_serializer.rb:6
msgid ""
"A custom {Serializers::Base serializer} which returns resource URLs instead "
"of\n"
"static relative paths to files on disk."
msgstr ""
"カスタム{Serializers::Base serializer}。\n"
"ディスク上のファイルの為に静的な相対パスの代わりに、URLリソースを返す。"

# @return [DocServerSerializer]
#: ../lib/yard/server/doc_server_serializer.rb:10
msgid "a new instance of DocServerSerializer"
msgstr "DocServerSerializerの新しいインスタンス"

# YARD::Server::LibraryNotPreparedError
#: ../lib/yard/server/library_version.rb:6
msgid ""
"This exception is raised when {LibraryVersion#prepare!} fails, or discovers\n"
"that the library is not \"prepared\" to be served by"
msgstr ""
"この例外は、{LibraryVersion#prepare!}が失敗した時や、\n"
"ライブラリが提供される為に\"prepared\"されない事をかぎつけた場合、上げられ"
"る。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:10
msgid ""
"A library version encapsulates a library's documentation at a specific "
"version.\n"
"Although the version is optional, this allows for creating multiple "
"documentation\n"
"points for a specific library, each representing a unique version. The term\n"
"\"library\" used in other parts of the YARD::Server documentation refers to\n"
"objects of this class unless otherwise noted."
msgstr ""
"ライブラリバージョンは、特定のバージョンでライブラリドキュメントをカプセル化"
"する。\n"
"バージョンは任意だけれども、\n"
"これは、複数のドキュメントの特定のライブラリ用にポイントを作成する為に受入"
"れ、\n"
"それぞれ固有のバージョンを表す。\n"
"\"library\"の表現は、YARD::Serverドキュメントの他の部分で利用され、\n"
"他の方法で注意されなかった場合、このクラスのオブジェクトを参照する。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:16
msgid ""
"A library points to a location where a {#yardoc_file} is located so that\n"
"its documentation may be loaded and served. Optionally, a {#source_path} is\n"
"given to point to a location where any extra files (and {YARD::CLI::Yardoc ."
"yardopts})\n"
"should be loaded from. Both of these methods may not be known immediately,\n"
"since the yardoc file may not be built until later. Resolving the yardoc\n"
"file and source path are dependent on the specific library \"source type\" "
"used.\n"
"Source types (known as \"library source\") are discussed in detail below."
msgstr ""
"ライブラリの{#yardoc_file}メソッドの指す場所は、\n"
"そのドキュメントがロードされセーブされる場所を示される。\n"
"任意で、{#source_path}メソッドは、\n"
"追加のファイル(と{YARD::CLI::Yardoc .yardopts})が、\n"
"ロードされるべき場所のポイントを与えられる。\n"
"これらのメソッドの両方は、直ぐに理解できないかもしれない、\n"
"なぜなら、yardocファイルが最新でない場合、ビルドされないかもしれないからであ"
"る。\n"
"yardocファイルとソースパスを解決するには、\"source type\"に利用される固有のラ"
"イブラリに依存する。\n"
"ソースの型(\"library source\"として知られる)は、下の詳細の中で検討される。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:24
msgid ""
"== Using with Adapters\n"
"A list of libraries need to be passed into adapters upon creation. In\n"
"most cases, you will never do this manually, but if you use a "
"{RackMiddleware},\n"
"you will need to pass in this list yourself. To build this list of "
"libraries,\n"
"you should create a hash of library names mapped to an *Array* of "
"LibraryVersion\n"
"objects. For example:"
msgstr ""
"== アダプタと一緒に使用する\n"
"ライブラリのリストは、\n"
"作成する上でアダプターへ渡される必要がある。\n"
"大抵の場合、これを手動で行う事はしないだろう、\n"
"だが、あなたが {RackMiddleware}を利用する場合、\n"
"あなた自身が配列でこの中へ渡す必要があるだろう。\n"
"このライブラリの配列をビルドするには、\n"
"次のように、オブジェクトのLibraryVersionの*配列*に、\n"
"マップされ名付けられたライブラリのハッシュを作成すべきである。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:31
msgid ""
"  {'mylib' => [LibraryVersion.new('mylib', '1.0', ...),\n"
"               LibraryVersion.new('mylib', '2.0', ...)]}"
msgstr ""

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:34
msgid "Note that you can also use {Adapter#add_library} for convenience."
msgstr ""
"次の事に留意する。あなたは、\n"
"便利な{Adapter#add_library}メソッドを\n"
"使う事もできる。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:36
msgid "The \"array\" part is required, even for just one library version."
msgstr "\"配列\"の部分は、たった一つのライブラリのバージョンでも必要とされる。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:38
msgid ""
"== Library Sources\n"
"The {#source} method represents the library source type, ie. where the\n"
"library \"comes from\". It might come from \"disk\", or it might come from "
"a\n"
"\"gem\" (technically the disk, but a separate type nonetheless). In these\n"
"two cases, the yardoc file sits somewhere on your filesystem, though\n"
"it may also be built dynamically if it does not yet exist. This behaviour\n"
"is controlled through the {#prepare!} method, which prepares the yardoc "
"file\n"
"given a specific library source. We will see how this works in detail in\n"
"the following section."
msgstr ""
"== ライブラリのソース\n"
"{#source}メソッドはライブラリのソースのタイプを表す、\n"
"つまり、ライブラリの場所である。\n"
"それは、\"disk\"からくるかもしれない、\n"
"又は、\"gem\"からくるかもしれない。\n"
"(実際にはどちらもディスク上だが、型は別れる)\n"
"この二つのケースの場合、\n"
"yardocのファイルは、あなたのファイルシステムの何処かに置いてあり、\n"
"まだ見つかっていない場合、動的にビルドされるかもしれない。\n"
"この挙動は、{#prepare!}メソッドを通じて制御され、\n"
"与えられた固有のライブラリのソースのyardocファイルを用意する。\n"
"私達は、続くセクションの中でこの仕組みを理解するだろう。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:48
msgid ""
"== Implementing a Custom Library Source\n"
"YARD can be extended to support custom library sources in order to\n"
"build or retrieve a yardoc file at runtime from many different locations."
msgstr ""
"==　カスタムライブラリのソースを実装する\n"
"YARDはカスタムライブラリのソースをビルドするのをサポートする為、拡張され、\n"
"多くのの異なる場所から実行時にyardocファイルを読み出す。"

# YARD::Server::LibraryVersion
#: ../lib/yard/server/library_version.rb:52
msgid ""
"To implement this behaviour, two methods must be added to the +LibraryVersion"
"+\n"
"class, +#load_yardoc_from_SOURCE+ and +#source_path_for_SOURCE+. In both\n"
"cases, \"SOURCE\" represents the source type used in {#source} when "
"creating\n"
"the library object. The +#source_path_for_SOURCE+ method is called upon\n"
"creation and should return the location where the source code for the "
"library\n"
"lives. The load method is called from {#prepare!} if there is no yardoc "
"file\n"
"and should set {#yardoc_file}. Below is a full example for\n"
"implementing a custom library source, +:http+, which reads packaged .yardoc\n"
"databases from zipped archives off of an HTTP server."
msgstr ""
"この挙動を実装するには、\n"
"+LibraryVersion+クラスの +#load_yardoc_from_SOURCE+ メソッドと "
"+#source_path_for_SOURCE+ メソッドの\n"
"2つのメソッドが大抵追加される。\n"
"どちらの場合も、ライブラリのオブジェクトが作成される時の、\n"
"\"SOURCE\"は{#source}メソッドで利用されたsource typeを表す。\n"
"+#source_path_for_SOURCE+ メソッドは、作成される所で呼び出され、\n"
"存在するライブラリのソースコードの場所を返すべきである。\n"
"loadメソッドは、yardocファイルが無い場合、{#prepare!}メソッドから呼び出され"
"る。\n"
"そして、{#yardoc_file}を設定すべきである。\n"
"下は、カスタムライブラリのソースと +:http+ を実装する為の、完全な例であり、\n"
"これは、HTTPサーバー経由でzipされたアーカイブからパーケージされた.yardocデー"
"タベースを読み出す。"

# @example Implementing a Custom Library Source
#: ../lib/yard/server/library_version.rb:87
msgid ""
"# Adds the source type \"http\" for .yardoc files zipped on HTTP servers\n"
"class LibraryVersion\n"
"  def load_yardoc_from_http\n"
"    return if yardoc_file # we have the library\n"
"\n"
"    # otherwise download it in a thread and return immediately\n"
"    Thread.new do\n"
"      # zip/unzip method implementations are not shown\n"
"      download_zip_file(\"http://mysite.com/yardocs/#{self}.zip\")\n"
"      unzip_file_to(\"/path/to/yardocs/#{self}\")\n"
"      self.yardoc_file = \"/path/to/yardocs/#{self}/.yardoc\"\n"
"      self.source_path = self.yardoc_file\n"
"    end\n"
"\n"
"    # tell the server it's not ready yet (but it might be next time)\n"
"    raise LibraryNotPreparedError\n"
"  end\n"
"\n"
"  # we set this later\n"
"  def source_path_for_http; nil end\n"
"end\n"
"\n"
"# Creating a library of this source type:\n"
"LibraryVersion.new('name', '1.0', nil, :http)"
msgstr ""
"# HTTPサーバー上でzipされた.yardocファイル用にソースの型\"http\"を追加す"
"る。\n"
"class LibraryVersion\n"
"  def load_yardoc_from_http\n"
"    return if yardoc_file #ライブラリを持っている場合\n"
"\n"
"    # その他の場合、そのスレッドの中でダウンロードし直ぐに返す\n"
"    Thread.new do\n"
"      # zip/unzip メソッドの実装は示さない\n"
"      download_zip_file(\"http://mysite.com/yardocs/#{self}.zip\")\n"
"      unzip_file_to(\"/path/to/yardocs/#{self}\")\n"
"      self.yardoc_file = \"/path/to/yardocs/#{self}/.yardoc\"\n"
"      self.source_path = self.yardoc_file\n"
"    end\n"
"\n"
"    # サーバーを呼び出す準備がまだできていない場合(でも次回になるかもしれな"
"い)\n"
"    raise LibraryNotPreparedError\n"
"  end\n"
"\n"
"  # 最新のものを設定する\n"
"  def source_path_for_http; nil end\n"
"end\n"
"\n"
"#次の様に、このソースの型を指定して、ライブラリを作成する。\n"
"LibraryVersion.new('name', '1.0', nil, :http)"

# @example
#: ../lib/yard/server/library_version.rb:87
msgid "tag|example|Implementing a Custom Library Source"
msgstr "カスタムライブラリのソースを実装する"

# @return [String]
# @param [String] name
#: ../lib/yard/server/library_version.rb:89
#: ../lib/yard/server/library_version.rb:120
msgid "the name of the library"
msgstr "ライブラリの名前"

# @return [String]
#: ../lib/yard/server/library_version.rb:92
msgid "the version of the specific library"
msgstr "固有のライブラリのバージョン"

# @return [nil]
#: ../lib/yard/server/library_version.rb:98
msgid ""
"if no yardoc file exists yet. In this case, {#prepare!} will\n"
"be called on this library to build the yardoc file."
msgstr ""
"yardocファイルがまだ存在しない場合、\n"
"yardocファイルをビルドする為に、\n"
"{#prepare!}がこのライブラリ上で呼び出されるだろう。"

# @return [String]
#: ../lib/yard/server/library_version.rb:98
msgid ""
"the location of the yardoc file used to load the object\n"
"information from."
msgstr "オブジェクトの情報をロードするのに利用されるyardocファイルの場所"

# @see LibraryVersion
#: ../lib/yard/server/library_version.rb:105
#: ../lib/yard/server/library_version.rb:111
msgid ""
"LibraryVersion documentation for \"Implementing a Custom Library Source\""
msgstr ""

# @return [Symbol]
#: ../lib/yard/server/library_version.rb:105
msgid ""
"the source type representing where the yardoc should be\n"
"loaded from. Defaults are +:disk+ and +:gem+, though custom sources\n"
"may be implemented. This value is used to inform {#prepare!} about how\n"
"to load the necessary data in order to display documentation for an object."
msgstr ""
"ソースは、yardocがロードされるべき場所を表す。\n"
"デフォルトは +:disk+ と +:gem+ となるが、カスタムソースの実装もできる。\n"
"この値は、オブジェクト用のドキュメントを表示する為に\n"
"必要なデータをロードする方法について、{#prepare!}メソッドに通知する為に利用さ"
"れる。"

# @return [nil]
#: ../lib/yard/server/library_version.rb:111
msgid "if there is no source code"
msgstr "これらがソースコードでない場合"

# @return [String]
#: ../lib/yard/server/library_version.rb:111
msgid ""
"the location of the source code for a library. This\n"
"value is filled by calling +#source_path_for_SOURCE+ on this class."
msgstr ""
"ライブラリの為のソースコードの場所。\n"
"この値は、このクラスで +#source_path_for_SOURCE+ を呼び出して埋められる。"

# @return [LibraryVersion]
#: ../lib/yard/server/library_version.rb:120
msgid "a new instance of LibraryVersion"
msgstr "LibraryVersionの新しいインスタンス"

# @param [String]
#: ../lib/yard/server/library_version.rb:120
msgid "tag|param|version"
msgstr ""

# @param [String]
#: ../lib/yard/server/library_version.rb:120
msgid "tag|param|yardoc"
msgstr ""

# @param [Symbol] source
#: ../lib/yard/server/library_version.rb:120
msgid ""
"the location of the files used to build the yardoc.\n"
"Builtin source types are +:disk+ or +:gem+."
msgstr ""
"yardocをビルドする為に利用されるファイルの場所。\n"
"組み込みのソースの型は +:disk+ 又は +:gem+ 。"

# @param [String] yardoc
#: ../lib/yard/server/library_version.rb:120
msgid ""
"the location of the yardoc file, or nil if it is\n"
"generated later"
msgstr "yardocの場所、又は、最新のものが生成される場合は、nil"

# @param [String] version
#: ../lib/yard/server/library_version.rb:120
msgid ""
"the specific (usually, but not always, numeric) library\n"
"version"
msgstr ""
"固有(普通は数字で表されるが、しかし常にではない)のライブラリのバージョン"

# @param [Boolean] url_format
#: ../lib/yard/server/library_version.rb:132
msgid ""
"if true, returns the string in a URI-compatible\n"
"format (for appending to a URL). Otherwise, it is given in a more human\n"
"readable format."
msgstr ""
"trueの場合、URI-compatibleフォーマット(URL追加用)で文字列を返し、\n"
"それ以外の場合、人間が読めるフォーマットが与えられる。"

# @param [Boolean]
#: ../lib/yard/server/library_version.rb:132
msgid "tag|param|url_format"
msgstr ""

# @return [String]
#: ../lib/yard/server/library_version.rb:132
msgid "the string representation of the library."
msgstr "ライブラリの文字列表現"

# @return [Fixnum]
#: ../lib/yard/server/library_version.rb:137
msgid "used for Hash mapping."
msgstr "ハッシュのマッピング用に利用される"

# @return [Boolean]
#: ../lib/yard/server/library_version.rb:140
msgid "whether another LibraryVersion is equal to this one"
msgstr "LibraryVersionが条件と一致するかどうか"

# YARD::Server::LibraryVersion#prepare!
#: ../lib/yard/server/library_version.rb:148
msgid ""
"Prepares a library to be displayed by the server. This callback is\n"
"performed before each request on a library to ensure that it is loaded\n"
"and ready to be viewed. If any steps need to be performed prior to loading,\n"
"they are performed through this method (though they should be implemented\n"
"through the +load_yardoc_from_SOURCE+ method)."
msgstr ""
"サーバーで表示されるライブラリを準備する。\n"
"このコールバックは、ロードされその一覧を準備する事を\n"
"保証する為にライブラリ上で、個々のリクエストの前に実行される。\n"
"任意のステップが、ロードの為に先に実行する必要がある場合、\n"
"このメソッドを通じて実行される。\n"
"(けれどもこれは +load_yardoc_from_SOURCE+ メソッドを通じて実装されるべきであ"
"る。)"

# @note
#: ../lib/yard/server/library_version.rb:162
msgid ""
"You should not directly override this method. Instead, implement\n"
"+load_yardoc_from_SOURCENAME+ when implementing loading for a specific\n"
"source type. See the {LibraryVersion} documentation for \"Implementing\n"
"a Custom Library Source\""
msgstr ""
"あなたは、このメソッドを直接上書きすべきではない。\n"
"固有のソースの型用にロードを実装する時は、\n"
"代わりに、 +load_yardoc_form_SOURCENAME+ を実装する。\n"
"\"カスタムライブラリのソースの実装\"には、{LibraryVersion}ドキュメントを参"
"照。"

# @raise [LibraryNotPreparedError]
#: ../lib/yard/server/library_version.rb:162
msgid ""
"if the library is not ready to be\n"
"displayed. Usually when raising this error, you would simultaneously\n"
"begin preparing the library for subsequent requests, although this\n"
"is not necessary."
msgstr ""
"ライブラリが表示する為の準備ができていない場合、\n"
"通常このエラーを上げる時は、\n"
"次のリクエストの為のライブラリの準備が一斉に始まる。\n"
"なので、これは、必須ではない。"

# @return [Gem::Specification]
#: ../lib/yard/server/library_version.rb:171
msgid ""
"a gemspec object for a given library. Used\n"
"for :gem source types."
msgstr ""
"与えられたライブラリ用のgemspecオブジェクト。\n"
":gemのソースの型用に利用される。"

# @return [nil]
#: ../lib/yard/server/library_version.rb:171
msgid "if there is no installed gem for the library"
msgstr "これらが、ライブラリ用のgemをインストールされない場合"

# YARD::Server::LibraryVersion#load_yardoc_from_disk
#: ../lib/yard/server/library_version.rb:179
msgid ""
"Called when a library of source type \"disk\" is to be prepared. In this\n"
"case, the {#yardoc_file} should already be set, so nothing needs to be\n"
"done."
msgstr ""
"ソースの型が\"disk\"のライブラリの時呼び出され、準備する。\n"
"この場合、{#yardoc_file}は、既に設定されるべきであり、\n"
"何も必要としない。"

# YARD::Server::LibraryVersion#load_yardoc_from_gem
#: ../lib/yard/server/library_version.rb:186
msgid ""
"Called when a library of source type \"gem\" is to be prepared. In this\n"
"case, the {#yardoc_file} needs to point to the correct location for\n"
"the installed gem. The yardoc file is built if it has not been done."
msgstr ""
"ソースの型が\"gem\"のライブラリの時呼び出され、準備する。\n"
"この場合、{#yardoc_file}は\n"
"インストールされたgemの正規の場所を必要とする。\n"
"yardocファイルを持っていない場合は、ビルドされる。"

# @raise [LibraryNotPreparedError]
#: ../lib/yard/server/library_version.rb:191
msgid ""
"if the gem does not have an existing\n"
"yardoc file."
msgstr "gemがyardocファイルに存在しない場合"

# @return [String]
#: ../lib/yard/server/library_version.rb:210
msgid "the source path for a disk source"
msgstr "ディスクのソース用のソースのパス"

# @return [String]
#: ../lib/yard/server/library_version.rb:215
msgid "the source path for a gem source"
msgstr "gemのソース用のソースのパス"

# YARD::Server::RackMiddleware
#: ../lib/yard/server/rack_adapter.rb:7
msgid ""
"This class wraps the {RackAdapter} into a Rack-compatible middleware.\n"
"See {#initialize} for a list of options to pass via Rack's +#use+ method."
msgstr ""
"このクラスは、Rackと互換性のあるミドルウェアの{RackAdapter}をラップする。\n"
"Rack の +#use+ メソッド経由で渡す為のoptionsのリストは、{#initialize}メソッド"
"を参照。\n"

# @note
#: ../lib/yard/server/rack_adapter.rb:16
msgid ""
"You must pass a +:libraries+ option to the RackMiddleware via +#use+. To\n"
"read about how to return a list of libraries, see {LibraryVersion} or look\n"
"at the example below."
msgstr ""
"あなたは +#use+ メソッド経由でRackWiddlewareに +:libraries+ のオプションを渡"
"さなければならない。\n"
"librariesのリストを返す為の方法について読むには、{LibraryVersion}又は、下の例"
"を参照。"

# @example Using the RackMiddleware in a Rack application
#: ../lib/yard/server/rack_adapter.rb:16
msgid ""
"libraries = {:mylib => [YARD::Server::LibraryVersion.new('mylib', nil, '/"
"path/to/.yardoc')]}\n"
"use YARD::Server::RackMiddleware, :libraries => libraries"
msgstr ""

# @example
#: ../lib/yard/server/rack_adapter.rb:16
msgid "tag|example|Using the RackMiddleware in a Rack application"
msgstr "RackアプリケーションでRackミドルウェアを使用する。"

# YARD::Server::RackMiddleware#initialize
#: ../lib/yard/server/rack_adapter.rb:18
msgid "Creates a new Rack-based middleware for serving YARD documentation."
msgstr ""
"YARDドキュメントに提供する為に、\n"
"新しくRackが基本となるミドルウェアを作成する。"

# @return [RackMiddleware]
#: ../lib/yard/server/rack_adapter.rb:26
msgid "a new instance of RackMiddleware"
msgstr "Rackミドルウェアの新しいインスタンス"

# @param
#: ../lib/yard/server/rack_adapter.rb:26
msgid "tag|param|app"
msgstr ""

# @param app
#: ../lib/yard/server/rack_adapter.rb:26
msgid "the next Rack middleware in the stack"
msgstr "スタックの中の次のRackミドルウェア"

# YARD::Server::RackAdapter
#: ../lib/yard/server/rack_adapter.rb:43
msgid ""
"A server adapter to respond to requests using the Rack server infrastructure."
msgstr ""
"Rackサーバーのインフラによって、リクエストに答える為のサーバーアダプター。"

# YARD::Server::RackAdapter#call
#: ../lib/yard/server/rack_adapter.rb:47
msgid "Responds to Rack requests and builds a response with the {Router}."
msgstr "Rackのリクエストにレスポンスし、{Router}を用いレスポンスをビルドする。"

# @return [Array(Numeric,Hash,Array<String>)]
# @return [Array(Number,Hash,Array)]
#: ../lib/yard/server/rack_adapter.rb:48 ../lib/yard/server/router.rb:100
#: ../lib/yard/server/static_caching.rb:33
msgid "the Rack-style response"
msgstr "Rackスタイルのレスポンス"

# YARD::Server::RackAdapter#start
#: ../lib/yard/server/rack_adapter.rb:59
msgid ""
"Starts the +Rack::Server+. This method will pass control to the server and\n"
"block."
msgstr ""
"+Rack::Server+ をスタートする。\n"
"このメソッドは、サーバーとブロックに制御を渡すだろう。"

# YARD::Server::Router
#: ../lib/yard/server/router.rb:4
msgid ""
"A router class implements the logic used to recognize a request for a "
"specific\n"
"URL and run specific {Commands::Base commands}."
msgstr ""
"routerクラスは、特定のURL用のリクエストを認識する為に利用されたロジックを実装"
"し、\n"
"特定の{Commands::Base commands}を起動する。"

# YARD::Server::Router
#: ../lib/yard/server/router.rb:7
msgid ""
"== Subclassing Notes\n"
"To create a custom router, subclass this class and pass it into the adapter\n"
"options through {Adapter#initialize} or by directly modifying "
"{Adapter#router}."
msgstr ""
"== サブクラス化する時の注意\n"
"カスタムrouterを作成するには、\n"
"このクラスをサブクラス化し、\n"
"{Adapter#initialize}を通じてアダプタオプションへ渡すか、\n"
"直接{Adapter#router}を変更する。"

# YARD::Server::Router
#: ../lib/yard/server/router.rb:11
msgid ""
"The most general customization is to change the URL prefixes recognized by\n"
"routing, which can be done by overriding {#docs_prefix}, {#list_prefix}\n"
"and {#search_prefix}."
msgstr ""
"多くの場合、カスタマイズは、\n"
"routerで認識されるURLのプレフィックスを変更する為である。\n"
"{#docs_prefix}、{#list_prefix}、{#search_prefix}メソッドを上書きする事で、\n"
"実現できる。"

# YARD::Server::Router
#: ../lib/yard/server/router.rb:15
msgid ""
"== Implementing Custom Caching\n"
"By default, the Router class performs static disk-based caching on all\n"
"requests through the +#check_static_cache+. To override this behaviour,\n"
"or create your own caching mechanism, mixin your own custom module with\n"
"this method implemented as per {StaticCaching#check_static_cache}."
msgstr ""
"== カスタムキャッシュを実装する\n"
"デフォルトで、Routerクラスは、\n"
"+#check_static_cache+ を通じて\n"
"全てのリクエストで静的なディスクベースのキャッシュを実行する。\n"
"この挙動を上書きしたり、あなた自身でキャッシュのメカニズムを作成するには、\n"
"{StaticCaching#check_static_cache}メソッドとして実装されたこのメソッドを用い"
"て\n"
"あなた自身のカスタムモジュールをmixinする。"

# @example Creating a subclassed router
#: ../lib/yard/server/router.rb:30
msgid ""
"# Adds 'my' to all routing prefixes\n"
"class MyRouter < YARD::Server::Router\n"
"  def docs_prefix; 'mydocs' end\n"
"  def list_prefix; 'mylist' end\n"
"  def search_prefix; 'mysearch' end\n"
"end\n"
"\n"
"# Using it:\n"
"WebrickAdapter.new(libraries, :router => MyRouter).start"
msgstr ""

# @example
#: ../lib/yard/server/router.rb:30
msgid "tag|example|Creating a subclassed router"
msgstr "サブクラス化されたrouterを作成する"

# @return [Adapter Dependent]
#: ../lib/yard/server/router.rb:35
msgid "the request data coming in with the routing"
msgstr "routerを用いやってくるデータのリクエスト"

# @return [Adapter]
#: ../lib/yard/server/router.rb:38
msgid "the adapter used by the router"
msgstr "routerによって利用されたアダプタ"

# YARD::Server::Router#initialize
#: ../lib/yard/server/router.rb:41
msgid "Creates a new router for a specific adapter"
msgstr "特定のアダプタ用に新しいrouterを作成する"

# @return [Router]
#: ../lib/yard/server/router.rb:43
msgid "a new instance of Router"
msgstr "Routerの新しいインスタンス"

# @param [Adapter]
#: ../lib/yard/server/router.rb:43
msgid "tag|param|adapter"
msgstr ""

# @param [Adapter] adapter
#: ../lib/yard/server/router.rb:43
msgid "the adapter to route requests to"
msgstr "リクエストを送る為のアダプタ"

# YARD::Server::Router#call
#: ../lib/yard/server/router.rb:48
msgid ""
"Perform routing on a specific request, serving the request as a static\n"
"file through {Commands::StaticFileCommand} if no route is found."
msgstr ""
"特定のリクエストでrouterを実行し、\n"
"routeが見つからない場合、\n"
"{Commands::StaticFileCommand}を通じて、\n"
"静的なファイルとしてリクエストを提供する。"

# @return [Array(Number,Hash,Array)]
#: ../lib/yard/server/router.rb:52
msgid "the Rack-style server response data"
msgstr "Rackスタイルサーバーが返すデータ"

# YARD::Server::Router#docs_prefix
# YARD::Server::Router#list_prefix
# YARD::Server::Router#search_prefix
#: ../lib/yard/server/router.rb:64 ../lib/yard/server/router.rb:67
#: ../lib/yard/server/router.rb:70
msgid "Route Prefixes"
msgstr "プレフィックスを送る"

# @return [String]
#: ../lib/yard/server/router.rb:64
msgid "the URI prefix for all object documentation requests"
msgstr "全てのオブジェクトのドキュメントのリクエスト用のURIのプレフィックス"

# @return [String]
#: ../lib/yard/server/router.rb:67
msgid "the URI prefix for all class/method/file list requests"
msgstr ""
"全てのクラス/メソッド/ファイルのリストのリクエスト用のURIのプレフィックス"

# @return [String]
#: ../lib/yard/server/router.rb:70
msgid "the URI prefix for all search requests"
msgstr "全ての検索リクエスト用のURIプレフィックス"

# YARD::Server::Router#parse_library_from_path
# YARD::Server::Router#route
# YARD::Server::Router#route_docs
# YARD::Server::Router#route_index
# YARD::Server::Router#route_list
# YARD::Server::Router#route_search
#: ../lib/yard/server/router.rb:77 ../lib/yard/server/router.rb:100
#: ../lib/yard/server/router.rb:122 ../lib/yard/server/router.rb:140
#: ../lib/yard/server/router.rb:151 ../lib/yard/server/router.rb:159
msgid "Routing Methods"
msgstr "メソッドを送る"

# @return [Array(LibraryVersion, Array<String>)]
#: ../lib/yard/server/router.rb:77
msgid ""
"the library followed\n"
"by the rest of the path components in the request path. LibraryVersion\n"
"will be nil if no matching library was found."
msgstr ""
"ライブラリは、リクエストのパスの中で\n"
"そのパスの構成の残りによってフォローされる。\n"
"見つかったライブラリが一致しなかった場合、\n"
"LibraryVersionは、nilになるだろう。"

# YARD::Server::Router#route
#: ../lib/yard/server/router.rb:96
msgid ""
"Performs routing algorithm to find which prefix is called, first\n"
"parsing out library name/version information."
msgstr ""
"プレフィックスを検索する為のrouterアルゴリズムを実行する。\n"
"ライブラリのname/version情報の出力を最初に解析する。"

# @return [nil]
#: ../lib/yard/server/router.rb:100
msgid "if no route is matched"
msgstr "route処理がマッチしない場合"

# YARD::Server::Router#route_docs
#: ../lib/yard/server/router.rb:119
msgid "Routes requests from {#docs_prefix} and calls the appropriate command"
msgstr "{#docs_prefix}からリクエストを送り、適当なコマンドを呼び出す。"

# @param [Array<String>] paths
#: ../lib/yard/server/router.rb:122
msgid "path components (split by '/')"
msgstr "パスの構成('/'区切り)"

# @param [LibraryVersion] library
#: ../lib/yard/server/router.rb:122
msgid "the library to route for"
msgstr "routeする為のライブラリ"

# YARD::Server::Router#route_index
#: ../lib/yard/server/router.rb:139
msgid "Routes for the index of a library / multiple libraries"
msgstr "単一のライブラリ/複数のライブラリのインデックス用に送る"

# YARD::Server::Router#route_list
#: ../lib/yard/server/router.rb:149
msgid "Routes requests from {#list_prefix} and calls the appropriate command"
msgstr "{#list_prefix}メソッドからリクエストを送り、適切なコマンドを呼び出す"

# YARD::Server::Router#route_search
#: ../lib/yard/server/router.rb:157
msgid "Routes requests from {#search_prefix} and calls the appropriate command"
msgstr "{#search_prefix}メソッドからリクエストを送り、適切なコマンドを呼び出す"

# YARD::Server::Router#final_options
#: ../lib/yard/server/router.rb:167
msgid ""
"Adds extra :library/:path option keys to the adapter options.\n"
"Use this method when passing options to a command."
msgstr ""
"アダプタオプションに追加の:library/:pathオプションのキーを追加する。\n"
"このメソッドは、コマンドがオプションを解析する時に利用する。"

# YARD::Server::Router#final_options
#: ../lib/yard/server/router.rb:171
msgid "Utility Methods"
msgstr "ユーティリティメソッド"

# @return [Hash]
#: ../lib/yard/server/router.rb:171
msgid "finalized options"
msgstr "終わらせるオプション"

# YARD::Server::StaticCaching
#: ../lib/yard/server/static_caching.rb:4
msgid "Implements static caching for requests."
msgstr "リクエスト用の静的なキャッシュを実装する"

# @see Router
#: ../lib/yard/server/static_caching.rb:6
msgid "Router documentation for \"Caching\""
msgstr ""

# @see
#: ../lib/yard/server/static_caching.rb:6
msgid "tag|see|Router"
msgstr ""

# YARD::Server::StaticCaching#check_static_cache
#: ../lib/yard/server/static_caching.rb:8
msgid ""
"Called by a router to return the cached object. By default, this\n"
"method performs disk-based caching. To perform other forms of caching,\n"
"implement your own +#check_static_cache+ method and mix the module into\n"
"the Router class."
msgstr ""
"キャッシュされたオブジェクトを返す為にrouterによって呼び出される。\n"
"デフォルトで、このメソッドは、ディスクベースのキャッシュを実行する。\n"
"キャッシュの他の形式を実行するには、\n"
"あなた自身が +#check_static_cache+ メソッドを実装し、\n"
"Routerクラスへモジュールをmixinする。"

# YARD::Server::StaticCaching#check_static_cache
#: ../lib/yard/server/static_caching.rb:13
msgid ""
"Note that caching does not occur here. This method simply checks for\n"
"the existence of cached data. To actually cache a response, see\n"
"{Commands::Base#cache}."
msgstr ""
"次の事に留意する。キャッシュは、ここでは発生しない。\n"
"このメソッドは、単純にキャッシュデータの存在をチェックする。\n"
"実際にレスポンスをキャッシュするには、{Commands::Base#cache}を参照する。"

# @return [nil]
#: ../lib/yard/server/static_caching.rb:33
msgid "if no cache is available and routing should continue"
msgstr ""
"キャッシュが利用できない場合、nilを返す。\n"
"routerは継続すべきである。"

# @example Implementing In-Memory Cache Checking
#: ../lib/yard/server/static_caching.rb:33
msgid ""
"module MemoryCaching\n"
"  def check_static_cache\n"
"    # $memory_cache is filled by {Commands::Base#cache}\n"
"    cached_data = $memory_cache[request.path]\n"
"    if cached_data\n"
"      [200, {'Content-Type' => 'text/html'}, [cached_data]]\n"
"    else\n"
"      nil\n"
"    end\n"
"  end\n"
"end\n"
"\n"
"class YARD::Server::Router; include MemoryCaching; end"
msgstr ""

# @example
#: ../lib/yard/server/static_caching.rb:33
msgid "tag|example|Implementing In-Memory Cache Checking"
msgstr "メモリ内のキャッシュのチェックを実装する"

# @see
#: ../lib/yard/server/static_caching.rb:33
msgid "tag|see|Commands::Base#cache"
msgstr ""

# YARD::Server::WebrickAdapter
#: ../lib/yard/server/webrick_adapter.rb:6
msgid "The main adapter to initialize a WEBrick server."
msgstr "WEBrickサーバーをイニシャライズする為の主なアダプタ"

# YARD::Server::WebrickAdapter#start
#: ../lib/yard/server/webrick_adapter.rb:8
msgid ""
"Initializes a WEBrick server. If {Adapter#server_options} contains a\n"
"+:daemonize+ key set to true, the server will be daemonized."
msgstr ""
"WEBrickサーバーをイニシャライズする。\n"
"{Adapter#server_options}の内容の\n"
"+:daemonize+ キーにtrueが設定された場合、\n"
"サーバーは、デーモンで起動される。"

# YARD::Server::WebrickServlet
#: ../lib/yard/server/webrick_adapter.rb:19
msgid "The main WEBrick servlet implementation, accepting only GET requests."
msgstr ""
"主にWEBrickサーブレットの実装、取得するリクエストだけ受入れる。\n"
"(servlet:サーバー側で動くプログラムの事)"

# @return [WebrickServlet]
#: ../lib/yard/server/webrick_adapter.rb:22
msgid "a new instance of WebrickServlet"
msgstr "WebrickServletの新しいインスタンス"

# YARD::Tags::DefaultFactory#parse_tag
#: ../lib/yard/tags/default_factory.rb:8
msgid "Parses tag text and creates a new tag with descriptive text"
msgstr "タグテキストを解析し、説明文と共に新しいタグを作成する。"

# @return [Tag]
#: ../lib/yard/tags/default_factory.rb:12
msgid "a tag object with the tag_name and text values filled"
msgstr "タグ名やテキストの入ったタグオブジェクト"

# @param tag_name
#: ../lib/yard/tags/default_factory.rb:12
#: ../lib/yard/tags/default_factory.rb:21
#: ../lib/yard/tags/default_factory.rb:32
#: ../lib/yard/tags/default_factory.rb:44
#: ../lib/yard/tags/default_factory.rb:56
msgid "the name of the tag to parse"
msgstr "解析の為のタグの名前"

# @param [String] text
#: ../lib/yard/tags/default_factory.rb:12
#: ../lib/yard/tags/default_factory.rb:21
#: ../lib/yard/tags/default_factory.rb:32
#: ../lib/yard/tags/default_factory.rb:44
#: ../lib/yard/tags/default_factory.rb:56
#: ../lib/yard/tags/default_factory.rb:98
msgid "the raw tag text"
msgstr "元のタグテキスト"

# YARD::Tags::DefaultFactory#parse_tag_with_name
#: ../lib/yard/tags/default_factory.rb:17
msgid ""
"Parses tag text and creates a new tag with a key name and descriptive text"
msgstr "タグテキストを解析し、キー名と説明文と共に新しいタグを作成する。"

# @return [Tag]
#: ../lib/yard/tags/default_factory.rb:21
msgid "a tag object with the tag_name, name and text values filled"
msgstr "タグ名,キー名,テキストの入ったタグオブジェクト"

# YARD::Tags::DefaultFactory#parse_tag_with_types
#: ../lib/yard/tags/default_factory.rb:27
msgid ""
"Parses tag text and creates a new tag with formally declared types and\n"
"descriptive text"
msgstr ""
"タグテキストを解析し、形式的に宣言される型と説明文と共に新しいタグを作成す"
"る。"

# @return [Tag]
#: ../lib/yard/tags/default_factory.rb:32
msgid "a tag object with the tag_name, types and text values filled"
msgstr "タグ名,型,テキストを含んだタグオブジェクト"

# YARD::Tags::DefaultFactory#parse_tag_with_types_and_name
#: ../lib/yard/tags/default_factory.rb:39
msgid ""
"Parses tag text and creates a new tag with formally declared types, a key\n"
"name and descriptive text"
msgstr ""
"タグタキストを解析し,形式的に宣言された型と共に新しいタグを作成する,\n"
"キー名と説明文。"

# @return [Tag]
#: ../lib/yard/tags/default_factory.rb:44
#: ../lib/yard/tags/default_factory.rb:56
msgid "a tag object with the tag_name, name, types and text values filled"
msgstr "タグ名,キー名,型,テキストの入ったタグオブジェクト"

# YARD::Tags::DefaultFactory#parse_tag_with_types_and_name
#: ../lib/yard/tags/default_factory.rb:51
msgid ""
"Parses tag text and creates a new tag with formally declared types, a title\n"
"on the first line and descriptive text"
msgstr ""
"タグテキストを解析し、新しいタグを作成する。\n"
"形式的に宣言された型、最初の行のタイトル、説明文を用いる。"

# YARD::Tags::DefaultFactory#extract_name_from_text
#: ../lib/yard/tags/default_factory.rb:94
msgid ""
"Extracts the name from raw tag text returning the name and remaining value"
msgstr "元のタグテキストの返す名前から名前を抽出する。又、残りの値は残す。"

# @return [Array]
#: ../lib/yard/tags/default_factory.rb:98
msgid ""
"an array holding the name as the first element and the\n"
"value as the second element"
msgstr "最初の要素は名前を含み、次の要素は残りの値を含んだ配列"

# YARD::Tags::DefaultFactory#extract_types_and_name_from_text
#: ../lib/yard/tags/default_factory.rb:116
msgid ""
"Parses a [], <>, {} or () block at the beginning of a line of text\n"
"into a list of comma delimited values."
msgstr ""
"テキスト行の先頭で[],<>,{},()ブロックのカンマで区切られた値の配列の中を解析す"
"る\n"

# @example 
#: ../lib/yard/tags/default_factory.rb:125
msgid ""
"obj.parse_types('[String, Array<Hash, String>, nil]') # => [nil, ['String', "
"'Array<Hash, String>', 'nil'], \"\"]\n"
"obj.parse_types('b<String> A string') # => ['b', ['String'], 'A string']"
msgstr ""

# @return [Array(String, Array<String>, String)]
#: ../lib/yard/tags/default_factory.rb:125
msgid ""
"the text before the type\n"
"list (or nil), followed by the type list parsed into an array of\n"
"strings, followed by the text following the type list."
msgstr ""
"型の配列の前のテキスト(又はnil)、\n"
"続いて、文字列の配列の中を解析されることによって処理される,型のリスト,\n"
"続いて、型のリストをフォローする事によって処理される,テキストを含んだ配列"

# YARD::Tags::DefaultTag#defaults
#: ../lib/yard/tags/default_tag.rb:5
msgid "Returns the value of attribute defaults"
msgstr "デフォルトの属性の値を返す"

# @return [DefaultTag]
#: ../lib/yard/tags/default_tag.rb:6
msgid "a new instance of DefaultTag"
msgstr "DefaultTagクラスの新しいインスタンス"

# YARD::Tags::Directive
#: ../lib/yard/tags/directives.rb:6
msgid ""
"The base directive class. Subclass this class to create a custom\n"
"directive, registering it with {Library.define_directive}. Directive\n"
"classes are executed via the {#call} method, which perform all directive\n"
"processing on the object."
msgstr ""

# YARD::Tags::Directive
#: ../lib/yard/tags/directives.rb:11
msgid ""
"If processing occurs within a handler, the {#handler} attribute is\n"
"available to access more information about parsing context and state.\n"
"Handlers are only available when parsing from {Parser::SourceParser},\n"
"not when parsing directly from {DocstringParser}. If the docstring is\n"
"attached to an object declaration, {#object} will be set and available\n"
"to modify the generated code object directly. Note that both of these\n"
"attributes may be nil, and directives should test their existence\n"
"before attempting to use them."
msgstr ""

# @abstract
#: ../lib/yard/tags/directives.rb:22
msgid "Subclasses should implement {#call}."
msgstr ""

# @see
#: ../lib/yard/tags/directives.rb:22
msgid "tag|see|Library.define_directive"
msgstr ""

# @return [Tag]
#: ../lib/yard/tags/directives.rb:24
msgid "the meta-data tag containing data input to the directive"
msgstr ""

# YARD::Tags::Directive#expanded_text
# YARD::Tags::Directive#expanded_text=
#: ../lib/yard/tags/directives.rb:27
msgid ""
"Set this field to replace the directive definition inside of a docstring\n"
"with arbitrary text. For instance, the {MacroDirective} uses this field\n"
"to expand its macro data in place of the call to a +@!macro+."
msgstr ""

# @return [nil]
#: ../lib/yard/tags/directives.rb:33
msgid "if no expansion should take place for this directive"
msgstr ""

# @return [String]
#: ../lib/yard/tags/directives.rb:33
msgid ""
"the text to expand in the original docstring in place\n"
"of this directive definition."
msgstr ""

# @return [DocstringParser]
#: ../lib/yard/tags/directives.rb:37
msgid ""
"the parser that is parsing all tag\n"
"information out of the docstring"
msgstr ""

# @return [CodeObjects::Base]
#: ../lib/yard/tags/directives.rb:42
msgid ""
"the object the parent docstring is\n"
"attached to. May be nil."
msgstr ""
"オブジェクトを返す、親のdocstringがオブジェクトに追加される。\n"
"nilになるかもしれない。"

# @return [Handlers::Base, nil]
#: ../lib/yard/tags/directives.rb:48
msgid ""
"the handler object the docstring parser\n"
"might be attached to. May be nil. Only available when parsing\n"
"through {Parser::SourceParser}."
msgstr ""

# @return [Section]
#: ../lib/yard/tags/directives.rb:54
msgid "a new instance of Directive"
msgstr "ディレクティブの新しいインスタンス"

# @param [Symbol]
# @param [#to_s]
#: ../lib/yard/tags/directives.rb:54 ../lib/yard/tags/library.rb:100
#: ../lib/yard/tags/library.rb:158
msgid "tag|param|tag"
msgstr ""

# @param [OptionParser] opts
#: ../lib/yard/tags/directives.rb:54
msgid "the docstring parser object"
msgstr "docstringのパーサーオブジェクト"

# @return [Adapter Dependent]
#: ../lib/yard/tags/directives.rb:54
msgid "the meta-data tag containing all input to the docstring"
msgstr "メタデータタグ、docstringに全て入力するデータを含んでいる"

# YARD::Tags::Directive#call
#: ../lib/yard/tags/directives.rb:63
msgid ""
"Called when processing the directive. Subclasses should implement\n"
"this method to perform all functionality of the directive."
msgstr ""

# YARD::Parser::SourceParser.before_parse_list
# YARD::Parser::SourceParser.after_parse_list
# YARD::Parser::SourceParser.before_parse_file
# YARD::Parser::SourceParser.after_parse_file
# YARD::Parser::SourceParser.before_parse_list_callbacks
# YARD::Parser::SourceParser.after_parse_list_callbacks
# YARD::Parser::SourceParser.before_parse_file_callbacks
# YARD::Parser::SourceParser.after_parse_file_callbacks
#: ../lib/yard/tags/directives.rb:68 ../lib/yard/tags/directives.rb:73
#: ../lib/yard/tags/directives.rb:97 ../lib/yard/tags/directives.rb:98
#: ../lib/yard/tags/directives.rb:120 ../lib/yard/tags/directives.rb:121
#: ../lib/yard/tags/directives.rb:250 ../lib/yard/tags/directives.rb:251
#: ../lib/yard/tags/directives.rb:263 ../lib/yard/tags/directives.rb:268
#: ../lib/yard/tags/directives.rb:273 ../lib/yard/tags/directives.rb:278
#: ../lib/yard/tags/directives.rb:282 ../lib/yard/tags/directives.rb:298
#: ../lib/yard/tags/directives.rb:318 ../lib/yard/tags/directives.rb:350
#: ../lib/yard/tags/directives.rb:351 ../lib/yard/tags/directives.rb:353
#: ../lib/yard/tags/directives.rb:355 ../lib/yard/tags/directives.rb:363
#: ../lib/yard/tags/directives.rb:372 ../lib/yard/tags/directives.rb:376
#: ../lib/yard/tags/directives.rb:385 ../lib/yard/tags/directives.rb:393
#: ../lib/yard/tags/directives.rb:433 ../lib/yard/tags/directives.rb:434
#: ../lib/yard/tags/directives.rb:442 ../lib/yard/tags/directives.rb:448
#: ../lib/yard/tags/directives.rb:458 ../lib/yard/tags/directives.rb:485
#: ../lib/yard/tags/directives.rb:489 ../lib/yard/tags/directives.rb:518
#: ../lib/yard/tags/directives.rb:519 ../lib/yard/tags/directives.rb:552
#: ../lib/yard/tags/directives.rb:553 ../lib/yard/tags/directives.rb:582
#: ../lib/yard/tags/directives.rb:583
msgid "Parser callbacks"
msgstr "パーサーのコールバック"

# YARD::Server::Adapter#start
#: ../lib/yard/tags/directives.rb:68
msgid ""
"implement this method to perform all data processing for\n"
"the directive."
msgstr "ディレクディブ用に全てのデータ処理を実行する為にこのメソッドを実装する"

# YARD::Tags::Directive#after_parse
#: ../lib/yard/tags/directives.rb:71
msgid ""
"Called after parsing all directives and tags in the docstring. Used\n"
"to perform any cleanup after all directives perform their main task."
msgstr ""

# YARD::Tags::EndGroupDirective
#: ../lib/yard/tags/directives.rb:79
msgid ""
"Ends a group listing definition. Group definition automatically end\n"
"when class or module blocks are closed, and defining a new group overrides\n"
"the last group definition, but occasionally you need to end the current\n"
"group to return to the default listing. Use {tag:!group} to begin a\n"
"group listing."
msgstr ""

# @example 
#: ../lib/yard/tags/directives.rb:97
msgid ""
"class Controller\n"
"  # @!group Callbacks\n"
"\n"
"  def before_filter; end\n"
"  def after_filter; end\n"
"\n"
"  # @!endgroup\n"
"\n"
"  def index; end\n"
"end"
msgstr ""

# @see
#: ../lib/yard/tags/directives.rb:97
msgid "tag|see|tag:!group"
msgstr ""

# YARD::Tags::GroupDirective
#: ../lib/yard/tags/directives.rb:105
msgid ""
"Defines a group listing. All methods (and attributes) seen after this\n"
"directive are placed into a group with the given description as the\n"
"group name. The group listing is used by templates to organize methods\n"
"and attributes into respective logical groups. To end a group listing\n"
"use {tag:!endgroup}."
msgstr ""

# @example 
#: ../lib/yard/tags/directives.rb:120
msgid ""
"# @!group Callbacks\n"
"\n"
"def before_filter; end\n"
"def after_filter; end"
msgstr ""

# @note
#: ../lib/yard/tags/directives.rb:120
msgid ""
"A group definition only applies to the scope it is defined in.\n"
"If a new class or module is opened after the directive, this directive\n"
"will not apply to methods in that class or module."
msgstr ""

# @see
#: ../lib/yard/tags/directives.rb:120
msgid "tag|see|tag:!endgroup"
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:128
msgid ""
"Defines a block of text to be expanded whenever the macro is called by name\n"
"in subsequent docstrings. The macro data can be any arbitrary text data, be\n"
"it regular documentation, meta-data tags or directives."
msgstr ""

#: ../lib/yard/tags/directives.rb:132
msgid "== Defining a Macro"
msgstr "== マクロを定義する"

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:134
msgid ""
"A macro must first be defined in order to be used. Note that a macro is "
"also\n"
"expanded upon definition if it defined on an object (the docstring of a\n"
"method, class, module or constant object as opposed to a free standing\n"
"comment). To define a macro, use the \"new\" or \"attach\" identifier in "
"the\n"
"types specifier list. A macro will also automatically be created if an\n"
"indented macro data block is given, so the keywords are not strictly needed."
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:141
msgid "=== Anonymous Macros"
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:143
msgid ""
"In addition to standard named macros, macros can be defined anonymously if\n"
"no name is given. In this case, they can not be re-used in future "
"docstrings,\n"
"but they will expand in the first definition. This is useful when needing\n"
"to take advantage of the macro expansion variables (described below)."
msgstr ""

#: ../lib/yard/tags/directives.rb:148
msgid "== Using a Macro"
msgstr "== マクロを使う"

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:150
msgid ""
"To re-use a macro in another docstring after it is defined, simply use\n"
"<tt>@!macro the_name</tt> with no indented block of macro data. The "
"resulting\n"
"data will be expanded in place."
msgstr ""

#: ../lib/yard/tags/directives.rb:154
msgid "== Attaching a Macro to a DSL Method"
msgstr "== DSL（Class）メソッドにマクロを追加する"

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:156
msgid ""
"Macros can be defined to auto-expand on DSL-style class method calls. To\n"
"define a macro to be auto expanded in this way, use the \"attach\" keyword\n"
"in the type specifier list (\"new\" is implied)."
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:160
msgid ""
"Attached macros can also be attached directly on the class method "
"declaration\n"
"that provides the DSL method to its subclasses. The syntax in either case\n"
"is the same."
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:164
msgid "== Macro Expansion Variables"
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:166
msgid ""
"In the case of using macros on DSL-style method calls, a number of "
"expansion\n"
"variables can be used for interpolation inside of the macro data. The "
"variables,\n"
"similar in syntax to Ruby's global variables, are as follows:"
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:170
msgid ""
"* $0 - the method name being called\n"
"* $1, $2, $3, ... - the Nth argument in the method call\n"
"* $& - the full source line"
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:174
msgid ""
"The following example shows what the expansion variables might hold for a "
"given\n"
"DSL method call:"
msgstr ""

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:177
msgid ""
"  property :foo, :a, :b, :c, String\n"
"  # $0 => \"property\"\n"
"  # $1 => \"foo\"\n"
"  # $2 => \"a\"\n"
"  # $& => \"property :foo, :a, :b, :c, String\""
msgstr ""

#: ../lib/yard/tags/directives.rb:183
msgid "=== Ranges"
msgstr "=== 範囲"

#: ../lib/yard/tags/directives.rb:185
msgid ""
"Ranges are also acceptable with the syntax <tt>${N-M}</tt>. Negative values\n"
"on either N or M are valid, and refer to indexes from the end of the list.\n"
"Consider a DSL method that creates a method using the first argument with\n"
"argument names following, ending with the return type of the method. This\n"
"could be documented as:"
msgstr ""
"範囲は <tt>${N-M}</tt> の構文で指定できる。\n"
"NやMには負の値を指定可能で、\n"
"その場合リストの最後からのインデックスを参照する。\n"
"最初の引数でそれに続く引数名とともに使われて、\n"
"メソッドのリターンタイプとともに終了するメソッドを作るDSLメソッドを考えよう。\n"
"これは次のように記述できる。"

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:191
msgid ""
"    # @!macro dsl_method\n"
"    #   @!method $1(${2--2})\n"
"    #   @return [${-1}] the return value of $0\n"
"    create_method_with_args :foo, :a, :b, :c, String"
msgstr ""

#: ../lib/yard/tags/directives.rb:196
msgid ""
"As described, the method is using the signature <tt>foo(a, b, c)</tt> and "
"the return\n"
"type from the last argument, +String+. When using ranges, tokens are joined\n"
"with commas. Note that this includes using $0:"
msgstr ""
"上記の通り、メソッドは <tt>foo(a, b, c)</tt> の用法と最後の引数、\n"
"`String`からのリターンタイプを使っている。\n"
"範囲を使うときは、トークンはコンマでつながれている。\n"
"$0を使った場合を記述する。"

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:200
msgid ""
"    !!!plain\n"
"    $0-1 # => Interpolates to \"create_method_with_args, foo\""
msgstr ""

#: ../lib/yard/tags/directives.rb:203
msgid ""
"If you want to separate them with spaces, use <tt>$1 $2 $3 $4 ...</tt>. Note "
"that\n"
"if the token cannot be expanded, it will return the empty string (not an "
"error),\n"
"so it would be safe to list <tt>$1 $2 ... $10</tt>, for example."
msgstr ""
"それらをスペースを用い区切りたい場合は、<tt>$1 $2 $3 $4 ...</tt> を使う\n"
"留意する事としてトークンが拡張できない場合は\n"
"空の文字列を返すだろう。(エラーではない)\n"
"なので例えば\n"
"<tt>$1 $2 ... $10</tt> のように記述すると安全だろう。"

#: ../lib/yard/tags/directives.rb:207
msgid "=== Escaping Interpolation"
msgstr "=== 補間をエスケープする"

#: ../lib/yard/tags/directives.rb:209
msgid "Interpolation can be escaped by prefixing the +$+ with +\\+, like so:"
msgstr "補間文字をエスケープするには、下の様に +$+ の前に +\\+ 置く事でエスケープする。"

# YARD::Tags::MacroDirective
#: ../lib/yard/tags/directives.rb:211
msgid ""
"    # @!macro foo\n"
"    #   I have \\$2.00 USD."
msgstr ""

# @example Defining a simple macro
#: ../lib/yard/tags/directives.rb:250
msgid ""
"# @!macro [new] returnself\n"
"#   @return [self] returns itself"
msgstr ""

# @example Using a simple macro in multiple docstrings
#: ../lib/yard/tags/directives.rb:250
msgid ""
"# Documentation for map\n"
"# ...\n"
"# @macro returnself\n"
"def map; end\n"
"\n"
"# Documentation for filter\n"
"# ...\n"
"# @macro returnself\n"
"def filter; end"
msgstr ""

# @example Attaching a macro directly to a DSL method
#: ../lib/yard/tags/directives.rb:250
msgid ""
"class Post < Resource\n"
"  # @!macro [attach] property\n"
"  #   @return [$2] the $1 property\n"
"  property :title, String\n"
"\n"
"  # Macro will expand on this definition too\n"
"  property :view_count, Integer\n"
"end"
msgstr ""

# @example Attaching a macro to a class method (for DSL usage)
#: ../lib/yard/tags/directives.rb:250
msgid ""
"class Resource\n"
"  # Defines a new property\n"
"  # @param [String] name the property name\n"
"  # @param [Class] type the property's type\n"
"  # @!macro [attach] property\n"
"  #   @return [$2] the $1 property\n"
"  def self.property(name, type) end\n"
"end\n"
"\n"
"class Post < Resource\n"
"  property :title, String\n"
"  property :view_count, Integer\n"
"end"
msgstr ""

# @example
#: ../lib/yard/tags/directives.rb:250
msgid "tag|example|Attaching a macro directly to a DSL method"
msgstr "tag|example|DSLメソッドに直接マクロを追加する"

# @example
#: ../lib/yard/tags/directives.rb:250
msgid "tag|example|Attaching a macro to a class method (for DSL usage)"
msgstr "tag|example|クラスメソッドにマクロを追加する(DSL使用)"

# @example
#: ../lib/yard/tags/directives.rb:250
msgid "tag|example|Defining a simple macro"
msgstr "tag|example|簡単なマクロ定義"

# @example
#: ../lib/yard/tags/directives.rb:250
msgid "tag|example|Using a simple macro in multiple docstrings"
msgstr "tag|example|複数のdocstringの中の単純名マクロを使う"

# YARD::Tags::MethodDirective
#: ../lib/yard/tags/directives.rb:327
msgid ""
"Defines a method object with a given method signature, using indented\n"
"block data as the method's docstring. The signature is similar to the\n"
"{tag:overload} tag. The comment containing this directive does not need\n"
"to be attached to any source, but if it is, that source code will be\n"
"used as the method's source."
msgstr ""

# YARD::Tags::MethodDirective
#: ../lib/yard/tags/directives.rb:333
msgid "To define an attribute method, see {tag:!attribute}"
msgstr ""

# @example Attaching multiple methods to the same source
#: ../lib/yard/tags/directives.rb:350
msgid ""
"# @!method method1\n"
"# @!method method2\n"
"create_methods :method1, :method2"
msgstr ""

# @example Defining a simple method
#: ../lib/yard/tags/directives.rb:350
msgid ""
"# @!method quit(username, message = \"Quit\")\n"
"#   Sends a quit message to the server for a +username+.\n"
"#   @param [String] username the username to quit\n"
"#   @param [String] message the quit message\n"
"quit_message_method"
msgstr ""

# @note
#: ../lib/yard/tags/directives.rb:350
msgid ""
"For backwards compatibility support, you do not need to indent\n"
"the method's docstring text. If a +@!method+ directive is seen with\n"
"no indented block, the entire docstring is used as the new method's\n"
"docstring text."
msgstr ""

# @example
#: ../lib/yard/tags/directives.rb:350
msgid "tag|example|Attaching multiple methods to the same source"
msgstr "tag|example|同じソースに複数のメソッドを追加する"

# @example
#: ../lib/yard/tags/directives.rb:350
msgid "tag|example|Defining a simple method"
msgstr "tag|example|簡単なメソッドを定義する"

# @see
#: ../lib/yard/tags/directives.rb:350
msgid "tag|see|tag:!attribute"
msgstr ""

# YARD::Tags::AttributeDirective
#: ../lib/yard/tags/directives.rb:413
msgid ""
"Defines an attribute with a given name, using indented block data as the\n"
"attribute's docstring. If the type specifier is supplied with \"r\", \"w\", "
"or\n"
"\"rw\", the attribute is made readonly, writeonly or readwrite "
"respectively.\n"
"A readwrite attribute is the default, if no type is specified. The comment\n"
"containing this directive does not need to be attached to any source, but\n"
"if it is, that source code will be used as the method's source."
msgstr ""

# YARD::Tags::AttributeDirective
#: ../lib/yard/tags/directives.rb:420
msgid "To define an regular method, see {tag:!method}"
msgstr ""

# @example Defining a simple readonly attribute
#: ../lib/yard/tags/directives.rb:433
msgid ""
"# @!attribute [r] count\n"
"#   @return [Fixnum] the size of the list"
msgstr ""

# @example Defining a simple readwrite attribute
#: ../lib/yard/tags/directives.rb:433
msgid ""
"# @!attribute name\n"
"#   @return [String] the name of the user"
msgstr ""

# @note
#: ../lib/yard/tags/directives.rb:433
msgid ""
"For backwards compatibility support, you do not need to indent\n"
"the attribute's docstring text. If an +@!attribute+ directive is seen with\n"
"no indented block, the entire docstring is used as the new attribute's\n"
"docstring text."
msgstr ""

# @example
#: ../lib/yard/tags/directives.rb:433
msgid "tag|example|Defining a simple readonly attribute"
msgstr "tag|example|readonly属性を簡単に定義する"

# @example
#: ../lib/yard/tags/directives.rb:433
msgid "tag|example|Defining a simple readwrite attribute"
msgstr "tag|example|readwrite属性を簡単に定義する"

# @see
#: ../lib/yard/tags/directives.rb:433
msgid "tag|see|tag:!method"
msgstr ""

# YARD::Tags::ParseDirective
#: ../lib/yard/tags/directives.rb:495
msgid ""
"Parses a block of code as if it were present in the source file at that\n"
"location. This directive is useful if a class has dynamic meta-programmed\n"
"behaviour that cannot be recognized by YARD."
msgstr ""

# YARD::Tags::ParseDirective
#: ../lib/yard/tags/directives.rb:499
msgid ""
"You can specify the language of the code block using the types\n"
"specification list. By default, the code language is \"ruby\"."
msgstr ""

# @example Parsing C code
#: ../lib/yard/tags/directives.rb:518
msgid ""
"# @!parse [c]\n"
"#   void Init_Foo() {\n"
"#     rb_define_method(rb_cFoo, \"method\", method, 0);\n"
"#   }"
msgstr ""

# @example Declaring a method as an attribute
#: ../lib/yard/tags/directives.rb:518
msgid ""
"# This should really be an attribute\n"
"# @!parse attr_reader :foo\n"
"def object; @parent.object end"
msgstr ""

# @example Documenting dynamic module inclusion
#: ../lib/yard/tags/directives.rb:518
msgid ""
"class User\n"
"  # includes \"UserMixin\" and extends \"UserMixin::ClassMethods\"\n"
"  # using the UserMixin.included callback.\n"
"  # @!parse include UserMixin\n"
"  # @!parse extend UserMixin::ClassMethods\n"
"end"
msgstr ""

# @example
#: ../lib/yard/tags/directives.rb:518
msgid "tag|example|Declaring a method as an attribute"
msgstr "tag|example|属性としてメソッドを宣言する"

# @example
#: ../lib/yard/tags/directives.rb:518
msgid "tag|example|Documenting dynamic module inclusion"
msgstr "tag|example|動的にモジュール含有するドキュメントを作成する"

# @example
#: ../lib/yard/tags/directives.rb:518
msgid "tag|example|Parsing C code"
msgstr "tag|example|Cのコードを解析する"

# YARD::Tags::ScopeDirective
#: ../lib/yard/tags/directives.rb:536
msgid ""
"Modifies the current parsing scope (class or instance). If this\n"
"directive is defined on a docstring attached to an object definition,\n"
"it is applied only to that object. Otherwise, it applies the scope\n"
"to all future objects in the namespace."
msgstr ""

# @example Modifying the scope of a set of methods
#: ../lib/yard/tags/directives.rb:552
msgid ""
"# @!scope class\n"
"\n"
"# Documentation for method1\n"
"def method1; end\n"
"\n"
"# Documentation for method2\n"
"def method2; end"
msgstr ""

# @example Modifying the scope of a DSL method
#: ../lib/yard/tags/directives.rb:552
msgid ""
"# @!scope class\n"
"cattr_accessor :subclasses"
msgstr ""

# @example
#: ../lib/yard/tags/directives.rb:552
msgid "tag|example|Modifying the scope of a DSL method"
msgstr "tag|example|DSLメソッドのスコープを変更する"

# @example
#: ../lib/yard/tags/directives.rb:552
msgid "tag|example|Modifying the scope of a set of methods"
msgstr "tag|example|メソッドのグループのスコープを変更する"

# YARD::Tags::VisibilityDirective
#: ../lib/yard/tags/directives.rb:565
msgid ""
"Modifies the current parsing visibility (public, protected, or private).\n"
"If this directive is defined on a docstring attached to an object\n"
"definition, it is applied only to that object. Otherwise, it applies\n"
"the visibility to all future objects in the namespace."
msgstr ""

# @example Modifying the visibility of a DSL method
#: ../lib/yard/tags/directives.rb:582
msgid ""
"# @!visibility private\n"
"cattr_accessor :subclasses"
msgstr ""

# @example Modifying the visibility of a set of methods
#: ../lib/yard/tags/directives.rb:582
msgid ""
"# Note that Ruby's \"protected\" is recommended over this directive\n"
"# @!visibility protected\n"
"\n"
"# Documentation for method1\n"
"def method1; end\n"
"\n"
"# Documentation for method2\n"
"def method2; end"
msgstr ""

# @example
#: ../lib/yard/tags/directives.rb:582
msgid "tag|example|Modifying the visibility of a DSL method"
msgstr "tag|example|DSLメソッドの可視性を変更する"

# @example
#: ../lib/yard/tags/directives.rb:582
msgid "tag|example|Modifying the visibility of a set of methods"
msgstr "tag|example|メソッドのグループの可視性を変更する"

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:4
msgid ""
"Keeps track of all the registered meta-data tags and directives.\n"
"Also allows for defining of custom tags and customizing the tag parsing\n"
"syntax."
msgstr ""

# YARD::CLI::Yardoc
#: ../lib/yard/tags/library.rb:8
msgid "== Defining Custom Meta-Data Tags"
msgstr "== カスタムメタデータタグを定義する"

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:10
msgid ""
"To define a custom tag, use {define_tag}. You should pass the tag\n"
"name and the factory method to use when creating the tag. If you do not\n"
"provide a factory method to use, it will default to "
"{DefaultFactory#parse_tag}"
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:14
msgid ""
"You can also define tag objects manually by simply implementing a "
"\"tagname_tag\"\n"
"method that returns a {Tag} object, but they will not take advantage of tag "
"factory\n"
"parsing:"
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:18
msgid ""
"  def mytag_tag(text)\n"
"    Tag.new(:mytag, text)\n"
"  end"
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:22
msgid "== Defining Custom Directives"
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:24
msgid ""
"Directives can be defined by calling the {define_directive} method, taking\n"
"the directive name, an optional tag factory parser method (to parse the\n"
"data in the directive into a temporary {Tag} object) and a {Directive} "
"subclass\n"
"that performs the directive processing. For more information on creating a\n"
"Directive subclass, see the {Directive} class documentation."
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:30
msgid ""
"Similar to tags, Directives can also be defined manually, in this case "
"using\n"
"the method name \"mydirective_directive\" and returning a new {Directive} "
"object:"
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:33
msgid ""
"  def mydirective_directive(tag, parser)\n"
"    MyDirective.new(tag, parser)\n"
"  end"
msgstr ""

# YARD::Tags
#: ../lib/yard/tags/library.rb:37
msgid "== Namespaced Tags"
msgstr "== Namespaceタグ"

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:39
msgid ""
"In YARD 0.8.0+, tags can be namespaced using the '.' character. It is "
"recommended\n"
"to namespace project specific tags, like +@yard.tag_name+, so that tags do "
"not\n"
"collide with other plugins or new built-in tags."
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:43
msgid "== Adding/Changing the Tag Syntax"
msgstr ""

# YARD::Tags::Library
#: ../lib/yard/tags/library.rb:45
msgid ""
"If you have specialized tag parsing needs you can substitute the {#factory}\n"
"object with your own by setting {Library.default_factory= Library."
"default_factory}\n"
"to a new class with its own parsing methods before running YARD. This is "
"useful\n"
"if you want to change the syntax of existing tags (@see, @since, etc.)"
msgstr ""
"== 追加や変更のタグ構文\n"
"あなたが、専用のタグ解析が必要な場合、\n"
"自分で{Library.default_factory= Library.default_factory}を\n"
"YARDが起動する前に自身を解析するメソッドを用い\n"
"新しいクラスに設定する事によって\n"
"{#factory} オブジェクトを代替できる\n"
"これは、既に存在するタグ(@see,@since等)構文を変更したい場合、便利である。"

# @example Defining a custom directive
#: ../lib/yard/tags/library.rb:58
msgid "define_directive :method, :with_title_and_text, MethodDirective"
msgstr ""

# @example Defining a custom tag
#: ../lib/yard/tags/library.rb:58
msgid ""
"define_tag \"Parameter\", :param, :with_types_and_name\n"
"define_tag \"Author\", :author"
msgstr ""

# @example
#: ../lib/yard/tags/library.rb:58
msgid "tag|example|Defining a custom directive"
msgstr "tag|example|カスタムディレクティブを定義する"

# @example
#: ../lib/yard/tags/library.rb:58
msgid "tag|example|Defining a custom tag"
msgstr "tag|example|カスタムタグを定義する"

# @see
#: ../lib/yard/tags/library.rb:58 ../lib/yard/tags/library.rb:84
msgid "tag|see|DefaultFactory"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:58
msgid "tag|see|Directive"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:58
msgid "tag|see|define_directive"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:58
msgid "tag|see|define_tag"
msgstr ""

# @return [SymbolHash{Symbol=>String}]
#: ../lib/yard/tags/library.rb:62
msgid ""
"the map of tag names and their\n"
"respective display labels."
msgstr ""

# @return [NamespaceObject]
#: ../lib/yard/tags/library.rb:66
msgid "the main Library instance object."
msgstr "メインライブライリのインスタンスオブジェクト"

# YARD::Tags::Library.default_factory=
#: ../lib/yard/tags/library.rb:71
msgid ""
"Replace the factory object responsible for parsing tags by setting\n"
"this to an object (or class) that responds to +parse_TAGNAME+ methods\n"
"where +TAGNAME+ is the name of the tag."
msgstr ""
"+TAGNAME+ がタグの名前となる処理の所で、\n"
"+parse_TAGNAME+ メソッドに関連するオブジェクト(又は,クラス)の為に、\n"
"これを設定する事によってタグを解析するベースであるfactoryオブジェクトを変更す"
"る。"

# YARD::Tags::Library.default_factory=
#: ../lib/yard/tags/library.rb:75
msgid ""
"You should set this value before performing any source parsing with\n"
"YARD, otherwise your factory class will not be used."
msgstr ""
"あなたはYARDによって何らかのソースの解析を実行する前に、この値を設定しなけれ"
"ばならない。\n"
"設定しない場合、あなたのfactoryクラスは利用できない。"

# @example 
#: ../lib/yard/tags/library.rb:84
msgid "YARD::Tags::Library.default_factory = MyFactory"
msgstr ""

# @param [Class, Object]
#: ../lib/yard/tags/library.rb:84
msgid "tag|param|factory"
msgstr ""

# @param [Class, Object] factory
#: ../lib/yard/tags/library.rb:84
msgid "the factory that parses all tags"
msgstr "全てのタグを解析するファクトリー"

# YARD::Tags::Library.factory_method_for
#: ../lib/yard/tags/library.rb:93
msgid ""
"Returns the factory method used to parse the tag text for a specific tag"
msgstr ""
"特定のタグ用のタグテキストを解析するのに、利用されるファクトリーメソッドを返"
"す。"

# @return [nil]
#: ../lib/yard/tags/library.rb:100 ../lib/yard/tags/library.rb:113
msgid "if the tag is freeform text"
msgstr "タグがフリーフォームテキストの場合"

# @return [Class<Tag>]
#: ../lib/yard/tags/library.rb:100
msgid ""
"the Tag class to use to parse the tag\n"
"or the method to call on the factory class"
msgstr "ファクトリークラスで呼び出すタグやメソッドを解析し利用する為のタグクラス"

# @return [Symbol]
#: ../lib/yard/tags/library.rb:100 ../lib/yard/tags/library.rb:113
msgid "the factory method name for the tag"
msgstr "タグの為のfactoryメソッド名"

# YARD::Tags::Library.factory_method_for
#: ../lib/yard/tags/library.rb:105
msgid ""
"Returns the factory method used to parse the tag text for a specific\n"
"directive"
msgstr ""
"特定のディレクティブ用に\n"
"タグテキストを解析する為に利用されたファクトリーメソッドを返す"

# @param [Boolean]
#: ../lib/yard/tags/library.rb:113
msgid "tag|param|directive"
msgstr ""

# @return [Class<Tag>]
#: ../lib/yard/tags/library.rb:113
msgid ""
"the Tag class to use to parse the tag or\n"
"the methods to call on the factory class"
msgstr ""
"ファクトリークラスで呼び出す為に\n"
"タグやメソッドを解析し利用する為のタグクラス"

# @param [String, Symbol] section
#: ../lib/yard/tags/library.rb:113
msgid "the directive name"
msgstr "ディレクティブ名"

# YARD::Tags::Library.visible_tags
# YARD::Tags::Library.visible_tags=
#: ../lib/yard/tags/library.rb:118
msgid ""
"Sets the list of tags to display when rendering templates. The order of\n"
"tags in the list is also significant, as it represents the order that\n"
"tags are displayed in templates."
msgstr ""
"テンプレートをレンダリングする時、\n"
"表示する為にタグのリストをセットする。\n"
"リストの中のタグの順番は重要である。\n"
"これは、タグがテンプレートの中で表示される順番を表す。"

# YARD::Tags::Library.visible_tags
# YARD::Tags::Library.visible_tags=
#: ../lib/yard/tags/library.rb:122
msgid ""
"You can use the {Array#place} to insert new tags to be displayed in\n"
"the templates at specific positions:"
msgstr ""
"特定の場所でテンプレートの中で、\n"
"表示される新しいタグを挿入する為に{Array#place}メソッドを利用できる。"

# YARD::Tags::Library.visible_tags
# YARD::Tags::Library.visible_tags=
#: ../lib/yard/tags/library.rb:125
msgid "  Library.visible_tags.place(:mytag).before(:return)"
msgstr ""

# @return [Array<Symbol>]
#: ../lib/yard/tags/library.rb:128
msgid "a list of ordered tags"
msgstr "命令されるタグのリスト"

# YARD::Tags::Library.transitive_tags
# YARD::Tags::Library.transitive_tags=
#: ../lib/yard/tags/library.rb:131
msgid ""
"Sets the list of tags that should apply to any children inside the\n"
"namespace they are defined in. For instance, a \"@since\" tag should\n"
"apply to all methods inside a module it is defined in. Transitive\n"
"tags can be overridden by directly defining a tag on the child object."
msgstr ""
"定義されるnamespaceの内部で任意の子を適用しタグのリストをグループ化すべきであ"
"る。\n"
"例えば、\"@since\"タグは、モジュールの内部で定義される全てのメソッドが適用さ"
"れる。\n"
"過渡的なタグは、子のオブジェクトの上(親)のタグを直接定義する事によって上書き"
"できる。"

# @return [Array<Symbol>]
#: ../lib/yard/tags/library.rb:137
msgid "a list of transitive tags"
msgstr "過渡的なタグのリスト"

# YARD::Tags::Library.sorted_labels
#: ../lib/yard/tags/library.rb:140
msgid ""
"Sorts the labels lexically by their label name, often used when displaying\n"
"the tags."
msgstr ""
"ラベルをそのラベル名によってソートする。\n"
"タグを表示する時に、よく利用される。"

# @return [Array<Symbol>, String]
#: ../lib/yard/tags/library.rb:143
msgid "the sorted labels as an array of the tag name and label"
msgstr "ソートされるタグ名やラベルの配列"

# YARD::Tags::Library.define_tag
#: ../lib/yard/tags/library.rb:148
msgid ""
"Convenience method to define a new tag using one of {Tag}'s factory methods, "
"or the\n"
"regular {DefaultFactory#parse_tag} factory method if none is supplied."
msgstr ""
"{Tag}factoryメソッドの一つによって新しいタグを定義する便利なメソッド、\n"
"又、提供されない場合、正規の{DefaultFactory#parse_tag}メソッド"

# @param [Fixnum]
#: ../lib/yard/tags/library.rb:158
msgid "tag|param|label"
msgstr ""

# @param [#to_s, Class<Tag>]
# @param [CodeObjects::MethodObject]
#: ../lib/yard/tags/library.rb:158
#: ../lib/yard/templates/helpers/html_helper.rb:430
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "tag|param|meth"
msgstr ""

# @param [#to_s] label
#: ../lib/yard/tags/library.rb:158
msgid "the label used when displaying the tag in templates"
msgstr ""

# @param [#to_s] tag
#: ../lib/yard/tags/library.rb:158
msgid "the tag name to create"
msgstr "作成するタグ名"

# @param [#to_s, Class<Tag>] meth
#: ../lib/yard/tags/library.rb:158
msgid ""
"the {Tag} factory method to call when\n"
"creating the tag or the name of the class to directly create a tag for"
msgstr ""
"タグや直接タグを作成するクラスの名前を作成する時、呼び出すfactoryメソッドの"
"{Tag}"

# @overload
#: ../lib/yard/tags/library.rb:196
msgid "tag|overload|define_directive"
msgstr ""

# YARD::Tags::Library#factory
# YARD::Tags::Library#factory=
#: ../lib/yard/tags/library.rb:258
msgid ""
"A factory class to handle parsing of tags, defaults to {default_factory}"
msgstr ""
"タグの解析を操作するfactoryクラス、デフォルトは{default_factory}となる。"

# @return [Library]
#: ../lib/yard/tags/library.rb:260
msgid "a new instance of Library"
msgstr "ライブラリの新しいインスタンス"

# @param tag_name
#: ../lib/yard/tags/library.rb:267 ../lib/yard/tags/library.rb:280
msgid "the name of the tag to look for"
msgstr "検索する為のタグの名前"

# @return [Boolean]
#: ../lib/yard/tags/library.rb:267
msgid ""
"whether a tag by the given name is registered in\n"
"the library."
msgstr ""

# YARD::CodeObjects::CodeObjectList#initialize
#: ../lib/yard/tags/library.rb:272
msgid "Creates a new {Tag} object with a given tag name and data"
msgstr "与えられたタグ名とデータを用い新しい {Tag} オブジェクトを作成する。"

# @return [Base]
# @return [MacroObject]
#: ../lib/yard/tags/library.rb:273
msgid "the newly created tag object"
msgstr "新たに作成されたオブジェクト"

# @return [Boolean]
#: ../lib/yard/tags/library.rb:280
msgid ""
"whether a directive by the given name is registered in\n"
"the library."
msgstr ""

# YARD::Docstring#initialize
#: ../lib/yard/tags/library.rb:285
msgid ""
"Creates a new directive with tag information and a docstring parser\n"
"object."
msgstr "タグ情報とdocstringパーサーオブジェクトを用い新しいディレクティブを作成する"

# @return [String]
#: ../lib/yard/tags/library.rb:290 ../lib/yard/tags/tag.rb:14
msgid "the name of the tag"
msgstr "タグの名前"

# @return [Base]
# @return [MacroObject]
#: ../lib/yard/tags/library.rb:290
msgid "the newly created directive"
msgstr "新たに作成されたディレクティブ"

# @return [CodeObjects::Base]
#: ../lib/yard/tags/library.rb:290
msgid "the parser object parsing the docstring"
msgstr "パーサーオブジェクト、docstringを解析する"

# @param [Symbol] tag
# @param [String] tag_name
# @param [String] name
#: ../lib/yard/tags/library.rb:290
msgid "the tag data"
msgstr "タグデータ"

#: ../lib/yard/tags/library.rb:312
msgid ""
"# @abstract Subclass and override {#run} to implement\n"
"#   a custom Threadable class.\n"
"class Runnable\n"
"  def run; raise NotImplementedError end\n"
"end"
msgstr ""

# @yard.tag abstract
#: ../lib/yard/tags/library.rb:312
msgid "[] Abstract"
msgstr ""

# @param [Boolean]
#: ../lib/yard/tags/library.rb:312
msgid "tag|yard.tag|abstract"
msgstr ""

#: ../lib/yard/tags/library.rb:313
msgid ""
"Marks a class/module/method as abstract with optional\n"
"implementor information."
msgstr "任意の実装情報をと一緒に用い概要としてclass/module/methodをマークする"

#: ../lib/yard/tags/library.rb:327
msgid ""
"The special name +@api private+ does display a notice in\n"
"documentation if it is listed, letting users know that the\n"
"method is not to be used by external components."
msgstr ""
"特別な名前の +@api private+ は\n"
"それが記述された場合ドキュメントの中で通知を表示するようになり\n"
"ユーザーにメソッドが外部の構成要素によって使えないことを知らせる。"

# @note
#: ../lib/yard/tags/library.rb:327 ../lib/yard/tags/library.rb:473
#: ../lib/yard/tags/library.rb:518
msgid ""
"This tag is *transitive*. If it is applied on a\n"
"namespace (module or class), it will automatically be\n"
"applied to all children objects of that namespace unless\n"
"it is redefined on the child object."
msgstr ""

# @yard.tag api
#: ../lib/yard/tags/library.rb:327
msgid "[] API Visibility"
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:327
msgid ""
"class Post\n"
"  # @api private\n"
"  def reset_table!; table.flush end\n"
"end"
msgstr ""

# @param [Boolean]
#: ../lib/yard/tags/library.rb:327
msgid "tag|yard.tag|api"
msgstr ""

#: ../lib/yard/tags/library.rb:328
msgid ""
"Declares the API that the object belongs to. Does not display in\n"
"output, but useful for performing queries (+yardoc --query+). Any text is\n"
"allowable in this tag, and there are no predefined values."
msgstr ""
"オブジェクトが属するAPIを宣言する。\n"
"出力を表示できないが、クエリーの実行用に便利である(+yardoc --query+)。\n"
"任意のテキストは\n"
"このタグを受入可能であり、事前定義された値はない。"

# @example 
#: ../lib/yard/tags/library.rb:337
msgid ""
"# @attr [String] name the name of the structure\n"
"# @attr [Fixnum] size the size of the structure\n"
"class MyStruct < Struct; end"
msgstr ""

# YARD::Handlers::Base
#: ../lib/yard/tags/library.rb:337
msgid "Attribute"
msgstr "属性"

# @note
#: ../lib/yard/tags/library.rb:337 ../lib/yard/tags/library.rb:347
#: ../lib/yard/tags/library.rb:357
msgid "This attribute is only applicable on class docstrings"
msgstr ""

# @deprecated
#: ../lib/yard/tags/library.rb:337 ../lib/yard/tags/library.rb:347
#: ../lib/yard/tags/library.rb:357
msgid "Use the more powerful {tag:!attribute} directive instead."
msgstr ""

# @param [String]
# @param [Array<String, Symbol>]
# @param [String, :root]
#: ../lib/yard/tags/library.rb:337
msgid "tag|yard.tag|attr"
msgstr ""

# YARD::Tags::Library#attr_tag
#: ../lib/yard/tags/library.rb:338
msgid "Declares a readwrite attribute on a Struct or class."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:347 ../lib/yard/tags/library.rb:357
msgid ""
"# @attr_reader [String] name the name of the structure\n"
"# @attr_reader [Fixnum] size the size of the structure\n"
"class MyStruct < Struct; end"
msgstr ""

# YARD::Server::Commands::Base#request
# YARD::Server::Commands::Base#request=
# YARD::Server::Commands::Base#path
# YARD::Server::Commands::Base#path=
# YARD::Server::Commands::Base#headers
# YARD::Server::Commands::Base#headers=
# YARD::Server::Commands::Base#status
# YARD::Server::Commands::Base#status=
# YARD::Server::Commands::Base#body
# YARD::Server::Commands::Base#body=
#: ../lib/yard/tags/library.rb:347
msgid "Attribute Getter"
msgstr "Getter属性"

# @param [Boolean]
#: ../lib/yard/tags/library.rb:347
msgid "tag|yard.tag|attr_reader"
msgstr ""

# YARD::Tags::Library#attr_reader_tag
#: ../lib/yard/tags/library.rb:348
msgid "Declares a readonly attribute on a Struct or class."
msgstr ""

# YARD::Server::Commands::Base#request
# YARD::Server::Commands::Base#request=
# YARD::Server::Commands::Base#path
# YARD::Server::Commands::Base#path=
# YARD::Server::Commands::Base#headers
# YARD::Server::Commands::Base#headers=
# YARD::Server::Commands::Base#status
# YARD::Server::Commands::Base#status=
# YARD::Server::Commands::Base#body
# YARD::Server::Commands::Base#body=
#: ../lib/yard/tags/library.rb:357
msgid "Attribute Setter"
msgstr "Setter属性"

# @param [String]
#: ../lib/yard/tags/library.rb:357
msgid "tag|yard.tag|attr_writer"
msgstr ""

# YARD::Tags::Library#attr_writer_tag
#: ../lib/yard/tags/library.rb:358
msgid "Declares a writeonly attribute on a Struct or class."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:364
msgid ""
"# @author Foo Bar <foo@bar.com>\n"
"class MyClass; end"
msgstr ""

# @yard.tag author
#: ../lib/yard/tags/library.rb:364
msgid "[] Author"
msgstr ""

# @param [String]
#: ../lib/yard/tags/library.rb:364
msgid "tag|yard.tag|author"
msgstr ""

#: ../lib/yard/tags/library.rb:365
msgid "List the author or authors of a class, module, or method."
msgstr "著者やクラス,モジュール,メソッドの著者を記述する"

# @example Deprecate a method with a replacement API
#: ../lib/yard/tags/library.rb:380
msgid ""
"# @deprecated Use {#bar} instead.\n"
"def foo; end"
msgstr ""

# @yard.tag deprecated
#: ../lib/yard/tags/library.rb:380
msgid "[] Deprecated"
msgstr ""

# @example Deprecate a method with no replacement
#: ../lib/yard/tags/library.rb:380
msgid ""
"class Thread\n"
"  # @deprecated Exiting a thread in this way is not reliable and\n"
"  #   can cause a program crash.\n"
"  def kill; end\n"
"end"
msgstr ""

# @example
#: ../lib/yard/tags/library.rb:380
msgid "tag|example|Deprecate a method with a replacement API"
msgstr "tag|example|置換APIを用いメソッドをメソッドを廃止する"

# @example
#: ../lib/yard/tags/library.rb:380
msgid "tag|example|Deprecate a method with no replacement"
msgstr "tag|example|置換APIを用いないでメソッドを廃止する"

# @param [Boolean]
#: ../lib/yard/tags/library.rb:380
msgid "tag|yard.tag|deprecated"
msgstr ""

# YARD::Tags::Library#deprecated_tag
#: ../lib/yard/tags/library.rb:381
msgid ""
"Marks a method/class as deprecated with an optional description.\n"
"The description should be used to inform users of the recommended\n"
"migration path, and/or any useful information about why the object\n"
"was marked as deprecated."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:391
msgid ""
"# @example Reverse a String\n"
"#   \"mystring\".reverse #=> \"gnirtsym\"\n"
"def reverse; end"
msgstr ""

# @yard.tag [with_title_and_text] example
#: ../lib/yard/tags/library.rb:391
msgid "Example"
msgstr ""

# @yard.signature
#: ../lib/yard/tags/library.rb:391
msgid ""
"Optional title\n"
"Code block"
msgstr ""

# @param [String, CodeObjects::ExtraFileObject]
# @param [String]
# @param [String, Regexp]
#: ../lib/yard/tags/library.rb:391
msgid "tag|yard.tag|example"
msgstr ""

#: ../lib/yard/tags/library.rb:392
msgid ""
"Show an example snippet of code for an object. The first line\n"
"is an optional title."
msgstr "オブジェクト用にコード片の例を表示する。最初の行は任意のタイトル。"

#: ../lib/yard/tags/library.rb:399
msgid ""
"# @note This method should only be used in outer space.\n"
"def eject; end"
msgstr ""

# @yard.tag note
#: ../lib/yard/tags/library.rb:399
msgid "[] Note"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:399
msgid "tag|see|tag:todo"
msgstr ""

# @param [Parser::Ruby::AstNode]
#: ../lib/yard/tags/library.rb:399
msgid "tag|yard.tag|note"
msgstr ""

# YARD::Tags::Library#note_tag
#: ../lib/yard/tags/library.rb:400
msgid "Adds an emphasized note at the top of the docstring for the object"
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:418
msgid ""
"# @param [Hash] opts the options to create a message with.\n"
"# @option opts [String] :subject The subject\n"
"# @option opts [String] :from ('nobody') From address\n"
"# @option opts [String] :to Recipient email\n"
"# @option opts [String] :body ('') The email's body\n"
"def send_email(opts = {}) end"
msgstr ""

# @param [Hash] options
#: ../lib/yard/tags/library.rb:418
msgid "Options Hash"
msgstr "ハッシュのオプション"

# @yard.signature
#: ../lib/yard/tags/library.rb:418
msgid "name [Types] option_key (default_value) description"
msgstr ""

# @param [String, Symbol]
# @param [Symbol, String]
#: ../lib/yard/tags/library.rb:418
msgid "tag|yard.tag|option"
msgstr ""

#: ../lib/yard/tags/library.rb:419
msgid ""
"Describe an options hash in a method. The tag takes the\n"
"name of the options parameter first, followed by optional types,\n"
"the option key name, a default value for the key and a\n"
"description of the option. The default value should be placed within\n"
"parentheses and is optional (can be omitted)."
msgstr ""
"メソッドの中のハッシュのオプションを説明する。\n"
"タグは最初にoptionsのパラメータの名前(name)を取得し、\n"
"続いて任意で型(types)、オプションのキー名、\n"
"キー用のデフォルトの値、オプションの説明となる。\n"
"デフォルト値は任意で(入れなくてもよい)\n"
"括弧の中に置なければならない。"

# YARD::Tags::Library#option_tag
#: ../lib/yard/tags/library.rb:425
msgid ""
"Note that a +@param+ tag need not be defined for the options\n"
"hash itself, though it is useful to do so for completeness."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:437
msgid ""
"# @overload set(key, value)\n"
"#   Sets a value on key\n"
"#   @param [Symbol] key describe key param\n"
"#   @param [Object] value describe value param\n"
"# @overload set(value)\n"
"#   Sets a value on the default key +:foo+\n"
"#   @param [Object] value describe value param\n"
"def set(*args) end"
msgstr ""

# @yard.tag [OverloadTag] overload
#: ../lib/yard/tags/library.rb:437
msgid "Overloads"
msgstr ""

# @yard.signature
#: ../lib/yard/tags/library.rb:437
msgid ""
"method_signature(parameters)\n"
"Indented docstring for overload method"
msgstr ""

# @param [Fixnum]
#: ../lib/yard/tags/library.rb:437
msgid "tag|yard.tag|overload"
msgstr ""

#: ../lib/yard/tags/library.rb:438
msgid ""
"Describe that your method can be used in various\n"
"contexts with various parameters or return types. The first\n"
"line should declare the new method signature, and the following\n"
"indented tag data will be a new documentation string with its\n"
"own tags adding metadata for such an overload."
msgstr ""
"あなたのメソッドが様々なパラメータや戻りの型と一緒に\n"
"様々なコンテキストで利用される説明をする。\n"
"最初に行は新しいメソッドのシグネチャで宣言しなければならない、\n"
"そして続くインデントされたタグデータは\n"
"オーバーロードの様に自身の追加するメタデータタグを用い\n"
"新しいドキュメント文字列になる。"

# @example 
#: ../lib/yard/tags/library.rb:445
msgid ""
"# @param [String] the URL of the page to download\n"
"def load_page(url) end"
msgstr ""

# @yard.tag [with_types_and_name] param
#: ../lib/yard/tags/library.rb:445
msgid "Parameters"
msgstr ""

# @param [Array<Parser::Ruby::AstNode>]
# @param [Hash]
#: ../lib/yard/tags/library.rb:445
msgid "tag|yard.tag|param"
msgstr ""

# YARD::Tags::Library#param_tag
#: ../lib/yard/tags/library.rb:446
msgid ""
"Documents a single method parameter with a given name, type\n"
"and optional description."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:473
msgid ""
"# @private\n"
"class InteralImplementation; end"
msgstr ""

# @note
#: ../lib/yard/tags/library.rb:473
msgid ""
"This method is not recommended for hiding undocumented or\n"
"\"unimportant\" methods. This tag should only be used to mark objects\n"
"private when Ruby visibility rules cannot do so. In Ruby 1.9.3, you\n"
"can use +private_constant+ to declare constants (like classes or\n"
"modules) as private, and should be used instead of +@private+."
msgstr ""

# @yard.tag private
#: ../lib/yard/tags/library.rb:473
msgid "[] Private"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:473
msgid "tag|see|tag:api"
msgstr ""

# @param [String]
# @param [Array<String, Symbol>]
# @param [String, :root]
#: ../lib/yard/tags/library.rb:473
msgid "tag|yard.tag|private"
msgstr ""

# YARD::Tags::Library#private_tag
#: ../lib/yard/tags/library.rb:474
msgid ""
"Declares that the _logical_ visibility of an object is private.\n"
"In other words, it specifies that this method should be marked\n"
"private but cannot due to Ruby's visibility restrictions. This\n"
"exists for classes, modules and constants that do not obey Ruby's\n"
"visibility rules. For instance, an inner class might be considered\n"
"\"private\", though Ruby would make no such distinction."
msgstr ""

# YARD::Tags::Library#private_tag
#: ../lib/yard/tags/library.rb:481
msgid ""
"This tag is meant to be used in conjunction with the +--no-private+\n"
"command-line option, and is required to actually remove these objects\n"
"from documentation output. See {file:README.md} for more information on\n"
"switches."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:482
msgid ""
"# @raise [AccountBalanceError] if the account does not have\n"
"#   sufficient funds to perform the transaction\n"
"def withdraw(amount) end"
msgstr ""

# @yard.tag [with_types] raise
#: ../lib/yard/tags/library.rb:482
msgid "Raises"
msgstr ""

# @param [Boolean]
#: ../lib/yard/tags/library.rb:482
msgid "tag|yard.tag|raise"
msgstr ""

# YARD::Tags::Library#raise_tag
#: ../lib/yard/tags/library.rb:483
msgid ""
"Describes that a method may raise a given exception, with\n"
"an optional description of what it may mean."
msgstr ""

# YARD::Tags::Library#private_tag
#: ../lib/yard/tags/library.rb:486
msgid ""
"If you simply want to set the API visibility of a method, you should\n"
"look at the {tag:api} tag instead."
msgstr ""

# @example A regular return value
#: ../lib/yard/tags/library.rb:498
msgid ""
"# @return [Fixnum] the size of the file\n"
"def size; @file.size end"
msgstr ""

# @example A method returns an Array or a single object
#: ../lib/yard/tags/library.rb:498
msgid ""
"# @return [String] if a single object was returned\n"
"#   from the database.\n"
"# @return [Array<String>] if multiple objects were\n"
"#   returned.\n"
"def find(query) end"
msgstr ""

# @yard.tag [with_types] return
#: ../lib/yard/tags/library.rb:498
msgid "Returns"
msgstr ""

# @example
#: ../lib/yard/tags/library.rb:498
msgid "tag|example|A method returns an Array or a single object"
msgstr "tag|example|メソッドは配列や単一のオブジェクトを返す"

# @example
#: ../lib/yard/tags/library.rb:498
msgid "tag|example|A regular return value"
msgstr "tag|example|慣習的な戻り値の例"

# @param [Boolean]
#: ../lib/yard/tags/library.rb:498
msgid "tag|yard.tag|return"
msgstr ""

# YARD::Tags::Library#return_tag
#: ../lib/yard/tags/library.rb:499
msgid ""
"Describes the return value (and type or types) of a method.\n"
"You can list multiple return tags for a method in the case\n"
"where a method has distinct return cases. In this case, each\n"
"case should begin with \"if ...\"."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:510
msgid ""
"# Synchronizes system time using NTP.\n"
"# @see http://ntp.org/documentation.html NTP Documentation\n"
"# @see NTPHelperMethods\n"
"class NTPUpdater; end"
msgstr ""

# @yard.tag [with_name] see
#: ../lib/yard/tags/library.rb:510
msgid "See Also"
msgstr ""

# @param [Tags::Tag, Tags::RefTag]
#: ../lib/yard/tags/library.rb:510
msgid "tag|yard.tag|see"
msgstr ""

#: ../lib/yard/tags/library.rb:511
msgid ""
"\"See Also\" references for an object. Accepts URLs or\n"
"other code objects with an optional description at the end.\n"
"Note that the URL or object will be automatically linked by\n"
"YARD and does not need to be formatted with markup."
msgstr ""
"\"See Also(参照)\"はオブジェクトに参照される。\n"
"URLや最後で任意の説明を用いた他のコードオブジェクトを受入れる。\n"
"留意する事としてURLやオブジェクトは\n"
"YARDによって自動的にリンクされ、\n"
"マークアップを用いフォーマットされる必要はない。"

# @example 
#: ../lib/yard/tags/library.rb:518
msgid ""
"# @since 1.2.4\n"
"def clear_routes; end"
msgstr ""

# @yard.tag since
#: ../lib/yard/tags/library.rb:518
msgid "[] Since"
msgstr ""

# @param [Fixnum, nil]
#: ../lib/yard/tags/library.rb:518
msgid "tag|yard.tag|since"
msgstr ""

#: ../lib/yard/tags/library.rb:519
msgid "Lists the version that the object was first added."
msgstr "オブジェクトが最初に追加されたバージョンを記述する"

#: ../lib/yard/tags/library.rb:544
msgid ""
"# @todo Add support for Jabberwocky service.\n"
"#   There is an open source Jabberwocky library available\n"
"#   at http://jbrwcky.org that can be easily integrated.\n"
"class Wonderlander; end"
msgstr ""

# @yard.tag todo
#: ../lib/yard/tags/library.rb:544
msgid "[] Todo Item"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:544
msgid "tag|see|tag:note"
msgstr ""

# @param [String]
#: ../lib/yard/tags/library.rb:544
msgid "tag|yard.tag|todo"
msgstr ""

# YARD::Tags::Library#todo_tag
#: ../lib/yard/tags/library.rb:545
msgid ""
"Marks a TODO note in the object being documented.\n"
"For reference, objects with TODO items can be enumerated\n"
"from the command line with a simple command:"
msgstr ""

# YARD::Tags::Library#todo_tag
#: ../lib/yard/tags/library.rb:549
msgid ""
"  !!!sh\n"
"  mocker$ yard list --query '@todo'\n"
"  lib/mocker/mocker.rb:15: Mocker\n"
"  lib/mocker/report/html.rb:5: Mocker::Report::Html"
msgstr ""

# YARD::Tags::Library#todo_tag
#: ../lib/yard/tags/library.rb:554
msgid ""
"YARD can also be used to enumerate the TODO items from\n"
"a short script:"
msgstr ""

# YARD::Tags::Library#todo_tag
#: ../lib/yard/tags/library.rb:557
msgid ""
"  !!!ruby\n"
"  require 'yard'\n"
"  YARD::Registry.load!.all.each do |o|\n"
"    puts o.tag(:todo).text if o.tag(:todo)\n"
"  end"
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:557
msgid ""
"# The public REST API for http://jbrwcky.org\n"
"# @version 2.0\n"
"class JabberwockyAPI; end"
msgstr ""

# @yard.tag version
#: ../lib/yard/tags/library.rb:557
msgid "[] Version"
msgstr ""

# @param [Array<String>]
#: ../lib/yard/tags/library.rb:557
msgid "tag|yard.tag|version"
msgstr ""

# YARD::Tags::Library#version_tag
#: ../lib/yard/tags/library.rb:558
msgid ""
"Lists the version of a class, module or method. This is\n"
"similar to a library version, but at finer granularity.\n"
"In some cases, version of specific modules, classes, methods\n"
"or generalized components might change independently between\n"
"releases. A version tag is used to infer the API compatibility\n"
"of a specific object."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:573
msgid ""
"# For a block {|a,b,c| ... }\n"
"# @yield [a, b, c] Gives 3 random numbers to the block\n"
"def provide3values(&block) yield(42, 42, 42) end"
msgstr ""

# @yard.tag [with_types] yield
#: ../lib/yard/tags/library.rb:573
msgid "Yields"
msgstr ""

#: ../lib/yard/tags/library.rb:573
msgid "[parameters] description"
msgstr ""

# @yieldparam [Tags::Tag]
#: ../lib/yard/tags/library.rb:573
msgid "tag|see|tag:yieldparam"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:573
msgid "tag|see|tag:yieldreturn"
msgstr ""

# @param [Fixnum]
#: ../lib/yard/tags/library.rb:573
msgid "tag|yard.tag|yield"
msgstr ""

# YARD::Tags::Library#yield_tag
#: ../lib/yard/tags/library.rb:574
msgid ""
"Describes what a method might yield to a given block.\n"
"The types specifier list should not list types, but names\n"
"of the parameters yielded to the block. If you define\n"
"parameters with +@yieldparam+, you do not need to define\n"
"the parameters in the type specification of +@yield+ as\n"
"well."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:582
msgid ""
"# @yieldparam [String] name the name that is yielded\n"
"def with_name(name) yield(name) end"
msgstr ""

# @yard.tag [with_types_and_name] yieldparam
#: ../lib/yard/tags/library.rb:582
msgid "Yield Parameters"
msgstr ""

# @yieldparam [Tags::Tag]
#: ../lib/yard/tags/library.rb:582
msgid "tag|yard.tag|yieldparam"
msgstr ""

# YARD::Tags::Library#yieldparam_tag
#: ../lib/yard/tags/library.rb:583
msgid ""
"Defines a parameter yielded by a block. If you define the\n"
"parameters with +@yieldparam+, you do not need to define\n"
"them via +@yield+ as well."
msgstr ""

# @example 
#: ../lib/yard/tags/library.rb:591
msgid ""
"# @yieldreturn [Fixnum] the number to add 5 to.\n"
"def add5_block(&block) 5 + yield end"
msgstr ""

# @yard.tag [with_types] yieldreturn
#: ../lib/yard/tags/library.rb:591
msgid "Yield Returns"
msgstr ""

# @see
#: ../lib/yard/tags/library.rb:591
msgid "tag|see|tag:return"
msgstr ""

# @yard.tag [with_types]
#: ../lib/yard/tags/library.rb:591
msgid "tag|yard.tag|yieldreturn"
msgstr ""

# YARD::Tags::Library#yieldreturn_tag
#: ../lib/yard/tags/library.rb:592
msgid ""
"Documents the value and type that the block is expected\n"
"to return to the method."
msgstr ""

# @yard.directive [with_types_and_title] attribute
#: ../lib/yard/tags/library.rb:595
msgid "AttributeDirective"
msgstr ""

# @yard.signature
#: ../lib/yard/tags/library.rb:595
msgid ""
"[r | w | rw] attribute_name\n"
"Indented attribute docstring"
msgstr ""

# @param [Boolean]
#: ../lib/yard/tags/library.rb:595
msgid "tag|yard.directive|attribute"
msgstr ""

# @yard.directive [EndGroupDirective] endgroup
#: ../lib/yard/tags/library.rb:598
msgid "EndGroupDirective"
msgstr ""

# @yard.directive [EndGroupDirective]
#: ../lib/yard/tags/library.rb:598
msgid "tag|yard.directive|endgroup"
msgstr ""

# @yard.directive [GroupDirective] group
#: ../lib/yard/tags/library.rb:600
msgid "GroupDirective"
msgstr ""

# @yard.directive [GroupDirective]
#: ../lib/yard/tags/library.rb:600
msgid "tag|yard.directive|group"
msgstr ""

# @yard.directive [with_types_and_title] macro
#: ../lib/yard/tags/library.rb:604
msgid "MacroDirective"
msgstr ""

# @yard.signature
#: ../lib/yard/tags/library.rb:604
msgid ""
"[attach | new] optional_name\n"
"Optional macro expansion data"
msgstr ""

# @param [MacroObject]
# @param [CodeObjects::MacroObject]
#: ../lib/yard/tags/library.rb:604
msgid "tag|yard.directive|macro"
msgstr ""

# @yard.directive [with_title_and_text] method
#: ../lib/yard/tags/library.rb:608
msgid "MethodDirective"
msgstr ""

# @yard.signature
#: ../lib/yard/tags/library.rb:608
msgid ""
"method_signature(parameters)\n"
"Indented method docstring"
msgstr ""

# @yard.directive [with_title_and_text]
#: ../lib/yard/tags/library.rb:608
msgid "tag|yard.directive|method"
msgstr ""

# title
#: ../lib/yard/tags/library.rb:611
msgid "ParseDirective"
msgstr "パーサーディレクティブ"

# @return [Symbol]
#: ../lib/yard/tags/library.rb:611
msgid "[language] code"
msgstr ""

# @yard.directive [with_types]
#: ../lib/yard/tags/library.rb:611
msgid "tag|yard.directive|parse"
msgstr ""

# @yard.directive [ScopeDirective] scope
#: ../lib/yard/tags/library.rb:616
msgid "ScopeDirective"
msgstr ""

#: ../lib/yard/tags/library.rb:616
msgid "class | instance"
msgstr ""

# @param [Symbol]
#: ../lib/yard/tags/library.rb:616
msgid "tag|yard.directive|scope"
msgstr ""

#: ../lib/yard/tags/library.rb:617
msgid ""
"Sets the scope of a DSL method. Only applicable to DSL method\n"
"calls. Acceptable values are 'class' or 'instance'"
msgstr ""
"DSLメソッドのスコープに設定する。DSLメソッド呼び出しにだけ適用できる。\n"
"受け入れる値は'class'または'instance'である。"

# @yard.directive [VisibilityDirective] visibility
#: ../lib/yard/tags/library.rb:621
msgid "VisibilityDirective"
msgstr ""

# @yard.signature
#: ../lib/yard/tags/library.rb:621
msgid "public | protected | private"
msgstr ""

# @yard.directive [VisibilityDirective]
#: ../lib/yard/tags/library.rb:621
msgid "tag|yard.directive|visibility"
msgstr ""

#: ../lib/yard/tags/library.rb:622
msgid ""
"Sets the visibility of a DSL method. Only applicable to\n"
"DSL method calls. Acceptable values are public, protected, or private."
msgstr ""
"DSLメソッドの可視性を設定する。\n"
"DSLメソッド呼び出しに適用できる。\n"
"受け入れる値はpublic,protected,privateとなる"

# @param value
#: ../lib/yard/tags/option_tag.rb:4
msgid "the value to set the attribute pair to."
msgstr "pair属性に設定する値"

# YARD::Tags::OptionTag#pair
#: ../lib/yard/tags/option_tag.rb:5
msgid "Returns the value of attribute pair"
msgstr "pair属性の値を返す"

# YARD::Tags::OptionTag#pair=
#: ../lib/yard/tags/option_tag.rb:5
msgid "Sets the attribute pair"
msgstr "pair属性を設定する"

# @return [OptionTag]
#: ../lib/yard/tags/option_tag.rb:6
msgid "a new instance of OptionTag"
msgstr "オプションタグの新しいインスタンス"

# YARD::Tags::OverloadTag#parameters
#: ../lib/yard/tags/overload_tag.rb:5
msgid "Returns the value of attribute parameters"
msgstr "parameters属性の値を返す"

# YARD::Tags::OverloadTag#signature
#: ../lib/yard/tags/overload_tag.rb:5
msgid "Returns the value of attribute signature"
msgstr "signature属性の値を返す"

# @return [OverloadTag]
#: ../lib/yard/tags/overload_tag.rb:6
msgid "a new instance of OverloadTag"
msgstr "OverloadTagの新しいインスタンス"

# @param value
#: ../lib/yard/tags/ref_tag_list.rb:4
msgid "the value to set the attribute tag_name to."
msgstr "tag_name属性を設定する値"

# YARD::Tags::RefTagList#tag_name
#: ../lib/yard/tags/ref_tag_list.rb:5
msgid "Returns the value of attribute tag_name"
msgstr "tag_name属性の値を返す"

# YARD::Tags::RefTagList#tag_name=
#: ../lib/yard/tags/ref_tag_list.rb:5
msgid "Sets the attribute tag_name"
msgstr "tag_name属性を設定する"

# @return [RefTagList]
#: ../lib/yard/tags/ref_tag_list.rb:6
msgid "a new instance of RefTagList"
msgstr "RefTagListの新しいインスタンス"

# YARD::Tags::Tag
#: ../lib/yard/tags/tag.rb:4
msgid ""
"Represents a metadata tag value (+@tag+). Tags can have any combination of\n"
"{#types}, {#name} and {#text}, or none of the above."
msgstr ""
"タグはメタデータタグの値(+@tag+)を表し\n"
"任意の{#types},{#name},{#text},又は,\n"
"前述のどれでもないメソッドの組み合わせを持つ事が出来る。"

# @example Programmatic tag creation
#: ../lib/yard/tags/tag.rb:12
msgid ""
"# The following docstring syntax:\n"
"#   @param [String, nil] arg an argument\n"
"#\n"
"# is equivalent to:\n"
"Tag.new(:param, 'an argument', ['String', 'nil'], 'arg')"
msgstr ""
"# 次のdocstring構文は:\n"
"#   @param [String, nil] arg an argument\n"
"#\n"
"# 以下と同様になる。\n"
"Tag.new(:param, 'an argument', ['String', 'nil'], 'arg')"

# @example
#: ../lib/yard/tags/tag.rb:12
msgid "tag|example|Programmatic tag creation"
msgstr "タグを作成するプログラム例"

# @return [nil]
#: ../lib/yard/tags/tag.rb:18
msgid "if no tag text is supplied"
msgstr "タグテキストが指定されない場合"

# @return [String]
#: ../lib/yard/tags/tag.rb:18
msgid "the tag text associated with the tag"
msgstr "タグと一緒に関連付けられるタグテキスト"

# @return [Array<String>]
#: ../lib/yard/tags/tag.rb:22
msgid "a list of types associated with the tag"
msgstr "タグと一緒に関連付けられる型のリスト"

# @return [nil]
#: ../lib/yard/tags/tag.rb:22
msgid "if no types are associated with the tag"
msgstr "型がタグと一緒に関連付けられない場合"

# @return [String]
#: ../lib/yard/tags/tag.rb:25
msgid "a name associated with the tag"
msgstr "タグと共に関連づけられる,名前"

# @return [CodeObjects::Base]
#: ../lib/yard/tags/tag.rb:28
msgid "the associated object"
msgstr "関連するオブジェクト"

# YARD::Tags::Tag#initialize
#: ../lib/yard/tags/tag.rb:31
msgid ""
"Creates a new tag object with a tag name and text. Optionally, formally "
"declared types\n"
"and a key name can be specified."
msgstr ""
"タグ名とテキストと共に新しいタグオブジェクトを作成する。\n"
"任意で、形式的に宣言される型やキー名を指定する事が出来る。"

# YARD::Tags::Tag#initialize
#: ../lib/yard/tags/tag.rb:34
msgid ""
"Types are mainly for meta tags that rely on type information, such as +param"
"+, +return+, etc."
msgstr "型は主に、+param+, +return+等の様な型情報を頼るメタタグ用である。"

# YARD::Tags::Tag#initialize
#: ../lib/yard/tags/tag.rb:36
msgid ""
"Key names are for tags that declare meta data for a specific key or name, "
"such as +param+,\n"
"+raise+, etc."
msgstr ""
"キー名(name)は +param+ , +raise+ 等のような\n"
"特定のキーや名前用のメタデータを宣言するタグの為にある。"

# @return [Tag]
#: ../lib/yard/tags/tag.rb:43
msgid "a new instance of Tag"
msgstr "タグの新しいインスタンス"

# @param [String] name
#: ../lib/yard/tags/tag.rb:43
msgid "optional key name which the tag refers to"
msgstr "タグが参照する,任意のキー名"

# @param [Array<String>] types
#: ../lib/yard/tags/tag.rb:43
msgid ""
"optional type list of formally declared types\n"
"for the tag"
msgstr "タグ用に形式的に宣言された型の入った,任意の型配列"

# @param [String] text
#: ../lib/yard/tags/tag.rb:43
msgid "the descriptive text for this tag"
msgstr "このタグの為の説明文"

# @param [#to_s] tag_name
#: ../lib/yard/tags/tag.rb:43
msgid "the tag name to create the tag for"
msgstr "タグを作成する為のタグ名"

# YARD::Tags::Tag#type
#: ../lib/yard/tags/tag.rb:48
msgid ""
"Convenience method to access the first type specified. This should mainly\n"
"be used for tags that only specify one type."
msgstr ""
"最初の指定される型にアクセスする為の便利なメソッド,\n"
"これは、主に型が一つだけのタグを指定する時に利用されるべきである。"

# @see
#: ../lib/yard/tags/tag.rb:52
msgid "tag|see|#types"
msgstr ""

# @return [String]
#: ../lib/yard/tags/tag.rb:52
msgid "the first of the list of specified types"
msgstr "指定される型のリストの最初の部分"

# YARD::Templates::Engine
#: ../lib/yard/templates/engine.rb:6
msgid ""
"This module manages all creation, handling and rendering of {Template}\n"
"objects."
msgstr ""
"このモジュールは、全ての作成を管理し,操作する。そして、{Template}オブジェクト"
"から表示する。"

# YARD::Templates::Engine
#: ../lib/yard/templates/engine.rb:9
msgid ""
"* To create a template object at a path, use {template}.\n"
"* To render a template, call {render}.\n"
"* To register a template path in the lookup paths, call "
"{register_template_path}."
msgstr ""
"* パスでテンプレートオブジェクトを作成するには、{template}を使う\n"
"* テンプレートを表示するには、{render}を呼び出す\n"
"* 検索するパスでテンプレートパスを記録するには、{register_template_path}を呼"
"び出す。"

# @return [Array<String>]
#: ../lib/yard/templates/engine.rb:14
msgid "the list of registered template paths"
msgstr "渡されたテンプレートパスのリスト"

# YARD::Templates::Engine.register_template_path
#: ../lib/yard/templates/engine.rb:17
msgid "Registers a new template path in {template_paths}"
msgstr "{template_paths}の中で、新しいテンプレートパスを記録する"

# @param [String] path
#: ../lib/yard/templates/engine.rb:20
msgid "a new template path"
msgstr "新しいテンプレートパス"

# YARD::Templates::Engine.template
#: ../lib/yard/templates/engine.rb:25
msgid ""
"Creates a template module representing the path. Searches on disk\n"
"for the first directory named +path+ (joined by '/') within the\n"
"template paths and builds a template module for. All other matching\n"
"directories in other template paths will be included in the\n"
"generated module as mixins (for overriding)."
msgstr ""
"パスを表すテンプレートモジュールを作成する。\n"
"テンプレートパスの内部で、\n"
"+path+ と名付けられた最初のディレクトリ('/'区切り)用に、\n"
"ディスク上をサーチする。\n"
"そして、テンプレートモジュール用にビルドする。\n"
"他にマッチするテンプレートパスの中のディレクトリ全ては、mixinとして(オーバー"
"ライド用に)、\n"
"生成されたモジュールが含まれる。"

# @param [Array<String, Symbol>] path
#: ../lib/yard/templates/engine.rb:34
msgid "a list of path components"
msgstr "構成要素のパスのリスト"

# @raise [ArgumentError]
#: ../lib/yard/templates/engine.rb:34
msgid ""
"if the path does not exist within one of the\n"
"{template_paths} on disk."
msgstr "ディスク上に{template_paths}が一つも存在しない場合、例外を上げる。"

# @return [Template]
#: ../lib/yard/templates/engine.rb:34
msgid "the module representing the template"
msgstr "モジュールの表しているテンプレート"

# YARD::Templates::Engine.template!
#: ../lib/yard/templates/engine.rb:48
msgid "Forces creation of a template at +path+ within a +full_path+."
msgstr ""
"+fullpath+ 内部の\n"
"+path+ で、テンプレートの作成を強制する。"

# @param [Array<String>]
#: ../lib/yard/templates/engine.rb:52
msgid "tag|param|full_paths"
msgstr ""

# @param [Array<String>] full_paths
#: ../lib/yard/templates/engine.rb:52
msgid "the full path on disk of the template"
msgstr "テンプレートのディスク上のフルパス"

# @param [String] path
#: ../lib/yard/templates/engine.rb:52
msgid "the path name of the template"
msgstr "テンプレートのパス名"

# @return [Template]
#: ../lib/yard/templates/engine.rb:52
msgid "the template module representing the +path+"
msgstr "テンプレートモジュールは、+path+ を表している。"

# YARD::Templates::Engine.render
#: ../lib/yard/templates/engine.rb:65
msgid ""
"Renders a template on a {CodeObjects::Base code object} using\n"
"a set of default (overridable) options. Either the +:object+\n"
"or +:type+ keys must be provided."
msgstr ""
"デフォルトのオプション(上書き可能)のグループによって、\n"
"{Codeobject::base code object}のテンプレートを表示する。\n"
"+:object+ か +:type+ キーが提供されければならない。"

# YARD::Templates::Engine.render
#: ../lib/yard/templates/engine.rb:69
msgid ""
"If a +:serializer+ key is provided and +:serialize+ is not set to\n"
"false, the rendered contents will be serialized through the {Serializers::"
"Base}\n"
"object. See {with_serializer}."
msgstr ""
"+:serializer+ キーが提供されるか、 +:serialize+ にfalseを設定しない場合、\n"
"表示される内容は、{Serializers::Base}オブジェクトを通して、シリアライズされる"
"だろう。\n"
"{with_serializer}参照。"

# @example Renders an object with html formatting
#: ../lib/yard/templates/engine.rb:81
msgid "Engine.render(:format => :html, :object => obj)"
msgstr ""

# @example Renders without an object
#: ../lib/yard/templates/engine.rb:81
msgid "Engine.render(:type => :fulldoc, :otheropts => somevalue)"
msgstr ""

# @example
#: ../lib/yard/templates/engine.rb:81
msgid "tag|example|Renders an object with html formatting"
msgstr "htmlフォーマットと共にオブジェクトを表示する"

# @example
#: ../lib/yard/templates/engine.rb:81
msgid "tag|example|Renders without an object"
msgstr "オブジェクト無しの表示"

# @param [Hash] options
#: ../lib/yard/templates/engine.rb:81 ../lib/yard/templates/engine.rb:140
msgid "the options hash"
msgstr "ハッシュのオプション"

# YARD::Templates::Engine.generate
#: ../lib/yard/templates/engine.rb:93
msgid ""
"Passes a set of objects to the +:fulldoc+ template for full documentation "
"generation.\n"
"This is called by {CLI::Yardoc} to most commonly perform HTML\n"
"documentation generation."
msgstr ""
"完璧なドキュメント生成用に、+:fulldoc+ テンプレートに\n"
"オブジェクトのグループが渡される。\n"
"これは、{CLI::Yardoc}によって呼び出される\n"
"一般的にhtmlドキュメント生成を実行しなければならない。"

# @param [Hash] options
#: ../lib/yard/templates/engine.rb:100
msgid "(see {render})"
msgstr ""

# @param [Array<CodeObjects::Base>] objects
#: ../lib/yard/templates/engine.rb:100
msgid ""
"a list of {CodeObjects::Base}\n"
"objects to pass to the template"
msgstr ""
"テンプレートに渡す為の\n"
"{CodeObjects::Base} オブジェクトのリスト"

# YARD::Templates::Engine.with_serializer
#: ../lib/yard/templates/engine.rb:108
msgid "Serializes the results of a block with a +serializer+ object."
msgstr "+serializer+ オブジェクトを用いブロックの結果をシリアライズする。"

# @yield
#: ../lib/yard/templates/engine.rb:114
msgid "a block whose result will be serialize"
msgstr "結果がシリアライズされるブロック"

# @param [Serializers::Base]
#: ../lib/yard/templates/engine.rb:114
msgid "tag|param|serializer"
msgstr "serializer"

# @see
#: ../lib/yard/templates/engine.rb:114
msgid "tag|see|Serializers::Base"
msgstr ""

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/engine.rb:114
msgid "the code object to serialize"
msgstr "シリアライズする為のコードオブジェクト"

# @yieldreturn [String]
#: ../lib/yard/templates/engine.rb:114
msgid "the contents to serialize"
msgstr "シリアライズする為の内容"

# @param [Serializers::Base] serializer
#: ../lib/yard/templates/engine.rb:114
msgid "the serializer object"
msgstr "シリアライザーオブジェクト"

# YARD::Templates::Engine.set_default_options
#: ../lib/yard/templates/engine.rb:134
msgid "Sets default options on the options hash"
msgstr "ハッシュのオプションのデフォルトのオプションを設定する。"

# YARD::Templates::Engine.find_template_paths
#: ../lib/yard/templates/engine.rb:152
msgid ""
"Searches through the registered {template_paths} and returns\n"
"all full directories that have the +path+ within them on disk."
msgstr ""
"記録される{template_paths}を通して、検索され、\n"
"ディスク上に +path+ を持つ全てのディレクトリを返す。\n"

# @return [Array<String>]
#: ../lib/yard/templates/engine.rb:160
msgid ""
"a list of full paths that are existing\n"
"candidates for a template module"
msgstr "テンプレートモジュール用の候補が存在するフルパスのリスト"

# @param [Template] from_template
#: ../lib/yard/templates/engine.rb:160
msgid ""
"if provided, allows a relative\n"
"path to be specified from this template's full path."
msgstr ""
"提供された場合、\n"
"このテンプレートのフルパスから指定される相対パスを受入れる。"

# @param [Template]
#: ../lib/yard/templates/engine.rb:160
msgid "tag|param|from_template"
msgstr "from_template"

# @param [String] path
#: ../lib/yard/templates/engine.rb:160
msgid ""
"the path component to search for in the\n"
"{template_paths}"
msgstr "{template_paths}用に検索する為のパスの構成"

# YARD::Templates::Engine.template_module_name
#: ../lib/yard/templates/engine.rb:172
msgid "The name of the module that represents a +path+"
msgstr "+path+ を表すモジュール名"

# @return [String]
#: ../lib/yard/templates/engine.rb:175
msgid "the module name"
msgstr "モジュール名"

# @param [String] the
#: ../lib/yard/templates/engine.rb:175
msgid "the path to generate a module name for"
msgstr "パス用のモジュール名を生成する為のパス"

# YARD::Templates::Helpers::BaseHelper
#: ../lib/yard/templates/helpers/base_helper.rb:3
msgid "The base helper module included in all templates."
msgstr "ベースへルパーモジュールは、全てのテンプレートを含んでいる。"

# @param value
#: ../lib/yard/templates/helpers/base_helper.rb:4
msgid "the value to set the attribute object to."
msgstr "オブジェクトの属性を設定する値"

# @param value
#: ../lib/yard/templates/helpers/base_helper.rb:4
msgid "the value to set the attribute serializer to."
msgstr "シリアライザーの属性を設定する値"

# YARD::Templates::Helpers::BaseHelper#object
#: ../lib/yard/templates/helpers/base_helper.rb:5
msgid "Returns the value of attribute object"
msgstr "オブジェクトの属性の値を返す"

# YARD::Templates::Helpers::BaseHelper#serializer
#: ../lib/yard/templates/helpers/base_helper.rb:5
msgid "Returns the value of attribute serializer"
msgstr "シリアライザーの属性の値を返す"

# YARD::Templates::Helpers::BaseHelper#object=
#: ../lib/yard/templates/helpers/base_helper.rb:5
msgid "Sets the attribute object"
msgstr "オブジェクトの属性を設定する。"

# YARD::Templates::Helpers::BaseHelper#serializer=
#: ../lib/yard/templates/helpers/base_helper.rb:5
msgid "Sets the attribute serializer"
msgstr "シリアライザーの属性を設定する。"

# @return [CodeObjects::Base]
#: ../lib/yard/templates/helpers/base_helper.rb:8
#: ../lib/yard/templates/helpers/base_helper.rb:10
msgid ""
"the object representing the current generated\n"
"page. Might not be the current {#object} when inside sub-templates."
msgstr ""

# YARD::Templates::Helpers::BaseHelper#globals
#: ../lib/yard/templates/helpers/base_helper.rb:15
msgid ""
"An object that keeps track of global state throughout the entire template\n"
"rendering process (including any sub-templates)."
msgstr ""
"全体のテンプレートの表示処理を通じて、globalの状態の軌跡を保持するオブジェク"
"ト。\n"
"(任意のサブテンプレートを含んでいる)"

# YARD::Templates::Helpers::BaseHelper#globals
#: ../lib/yard/templates/helpers/base_helper.rb:19
msgid "Managing Global Template State"
msgstr "グローバルなテンプレートの状態を管理する。"

# @return [OpenStruct]
#: ../lib/yard/templates/helpers/base_helper.rb:19
msgid "a struct object that stores state"
msgstr "状態を記憶する構造体オブジェクト"

# YARD::Templates::Helpers::BaseHelper#run_verifier
#: ../lib/yard/templates/helpers/base_helper.rb:29
msgid "Running the Verifier"
msgstr "Verifierを起動する。"

# @param [Array<CodeObjects::Base>] list
#: ../lib/yard/templates/helpers/base_helper.rb:29 ../lib/yard/verifier.rb:90
msgid "a list of code objects"
msgstr "コードオブジェクトのリスト"

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/templates/helpers/base_helper.rb:29
msgid ""
"a list of code objects that match\n"
"the verifier. If no verifier is supplied, all objects are returned."
msgstr ""
"verifierにマッチするコードオブジェクトのリスト\n"
"verifierが提供されない場合、全てのオブジェクトが、返される。"

# YARD::Templates::Helpers::BaseHelper#h
#: ../lib/yard/templates/helpers/base_helper.rb:36
msgid ""
"Escapes text. This is used a lot by the HtmlHelper and there should\n"
"be some helper to \"clean up\" text for whatever, this is it."
msgstr ""
"テキストをエスケープする。これは、HtmlHelperに多く利用され、\n"
"どんなテキストでも仕上げる為にいくつかのhelperメソッドになる。"

# YARD::Templates::Helpers::BaseHelper#h
#: ../lib/yard/templates/helpers/base_helper.rb:37
msgid "Escaping Text"
msgstr "テキストをエスケープする。"

# YARD::Templates::Helpers::BaseHelper#linkify
#: ../lib/yard/templates/helpers/base_helper.rb:44
msgid ""
"Links objects or URLs. This method will delegate to the correct +link_+\n"
"method depending on the arguments passed in."
msgstr ""
"オブジェクトやURLをリンクする。このメソッドは、\n"
"渡された引数に応じて、妥当な +link_+ メソッドに委譲するだろう。"

# YARD::Templates::Helpers::BaseHelper#linkify
# YARD::Templates::Helpers::BaseHelper#link_include_object
# YARD::Templates::Helpers::BaseHelper#link_include_file
# YARD::Templates::Helpers::BaseHelper#link_object
# YARD::Templates::Helpers::BaseHelper#link_url
# YARD::Templates::Helpers::BaseHelper#link_file
# YARD::Templates::Helpers::HtmlHelper#resolve_links
# YARD::Templates::Helpers::HtmlHelper#link_file
# YARD::Templates::Helpers::HtmlHelper#link_include_file
# YARD::Templates::Helpers::HtmlHelper#link_include_object
# YARD::Templates::Helpers::HtmlHelper#link_object
# YARD::Templates::Helpers::HtmlHelper#link_url
#: ../lib/yard/templates/helpers/base_helper.rb:54
#: ../lib/yard/templates/helpers/base_helper.rb:102
#: ../lib/yard/templates/helpers/base_helper.rb:110
#: ../lib/yard/templates/helpers/base_helper.rb:119
#: ../lib/yard/templates/helpers/base_helper.rb:138
#: ../lib/yard/templates/helpers/base_helper.rb:149
#: ../lib/yard/templates/helpers/html_helper.rb:180
#: ../lib/yard/templates/helpers/html_helper.rb:219
#: ../lib/yard/templates/helpers/html_helper.rb:231
#: ../lib/yard/templates/helpers/html_helper.rb:240
#: ../lib/yard/templates/helpers/html_helper.rb:245
#: ../lib/yard/templates/helpers/html_helper.rb:273
msgid "Linking Objects and URLs"
msgstr "オブジェクトとURLにリンクする。"

# @example Linking an object by path
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "linkify('YARD::Docstring')"
msgstr ""

# @example Linking to an extra file
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "linkify('file:README')"
msgstr ""

# @example Linking a URL
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "linkify('http://example.com')"
msgstr ""

# @example Including docstring contents of an object
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "linkify('include:YARD::Docstring')"
msgstr ""

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "tag|example|Including docstring contents of an object"
msgstr "インクルードしているdocstringは、オブジェクトの内容となる。"

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "tag|example|Linking a URL"
msgstr "URLにリンクする。"

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "tag|example|Linking an object by path"
msgstr "パスによってオブジェクトにリンクする"

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:54
msgid "tag|example|Linking to an extra file"
msgstr "extraファイル(追加のファイル)にリンクする。"

# YARD::Templates::Helpers::BaseHelper#link_include_object
# YARD::Templates::Helpers::HtmlHelper#link_include_object
#: ../lib/yard/templates/helpers/base_helper.rb:99
#: ../lib/yard/templates/helpers/html_helper.rb:241
msgid "Includes an object's docstring into output."
msgstr "出力へ、オブジェクトのdocstringを含める"

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/helpers/base_helper.rb:102
msgid "the object to include"
msgstr "含めるオブジェクト"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:102
msgid "the object's docstring (no tags)"
msgstr "docstringオブジェクト(タグ無し)"

# YARD::Templates::Helpers::BaseHelper#link_include_file
# YARD::Templates::Helpers::HtmlHelper#link_include_file
#: ../lib/yard/templates/helpers/base_helper.rb:107
#: ../lib/yard/templates/helpers/html_helper.rb:232
msgid "Include a file as a docstring in output"
msgstr "出力でdocstringとして、ファイルを含める"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:110
msgid "the file's contents"
msgstr "ファイルの内容"

# @param [String] file
#: ../lib/yard/templates/helpers/base_helper.rb:110
msgid "the filename to include"
msgstr "含めるファイル名"

# YARD::Templates::Helpers::BaseHelper#link_object
# YARD::Templates::Helpers::HtmlHelper#link_object
#: ../lib/yard/templates/helpers/base_helper.rb:115
#: ../lib/yard/templates/helpers/html_helper.rb:246
msgid "Links to an object with an optional title"
msgstr "任意のタイトルと共にオブジェクトにリンクする"

# @param [String]
#: ../lib/yard/templates/helpers/base_helper.rb:119
#: ../lib/yard/templates/helpers/base_helper.rb:138
#: ../lib/yard/templates/helpers/base_helper.rb:149
msgid "tag|param|title"
msgstr "title"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:119
msgid "the linked object"
msgstr "リンクしたオブジェクト"

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/helpers/base_helper.rb:119
msgid "the object to link to"
msgstr "リンクするオブジェクト"

# @param [String] title
#: ../lib/yard/templates/helpers/base_helper.rb:119
msgid "the title to use for the link"
msgstr "リンク用に利用するタイトル"

# YARD::Templates::Helpers::BaseHelper#link_url
# YARD::Templates::Helpers::HtmlHelper#link_url
#: ../lib/yard/templates/helpers/base_helper.rb:133
#: ../lib/yard/templates/helpers/html_helper.rb:274
msgid "Links to a URL"
msgstr "URLにリンクする"

# @param [Hash] params
#: ../lib/yard/templates/helpers/base_helper.rb:138
msgid "optional parameters for the link"
msgstr "リンク用の任意のパラメーター"

# @param [String] url
#: ../lib/yard/templates/helpers/base_helper.rb:138
msgid "the URL to link to"
msgstr "リンクするURL"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:138
msgid "the linked URL"
msgstr "リンクしたURL"

# @param [String] title
#: ../lib/yard/templates/helpers/base_helper.rb:138
msgid "the optional title to display the link as"
msgstr "任意のタイトルとして、リンクに表示する"

# YARD::Templates::Helpers::BaseHelper#link_file
# YARD::Templates::Helpers::HtmlHelper#link_file
#: ../lib/yard/templates/helpers/base_helper.rb:143
#: ../lib/yard/templates/helpers/html_helper.rb:220
msgid "Links to an extra file"
msgstr "extraファイルにリンクする"

# @param [String] anchor
#: ../lib/yard/templates/helpers/base_helper.rb:149
#: ../lib/yard/templates/helpers/html_helper.rb:342
msgid "optional anchor"
msgstr "任意のアンカー"

# @param [String]
#: ../lib/yard/templates/helpers/base_helper.rb:149
#: ../lib/yard/templates/helpers/html_helper.rb:309
#: ../lib/yard/templates/helpers/html_helper.rb:342
msgid "tag|param|anchor"
msgstr "anchor"

# @param [String, CodeObjects::ExtraFileObject] filename
# @param [String] filename
#: ../lib/yard/templates/helpers/base_helper.rb:149
#: ../lib/yard/templates/helpers/html_helper.rb:342
msgid "the filename to link to"
msgstr "リンクするファイル名"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:149
msgid "the link to the file"
msgstr "ファイルへのリンク"

# @param [String] title
#: ../lib/yard/templates/helpers/base_helper.rb:149
msgid "the title of the link"
msgstr "リンクのタイトル"

# YARD::Templates::Helpers::BaseHelper#format_types
#: ../lib/yard/templates/helpers/base_helper.rb:157
msgid "Formats a list of return types for output and links each type."
msgstr "出力用に戻りの型のリストをフォーマットし、それぞれの型にリンクする。"

# YARD::Templates::Helpers::BaseHelper#format_types
# YARD::Templates::Helpers::BaseHelper#format_object_type
# YARD::Templates::Helpers::BaseHelper#format_object_title
# YARD::Templates::Helpers::BaseHelper#format_source
#: ../lib/yard/templates/helpers/base_helper.rb:165
#: ../lib/yard/templates/helpers/base_helper.rb:179
#: ../lib/yard/templates/helpers/base_helper.rb:193
#: ../lib/yard/templates/helpers/base_helper.rb:206
msgid "Formatting Object Attributes"
msgstr "オブジェクトの属性をフォーマットする"

# @param [Array<String>] list
#: ../lib/yard/templates/helpers/base_helper.rb:165
msgid "a list of types"
msgstr "型のリスト"

# @example Formatting types
#: ../lib/yard/templates/helpers/base_helper.rb:165
msgid "format_types(['String', 'Array']) #=> \"(String, Array)\""
msgstr ""

# @example Formatting types without surrounding brackets
#: ../lib/yard/templates/helpers/base_helper.rb:165
msgid "format_types(['String', 'Array'], false) #=> \"String, Array\""
msgstr ""

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:165
msgid "tag|example|Formatting types"
msgstr "型をフォーマットする"

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:165
msgid "tag|example|Formatting types without surrounding brackets"
msgstr "周りをブラケット(括弧)無しの型へフォーマットする"

# @param [Boolean]
#: ../lib/yard/templates/helpers/base_helper.rb:165
#: ../lib/yard/templates/helpers/html_helper.rb:414
msgid "tag|param|brackets"
msgstr "brackets"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:165
msgid "the formatted list of Ruby types"
msgstr "フォーマットされたRubyの型のリスト"

# @param [Boolean] brackets
#: ../lib/yard/templates/helpers/base_helper.rb:165
msgid "whether to surround the types in brackets"
msgstr "ブラケット(括弧)の型で囲むかどうか"

# @example Formatted type of an exception class
#: ../lib/yard/templates/helpers/base_helper.rb:179
msgid ""
"o = ClassObject.new(:root, :MyError)\n"
"o.superclass = P('RuntimeError')\n"
"format_object_type(o) # => \"Exception\""
msgstr ""

# @example Formatted type of a method
#: ../lib/yard/templates/helpers/base_helper.rb:179
msgid ""
"o = MethodObject.new(:root, :to_s)\n"
"format_object_type(o) # => \"Method\""
msgstr ""

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:179
msgid "tag|example|Formatted type of a method"
msgstr "メソッドの入ったフォーマットされた型"

# @example
#: ../lib/yard/templates/helpers/base_helper.rb:179
msgid "tag|example|Formatted type of an exception class"
msgstr "exceptionクラスのフォーマットされた型"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:179
msgid ""
"the human-readable formatted {CodeObjects::Base#type #type}\n"
"for the object"
msgstr ""
"人が読みやすくフォーマットされたオブジェクト用の{CodeObjects::Base#type "
"#type}メソッド"

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/helpers/base_helper.rb:179
msgid "the object to retrieve the type for"
msgstr "型を回収するオブジェクト"

# @example 
#: ../lib/yard/templates/helpers/base_helper.rb:193
msgid ""
"s = format_object_title ModuleObject.new(:root, :MyModuleName)\n"
"s # => \"Module: MyModuleName\""
msgstr ""

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/helpers/base_helper.rb:193
msgid "the object to retrieve a title for"
msgstr "タイトルを回収するオブジェクト"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:193
msgid "the page title name for a given object"
msgstr "与えられたオブジェクト用のページのタイトル名"

# YARD::Templates::Helpers::BaseHelper#format_source
#: ../lib/yard/templates/helpers/base_helper.rb:203
msgid "Indents and formats source code"
msgstr "インデントし、ソースコードをフォーマットする"

# @return [String]
#: ../lib/yard/templates/helpers/base_helper.rb:206
msgid "formatted source code"
msgstr "フォーマットされたソースコード"

# @param [String] value
#: ../lib/yard/templates/helpers/base_helper.rb:206
msgid "the input source code"
msgstr "入力のソースコード"

# YARD::Templates::Helpers::FilterHelper
#: ../lib/yard/templates/helpers/filter_helper.rb:4
msgid "Helpers for various object types"
msgstr "様々なオブジェクト型用のHelperメソッド"

# @return [Boolean]
#: ../lib/yard/templates/helpers/filter_helper.rb:6
msgid "whether an object is a method"
msgstr "オブジェクトがメソッドかどうか"

# @return [Boolean]
#: ../lib/yard/templates/helpers/filter_helper.rb:11
msgid "whether an object is a namespace"
msgstr "オブジェクトがnamespaceかどうか"

# @return [Boolean]
#: ../lib/yard/templates/helpers/filter_helper.rb:16
msgid "whether an object is a class"
msgstr "オブジェクトがクラスかどうか"

# @return [Boolean]
#: ../lib/yard/templates/helpers/filter_helper.rb:21
msgid "whether an object is a module"
msgstr "オブジェクトがモジュールかどうか"

# YARD::Templates::Helpers::HtmlHelper
#: ../lib/yard/templates/helpers/html_helper.rb:6
msgid "The helper module for HTML templates."
msgstr "HTMLテンプレート用のhelperモジュール。"

# YARD::Templates::Helpers::HtmlHelper#h
#: ../lib/yard/templates/helpers/html_helper.rb:13
msgid "Escapes HTML entities"
msgstr "HTMLの構成要素をエスケープする。"

# YARD::Templates::Helpers::HtmlHelper#h
# YARD::Templates::Helpers::HtmlHelper#urlencode
#: ../lib/yard/templates/helpers/html_helper.rb:16
#: ../lib/yard/templates/helpers/html_helper.rb:24
msgid "Escaping Template Data"
msgstr "テンプレートのデータをエスケープする。"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:16
msgid "the HTML with escaped entities"
msgstr "エスケープされたものと一緒のHTML"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:16
msgid "the text to escape"
msgstr "エスケープするテキスト"

# YARD::Templates::Helpers::HtmlHelper#urlencode
#: ../lib/yard/templates/helpers/html_helper.rb:21
msgid "Escapes a URL"
msgstr "URLをエスケープする"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:24
msgid "the URL"
msgstr "URL"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:24
msgid "the escaped URL"
msgstr "エスケープされたURL"

# YARD::Templates::Helpers::HtmlHelper#htmlify
#: ../lib/yard/templates/helpers/html_helper.rb:31
msgid "Turns text into HTML using +markup+ style formatting."
msgstr ""
"+markup+ スタイルフォーマットにする事によって、HTMLへテキストを切り替える。"

# YARD::Templates::Helpers::HtmlHelper#htmlify
# YARD::Templates::Helpers::HtmlHelper#html_markup_markdown
# YARD::Templates::Helpers::HtmlHelper#html_markup_textile
# YARD::Templates::Helpers::HtmlHelper#html_markup_rdoc
# YARD::Templates::Helpers::HtmlHelper#html_markup_text
# YARD::Templates::Helpers::HtmlHelper#html_markup_none
# YARD::Templates::Helpers::HtmlHelper#html_markup_html
# YARD::Templates::Helpers::HtmlHelper#html_markup_ruby
# YARD::Templates::Helpers::HtmlHelper#htmlify_line
#: ../lib/yard/templates/helpers/html_helper.rb:36
#: ../lib/yard/templates/helpers/html_helper.rb:57
#: ../lib/yard/templates/helpers/html_helper.rb:73
#: ../lib/yard/templates/helpers/html_helper.rb:83
#: ../lib/yard/templates/helpers/html_helper.rb:91
#: ../lib/yard/templates/helpers/html_helper.rb:101
#: ../lib/yard/templates/helpers/html_helper.rb:109
#: ../lib/yard/templates/helpers/html_helper.rb:115
#: ../lib/yard/templates/helpers/html_helper.rb:123
#: ../lib/yard/templates/helpers/html_helper.rb:134
#: ../lib/yard/templates/helpers/html_helper.rb:139
msgid "Converting Markup to HTML"
msgstr "HTMLへMarkupを変換する。"

# @param [Symbol] markup
#: ../lib/yard/templates/helpers/html_helper.rb:36
msgid ""
"examples are +:markdown+, +:textile+, +:rdoc+.\n"
"To add a custom markup type, see {MarkupHelper}"
msgstr ""
"例えば、 +:markdown+ , +:textile+ , +:rdoc+ がある。\n"
"カスタムマークアップの型を追加するには、 {MarkupHelper}参照。"

# @param [Symbol]
#: ../lib/yard/templates/helpers/html_helper.rb:36
msgid "tag|param|markup"
msgstr "markup"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:36
msgid "the HTML"
msgstr "HTML"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:36
msgid "the text to format"
msgstr "フォーマットするテキスト"

# YARD::Templates::Helpers::HtmlHelper#html_markup_markdown
#: ../lib/yard/templates/helpers/html_helper.rb:54
msgid "Converts Markdown to HTML"
msgstr "HTMLへMarkdownを変換する。"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:57
msgid "input Markdown text"
msgstr "Markdownテキストを入力する"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:57
#: ../lib/yard/templates/helpers/html_helper.rb:73
#: ../lib/yard/templates/helpers/html_helper.rb:91
#: ../lib/yard/templates/helpers/html_helper.rb:123
msgid "output HTML"
msgstr "HTMLを出力する"

# YARD::Templates::Helpers::HtmlHelper#html_markup_textile
#: ../lib/yard/templates/helpers/html_helper.rb:70
msgid "Converts Textile to HTML"
msgstr "HTMLへTextileを変換する。"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:73
msgid "the input Textile text"
msgstr "入力するTextileテキスト"

# YARD::Templates::Helpers::HtmlHelper#html_markup_text
#: ../lib/yard/templates/helpers/html_helper.rb:80
msgid "Converts plaintext to strict Textile (hard breaks)"
msgstr "厳格なTextileにプレーンテキストを変換する。(hard breaks)"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:83
msgid "the input textile data"
msgstr "入力するTextileのデータ"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:83
#: ../lib/yard/templates/helpers/html_helper.rb:101
#: ../lib/yard/templates/helpers/html_helper.rb:109
msgid "the output HTML"
msgstr "出力HTML"

# YARD::Templates::Helpers::HtmlHelper#html_markup_rdoc
#: ../lib/yard/templates/helpers/html_helper.rb:88
msgid "Converts RDoc formatting (SimpleMarkup) to HTML"
msgstr "RDocフォーマット(SimpleMarkup)をHTMLへ変換する。"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:91
msgid "the input RDoc formatted text"
msgstr "RDocでフォーマットされたテキストの入力"

# YARD::Templates::Helpers::HtmlHelper#html_markup_text
#: ../lib/yard/templates/helpers/html_helper.rb:98
msgid "Converts plaintext to pre-formatted HTML"
msgstr "事前にフォーマットされたHTMLにプレーンテキストを変換する。"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:101
#: ../lib/yard/templates/helpers/html_helper.rb:109
msgid "the input text"
msgstr "入力テキスト"

# YARD::Templates::Helpers::HtmlHelper#html_markup_text
#: ../lib/yard/templates/helpers/html_helper.rb:106
msgid "Converts plaintext to regular HTML"
msgstr "通常のHTMLにプレーンテキストを変換する。"

# @since
#: ../lib/yard/templates/helpers/html_helper.rb:115
msgid "0.6.6"
msgstr ""

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:115
msgid "the same text with no markup"
msgstr "markupの無い、同じテキスト"

# YARD::Templates::Helpers::HtmlHelper#html_markup_html
#: ../lib/yard/templates/helpers/html_helper.rb:120
msgid "Converts HTML to HTML"
msgstr "HTMLからHTMLへ変換する"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:123
msgid "input html"
msgstr "htmlを入力する"

# YARD::Templates::Helpers::HtmlHelper#html_markup_ruby
#: ../lib/yard/templates/helpers/html_helper.rb:128
msgid ""
"Highlights Ruby source. Similar to {#html_syntax_highlight}, but\n"
"this method is meant to be called from {#htmlify} when markup is\n"
"set to \"ruby\"."
msgstr ""
"Rubyのソースをハイライトする。\n"
"{#html_syntax_highlight}メソッドと同様である。\n"
"しかし、このメソッドはmarkupが\"ruby\"を設定する時に、\n"
"{#htmlify}メソッドから呼び出される事を意味している。"

# @param [String] source
#: ../lib/yard/templates/helpers/html_helper.rb:134
msgid "the Ruby source"
msgstr "Rubyのソース"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:134
msgid "the highlighted HTML"
msgstr "ハイライトされたHTML"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:139
msgid "HTMLified text as a single line (paragraphs removed)"
msgstr "単一の行として、HTML化された(パラグラフが削除された)テキスト"

# YARD::Templates::Helpers::HtmlHelper#html_syntax_highlight
#: ../lib/yard/templates/helpers/html_helper.rb:146
msgid "Syntax highlights +source+ in language +type+."
msgstr "構文は、+type+ の言語で +source+ をハイライトする。"

# YARD::Templates::Helpers::HtmlHelper#html_syntax_highlight
# YARD::Templates::Helpers::HtmlHelper#html_syntax_highlight_plain
#: ../lib/yard/templates/helpers/html_helper.rb:154
#: ../lib/yard/templates/helpers/html_helper.rb:165
msgid "Syntax Highlighting Source Code"
msgstr "ソースコードをハイライトする構文"

# @note
#: ../lib/yard/templates/helpers/html_helper.rb:154
msgid ""
"To support a specific language +type+, implement the method\n"
"+html_syntax_highlight_TYPE+ in this class."
msgstr ""
"特定の +type+ の言語をサポートするには、\n"
"このクラスの中の、+html_syntax_highlight_TYPE+メソッドを実装する。"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:154
msgid "the highlighted source"
msgstr "ハイライトされたソース"

# @param [Symbol] type
#: ../lib/yard/templates/helpers/html_helper.rb:154
msgid ""
"the language type (:ruby, :plain, etc). Use\n"
":plain for no syntax highlighting."
msgstr ""
"言語の型(:ruby, :plain, etc.)。\n"
"ハイライト無しの構文には、 :plain を使う"

# @param [String] source
#: ../lib/yard/templates/helpers/html_helper.rb:154
msgid "the source code to highlight"
msgstr "ハイライトするソースコード"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:165
msgid "unhighlighted source"
msgstr "ハイライトを戻されたソース"

# YARD::Templates::Helpers::HtmlHelper#resolve_links
#: ../lib/yard/templates/helpers/html_helper.rb:172
msgid ""
"Resolves any text in the form of +{Name}+ to the object specified by\n"
"Name. Also supports link titles in the form +{Name title}+."
msgstr ""
"Nameによって指定されたオブジェクトに +{Name}+ の形式で\n"
"任意のテキストを解決する。\n"
"さらに、 +{Name title}+ 形式のタイトルのリンクもサポートする。"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:180
msgid "HTML with linkified references"
msgstr "リンクされた参照を用いたHTML"

# @example Linking to a class with a title
#: ../lib/yard/templates/helpers/html_helper.rb:180
msgid ""
"resolve_links(\"{A::B::C the C class}\") # => \"<a href='...'>the c class</a>"
"\""
msgstr ""

# @example Linking to an instance method
#: ../lib/yard/templates/helpers/html_helper.rb:180
msgid ""
"resolve_links(\"{MyClass#method}\") # => \"<a href='...'>MyClass#method</a>\""
msgstr ""

# @example
#: ../lib/yard/templates/helpers/html_helper.rb:180
msgid "tag|example|Linking to a class with a title"
msgstr "タイトルと共にクラスにリンクする"

# @example
#: ../lib/yard/templates/helpers/html_helper.rb:180
msgid "tag|example|Linking to an instance method"
msgstr "インスタンスメソッドにリンクする"

# @param [String] text
#: ../lib/yard/templates/helpers/html_helper.rb:180
msgid "the text to resolve links in"
msgstr "リンクを解決する為のテキスト"

# YARD::Templates::Helpers::HtmlHelper#anchor_for
# YARD::Templates::Helpers::HtmlHelper#url_for
# YARD::Templates::Helpers::HtmlHelper#url_for_file
#: ../lib/yard/templates/helpers/html_helper.rb:288
#: ../lib/yard/templates/helpers/html_helper.rb:309
#: ../lib/yard/templates/helpers/html_helper.rb:342
#: ../lib/yard/templates/helpers/html_helper.rb:364
#: ../lib/yard/templates/helpers/html_helper.rb:372
#: ../lib/yard/templates/helpers/html_helper.rb:380
#: ../lib/yard/templates/helpers/html_helper.rb:388
msgid "URL Helpers"
msgstr ""

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:288
msgid "the anchor for a specific object"
msgstr "固有のオブジェクト用のアンカー"

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/helpers/html_helper.rb:288
msgid "the object to get an anchor for"
msgstr "アンカーを取得するオブジェクト"

# YARD::Templates::Helpers::HtmlHelper#url_for
#: ../lib/yard/templates/helpers/html_helper.rb:304
msgid "Returns the URL for an object."
msgstr "オブジェクト用にURLを返す"

# @param [Boolean]
#: ../lib/yard/templates/helpers/html_helper.rb:309
msgid "tag|param|relative"
msgstr "relative"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:309
msgid "the URL location of the object"
msgstr "オブジェクトのURLの場所"

# @param [String] anchor
#: ../lib/yard/templates/helpers/html_helper.rb:309
msgid "the anchor to link to"
msgstr "リンクするアンカー"

# @param [String, CodeObjects::Base] obj
#: ../lib/yard/templates/helpers/html_helper.rb:309
msgid "the object (or object path) to link to"
msgstr "リンクするオブジェクト(又は、オブジェクトパス)"

# @param [Boolean] relative
#: ../lib/yard/templates/helpers/html_helper.rb:309
msgid "use a relative or absolute link"
msgstr "相対or絶対リンクを使うかどうか(trueで相対リンク)"

# YARD::Templates::Helpers::HtmlHelper#url_for_file
#: ../lib/yard/templates/helpers/html_helper.rb:338
msgid "Returns the URL for a specific file"
msgstr "固有のファイル用のURLを返す"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:342
msgid "the URL pointing to the file"
msgstr "ファイルの場所を指し示す、URL"

# YARD::Templates::Helpers::HtmlHelper#url_for_file
#: ../lib/yard/templates/helpers/html_helper.rb:360
msgid "Returns the URL for a list type"
msgstr "リストのタイプ用にURLを返す"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:364
msgid "the URL pointing to the list"
msgstr "リストの為の場所を示すURL"

# @param [ClassObject] klass
#: ../lib/yard/templates/helpers/html_helper.rb:364
msgid "the list type to generate a URL for"
msgstr "リストの型用のURLを生成するためのリストの型"

# YARD::Templates::Helpers::HtmlHelper#url_for_file
#: ../lib/yard/templates/helpers/html_helper.rb:369
msgid "Returns the URL for the frameset page"
msgstr "フレームセットページ用のURLを返す"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:372
msgid "the URL pointing to the frames page"
msgstr "フレームページのURLのポイント"

# YARD::Templates::Helpers::HtmlHelper#url_for_main
#: ../lib/yard/templates/helpers/html_helper.rb:377
msgid "Returns the URL for the main page (README or alphabetic index)"
msgstr ""

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:380
#: ../lib/yard/templates/helpers/html_helper.rb:388
msgid ""
"the URL pointing to the first main page the\n"
"user should see."
msgstr "ユーザーが調べる最初のメインページの為のURLのポイント"

# YARD::Templates::Helpers::HtmlHelper#format_object_name_list
#: ../lib/yard/templates/helpers/html_helper.rb:395
msgid "Formats a list of objects and links them"
msgstr "オブジェクトのリストをフォーマットし、それをリンクする。"

# YARD::Templates::Helpers::HtmlHelper#format_object_name_list
# YARD::Templates::Helpers::HtmlHelper#format_types
# YARD::Templates::Helpers::HtmlHelper#signature_types
# YARD::Templates::Helpers::HtmlHelper#signature
#: ../lib/yard/templates/helpers/html_helper.rb:396
#: ../lib/yard/templates/helpers/html_helper.rb:414
#: ../lib/yard/templates/helpers/html_helper.rb:430
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "Formatting Objects and Attributes"
msgstr "オブジェクトと属性をフォーマットする。"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:396
msgid "a formatted list of objects"
msgstr "フォーマットされたオブジェクトのリストを返す"

# YARD::Templates::Helpers::HtmlHelper#format_types
#: ../lib/yard/templates/helpers/html_helper.rb:403
msgid "Formats a list of types from a tag."
msgstr "タグから型のリストをフォーマットする。"

# @param [Boolean] brackets
#: ../lib/yard/templates/helpers/html_helper.rb:414
msgid ""
"omits the surrounding\n"
"brackets if +brackets+ is set to +false+."
msgstr ""
"+brackets+ に +false+ が設定された場合、\n"
"周りのブラケット(括弧)を除外する。"

# @param [Array<String>, FalseClass]
#: ../lib/yard/templates/helpers/html_helper.rb:414
msgid "tag|param|typelist"
msgstr "typelist"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:414
msgid ""
"the list of types formatted\n"
"as [Type1, Type2, ...] with the types linked\n"
"to their respective descriptions."
msgstr ""
"それらの関連する説明にリンクした型と共に、\n"
"[Type1, Type2, ...]としてフォーマットされた型のリスト"

# @param [Array<String>, FalseClass] typelist
#: ../lib/yard/templates/helpers/html_helper.rb:414
msgid "the list of types to be formatted."
msgstr "フォーマットされる型のリスト"

# YARD::Templates::Helpers::HtmlHelper#signature_types
#: ../lib/yard/templates/helpers/html_helper.rb:425
msgid "Get the return types for a method signature."
msgstr "メソッドのシグネチャ用に、返す型を取得する。"

# @param [Boolean]
#: ../lib/yard/templates/helpers/html_helper.rb:430
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "tag|param|link"
msgstr "link"

# @param [CodeObjects::MethodObject] meth
#: ../lib/yard/templates/helpers/html_helper.rb:430
msgid "the method object"
msgstr "メソッドのオブジェクト"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:430
msgid "the signature types"
msgstr "シグネチャの型"

# @param [Boolean] link
#: ../lib/yard/templates/helpers/html_helper.rb:430
msgid "whether to link the types"
msgstr "型をリンクするかどうか"

# YARD::Templates::Helpers::HtmlHelper#signature
#: ../lib/yard/templates/helpers/html_helper.rb:459
msgid "Formats the signature of method +meth+."
msgstr "+meth+ メソッドのシグネチャをフォーマットする"

# @param [Boolean]
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "tag|param|full_attr_name"
msgstr "full_attr_name"

# @param [Boolean]
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "tag|param|show_extras"
msgstr "show_extras"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "the formatted method signature"
msgstr "フォーマットされたメソッドのシグネチャ"

# @param [CodeObjects::MethodObject] meth
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid ""
"the method object to list\n"
"the signature of"
msgstr "シグネチャを記述するメソッドオブジェクト"

# @param [Boolean] link
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "whether to link the method signature to the details view"
msgstr "詳細の一覧にメソッドのシグネチャをリンクするかどうか"

# @param [Boolean] show_extras
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid "whether to show extra meta-data (visibility, attribute info)"
msgstr "追加のメタデータを見せるかどうか(可視性、infoの属性)"

# @param [Boolean] full_attr_name
#: ../lib/yard/templates/helpers/html_helper.rb:467
msgid ""
"whether to show the full attribute name\n"
"(\"name=\" instead of \"name\")"
msgstr "完全なnameの属性を見せるかどうか(\"name=\" instead of \"name\")"

# YARD::Templates::Helpers::HtmlHelper#charset
#: ../lib/yard/templates/helpers/html_helper.rb:504
msgid ""
"Returns the current character set. The default value can be overridden\n"
"by setting the +LANG+ environment variable or by overriding this\n"
"method. In Ruby 1.9 you can also modify this value by setting\n"
"+Encoding.default_external+."
msgstr ""
"現在の文字集合を返す。\n"
"デフォルトの値は、 +LANG+ 環境変数を設定したり、このメソッドを上書きする事に"
"よって\n"
"上書きできる。\n"
"又、Ruby1.9では +Encoding.default_external+ を設定する事によって、\n"
"この値を変更できる。"

# YARD::Templates::Helpers::HtmlHelper#charset
#: ../lib/yard/templates/helpers/html_helper.rb:510
#: ../lib/yard/templates/helpers/html_helper.rb:536
#: ../lib/yard/templates/helpers/html_helper.rb:542
#: ../lib/yard/templates/helpers/html_helper.rb:557
#: ../lib/yard/templates/helpers/html_helper.rb:572
msgid "Getting the Character Encoding"
msgstr "Character Encodingを取得する"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:510
msgid "the current character set"
msgstr "現在の文字集合"

# YARD::Templates::Helpers::HtmlHelper#tag_attrs
#: ../lib/yard/templates/helpers/html_helper.rb:533
msgid "Converts a set of hash options into HTML attributes for a tag"
msgstr "タグ用にHTML属性へハッシュのオプションのグループを変換する。"

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:536
msgid "the tag attributes of an HTML tag"
msgstr "HTMLタグのタグ属性"

# @param [Hash{String => String}] opts
#: ../lib/yard/templates/helpers/html_helper.rb:536
msgid "the tag options"
msgstr "そのタグのオプション"

# YARD::Templates::Helpers::HtmlHelper#convert_method_to_overload
#: ../lib/yard/templates/helpers/html_helper.rb:541
msgid "Converts a {CodeObjects::MethodObject} into an overload object"
msgstr "上書きするオブジェクトへ{CodeObjects::MethodObject}を変換する"

# YARD::Templates::Helpers::HtmlHelper#parse_lang_for_codeblock
#: ../lib/yard/templates/helpers/html_helper.rb:551
msgid ""
"Parses !!!lang out of codeblock, returning the codeblock language\n"
"followed by the source code."
msgstr ""

# @since
#: ../lib/yard/templates/helpers/html_helper.rb:557
msgid "0.7.5"
msgstr ""

# @return [Array(String, String)]
#: ../lib/yard/templates/helpers/html_helper.rb:557
msgid ""
"the language, if any, and the\n"
"remaining source"
msgstr ""

# @param [String] source
#: ../lib/yard/templates/helpers/html_helper.rb:557
msgid "the source code whose language to determine"
msgstr "どの言語か決める為のソースコード"

# YARD::Templates::Helpers::HtmlHelper#parse_codeblocks
#: ../lib/yard/templates/helpers/html_helper.rb:567
msgid ""
"Parses code blocks out of html and performs syntax highlighting\n"
"on code inside of the blocks."
msgstr ""

# @return [String]
#: ../lib/yard/templates/helpers/html_helper.rb:572
msgid "highlighted html"
msgstr "ハイライトされたHTML"

# @param [String]
#: ../lib/yard/templates/helpers/html_helper.rb:572
msgid "tag|param|html"
msgstr ""

# @see
#: ../lib/yard/templates/helpers/html_helper.rb:572
msgid "tag|see|#html_syntax_highlight"
msgstr ""

# @param [String] name
#: ../lib/yard/templates/helpers/html_helper.rb:572
msgid "the html to search for code in"
msgstr "HTMLの中のコード用に検索するためのHTML"

# YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
#: ../lib/yard/templates/helpers/html_syntax_highlight_helper.rb:5
msgid "Helper methods for syntax highlighting."
msgstr "構文ハイライト用のHelperメソッド"

# YARD::Templates::Helpers::HtmlSyntaxHighlightHelper#html_syntax_highlight_ruby
#: ../lib/yard/templates/helpers/html_syntax_highlight_helper.rb:7
msgid "Highlights Ruby source"
msgstr "Rubyのソースをハイライトする"

# @param [String] source
#: ../lib/yard/templates/helpers/html_syntax_highlight_helper.rb:9
msgid "the Ruby source code"
msgstr "Rubyのソースコード"

# @return [String]
#: ../lib/yard/templates/helpers/html_syntax_highlight_helper.rb:9
msgid "the highlighted Ruby source"
msgstr "ハイライトされたRubyのソース"

# @param value
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:23
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:68
msgid "the value to set the attribute from_path to."
msgstr "from_path属性を設定する値"

# YARD::Templates::Helpers::Markup::RDocMarkup#from_path
# YARD::Templates::Helpers::Markup::RDocMarkupToHtml#from_path
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:24
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:69
msgid "Returns the value of attribute from_path"
msgstr "from_path属性の値を返す"

# YARD::Templates::Helpers::Markup::RDocMarkup#from_path=
# YARD::Templates::Helpers::Markup::RDocMarkupToHtml#from_path=
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:24
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:69
msgid "Sets the attribute from_path"
msgstr "from_path属性を設定する"

# @return [RDocMarkup]
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:25
msgid "a new instance of RDocMarkup"
msgstr "RDocMarkupの新しいインスタンス"

# YARD::Templates::Helpers::Markup::RDocMarkup#fix_typewriter
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:42
msgid "Fixes RDoc behaviour with ++ only supporting alphanumeric text."
msgstr ""
"RDocの振舞いを修正する(アルファベットと数字を組み合わせたテキストのサポートだ"
"け追加)"

# @todo
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:44
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:62
msgid "Refactor into own SimpleMarkup subclass"
msgstr "自身をSimpleMarkupサブクラスへリファクタリング予定"

# YARD::Templates::Helpers::Markup::RDocMarkup#fix_dash_dash
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:59
msgid ""
"Don't allow -- to turn into &#8212; element. The chances of this being\n"
"some --option is far more likely than the typographical meaning."
msgstr ""
"--を&#8212へ変換する事は許可していない。\n"
"表示している意味よりも、いくつかの--optionになる可能性が高い。"

# YARD::Templates::Helpers::Markup::RDocMarkupToHtml#handle_special_HYPERLINK
#: ../lib/yard/templates/helpers/markup/rdoc_markup.rb:71
msgid "Disable auto-link of URLs"
msgstr "URLの自動リンクを無効にする"

# YARD::Templates::Helpers::MarkupHelper
#: ../lib/yard/templates/helpers/markup_helper.rb:6
msgid "Helper methods for loading and managing markup types."
msgstr "読み込みと,型のmarkupの管理用のHelperメソッド"

# YARD::Templates::Helpers::MarkupHelper.clear_markup_cache
#: ../lib/yard/templates/helpers/markup_helper.rb:9
msgid "Clears the markup provider cache information. Mainly used for testing."
msgstr ""
"マークアッププロバイダーのキャッシュ情報を初期化する。\n"
"主にtest用に利用される。"

# @since
#: ../lib/yard/templates/helpers/markup_helper.rb:17
msgid "0.6.4"
msgstr ""

# @return [Hash{Symbol=>{(:provider,:class)=>Object}}]
#: ../lib/yard/templates/helpers/markup_helper.rb:17
msgid "the cached markup providers"
msgstr "キャッシュされたマークアッププロバイダー"

# YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS
#: ../lib/yard/templates/helpers/markup_helper.rb:23
msgid "The default list of markup providers for each markup type"
msgstr ""
"それぞれのマークアップの型用の\n"
"マークアッププロバイダーのデフォルトのリスト。"

# YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS
#: ../lib/yard/templates/helpers/markup_helper.rb:49
msgid ""
"Returns a list of extensions for various markup types. To register\n"
"extensions for a type, add them to the array of extensions for the\n"
"type."
msgstr ""
"様々なmarkupの型の為に拡張のリストを返す。\n"
"型用に拡張を記録するには、型用の拡張の配列に拡張を追加する。"

# YARD::Templates::Helpers::MarkupHelper::MARKUP_FILE_SHEBANG
#: ../lib/yard/templates/helpers/markup_helper.rb:62
msgid ""
"Contains the Regexp object that matches the shebang line of extra\n"
"files to detect the markup type."
msgstr ""
"markup型を認識する為に、\n"
"追加のファイルのshebang行にマッチする\n"
"Regexpオブジェクトを含んでいる。"

# YARD::Templates::Helpers::MarkupHelper#load_markup_provider
#: ../lib/yard/templates/helpers/markup_helper.rb:66
msgid ""
"Attempts to load the first valid markup provider in {MARKUP_PROVIDERS}.\n"
"If a provider is specified, immediately try to load it."
msgstr ""
"{MARKUP_PROVIDERS}で最初の有効なマークアップロバイダーを読み込む。\n"
"プロバイダーが指定される場合、直ぐにロードするか試す。"

# YARD::Templates::Helpers::MarkupHelper#load_markup_provider
#: ../lib/yard/templates/helpers/markup_helper.rb:69
msgid ""
"On success this sets `@markup_provider` and `@markup_class` to\n"
"the provider name and library constant class/module respectively for\n"
"the loaded provider."
msgstr ""
"これは成功した場合、プロバイダー名に\n"
"`@markup_provider`と`@markup_class`を設定し、\n"
"ロードされたプロバイダーの為に、\n"
"それぞれライブラリ,定数,クラス/モジュールとなる。"

# YARD::Templates::Helpers::MarkupHelper#load_markup_provider
#: ../lib/yard/templates/helpers/markup_helper.rb:73
msgid ""
"On failure this method will inform the user that no provider could be\n"
"found and exit the program."
msgstr ""
"失敗した場合、このメソッドは、\n"
"プロバイダーが見つける事ができないユーザーを知らせて、プラグラムを脱出するだ"
"ろう。"

# @return [Boolean]
#: ../lib/yard/templates/helpers/markup_helper.rb:76
msgid "whether the markup provider was successfully loaded."
msgstr "マークアップのプロバイダーが正常に読み込まれたかどうか"

# YARD::Templates::Helpers::MarkupHelper#markup_for_file
#: ../lib/yard/templates/helpers/markup_helper.rb:108
msgid ""
"Checks for a shebang or looks at the file extension to determine\n"
"the markup type for the file contents. File extensions are registered\n"
"for a markup type in {MARKUP_EXTENSIONS}."
msgstr ""
"shebangをチェックし、\n"
"ファイルの内容の為にマークアップの型を決めるファイル拡張子を探す。\n"
"ファイル拡張子は、{MARKUP_EXTENSIONS}のマークアップの型が記録される。"

# YARD::Templates::Helpers::MarkupHelper#markup_for_file
#: ../lib/yard/templates/helpers/markup_helper.rb:112
msgid "A shebang should be on the first line of a file and be in the form:"
msgstr "shebangは、ファイルの最初の行になり、次のような形式となる。"

# YARD::Templates::Helpers::MarkupHelper#markup_for_file
#: ../lib/yard/templates/helpers/markup_helper.rb:114
msgid "  #!markup_type"
msgstr ""

# YARD::Templates::Helpers::MarkupHelper#markup_for_file
#: ../lib/yard/templates/helpers/markup_helper.rb:116
msgid "Standard markup types are text, html, rdoc, markdown, textile"
msgstr "標準のマークアップは、text,htmlcrdoc,markdown,textileとなる。"

# @param [String] contents
#: ../lib/yard/templates/helpers/markup_helper.rb:122
msgid ""
"Unused. Was necessary prior to 0.7.0.\n"
"Newer versions of YARD use {CodeObjects::ExtraFileObject#contents}"
msgstr ""
"利用されない。0.7.0.より前では、必須だった。\n"
"YARDの最新バージョンでは、{CodeObjects::ExtraFileObject#contents}を用いる。"

# @see
#: ../lib/yard/templates/helpers/markup_helper.rb:122
msgid "tag|see|MARKUP_EXTENSIONS"
msgstr ""

# @return [Symbol]
#: ../lib/yard/templates/helpers/markup_helper.rb:122
msgid "the markup type recognized for the file"
msgstr "ファイルに認識されたマークアップタイプ"

# YARD::Templates::Helpers::MarkupHelper#markup_file_contents
#: ../lib/yard/templates/helpers/markup_helper.rb:135
msgid ""
"Strips any shebang lines on the file contents that pertain to\n"
"markup or preprocessing data."
msgstr ""
"マークアップや処理するデータに関係があるファイルの内容の\n"
"任意のshebang行をStripする。"

# @deprecated
#: ../lib/yard/templates/helpers/markup_helper.rb:140
msgid "Use {CodeObjects::ExtraFileObject#contents} instead"
msgstr "替わりに{CodeObjects::ExtraFileObject#contents}を使う"

# @return [String]
#: ../lib/yard/templates/helpers/markup_helper.rb:140
msgid "the file contents minus any preprocessing tags"
msgstr ""
"ファイルの内容が任意のtagを表す\n"
"\n"

# YARD::Templates::Helpers::MarkupHelper#markup_class
#: ../lib/yard/templates/helpers/markup_helper.rb:145
msgid ""
"Gets the markup provider class/module constant for a markup type\n"
"Call {#load_markup_provider} before using this method."
msgstr ""
"マークアップ型がこのメソッドを使う前に{#load_markup_provider}を呼び出すマーク"
"アッププロバイダーのクラス/モジュールの定数を取得する。"

# @return [Class]
#: ../lib/yard/templates/helpers/markup_helper.rb:149
msgid "the markup class"
msgstr "マークアップのクラス"

# @param [Symbol] the
#: ../lib/yard/templates/helpers/markup_helper.rb:149
#: ../lib/yard/templates/helpers/markup_helper.rb:159
msgid "the markup type (:rdoc, :markdown, etc.)"
msgstr "マークアップの型(:rdoc, :markdown, etc.)"

# YARD::Templates::Helpers::MarkupHelper#markup_provider
#: ../lib/yard/templates/helpers/markup_helper.rb:155
msgid ""
"Gets the markup provider name for a markup type\n"
"Call {#load_markup_provider} before using this method."
msgstr ""
"マークアップ型がこのメソッド使う前に{#load_markup_provider}を呼び出すマーク"
"アッププロバイダー名を取得する。"

# @return [Symbol]
#: ../lib/yard/templates/helpers/markup_helper.rb:159
msgid "the markup provider name (usually the gem name of the library)"
msgstr "マークアッププロバイダー名(慣習では、ライブラリのgem名)"

# YARD::Templates::Helpers::MethodHelper
#: ../lib/yard/templates/helpers/method_helper.rb:4
msgid "Helper methods for method objects."
msgstr "メソッドオブジェクト用のHelperメソッド"

# @return [String]
#: ../lib/yard/templates/helpers/method_helper.rb:6
msgid "formatted arguments for a method"
msgstr "メソッド用にフォーマットされた引数"

# @return [String]
#: ../lib/yard/templates/helpers/method_helper.rb:25
msgid "formatted and linked return types for a method"
msgstr "メソッド用にフォーマットとリンクされた型を返す"

# @return [String]
#: ../lib/yard/templates/helpers/method_helper.rb:32
msgid "formatted block if one exists"
msgstr "何か渡された場合、フォーマットされたブロックを返す"

# @return [String]
#: ../lib/yard/templates/helpers/method_helper.rb:47
msgid "formats line numbers for source code of an object"
msgstr "オブジェクトのソースコード用に行数をフォーマットする"

# @return [String]
#: ../lib/yard/templates/helpers/method_helper.rb:54
msgid "formats source of an object"
msgstr "オブジェクトのソースをフォーマットする"

# @return [String]
#: ../lib/yard/templates/helpers/method_helper.rb:65
msgid "formats source code of a constant value"
msgstr "定数の値の入ったソースコードをフォーマットする"

# YARD::Templates::Helpers::ModuleHelper
#: ../lib/yard/templates/helpers/module_helper.rb:5
msgid "Helper methods for managing module objects."
msgstr "モジュールオブジェクトを管理用のHelperメソッド"

# YARD::Templates::Helpers::ModuleHelper#prune_method_listing
#: ../lib/yard/templates/helpers/module_helper.rb:7
msgid ""
"Prunes the method listing by running the verifier and removing attributes/"
"aliases"
msgstr ""
"verifierを起動する事によって、メソッドのリストを切り詰め、属性/エイリアスを削"
"除する。"

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/templates/helpers/module_helper.rb:10
msgid "a pruned list of methods"
msgstr "切り詰められたメソッドのリスト"

# @param [Boolean]
#: ../lib/yard/templates/helpers/module_helper.rb:10
msgid "tag|param|hide_attributes"
msgstr "hide_attributes"

# @param [Boolean] hide_attributes
#: ../lib/yard/templates/helpers/module_helper.rb:10
msgid "whether to prune attribute methods from the list"
msgstr "リストからメソッドの属性を切り詰めるかどうか"

# YARD::Templates::Helpers::TextHelper
#: ../lib/yard/templates/helpers/text_helper.rb:5
msgid "Helper methods for text template formats."
msgstr "テキストテンプレートフォーマット用のHelperメソッド"

# @return [String]
#: ../lib/yard/templates/helpers/text_helper.rb:7
msgid "escapes text"
msgstr "テキストをエスケープする"

# @return [String]
#: ../lib/yard/templates/helpers/text_helper.rb:22
msgid "wraps text at +col+ columns."
msgstr "+col+ 列でテキストをラップする。"

# @return [String]
#: ../lib/yard/templates/helpers/text_helper.rb:27
msgid "indents +text+ by +len+ characters."
msgstr "+len+ 文字で +text+ をインデントする"

# @return [String]
#: ../lib/yard/templates/helpers/text_helper.rb:32
msgid "aligns a title to the right"
msgstr "右にタイトルを並べる"

# @return [String]
#: ../lib/yard/templates/helpers/text_helper.rb:37
msgid "aligns text to the right"
msgstr "右にテキストを並べる"

# @return [String]
#: ../lib/yard/templates/helpers/text_helper.rb:43
msgid "returns a horizontal rule for output"
msgstr "出力用に横方向の罫線を返す"

# @return [String]
#: ../lib/yard/templates/helpers/text_helper.rb:48
msgid "the formatted signature for a method"
msgstr "メソッド用にフォーマットされたシグネチャ"

# YARD::Templates::Helpers::UMLHelper
#: ../lib/yard/templates/helpers/uml_helper.rb:4
msgid "Helpers for UML template format"
msgstr "UMLテンプレートフォーマット用のHelperメソッド"

# YARD::Templates::Helpers::UMLHelper#uml_visibility
#: ../lib/yard/templates/helpers/uml_helper.rb:6
msgid ""
"Official UML visibility prefix syntax for an object given its visibility"
msgstr "オブジェクト用に与えられた可視性の為の公式のUMLプレフィックス構文"

# @return [String]
#: ../lib/yard/templates/helpers/uml_helper.rb:8
msgid "the UML visibility prefix"
msgstr "UML可視性のプレフィックス"

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/helpers/uml_helper.rb:8
msgid "the object to retrieve visibility for"
msgstr "可視性を回収するオブジェクト"

# YARD::Templates::Helpers::UMLHelper#format_path
#: ../lib/yard/templates/helpers/uml_helper.rb:17
msgid "Formats the path of an object for Graphviz syntax"
msgstr "Graphviz構文用にオブジェクトのパスをフォーマットする。"

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/helpers/uml_helper.rb:19
msgid "an object to format the path of"
msgstr "パスをフォーマットするオブジェクト"

# @return [String]
#: ../lib/yard/templates/helpers/uml_helper.rb:19
msgid "the encoded path"
msgstr "エンコードされたパス"

# YARD::Templates::Helpers::UMLHelper#h
#: ../lib/yard/templates/helpers/uml_helper.rb:24
msgid "Encodes text in escaped Graphviz syntax"
msgstr "Graphviz構文用にエスケープされたテキストをエンコードする"

# @param [String] text
#: ../lib/yard/templates/helpers/uml_helper.rb:26
msgid "text to encode"
msgstr "エンコードするテキスト"

# @return [String]
#: ../lib/yard/templates/helpers/uml_helper.rb:26
msgid "the encoded text"
msgstr "エンコードされたテキスト"

# YARD::Templates::Helpers::UMLHelper#tidy
#: ../lib/yard/templates/helpers/uml_helper.rb:31
msgid "Tidies data by formatting and indenting text"
msgstr "フォーマットによってデータを整える、テキストをインデントする。"

# @param [String] data
#: ../lib/yard/templates/helpers/uml_helper.rb:33
msgid "pre-formatted text"
msgstr "フォーマットされる前のテキスト"

# @return [String]
#: ../lib/yard/templates/helpers/uml_helper.rb:33
msgid "tidied text."
msgstr "整えられたテキスト"

# YARD::Templates::Section
#: ../lib/yard/templates/section.rb:4
msgid ""
"Abstracts the structure for a section and its subsections into an ordered\n"
"list of sections and subsections."
msgstr ""
"セクションに構造体を抽象化し、セクションとサブセクションのオーダーされたリス"
"トをサブサクションにする。"

# @return [Section]
#: ../lib/yard/templates/section.rb:9
msgid "a new instance of Section"
msgstr "セクションの新しいインスタンス"

# @param value
#: ../lib/yard/templates/template.rb:6
msgid "the value to set the attribute class to."
msgstr "class属性を設定する値"

# @param value
#: ../lib/yard/templates/template.rb:6
msgid "the value to set the attribute section to."
msgstr "section属性を設定する値"

# YARD::Templates::Template#class
#: ../lib/yard/templates/template.rb:7
msgid "Returns the value of attribute class"
msgstr "class属性の値を返す"

# YARD::Templates::Template#section
#: ../lib/yard/templates/template.rb:7
msgid "Returns the value of attribute section"
msgstr "section属性の値を返す"

# YARD::Templates::Template#class=
#: ../lib/yard/templates/template.rb:7
msgid "Sets the attribute class"
msgstr "classの属性を設定する"

# YARD::Templates::Template#section=
#: ../lib/yard/templates/template.rb:7
msgid "Sets the attribute section"
msgstr "section属性を設定する"

# YARD::Server::Commands::LibraryIndexCommand#options
# YARD::Templates::Template#options
#: ../lib/yard/templates/template.rb:8
msgid "Returns the value of attribute options"
msgstr "options属性の値を返す"

# YARD::Templates::Template.extra_includes
# YARD::Templates::Template.extra_includes=
#: ../lib/yard/templates/template.rb:11
msgid ""
"Extra includes are mixins that are included after a template is created. "
"These\n"
"mixins can be registered by plugins to operate on templates and override "
"behaviour."
msgstr ""

# YARD::Templates::Template.extra_includes
# YARD::Templates::Template.extra_includes=
#: ../lib/yard/templates/template.rb:14
msgid ""
"Note that this array can be filled with modules or proc objects. If a proc "
"object\n"
"is given, the proc will be called with the {Template#options} hash "
"containing\n"
"relevant template information like the object, format, and more. The proc "
"should\n"
"return a module or nil if there is none."
msgstr ""

# @example Adding in extra mixins to include on a template
#: ../lib/yard/templates/template.rb:24
msgid "Template.extra_includes << MyHelper"
msgstr ""

# @example Conditionally including a mixin if the format is html
#: ../lib/yard/templates/template.rb:24
msgid ""
"Template.extra_includes << proc {|opts| MyHelper if opts.format == :html }"
msgstr ""

# @return [Array<Module>]
#: ../lib/yard/templates/template.rb:24
msgid ""
"a list of modules to be automatically included\n"
"into any new template module"
msgstr ""
"任意の新しいテンプレートモジュールへ自動でインクルードされるモジュールのリス"
"ト"

# @example
#: ../lib/yard/templates/template.rb:24
msgid "tag|example|Adding in extra mixins to include on a template"
msgstr "tag|example|テンプレート上でincludeするために追加のmixinを追加する"

# @example
#: ../lib/yard/templates/template.rb:24
msgid "tag|example|Conditionally including a mixin if the format is html"
msgstr ""

# YARD::Templates::Template.include_extra
#: ../lib/yard/templates/template.rb:33
msgid "Includes the {extra_includes} modules into the template object."
msgstr ""

# @param [Template]
#: ../lib/yard/templates/template.rb:37
msgid "tag|param|template"
msgstr "tag|param|template"

# @return [LibraryVersion]
#: ../lib/yard/templates/template.rb:37
msgid "the options hash containing all template information"
msgstr "ハッシュのオプションは全てのテンプレート情報を含んでいる"

# @param [CodeObjects::Base] object
#: ../lib/yard/templates/template.rb:37
msgid "the template object to mixin the extra includes."
msgstr "追加のincludeをmixinする為のテンプレートオブジェクト"

# @param value
#: ../lib/yard/templates/template.rb:59
msgid "the value to set the attribute full_path to."
msgstr "full_path属性を設定する値"

# @param value
#: ../lib/yard/templates/template.rb:59
msgid "the value to set the attribute path to."
msgstr "path属性を設定する値"

# YARD::Templates::Template::ClassMethods#full_path
#: ../lib/yard/templates/template.rb:60
msgid "Returns the value of attribute full_path"
msgstr "full_path属性の値を返す"

# YARD::Templates::Template::ClassMethods#path
#: ../lib/yard/templates/template.rb:60
msgid "Returns the value of attribute path"
msgstr "path属性の値を返す"

# YARD::Templates::Template::ClassMethods#full_path=
#: ../lib/yard/templates/template.rb:60
msgid "Sets the attribute full_path"
msgstr "full_path属性を設定する"

# YARD::Templates::Template::ClassMethods#path=
#: ../lib/yard/templates/template.rb:60
msgid "Sets the attribute path"
msgstr "path属性を設定する"

# @return [ClassMethods]
#: ../lib/yard/templates/template.rb:68
msgid "a new instance of ClassMethods"
msgstr "ClassMethodsの新しいインスタンス"

# YARD::Templates::Template::ClassMethods#find_file
#: ../lib/yard/templates/template.rb:78
msgid ""
"Searches for a file identified by +basename+ in the template's\n"
"path as well as any mixed in template paths. Equivalent to calling\n"
"{ClassMethods#find_nth_file} with index of 1."
msgstr ""
"テンプレートパスも\n"
"任意の混ぜられたテンプレートパスも +basename+ でファイルが一致する為に検索す"
"る。\n"
"{ClassMethods#find_nth_file}メソッドを index 1 で呼び出すのと同様である。"

# @param [String]
#: ../lib/yard/templates/template.rb:85 ../lib/yard/templates/template.rb:96
#: ../lib/yard/templates/template.rb:290
msgid "tag|param|basename"
msgstr "basename"

# @see
#: ../lib/yard/templates/template.rb:85
msgid "tag|see|find_nth_file"
msgstr "find_nth_file"

# @param [String] basename
#: ../lib/yard/templates/template.rb:85 ../lib/yard/templates/template.rb:96
msgid "the filename to search for"
msgstr "検索するファイル名"

# @return [String]
#: ../lib/yard/templates/template.rb:85
msgid ""
"the full path of a file on disk with filename\n"
"+basename+ in one of the template's paths."
msgstr ""
"テンプレートパスの一つである +basename+ の入ったディスク上のファイルのフルパ"
"スを返す"

# YARD::Templates::Template::ClassMethods#find_nth_file
#: ../lib/yard/templates/template.rb:90
msgid ""
"Searches for the nth file (where n = +index+) identified\n"
"by basename in the template's path and any mixed in template paths."
msgstr ""
"n番目のファイルがテンプレートパスか任意の混ぜられたテンプレートパスのbasename"
"によって\n"
"一致するかサーチする。"

# @param [Fixnum]
#: ../lib/yard/templates/template.rb:96
msgid "tag|param|index"
msgstr "index"

# @return [String]
#: ../lib/yard/templates/template.rb:96
msgid ""
"the full path of the nth file on disk with\n"
"filename +basename+ in one of the template paths"
msgstr ""
"テンプレートパスの一つの +basename+ を用いたディスク上のn番目のファイルフルパ"
"ス"

# @param [Fixnum] index
#: ../lib/yard/templates/template.rb:96
msgid "the nth existing file to return"
msgstr "n番目に存在するファイルを戻すindex"

# YARD::Templates::Template::ClassMethods#new
#: ../lib/yard/templates/template.rb:115
msgid "Creates a new template object to be rendered with {Template#run}"
msgstr "{Template#run}と共に表示される新しいテンプレートオブジェクトを作成する"

# YARD::Templates::Template::ClassMethods#S
#: ../lib/yard/templates/template.rb:131
msgid "Alias for creating a {Section} with arguments"
msgstr "引数と共に{Section}の作成用のエイリアス"

# @see
#: ../lib/yard/templates/template.rb:133
msgid "tag|see|Section#initialize"
msgstr "Section#initialize"

# @return [Template]
#: ../lib/yard/templates/template.rb:166
msgid "a new instance of Template"
msgstr "テンプレートの新しいインスタンス"

# YARD::Templates::Template#T
#: ../lib/yard/templates/template.rb:177
msgid ""
"Loads a template specified by path. If +:template+ or +:format+ is\n"
"specified in the {#options} hash, they are prepended and appended\n"
"to the path respectively."
msgstr ""
"pathによって指定されたテンプレートをロードする。\n"
"+:template+ や +:format+ が{#options}ハッシュメソッドで指定される場合、\n"
"#optionsメソッドに関係するパスが前後に加えられる。"

# @return [Template]
#: ../lib/yard/templates/template.rb:182
msgid "the loaded template module"
msgstr "ロードされたテンプレートモジュール"

# @param [Array<String, Symbol>] path
#: ../lib/yard/templates/template.rb:182
msgid "the path of the template"
msgstr "テンプレートのパス"

# YARD::Templates::Template#sections
#: ../lib/yard/templates/template.rb:189
msgid "Sets the sections (and subsections) to be rendered for the template"
msgstr "テンプレート用に表示されるセクション(とサブサクション)を設定する。"

# @example Sets a set of method and erb sections
#: ../lib/yard/templates/template.rb:204
msgid "sections :a, :b, :c # a is a method, the rest are erb files"
msgstr ""

# @example Sets a set of erb sections
#: ../lib/yard/templates/template.rb:204
msgid "sections :a, :b, :c # searches for a.erb, b.erb, c.erb"
msgstr ""

# @example Sections with subsections
#: ../lib/yard/templates/template.rb:204
msgid ""
"sections :header, [:name, :children]\n"
"# the above will call header.erb and only renders the subsections\n"
"# if they are yielded by the template (see #yieldall)"
msgstr ""
"sections :header, [:name, :children]\n"
"# 上は、header.erbが呼び出され、subsectionをが表示する。\n"
"# テンプレートでyieldしたい場合は (see #yieldall) 参照"

# @example
#: ../lib/yard/templates/template.rb:204
msgid "tag|example|Sections with subsections"
msgstr "subsectionsを用いたsection"

# @example
#: ../lib/yard/templates/template.rb:204
msgid "tag|example|Sets a set of erb sections"
msgstr "erb sectionのグループを設置する"

# @example
#: ../lib/yard/templates/template.rb:204
msgid "tag|example|Sets a set of method and erb sections"
msgstr "メソッドのグループとercセクションを設定する"

# @param [Array<Symbol, String, Template, Array>] args
#: ../lib/yard/templates/template.rb:204
msgid ""
"the sections\n"
"to use to render the template. For symbols and strings, the\n"
"section will be executed as a method (if one exists), or rendered\n"
"from the file \"name.erb\" where name is the section name. For\n"
"templates, they will have {Template::ClassMethods#run} called on them.\n"
"Any subsections can be yielded to using yield or {#yieldall}"
msgstr ""
"テンプレートを表示する為に利用するセクション。\n"
"symbolとstringでセクションは、メソッドとして実行される。(存在する場合)\n"
"又、nameがsection名の所で\"name.erb\"ファイルから表示される\n"
"テンプレート用に、呼び出された{Template::ClassMethods#run}を持つだろう。\n"
"任意のsubsectionは、yieldや{#yieldall}メソッドによってyieldされる。"

# YARD::Templates::Template#init
#: ../lib/yard/templates/template.rb:210
msgid ""
"Initialization called on the template. Override this in a 'setup.rb'\n"
"file in the template's path to implement a template"
msgstr ""
"テンプレート上で呼び出される初期化処理。\n"
"テンプレートを実装するテンプレートのパスで'setup.rb'ファイルを上書きする。"

# @example A default set of sections
#: ../lib/yard/templates/template.rb:217
msgid ""
"def init\n"
"  sections :section1, :section2, [:subsection1, :etc]\n"
"end"
msgstr ""

# @example
#: ../lib/yard/templates/template.rb:217
msgid "tag|example|A default set of sections"
msgstr "セクションのデフォルトのグループ"

# @see
#: ../lib/yard/templates/template.rb:217
msgid "tag|see|#sections"
msgstr ""

# YARD::Templates::Template#run
#: ../lib/yard/templates/template.rb:221
msgid ""
"Runs a template on +sects+ using extra options. This method should\n"
"not be called directly. Instead, call the class method {ClassMethods#run}"
msgstr ""
"追加のオプションによって、+sects+上でテンプレートを起動する。\n"
"このメソッドは、直接呼び出されないだろう。\n"
"代わりに、{ClassMethods#run}クラスメソッドを呼び出す。"

# @param [Section, Array] sects
#: ../lib/yard/templates/template.rb:230
msgid "a section list of sections to render"
msgstr "表示する為のsectionのリスト"

# @param [Hash, nil] opts
#: ../lib/yard/templates/template.rb:230
msgid "any extra options to apply to sections"
msgstr "sectionsに適用する任意の追加のオプション"

# @yieldparam [Hash] opts
#: ../lib/yard/templates/template.rb:230
msgid "any extra options to yield"
msgstr "yieldする任意の追加のオプション"

# @yield [opts]
#: ../lib/yard/templates/template.rb:230
msgid "calls for the subsections to be rendered"
msgstr "表示されるサブセクション用に呼び出される"

# @param [Boolean] break_first
#: ../lib/yard/templates/template.rb:230
msgid "if true, renders only the first section"
msgstr "trueなら、最初のセクションだけ表示される"

# @param [Boolean]
#: ../lib/yard/templates/template.rb:230
msgid "tag|param|break_first"
msgstr " break_first"

# @param [Section, Array]
#: ../lib/yard/templates/template.rb:230
msgid "tag|param|sects"
msgstr "sects"

# @param [Fixnum]
#: ../lib/yard/templates/template.rb:230
msgid "tag|param|start_at"
msgstr "start_at"

# @yieldparam [Hash]
#: ../lib/yard/templates/template.rb:230
msgid "tag|yieldparam|opts"
msgstr ""

# @param [Fixnum] start_at
#: ../lib/yard/templates/template.rb:230
msgid "the index in the section list to start from"
msgstr "セクションのリストの最初のindex"

# @return [String]
#: ../lib/yard/templates/template.rb:230
msgid "the rendered sections joined together"
msgstr "一緒に加えられた,表示されたsection"

# YARD::Templates::Template#yieldall
#: ../lib/yard/templates/template.rb:254
msgid "Yields all subsections with any extra options"
msgstr "任意の追加のオプションと共に全てのサブセクションをyieldする。"

# @param [Hash] opts
#: ../lib/yard/templates/template.rb:256
msgid "extra options to be applied to subsections"
msgstr "サブセクションに適用される追加のオプション"

# @yield
#: ../lib/yard/templates/template.rb:263
msgid "calls subsections to be rendered"
msgstr "表示されるサブセクションを呼び出す"

# @param [String, Symbol]
# @param [Symbol, String]
#: ../lib/yard/templates/template.rb:263 ../lib/yard/templates/template.rb:308
msgid "tag|param|section"
msgstr "section"

# @return [String]
#: ../lib/yard/templates/template.rb:263
msgid "the contents of the ERB rendered section"
msgstr "セクションに表示されるERBの内容"

# @param [String, Symbol] section
#: ../lib/yard/templates/template.rb:263
msgid "the section name"
msgstr "セクション名"

# YARD::Templates::Template#file
#: ../lib/yard/templates/template.rb:271
msgid ""
"Returns the contents of a file. If +allow_inherited+ is set to +true+,\n"
"use +{{{__super__}}}+ inside the file contents to insert the contents\n"
"of the file from an inherited template. For instance, if +templates/b+\n"
"inherits from +templates/a+ and file \"test.css\" exists in both "
"directories,\n"
"both file contents can be retrieved by having +templates/b/test.css+ look\n"
"like:"
msgstr ""
"ファイルの内容を返す。\n"
"+allow_inherited+ が +true+ に設定される場合、\n"
"継承されたテンプレートから\n"
"ファイルの入った内容を挿入する為、\n"
"ファイルの内容の内部で\n"
"+{{{__super__}}}+ を使う。\n"
"例えば、 +templates/b+ が +templates/a+ から継承され、 \"test.css\"ファイルが"
"存在する\n"
"ディレクトリの中で両方とも存在している場合、\n"
"両方ファイルの内容は、以下の用に\n"
"+templates/b/test.css+ を持つ事によって回収できる。"

# YARD::Templates::Template#file
#: ../lib/yard/templates/template.rb:278
msgid ""
"  {{{__super__}}}\n"
"  ...\n"
"  body { css styles here }\n"
"  p.class { other styles }"
msgstr ""

# @param [Boolean]
#: ../lib/yard/templates/template.rb:290
msgid "tag|param|allow_inherited"
msgstr "allow_inherited"

# @see
#: ../lib/yard/templates/template.rb:290
msgid "tag|see|ClassMethods#find_file"
msgstr ""

# @see
#: ../lib/yard/templates/template.rb:290
msgid "tag|see|ClassMethods#find_nth_file"
msgstr ""

# @return [String]
#: ../lib/yard/templates/template.rb:290
msgid ""
"the contents of a file identified by +basename+. All\n"
"template paths (including any mixed in templates) are searched for\n"
"the file"
msgstr ""
"+basename+ によって指定されたファイルの内容。\n"
"全てのテンプレートパスは(任意の混ぜられたテンプレートを含んでいる)、\n"
"ファイル用に検索される。"

# @param [String] basename
#: ../lib/yard/templates/template.rb:290
msgid "the name of the file"
msgstr "ファイルの名前"

# @param [Boolean] allow_inherited
#: ../lib/yard/templates/template.rb:290
msgid ""
"whether inherited templates can\n"
"be inserted with +{{{__super__}}}+"
msgstr "継承されたテンプレートが +{{{__super__}}}+ を用いて継承されるかどうか"

# YARD::Templates::Template#superb
#: ../lib/yard/templates/template.rb:304
msgid "Calls the ERB file from the last inherited template with {#section}.erb"
msgstr ""
"{#section}.erbと共に継承されたテンプレートの最後からERBファイルを呼び出す。"

# @param [Symbol, String] section
#: ../lib/yard/templates/template.rb:308
msgid "if provided, uses a specific section name"
msgstr "提供された場合、固有のセクション名を使う"

# @return [String]
#: ../lib/yard/templates/template.rb:308
msgid ""
"the rendered ERB file in any of the inherited template\n"
"paths."
msgstr "継承されたテンプレートパスの任意で表示されるERBファイル"

# YARD::Templates::TemplateOptions
#: ../lib/yard/templates/template_options.rb:6
msgid ""
"An Options class containing default options for base template rendering. "
"For\n"
"options specific to generation of HTML output, see {CLI::YardocOptions}."
msgstr ""

# @see
#: ../lib/yard/templates/template_options.rb:9
msgid "tag|see|CLI::YardocOptions"
msgstr ""

# @param [String] text
#: ../lib/yard/templates/template_options.rb:11
msgid "the template output format"
msgstr "テンプレート出力のフォーマット"

# @param [String] path
#: ../lib/yard/templates/template_options.rb:14
msgid "the template name used to render output"
msgstr "出力を表示するため利用されたテンプレート名"

# @param value
#: ../lib/yard/templates/template_options.rb:17
msgid "the markup format to use when parsing docstrings"
msgstr "docstringを解析する時に使うためのマークアップフォーマット"

# YARD::Templates::Helpers::HtmlHelper#signature_types
#: ../lib/yard/templates/template_options.rb:20
msgid "the default return type for a method with no return tags"
msgstr "returnタグを用いないメソッド用のデフォルトの戻りの型"

# @return [Boolean]
#: ../lib/yard/templates/template_options.rb:23
msgid "whether void methods should show \"void\" in their signature"
msgstr ""

# @param [String] source
#: ../lib/yard/templates/template_options.rb:26
msgid "whether code blocks should be syntax highlighted"
msgstr "コードブロックが構文ハイライトされるかどうか"

# YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS
#: ../lib/yard/templates/template_options.rb:29
msgid "the markup provider class for the markup format"
msgstr "マークアップフォーマット用のマークアッププロバイダークラス"

# @return [OpenStruct]
#: ../lib/yard/templates/template_options.rb:33
msgid ""
"an open struct containing any global state across all\n"
"generated objects in a template."
msgstr ""
"テンプレートの中で生成された全てのオブジェクトに渡って\n"
"全てのglobalの状態を含んでいるopen struct"

# @return [Template]
#: ../lib/yard/templates/template_options.rb:37
msgid "the main object being generated in the template"
msgstr "テンプレートの中で生成されるメインオブジェクト"

# YARD::CodeObjects::Base#name
# YARD::CodeObjects::Proxy#name
#: ../lib/yard/templates/template_options.rb:40
msgid "the owner of the generated object"
msgstr "生成されたオブジェクトのオーナー"

# @return [Boolean]
#: ../lib/yard/templates/template_options.rb:43
msgid "the template type used to generate output"
msgstr "出力を生成するために使ったテンプレートタイプ"

# @return [Boolean]
#: ../lib/yard/templates/template_options.rb:46
msgid "whether serialization should be performed"
msgstr "シリアライズが実行されるかどうか"

# @return [Serializers::Base]
#: ../lib/yard/templates/template_options.rb:50
msgid ""
"the serializer used to generate links and serialize\n"
"output. Serialization output only occurs if {#serialize} is +true+."
msgstr ""

# @deprecated
#: ../lib/yard/templates/template_options.rb:54
#: ../lib/yard/templates/template_options.rb:56
msgid "use {#highlight} instead."
msgstr ""

# @return [String]
#: ../lib/yard/templates/template_options.rb:54
#: ../lib/yard/templates/template_options.rb:56
msgid "whether highlighting should be ignored"
msgstr "ハイライトが無視されるかどうか"

# @param [String] title
#: ../lib/yard/templates/template_options.rb:60
msgid "the title of a given page"
msgstr "与えられたページのタイトル"

# @return [Array<String>]
#: ../lib/yard/templates/template_options.rb:68
msgid ""
"an array of module name wildcards to embed into\n"
"class documentation as if their methods were defined directly in the class.\n"
"Useful for modules like ClassMethods. If the name contains '::', the module\n"
"is matched against the full mixin path, otherwise only the module name is "
"used."
msgstr ""

# @example A list of mixin path names (including wildcards)
#: ../lib/yard/templates/template_options.rb:68
msgid "opts.embed_mixins #=> ['ClassMethods', '*Helper', 'YARD::*']"
msgstr ""

# @example
#: ../lib/yard/templates/template_options.rb:68
msgid "tag|example|A list of mixin path names (including wildcards)"
msgstr ""

# @param [CodeObjects::Base] mixin
#: ../lib/yard/templates/template_options.rb:74
msgid ""
"accepts any code object, but returns\n"
"nil unless the object is a module."
msgstr ""

# @return [nil]
#: ../lib/yard/templates/template_options.rb:74
msgid "if the mixin is not a module object"
msgstr "mixinがモジュールオブジェクトでない場合"

# @param [Fixnum, nil]
#: ../lib/yard/templates/template_options.rb:74
msgid "tag|param|mixin"
msgstr "tag|param|mixin"

# @return [Boolean]
#: ../lib/yard/templates/template_options.rb:74
msgid "whether a mixin matches the embed_mixins list"
msgstr "mixinがembed_mixinsのリストにマッチするかどうか"

# @param [Serializers::Base] serializer
#: ../lib/yard/templates/template_options.rb:85
msgid "the verifier object"
msgstr "verifier(認証)オブジェクト"

# YARD::Verifier
#: ../lib/yard/verifier.rb:3
msgid ""
"Similar to a Proc, but runs a set of Ruby expressions using a small\n"
"DSL to make tag lookups easier."
msgstr ""
"Procと同様であるが、検索しやすいタグを作る為に、\n"
"ちょっとしたDSLによって、Rubyの式のグループを起動する。"

# YARD::Verifier
#: ../lib/yard/verifier.rb:6
msgid ""
"The syntax is as follows:\n"
"* All syntax is Ruby compatible\n"
"* +object+ (+o+ for short) exist to access the object being verified\n"
"* +@TAGNAME+ is translated into +object.tag('TAGNAME')+\n"
"* +@@TAGNAME+ is translated into +object.tags('TAGNAME')+\n"
"* +object+ can be omitted as target for method calls (it is implied)"
msgstr ""
"次の様な構文となる:\n"
"* 全ての構文は、Rubyと互換性がある。\n"
"* +object+ (略字は +o+)は検証されるオブジェクトにアクセスする為に存在する。\n"
"* +@TAGNAME+ は +object.tag('TAGNAME')+ の中で変換される\n"
"* +@@TAGNAME+ は +object.tags('TAGNAME')+ の中で変換される\n"
"* +object+ は、メソッド呼び出し用の対象として省略できる。(ほのめかす)"

# @example Check if there are any @param tags
#: ../lib/yard/verifier.rb:33
msgid ""
"Verifier.new('@@param.empty?')\n"
"# Equivalent to:\n"
"Verifier.new('object.tags(:param).empty?')"
msgstr ""
"Verifier.new('@@param.empty?')\n"
"# 下は上と同様\n"
"Verifier.new('object.tags(:param).empty?')"

# @example Specifying multiple expressions
#: ../lib/yard/verifier.rb:33
msgid ""
"Verifier.new('@return', '@param', '@yield')\n"
"# Equivalent to:\n"
"Verifier.new('@return && @param && @yield')"
msgstr ""
"Verifier.new('@return', '@param', '@yield')\n"
"# 以下は上と同様\n"
"Verifier.new('@return && @param && @yield')"

# @example Create a verifier to find any return tag with an empty description
#: ../lib/yard/verifier.rb:33
msgid ""
"Verifier.new('@return.text.empty?')\n"
"# Equivalent to:\n"
"Verifier.new('object.tag(:return).text.empty?')"
msgstr ""
"Verifier.new('@return.text.empty?')\n"
"# 下は上と同様\n"
"Verifier.new('object.tag(:return).text.empty?')"

# @example Using +object+ or +o+ to look up object attributes directly
#: ../lib/yard/verifier.rb:33
msgid ""
"Verifier.new('object.docstring == \"hello world\"')\n"
"# Equivalent to:\n"
"Verifier.new('o.docstring == \"hello world\"')"
msgstr ""
"Verifier.new('object.docstring == \"hello world\"')\n"
"# 下は上と同様\n"
"Verifier.new('o.docstring == \"hello world\"')"

# @example Without using +object+ or +o+
#: ../lib/yard/verifier.rb:33
msgid "Verifier.new('tag(:return).size == 1 || has_tag?(:author)')"
msgstr ""

# @example
#: ../lib/yard/verifier.rb:33
msgid "tag|example|Check if there are any @param tags"
msgstr "@paramタグがあるかチェックする"

# @example
#: ../lib/yard/verifier.rb:33
msgid ""
"tag|example|Create a verifier to check for objects that don't have @private "
"tags"
msgstr "@privateタグを持たないオブジェクト用にチェックする検証器を作成する。"

# @example
#: ../lib/yard/verifier.rb:33
msgid ""
"tag|example|Create a verifier to find any return tag with an empty "
"description"
msgstr "空の説明と共に、任意のreturnタグを見つける検証器を作成する。"

# @example
#: ../lib/yard/verifier.rb:33
msgid "tag|example|Specifying multiple expressions"
msgstr "複数の表現を指定する"

# @example
#: ../lib/yard/verifier.rb:33
msgid "tag|example|Using +object+ or +o+ to look up object attributes directly"
msgstr "直接オブジェクト属性を検索するには、+object+ や +o+を使う"

# @example
#: ../lib/yard/verifier.rb:33
msgid "tag|example|Without using +object+ or +o+"
msgstr "+object+ と +o+ を使わない例"

# @example Create a verifier to check for objects that don't have @private tags
#: ../lib/yard/verifier.rb:33
msgid ""
"verifier = Verifier.new('!@private')\n"
"verifier.call(object) # => true (no @private tag)"
msgstr ""

# @return [Array<String>]
#: ../lib/yard/verifier.rb:36
msgid "a list of all expressions the verifier checks for"
msgstr "チェックする検証器用の全ての式のリスト"

# YARD::Verifier#initialize
#: ../lib/yard/verifier.rb:44
msgid "Creates a verifier from a set of expressions"
msgstr "式のグループから検証器を作成する。"

# @param [Array<String>] expressions
#: ../lib/yard/verifier.rb:47
msgid ""
"a list of Ruby expressions to\n"
"parse."
msgstr "解析するRubyの式のリスト"

# @return [Verifier]
#: ../lib/yard/verifier.rb:47
msgid "a new instance of Verifier"
msgstr "検証器の新しいインスタンス"

# @param [Array<String>]
#: ../lib/yard/verifier.rb:47 ../lib/yard/verifier.rb:57
msgid "tag|param|expressions"
msgstr "式"

# YARD::Verifier#add_expressions
#: ../lib/yard/verifier.rb:53
msgid "Adds a set of expressions and recompiles the verifier"
msgstr "式のグループを追加し、検証器を再編集する。"

# @param [Array<String>] expressions
#: ../lib/yard/verifier.rb:57
msgid "a list of expressions"
msgstr "式のリスト"

# YARD::Verifier#method_missing
#: ../lib/yard/verifier.rb:62
msgid "Passes any method calls to the object from the {#call}"
msgstr "{#call}メソッドからオブジェクトに任意のメソッド呼び出しを解析する"

# YARD::Verifier#call
#: ../lib/yard/verifier.rb:71
msgid "Tests the expressions on the object."
msgstr "オブジェクト上の式をテストする"

# @note
#: ../lib/yard/verifier.rb:75
msgid "If the object is a {CodeObjects::Proxy} the result will always be true."
msgstr "オブジェクトが{CodeObjects::Proxy}なら、評価結果は,常にtrueになる。"

# @param [CodeObjects::Base] object
#: ../lib/yard/verifier.rb:75
msgid "the object to verify"
msgstr "検証するオブジェクト"

# @return [Boolean]
#: ../lib/yard/verifier.rb:75
msgid "the result of the expressions"
msgstr "式の結果"

# YARD::Verifier#run
#: ../lib/yard/verifier.rb:85
msgid ""
"Runs a list of objects against the verifier and returns the subset\n"
"of verified objects."
msgstr ""
"オブジェクトに対する検証器のリストを起動し、検証されるオブジェクトの下位集合"
"を返す"

# @return [Array<CodeObjects::Base>]
#: ../lib/yard/verifier.rb:90
msgid ""
"a list of code objects that match\n"
"the verifier."
msgstr "検証器にマッチするコードオブジェクトのリスト"

# @return [CodeObjects::Base]
#: ../lib/yard/verifier.rb:97
msgid "the current object being tested"
msgstr "テストされる現在のオブジェクト"

# YARD::Verifier#modify_nilclass
#: ../lib/yard/verifier.rb:106
msgid ""
"Modifies nil to not throw NoMethodErrors. This allows\n"
"syntax like object.tag(:return).text to work if the #tag\n"
"call returns nil, which means users don't need to perform\n"
"stringent nil checking"
msgstr ""
"NoMethodErrorsにthrowせずnil classに変更する。\n"
"#tagメソッド呼び出しがnilを返す場合、\n"
"これはobject.tag(:return).textのような構文を受け入れる。\n"
"ユーザーが厳密なnilのチェックする為に必要としない事を意味する。"

# YARD::Verifier#unmodify_nilclass
#: ../lib/yard/verifier.rb:118
msgid "Returns the state of NilClass back to normal"
msgstr "NilClassの状態を元に戻す"

# YARD::Verifier#create_method_from_expressions
#: ../lib/yard/verifier.rb:126
msgid ""
"Creates the +__execute+ method by evaluating the expressions\n"
"as Ruby code"
msgstr ""
"Rubyのコードのような式を評価する事によって +__execute+ メソッドを作成する。"

# YARD::Verifier#parse_expression
#: ../lib/yard/verifier.rb:137
msgid "Parses a single expression, handling some of the DSL syntax."
msgstr "単独の式を解析し、いくつかのDSL構文を操作する。"

# YARD::Verifier#parse_expression
#: ../lib/yard/verifier.rb:139
msgid ""
"The syntax \"@tag\" should be turned into object.tag(:tag),\n"
"and \"@@tag\" should be turned into object.tags(:tag)"
msgstr ""
"\"@tag\"構文は、object.tag(:tag)へ渡され、\n"
"\"@tags\"構文は、object.tags(:tag)へ渡される。"

# @return [String]
#: ../lib/yard/verifier.rb:142
msgid "the parsed expression"
msgstr "解析された式"

# YARD::Tags::Library
#~ msgid ""
#~ "This will allow you to use @mytag TEXT to add meta data to classes "
#~ "through\n"
#~ "the docstring. You can use the {Library#factory} object to help parse "
#~ "standard\n"
#~ "tag syntax."
#~ msgstr ""
#~ "この例は、\n"
#~ "あなたが、docstringを通じてクラス化するメタデータを追加する為に\n"
#~ "@mytag TEXTを使う事を受け入れる。\n"
#~ "あなたは、標準のタグ構文を解析し補助する為に\n"
#~ "{Library#factory}オブジェクトを利用できる。"

# YARD::Tags::Library
#~ msgid ""
#~ "== Method #2\n"
#~ "Write your own +tagname_tag+ method that takes the raw text as a "
#~ "parameter.\n"
#~ "Example:\n"
#~ "  def mytag_tag(text)\n"
#~ "    # parse your tag contents here\n"
#~ "  end"
#~ msgstr ""
#~ "== 方法 #2\n"
#~ "自分で引数の様に生のテキストを取得し、 +tagname_tag+ メソッドを書く。\n"
#~ "\\nExample:\n"
#~ "  def mytag_tag(text)\n"
#~ "    # parse your tag contents here\n"
#~ "  end"

# YARD::Tags::Library
#~ msgid ""
#~ "Note that +tag_factory+ is the factory object used to parse tags. This "
#~ "value\n"
#~ "defaults to the {DefaultFactory} class and can be set by changing "
#~ "{Library.default_factory}."
#~ msgstr ""
#~ "次の事に留意する。\n"
#~ "+tag_factory+ は、タグを解析する為に利用されるfactoryオブジェクトとな"
#~ "る。\n"
#~ "この値は{DefaultFactory}クラスがデフォルトとなり、\n"
#~ "{Library.default_factory}を変更する事によって設定できる。"

# YARD::Tags::Library
#~ msgid ""
#~ "The second line will expand to:\n"
#~ "  def author_tag(text) tag_factory.parse_tag(text) end"
#~ msgstr ""
#~ "例の2番目の行は次の様になる:\n"
#~ "  def author_tag(text) tag_factory.parse_tag(text) end"

# YARD::Tags::Library
#~ msgid ""
#~ "The first line will expand to the code:\n"
#~ "  def param_tag(text) tag_factory.parse_tag_with_types_and_name(text) end"
#~ msgstr ""
#~ "例の最初の行は、次の様になる:\n"
#~ "  def param_tag(text) tag_factory.parse_tag_with_types_and_name(text) end"

# YARD::Tags::Library
#~ msgid ""
#~ "== Method #1\n"
#~ "Use {Library.define_tag} to define a new tag by passing the tag name\n"
#~ "and the factory method to use when creating the tag. These definitions "
#~ "will\n"
#~ "be auto expanded into ruby code similar to what is shown in method #2. If "
#~ "you\n"
#~ "do not provide a factory method to use, it will default to "
#~ "{DefaultFactory#parse_tag}\n"
#~ "Example:\n"
#~ "  define_tag \"Parameter\", :param, :with_types_and_name\n"
#~ "  define_tag \"Author\", :author"
#~ msgstr ""
#~ "== 方法 #1\n"
#~ "{Library.define_tag}を使い,タグ名を解析する事によって新しいタグを定義"
#~ "し、\n"
#~ "タグを作成する時にfactoryメソッドを使用する。\n"
#~ "これらの定義は 方法 #2の中の見られる事と同様に\n"
#~ "Rubyコードの中で自動拡張される。\n"
#~ "あなたがfactoryメソッドを利用しない場合、\n"
#~ "デフォルトは{DefaultFactory#parse_tag}になるだろう。\n"
#~ "\\nExample:\n"
#~ "  define_tag \"Parameter\", :param, :with_types_and_name\n"
#~ "  define_tag \"Author\", :author"

# YARD::Tags::Library
#~ msgid ""
#~ "Holds all the registered meta tags. If you want to extend YARD and add\n"
#~ "a new meta tag, you can do it in one of two ways."
#~ msgstr ""
#~ "全ての記録されるメタタグを把握する。あなたがYARDを拡張したい場合や\n"
#~ "新しいメタタグを追加したい場合は、2つの方法のうちどちらかを選択することが"
#~ "できる。"

# YARD::Server::WebrickServlet#adapter=
#~ msgid "Sets the attribute adapter"
#~ msgstr "アダプタの属性を設定する"

# YARD::Server::WebrickServlet#adapter
#~ msgid "Returns the value of attribute adapter"
#~ msgstr "アダプタの属性の値を返す"

# @param value
#~ msgid "the value to set the attribute adapter to."
#~ msgstr "アダプタの属性を設定する値"

# YARD::Server::Commands::SearchCommand#results=
#~ msgid "Sets the attribute results"
#~ msgstr "results属性を設定する"

# YARD::Server::Commands::SearchCommand#query=
#~ msgid "Sets the attribute query"
#~ msgstr "query属性を設定する"

# YARD::Server::Commands::SearchCommand#results
#~ msgid "Returns the value of attribute results"
#~ msgstr "results属性の値を返す"

# YARD::Server::Commands::SearchCommand#query
#~ msgid "Returns the value of attribute query"
#~ msgstr "query属性の値を返す"

# @param value
#~ msgid "the value to set the attribute results to."
#~ msgstr "results属性を設定する値"

# @param value
#~ msgid "the value to set the attribute query to."
#~ msgstr "query属性を設定する値"

# YARD::Server::Commands::ListFilesCommand
#~ msgid "Returns the list of README/extra files in a library"
#~ msgstr "ライブラリの中のREADMEと追加のファイルのリストを返す"

# YARD::Server::Commands::ListMethodsCommand
#~ msgid "Returns the list of methods in a library"
#~ msgstr "ライブラリの中のメソッドのリストを返す"

# YARD::Server::Commands::ListClassesCommand
#~ msgid "Returns the list of classes / modules in a library"
#~ msgstr "ライブラリの中のクラスとモジュールのリストを返す"

# YARD::Server::Commands::LibraryIndexCommand#options=
#~ msgid "Sets the attribute options"
#~ msgstr "options属性を設定する"

# @param value
#~ msgid "the value to set the attribute options to."
#~ msgstr "options属性を設定する為の値"

# YARD::RegistryStore#proxy_types
#~ msgid "Returns the value of attribute proxy_types"
#~ msgstr "proxy_types属性の値を返す"

# @example
#~ msgid "tag|example|Performing a Search on a Registry"
#~ msgstr "レジストリー上で検索を実行する"

# @param [Boolean] load_order_errors
#~ msgid "whether or not to raise the {LoadOrderError}"
#~ msgstr "{LoadOrderError}の例外を上げるかどうか"

# @param [Symbol] parser_type
#~ msgid "the parser type to use"
#~ msgstr "使用するパーサータイプ。"

# @param [Boolean]
#~ msgid "tag|param|load_order_errors"
#~ msgstr "load_order_errors"

# @param [OpenStruct] globals
#~ msgid "global state to be re-used across separate source files"
#~ msgstr "ソースファイルをまたいで再利用される、globals"

# YARD::Parser::SourceParser#initialize
#~ msgid ""
#~ "Creates a new parser object for code parsing with a specific parser type."
#~ msgstr ""
#~ "明確なパーサー型と共にコード解析用の\n"
#~ "新しいパーサーオブジェクトを作成する。"

# YARD::Parser::SourceParser.parse_in_order
#~ msgid ""
#~ "Parses a list of files in a queue. If a {LoadOrderError} is caught,\n"
#~ "the file is moved to the back of the queue with a Continuation object\n"
#~ "that can continue processing the file."
#~ msgstr ""
#~ "err節の説明が入ってない\n"
#~ "Errorの時は Continuation オブジェクトではなく、\n"
#~ "e.contextと共にファイルの後ろにpushされる。)\n"
#~ "\n"
#~ "キューの中のファイルのリストを解析する。\n"
#~ "{LoadOrderError}が見つかった場合、\n"
#~ "ファイルはキューの後ろに移動され、Continuationオブジェクトを用い、\n"
#~ "処理しているファイルを継続できる"

# @param [Continuation]
#~ msgid "tag|param|context"
#~ msgstr "context"

# @return [LoadOrderError]
#~ msgid "a new instance of LoadOrderError"
#~ msgstr "LoadOrderErrorの新しいインスタンス。"

# @return [Continuation]
#~ msgid ""
#~ "the context representing the\n"
#~ "point at which the load order error occurred."
#~ msgstr ""
#~ "コンテキストはload order errorが起こされる所の\n"
#~ "ポイントを指摘する。"

# YARD::Parser::LoadOrderError
#~ msgid ""
#~ "A LoadOrderError occurs when a handler needs to modify a\n"
#~ "{CodeObjects::NamespaceObject} (usually by adding a child to it)\n"
#~ "that has not yet been resolved."
#~ msgstr ""
#~ "LoadOrderErrorは、ハンドラーが解決されない{CodeObjects::NamespaceObject}"
#~ "を\n"
#~ "修正する必要がある時に起こる。(通常は、NamespaceObjectに子を追加する)"

# @return [Object]
#~ msgid "the current value of shebang_line"
#~ msgstr "shebang_lineの現在の値"

# @return [Object]
#~ msgid "the current value of enumerator"
#~ msgstr "enumeratorの現在の値"

# @return [Object]
#~ msgid "the current value of encoding_line"
#~ msgstr "encoding_lineの現在の値"

# YARD::Parser::Ruby::Legacy::Statement#group=
# YARD::Parser::Ruby::AstNode#group=
#~ msgid "Sets the attribute group"
#~ msgstr "グループ属性を設定する。"

# YARD::Parser::Ruby::Legacy::Statement#group
# YARD::Parser::Ruby::AstNode#group
#~ msgid "Returns the value of attribute group"
#~ msgstr "グループ属性の入った値を返す。"

# @param value
#~ msgid "the value to set the attribute group to."
#~ msgstr "グループ属性を設定する,値"

# @return [LocaleInfoCollector]
#~ msgid "a new instance of LocaleInfoCollector"
#~ msgstr "LocaleInfoCollectorの新しいインスタンス"

# @param [String] member
#~ msgid "the name of the struct member whose return type we need"
#~ msgstr "必要とする型を返す構造体memberの名前"

# @param [Boolean] load_order_error
#~ msgid ""
#~ "whether or not to raise {Parser::LoadOrderError}\n"
#~ "when a file has unresolved references that need to be parsed first.\n"
#~ "If these errors are raised, the processor will attempt to load all\n"
#~ "other files before continuing to parse the file."
#~ msgstr ""
#~ "ファイルが最初に解析される必要がある参照を未解決の時、\n"
#~ "{Parser::LoadOrderError}の例外を上げるかどうか\n"
#~ "もしこれらのエラーが上げられる場合、\n"
#~ "プロセッサーは、ファイルの解析を継続する前に\n"
#~ "全ての他のファイルをロードをする。"

# @param [Symbol] parser_type
#~ msgid ""
#~ "the parser type (:ruby, :ruby18, :c) from\n"
#~ "the parser. Used to select the handler (since handlers are specific\n"
#~ "to a parser type)."
#~ msgstr ""
#~ "パーサーが提供する,パーサータイプ(:ruby, :ruby18, :c)\n"
#~ "利用するハンドラーを選択するには、(ハンドラーがパーサータイプを指定す"
#~ "る。)\n"
#~ "the parser. Used to select the handler (since handlers are specific to a "
#~ "parser type)."

# @param [OpenStruct] globals
#~ msgid ""
#~ "the object holding all state during the\n"
#~ "post processing stage"
#~ msgstr "後処理段階の間に全ての状態を保持するオブジェクト"

# @param [String] file
#~ msgid ""
#~ "the name of the file that is being processed.\n"
#~ "uses '(stdin)' if file is nil."
#~ msgstr ""
#~ "処理されるファイルの名前、\n"
#~ "ファイルがnilの場合、'(stdin)'を使う。"

# @param [Symbol]
#~ msgid "tag|param|parser_type"
#~ msgstr "parser_type"

# @return [Boolean]
#~ msgid "whether or not {Parser::LoadOrderError} is raised"
#~ msgstr "{Parser::LoadOrderError}の例外を上げるかどうか"

# @param [CodeObjects::Base] object
#~ msgid "the object to expand the macro on"
#~ msgstr "拡張するオブジェクトのマクロ"

# @param [CodeObjects::MacroObject] macro
#~ msgid "the macro object to expand"
#~ msgstr "マクロによって拡張する為のオブジェクト"

# @return [CodeObjects::MacroObject]
#~ msgid "the newly created macro"
#~ msgstr "新たに作成されたマクロ"

# @param [Docstring, CodeObjects::Base] object_or_docstring
#~ msgid ""
#~ "the docstring\n"
#~ "or it's object with which to check for a macro"
#~ msgstr "マクロのチェックの為のdocstringやオブジェクト"

# @return [nil]
#~ msgid "if the docstring does not create or reference a macro"
#~ msgstr "docstringが作られていない場合やマクロの参照がない場合"

# YARD::Handlers::Base#find_or_create_macro
#~ msgid ""
#~ "Attempts to find or create a macro if a +@macro+ tag is found in the\n"
#~ "docstring (or the object's docstring)."
#~ msgstr ""
#~ "+@macro+ タグがdocstring(やオブジェクトのdocstring)の中で見つかった場"
#~ "合、\n"
#~ "マクロタグがあるか探し、マクロ作成を試みる。"

# @return [String]
#~ msgid "the localized docstring."
#~ msgstr "docstringを局所化する"

# YARD::Docstring#document
#~ msgid ""
#~ "Gets a localized docstring. Use String#to_s to get non\n"
#~ "localized docstring."
#~ msgstr ""
#~ "局所化されるdocstringを取得する。\n"
#~ "局所化されないdocstringを取得するには、\n"
#~ "String#to_sメソッドを使う。"

# @param [Array<String>] call_params
#~ msgid ""
#~ "the method name and parameters\n"
#~ "to the method call. These arguments will fill $0-N"
#~ msgstr ""
#~ "メソッド名やメソッド呼び出しの為のパラメータ。\n"
#~ "これらの引数には、$0-Nを入れる。"

# @param [String] full_source
#~ msgid ""
#~ "the full source line (excluding block) \n"
#~ "interpolated as $*"
#~ msgstr "$*のように、補完される完全なソースの行(blockを除外する)"

# @return [String]
#~ msgid "the expanded macro data"
#~ msgstr "拡張されたマクロデータ"

# @param [String] block_source
#~ msgid ""
#~ "Currently unused. Will support \n"
#~ "interpolating the block data as a variable."
#~ msgstr ""
#~ "実際には、使われない。\n"
#~ "変数のように補完するブロックデータをサポートする。"

# @return [Boolean]
#~ msgid "whether to report missing translations."
#~ msgstr "見つからない変換をレポートするかどうか"

# @return [String]
#~ msgid "a language for output document."
#~ msgstr "ドキュメント出力用の言語"

# @return [Array<String>]
#~ msgid "the default list of locale path."
#~ msgstr "デフォルトのロケールパスのリスト"

# @return [Array<String>]
#~ msgid "a list of locale path."
#~ msgstr "ロケールパスのリスト"

#~ msgid ""
#~ "  3. Define custom javascript to load the search fields and the keyboard "
#~ "shortcuts."
#~ msgstr ""
#~ "  3. 検索フィールドとキーボードショートカットをロードするカスタム"
#~ "javascriptを定義する。"

#~ msgid ""
#~ "The interpolation syntax is similar to Ruby's regular expression variable "
#~ "syntax.\n"
#~ "It uses $1, $2, $3, ..., referring to the Nth argument in the method "
#~ "call. Using\n"
#~ "the above property example, $1 would be 'title', and $2 would be "
#~ "'String'.\n"
#~ "$0 is a special variable that refers to the method call itself, in this "
#~ "case\n"
#~ "'property'. Finally, there is a $& variable which refers to the full "
#~ "line,\n"
#~ "or 'property :title, String'."
#~ msgstr ""
#~ "補間の構文法は、Rubyの正規表現の変数の構文の表現に似ている。\n"
#~ "メソッドコールでのN番目の引数かを参照して、\n"
#~ "$1,$2,$3・・・を使う。\n"
#~ "上記の例で言うと、$1は'title'、$2は'String'となる。\n"
#~ "$0は、このケースのプロパティでは、\n"
#~ "メソッドコール自体を参照する特別な変数である。\n"
#~ "最後に、$&変数というのがある。\n"
#~ "これは全ての行あるいは'property :title, String'.を参照する。"

#~ msgid "### Macro Variable Interpolation Syntax"
#~ msgstr "### マクロの変数補間構文"

#~ msgid ""
#~ "If you cannot declare the macro on the actual method declaration, you "
#~ "can\n"
#~ "arbitrarily attach the macro to any method call. Suppose we only had the\n"
#~ "Post class in our codebase, we could add the macro to the first usage of\n"
#~ "the `property` call:"
#~ msgstr ""
#~ "もし、元々のクラスのメソッドでマクロを宣言してなくても、\n"
#~ "他のメソッド呼び出しでマクロを付けることができる。\n"
#~ "自身のコードベースの中でしかPostクラスを持っていないとすれば、\n"
#~ "`property`呼び出しで初めて使う時にマクロをつけることができる。"

#~ msgid ""
#~ "Macros can be created on class level methods (or class level method "
#~ "calls) in \n"
#~ "order to implicitly expand a macro whenever that method is subsequently "
#~ "called \n"
#~ "in a class, or any class that mixes in or inherits the method. These "
#~ "macros\n"
#~ "are called \"attached\" and are declared with the `[attach]` flag. For "
#~ "instance, \n"
#~ "a library that uses a class level method call `property` in its codebase "
#~ "can \n"
#~ "document these declarations in any future call like so:"
#~ msgstr ""
#~ "マクロはメソッドがクラスの中で呼び出された後で、\n"
#~ "何らかのマクロの拡張を実装する時にコードの中の\n"
#~ "クラスレベルメソッド上に作成される。(または、クラスレベルメソッド呼び出"
#~ "し)\n"
#~ "これらのマクロは`[attach]`フラグを用いる。\n"
#~ "これが宣言される事によってマクロが追加される。\n"
#~ "例えば、ライブラリーが`property`クラスレベルメソッド呼び出しを利用するに"
#~ "は、\n"
#~ "以下の様に、将来呼び出せるように宣言を記述できる。"

#~ msgid ""
#~ "In the above case, the macro 'macro_name' will always show both lines of "
#~ "text\n"
#~ "when expanded on other objects."
#~ msgstr ""
#~ "上記のケースだと、 'macro_name' というマクロは他のオブジェクトで\n"
#~ "展開すると、テキストの両方の行を表示する。"

#~ msgid ""
#~ "If there is no indented macro data, the entire docstring is saved as the\n"
#~ "macro data. For instance,"
#~ msgstr ""
#~ "インデントされたマクロのデータがないならば、\n"
#~ "docstring全体はマクロのデータとして保存される。\n"
#~ "例えば、"

#~ msgid ""
#~ "You can therefore keep portions of docstrings local to objects even when\n"
#~ "creating a macro, by indenting the portion of the data that should be "
#~ "re-\n"
#~ "expanded, and listing the local docstring data above or below."
#~ msgstr ""
#~ "マクロを作った時でも、docstringの一部をマクロとは別にしておくことができ"
#~ "る。\n"
#~ "それには、再度展開されるべきマクロデータの一部をインデントして、なおか"
#~ "つ、\n"
#~ "上か下にローカルのdocstringのデータを列挙する。"

#~ msgid ""
#~ "In the above case, \"The macro data is here.\" is the only portion that "
#~ "will be\n"
#~ "re-used if the macro is called again on another object. However, for the "
#~ "case\n"
#~ "of the above method, both the macro data and the local docstring will be\n"
#~ "applied to the method, creating the docstring:"
#~ msgstr ""
#~ "上記のケースで、\"The macro data is here.\"はマクロが、\n"
#~ "別のオブジェクトで呼ばれたら再利用されるものの一部である。\n"
#~ "だが、ここで使われないというわけではなく、\n"
#~ "上記のケースでは、マクロデータと他のdocstring(This data is~)はメソッドに適"
#~ "用され\n"
#~ "docstringを生成する。"

#~ msgid ""
#~ "If a macro tag has an indented body of macro data (shown below), it will "
#~ "be\n"
#~ "the only portion of the docstring saved for re-use."
#~ msgstr ""
#~ "マクロのタグが以下のようなインデントされたマクロデータの構造を有しているな"
#~ "らば、\n"
#~ "それは再利用のために保存されたdocstringの一部分にすぎない。\n"

#~ msgid "### Indenting the Macro Data"
#~ msgstr "### マクロのデータをインデントする。"

#~ msgid ""
#~ "Note that the name is never optional. Even if the macro is never re-"
#~ "used,\n"
#~ "it must be named."
#~ msgstr ""
#~ "次の事に留意する。\n"
#~ "名前は必ずつける。\n"
#~ "(マクロが再利用されていない時でも、必ず命名されなければならない。)"

#~ msgid ""
#~ "Any time 'foo' is called in the class scope of an inheriting class, the "
#~ "macro\n"
#~ "will automatically expand on that method call (potentially creating a "
#~ "new\n"
#~ "method object). Attaching macros is discussed below."
#~ msgstr ""
#~ "上のfooは常時、継承クラスのクラススコープの中に呼び出される。\n"
#~ "そしてマクロはメソッド呼び出しで自動的に展開する。\n"
#~ "(暗黙の内に新しいメソッドオブジェクトを生成する。)\n"
#~ "マクロを追加する方法は、以降で説明される。"

#~ msgid ""
#~ "You can also \"attach\" a macro to a method if it is in the class scope. "
#~ "In\n"
#~ "this case, you do not need to also provide the 'new' flag, using "
#~ "'attach'\n"
#~ "is sufficient:"
#~ msgstr ""
#~ "クラスのスコープの中にあれば、\n"
#~ "メソッドにマクロを\"attach\"できる。\n"
#~ "この場合、\"new\"フラグを提供する必要はなく、\n"
#~ "以下の様に\"attach\"で十分である。\n"

#~ msgid "Or:"
#~ msgstr "または:"

#~ msgid ""
#~ "For instance, creating a new macro might look like (see the section on\n"
#~ "interpolation below for a description of the `$2` syntax):"
#~ msgstr ""
#~ "例えば、新しいマクロを作ることは以下のようになる。\n"
#~ "(`$2`構文の説明は補間のセクション参照)"

#~ msgid ""
#~ "  1. there are interpolation variables (`$1`, `$2`, `${3-5}`, etc.) in "
#~ "the\n"
#~ "     docstring, or,\n"
#~ "  2. the macro is specified with the `[new]` or `[attached]` flag."
#~ msgstr ""
#~ "  1. docstringには補間変数(`$1`,`$2`,`$3-5`,etc.)がある。\n"
#~ "     （ここでいう補間変数とは、それを使用した場所と補間元とを置換するとい"
#~ "う意味）\n"
#~ "  2. あるいは、マクロは[new]か[attached]のフラグで指定されている。\n"

#~ msgid "If the macro does not already exist, it will be created if:"
#~ msgstr "マクロがまだ存在しない場合で、次の条件の時はマクロが生成される。"

#~ msgid ""
#~ "In the above example, both attributes `foo` and `bar` will get the "
#~ "docstring\n"
#~ "that includes a return tag \"the attribute as a String\". It would be "
#~ "equivalent\n"
#~ "to writing the following:"
#~ msgstr ""
#~ "上記の例では、fooとbarの２つの属性ともリターンタグの\n"
#~ "\"the attribute as a String\"を含んだdocstringを取得している。\n"
#~ "次のように書いた場合と同じである。"

#~ msgid ""
#~ "Macros enable the documenter to write repetitive documentation once and "
#~ "then\n"
#~ "re-apply it to other objects. Macros are defined on docstrings using the\n"
#~ "`@macro` tag. The same `@macro` tag is used to expand them. The "
#~ "following\n"
#~ "is an example of a simple macro declaration and expansion:"
#~ msgstr ""
#~ "マクロを使うと一度書いたドキュメントを、\n"
#~ "他のオブジェクトで再利用できる。\n"
#~ "マクロはdocstringsで@macroタグを使って定義される。\n"
#~ "同じ名前の@macroタグは展開するために使われる。\n"
#~ "以下は、単純なマクロの宣言と展開の例である。"

#~ msgid "## Macros"
#~ msgstr "## マクロ"

#~ msgid ""
#~ "Reference tags are represented by the {YARD::Tags::RefTag} class and are "
#~ "created\n"
#~ "directly during parsing by {YARD::Docstring}."
#~ msgstr ""
#~ "リファレンスタグは、{YARD::Tags::RefTag}クラスによって表わされ、\n"
#~ "{YARD::Docstring}を解析する間に作られる。\n"

#~ msgid ""
#~ "Because the UserHelper module methods delegate directly to `User.new`, "
#~ "copying\n"
#~ "the documentation details would be unmaintainable. In this case, the (see "
#~ "METHODNAME)\n"
#~ "syntax is used to reference the tags from the User constructor to the "
#~ "helper methods.\n"
#~ "For the first method, all `@param` tags are referenced in one shot, but "
#~ "the second\n"
#~ "method only references one of the tags by adding `username` before the "
#~ "reference."
#~ msgstr ""
#~ "何故なら、上のUserHelperモジュールのメソッドは直接`User.new`へ委譲するの"
#~ "で、\n"
#~ "ドキュメントの詳細をコピーすることはできない。\n"
#~ "このような場合、 (see METHODNAME) 構文はユーザーコンストラクターから\n"
#~ "ヘルパーメソッドまでのタグを参照するために利用される。\n"
#~ "最初のメソッドは、すべての@paramタグを一発で参照する。\n"
#~ "しかし、次のメソッドはリファレンスの前にユーザーネームが\n"
#~ "加えられたタグのみを参照する。"

#~ msgid ""
#~ "Although attempt is made in YARD to leave as many of the syntax details "
#~ "as\n"
#~ "possible to the factory provider, there is a special tag syntax for "
#~ "referencing\n"
#~ "tags created in other objects so that they can be reused again. This is "
#~ "common\n"
#~ "when an object describes a return type or parameters that are passed "
#~ "through to\n"
#~ "other methods. In such a case, it is more manageable to use the reference "
#~ "tag\n"
#~ "syntax. Consider the following example:"
#~ msgstr ""
#~ "ファクトリーの提供者によってYARDの中では沢山の構文の詳細を残すように試みら"
#~ "れたけれども、\n"
#~ "再利用できるように、他のオブジェクトの中に作成されたタグを参照する特別なタ"
#~ "グ構文がある。\n"
#~ "これは、オブジェクトが返す型や他のオブジェクトの為に解析されるパラメータ"
#~ "を\n"
#~ "説明する時に一般的に用いられる。\n"
#~ "このような場合には参照タグ構文を使うとより扱いやすい、\n"
#~ "以下の例を考えてみる。\n"

#~ msgid "## Reference Tags"
#~ msgstr "## 参照タグ"

#~ msgid "        @yieldreturn [optional, types, ...] description"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @yieldreturn [型(省略可能)...] 説明"

#~ msgid "  * `@yieldreturn`: Defines return type of a block"
#~ msgstr "  * `@yieldreturn`: ブロックのリターンタイプを定義する。"

#~ msgid "        @yieldparam [optional, types, ...] argname description"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @yieldparam [型(省略可能)...] 引数名 説明"

#~ msgid "  * `@yieldparam`: Defines parameters yielded by a block"
#~ msgstr "  * `@yieldparam`: ブロックでyieldされたパラメータを定義する。"

#~ msgid ""
#~ "        # for block {|a, b, c| ... }\n"
#~ "        @yield [a, b, c] Description of block"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        # for block {|a, b, c| ... }\n"
#~ "        @yield [a, b, c] ブロックの説明"

#~ msgid ""
#~ "  * `@yield`: Describes the block. Use types to list the parameter\n"
#~ "    names the block yields."
#~ msgstr "  * `@yield`: パラメータを列挙してブロックを説明する。"

#~ msgid "  * `@todo`: Marks a TODO note in the object being documented"
#~ msgstr ""
#~ "  * `@todo`: ドキュメントを作成しているオブジェクトの中に、\n"
#~ "    TODOをマークする。"

#~ msgid "        @return [optional, types, ...] description"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @return [型(省略可能)...] 説明"

#~ msgid "  * `@return`: Describes return value of method"
#~ msgstr "  * `@return`: メソッドの戻り値を説明する。"

#~ msgid "        @raise [ExceptionClass] description"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @raise [ExceptionClass] 説明"

#~ msgid "  * `@raise`: Describes an Exception that a method may throw"
#~ msgstr "  * `@raise`: メソッドが投げる例外を記述する。"

#~ msgid ""
#~ "  * `@private`: Defines an object as private. This exists for classes,\n"
#~ "    modules and constants that do not obey Ruby's visibility rules. For\n"
#~ "    instance, an inner class might be considered \"private\", though "
#~ "Ruby\n"
#~ "    would make no such distinction. By declaring the @private tag, the\n"
#~ "    class can be hidden from documentation by using the `--no-private`\n"
#~ "    command-line switch to yardoc (see {file:README.md})."
#~ msgstr ""
#~ "  * `@private`: privateとしてオブジェクトを定義する。\n"
#~ "これはRubyの可視性に従わないクラス、モジュール、定数のために存在する。\n"
#~ "たとえば、Rubyはそのような区分はしないだろうが,内部クラスは\"private\"だと"
#~ "考える場合、\n"
#~ "yardoc用のコマンド`--no-private`({file:README.md} 参照)を使うことによっ"
#~ "て\n"
#~ "@privateタグを宣言すると、クラスをドキュメンテーションから隠すことができ"
#~ "る。"

#~ msgid "        @param [optional, types, ...] argname description"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @param [型(省略可能)...] 引数名 説明"

#~ msgid "  * `@param`: Defines method parameters"
#~ msgstr "  * `@param`: メソッドのパラメータを定義する。"

#~ msgid ""
#~ "  * `@note`: Creates an emphasized note for the users to read about the\n"
#~ "    object."
#~ msgstr ""
#~ "  * `@note`: ユーザがオブジェクトのことを読んで知るために、\n"
#~ "     強調された注意書きを作る。\n"

#~ msgid ""
#~ "  * `@method`: Recognizes a DSL class method as a method with the given "
#~ "name\n"
#~ "    and optional signature. Only used with DSL methods."
#~ msgstr ""
#~ "  * `@method`: DSLクラスメソッドを名前と省略可能な用法がついたメソッドとし"
#~ "て認識する。DSLメソッドと一緒の時だけ使われる。"

#~ msgid ""
#~ "        @macro [new|attached] macro_name\n"
#~ "          The macro contents to expand"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @macro [new,又は,attached] マクロ名\n"
#~ "          展開する内容をここ以降に書く"

#~ msgid ""
#~ "  * `@macro`: Registers or expands a new macro. See the [Macros]"
#~ "(#macros)\n"
#~ "    section for more details. Note that the name parameter is never "
#~ "optional."
#~ msgstr ""
#~ "  * `@macro`: 新しいマクロを登録または拡張する。\n"
#~ "     詳細は [Macros](#macros) 参照。\n"
#~ "     NAMEというパラメータは省略できないことに注意する。"

#~ msgid ""
#~ "        @deprecated Describe the reason or provide alt. references here"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @deprecated 廃止される理由や代替の提供についての参照をここに書く。"

#~ msgid ""
#~ "  * `@deprecated`: Marks a method/class as deprecated with an optional\n"
#~ "    reason."
#~ msgstr ""
#~ "  * `@deprecated`: 廃止予定のメソッド,クラスをマークする。任意で理由を書く"

#~ msgid "        @author Full Name"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @author フルネーム"

#~ msgid "  * `@author`: List the author(s) of a class/method"
#~ msgstr "  * `@author`: クラス,メソッドの作者リスト"

#~ msgid "        @attribute [rw|r|w] NAME"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @attribute [rw|r|w] 名前"

#~ msgid ""
#~ "  * `@attribute`: Recognizes a DSL class method as an attribute with the "
#~ "given\n"
#~ "    name. Also accepts the r, w, or rw flag to signify that the attribute "
#~ "is \n"
#~ "    readonly, writeonly, or readwrite (default). Only used with DSL "
#~ "methods."
#~ msgstr ""
#~ "  * `@attribute`: DSLクラスメソッドを指定された名前を持つ属性として認識す"
#~ "る。\n"
#~ "     又,r,w,rwフラグは読み込み専用,書込み専用,読書き両用(デフォルト)とな"
#~ "る。\n"
#~ "     DSLのメソッドだけで使用される。\n"

#~ msgid "        @attr_writer [Types] name description of writeonly attribute"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @attr_writer [型...] 名前 書込み専用属性の説明"

#~ msgid ""
#~ "  * `@attr_writer`: Declares a writeonly attribute from the docstring of "
#~ "class.\n"
#~ "    Meant to be used on Struct classes only (classes that inherit "
#~ "Struct). See `@attr`."
#~ msgstr ""
#~ "  * `@attr_writer`: クラスのdocstringから書き込み専用属性と宣言する\n"
#~ "     Structクラスだけで使用できる。(Structクラスを継承するクラス)`@attr`参"
#~ "照。"

#~ msgid ""
#~ "        @attr_reader [Types] name description of a readonly attribute"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @attr_reader [型...] 名前 読取り専用属性の説明"

#~ msgid ""
#~ "  * `@attr_reader`: Declares a readonly attribute from the docstring of a "
#~ "class.\n"
#~ "    Meant to be used on Struct classes only (classes that inherit "
#~ "Struct). See `@attr`."
#~ msgstr ""
#~ "  * `@attr_reader`: クラスのdocstringから読み込み専用属性と宣言する。\n"
#~ "     Structクラスだけで使用できる。(Structクラスを継承するクラス)`@attr`参"
#~ "照。"

#~ msgid ""
#~ "        @attr [Types] attribute_name a full description of the attribute"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @attr [型...] 属性名 属性の全ての説明"

#~ msgid ""
#~ "  * `@attr`: Declares an attribute from the docstring of a class. Meant "
#~ "to be\n"
#~ "    used on Struct classes only (classes that inherit Struct)."
#~ msgstr ""
#~ "  * `@attr`: クラスのdocstringから属性を宣言する。\n"
#~ "     Structクラスだけで使用できる。(Structクラスを継承するクラス)"

#~ msgid "        @api freeform text"
#~ msgstr ""
#~ "        !!!plain\n"
#~ "        @api フリーフォームテキスト"

#~ msgid "YARD supplies the following built-in tags:"
#~ msgstr "YARDは、以下のビルトインタグを用意している。"

#~ msgid "## List of Available Tags"
#~ msgstr "## 利用可能なタグのリスト"

#~ msgid "As mentioned, types are optional, so the following is also valid:"
#~ msgstr "型は省略可能で, 以下は同様に有効である"

#~ msgid ""
#~ "Note that \"url\" in the above example is the key name. The syntax is of "
#~ "the form:"
#~ msgstr ""
#~ "次の事に留意する。\n"
#~ "上の例の中の\"url\"は、キー名である。\n"
#~ "この構文は次の形式になる。"

#~ msgid ""
#~ "A special case of the above data with optional type information is the "
#~ "case\n"
#~ "of tags like `@param`, where the data is further associated with a key. "
#~ "In\n"
#~ "the case of `@param` the key is an argument name in the method. The "
#~ "following\n"
#~ "shows how this can be used:"
#~ msgstr ""
#~ "省略可能な型情報を用いた上のデータの様な特殊なケースは、\n"
#~ "データがキーを用い更に関連付けられる場合、\n"
#~ "@paramのようなタグのケースとなる。\n"
#~ "`@param`キーのケースの場合は、メソッドの中の名前は引数となる。\n"
#~ "次のような用法で使われる。"

#~ msgid "### Data With Name and Optional Type Information"
#~ msgstr "### 名前と任意の型情報のついたデータ"

#~ msgid ""
#~ "This syntax optionally contains type information to be associated with "
#~ "the\n"
#~ "tag. Type information is specified as a freeform list of Ruby types, "
#~ "duck\n"
#~ "types or literal values. The following is a valid tag with type "
#~ "information:"
#~ msgstr ""
#~ "この構文は、省略できるタグに関連付けられる型情報が含まれる。\n"
#~ "型情報は、Rubyの型かダックタイプやリテラル値の\n"
#~ "フリーフォームのリストとして指定される。\n"
#~ "以下は、型情報を持つ有効なタグとなる。"

#~ msgid "### Data With Optional Type Information"
#~ msgstr "### 任意の型情報がついたデータ"

#~ msgid ""
#~ "Occasionally a freeform tag may reserve the first line for a title (or "
#~ "some\n"
#~ "other associative identifier) and treat only the subsequent indented "
#~ "lines as\n"
#~ "the tag data. Two examples are the `@example` and `@overload` tags. In "
#~ "the case\n"
#~ "of `@example` the first line is a title, and in the case of `@overload` "
#~ "the\n"
#~ "first line is the method signature for the overload. Here is an example "
#~ "of both:"
#~ msgstr ""
#~ "いくつかのフリーフォームタグは最初の行をタイトル(又は,他の関連する識別子)"
#~ "にする。\n"
#~ "そして、それに続くインデントされた行をタグデータとして処理する。\n"
#~ "２つの例は@exampleと@overloadタグのケースで、\n"
#~ "@exampleの場合は最初の行はタイトルとなる。\n"
#~ "@overloadの場合は最初の行はメソッドの用法となる。\n"
#~ "ここで両方の例を次に示す。"

#~ msgid "### Freeform Data With Title"
#~ msgstr "### タイトルを用いたフリーフォームデータ"

#~ msgid ""
#~ "This syntax has no special syntax, it is simply a tagname followed by "
#~ "any\n"
#~ "data."
#~ msgstr ""
#~ "この構文は特別な構文ではなく,\n"
#~ "何らかのデータに続いたタグ名があるだけとなる。"

#~ msgid "### Freeform Data"
#~ msgstr "### フリーフォームデータ"

#~ msgid ""
#~ "If a tag's data begins with `(see NAME)` it is considered a \"reference "
#~ "tag\".\n"
#~ "The syntax and semantics of a reference tag are discussed in the section "
#~ "below\n"
#~ "titled \"[Reference Tags](#reftags)\""
#~ msgstr ""
#~ "タグのデータが、`（see NAME）`で始まる場合、`それは、`参照タグ`とみなされ"
#~ "る。\n"
#~ "`参照タグ`の構文と文法は、\"[Reference Tags](#reftags)\"以下のセクションで"
#~ "説明されている。"

#~ msgid ""
#~ "In the above example, \"@tagname\" will have the text *\"This is tag data"
#~ "\"*."
#~ msgstr ""
#~ "上記の例で、\"@tagname\"内の情報は\"this is tag data\"となる。\n"
#~ "(but this is not は含まない)"

#~ msgid ""
#~ "Tags begin with \"@tagname\" at the start of a comment line. Tags can "
#~ "span multiple\n"
#~ "lines if the subsequent lines are indented by more than one space. The "
#~ "following\n"
#~ "syntax is valid:"
#~ msgstr ""
#~ "タグは、コメント行の冒頭にある\"@tagname\"から始まる。\n"
#~ "後続の行がスペースでインデントされている場合は、\n"
#~ "複数行にまたがることができる。\n"
#~ "次の構文は有効となる。"

#~ msgid ""
#~ "Tags are the best way to add arbitrary metadata when documenting an "
#~ "object in a\n"
#~ "way to access it later without having to parse the entire comment string. "
#~ "The\n"
#~ "rest of the document will describe the tag syntax, how to access the "
#~ "tag \n"
#~ "metadata and how to extend YARD to support custom tags or override "
#~ "existing tags."
#~ msgstr ""
#~ "タグはオブジェクトをドキュメント化する際、\n"
#~ "コメント文字列全てを解析せずにアクセスできるように、\n"
#~ "メタデータを追加する最善の方法となる。\n"
#~ "このドキュメントの残りの部分は、\n"
#~ "タグのメタデータにアクセスする方法\n"
#~ "カスタムタグをサポートしたり、既存のタグを上書きしたりするために\n"
#~ "YARDを拡張する方法といった、タグの構文の説明になる。"

#~ msgid ""
#~ "The above example adds metadata under the name `tagname` to the Foo class "
#~ "object."
#~ msgstr ""
#~ "上記の例では、\n"
#~ "Fooクラスオブジェクトの為に`@tagname`以降にメタデータを追加する。"

#~ msgid ""
#~ "Tags represent the metadata that can be added to documentation through "
#~ "the `@tag`\n"
#~ "style syntax:"
#~ msgstr ""
#~ "タグとは以下の様に@tag形式の構文を介して、\n"
#~ "ドキュメントに追加できるメタデータを表す。"

#~ msgid ""
#~ "* **Docstring (Documentation String)**: Comments associated with a code "
#~ "object\n"
#~ "  used for documentation purposes."
#~ msgstr ""
#~ "* **Docstring (Documentation String)**: コードオブジェクトに関連するコメン"
#~ "ト,\n"
#~ "用途を記述する為に利用される。"

#~ msgid ""
#~ "* **Domain Specific Language (DSL)**: In the context of Ruby, a DSL is a "
#~ "language\n"
#~ "  optimized for a specific domain (problem) but represented using Ruby "
#~ "syntax."
#~ msgstr ""
#~ "* **Domain Specific Language (DSL)**: Ruby関連の用語で、\n"
#~ "DSLとは、特定のドメイン(問題)用に最適化された言語である。\n"
#~ "しかし、内容自体はRuby構文によって表される。"

#~ msgid ""
#~ "* **Code Object**: Any explicitly defined Ruby source that describes a "
#~ "feature\n"
#~ "  of the code. By default, this refers to classes, modules, methods, "
#~ "constants\n"
#~ "  and class variables, though it can be extended to refer to custom "
#~ "functionality\n"
#~ "  defined by a DSL (like a spec, for instance)."
#~ msgstr ""
#~ "* **Code Object**: コードの機能を説明するRubyソースを明確に定義される。\n"
#~ "デフォルトでこれはクラス,モジュール,メソッド,定数,クラス変数を参照する。\n"
#~ "それは、DSLによって定義されるカスタム機能を参照する為に拡張できると考え"
#~ "る。\n"
#~ "(例えば、rspecのように)"

#~ msgid "# Glossary"
#~ msgstr "# 用語集"

#~ msgid ""
#~ "Usage\n"
#~ "-----"
#~ msgstr ""
#~ "使用法\n"
#~ "-----"

#~ msgid ""
#~ "Installing\n"
#~ "----------"
#~ msgstr ""
#~ "インストール\n"
#~ "----------"
