OmniAICreator/Qiita-1.07M huggingface dataset:
[Ruby入門] 02.エディタの準備（Visual Studio Code で Ruby書いてデバッグ）

&gt;&gt; 連載の目次は [こちら！](http://qiita.com/prgseek/items/237d02be844534063f1d)

##参考記事
http://d.hatena.ne.jp/t_tutiya/20170204/1486204880
↓からの
http://dev.classmethod.jp/tool/visual-studio-code-ruby-debug/
http://d.hatena.ne.jp/deko2369/20160611/1465653006


##手順

###1. Visual Studio Code をインストールしておく

###2. Rubyの拡張をインストール
[Visual Studio Code 上の作業]

左の「拡張機能」ボタンを押して、検索キーワードに "Ruby" と入れると、検索結果トップに、

Provides Ruby language and debugging support for Visual Studio Code

というのが出てくるので、これをインストールする。

###3. Rubyのスクリプトを用意
[Visual Studio Code 上の作業]

①左の「エクスプローラー」ボタンを押してエクスプローラーを開き、「フォルダーを開く」で、Finderから操作。適宜、新規フォルダを作成。

②エクスプローラー上のフォルダー名の右の「新しいファイル」をクリックして、新規ファイルを作成

③とりあえず、以下の内容でRubyスクリプトを作成

```/Users/miro/Documents/RubyProjects/MyRuby/test.rb
class Wao
  def hello
    puts 'Ya'
  end
end

wao = Wao.new
wao.hello
```

・コード補完が効く
・メソッドや変数を Command+クリック(またはFn+F12) すると、定義箇所にジャンプする


###4. デバッグ用のGemを入れる
[ターミナルでの作業]

####4-0. 概要

+ gem は、Rubyのライブラリのパッケージであり、パッケージ管理ツール(コマンド)でもある。
+ bundler は、gemの互換性とか依存関係なんかも考慮してくれるgem管理ツール（RPMに対するyumみたいなもの？）
+ ここでは Rubyのデバッグをするためのgemである「ruby-debug-ide」と「debase」を入れる

####4-1. bundler をインストール

```
$ gem install bundler
Fetching: bundler-1.14.6.gem (100%)
〜 中略 〜
1 gem installed
```

####4-2. bundler の初期化（Gemfileの生成）

```
$ bundle init
Writing new Gemfile to /Users/miro/Gemfile

$ cat Gemfile
# frozen_string_literal: true
source "https://rubygems.org"

# gem "rails"
```

####4-3. 上記で生成したGemfile に、インストールしたいGemを追加記述
↓末尾にこの２行を追記

```
gem "ruby-debug-ide"
gem "debase"
```

####4-4. んでインストール

```
bundle install
```

####4-5. インストールできたか確認

```
$ gem list
*** LOCAL GEMS ***
〜 中略 〜
debase (0.2.1)
〜 中略 〜
ruby-debug-ide (0.6.0)
```

###5. Visual Studio Code に戻ってデバッグ設定（launch.json の生成と設定）

①先の手順3で作ったフォルダをVSCodeのエクスプローラーで開いている状態で、左の虫のボタン（デバッグボタン）を押下

②上部の歯車ボタンをクリックし、プルダウンからRubyを選択

③すると launch.json が開く。(存在しない場合は、ここでフォルダ配下に .vscode/launch.json が生成される)

④以下の内容に書き換える

```.vscode/launch.json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug Local File",
            "type": "Ruby",
            "request": "launch",
            "program": "${workspaceRoot}/test.rb",  //*1
            // ,"useBundler": true                  //*2
        }
    ]
}
```

*1 デバッグしたいファイル名
*2 "useBundler" について
「"useBundler": true」を指定せよ、ってなってる情報もあるが、ruby-debug-ide をパス指定で入れている場合のみ必要らしい。なのでここでは指定していない。
（参考URL: http://qiita.com/chimame/items/56e48ab3145312ff1786 ）

###6. んで、デバッグしてみる
①デバッグしたいファイルを開いている状態で、左の虫のボタン（デバッグボタン）を押下

②上部の「デバッグコンソール」ボタンを押下して、デバッグコンソールを表示させる

③上部の「デバッグの開始」ボタン（緑の三角ボタン）を押下して実行

④デバッグコンソール に実行結果が表示される

####デバッグ操作
+ エディターの各行の一番左の部分をクリックして、ブレークポイントを設定できる
+ ウォッチ式で、任意の変数や、式を実行した場合の値を確認できる

など、通常のIDEのデバッガ機能が使える。

####※デバッガのエラー
デバッグすると、２回め以降、以下のようなエラーが出る。

```
Debugger error: Client: Error: read ECONNRESET
```

デバッガとの通信がうまくいっていない？と思われるが、あまり情報を見つけられなかった..

デバッグ結果は出力されるので、ひとまずよしとするか（情報求む...）
ASP.NET Core Identityで認証エラーの時に401を返す

ASP.NET MVCではおなじみのIdentityライブラリですね。ユーザー管理はこれに任せると開発が非常に楽になります。
ただ、いろいろとおせっかいもあるので今回は認証エラー時のお話をします。

# 401を返すと302が返ってくる

おっとまず日本語がおかしいぜ。
じゃなくてありのまま言いうとこうなります。

例えば単純にDBから全件取得だけのAPIで、認証されていないユーザーなら401を返すAPIを書いてみます。

```csharp
[Route("api/projects")]
public class ProjectsController : Controller
{
    private readonly DatabaseContext db;

    public ProjectsController(DatabaseContext db)
    {
        this.db = db;
    }

    [Authorize]
    [HttpGet]
    public async Task<IEnumerable<Project>> GetProjects()
    {
        return await db.Projects.ToListAsync();
    }
}
```

これで認証されていないクライアントからは401になると思うじゃん？でも実際は302(Found)が返ってくるんですよ。

![302.png](https://qiita-image-store.s3.amazonaws.com/0/44992/dee982b6-d7eb-3426-13f5-f9dd25ef9d10.png)

ほらぁ(死亡)

# Identityさんどうしてこんなことするん？

これはIdentityの仕様で、つまり認証されていない人はログインページまで飛びましょうね～ということをやってくれているのです。HeaderについているURLはデフォルトのもので、大体のシステムはこのURL飛べばログイン画面いけるっしょってこと。

MVCをがっつり使ってる人はそれでいいかもしれませんが、WebAPIとして使いたい人にとっては迷惑千万です。

# 401にするためのおまじない

Identityの認証にCookieを使っている場合にこういった挙動になるようです。

```Startup.cs
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    app.UseIdentity();
    app.UseCookieAuthentication(new CookieAuthenticationOptions()
    {
        AutomaticChallenge = false
    });
}
```

`AutomaticChallenge`をfalseにすることによってリダイレクトがなくなります。

swaggerでアクセスすると401が返ってきます。
テストコードで動かすと`InvalidOperationException`例外が発生します。
![401.png](https://qiita-image-store.s3.amazonaws.com/0/44992/29b0c1d3-de9e-d887-f823-ac0e3f37442f.png)


普通にステータスコード401のレスポンスでいいのに・・・。
写真取り込みスクリプト

## 開発の動機
ソニーとかキャノンとかニコンとかの写真管理ソフトは全部網羅して管理しようとするのでめちゃくちゃ重い。
おまけに我が家は写真はLAN上のNASに置いてるので更にめんどくさかったりする。

欲しい機能は画像を日付でフォルダ別に移動してくれればいい。
うん。作れそう。Pythonの勉強がてらやってみよう。

## できたもの

https://github.com/rkun123/PicCopier
Pythonのスクリプトです。もちろんPython実行環境必要です。あとライブラリも。
readme.mdに使い方書いてます。

## やってること

指定フォルダ内のファイル(JPGにかぎらず)を別の指定フォルダにExifまたは更新時刻で日付に分けてコピー。
CUIでの引数でもymlファイルでもフォルダ指定できる。
それだけ。

プログラムとしてはとっても汚いと思います。でも動くからいいや。
Amazon DynamoDB – 仕組みから費用まで

DynamoDBに関する基本的な内容をまとめてみたものです。DynamoDBに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[Amazon DynamoDB - 仕組みから費用まで] (https://www.techcrowd.jp/dynamodb/summary-3/)

# [Amazon DynamoDBの生い立ち] (https://www.techcrowd.jp/dynamodb/summary-3/)
DynamoDBは、RDBMSのスケールの限界を超えるために開発された、応答性能や信頼性が高く、費用対効果が優れている、特にインターネット分野の利用に適しているNoSQLのデータベースです。

DynamoDBの開発目標は以下の通り。

- 可用性の向上：DynamoDBのデータはAmazonリージョン内の地理的に分散した３つの場所に各テーブルのレプリカがSSDに保存されことで、可用性と耐久性の向上が期待されます。
- スケーラビリティの容易さ：DynamoDBは設定だけでスケールして限界がないのでフルーマネージメントで管理不要です。DynamoDBはプロビジョンされたスループットを確保するためにテーブルを複数のパーティションに分散して格納、Hash Keyをパーティション間でのデータ分散に利用し、格納ストレージサイズやプロビジョンされたスループットによって自動的にパーティションニングを実施します。
- 予測可能な性能：必要なスループットを予め設定し、設定値（キャパシティーユニット）の変更はオンラインで実行可能、さらに現在消費しているスループットはマネジメントコンソールから５分単位で確認できます。

# [Amazon DynamoDBの特徴 (1)] (https://www.techcrowd.jp/dynamodb/summary-3/)
**完全マネージド型のNoSQLデータベースサービス**：Amazon DynamoDB は完全マネージド型のクラウド NoSQL データベースサービスです。開発者はデータベーステーブルを作成し、スループットを設定するだけで、残りの処理は自動的に行われます。ハードウェアまたはソフトウェアのプロビジョニング、設定と構成、ソフトウェアの修正、信頼できる分散型データベースクラスターの操作、拡張による複数のインスタンスでのデータのパーティション化などのデータベース管理タスクについて心配する必要はありません。

 
**ハイスケーラブル、低レイテンシー**：テーブルを作成するときに、必要なリクエスト容量を指定します。スループット要件が変わった場合は、AWS Management Console または Amazon DynamoDB API を使用して、テーブルのリクエスト容量を更新します。Amazon Dynamo DB はすべてのスケーリングを水面下で管理し、ユーザーはスケーリングの進行中でもスループットレベルを実現することができます。Amazon DynamoDB は、あらゆる規模のすべてのアプリケーションで安定した高速パフォーマンスを実現します。通常、サービス側の平均レイテンシーは 1 桁台のミリ秒単位です。データのボリュームが増えてアプリケーションのパフォーマンス向上が必要になった場合、Amazon Dynamo DB では自動パーティション化と SSD テクノロジを使用してスループット要件を満たし、すべてのスケールで低レイテンシーを提供します。

 
**高可用性**：DynamoDBのデータは３箇所にクロスリージョンレプリケーションされることで、データセンターの障害が発生した場合に、他のリージョンへの切り替えが可能となります。

**シンプルかつパワフルなAPI**：Amazon DynamoDB は、AWS Lambda と統合され、データの変化に自動的に反応するアプリケーションの設計を可能にするトリガーを実現しています。

 

# [Amazon DynamoDBの特徴 (2)] (https://www.techcrowd.jp/dynamodb/summary-3/)
**管理不要で信頼性が高い**：DynamoDBは、SPOF(単一障害点)が存在しないように構成され、データは３箇所の施設に保存されるので信頼性が高く、ストレージは必要に応じて自動的にパーティショニングされます。

 
**プロビジョンスループット**：テーブル毎にReadとWriteそれぞれに対し、必要な分だけのスループットキャパシティを割り当てることができ、この設定値はDB運用中にオンラインで変更可能です。

 
**ストレージの容量制限がない**：使った分だけの従量課金制のストレージを使用し、データ容量の増加に応じたディスクやノードの増設作業は不要です。
Web関係の困り事を英語でググる時に知っておくと便利な単語やセンテンス

私が現在メインで取り組んでいるのは主に以下の通り

* concrete5
* Zurb Foundation
* jade

これらに共通しているのは**まだまだ日本語の情報が少ない**ということ。

# せや、英語でググったれ！
最近、Webの困りごとが発生すると、だいたい日本語でググるより英語でググったほうが早い気がしてきました。

そこで、ここでは、どういう単語やセンテンスでググるとすぐ見つかりやすいかを紹介したいと思います。

# お困り系
## これ、動かへんねんけど
* doesn't work
* not working

だいたいこの表現です。**concrete5 stack doesn't works** とか **Foundation 5 Abide not working** とかです。英語の場合、文章でググると、かなりの確率でフォーラムやStack overflowの記事にあたります（そこを読んで解決するかどうかは別ですが…）

## これ使うのに、他に何か要るん？
* requirements
* dependencies

依存するパッケージやモジュールについて調べたい時。ソースコードにもよく現れる単語なのでわかりやすいですね。**Do I need any other dependencies?**とか聞いたりします。

## ◯◯するには、どないしたらええのん？
* How do I ~

**How do I use Japanese in vars?**とかです

## まだ開発中なん？
* WIP

質問として聞くことはないかもしれませんが、よく見かける**WIP**というのは、開発中という意味。**Work In Progress（作業進行中）**のアクロニウムです。

# プログラム系
コード書く上でググりたい時、例えば「PHP 変数」と日本語でググる場合、英語ではどうしてんの？ というような感じの紹介です。

## 変数
* var
* vars
* variable

正しくはvariableなのですが、慣例的にvarとかvarsでも意味は通ります。

## 配列
* array

まあ、これはソースコード上でも見かけるのでわかりますよね

## 関数
* functions

これも、まあ

## オブジェクト
* object

これも（ry

## ループ
* iteration

あんまり英語ではループって言わないっぽいです。

## 条件分岐
* condition
* conditional

日本語では**if文**って言ったりもしますが、英語ではifってありふれた単語なので、ググラビリティが低いです。

## 変数の中で変数を扱うやつ
* interpolation

PHPでいうところの

```php:apple.php
$apple = "りんご";
$text = "${apple}はおいしいなあ";
echo $text;
```
みたいなことです。初心者向けの書籍などではこの波括弧でくくるテクニックの名称を説明してないことも多いでので、名称でググることが出来ない人も多いと思います（私もかつてそうでした）。で、このテクニックはどうもインターポレーションというらしいです（ちゃんとした技術書にはインターポレーションて書いてますね）私は、jadeでJSの変数を展開するやり方`#{hoge}`を調べていた時に知りました。

## 整数を１ずつ足していくやつ
* increment

いわゆる、i++（あいぷらぷら）ってやつですね。あ、そういえばこのQiitaを提供してくれている会社も…

## とりあえず動くレベル
* workaround

フレームワークなどで、標準では用意されてない機能にカスタマイズを施し、その要件が**取りあえず動いている**レベルの実装を指します。

例えば**Foundation IE8 workaround**みたいな使い方をします。

細かい検証はしてないから、利用は自己責任でな、という行間に隠れた意図も見え隠れする言い回しです…

## その機能を外す、無効にする
* kill
* omit
* disable

Foundationはレスポンシブフレームワークですが、逆にレスポンシブじゃないフレームワークとして使いたい場合、そういう機能は用意されていません。でも、どうしてもレスポンシブを切りたくて、そういう機能を実装したことがありました。** Disable responsivness for Foundation5**としてGistに公開しています。

## その機能を除外したい
* ignore
* exclude

# まとめと今後
今後、随時追記していきます。
JavaLiteのActiveWebの文字化けでハマった

# 概要
JavaLite(http://javalite.io/) のActiveWeb では FreeMarker というテンプレートエンジンを使っているのですが、viewファイル（ftlファイル。UTF-8）に書いた日本語文字列が文字化けしてハマった。

いろいろ調べてみると、レスポンスヘッダーのContent-Typeが「text/html; charset=ISO-8859-1」になっていた。ISO-8859-1ではなくUTF-8にしたいところ。

# 前提
ActiveWebのバージョンは1.13。

# 対策
EncodingFilterを自作して、web.xmlで設定する。

```java:EncodingFilter.java
package app.system;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class EncodingFilter implements Filter {
    private String encoding;

    public void init(FilterConfig config) throws ServletException {
        encoding = config.getInitParameter("encoding");
    }

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException {
        request.setCharacterEncoding(encoding);
        response.setCharacterEncoding(encoding);
        response.setContentType("text/html; charset=" + encoding);
        chain.doFilter(request, response);
    }

    public void destroy() {}
}
```

```xml:web.xml
  . . .

	<filter>
		<filter-name>encoding</filter-name>
		<filter-class>app.system.EncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>

  . . .
	
	<filter-mapping>
		<filter-name>encoding</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
  . . .

```
EncodingFilterは他のFilterよりも早めに呼び出さないと動かない場合があるので注意。
「Requests」と「lxml」を使ってWebの情報を取得してみた

Scrapyを使ってみようと思っていますが、まずは「Requests」と「lxml」で試しにWebの情報を取得してみました。
Pythonを使ったWebスクレイピングの第一歩。

#やったこと
 - 「Requests」を使ってWebの情報取得
 - 「lxml」を使って取得してきたHTMLから必要な情報の抜き出し

##インストール
```python3
pip install requests
```

```python3
pip install lxml
```

##テスト用のHTML
EC2上に配置して、一応インターネット経由でテストしました。

```html:test.html
<html>
    <body>
        <div id="test1">test1
            <ul id="test1_ul">test1 ul</ul>
        </div>
    </body>
</html>
```

##スクレイピングのコード
 - 引数にURLを渡したら、そのHTMLから処理をする
 - User-Agentは念のためMacに変更

（引数がないときのエラー処理等々は実装していません）

```python3:scraping.py
import sys
import requests
import lxml.html

#set dummy user-agent
headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/602.4.8 (KHTML, like Gecko) Version/10.0.3 Safari/602.4.8'}

#URLを引数で指定
url = ''
if len(sys.argv) > 1:
    url = sys.argv[1]

response = requests.get(url, headers = headers)
html = lxml.html.fromstring(response.content)

for div in html.xpath('//*[@id="test1_ul"]') :
    print(div.text)
```

実行コマンドは以下の通り。
引数のURLは任意です。

```
python scraping.py http://ec2******
```


##その他
XPathやCSSセレクターをChromeの開発者ツールで容易に取得できるのが便利。
hadoop-clientまわりのソースコードリーディング

目的
----
`hdfs dfs -ls /` を実行した時にどのようなコードが実行されるかコードを追ってみた。

hdfsコマンド
-----------
hdfsコマンドは `hadoop-hdfs` モジュールで管理されている。

https://github.com/apache/hadoop/blob/59d69257a888347f0fb9c51bb000afc986b64f98/hadoop-hdfs-project/hadoop-hdfs/src/main/bin/hdfs

dfs
---
`dfs` を指定すると、org.apache.hadoop.fs.FsShell が呼び出される。mainメソッドがエントリポイント。

https://github.com/apache/hadoop/blob/b606e025f10daed18b90b45ac00cd0c82e818581/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/FsShell.java#L382

CommandFactory
--------------
実行するサブコマンドが決まると、CommandFactoryからそれに対応する実行クラスを取得することができる。

https://github.com/apache/hadoop/blob/b606e025f10daed18b90b45ac00cd0c82e818581/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/FsShell.java#L313

Ls
--
サブコマンドが `ls` の場合は、org.apache.hadoop.fs.shell.Ls#run が呼び出される。

https://github.com/apache/hadoop/blob/b606e025f10daed18b90b45ac00cd0c82e818581/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/Ls.java

Commadn, FsCommand
------------------
Ls等のサブコマンドのクラスはFsCommandクラスを、FsCommandクラスはCommandクラスを継承している。Ls#runを呼び出すと、Command#runが起動して、processRawArguments → processArguments → processArgument → processPathArgument → processPaths → processPath と呼び出していく。サブコマンドのクラスは適宜これらのメソッドをオーバーライドする。

PathData
--------
processRawArguments を呼び出す際に、expandArgument を呼び出して引数(文字列)をPathDataに変換する。

https://github.com/apache/hadoop/blob/b606e025f10daed18b90b45ac00cd0c82e818581/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/PathData.java#L322

この時に、指定されたパスのURLスキームを参照し、適切なFileSystem を取得して、そのパスの情報をPathDataに保存する。

結果出力
-------
LsのprocessPathArgument → processPaths → processPath と遷移し、[Ls#processPath](https://github.com/apache/hadoop/blob/b606e025f10daed18b90b45ac00cd0c82e818581/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/fs/shell/Ls.java#L242)でパスの情報を出力して終了。
カラム型データベースとは

noSQLに関する基本的な内容をまとめてみたものです。noSQLに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[カラム型データベースとは] (https://www.techcrowd.jp/nosql/column/)

# [集計や分析をするために使用されるカラム型データベース] (https://www.techcrowd.jp/nosql/column/)
データベースの列方向の処理に特化したのがカラム型データベースです。
カラム型データベースは、任意の列だけの値を更新したり、条件を満たす列を探し出すなのどの操作がしやすい構造となっています。
そのため、特定の列の合計を計算する場合は、他の列にアクセスする必要がないために高速の処理が可能です。

さらに、列方向の圧縮を行うことでより高速の処理が可能となりますので、集計や分析などにはカラム型データベースが適してます。

しかし、データを追加したり削除する場合は、一つの列を操作するだけではなく複数の列を処理する必要があるので、効率良く処理することはできません。

# [カラム型データベースとデータウェアハウス] (https://www.techcrowd.jp/nosql/column/)
従来のリレーショナルデータベースでは時間が掛かり過ぎて、データウェアハウスに用いるには十分とは言えませんでした。
そのため、大量のデータを高速で参照したり集計する必要のあるデータウェアハウスには、カラム型データベースが良く用いられます。
特にビッグデータの処理が要求されるデータウェアハウスにとっては、コストが安くてスケールアウトも容易なカラム型データベースが最適です。

# [代表的なカラム型データベース] (https://www.techcrowd.jp/nosql/column/)
代表的なカラム型データベースには、CassandraやRedShiftなどがあります。

**Cassandra**
・Facebookがオープンソースとしてリリース
・結果整合性の調節をすることができる
・高い書き込み性能を実現するために、LSM-Treeが採用されている

**RedShift**
・列指向ストレージ技術が採用されたことで、複数ノードの操作でもクエリの I/O 効率と並列度が向上している
・既存のSQLクライアントが使えるように、カスタムのJDBCやODBC ドライバが用意されている
UniRubyを使ってみよう

## 前書き

Unityでスクリプト書いてますか？
配列が1開始とか`--`のコメントアウトに飽き飽きしてませんか？

Rubyでは配列は０開始ですね。
さらに、コメントアウトは`--`とか変なのではなく`#`ですね。
こんな感じのスクリプト言語がUnityで使えます。

## Asset Store

1. 検索
2. ダウンロードしましょう。たった5.4ドル、約600円（ラークなんて１カートン4,200円≒37ドル？高っけ・・）。そんな金あれば7個アセット買おう。

「UniRuby」を入力して検索。
1つしか検索されないのですごいわかりやすい！

<img width="506" alt="Screen Shot 2017-04-13 at 8.37.54 AM.png" src="https://qiita-image-store.s3.amazonaws.com/0/11951/0194a182-0324-0b87-f097-d54a18dd0889.png">


Unity Asset Store URL:	https://www.assetstore.unity3d.com/#!/content/85825
Short URL:	http://u3d.as/MeG

## インポート

パッケージを展開してUnityへインポートします。
特に何も考えなくていいはずです。

## DEMOの使い方

<img width="263" alt="Screen Shot 2017-03-26 at 4.20.31 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/11951/6c0b4d41-1de9-9322-7447-6ad3e83dd7be.png">


SceneDemoを開きます。

### Run From Stringボタン

UnityEditorを実行し、このボタンを押下すると、
Textに書かれているRubyのコードを実行してくれます。

<img width="635" alt="Screen Shot 2017-03-26 at 4.21.11 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/11951/a8b6d9cd-7b25-cbcc-5979-72647fbe1739.png">

デモでは、`ProgramText`というオブジェクトに入っているテキスト

```ruby
10.times.each {|i| debug_log i * i }
```

というコードが実行されます。

`10.times`なので0〜9（0開始の計10）の数字同士で掛け算して実行してログを出します。

`debug_log`というメソッドがあります。
`debug_warning`や`debug_error`もあります。

### Run From Text fileボタン

<img width="626" alt="Screen Shot 2017-03-26 at 4.25.57 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/11951/350a0edf-dbd0-715c-cd86-caefa0b3bfdb.png">


これはテキストファイルから実行します。

テキストはここにあります。
<img width="263" alt="Screen Shot 2017-03-26 at 4.20.31 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/11951/7dc920ba-802a-9b7d-8e2b-0d369abf1f84.png">

```ruby
#coding:utf-8

debug_log "Hello, world!"
5.times.each {|i| debug_log(i * i) }

class Car
  def initialize(carname)
    @name = carname
  end
  
  def dispName
    debug_log(@name)
  end
end

car1 = Car.new("First Car")
car1.dispName

car2 = Car.new("日本車")
car2.dispName

car3 = Car.new("한국차")
car3.dispName

set_result("子曰、吾十有五而学志于學。三十而立。四十而惑。五十而知天命。六十而耳順。七十而從心所欲不踰矩")
```

こんなコードです。

`debug_log`のものはもちろんそのままログにでます。

`set_result`と書けば結果をセットできます。

UniRubySample.csを読むのがいいです。

```csharp
// testテキストをロード
var script = Resources.Load<TextAsset>("test").text;

// 実行
UniRubyManager.Run(script);

// マルチバイト文字を取り出す。
var myStr = UniRubyManager.result.mutlibyteStringValue;

// 画面に表示
this.result.text = myStr.ToString()
```

`mutlibyteStringValue`というのを使っているのが重要です。
他にも`intValue`と`stringValue`を用意してます。

### Run Someボタン

<img width="416" alt="Screen Shot 2017-03-26 at 4.36.21 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/11951/a1a20ada-62a7-b93f-8bf8-e327fff7165d.png">

これはC#のソースのstringのRubyコードを実行してます。
`intValue`と`stringValue`などを使っている例です。
タイ語も表示しています。

## iOSのビルドについて（1.0.1）

Xcodeで設定を自動でしてくれます。
`Assets/UniRuby/Lib/MRuby.framework`というパス設定である前提ですので、
適宜修正が必要です。
`CopyAndReplaceDirectory.cs`の`FIXME`の箇所のパスを適宜修正をお願いします

## よろしくお願いします。

<div class='alert alert-warning'><h4>注意</h4>
1.0.0は現在EditorとmacOSのみサポートだが、iOSは1.0.1で対応(IL2CPPは未対応)。
Androidはサポートしてませんが、1.0.2かな？
</div>

## サポート[English, 日本語, 한국어 OK]

https://forum.unity3d.com/threads/released-1-0-1-uniruby-japanese-english-korean-supported.466374/
Play Frameworkで起動時に処理を実行する

データの初期化とかタイマーみたいな常駐機能の起動とか、アプリケーションの起動時に実施したいものってありますよね。
JavaEEの場合は「Servletのinitメソッド」や「CDIのApplicationスコープ + @Initialized」あたりを使うことが多いと思います。

Playの場合、昔は`GlobalSettings#onStart`ってので対応してたみたいだけど、2.5ではDI(dependency injection)を使って何とかしろって方向見たいです。
というか、この辺の話がDIは「デフォルトでGuiceを使ってるからGuice知ってれば分かるでしょ？」的なノリなのか、さっぱり書いてないです。段々Playの流儀に慣れてきましたよ？

まあ、activatorで作るplay-seed（playのテンプレート）が良い見本になるので、まずは動かしてコード読めってことですね。

結論だけ先に書くと、app直下にGuiceのModuleをAbstractModuleを継承して作って、configureメソッドの中でインスタンスを生成してやればいいです。

```scala
class Module extends AbstractModule {
  override def configure() = {
    // application starts.
    bind(classOf[ExampleService]).asEagerSingleton()
  }
}

@Singleton
class ExampleService {
  Logger.info("Hello World")
}

```

これで起動時に`Hello World`とログが出力されるようになりました。

### モジュールによる起動時の読み込み

さて、ではなんでこれでOKかというと答えは`application.conf`の中にあります。

```
play.modules {
  # By default, Play will load any class called Module that is defined
  # in the root package (the "app" directory), or you can define them
  # explicitly below.
  # If there are any built-in modules that you want to disable, you can list them here.
  #enabled += my.application.Module

  # If there are any built-in modules that you want to disable, you can list them here.
  #disabled += ""
}
```

そもそも**モジュール**は独立したコンポーネントを提供して、Playをプラガブルに拡張できるようにするための機能です。
コミュニティベースとはいえ公式に載ってるものだけでも[これだけ](https://playframework.com/documentation/2.5.x/ModuleDirectory)あります。
その性質上、モジュールは起動時に呼ばれないといけないので、

```
play.modules.enabled += "modules.MyModule"
```

で追記をしておくと起動時に読み込んでくれるようです。
さらにコメントに記載の通り、app直下にある`Module`という名前のモジュールクラスはデフォルトで読み込むようです。
なので、Moduleクラスになんか書いとけば実行時、より正確にはconfigのロード時に呼ばれることになります。

今回は後述するライフサイクル管理がしたいので、bindもしています。

### GuiceによるBind

先ほどのモジュールですが[Guice](https://github.com/google/guice/wiki/Motivation)のモジュールを使っています。Guiceは[JSR 330: Dependency Injection for Java](https://jcp.org/en/jsr/detail?id=330)の実装です。JavaEEのCDIをもうちょっと一般化したものですね。

使い方はいたって簡単で、最初のサンプルの通り必要であれば`@Singleton`でスコープを定義して、ModuleのconfigureにBind定義を書くだけです。
Bindメソッドの使い方は[こちら](https://github.com/google/guice/wiki/Scopes)を参照。

### Application life cycle

起動時だけではなく終了時もクリーンアップとか実行したいものです。少なくとも正常終了時は後片付けはしたいですね。
そんなときは[ApplicationLifecycle](https://www.playframework.com/documentation/2.5.x/ScalaDependencyInjection#component-lifecycle)を使います。

```scala
@Singleton
class ExampleService @Inject()(appLifecycle: ApplicationLifecycle) {
  Logger.info("start")

  appLifecycle.addStopHook { () =>
    Logger.info("end")
    Future.successful(())
  }
}
```

Moduleクラスの方の記述は変わりませんが、ExampleServiceに`ApplicationLifecycle`クラスをインジェクションしてこちらを利用します。
ApplicationLifecycleはその名の通りライフサイクルイベントを制御しているので、`addStopHook`にて終了時に実行したいメソッドを登録できます。
これで、タイマーの終了処理とかクリーンアップとかリソース解放とかの後片付け処理もバッチりですね。

まとめ
------------

Playの資料はネット上だと2.3が一番豊富な気がします。
ただ、2.4, 2.5でDI周りを中心に結構仕様が変わってるので要注意ですね。

マニュアルも目的の箇所だけ読んでも、良く分からないことが多いのでコード見るのも大事ですね。

それでは、Happy Hacking!
ドキュメント型データベースとは

noSQLに関する基本的な内容をまとめてみたものです。noSQLに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[ドキュメント型データベースとは] (https://www.techcrowd.jp/nosql/documentdb/)

# [ドキュメント型データベースとは] (https://www.techcrowd.jp/nosql/documentdb/)
ドキュメント型データベースとは、保存するデータ構造が自由なデータベースです。
一件分のデータはドキュメントと呼ばれ、JSONやXMLなどの記述書式で書かれたデータが保存されます。
容易にスケールアウトできるような構造をしたドキュメント型データベースが多いので、急なシステムの増強も可能です。

コンピュータの性能を向上させるスケールアップよりも、スケールアウトする方がコストは安く済むので、ドキュメント型データベースはコスト面でも有利なデータベースとなっています。

# [ドキュメント型データベースの利用形態] (https://www.techcrowd.jp/nosql/documentdb/)
ドキュメント型データベースはJSONやXMLなどのデータが扱えるので、ログ分析・Webシステム・オンラインゲームなどの複雑なデータ構造を扱うアプリケーションに良く用いられます。
ドキュメント型データベースを用いる事で、アプリケーション開発を容易にする事が可能です。

# [ドキュメント型データベースとリレーショナルデータベース] (https://www.techcrowd.jp/nosql/documentdb/)
**ドキュメント型データベース**
・データを自由な形式で保存する（事前にテーブルの構造を決める必要がない）
・比較的簡単にスケールアウトできる
・データの整合性が保証されない時もある

**リレーショナルデータベース**
・データを表形式で保存する（事前にテーブルの構造を決めておく必要がある）
・簡単にスケールアウトできない
・常にデータが正しい事が保証される

# [代表的なドキュメント型データベース] (https://www.techcrowd.jp/nosql/documentdb/)
代表的なドキュメント型データベースとしては、MongoDBとDynamoDBがあります。

**MongoDBの特徴**
・JavaScriptのJSONをもとにしたBSONでデータを保存する
・結合が出来ないので、結合が必要となる複雑な処理には向かない

**DynamoDBの特徴**
・ドキュメントの保存・クエリ・更新が可能
・AWS SDKを使うと、JSONドキュメントをDynamoDB に保存するアプリケーションが構築できる
THREE.Geometryを使って描画をまとめる

THREE.Geometryメモ

===初歩的なメモ

同じマテリアルを使った要素において、描画のデータをまとめる事で高速化が図れる


```javascript:js.js
var geometry = new THREE.Geometry();
```

今回は画像のデータを一度に描画をしてみるので
※画像データの読み込み方古い方法です。すいません

```javascript:js.js
var texture = THREE.ImageUtils.loadTexture('bricks.jpg', null, function() {renderer.render(scene, camera);});
var material = new THREE.MeshBasicMaterial( {map:texture,side: THREE.DoubleSide});
```

これで描画用の情報ができたので今度はGeometryを用意する

```javascript:js.js
for(var i = 0 ; i < 10 ; i++){
      var geo = new THREE.PlaneGeometry(500, 500);
      var ground = new THREE.Mesh( geo );
      ground.position.y = -300;
      ground.position.z = 1600-200*i;
      geometry.mergeMesh(ground);
}
```

これは画像をz軸で並べて、正面だと見えないので下に埋めただけのデータ

geometry.mergeMesh(ground);をするたびに、geometryと結合を繰り返してくれる

```javascript:js.js
scene.add(new THREE.Mesh(geometry, material));
```


そして描画

materialが同じであれば高速化ができる。
KVS（Key-Value Store）とは

noSQLに関する基本的な内容をまとめてみたものです。noSQLに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[KVS (Key-Value Store)とは] (https://www.techcrowd.jp/nosql/kvs/)

# [noSQLの一つのジャンルとしてのKVS] (https://www.techcrowd.jp/nosql/kvs/)
KVS（Key-Value Store）は、KeyとValueを組み合わせる単純な構造からなるデータストアです。
Keyを指定すると、Keyに関連付けられたValueが呼び出される仕組みとなっています。

**KVSの特徴**
- データモデルがシンプルである
- スケールアウトに適した構造をしている
- 高速でデータの読み書きが可能
- 分散処理に適している
- トランザクション処理できないものが多い

# [KVSの利用形態] (https://www.techcrowd.jp/nosql/kvs/)
KVSはKeyとValueの関係だけのデータベースなので、複数のサーバーにデータを分散させて格納する分散データストアとしての利用が増えています。

分散データストアは負荷の分散や高可用性を低コストで実現できるために、大規模なデータを扱うWEBアプリケーションなどで利用される形態です。
リレーショナルデータベースは構造的にデータを分散させるのが難しいのですが、KVSはいくらでもサーバーを増やして分散化することができます。

KVSはテーブル同士を結合するような複雑な処理は苦手にしていますが、自由にスケールできるというメリットを活かして利用されています。

# [代表的なKVS] (https://www.techcrowd.jp/nosql/kvs/)
代表的なKVSとして、memchaed・Redis・BigTableなどがあります。

**memchaed**
・メモリにデータを保存して、データベースの負担を減らすKVS
・サーバ上のメモリにデータを格納するので、応答性に優れている

**Redis**
・Redisもメモリ上にデータを格納するので、高速の読み書きが可能となる
・文字列・BLOB・リスト・ハッシュなど、幅広い種類のデータが扱える事からデータストラクチャ・ストアと呼ばれる

**BigTable**
・Googleの分散データストア
・Google検索・YouTube・Google Mapなど、Googleの数多くプロジェクトに使われている
noSQL DBとRDBの違い

noSQLに関する基本的な内容をまとめてみたものです。noSQLに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[noSQL DBとRDBの違い] (https://www.techcrowd.jp/nosql/nosql_vs_rdb/)

# [分散環境でのRDBの限界] (https://www.techcrowd.jp/nosql/nosql_vs_rdb/)
トランザクション処理の特性を、
- Atomicity（原子性）
- Consistency（一貫性）
- Isolation（独立性）
- Durability（永続性）
の頭文字を取ってACIDとして表します。

RDB(リレーショナルデータベース)はACIDを守ってトランザクション処理を行いますが、分散環境でトランザクション処理しようとすると、頻繁に排他制御が発生して長時間の処理待ちが起こります。
長時間処理が停止してしまうようでは、データベースとして使い物になりません。

そのため、RDBほど厳密にACIDを守らないnoSQLが分散データベースとして用いられるのです。
noSQLは一貫性よりも可用性を重視するため長時間の処理待ちが発生せずに、分散環境でも高速の処理が可能となります。


# [それぞれのnoSQLの特徴とマッチする用途] (https://www.techcrowd.jp/nosql/nosql_vs_rdb/)
NoSQLをデータモデルで分類すると、キーバリュー型・カラム型・ドキュメント型に分類できます。

**キーバリュー型**
・キーとバリューを関連付けて、データを保管する
・データを高速で読み書きすることは可能だが、複雑な処理には適していない

**カラム型**
・カラム単位でデータを保管する
・大規模なデータの読み込みなどはRDMSよりも高速で処理できるので、データウェアハウスとして用いられることが多い

**ドキュメント型**
・JSONやXMLなどの構造を持ったドキュメントを保管する
・構造が複雑なデータを格納するのに適している
noSQL概要とAWS関連サービス

noSQLに関する基本的な内容をまとめてみたものです。noSQLに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[noSQL概要とAWS関連サービス] (https://www.techcrowd.jp/nosql/nosql-summary/)

# [noSQLの概要] (https://www.techcrowd.jp/nosql/nosql-summary/)
noSQLとは、リレーショナルデータベース以外のデータベースを指します。
noSQLはSQLを否定するものではなく、一般的には「Not only SQL」と解釈されているように、noSQLとリレーショナルデータベースは異なる特性を持ったデータベースです。
リレーショナルデータベースが苦手とする分野やコストが高くなってしまう分野について、noSQLが使われます。

**noSQLの特徴**
    - 容易にスケールアウトできる
    - 結果整合性の保証
    - スキーマがない
    - トランザクション処理に不向き

# [AWSのnoSQL関連サービス] (https://www.techcrowd.jp/nosql/nosql-summary/)
AWSで使用可能なnoSQLとして、Amazon DynamoDBやAmazon ElastiCacheがあります。

**Amazon DynamoDB**
・高速で柔軟な完全マネージド型のクラウド上のnoSQLデータベースサービスです
・ドキュメントとキー値データストラクチャに対応しています
・サービス側の平均レイテンシーは10ミリ秒未満と高速で処理が行われます

**Amazon ElastiCache**
・クラウドでのキャッシュのデプロイや運用などを容易にするWEBサービスです
・高速のメモリ内のキャッシュからデータを取得することで、WEBアプリケーションのパフォーマンスの向上できます
・オープンソースのインメモリキャッシュエンジンであるMemcachedとRedisをサポートしています
・パッチ管理や障害処理については管理タスクが自動で行うので、手間の掛かる作業が不要です

# [各種noSQLの特徴とマッチする用途] (https://www.techcrowd.jp/nosql/nosql-summary/)
NoSQLをデータモデルで分類すると、キーバリュー型・カラム型・ドキュメント型に分類できます。

**キーバリュー型**
・キーとバリューを関連付けて、データを保管する
・データを高速で読み書きすることは可能だが、複雑な処理には適していない

**カラム型**
・カラム単位でデータを保管する
・大規模なデータの読み込みなどはRDMSよりも高速で処理できるので、データウェアハウスとして用いられることが多い

**ドキュメント型**
・JSONやXMLなどの構造を持ったドキュメントを保管する
・構造が複雑なデータを格納するのに適している
スマホ版Evernoteで手描きメモを取る方法

# スマホ版Evernoteで、手描きのメモを取るには？

1. キーボードの右上にある「+」をタップする。
1. 「手描きスケッチを追加」をタップ。


![YifHSdLWoacWEDgZ/AV02ceQWqezWhQTp.jpg](https://firebasestorage.googleapis.com/v0/b/type-c1c71.appspot.com/o/YifHSdLWoacWEDgZ%2FAV02ceQWqezWhQTp.jpg?alt=media&token=1468e4ec-c48b-4f49-9839-d2823c5a5baf)
AWS上でMongoDBを動かす 

MongoDBに関する基本的な内容をまとめてみたものです。MongoDBに関する、Web上にすでにある良識な解説コンテンツをまとめたまとめサイトの抜粋です。
[AWS上でMongoDBを動かす] (https://www.techcrowd.jp/mongodb/aws/)

# [AWSであれば、MongoDB環境を容易に構築できる] (https://www.techcrowd.jp/mongodb/aws/)
AWS MarketPlaceには、MongoDB環境を構築するために必要なミドルウェアがプリインストールされたOSイメージが多数あります。
※MongoDBの開発元である 10gen (現MongoDB Inc.)もMongoDB入りイメージを無償提供中

基本的に、それらのイメージをもとにAWSのインスタンスを立ち上げればMongoDB環境ができあがります。英文ですが、下記に具体的な構築手順があります。
http://www.mongodb.org/display/DOCS/AWS+Marketplace

 
# [AWSの複数ゾーンとレプリカを組み合わせればDRも容易] (https://www.techcrowd.jp/mongodb/aws/)

MongoDBは、マスタ/スレープ方式のレプリケーションに対応しています。

世界中のデータセンターから選択できる、AWSのさまざまなリージョンやアベイラビリティゾーンを複数選択してMongoDBのレプリカ機能を使用すれば、DR (Disaster Recovery)対応も可能です。

AWSは12のリージョンに、合計で33のアベイラビリティゾーンで運用されています (2016年5月現在)
https://aws.amazon.com/jp/about-aws/global-infrastructure/
AWSのリージョンは、最低でも2つのAZ(アベイラビリティゾーン)をもっていて、それぞれのAZはお互いに地理的・電源的・ネットワーク的に分離されつつも、AZ間は高速専用線で接続されています。

一方のゾーンにMongoDBおよびMongoDBのArbiterインスタンスを立ち上げ、もう一方のゾーンにMongoDBインスタンスを立ち上げれば、片方のゾーンで地震等の災害があっても、データが残り、そのままMongoDBは機能し続けます。

# [シャードとレプリカを組み合わせたMongoDBクラスタ構成] (https://www.techcrowd.jp/mongodb/aws/)
MongoDBでは、基本的に、シャードを増やすことにより水平スケールさせ、レプリカにより可用性を実現します。各シャードをレプリカセットにすることにより、高い可用性を実現しながら、水平スケールさせた大規模なデータベースを構成することができます。

開発段階では、1 つのレプリカセットから始めることもできますし、本稼働中に 3 つのレプリカセットに移行することもできます。下記URLに、AWS上でMongoDB環境を構築するアーキテクチャ例が示されています。
http://docs.aws.amazon.com/ja_jp/quickstart/latest/mongodb/architecture.html
・図1:  レプリケーション係数 3 の MongoDB リファレンスデプロイ
・図2:  3つのレプリカセット2方向シャーディングを使用するAWSのMongoDBクラスター

# [MongoDBをAWS上で動くようにするまでの手順] (https://www.techcrowd.jp/mongodb/aws/)
AWSにて、MongoDBを動くようにするまでの手順は、概略、下記の通り:

・EC2インスタンスおよびEBSボリュームを用意

・Amazon VPC をセットアップ

*Amazon VPC 内のプライベートサブネットとパブリックサブネット、NAT インスタンス、
セキュリティ グループ、IAM ロールなど、MongoDB のデプロイ中に必要な様々な
ネットワークリソースを作成

・Amazon EBS をセットアップして MongoDB を保存。

・MongoDB 設定をカスタマイズするオプションを指定した後、MongoDBを起動。

 MongoDB のバージョン番号 (2.6 または 3.0)、レプリカセットの数 (1 または 3)、シャード数
(0、1、2、または 3)、インスタンスあたりのマイクロシャード数を選択することができます。

※より詳細は、下記を参照ください。
[AWS上の MongoDB] http://docs.aws.amazon.com/ja_jp/quickstart/latest/mongodb/deployment.html
raspberry piにsoftflowdを入れる



raspberry pi/raspbianはパッケージマネージャで普通にsoftflowdがインストールできます。
これで持ち運びできるnetflow expoterができます。

- 試した構成

|component|version|
|:-:|:-:|
|raspbery pi|raspberry pi 2 model B|
|raspbian|7.11|


```
# とりあえずupdate

sudo apt-get update
sudo apt-get upgrade
```

```
# パッケージマネージャでインストール
sudo apt-get install softflowd

# インストール後failとでるが気にせず下記コマンドを打鍵
sudo mkdir -p /var/run/softflowd/chroot
```

```
# softflowdを起動
# インターフェースはpromiscous mode になる
sudo softflowd -v [netflow_version] -n [collector_ip]:[collector_port] -m [max_flow_number] -i [interface]

```

```
# 統計をみる
sudo softflowctl statistics

# 処理中のflowをみる
sudo softflowctl dump-flows

# 処理中のフローを強制的にコレクタに送る
softflowctl expire-all
```

```
こんな感じのcronでflowを早めに出させる事ができる
*/1 * * * * softflowctl expire-all
```
SwiftLint 導入

新調したばかりのMacに、swiftの静的解析ツール、SwiftLintを導入してみました。
SwiftLint(GitHub)
https://github.com/realm/SwiftLint

# 準備(Command Line Tools for Xcode, Homebrewインストール)
SwiftLintの導入にはパッケージ管理システムのHomebrewのインストールが必要のようです。
そしてHomebrewのインストールにはCommand Line Tools for Xcodeが必要です。

なのでCommand Line Tools for Xcodeからインストールしましょう。
＊さらに言うと、Command Line Tools for XcodeのインストールにはXcodeがインストールされていることが必要ですが、ここは省略。

### 1, Command Line Tools for Xcodeのインストール
`$ xcode-select --install`
*インストール確認メッセージが表示されます。

### 2, Homebrew インストール
Homebrewのサイト（ https://brew.sh ）にインストールコマンドが書いてあるのでそれを実行します。

```
$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

*途中でMacの管理者権限パスワードが求められます。

インストール終了するとこんなメッセージが表示されます。

```
==> Next steps:
- Run `brew help` to get started
- Further documentation: 
    http://docs.brew.sh
```

Run \`brew help\` to get startedとあるので、実行しましょう。
```$ brew help```

helpが表示されるだけですね。

`brew doctor` を実行してエラーがないか確認するといいでしょう。

# SwiftLintインストール
### 1, SwiftLintをインストール
`brew install swiftlint`

```
$ brew install swiftlint
Updating Homebrew...
==> Auto-updated Homebrew!
Updated 1 tap (homebrew/core).
==> Updated Formulae
kobalt

==> Downloading https://homebrew.bintray.com/bottles/swiftlint-0.17.0.el_capitan
######################################################################## 100.0%
==> Pouring swiftlint-0.17.0.el_capitan.bottle.tar.gz
🍺  /usr/local/Cellar/swiftlint/0.17.0: 37 files, 13.8MB
```

### 2, Xcodeでの設定
プロジェクトを開き、「Build Phases」->　左上の「＋」マーク -> 「New Run Script Phase」を選択。
<img width="885" alt="Screen Shot 2017-03-26 at 3.09.55 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/36475/68a3cba6-e3f1-cb66-c669-822e2502f1c2.png">

以下のScriptを記述しましょう。
*"Run Script"という名前を適切に変えてあげると、さらに良いと思います。

```
if which swiftlint >/dev/null; then
  swiftlint
else
  echo "SwiftLint does not exist, download from https://github.com/realm/SwiftLint"
fi
```
<img width="927" alt="Screen Shot 2017-03-26 at 3.18.49 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/36475/e9d25189-4986-3c82-930d-751a627be88b.png">


### 3, プロジェクト実行
コマンド+B や コマンド+R でプロジェクト実行すると、おびただしいほどの警告が表示されます。
<img width="537" alt="Screen Shot 2017-03-26 at 3.23.17 PM.png" src="https://qiita-image-store.s3.amazonaws.com/0/36475/7cbeaac2-c6b9-1187-f5fc-b32ece5fcdf0.png">

### 4, .swiftlint.ymlファイルを作成
swiftLintはxcodeprojファイルと同階層に以下のような`.swiftlint.yml`ファイルを作成することによって警告の検出有無を調節できます。

```
included:
  - Source
  - Tests
excluded:
  - Tests/SwiftLintFrameworkTests/Resources
opt_in_rules:
  - empty_count
  - file_header
  - explicit_init
  - closure_spacing
  - overridden_super_call
  - redundant_nil_coalescing
  - private_outlet
  - nimble_operator
  - attributes
  - operator_usage_whitespace
  - closure_end_indentation
  - first_where
  - sorted_imports
  - object_literal
  - number_separator
  - prohibited_super_call
  - fatal_error_message

line_length: 120
number_separator:
  minimum_length: 5
```

SwiftLint導入については以上です。
`.swiftlint.yml`ファイルについては、また今度。。
MongoDBのアーキテクチャ

MongoDBに関する基本的な内容をまとめてみたものです。MongoDBに関する、Web上にすでにある良識な解説コンテンツをまとめたまとめサイトの抜粋です。
[MongoDBのアーキテクチャ] (https://www.techcrowd.jp/mongodb/architecture/)

# [MongoDBにおけるクラスタ構成] (https://www.techcrowd.jp/mongodb/architecture/)
MongoDBでは、レプリケーション機能・シャーディング機能を提供しており、両者を組み合わせることにより分散コンピューティング環境にて、負荷分散された冗長構成のクラスタを構築することができます。
(アプリケーション側からは、クラスタ全体をひとつの論理DBとみなすことができます)

・レプリケーション構成においては、一般的な条件下では障害からの自動フェイルオーバー
・シャーディング構成においては、自動バランシング機能を備え、データをそれぞれのノードにできるだけ均等に配分するとともに、動的にノードの追加や削除にも対応

**クラスタ構成要素**
- primaryサーバ 	 レプリケーションのマスタ。データのマスタを保持
- secondaryサーバ 	レプリケーションのテレーブ。プライマリ上のデータのコピーを保持
- arbiterサーバ 	自動的にフェイルオーバーする際に新しいプライマリノードを選択・指示
- configサーバ 	シャーディングの構成情報や分散状況を保持
- mongosサーバ 	シャーディング構成にて、データリクエストに対するルーティングを実施

# [2方向シャーディングと3レプリカセットのクラスター] (https://www.techcrowd.jp/mongodb/architecture/)


MongoDBで、レプリケーション・シャーディング機能を利用して、可用性と水平スケールを実現する構成を実現する場合、最小構成で2方向シャーディングと3つのレプリカセットの構成となります。

MongoDBでは、ひとつのレプリカセットから始めて、本稼働中に3つのレプリカセットに移行することも可能です。

複数のレプリカ構成の場合には、書き込みオペレーションはプライマリノードで行われ、セカンダリノードに非同期にレプリケートされます (読み取りオペレーションでセカンダリノードを選択する場合には、古いノードに注意する必要があります)

MongoDBでは各シャードをレプリカセットにすることができます。2方向シャーディングと3つのレプリカセットの構成の場合には、ひとつのシャードが3つのレプリカセットにレプリケートされます。
AWSを利用する場合には、それぞれのレプリカは別々のアベイラビリティーゾーンに格納されますので、データセンター単位での障害があった場合でも、別のアベイラビリティゾーンにあるレプリカに自動フェールオーバーされてMongoDBは機能し続けることができます。

※参考: MongoDB on AWS >> アーキテクチャ
http://docs.aws.amazon.com/ja_jp/quickstart/latest/mongodb/architecture.html
MongoDBにおけるスキーマ

MongoDBに関する基本的な内容をまとめてみたものです。MongoDBに関する、Web上にすでにある良識な解説コンテンツをまとめたまとめサイトの抜粋です。
[MongoDBにおけるスキーマ] (https://www.techcrowd.jp/mongodb/schema/)

# [スキーマレスで柔軟にデータ処理を行うことができる] (https://www.techcrowd.jp/mongodb/schema/)
MongoDBはスキーマレスで動的なスキーマをもちます。
・同じコレクションにあるドキュメントの構造が異なっていても可
・更新ごとにドキュメントの構造を変更させることも可能

従って、カラムを固定できないような用途/開発時などのスキーマの変更が頻繁に行われる場合には便利なデータベースです。RDBMSで開発を行っている場合には、テーブルのスキーマが変更になるたびにデータベース側とアプリ側の双方で修正を行わなければなりませんが、MongoDBを使っていればアプリケーション側の修正のみですみます。

# [MongoDBにおけるスキーマのデザイン (RDBとの比較)] (https://www.techcrowd.jp/mongodb/schema/)

MongoDBはスキーマレスで動的なスキーマをもちます。
・同じコレクションにあるドキュメントの構造が異なっていても可
・更新ごとにドキュメントの構造を変更させることも可能

従って、カラムを固定できないような用途/開発時などのスキーマの変更が頻繁に行われる場合には便利なデータベースです。RDBMSで開発を行っている場合には、テーブルのスキーマが変更になるたびにデータベース側とアプリ側の双方で修正を行わなければなりませんが、MongoDBを使っていればアプリケーション側の修正のみですみます。

 
# [MongoDBにおけるスキーマのデザイン (RDBとの比較)] (https://www.techcrowd.jp/mongodb/schema/)

MongoDBはRDBMSと違ってJOINはできません。代わりに基準となるオブジェクトに別のオブジェクトをあらかじめembedded（埋め込み）させておくことで，ある程度同じように扱うことができるようにすることができます。

また，MongoDBではリレーションの概念はもっていません。集約できる情報は関連テープルに分散するのではなく、同じドキュメントのサブドキュメントとして集約します。

基本的に、RDBMSではデータを正規化します。データの集約、整形を経て、アプリケーションが扱いやすい形にした上に加工します。
一方で、MongoDBでは、はじめからアプリケーションで取り扱う形でそのままデータベースに格納します。

# [MongoDBにおけるスキーマデザインとパフォーマンス] (https://www.techcrowd.jp/mongodb/schema/)
MongoDBではデータファイルを仮想メモリにマッピング（Linuxではmmapという機能を利用）し，MongoDBのプロセスは仮想メモリにアクセスします。アクセスするデータが物理メモリに乗っている場合には高速にアクセスできますが，アクセスするデータが物理メモリに乗っていない場合（ページフォルト発生時）は，ディスクからデータを物理メモリに読み込み，その後アクセスする必要があります。そのため，アクセスするデータ（インデックスを含む）がメモリ上にあるかどうかが処理性能を大きく左右します。

MongoDBのコレクションは、アプリケーションが一番よくアクセスするパターンを意識して設計すべきです。一方で、RDBSでは正規化すれば基本的によく、どのようにアクセスされるかを考慮してスキーマの設計を変える必要はありません。

たとえば、データベースに顧客の個人情報が格納されていて、アプリケーションにて顧客の全個人情報を表示するというのが主要な機能であれば、同じコレクションに各顧客の全個人情報を格納するスキーマが適しています。データベースに対するランダムアクセスも一回ですみますし、アクセス頻度の高いデータがメモリ上にのっている確率に高くなり、パフォーマンスが向上します。
シャーディング: MongoDBによる水平スケールを実現する仕組み

MongoDBに関する基本的な内容をまとめてみたものです。MongoDBに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[シャーディング: MongoDBによる水平スケールを実現する仕組み] (https://www.techcrowd.jp/mongodb/sharding/)

# [シャーディングとは] (https://www.techcrowd.jp/mongodb/sharding/)
シャーディングとは、複数のノードに渡るデータのディストリビューションを指します。
複数のノードに渡って異なるデータを保存することで、読み取りや書き込みのパフォーマンスのための水平方向のスケーラビリティが実現します。

データセットが大きい場合、単一ノードでは CPU または I/O パフォーマンスによってボトルネックが発生することがあります。シャーディングは、シャードノードが処理するオペレーションの数を減らし、クラスター全体のパフォーマンスを向上させることで、このボトルネックを解決します。

シャーディングは水平スケーリングさせることを可能にし、下記のメリットをもたらします。

**負荷分散により性能の向上**:
データを複数のサーバに分散させることにより，CPUやI/O負荷を分散させることが可能です。

**リソース分散によるコストパフォーマンスの向上**:
メモリやディスクは、サイズの大きなモジュールほど単価が価格が高くなります。複数のサーバにデータを分散させて、それぞれのサーバにのせるメモリやディスクの容量を小さくすることが，コストパフォーマンスの向上につながります。

# [MongoDBにおけるオートシャーディングの仕組み] (https://www.techcrowd.jp/mongodb/sharding/)
MongoDBのシャーディングはレンジパーティション方式を採用しています。シャードキーを指定することで，各サーバに格納されるデータの範囲が決定されます。サーバ間で重複データは持たず，1つのデータが格納されるサーバはシャードキーの範囲によって1つに決定されます。

分散するデータの単位は、「チャンク」とよばれ、あるコレクションの連続した範囲のデータで、複数のドキュメントとなります。チャンクは設定された最大サイズに達すると分割され、シャードが持っているチャンク数に応じて必要であれば他のシャードに自動的に移動されます。もちろんチャンクの分割と移動はパフォーマンスに与えるインパクトは大きく、チャンクの移動や分割中には一部リクエストは正しい情報を返せないので、できるだけチャンクの移動や分割が少なくなるような適切なシャードキーの選択が肝となります。


# [チャンクを自動的に分割していくリバランシングの仕組み] (https://www.techcrowd.jp/mongodb/sharding/)
MongoDBのオートバランシングでは、各シャードにおいて、最大のチャンク数を持つシャードと最小のチャンク数を持つシャードの差が規定値を超えると、均等化の処理としてチャンクの移動が行われます。
(新規にシャードを追加した場合も同様にリバランシング処理が行われる)

たとえば、Shard1にチャンクAのみがある状態から、Shard1にチャンクBも追加されて
さらにShard1にチャンクCも追加されたとします。規定値が2であると、規定値を超えていますのでチャンクCがShard2に自動的に移動されます(下図参照ください)。
MongoDBにおけるクエリ

MongoDBに関する基本的な内容をまとめてみたものです。MongoDBに関する、Web上にすでにある良識な解説コンテンツをまとめたサイトの抜粋です。
[MongoDBにおけるクエリ] (https://www.techcrowd.jp/mongodb/query/)

# [MongoDBにおけるクエリの表現力] (https://www.techcrowd.jp/mongodb/query/)
SQLライクな操作言語によりデータベースにアクセスして、CRUD操作(生成・読み込み・更新・削除)を行うことができます。JOINを除く、ほとんどのSQLを再現することができます。

ただし、データ構造がDB -> コレクション -> Documentであり、取り扱うDocumentデータがJSON形式のデータとはなりますので、
・コレクションの各メソッドを用いてCRUD操作をします
・メソッドの引数にはJSON形式のデータを渡します

また、変数・制御構造なども記述することができますので、集計等の高度なクエリも記述することが可能です。

# [MongoDBシェルからの利用] (https://www.techcrowd.jp/mongodb/query/)
Mongoクエリ言語はMongoDBのコマンドラインインターフェースであるMongoDBシェルから使用できます。シェルは以下のコマンドから起動します。

$mongo
MongodB shell version: 3.2.1
connecting to: testdb
>

**データの挿入・読み込み・更新・削除**

データの挿入・更新・削除・参照は、コレクションのメソッドを呼び出します。たとえば、挿入であれば、下記のように、insertメソッドを呼び出します。

db.collection.insert({"title";"mongo"})

メソッドの引数にはJSON形式のデータを渡します

データを挿入する場合には、insertの引数にJSONのデータを渡しますし、参照する場合には、絞り込みの条件をJSON形式(JSONデータの特定のフィールドに対する条件指定)で指定します。

db.collection.insert({"description";"hello world","list":["Sunday","Monday","Tuesday"]})

**変数の利用**

MongoDBのシェルでは、JavaScriptの記法で変数を使うことができまする。たとえば、あらかじめ変数に値を設定して、メソッドには変数を渡すことができます。

data = {"description";"hello world","list":["Sunday","Monday","Tuesday"]}
> db.collection.insert(data)

**制御構造**

MongoDBでは、制御構造に関しても、JavaScriptのような制御構造を使うことができます。

for (var i=1; i<=10; i++) db.collection.insert ({x:1, j:i*i})


# [JavaからのMongoDBへの接続・操作] (https://www.techcrowd.jp/mongodb/query/)

MongoDBには、たとえばJava MongoDB driverを利用してJavaで接続することができます。
https://docs.mongodb.com/ecosystem/drivers/java/

**MongoDBへの接続**

DB名を指定して接続します。指定したDB名のDBが存在しなければ、MongoDBが新たに生成します。
DB db = mongoClient.getDB("DB名")

**コレクションの取得**

コレクション名を指定してメソッドを呼び出すことにより、コレクションを取得することができ、そのコレクションに対してinsertメソッド(挿入)、更新メソッド(update)などを呼ぶことにより、ドキュメントに対する操作を行うことができます。

DBCollection collection = db.getCollection("collection名")
React-bootstrapを試してみました

以前の記事でReactを少し触ってみました。
http://qiita.com/zuzuwen/items/bb0d4d2d9cdab5920f49
続きで今度はbootstrapテーマを適応させてみました。

1.「package.json」にreact-bootstrapを記載

```package.json
"dependencies": {
...
    "react-bootstrap": "0.30.8",
...
}
```
2.ButtonとButtonToolbarをimportする

```MyBootstrapComponent.tsx
/// <reference path="../node_modules/@types/react/index.d.ts" />
import * as React from "react";
import { Button, ButtonToolbar } from 'react-bootstrap';

export default class MyBootstrapComponent extends React.Component<{ prop: any }, {}> {
    render() {
        return (<div>
            <h2>Buttons</h2>
            <ButtonToolbar>
                <Button>Default</Button>
                <Button bsStyle="primary">Primary</Button>
                <Button bsStyle="success">Success</Button>
                <Button bsStyle="info">Info</Button>
                <Button bsStyle="warning">Warning</Button>
                <Button bsStyle="danger">Danger</Button>
                <Button bsStyle="link">Link</Button>
            </ButtonToolbar>
        </div>);
    }
}
```

```App.tsx
/// <reference path="../node_modules/@types/react/index.d.ts" />
/// <reference path="../node_modules/@types/react-dom/index.d.ts" />
import * as React from "react";
import * as ReactDOM from "react-dom";
import MyBootstrapComponent from "./MyBootstrapComponent";

window.onload = () => {
 ...

    ReactDOM.render(<MyBootstrapComponent prop=""/>, document.getElementById('bootstrapbutton'));
};
```
3.スタイルシート適応とdiv追加

```Index.html
...
<head>
...
   <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/latest/css/bootstrap.min.css">
</head>
...
<body>
...
    <div id="bootstrapbutton"></div>
...
</body>
...
```
Bracketsでinteractive-linterの不要な警告を無効にする


# interactive-linterの不要な警告を無効に

bracketsでjqueryを書いたらinteractive-linterの警告が出されたので、不要な警告を無効化した際のメモ。

## 症状と無効化設定

下記のようなコードを書くと

```
$(function() {
  var windowWidth = window.innerWidth;
  …
}
```
こんな警告が

```
'$' is not defined. - W117 - Details
'window' is not defined. - W117 - Details
```

lintがjqueryとwindowオブジェクトを認識していないようなので、この警告を出さないように設定ファイルに追加。

```brackets.json
{
    "interactive-linter.javascript": {
      "globals": {
        "$":false,
        "window": false
      }
    }
}
```

## 参考

- https://www.d-wood.com/blog/2014/06/05_6316.html
- http://qiita.com/kaznmb/items/7f96b84623923f9c943d
- https://teratail.com/questions/3901
- http://qiita.com/uggds/items/301c1c43f8b9ffbc52d7

ありがとうございました。
ドットによるオブジェクトの属性の取得をカスタマイズするための__getattr__と__getattribute__

# `.`による属性の取得
`class`文内で定義した、変数やメソッドといったオブジェクトの属性は、普通`.`で取得すると思います。例えば次のようなクラスを定義したとします。

```py:
class Foo:
    def __init__(self):
        self.foo = "foo"
        self.bar = "bar"
```
`Foo`のインスタンス`foo`の属性`foo`や`bar`は`.`で取得することができます。

```pycon:
>>> foo = Foo()
>>> foo.foo
'foo'
>>> foo.bar
'bar'
```
この`.`による動作は特別な属性である`__getattr__`や`__getattribute__`メソッドを用いてカスタマイズすることができます。

# `__getattr__`によるカスタマイズ
`__getattr__`を定義すると、`.`で属性を取得しようとした時に、通常の名前検索をまず行って、それでも指定された属性が見つからない場合、`__getattr__`が呼ばれ、返された値をその属性として返します。

次のクラス`Foo`は、`__getattr__`をメンバ変数`foo`を常に返すように定義しています。

```py:
class Foo:

    def __init__(self):
        self.foo = "foo"
        self.bar = "bar"
    
    def __getattr__(self, name):
        return self.foo
```
`Foo`のインスタンス`foo`は、`self.bar`というメンバ変数を持つので、`foo.bar`では、`self.bar`が返されますが、`self.anything`というメンバ変数は無いので`self.__getattr__("anything")`が実行され、`self.foo`(すなわち文字列`"foo"`)が返されています。

```pycon:
>>> foo = Foo()
>>> foo.foo
'foo'
>>> foo.bar
'bar'
>>> foo.anything
'foo'
```

# `__getattribute__`によるカスタマイズ

`__getattribute__`が定義されていた場合、`.`で属性を取得しようとすると常にこのメソッドが呼ばれます。`__getattribute__`の定義の中では、`.`を用いてそのオブジェクトの属性を取得しようとすると、自分自身の`__getattribute__`が再帰的に呼ばれてしまうため、それを避けるためにスーパークラス`object`の`__getattribute__`を使用します。

```py:
class Bar:

    def __init__(self):
        self.foo = "foo"
        self.bar = "bar"
    
    def __getattribute__(self, name):
        return object.__getattribute__(self, "foo")
```
次の実行結果を見るとわかるように、`Bar`のインスタンス`bar`は、`self.bar`というメンバ変数を持っているにも関わらず、`bar.bar`としても`__getattribute__`により`self.foo`(すなわち文字列`"foo"`)が返されています。

```pycon:
>>> bar = Bar()
>>> bar.foo
'foo'
>>> bar.bar
'foo'
>>> bar.anything
'foo'
```
# 組み込み関数`getattr`と`hasattr`
組み込み関数`getattr`と`hasattr`は、`__getattr__`や`__hasattr__`でカスタマイズされた属性取得に基づきます。ですので、`getattr`でオブジェクトの属性を取得するのと`.`で取得するのは同じことです。上の例での`Foo`と`Bar`のインスタンスで確かめると出力はこうなります。

```pycon:
>>> getattr(foo, "bar")
'bar'
>>> getattr(bar, "bar")
'foo'
```
`__getattr__`や`__getattribute__`がどんな属性を指定しても値を返す(つまり`AttributeError`が発生しない)のであれば、`hasattr`は常に`True`を返します。

```pycon:
>>> hasattr(foo, "anything")
True
>>> hasattr(bar, "anything")
True
```
jQuery Pluginをパラメーターの代わりにdata属性で代用できるプラグイン

* Github: https://github.com/kamem/jquery.pluginFromDataAttr


プラグインを複数のページなどで違う動作をしたい場合に
わざわざjsを用意してパラメーターを指定し直さないければいけないのが煩わしいと思っていました。

その代わりにdata-*でパラメーターを指定して使うことができるjQueryプラグインです。

[DEMO](http://github.develo.org/jquery.pluginFromDataAttr/)

インストール
-----

	npm install jquery.plugin-from-data-attr

仕様
-----
* 下記のようなプラグインがあった場合に

		$('.tab').tab({
			timer: 1000,
			num: 1,
			isSessionStorage: true
		});

* 下記のようにHTMLのdata属性を代わりに使うことができます。

		<p class="tab" data-timer="1000" data-num="1" is-session-storage="true">


使い方
-----
1. スクリプトの記述（プラグインの後にjquery.pluginFromDataAttr.jsを読むこむ）

		<script src="js/jquery.js"></script>
		<script src="js/jquery.tab.js"></script>
		<script src="js/jquery.pluginFromDataAttr.js"></script>

2. $('適応したいタグ').dataExtend('プラグイン名');

		<script>
		$(function(){
			$('.nav').pluginFromDataAttr('tab');
		});
		</script>

3. HTMLにdata属性を記述する（キャメルケースの場合「-」でつなげる）※ is-session-storage = isSessionStorage

		<p class="tab" data-timer="1000" data-num="1" is-session-storage="true">
source()のディレクトリ問題

Rでプロジェクトが大きくなってくるとソースファイルを呼び出し元(./MAIN.R)と別のディレクトリ("../SRC/SOURCE.R")において、ライブラリとして読み込んで使用したくなる。ソースファイルが単独で作動すれば良い。しかし、SOURCE.Rからさらにソースやデータ(例えば同一ディレクトリにある"../SRC/SOURCE2.R")を読み込もうと思ってSOURCE.Rからみた相対パスを記載しても読み込まれない。これはsource("SOURCE.R")を実行してもディレクトリが呼び出し元のままであることに起因している。SOURCE.R内の呼び出しを書き換えるとSOURCE.Rに汎用性がなくなるし、setwd()すると戻し忘れたりややこしい。

SOURCE.R内で絶対パスを取得し対応することとする。

```R:SOURCE.R
library(tools)
SC_DIR <- file_path_as_absolute(dirname(sys.frame(1)$ofile))
source(paste0(SC_DIR, "/SOURCE2.R"))
```
goで絵文字表示可能なエクセルで開けるcsvファイルの出力（utf16le, タブ区切り）


UTF16LEのBOM付きでエンコード、タブ区切りで出力。

```main.go
package main

import (
	"fmt"
	"encoding/csv"
	"bytes"
	"io/ioutil"
	"golang.org/x/text/transform"
	"golang.org/x/text/encoding/unicode"
	"os"
)

func main() {
	buf := new(bytes.Buffer)
	w := csv.NewWriter(buf)
	w.Comma = '\t'
	w.Write([]string{"name", "type"})
	w.Write([]string{"blacksmith🔨", "villager"})
	w.Write([]string{"creeper💣", "enemy"})
	w.Write([]string{"zonbie😡", "enemy"})
	w.Flush()
	utf16byte, err := ioutil.ReadAll(transform.NewReader(
		buf,
		unicode.UTF16(unicode.LittleEndian, unicode.UseBOM).NewEncoder()))
	if err != nil {
		fmt.Println(err)
	}
	file, err := os.OpenFile("utf16le.csv", os.O_WRONLY|os.O_CREATE, 0600)
	file.Write(utf16byte)
}
```
Google Test / Google Mock

# C言語でGoogle TestとGoogle Mockを使う

## インストール方法
いちいち解説しない。
インストール方法からちょっと使ってみました的なTipsなんてそこらを探せばポロポロ出てくるからGoogle先生に聞いたほうが早い。というか本家見ろ。

### 注意点
Google Mock+Google Testを使うなら個別にビルドしないほうがいい。
Google MockのZipアーカイブを展開してさくさ生されたディレクトリ直下にGoogle Testのソースディレクトリをディレクトリ名gtestで展開してgmockをビルドする。

個別にビルドしたGMockとGtestを混在するとどうもうまく動かないので、gmockをビルドした時に使用したgtestのライブラリを使用すること。


## 幾つかの使い方
Getting startとかチートシートとかに載ってるけどわからない or わかりにくい、そもそも載っていないような使い方を書いておく。

# Cで使う
もともとC++向けのテストフレームワークだから、Cで使おうとすると無理やりな感じになる。
例えばこんな感じのCモジュールがあったとする。

``` sample.c
/* こんなアホなコードがあったなら削除したいが、あくまで例である。 */

#define CONSTANT_VALLUE 1

int add_constant(int v)
{
    return v + CONSTANT_VALUE;
}
```

``` sample.h
int add_constat(int v);
```

``` sample_user.c
/* たまにこういうことする人がいるけどアホなのかな */
#include "sample.h"

int foo(int v)
{
    return add_constant(v);
}
```

で、このCモジュールsample_user.cを単体テストするなら、sample.c::add_constantのmockが必要。テストコードと合わせるならこんな感じ。

``` test_sample_user.cc
#include <gmock/gmock.h>

class SampleMock {
public:
    GMOCK_METHOD1(add_constant, int (int ));
};

SampleMock *mock;

extern "C" {
int add_constant(int v) {
    return mock->add_constant(v);
}

class TestSampleUser : public ::testing::Test {
protected:
    virtual void SetUp() {
        mock = new SampleMock();
    }
    virtual void TearDown() {
        delete mock;
    }
};

TEST_F(TestSampleUser, TestFoo) {
    EXPECT_CALL(*mock, add_constant(::testing::_)).WillOnce(testing::Return(2));

    EXPECT_EQ(2, foo(1));
}

```

かっこわるいことだが、Google Mockの機能を使う必要があるため、モックした関数で使うモッククラスのオブジェクトと、テストコード中のモッククラスのオブジェクトが同じものである必要が有るため、どうしてもグローバル変数にしないとうまくいかない。

うまいやり方があるなら教えてほしい。

# 引数チェック
構造体渡した場合とか、ポインタ渡しした場合はあんまり書かれていない。
さっきの糞コードをちょっと改変した例

``` sample.c
#include "sample.h"

#define CONSTANT_VALLUE 1

int add_constant(struct Value *v)
{
    return v->value + CONSTANT_VALUE;
}
```

``` sample.h
struct Value {
    int value;
};

int add_constant(struct Value *v);
```

``` sample_user.c
#include "sample.h"

int foo(struct Value *v)
{
    return add_constant(v);
}
```

んでテストコード。
上のテスト対象モジュールは構造体のポインタを取る関数る。テストコードでは、与えらる引数が正しいことをチェックする必要がある。

``` test_sample_user.cc
#include <gmock/gmock.h>
#include "sample.h"

class SampleMock {
public:
    GMOCK_METHOD1(add_constant, int (struct Value* ));
};

SampleMock *mock;

extern "C" {
int add_constant(struct Value *v) {
    return mock->add_constant(v);
}

class TestSampleUser : public ::testing::Test {
protected:
    virtual void SetUp() {
        mock = new SampleMock();
    }
    virtual void TearDown() {
        delete mock;
    }
};

using ::testing::Return;
using ::testing::Pointee;

TEST_F(TestSampleUser, TestFoo) {
    EXPECT_CALL(*mock, add_constant(::testing::_)).WillOnce(testing::Return(2));

    EXPECT_EQ(2, foo(1));
}
```

# 雑記
インストールからGetting startやるぐらいなら読みゃわかるんですよ。READMEあるんだから。
問題は実際の使い方。そこまで書いてない記事が結構あった印象。