超初心者のための「Railsがなにをしているか例えてみよう」講座　

おはようございます、こんにちは、こんばんわ。
私はインフラトップという会社で、
プログラミング学習の「WEBCAMP」でメンターとして勤めております。
その中で、良くされる質問が、
「Railsでそもそも何を書いたらいいのかわからない」
「Railsがなんで動いているのかわからない」
などです。その気持ち…。
よ～～～～～～～～～～～～っくわかります。

.saveとついているから何となく保存されているんだろうな、
とゲームなどでそれとなく覚えている単語から推測、
理解して使っているような時期が、私にもありました。

WEBCAMPメンターとして働く最中にしたRailsの仕組みの説明を、
フィードバックとして記事にしようと思い立ちました。

プログラミングは、
どう説明しても人によって理解の速度が違うので、
これが「完璧な説明」とは言えないと思います。
しかし生徒の皆様にご理解をいただけたことも多く、
有効な説明と自負しております。

あくまでもわかりやすくするために多少の独自解釈を含みつつ、
ざっくりかいつまんでのお話をさせていただきます。

もくじ

• そもそもRailsって何をしているの？
• Railsの動きは、「店舗と商品と運送と保存管理」で成り立っている
• Railsで最低限抑えるべきこと

そもそもRailsって何？何をしているの？

まずはここからご説明をさせていただきます。
Rubyを使って作られたフレームワークということが一般的に説明されていますが、
一言で言えば、

• Railsの規約に従って作っていけば、比較的簡単にアプリを作れる仕組み
• Rubyを使って作られており、アプリの作成にもRubyが使える。
• Web上にアプリ・サービスを作る事に使える。

というのが、Railsフレームワークです。
ひとまず、この３点を覚えておけばRailsの理解の下準備としては十分です。
Web上にアプリケーションを作る、というのがとても重要です。

続いて、Railsが何をしているのかをご説明します。
MVCという構造を採用しています。

• Model…データベースの管理
• View…ホームページとして表示する機能
• Controller…機能を定義して、モデルと提携してデータを引き出し、Viewの管理も行う

というようになっています。

つまり、
Web上にアプリを作るというのは、
フォームに文字などを入れると、データベースに保存され、
自動で更新されるホームページが出来上がる、ということです。

それだけ？と思うかもしれませんが、極論を言えばそれだけです。
その中に数式を入れて計算させたり、
通常のホームページのように装飾したりできますが、
根本の部分はこの点に集約されます。
もっと便利にするためにgemなども使えますが、
こちらは基礎を押さえてからご利用頂いた方がいいと思います。

基本的にはこの点を起点としてRailsアプリは作られている、と考えておきましょう。

Railsの動きは「店舗と商品と運送と保存管理」で成り立っている

それでは、Railsアプリの基本を押さえる為に、
Railsがしている仕事を現実の仕事に例えていきます。
MVCの説明をしましたが、一つずつ分解して考えていきましょう。

• Model→データベース＝「運送業の倉庫」データを預けたり、預かり方を設定できる。
• View→ホームページ＝「コンビニ店舗」預かったデータをホームページに展開、閲覧できるようにする。新しいデータの預かりもできる。
• Controller→「倉庫の従業員＆運転手」仕事のやり方を作る、データの出し入れの管理＝倉庫の従業員兼、運送トラック。

MVCに加えて、今度はRoutesというのも出て来ます。

• Routes→「倉庫とコンビニの住所」ブラウザでどの住所＝URLに行けば、仕事ができるかを設定する。

まずはこれくらいを意識して、解説を読んでみましょう。
今回はデータベースへの保存と、Viewからのブラウザ表示のみに焦点を当てます。
実際に手を動かしてチェックしてみて下さい。

それでは、スタート前に、以下のコマンドを入れて下準備をします。
コントローラを準備しましょう。
rails g controller posts new index create show


続いて、routesを変更します。
routesは、

• URLを入力したら
• viewで<%= link_to 'リンク名', ~path %>で作られるリンクをクリックしたら
• フォームなどのデータベースに更新する処理をしたら

どのような機能につながるのかを、
設定します。

get '/URL' => 'コントローラ名#アクション名'

この場合は、URLにつないだら、コントローラに設定されたデータを持ってきて、
同じ名前のアクション名のついたViewをホームページとして設定します。

post '/モデル名s' => 'モデル名s(コントローラ名）#create'

この場合は、Viewファイルにあるフォームから送信した場合、
モデル名に対応したデータベースに保存させる、という記述です。
createのアクションで詳しく解説します。

それでは今回説明するアクションのroutesを書いていきましょう。

Rails.application.routes.draw do
  # アプリを開いた瞬間につながるページをrootで記述します。
  root 'posts#index'

  # 今回使用するrouteはこちらです。
  # resourcesで自動出力されるものと同一にしてあります。
  get  '/posts/new'  => 'posts#new',as: 'new_post'
  post '/posts'      => 'posts#create'
  get  '/posts'      => 'posts#index'
  get  '/posts/:id'  => 'posts#show',as: 'post'
end

ここまでで、下準備はOKです。
あとは、実際に起こっている出来事を追いかけながらチェックします。

まずは、データの格納先である、データベースに保存するためのモデルを作ります。
モデルは「データベース」そのものというよりは、
データベースに対応した箱を作り、その取扱い方法を記述するものです。
今回は、データベースに対応した箱を作るコマンドからスタートします。
rails new アプリ名
でアプリを作成後、アプリに移動、その後に実行していきます。
以下のコマンドをターミナルに打ち込んでみましょう。

rails g model post title:string body:string
rails db:migrate

このコマンドを実行すると、
こんな感じの仕切りが付いた箱が作れるようになります。
今後、posts_controllerでPost.newと入れると、
保存用に準備できる箱ができあがるようになります。

そして仕切り箱には名前がついています。

title,body,id,created_at,updated_at

この仕切り箱一つ一つのデータの格納場所を、
「カラム」といいます。
このうち、
titleとbodyは、コマンドで自分で準備したもので、
id,created_at,updated_atの三つは、自動で準備されるものです。
この三つはrailsが自動で記入するので、基本的にはいじれないものです。
idは保存されたデータに順番に自動で振られる番号です。（重要）
created_atはデータの作成日、
updated_atはデータの更新日です。
先ほど入力した
rails g model post title:string body:string
というコマンドで、Postモデルが出来あがり、
それ以降は「Post.new」とコントローラで記述することで、
一つ箱が作れるようになります。
これがないと、データをデータベースに保存できません。

では続いて、入力フォームのあるページと動作を記述してみます。
これはnewアクションと言います。
下記の絵と、コードを参照して動きを確認しましょう。

このnewアクションは、
localhost:3000/posts/new
にアクセスするか、

もしくはViewfileの中で
<%= link_to 'new',new_post_path %>
で作られるリンクをクリックすると、
ブラウザにフォームが書かれたnewのページが表示されます。

def new
    @post = Post.new
end

<%= form_for(@post) do |f| %>
  <div class="field">
        <%= f.label :件名 %>
        <%= f.text_field :title %>
    </div>
    <br>
  <div class="field">
        <%= f.label :本文 %>
        <%= f.text_area :body %>
    </div>
    <br>
    <%= f.submit :投稿 %>
<% end %>

@post = Post.newで@postという作業員さんに、Post.newという箱を預けます。
これが届くことで入力フォームに入力可能になり、
データベースに保存ができるようになります。
そして入力フォームを画面に表示するために、
fomr_forの記述がしてある場所に@postさんに来てもらい、
Post.newの内容の記述ができるようにブラウザで表示、
ページにアクセスしている人に記述をお願いし、
最後に送信ボタンを押してもらうと、createアクションに送信します。

ここが重要で、
Post.newでPostモデル用の箱を作ったので、
app/controllers/posts_controller.rb
の中にあるcreateに、その荷物を送るという手順になっています。
Post.newで新しく箱を準備するので「新規の投稿」、
新しくデータとデータをしまう場所をcreateしてもらう、ということです。

ちなみにposts_controller.rbは、
「Postモデルの」という意味のあるコントローラ名です。
複数形にするのがポイントです。（Railsの命名規則です）
ここではPostモデルと契約していることになっている、
と考えるとイメージしやすいと思います。
こうすることで、Postモデルのデータを取り扱う役割が持てます。

createアクションでは、以下のような記述と、作業内容になります。
今回は、データベースにしまう動きですので、ブラウザには表示しません。
コントローラしか記述をしないで大丈夫です。
こちらも画像を確認しながら、動きをチェックしてください。

このcreateアクションはnewに書かれたフォームで、
データを入力、送信ボタンを押すと動きます。

def create
  @post = Post.new(post_params)
  @post.save
  redirect_to posts_path
end
# private以下は、一番下のほうに記入します。ここから
private

def post_params
  params.require(:post).permit(:title, :body)
end
# ここまで。この下にendがひとつだけあるのを確認して下さい。
end

まず、
@postさんという作業員さんに、新たにPostモデルの箱を渡します。
しかし、渡す前に、post_paramsさんという別の作業員さんにチェックを依頼します。
newのフォームからもらったほうのPost.newの箱のデータを、
「Postモデルかどうか」→params.require(:post)
「カラムはtitleとbodyだけ受け付ける」→.permit(:title, :body)
という順番で検査します。
newのフォームからもらったPost.newのデータが正しければ、
createで作られたPost.newモデルにしまい直すという作業をします。
そしてしまい直したら、
@post.saveで@postさんは、倉庫にデータを収めに行ってくれます。
これらの作業は、Rails内部で行われているので、見えません。
しかし、このままですと、このページにアクセスしている人は、
データが登録できたかどうかが確認できません。
ですので、redirect_to posts_pathで、
ブラウザの表示をindexアクションのページに移動させるようにする必要があります。

ここまでで、createの仕事が終わりになります。

ではせっかくなので、続いてindexアクションについての記述を行いましょう。
indexアクションは、すべての投稿をまとめて表示する、という内容です。
今回は投稿後は必ずこのページに移動するように設定しています。

indexアクションは、
このnewアクションは、
localhost:3000/posts/
にアクセスするか、

もしくはViewfileの中で
<%= link_to 'new',posts_path %>
で作られるリンクをクリックすると、
Postモデルに保存されたデータの一覧ページにつながります。

  def index
    @posts = Post.all
  end

これだけです。
これはどういうことをしているのかというと、
PostはPostモデルにアクセスします、という意味で、
.allはPostモデルに保存されたものをすべて持ってきてください、という意味です。

今回は@postsというトラックに、
Postモデルに保存されたものをすべてしまいました。
そして、しまい込んだあと、
Viewファイルに記述された@postsにデータが届くようになっています。
このデータをすべて同じレイアウトで並べられるように、
each文で、レイアウトを決め、すべてのデータを同じ展開の仕方で表示します。

Viewファイルに以下の表記をして下さい。

<h2>投稿一覧</h2>
<h3>件名/本文</h3>
<% @posts.each do |post| %>
    <%= post.title %>/<%= post.body %>
    <br>
<% end %>

そうすると、すべてのPostモデルのデータを、
<%= post.title %>/<%= post.body %><br>

というレイアウトで繰り返して表示します。
棚にきれいに整列させて並べるような感じです。

では最後にshowアクションの記述を行ってみましょう。
showアクションは、
Postモデルに保存されたデータの中から、
保存されるごとに自動で番号が振られるidを基準に、
ひとつのデータを持ってくるように指定するアクションです。

このnewアクションは、
localhost:3000/posts/id（=保存された番号）
にアクセスするか、

もしくはViewfileの中で、
※この例はindex.htmlの@posts.eachの中で使われる想定です。
<%= link_to 'new',post_path(post) %>
で作られるリンクをクリックすると、
ブラウザにshowのページが表示されます。

今回は、
localhost:3000/posts/2
だった場合の動きです。
ちなみに、この場合二件以上データが投稿されていない場合は、
表示ができません。無いものは表示できないからです。

    def show
        @post = Post.find(params[:id])
    end

@が先頭についた変数をインスタンス変数、と言います。

Post.findは、Postのように先頭の文字を大文字に変更すると、
コントローラはPostモデルにアクセスする、という意味になります。
そして.findで「idを頼りに一件だけデータを選択します」という意味になります。
(params[:id])で、そのデータがidです、と確定します。

<%= @post.title %>
<%= @post.body %>

などと書けば、データベースに保存されたPostモデルのカラムがそれぞれ表示されます。
ここまででデータベースへの保存と、
ページの表示に関する機能の実装方法を説明しました。

Railsで最低限抑えるべきこと

最後に復習とまとめとして、
Railsで最低限抑えるべきことを記載します。

• Railsアプリを作るということは、
  フォームに文字などを入れると、データベースに保存され、
  自動で更新されるホームページを作るということ

• MVCはあくまでデータの出し入れと、
  ホームページとしてデータをどう表示するかを制御しているというのが基本

• routesで各機能へのURL、pathの制御を行っている

• コントローラ内でPostとつけた場合、データベースから
  Postモデル関係のデータを引き出す操作を行うこと。
  @を付けた変数をコントローラで準備しないと、
  Viewにはデータが届けられないこと
  （回避する方法自体はある）

• Post.newという記述がデータベースへの保存には必要なこと。
  保存されたPostモデルデータは主にposts_controllerで取り扱うこと。
  （回避する方法自体はある）

この点をひとまずしっかり抑えられれば、
初心者がRailsアプリケーションを作る上では十分です。
データの流れ、Railsの動きがしっかり分かれば、
悩みも半減すると思います。

少し長い記事になってしまいましたが、
ご覧いただきありがとうございました！

画像素材：かわいいフリー素材集いらすとや　様　(https://www.irasutoya.com/)

はじめに

InfratopAdventCalendarの2日目を担当します。@tatsukichiです。

それではやっていきます

皆さんはタスク管理にどのようなツールを使っていますか？
今回は、自分で立てたEC2インスタンスに
Railsで作成されているredmineを使ってタスク管理をしていきましょうというエントリーです。

個人で使うのもよし。チームで使うのもよし。
数多くのプラグインがあるredmineを使って、自分のタスクスタイルにあった管理ツールをAWSのサービスEC2を使って5分で作成していきましょう！
※今回は、redmineを作成し管理ユーザでログインするまでをゴールとしています。

手順

行うことは大きく３つだけ。
- AMIを使ってインスタンスを作成
- アクセスしてみる
- 管理ユーザでログインしてみる

AMIを使ってインスタンスを作成

AMIを使用し、インスタンスを作成するにあたり簡単に解説を挟んでいますが、必要なければ読み飛ばしてください。

AMIとは

そもそもAMIとは、Amazon Machine Imageのそれぞれの頭文字をとった名前です。
- OS
- アプリケーションサーバ
- アプリケーション
- etc.
これらの情報をひとまとめにしたEC2のテンプレートのようなものです。

AMIは、redmineのように既に存在しているものもありますが、オリジナルで作成することも可能です。
例えば、インスタンスを複製したいときなどにAMIを使用することで容易にインスタンスのコピーを作成することができます。

AMIの中には有料のものも存在しますが、redmineの使用量は無料となってます。

インスタンスの作成

それでは早速、redmineのAMIを使用してEC2インスタンスを作成していきましょう。

まずは、インスタンスを作成する画面でAMIを選択していきます。
1. AWS Marketplaceを選択します
AWS MarketplaceはAWSが用意したAMIが表示されます。
2. 「redmine」と検索します。
3. Bitnamiのredmineを選択します。

次に、インスタンスタイプを選択します。
redmineの使用人数等にもよりますが、今回は無料枠でも使用可能なt2.microを使用していきます。

以下の部分を選択します。

ここまでできたら、確認と作成をクリックしインスタンスを作成します。

鍵はもちろん、既存のものでも新しく作成しても問題ありません。

アクセスしてみる

それではインスタンスが作成されましたら、パブリックIPにアクセスしてみましょう。

あれ、もうできた。

そうです。
たったこれだけであなただけのredmineが作成できました。
さて、何分かかりましたか？

管理ユーザでログインしてみる

ここまでは誰でもできてしまいそうな内容ですが、ここからは知らないと苦労しますので
一緒にやってみましょう。

redmineは動いているみたいだけど。。。
そうです。ログインできないんです。

ログインするには以下の手順でパスワードを見つける必要があります。
1. EC2インスタンス起動時のシステムログをみる

2. 管理ユーザのパスワードをみつける

以下の情報を入力してログインしてみましょう。

ログインID　: user
パスワード　: [白塗りの部分]

最後に

これで今回作成したredmineはあなたのものになりました。
便利なプラグインやイケてるテーマなどもありますので、好みにあったものを使用して楽しんでみてください。

ありがとうございました。

※この記事は＜ストーリー編＞と＜論理編＞に分かれております。諸事情により詳しい技術のお話は別記事にまとめたいと思います。（じ、時間がなかったわけじゃないんだからね！）

＜ストーリー編＞

どうも、おはこんばんにちわ！
みなさん社内のチャットツールは何を使っていますか？

僕が所属する会社では、"slack"です。

slackを使っているIT企業は多いのではないでしょうか。

そんなslackを使う中で、常日頃から不便に感じていた問題がありました。

それは、「チャンネルに複数のメンバーを招待するのがめんどくさい」問題です。

数人ならまだ良いのですが、僕たちは業務上、新しいチャンネルを作り、そこに40人くらいのメンバーを招待するという作業を、頻繁に行います。

この40人の招待が、めちゃくちゃ面倒くさい。
一般的な招待の仕方は、下記のような画面で、一人一人検索して招待するのですが、

なぜか検索に引っかからない人もいるんですね🤔
なぜなんだ。。。

この作業にかかる時間とストレスを、削減するための結論が、
「そうや！スラッシュコマンドや。あれをカスタマイズして、コマンド１つで任意のメンバーを全員招待できるようにしよう。」
です。

＜論理編＞

ここからは、実際に僕が、スラッシュコマンドをにカスタマイズした、手順と考え方についてです。
僕は本当に何もわからなかったので、とても苦戦しました。

簡単にまとめると、
①slack api を使いslack側にアプリを作成。どのワークスペースに結びつけるかもこの時。
②今度は、slackの外に、実際にスラッシュコマンドを打った時に、動く肝心のアプリを作る。
③slack apiに戻り、何というスラッシュコマンドを叩いた時に、どのアプリにアクセスするかを設定。
→完成！

という流れです。

①については、下記の記事を参考に作りました。
https://qiita.com/t-mimura/items/d6541ec596bdebea5a7b　

slackにはデフォルトで、スラッシュコマンド が複数用意されていますが、
さらに、カスタムしやすいように、「slack api」 というgemがあり、これをインストールすると、便利なメソッドがたくさん使えるようになります。
それらは②の工程で使うことになるでしょう。

今回僕が使ったのは、.users_list や　.groups_invite　です。
まず、 .users_listで全ユーザー情報を集め、その中で該当するユーザーだけ取得します。
プライベートチャンネルに複数人招待するメソッドが .groups_invite　になります。
.groups_inviteを使い、任意のユーザーをプライベートチャンネルに一度に招待可能というわけです。

どうですか？簡単に聞こえますよね。
ちなみに僕はわからなすぎて、形になるまでに１ヶ月くらいはかかりました。死

次回、「具体的なコードはこう書いた！」お楽しみに！！！！！

突然の自分語り

あれはそこまで遡らないこと去年の8月。

RubyやRailsを学び始めてひと月とちょっとが経ち、色々見よう見まねで作ってはみたものの、未だにいいね機能やフォロー、フォロワー機能などの仕組みがわからず。
というか、よくよく考えてみるとどういう仕組みでSNSを使っているユーザーが投稿していて、その投稿とユーザーが結びついているのがわかっていない、という状況にありました。いや、今から考えるとどんだけわかってなかったんや。

こういったモデル同士、つまりユーザーやその投稿、そして投稿につけられる"いいね"やユーザーに対するフォローなどの関連付けの事をアソシエーションと言うのですが、そのような概念がプログラミング初心者のみなさんにはとても難しく感じるのではないか？？いや、きっとそうに違いない！というスーパーお節介な動機からこのような記事を執筆するに至りました。そしたらバカみたいに長くなってしまいました。これちゃんと最後までやってくれる人いるかな・・・・・。

正直、アソシエーションやリレーションの記事などは、SQLから学ぶのなどもう既にたくさん出ています。
ですが、意外とテキストベースの解説が多く個人的には初心者がとっつきにくいような気がしており、なるべく図などを使ってわかりやすく説明できたらなと思っております。噛み砕きすぎている点についてはツッコミください。

では、よろしくお願いします！！！

目次

普段やってること

普段は機械学習でこういうの予測してます。(HMMで予測しましたが最終的にLSTMになりました)
AIによる宅建士試験出題予測『未来問』無料プレゼント

バンドもやってます。HPはプログラミング初めて3ヶ月ぐらいの時に自分で作った物です(Railsで作ってCMSっぽくしてあります。)
2018年のサマソニ出演しました！！！！！CDも全法人で全国流通してます！！！！！！
ravenknee official HP

この記事を読むにあたっての前提

・CRUDを理解している
・MVCをざっくり理解している
・特に、Model, DataBase, Table周りの意味も簡単に知っている。

もちろん、それ以外の方も是非是非挑戦してみてください。理解なんて後から帳尻合わせていきましょう。

できるようになること

• これが作れるようになる(お粗末ですいません) - https://rails-association-tutorial.herokuapp.com

丁寧すぎるherokuへのデプロイの方法はこちら - 【初心者向け】railsアプリをherokuを使って確実にデプロイする方法【決定版】

• 簡単な設計ができるようになる。
• ユーザー、投稿、イイネ、コメント、フォロー機能のアソシエーションが理解でき、実装できるようになる。

注意してほしいこと

• validationは説明しません(ごめんなさい)
• dependent系のオプションも説明しません(この記事読んだあと調べればすぐわかります。)
• 例外処理もしません
• indexとかも貼りません

本当にアソシエーション周りだけの理解をするための記事です。ご了承ください。
validation, dependent, viewのパーシャル化だけ実装したコードは最後に上げておきます。

アソシエーションとは

https://railsguides.jp/association_basics.html
モデル間の関連付けに使われる概念です。
モデル間の関連付けと言われてもピンとこない人が多いと思うので(自分がそうでした)、図を駆使しながら具体例で考えてみましょう。

プログラミング初心者のAさんがあるブログアプリを作ったとします。そのブログは最初はAさん一人で使うものだったため、記事投稿機能のみがつけられていて、モデルもArticleモデル一つのみ実装されていました。

ですが、そのサイトをたまたま見つけてしまったBさんが、勝手に自分の投稿をし始めてしまいました。

これではどれが誰の投稿かわからなくなってしまう、とAさんはブログにユーザーログイン機能を付け足しました。これでアプリにはArticleモデルとUserモデルの二つモデルが実装されていることになります。

そして、この時にまさしくどれが誰の投稿なのかを関連付けるものがアソシエーションなのです。

そして、アソシエーションを行う際は、そのモデル同士の親子関係がどのようになっているかがとても大事になってきます。

　モデル同士の親子関係とは

図で考えてみましょう。
Aさん(User)は、自分が作ったブログサイトでたくさんの記事(Article)を投稿します。

Bさんも少しは投稿します。

つまり、User一人一人は沢山のArticleを持っている(User has many articles.)、と考えることができます。(この突然出てきた英文は伏線ですよ！！！！)

逆の立場(Article)も考えてみましょう。
ある日投稿された記事(Article)は、Aさん(User)によって書かれました。

次の日投稿された記事はBさんによって書かれました。
他の日に投稿された記事も、それぞれAさん、Bさんどちらかによって書かれた記事です。Aさん、Bさんが共作で書いた記事というのはありえません。

つまり、Articleは誰か一人のUserに所属している(Article belongs to a user.)と考えることができます。

UserがいなくてはArticleは生まれないし、Articleは必ず誰か一人のUserから生まれます。そう、Userが親でArticleが子となっているわけなのです。これが親子関係です。

このような関係をUserとArticleは一対多の関係または1:Nの関係といいます。もちろんUserが1でArticleが多です。(これがめちゃめちゃ大事です！！！！！！！！！！)

他にも一対一(1:1)の関係や多対多(M:N)の関係などもあります。
一対一は簡単なので割愛します。多対多は少し難しいですが、これからやっていくチュートリアルで登場&解説するので、ご安心ください。

さあ、それではいざアプリ制作に取り掛かっていきたいのですが、その前にデータベース設計を行わなくてはなりません。
そう、アソシエーションはデータベース設計と密接に関わっております。

データベース設計とは？（少し難しい話です）

情報システムにおいて、どのような情報をデータベースに格納すべきかを検討し、その「格納すべき情報」を「どのような形で保持するか？」を設計することです。

一般化した定義のためわかりづらいかもしれませんが、

• 情報システムはTwitterアプリそのもの
• どのような情報は
  • ユーザー(のemailやpassword)
  • tweet(本文やどのユーザーが投稿したのか？など)
  • お気に入りなど
• 「格納すべき情報」を「どのような形で保持するか?」というのは
  • 情報システムをより細かく考えたデータ
    • つまりユーザーでいうと「emailは文字列型、その識別idは整数型」など

といったアプリの動的な部分の設計のことを言います。データのことをちゃんと詳しく決めよう！！ということです。

そして、データベース設計において大事な概念が４つあります。

• エンティティ
• 属性
• 関連（リレーション）
• 関連の多重度

順番に説明して行きますが、完全に理解しなくて大丈夫ですので軽〜く読んでみてください。

エンティティ

エンティティとは、モデリングの対象となるアプリの中で管理する必要がある情報です。ツイッターでいうとUser, Tweet, Favorite, Followなどがこれにあたります。RailsのModelに近いですね。(実際は違います！)
そして項目を見るとわかると思いますが、エンティティはアプリの要件定義と表裏一体なのです。ここら辺は調べるといくらでも深い記事が出てくるので割愛します。

関連（リレーション）

関連（リレーション）とは、結び付きのあるエンティティ同士をリンクさせるものです。先ほどの例だとUserとArticle(ツイッターでいうとUserとTweet)が簡単な関連となります。
ここで、「あれ、関連付けって、アソシエーションっていうじゃないの？」と思う方もいらっしゃると思いますが、アソシエーションとリレーションは同じものと思って大丈夫です。

属性(プロパティ)

属性とは、あるエンティティ(Model)に従属する項目のことで、エンティティを1つに定めたときに、一緒に分かる情報だと思ってください。例えば、あるユーザーを指定したら、そのユーザーのemailやアカウント名などがこれにあたります。テーブルのカラムと同じですね。

関連の多重度

関連のあるエンティティAとBについて、片方から他方を見たときに相手が1つなのか、複数なのかということを明らかにすることです。
先ほどの例にすると、Userから見るとArticleは複数、Articleから見るとUserは1つということになります。
すなわち、1つのAからBを見たときおよび1つのBからAを見たときの相手の数を明らかにすることが、多重度を決定するということになります。

・・・・はい、ここまでがデータベースの設計についての基本の概念であり、その中の関連(リレーション)、関連の多重度がまさにアソシエーションにあたります。
アソシエーションとデータベース設計が密接に関わっていること、お分りいただけたでしょうか。

早速難しい話からスタートしてしまいましたが、最初はわからないのは当たり前です。
実際の開発では、設計を完璧に仕上げることがほとんどの場合においてマストですが、とりあえず今回は小さく設計して実装=>また小さく設計&実装という形で一つ一つ確認していきましょう。
では、チュートリアルに入ります！

(ありがちだけど)twitterクローンを作ってみよう

Rails tutorialやその他シラバスなどでおなじみの、twitterクローンでアソシエーションを学んでいきます。
今回学びたいのはアソシエーションの部分のみなので、見栄えやその他細かい機能は必要最低限で行こうと思います。ご了承ください。

それではまずは設計です。設計の時によく使われるのが、ER図というものです。

ER図とは

データベース設計（データモデリング）で使う設計手法です。お絵かきの方法です。
ER図は、データベースが必要なWEBサイトやシステムの設計では必ずと言ってよいほど作成されます。逆に言うと、ER図なしにはデータベースを構築できません。データベース設計の基本中の基本と言える設計手法です。
様々な記法があったりするのですがここではIE記法というものを採用します。(とても簡単です)

IE記法

データベース設計のうち、関連(リレーション)、関連の多重度の二つを決めるものです。要するにアソシエーションを決める記号となります。
上記のデータベース設計で出て来た画像も、ER図であり、IE記法でかかれています。
以下三つの記号から成り立っています。

今回はこれのうち鳥の足(多)を使ってツイッタークローンをシンプルに設計します。

ログイン機能とツイート機能をER図を使って設計しよう

(設計図の作成には Cacooというのを使用していますが、皆さんは手書きで問題ありません。)

最初に言った通り、まずは小さく設計しましょう。UserとTweetについて決めて行きます。

上述の通りエンティティ(Model)はUserとTweetの二つになります。
次にプロパティです。
Userはdeviseというgemを使う予定なので、デフォルトのカラムであるemailとpassword(deviseではencrypted_passwordという名前になっています。)を使って行きましょう。
Tweetは本文(body)のみで大丈夫でしょう。

とりあえずここまでを図に落とし込んでみましょう。

次にアソシエーション部分である、関連と関連の多重度についてです。

UserとTweetは最初に出した例であるUserとArticleの関係と同じであり、一つのUserはTweetを複数持っています。

つまり、UserとTweetは一対多(1:N)の関係というわけです。

なので、ER図はこのようになります。

ただ、ここで注意するべきことがあります。このままだとTweetがどのUserに所属しているのかという情報がありません。

それを設定するために、foreign_keyを設定する必要があります。

foreign_keyとは

まず、データには一つ一つ識別するためのidがあります。これをPrimary Key(主キー)と言い、Railsではidというカラム名でテーブル作成時に標準搭載されています。

そして、foreign keyというのはその親のid(Primary key)を保存するカラムというわけです。
これによりどの親に所属しているのか？というのを識別することができます。

(赤丸のuser_idがforeign_key)

なのでプロパティにforeign_keyを追加しましょう。親のモデル名_idという名前とするとRailsの命名規則により色々便利になるので、user_idとしましょう。
ER図はこのようになります。

これでUser,Tweet部分の設計は完了しました！！では実装して行きましょう。

ようやくプログラミング！

設計の通りに下準備

それではアプリを作成し、ER図の通りにUserとTweetについて準備してきましょう。

※1 $マークはターミナルのコマンドという意味です。実際には打たないでください。
※2 #~~はコメントアウトです。打たなくて大丈夫です。

$rails new association_tutorial
$cd association_tutorial/

Userはログイン機能をつけるため、deviseというgemを使用します。(deviseの詳しい説明は割愛します。こちらの記事がおすすめです。)

Gemfileに以下の記述をしましょう。(色々書いてあると思いますが消さずに追加してください。)

gem 'devise'  # 一番下に追加

ターミナルに戻り、以下のコマンドを打ってください。deviseの機能をインストールし、その機能を取り込んだUserモデルを作成します。

$bundle install  # gemのダウンロード
$rails g devise:install  # deviseの機能のインストール
$rails g devise User  # deviseの機能を取り込んだUserモデルの作成
$rails g controller users index show #(deviseの機能ではない)usersコントローラの作成。今回はindexとshowアクションを用意

カラム(プロパティ)は、deviseのデフォルトのカラムがemailとpasswordとなっており、設計と同じなのでこのままで問題ありません。

次にTweetについてです。(foreign_keyであるuser_idもこのタイミングで追加しています。)

$rails g model Tweet body:text user_id:integer # 要件通りにカラムとその型も一緒に定義。
$rails g controller tweets new index show create

忘れずにテーブルの確定をしましょう。

$rails db:migrate

以下のように表示されればOKです。

そしてルーティングの設定です。以下のように記述してください。

Rails.application.routes.draw do

  root 'tweets#index'  # 追加

# ===========ここはいらないので削除orコメントアウト==========
  #get 'tweets/new'
  #get 'tweets/index'
  #get 'tweets/show'
  #get 'tweets/create'
  #get 'users/index'
  #get 'users/show'
#==================================================

  devise_for :users
  resources :tweets  # 追加
  resources :users  # 追加

  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end

tweets, usersコントローラもサクッと表示部分を書いておきます。

class TweetsController < ApplicationController
  before_action :authenticate_user!, except: [:index]  # deviseのメソッドで「ログインしていないユーザーをログイン画面に送る」メソッド
  def new
    @tweet = Tweet.new # 新規投稿用の空のインスタンス
  end

  def create
    # 後で書きます。
  end

  def index
    @tweets = Tweet.all
  end

  def show
    @tweet = Tweet.find(params[:id])
  end
end

class UsersController < ApplicationController
  before_action :authenticate_user!
  def index
    @users = User.all
  end

  def show
    @user = User.find(params[:id])
  end
end

最後に、レイアウトなどの各ページも作っておきましょう。(フロントがぐちゃぐちゃなのは本当にごめんなさい！パーシャル化はあえてしておりません。)

<!DOCTYPE html>
<html>
  <head>
    <title>AssociationTutorial</title>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
  </head>

  <body>
  <!-- 追加 -->
    <% if user_signed_in? %>  <!-- deviseのメソッドで、「ログインしているかしていないかでtrue or falseを返す」メソッド -->
      <%= link_to "新規投稿", new_tweet_path %>
      <%= link_to "ログアウト", destroy_user_session_path, method: :delete %>
      <%= link_to "マイページ", user_path(current_user.id) %>
    <% else %>
      <%= link_to "新規登録", new_user_registration_path %>
      <%= link_to "ログイン", new_user_session_path %>
    <% end %>
      <%= link_to "ツイート一覧", tweets_path %>
      <%= link_to "ユーザー一覧", users_path %>
  <!-- ここまで -->
    <%= yield %>
  </body>
</html>

<h1>Tweets#new</h1>
<p>Find me in app/views/tweets/new.html.erb</p>

<%= form_for @tweet do |f| %>
  <p>
    <%= f.label :body,"ツイート" %>
    <%= f.text_field :body %>
  </p>
  <%= f.submit %>
<% end %>

<h1>Tweets#index</h1>
<p>Find me in app/views/tweets/index.html.erb</p>

<% @tweets.each do |tweet| %>
  <hr>
  <p><span>ツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>

<h1>Tweets#show</h1>
<p>Find me in app/views/tweets/show.html.erb</p>

<p><span>ツイート内容: </span><%= @tweet.body %></p>

<h1>Users#index</h1>
<p>Find me in app/views/users/index.html.erb</p>

<% @users.each do |user| %>
  <hr>
  <p><span>email: </span><%=link_to user.email, user_path(user.id) %></p>
<% end %>

<h1>Users#show</h1>
<p>Find me in app/views/users/show.html.erb</p>
<hr>
<p><span>email: </span><%= @user.email %></p>

いよいよアソシエーションを記述しよう

さあ、いよいよアソシエーションの記述になります。ER図で言うと棒線の部分がこれにあたります。

・・・と、いってもRailsは命名規則によってものすごくよしなにやってくれるので、記述することはとても少ないです。

has_many

UserはたくさんのTweetを持っています(User has many tweets.)。なので、Userモデルに以下の記述をしてください。

class User < ApplicationRecord
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable

  has_many :tweets  # これを追加
end

このように子の方のモデル名の複数形を書きます。has_manyの方が複数形なことはRailsの命名規則でマストですのでお気をつけください。(英文と同じですね！)

belongs_to

Tweetは一つのUserに所属しています(Tweet belongs to a User.)。
もうおわかりですね。tweetモデルに以下のように記述します。

class Tweet < ApplicationRecord
    belongs_to :user  # これを追加
end

はい、こちらは一つなので単数形です。

そして、これだけの記述だけでアソシエーションをすることができています。tweetsテーブルに追加してあるforeign_keyのuser_idも、モデル名_idとしたおかげで勝手に認識してくれています。railsはこういったところがとてもすごいですね。

コントローラの編集

さて、userとtweetをアソシエーションさせた状態で保存させたいです。なので、tweetを保存するタイミング、要するにtweets#createとストロングパラメータ(tweets_params)を以下のように記述しましょう。

class TweetsController < ApplicationController
  before_action :authenticate_user!, except: [:index]  # deviseのメソッドで「ログインしていないユーザーをログイン画面に送る」メソッド

  def new
    @tweet = Tweet.new  # 新規投稿用の空のインスタンス
  end

  def create
# ============追加================
    @tweet = Tweet.new(tweet_params)  # フォームから送られてきたデータ(body)をストロングパラメータを経由して@tweetに代入
    @tweet.user_id = current_user.id # user_idの情報はフォームからはきていないので、deviseのメソッドを使って「ログインしている自分のid」を代入
    @tweet.save
    redirect_to tweets_path
# =================================
  end

  def index
    @tweets = Tweet.all
  end

  def show
    @tweet = Tweet.find(params[:id])
  end
# ===============追加=============
  private
    def tweet_params
      params.require(:tweet).permit(:body) # tweetモデルのカラムのみを許可
    end
# =================================
end

ここで注意したいポイントは、user_idの情報はフォームから送られていないので、追加で代入してあげないといけないと言うことです。

この場合はdeviseのメソッドであるcurrent_userでログイン中のユーザーの情報が取得できるため(つまりツイートした本人)、current_user.idを@tweet.user_idに代入しています。

これで、アソシエーションをした状態でデータの保存をすることができました！
とりあえず何人か新規登録して、投稿してみましょう。
deviseの新規登録画面 - http://localhost:3000/users/sign_up
新規投稿画面 - http://localhost:3000/tweets/new

ログをみても、きちんとuser_idに代入されているのがわかると思います。

アソシエーションしているデータの受け取り方

ここまででアソシエーションした状態でデータ保存をすることができました。
次は「ユーザーがツイートしたデータ」や、「このツイートをしたユーザー」などといった表示の方法です。

Userがtweetしたデータ

結論から言うと、

@user.tweets

(@userは一つのユーザーのデータです。)
これで「ユーザーに関連したツイート」を取得することができます。
tweetsと複数形になっていることに注意してください。この記述はUserモデルに記述したhas_many :tweetsによって決まっています。
そして、複数形になっていることからもわかりますが、@user.tweetsは複数のツイートが入った配列となっております。

これらを用いて、Usersのコントローラとビューを以下のように変更しましょう。

class UsersController < ApplicationController
  before_action :authenticate_user!
  def index
    @users = User.all
  end

  def show
    @user = User.find(params[:id])
# ===============追加==============
    @tweets = @user.tweets
# ================================
  end
end

<h1>Users#show</h1>
<p>Find me in app/views/users/show.html.erb</p>
<hr>
<p><span>email: </span><%= @user.email %></p>

<!-- 追加 -->
<% @tweets.each do |tweet| %>
  <hr>
  <p><span>ツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>

http://localhost:3000/users/1
このようになっていればうまくいっています。

このtweetをしたUser

こちらも同じように

@tweet.user

このようにすれば「このツイートをしたユーザー」を取得することができます。
こちらもTweetモデルに記述したbelongs_to :userより、単数にすることで取得します。

そして、こちらは単数なので、取得したデータも一つのみです。

なので、Tweetsコントローラとビューは以下のようになります。

class TweetsController < ApplicationController
  before_action :authenticate_user!, except: [:index]  # deviseのメソッドで「ログインしていないユーザーをログイン画面に送る」メソッド

  def new
    @tweet = Tweet.new  # 新規投稿用の空のインスタンス
  end

  def create
    @tweet = Tweet.new(tweet_params)  # フォームから送られてきたデータ(body)をストロングパラメータを経由して@tweetに代入
    @tweet.user_id = current_user.id # user_idの情報はフォームからはきていないので、deviseのメソッドを使って「ログインしている自分のid」を代入
    @tweet.save
    redirect_to tweets_path
  end

  def index
    @tweets = Tweet.all
  end

  def show
    @tweet = Tweet.find(params[:id])
# ===============追加==============
    @user = @tweet.user
# ================================
  end

  private
    def tweet_params
      params.require(:tweet).permit(:body) # tweetモデルのカラムのみを許可
    end
end

<h1>Tweets#show</h1>
<p>Find me in app/views/tweets/show.html.erb</p>

<p><span>email: </span><%= @user.email %></p> <!-- 追加 -->
<p><span>ツイート内容: </span><%= @tweet.body %></p>

indexもemailを表示させちゃいましょう。

<h1>Tweets#index</h1>
<p>Find me in app/views/tweets/index.html.erb</p>
<% @tweets.each do |tweet| %>
  <hr>
  <p><span>email: </span><%=link_to tweet.user.email, user_path(tweet.user.id) %></p> <!-- 追加 -->
  <p><span>ツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>

ちょっと見慣れないかもしれないですが、このようにtweet.user.emailなど、メソッドチェーンで関連先を一気に取得することも可能です。(あまり長くなりすぎるとプログラムの可読性が悪くなるので注意！)

これで一対多の実装ができました！！！ひとまずお疲れ様です。

一対多まとめ

• 親子関係を考え、子供に親のid(foreign_key)が入るカラムを追加
• 親側モデルにhas_many :子供のモデル名の複数形、子供側モデルにbelongs_to :親のモデル名(単数形)と記述
• 関連したモデルの情報は、関連元のモデルのインスタンス.関連先のモデル名で取得可能。関連先のモデル名は、関連元のモデルに記述した関連先の名前が入る。(has_manyなら複数、belongs_toなら単数。)

お気に入り機能をER図を使って設計しよう

さて、次はお気に入り機能の実装です。ここまででめちゃめちゃ長くなってしまいましたが、気合いで頑張っていきましょう！

お気に入り機能とはどういう機能なのか？

お気に入りとは、ユーザーがツイートに対してつける印だとみなすことができます。

また片方ずつ考えていきましょう。
ユーザーは「たくさんのツイートをお気に入り」することができます。

逆も考えてみます。
「ツイートはたくさんのユーザーにお気に入り」されます。

このように「ユーザーもツイートもたくさん持っている」関係を多対多(M:N)の関係といいます。

多対多(M:N)を設計しよう

それではER図に落とし込んでいきたいのですが、Railsでは多対多の関係をUserモデル、Tweetモデルのみでは実装することができません。

実装するためには、中間テーブルというものが必要です。

中間テーブルとは

多対多をプログラムで実装するためには、お互いがお互いのforeign_keyを知らなくてはなりません。

ですが「複数のuserによってどんどんファボが増えていった」場合、画像のように配列にどんどん追加していくか、カラムをtweetsテーブルにどんどん追加しなくてはならず、非常に面倒です。

そのような状態を避けるために、お互いのidだけを保存するテーブルが必要となります。

それを、中間テーブルといいます。

これで「どうやってお気に入り数や、誰のお気に入りなのかを判断するの？」と思うかもしれませんが、それは中間テーブルに保存されるtweet_idとuser_idで判断しています。

例えば、「あるツイートについたお気に入り数」をみたいときは、そのtweet_idと同じレコードに保存されているuser_idの数を見ればよく、

「あるユーザーのお気に入りしたツイート」がみたいときは、そのuser_idと同じレコードに保存されているtweet_idから、ツイートを検索すれば良いことになります。

中間テーブルを使ってER図の作成

それでは中間テーブル込みのER図を作っていきましょう。

通常、中間テーブルはテーブル1_テーブル2の複数系(user_tweets)などとつけることが多いですが、今回中間テーブルの意味が「お気に入り登録」とはっきりわかっているため、favoritesテーブルとしてしまいましょう。

中間テーブルはたくさん持たれる側(どちらにもbelongs_to)なのに注意してください。
それでは、これを実装していきましょう！

設計の通りに下準備

設計の通り、Favorite関連のコントローラ、モデル、テーブルを作成します。

$rails g model Favorite user_id:integer tweet_id:integer
$rails g controller favorites create destroy
$rails db:migrate

あとはルーティングですが、後々のことを考えて、tweetsにネストしたルーティングを作成しましょう。
下記のようにdo ~ endの中に入れる形で書くことを、ネスト(入れ子)すると言います。

Rails.application.routes.draw do
  #==================削除orコメントアウト================
  # get 'favorites/create'
  # get 'favorites/destroy' 
  #=====================================
  root 'tweets#index'
  devise_for :users

  # ================ここをネスト(入れ子)した形に変更
  resources :tweets do
    resource :favorites, only: [:create, :destroy]
  end
  #======================================

  resources :users 
  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end

理由としては、お気に入り時に、foreign_keyの一つであるtweet_idを取得するのが楽になるからです。(一対多の時もそうでしたが、foreign_keyを取得しないとリレーションができません。)

詳しくはこちら - Railsのルーティングを極める(後編)

また、favoriteの詳細ページは作らない、つまりfavoriteのidは要らず省略したいため、resourceと、単数形のメソッドを利用しています。

rails routesでルーティングを確認すると、以下のようにfavoritesのcreateとdestroyに:tweet_idが含まれ、かつ:id(:favorite_id)が省略された形で生成されているのがわかると思います。

これで下準備は完了です。

アソシエーションの記述

中間テーブルfavoritesはたくさん持たれる側なので、このようになります。

class Favorite < ApplicationRecord
    belongs_to :user
    belongs_to :tweet
end

したがって、User, Tweetモデルも以下のようになります。

class User < ApplicationRecord
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable

  has_many :tweets
  has_many :favorites  # 追加
end

class Tweet < ApplicationRecord
    belongs_to :user
    has_many :favorites  # 追加
end

これでアソシエーションが組めたので、
@user.favoritesや@tweet.favoritesなどでそれぞれに関連したお気に入り(実際にはuser,tweetのidの2つ組の情報)が取得できるようになりました。
・・・が、viewを作る前に、一つ注意しなくてはならないことがあります。

お気に入り機能は登録だけでなく解除もできなくてはならないことです。
そのため、Tweetモデルに「このツイートをユーザーがファボしているかどうか」を判定するメソッドを用意しましょう。

ユーザーがツイートをお気に入りしたかどうかの判定メソッド

「ツイートがファボしてあるかどうか」を判定したいので、Tweetモデルに以下のように記述しましょう。

class Tweet < ApplicationRecord
    belongs_to :user
    has_many :favorites

# 追加
    def favorited_by?(user)
        favorites.where(user_id: user.id).exists?
    end
end

これは、Tweetのインスタンスメソッドなので、ビューなどで

if @tweet.favorited_by?(current_user)

という風に使うことができます。これはつまり

if @tweet.favorites.where(user_id: current_user.id).exists?

ということと同じなので、アソシエーションの記述である@tweet.favoritesの中に、引数で送られたuserのidがあるかどうか？ということを判定していることになります。

インスタンスメソッドについてはこちら - Rubyのクラスメソッドとインスタンスメソッドの例

それではお気に入りボタンを作っていきましょう。

お気に入りボタンの実装

tweetsのindexに実装します。先ほど定義したfavorited_by?を早速使います。
countメソッドで、配列の中の要素数を取得しており、そしてそれがそのままお気に入りの数となります。

<h1>Tweets#index</h1>
<p>Find me in app/views/tweets/index.html.erb</p>
<% @tweets.each do |tweet| %>
  <hr>
  <p><span>email: </span><%=link_to tweet.user.email, user_path(tweet.user.id) %></p>
  <p><span>ツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
  <!-- 追加 -->
  <% if user_signed_in? %>
    <% if tweet.favorited_by?(current_user) %> <!-- ログインしているユーザーがファボしたかどうかで分岐 -->
        <p><span>お気に入り解除: </span><%=link_to tweet.favorites.count, tweet_favorites_path(tweet.id), method: :delete %></p>
    <% else %>
        <p><span>お気に入り登録: </span><%=link_to tweet.favorites.count, tweet_favorites_path(tweet.id), method: :post %></p>
    <% end %>
  <% else %>
    <p><span>お気に入り数: </span><%= tweet.favorites.count %></p>
  <% end %>
  <!-- ここまで -->
<% end %>

お気に入り登録の時はmethod: :post
お気に入り解除の時はmethod: :deleteにすることに注意してください。rails routesでVerbのところをきちんと確認しましょう。

あとはコントローラです。

FavoritesControllerの実装

繰り返しますがURIに:tweet_idが含まれており、tweet_favorites_path(tweet.id)と引数でtweetのidを送ってあるので、params[:tweet_id]とすればお気に入り登録しようとしているツイートのidが取得できます。

class FavoritesController < ApplicationController
  def create
    # こう記述することで、「current_userに関連したFavoriteクラスの新しいインスタンス」が作成可能。
    # つまり、favorite.user_id = current_user.idが済んだ状態で生成されている。
    # buildはnewと同じ意味で、アソシエーションしながらインスタンスをnewする時に形式的に使われる。
    favorite = current_user.favorites.build(tweet_id: params[:tweet_id])
    favorite.save
    redirect_to tweets_path
  end

  def destroy
    favorite = Favorite.find_by(tweet_id: params[:tweet_id], user_id: current_user.id)
    favorite.destroy
    redirect_to tweets_path
  end
end

ポイントは

current_user.favorites.build(tweet_id: params[:tweet_id])

です。これは、current_userに関連したFavoriteインスタンスを生成しています。なので、Favoriteのプロパティはすでにuser_id: current_user.idが代入されております。
あとは残りのtweet_idにviewから送られてきたparams[:tweet_id]を代入するだけです。(params[:id]ではないことに注意！ルーティングで生成されるURIを見ればparams[:tweet_id]であることを確認できます。)

これにより、お気に入り登録&解除を行うことができるようになりました！
http://localhost:3000/tweets

has many through

中間テーブルに保存されている情報はそれぞれの親idでしかないので、直接取得しviewに表示しようと思うと、少しコツがいります。

# コントローラ
  def show
    @user = User.find(params[:id])
    @tweets = @user.tweets
    # mapメソッドを使いfavoriteをtweetの情報に変換
    @favorite_tweets = @user.favorites.map{|favorite| favorite.tweet}
  end
end

<!-- ビュー -->
<% @favorite_tweets.each do |tweet| %>
  <hr>
  <p><span>ファボツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>

このように、mapメソッドでfavoritesの情報をtweetの集まりに変換してあげなくてはいけません。

ですが、has many throughを使えば、ユーザーがファボしたツイートを直接アソシエーションで取得することができます。

このように実装します。

class User < ApplicationRecord
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable

  has_many :tweets
  has_many :favorites
  has_many :favorite_tweets, through: :favorites, source: :tweet  # 追加
end

source

sourceは「参照元のモデル」をさすオプションです。
これを指定することでアソシエーションでメソッドチェーンする時の名称を変更することができます。

本当はhas_many :tweets, through: :favorites
と記述したいのですが、上のhas_many :tweetsと重複してしまうため、favorite_tweetsと名称を変更しています。

has many throughを使った「ユーザーがファボしたツイートの表示」

これで、@user.favorite_tweetsとやることで、「ユーザーがファボしたツイート」を取得することができるようになりました。

それでは、Usersコントローラ、ビューも以下のように変更してください。

class UsersController < ApplicationController
  def index
    @users = User.all
  end

  def show
    @user = User.find(params[:id])
    @tweets = @user.tweets
    @favorite_tweets = @user.favorite_tweets # 追加
  end
end

<h1>Users#show</h1>
<p>Find me in app/views/users/show.html.erb</p>
<hr>
<p><span>email: </span><%= @user.email %></p>

<% @tweets.each do |tweet| %>
  <hr>
  <p><span>ツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>
<!-- 追加 -->
<% @favorite_tweets.each do |tweet| %>
  <hr>
  <p><span>ファボツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>

これでファボ機能が実装できました、確認してみましょう！！
http://localhost:3000

コメント機能も作ってみよう

コメント機能も多対多となります。

ここまでの知識があればきっと実装することができると思うので、是非ともやってみてください！
最後にソースコードを置いておきます。

ヒント

・中間テーブルに文章を入れれるカラムを追加

・「一回コメントした人も何度もコメントできるようにするか」はあなたの自由(favorited_by?の話です)

・form_for の引数に渡すインスタンスに注意

ネストしてあるコントローラへのルーティングは、form_forの場合

<%= form_for([@tweet, @comment]) do |f| %>

のように、配列で二つ([関連元のインスタンス, 関連先のインスタンス])渡す必要があります。

多対多まとめ

• Railsでは多対多を実装するために中間テーブルが必要。
• 中間テーブル側が子供(たくさん持たれる方)となるので、belongs_to :親1 belongs_to :親2と書こう.
• 親側はもちろんhas_many :中間テーブルの名前の複数形
• has_many_throughを使うと記述が省略できるので積極的に使おう
• has_many_throughを使うときに指定するsourceは参照元のモデル名なのに注意
• 「ファボしてるかしていないか」、という判定のメソッド(今回はfavorited_by?)を用意することに注意(コメントなど、用意しなくてもいい時もある)

#フォロー、フォロワー機能をER図を使って設計しよう

いよいよラストです！（本当に長かった）最後に、ユーザーフォロー機能を追加していきます。

フォロー、フォロワー機能とはどういう機能なのか？

結論から言うとフォローする側のユーザー、フォローされる側のユーザーというユーザー同士の多対多となります。

とりあえず多対多なので中間テーブルは必要そうです。
しかし、ご存知の通りUserモデルは一つしかなく、今のままだとフォローする側のユーザー、フォローされる側のユーザーがどれだか全くわかりません。

なので、ユーザーモデルをフォローする側、される側にうまく切り分けることがこの実装の鍵となります。

そしてこのような自分自身との結合のことを自己結合と言います。自己結合は多対多だけでなく、一対多でもあり得ます。(雇用者モデルにおいて、管理者:従業員の１対多など)

UserとUserの多対多(M:N)を設計しよう(自己結合)

ユーザーモデルは一旦忘れて考えましょう。
FollowingモデルとFollowerモデルがあったとします。(フォローする方とされる方)

これらはもちろん多対多で関連しているため、中間テーブルが存在します。関連を表現しているため、Relationshipモデルと名付けます。
中間テーブルなので各親テーブルのprimary_keyをforeign_keyとして保存したいです。
なので、

following_idにはFollowingモデルのidを
follower_idにはFollowerモデルのidを
Relationshipのforeign_keyに設定すれば良いと言うことがわかります。

こうすればやることは普通の多対多と同じです。

• Followingから見て、Followerを(Relationshipを介して)集める
• Followerから見て、Followingを(Relationshipを介して)集める

と言うことになります。

ここでふた通りのRelationshipを考えなくてはならないのは、プログラムで記述するときにわかります。

これをUserモデルに直して考えると、

• フォローする側のUserから見て、フォローされる側のUserを(中間テーブルを介して)集める
• フォローされる側のUserから見て、フォローしてくる側のUserを(中間テーブルを介して)集める

と言うことになります。

ヒジョーーにややこしくなってきましたが、ここまで落とし込めば十分にRailsで実装可能です。やっていきましょう！

設計の通りに下準備

ここは今までと同じく、設計通りにコマンドを打ち込むだけです。(中間テーブルの名前はRelationshipsとしました。)

$rails g model relationship following_id:integer follower_id:integer
$rails g controller relationships create destroy
$rails db:migrate

favoriteの時と同じく、親であるuserのidが欲しいため、usersの中にネストしましょう。
また、フォロー一覧、フォロワー一覧の画面も用意したいため、follows, followersと言うアクションへのルーティングを作ります。on memberメソッドを使います。
詳細 - Railsのルーティングを極める(後編)

Rails.application.routes.draw do

  #==================削除orコメントアウト================
  # get 'relationships/create'
  # get 'relationships/destroy'
  #=====================================
  root 'tweets#index' 

  devise_for :users

  resources :tweets do
    resource :favorites, only: [:create, :destroy]
  end

  # ================ここをネスト(入れ子)した形に変更
  resources :users do
    resource :relationships, only: [:create, :destroy]
    get :follows, on: :member # 追加
    get :followers, on: :member # 追加
  end
  #======================================
  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
end

まだviewやコントローラも触れていませんが、先にアソシエーションの記述を完成させます。

アソシエーションの記述

いよいよアソシエーションの記述です。

中間テーブルRelationshipモデルの設定

とりあえず、Userモデルと言う呼び方はやめてFollowing, Followerと言うモデル名に変更したいです。
そしてそれはclass_nameと言うオプションを使えば実現できます。

class_name

:class_name - 関連するモデルクラス名を指定。関連名と参照先のクラス名を分けたい場合に使う
ものとなります。

これを使うことにより

belongs_to 変更したい親モデル名, class_name: "元々の親モデル名"

とすることができます("元々の親モデル名"は文字列なのに注意！)。これでFollowモデル、Followerモデルを擬似的に作り出すことができそうです。

実際、Relationshipsテーブルのforeign_keyとしてfollowing_id、follower_idと名前をつけており、モデル名もFollowing, Followerとすれば帳尻が合います。
Relationshipモデルにそれぞれ所属先を定義しちゃいましょう。

class Relationship < ApplicationRecord
    belongs_to :following, class_name: "User"
    belongs_to :follower, class_name: "User"
end

Userモデルの設定

Relationshipモデル側にFollowing, Followerモデルに所属している、と言うことを定義してありますので、それをうまく使えば良さそうです。

ここで、設計の時に決めた自己結合の文句を確認してみましょう。

• フォローする側のUserから見て、フォローされる側のUserを(中間テーブルを介して)集める。
• フォローされる側のUserから見て、フォローしてくる側のUserを(中間テーブルを介して)集める。

です。
ですが、とりあえずこの通りに記述しようとしても、has_many :relationshipsをふた通り書かなくてはならないため、名前被りが起きてしまいます。なので、フォローする側、される側ふた通りの中間テーブルの名前を再定義しなくては行けなさそうです。

今回は、

• フォローする側のUserからみたRelationshipをactive_relationship
• フォローされる側のUserからみたRelationshipをpassive_relationship

としてみます。

参照元のモデルは先ほどもやったclass_name: "Relationship"と指定すれば良いだけなので、

has_many :active_relationships, class_name: "Relationship"
has_many :passive_relationships, class_name: "Relationship"

となります。

ですがこれだとまだ、親モデルの外部キーがなんなのかという情報が足りません。
active_relationshipで言うと「フォローする側のUserからみた」と言う情報が足りていない、と言うことになります。

そこで親モデルの外部キー指定するオプションとして、foreign_keyと言うのがあります。

foreign_key

:foreign_key - 参照先のテーブルの外部キーのカラム名を指定できる
これにそれぞれfollowing_id, follower_id、つまり親のprimary_keyを指定してあげれば、「フォローする側のUserからみた」と言う情報も取得することができます。

よって、最終的なUserモデルの最終的なアソシエーションの記述は以下のようになります。

class User < ApplicationRecord
  # Include default devise modules. Others available are:
  # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable

  has_many :tweets
  has_many :favorites
  has_many :favorite_tweets, through: :favorites, source: :tweet

  # ====================自分がフォローしているユーザーとの関連 ===================================
  #フォローする側のUserから見て、フォローされる側のUserを(中間テーブルを介して)集める。なので親はfollowing_id(フォローする側)
  has_many :active_relationships, class_name: "Relationship", foreign_key: :following_id
  # 中間テーブルを介して「follower」モデルのUser(フォローされた側)を集めることを「followings」と定義
  has_many :followings, through: :active_relationships, source: :follower
  # ========================================================================================

  # ====================自分がフォローされるユーザーとの関連 ===================================
  #フォローされる側のUserから見て、フォローしてくる側のUserを(中間テーブルを介して)集める。なので親はfollower_id(フォローされる側)
  has_many :passive_relationships, class_name: "Relationship", foreign_key: :follower_id
  # 中間テーブルを介して「following」モデルのUser(フォローする側)を集めることを「followers」と定義
  has_many :followers, through: :passive_relationships, source: :following
  # =======================================================================================

  def followed_by?(user)
    # 今自分(引数のuser)がフォローしようとしているユーザー(レシーバー)がフォローされているユーザー(つまりpassive)の中から、引数に渡されたユーザー(自分)がいるかどうかを調べる
    passive_relationships.find_by(following_id: user.id).present?
  end
end

先ほどまでの話にプラスして、has many throughで(中間テーブルを介して)followingsの時はfollowerを、followersの時はfollowingを集める記述をしています。
もちろんsourceでモデルの参照元を指定しています。
followingsで集めるUserはフォローされる側(follower)。逆も然りです。

以下の画像は、これまでの自己結合アソシエーションの記述をまとめたものです。

favoriteと同じく、Userがfollow済みかどうか判定したいため、followed_by?と言うメソッドも追加しています。

これでUserモデルのアソシエーションの記述も完了です。

残るはcontroller、viewを実装です！

コントローラ、ビューの実装

これで本当にチュートリアルは最後です。頑張っていきましょう！！！

ビューページの実装

(最後にある完成版のソースコードに、もう少し綺麗にしたviewファイルの奴も置いてあるので、もしよろしければそちらも参考ください。)

フォローボタンの実装

<h1>Tweets#index</h1>
<p>Find me in app/views/tweets/index.html.erb</p>
<% @tweets.each do |tweet| %>
  <hr>
  <p><span>email: </span><%=link_to tweet.user.email, user_path(tweet.user.id) %></p>
  <p><span>ツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
  <% if user_signed_in? %>
    <% if tweet.favorited_by?(current_user) %> <!-- ログインしているユーザーがファボしたかどうかで分岐 -->
        <p><span>お気に入り解除: </span><%=link_to tweet.favorites.count, tweet_favorites_path(tweet.id), method: :delete %></p>
    <% else %>
        <p><span>お気に入り登録: </span><%=link_to tweet.favorites.count, tweet_favorites_path(tweet.id), method: :post %></p>
    <% end %>

    <!-- ここを追加 -->
    <% if current_user != tweet.user %>
        <% if tweet.user.followed_by?(current_user) %>
            <p><%=link_to "フォロー済み", user_relationships_path(tweet.user.id), method: :delete %></p>
        <% else %>
            <p><%=link_to "フォローする", user_relationships_path(tweet.user.id), method: :post %></p>
        <% end %>
    <% end %>
    <!-- ここまで -->

  <% else %>
    <p><span>お気に入り数: </span><%= tweet.favorites.count %></p>
  <% end %>
<% end %>

<h1>Users#index</h1>
<p>Find me in app/views/users/index.html.erb</p>

<% @users.each do |user| %>
  <hr>
  <p><span>email: </span><%= link_to user.email, user_path(user.id) %></p>
    <!-- ここを追加 -->
    <% if current_user != user %>
        <% if user.followed_by?(current_user) %>
            <p><%=link_to "フォロー済み", user_relationships_path(user.id), method: :delete %></p>
        <% else %>
            <p><%=link_to "フォローする", user_relationships_path(user.id), method: :post %></p>
        <% end %>
    <% end %>
    <!-- ここまで -->
<% end %>

自分をフォローする自体は避けたいので、if current_user != userで自分をのぞいた人たちのみボタンを表示するような実装にしています。あとはほとんどfavoriteボタンと同じですね。

tweetsのshowページは省略します。理屈がわかっていれば絶対にできるはずです、やってみましょう！
次にコントローラです。

relationshipsコントローラの実装

class RelationshipsController < ApplicationController
  def create
    follow = current_user.active_relationships.build(follower_id: params[:user_id])
    follow.save
    redirect_to users_path
  end

  def destroy
    follow = current_user.active_relationships.find_by(follower_id: params[:user_id])
    follow.destroy
    redirect_to root_path
  end
end

favoriteの時と同じくcurrent_user.active_relationships.buildとすることで「following_id: current_user.id」を代入しながらインスタンスを作成することができます。

最後に、フォロー、フォロワー一覧を実装しましょう。

usersコントローラの実装

class UsersController < ApplicationController
  before_action :authenticate_user!
  def index
    @users = User.all
  end

  def show
    @user = User.find(params[:id])
    @tweets = @user.tweets
    @favorite_tweets = @user.favorite_tweets
  end

# ==============追加================
  def follows
    user = User.find(params[:id])
    @users = user.followings
  end

  def followers
    user = User.find(params[:id])
    @users = user.followers
  end
# ==============追加================
end

ビューの実装

follows, followersのビューは作っていなかったので、このタイミングで新規作成してください。

<h1>Users#follows</h1>
<p>Find me in app/views/users/follows.html.erb</p>

<% @users.each do |user| %>
  <hr>
  <p><span>email: </span><%= link_to user.email, user_path(user.id) %></p>
    <% if current_user != user %>
        <% if user.followed_by?(current_user) %>
            <p><%=link_to "フォロー済み", user_relationships_path(user.id), method: :delete %></p>
        <% else %>
            <p><%=link_to "フォローする", user_relationships_path(user.id), method: :post %></p>
        <% end %>
    <% end %>
<% end %>

<h1>Users#followers</h1>
<p>Find me in app/views/users/followers.html.erb</p>

<% @users.each do |user| %>
  <hr>
  <p><span>email: </span><%= link_to user.email, user_path(user.id) %></p>
    <% if current_user != user %>
        <% if user.followed_by?(current_user) %>
            <p><%=link_to "フォロー済み", user_relationships_path(user.id), method: :delete %></p>
        <% else %>
            <p><%=link_to "フォローする", user_relationships_path(user.id), method: :post %></p>
        <% end %>
    <% end %>
<% end %>

<h1>Users#show</h1>
<p>Find me in app/views/users/show.html.erb</p>
<hr>
<p><span>email: </span><%= @user.email %></p>

<!-- 追加 -->
<p><%=link_to "フォロー", follows_user_path(@user.id) %></p>
<p><%=link_to "フォロワー", followers_user_path(@user.id) %></p>
<% if current_user != @user %>
    <% if @user.followed_by?(current_user) %>
        <p><%=link_to "フォロー済み", user_relationships_path(@user.id), method: :delete %></p>
    <% else %>
        <p><%=link_to "フォローする", user_relationships_path(@user.id), method: :post %></p>
    <% end %>
<% end %>
<!--ここまで -->

<% @tweets.each do |tweet| %>
  <hr>
  <p><span>ツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>

<% @favorite_tweets.each do |tweet| %>
  <hr>
  <p><span>ファボツイート内容: </span><%=link_to tweet.body, tweet_path(tweet.id) %></p>
<% end %>

以上でフォロー機能の実装は完了です！！本当におつかれさまでした！！！！！！

http://localhost:3000

自己結合多対多まとめ

• User同士の関連付けなので、名前の重複が色々起きてしまう。そこはclass_nameオプションを使って名称変更しよう。その時のforeign_keyの指定も忘れずに。
• followする側が持つのはfollower達。つまりforeign_keyはfollowing_idなのに注意(逆も然り)
• あとは普通の多対多とだいたい同じ

完成版のソースコード

そのまま実装 - https://github.com/mormorbump/association_tutorial
リファクタリング済み(ヴァリデーション、パーシャル化済み) - https://github.com/mormorbump/association_tutorial_refactor
heroku - https://rails-association-tutorial.herokuapp.com
丁寧すぎるherokuへのデプロイの方法はこちら - 【初心者向け】railsアプリをherokuを使って確実にデプロイする方法【決定版】

まとめ

・・・・・・・・・・・・・・・・・・・・・・・はい、本当に長くなってしまいましたが(本当に長くなった)、これでアソシエーションの根幹の部分はほぼ全て抑えられたと思います。
アソシエーションだけに絞ったため細かい実装部分は色々足りていません(validationとか)。そこはご了承ください。
dependentオプションやscopeなども本当はやりたかったのですが、ここまで説明すれば独学でいけるだろうと思い割愛しました。興味があれば調べてみるのをオススメします。
ではみなさん、素敵なRailsライフをお過ごしくださいませ。ありがとうございました！

(最後に僕のバンドのMVを置いておきます)
https://www.youtube.com/watch?v=6bj2idcHdqk
https://www.youtube.com/watch?v=StMZoXUMPng
https://youtu.be/q_UVKz1P2CI
https://www.youtube.com/watch?v=kPnydGG5cps

ポリモーフィック関連(おまけ)

※コメント機能を実装してある前提で進めます。

いつか書きます。

はじめに

いきなりですが、普段インスタグラムを使っているなら
せっかくだしたくさんの人にフォローされてみたいし、いいねされたくないですか？
プログラミングの経験を身近なSNSで活かせたら楽しそうですよね！

自分も、せっかく投稿したんだし、出来ればたくさんの人に見てもらいたい！
たまたま見てくれた方々のフォローを待つのはなかなかもどかしい〜！！
ズボラだから簡単にフォロワー・いいねを増やしたいなんて思ったわけです。

そこで、instabotを使ってみたよってお話です✌🏻

対象者

• インスタグラムをやっている方
• インスタグラムのフォロワーを増やしたい方
• プログラミング経験者

instabotって？？

簡単にいうとインスタグラムの自動いいねツールです。
(いいね以外の機能もありますが今回は割愛👻)

いいね・フォロワーが増える流れ

インスタグラムの投稿にはハッシュタグがつけられます。
instabotではハッシュタグを指定して、紐づいている投稿に「いいね」をしにいきます。
いいねされたユーザーは自分のアカウントに気づいて閲覧してくれて、
その中でも興味を持ったユーザーはいいね・フォローをしてくれます。

一見「たかがいいね」「それで増えるの？」なんて疑いの目を向けたくなりますが、
自分が作成したテストアカウントでは一週間に
140フォロワー増えました👏🏻👏🏻

botは気分で動かしたり、しなかったりですが日々こんな感じ↓
知らない喫茶店知ってる人を自然と知れたりと個人的に大満足。

10件前後だった投稿のいいねも400件つくことも！
プロフィールのアクセス数も1800件を超えたり！

インサイトを見るのがたのしい〜〜

合わせて使うとたのしい分析ツール「インサイト」について

個人のアカウントでも自分のアカウントへのアクセス数や
フォロワーの男女比・国籍などのデータが見られるようになります。
https://gaiax-socialmedialab.jp/post-51356/

ここから実装☝🏻

自分の環境

• Python 3.7.0
• anaconda 1.7.2
• OS Mojave(10.14)/high sierra/sierra(10.12.5)で動作確認済み

導入方法

anacondaでbotの実行環境をつくる

今回使用するinstabotはPythonで書かれているため、Pythonが実行できる環境を
構築する必要があります。
Pythonの環境構築するためにanacondaをインストールする必要があります。

1. サイトからanacondaのインストーラをダウンロード https://www.anaconda.com/download/#macos

　Python 3.7 version *を選択

その際にブラウザ上に表示されるモーダルウインドウは❎ボタンで消して大丈夫です！

2. インストーラの実行。インストール先はルート以下の~/anaconda3です(VSCodeは使わなくても大丈夫なので任意)
3. プロジェクトでもpythonコマンドを実行できるようにPathを通す
　以下のコマンドはフルパスなのでどこのディレクトリで実行していただいても構いません。

$ vi ~/.bash_profile

.bash_profileに以下のpathを記述

# added by Anaconda3 4.3.0 installer                                                
export PATH="/path/to/anaconda/bin:$PATH"

4.忘れずに変更を適用

$ source ~/.bash_profile

これでプロジェクトディレクトリ以下でもpython3コマンドを実行できるようになります。
念の為、ここでバージョンを確認します。

$ python3 --version

バージョンは3.0以上になっていれば大丈夫です。

ここまでで環境設定は終わりです。

botの実行

1. まず、gitHubからソースコードをDesktop内にclone。

[ソース] https://github.com/instabot-py/instabot.py

$ git clone https://github.com/instabot-py/instabot.py.git

2.完了したらcd instabot.pyでプロジェクト内に移動。
プロジェクト名が.pyなの、ちょっと気持ち悪いですね〜🤧気になる方は変更を！

1. プロジェクトに必要なモジュールをインストールする。anacondaによりpipコマンドを使えるようになっているので以下を実行。

※pip --versionで18.1ならここは飛ばしてください。

$ pip install --upgrade pip

4.以下のコマンドで必要なモジュールをインストールする

$ pip install -r requirements.txt

以下のようなlogになれば完了です。

余談：　pipコマンドがpip3じゃなくてもいい理由。。 https://teratail.com/questions/46066

5.ファイルの編集
example.pyを適当なエディタで開いてください。
変更箇所で囲まれている行を適宜自分のアカウントに合わせて書き換えてください。
また、今回使用する機能はいいね機能のみなので
以下のコードで、コメントやフォローの機能は初期値を0などに変更しています。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import time

from src import InstaBot
from src.check_status import check_status
from src.feed_scanner import feed_scanner
from src.follow_protocol import follow_protocol
from src.unfollow_protocol import unfollow_protocol

#login:user:自分のアカウント名
#passward:自分のパスワード
#like_per_day:1日にいいねする数
#comments_per_day:1日にコメントする数
#tag_list:いいねするハッシュタグリスト
#tag_blacklist:入っていたら、いいねしないハッシュタグリスト
#max_like_for_one_tag:１つのタグに対して最大どのくらいいいねするか
#follow_per_day:1日にフォローする数
#unfollow_per_day:1日にアンフォローする数
#unfollow_break_min:最小でどのくらいフォロワーを減らすか
#unfollow_break_max:最大でどのくらいフォロワーを減らすか
#log_mod:0=コンソールにログを表示　1=ファイルにログを残す　2=ログ残さない

# ----変更箇所----
bot = InstaBot(
    login="userName", 
    password="password", 
    like_per_day=5000, 
    comments_per_day=0,
    tag_list=['純喫茶', '喫茶部', '喫茶店', '純喫茶コレクション', '珈琲'], 
    tag_blacklist=[],
    user_blacklist={},
    max_like_for_one_tag=5,
    tag_blacklist=[],               
    user_blacklist={},              
    follow_per_day=0,               
    follow_time=1 * 60,             
    unfollow_per_day=0,             
    unfollow_break_min=0,           
    unfollow_break_max=0,           

# ----変更箇所----
# 以下略

変更後の保存をお忘れなく！

6.ファイルを保存したら実行(instabot.pyディレクトリ内で)

$ python3 example.py

を実行

こんな感じでログインしていいねが実行されていきます。
インスタグラムの
止めるときはControl + Cで止まります。

おわり✌🏻

注意事項

無理にいいね数をあげると、いいね機能が停止されます😢😢目安として。。。。
一日平均3000いいねが限界のような気がしました🌴
ただしbotの一定時間当たり(1分とか１時間単位)のいいね数が
安定しないので1日あたりのいいね数は多めに5000とかの設定で様子見ると良いと思います。
上手な運用方法は研究中です〜〜〜むずかしい😭

instabot.pyがプログラムの大半を動かしているのでtime.sleepを挟んでみたり色々いじっ
てみてください！

参考サイト

参考サイト: https://garmentshack.jp/instabot/
ソース: https://github.com/instabot-py/instabot.py

ファイル解説: https://review-of-my-life.blogspot.com/2017/12/python-instagram-instabotpy.html

[おまけ]エラーについて

実行時にこうなってしまったら

ログイン情報を誤っている可能性が高いので見直してみてください。

これはいいね機能に規制がかかってしまっています。Control + Cで停止して様子を見てください。

Rubyの学習をはじめたばかりのときにつまずくポイントとして「クラス」というものがあります。
この記事ではRubyにおける「クラス」とは何か「インスタンス」とは何かを初心者の方にもわかりやすいように解説していきたいと思います。

この記事の概要

・Rubyにおける「クラス、インスタンス」の概念の説明
・「インスタンス変数、インスタンスメソッド」の説明
・「クラス変数、クラスメソッド」の説明

前提知識　「Rubyの全てのデータはオブジェクトとして扱う」

Rubyは全てのデータをオブジェクトとして扱います。そのデータ自体がメソッドを持っています。

「クラス」の概念

Rubyにおけるクラスとは「オブジェクトの種類を表すもの」、「一種のデータ型」であるとされます。

オブジェクトの種類を表すもの？？と疑問に思った方もいらっしゃると思うので解説してきます。前提知識で述べたようにRubyでは全てのデータをオブジェクトとして扱います。

そのオブジェクトごとに対象となるデータとメソッドが変わってきます。
例えば文字列オブジェクトなら文字列を扱い、数値オブジェクトなら数値を扱います。
そしてオブジェクトはなんらかのクラスに必ず属しています。
そのオブジェクトが属しているクラスごとに使えるメソッドが変わります。

クラスが定義されていることによって共通点を持ったデータを保存しやすくなったり、扱えるメソッドをまとめておくことができます。

Rubyではクラスはもとから定義されているものもあります。どのようなものが定義されているかはこちらのドキュメントをご覧ください　https://docs.ruby-lang.org/ja/latest/library/_builtin.html

またこれらの他にクラスは自分で定義することもできます。クラスの定義は以下のようになります。

 class Human

 end

この中に保存するデータとメソッドを定義していきます。

インスタンスとは？？

先ほど、クラスは「オブジェクトの設計図」と述べましたが、この設計図をもとにつくられるオブジェクトをインスタンスと言います。同じクラスからつくられたインスタンスは同じデータ項目をもち、同じメソッドを使えます。しかし、インスタンス一個一個のそれぞれの中に保存されているデータの中身はインスタンスごとに変わります。

ここでクラスとインスタンスについて現実世界を例に考えてみましょう

会社をクラス、社員をインスタンスとして例えます。
それぞれの会社（クラス）にはそれぞれのルールがあります。そのルールにしたがって社員（インスタンス）は行動（メソッド）を起こします。その会社（クラス）ごとにルールは異なるので属する会社（クラス）によって社員（インスタンス）の行動（メソッド）も限定されてくるのです。
そして、社員（インスタンス）は一人一人名前や性別が違います。これが先ほど説明したインスタンスの持っているデータはインスタンスごとに異なるというものです。

インスタンスの作成は以下のようにおこないます

class Company

end

member1 = Company.new #Companyクラスからインスタンスを作成し、変数member1に代入

クラス名に対してnewメソッドを使うことによってインスタンスが作成されます。

次にこのmember1に名前や性別、歳などの情報を持たせましょう。情報を持たせるために「インスタンス変数」を使います。「インスタンス変数」とはインスタンスごとに独立して持つ変数です。インスタンス変数は先頭に@マークをつけて使います。
インスタンス変数はクラス内でしたら全てのメソッドで使用することができます。同じ名前のインスタンス変数でも対象となっているオブジェクトごとに中に入っているデータ（名前、性別、歳）は異なります。

情報を持たせるための記述は以下のようになります。

class Company

 def initialize(name,sex,age)
　　#インスタンス作成時に引数で渡された名前と性別、歳をインスタンス変数に代入
   @name = name
   @sex = sex
   @age = age
  end

  def foge
   puts "私は#{@name}です。性別は#{@sex}です。歳は#{@age}です"
  end

end

member1 = Company.new("daichi","男",20) #Companyクラスからインスタンスを作成し、変数member1に代入。
#引数にインスタンスの名前、性別、歳などの情報（インスタンス個別の情報）を渡します。

member1.foge
#=>私はdaichiです。性別は男です。歳は20です。

newメソッドを使ってインスタンスが作成されるとinitializeメソッドが呼ばれます。initializeメソッドでは、インスタンスの初期設定を行います。今回の場合は引数として渡したインスタンスの名前と性別と歳をインスタンス変数に代入するという処理をおこなっています。
次にmember1のインスタンス対してmember1.fogeとすることでfogeというメソッドを呼び出しています。
このfogeとはインススタンスメソッドです。インスタンスメソッドとは、その名の通りインスタンスに対して呼び出されるメソッドです。今回のfogeというインスタンスメソッドは、member1というインスタンスに対して、インスタンス変数作成時に代入された@name,@sex,@ageを使い、簡単な自己紹介の文章を出力しています。(putsは文字列などを出力するメソッド）fogeメソッドのなかで@nameなどのインスタンス変数を使っています。これが先ほど述べたインスタンス変数はクラス内でしたら全てのメソッドで使用することができるということです。

インスタンスについてもう少し詳しく

次にインスタンス変数の値を変更する方法について解説します。インスタンス変数の値を読み書きするメソッドを「アクセスメソッド」といいます。本来インスタンス変数をクラスの外部から参照したり、外部から変更したりする場合は専用のメソッドを定義しなくてはいけません。しかしアクセスメソッドを使うことでインスタンス変数の値の読み書きが容易になります。
アクセスメソッドにはインスタンス変数の内容を読みこむ専用の「attr_reader」を使います。インスタンス変数の内容を書き込む専用にしたい場合は「attr_writer」を使います。読み書き両方をできるようにするためには「attr_accessor」を使います。attr_accessorの定義はクラスの直下におこないます。

class Company
 attr_accessor :name,:sex,:age

 def initialize(name,sex,age)
　　#インスタンス作成時に引数で渡された名前と性別、歳をインスタンス変数に代入
   @name = name
   @sex = sex
   @age = age
  end

  def foge
   puts "私は#{@name}です。性別は#{@sex}です。歳は#{@age}です"
  end

end

member1 = Company.new("daichi","男",20) #Companyクラスからインスタンスを作成し、変数member1に代入。
#引数にインスタンスの名前、性別、歳などの情報（インスタンス個別の情報）を渡します。

member1.foge
#=>私はdaichiです。性別は男です。歳は20です。

member1.name = "nana" #member1の名前をnanaに変更
member1.sex = "女" #member1の性別を女に変更
member1.age = 39 #member1の歳を39に変更

member1.foge #もう一度変更したmember1インスタンスに対してfogeというインスタンスメソッドを呼び出す
#=>私はnanaです。性別は女です。歳は39です

ご覧の通りmember1のもつ情報をクラスの外から変更することができましたね！！

クラス変数について

インスタンス変数の他にクラス変数というものがあります。インスタンス毎に格納されるデータが異なるインスタンス変数とは違い、クラス変数はそのクラスの中で共通のデータを持ちます。具体例をみながら覚えていきましょう。さきほどまで使っていたCampanyクラスの中に会社の社員数を表すnumberというクラス変数を定義します。クラス変数には変数の前に@@をつけます。

class Company

  @@number = 0 #クラス変数numberの定義

  #以下省略

クラスメソッドについて

次にクラスメソッドについて解説します。さきほど個々のインスタンスに対して呼び出すメソッドをインスタンスメソッドと呼びました。クラスメソッドとはそのクラスに対して呼び出すメソッドのことを言います。
クラスに関連は深いが、個々のインスタンスに含まれるデータを使わない時にクラスメソッドを定義します。
今回はクラス変数を出力するクラスメソッドを定義します。メソッド名はnumber_showにします。

クラスメソッドの定義の仕方は２種類あります。クラスメソッドをいくつか定義したい場合は後者の定義の仕方の方が便利です。

  class company
    def self.number_show #クラスメソッドの前にはselfをつける

    end
  end

　Company.number_show #クラスメソッドの呼び出しは「クラス名.メソッド名」

 class company
   class << self
     def number_show

     end
  end

　Company.number_show

さきほどのコードを使ってクラスメソッドの定義と呼び出しをみてみましょう

class Company

  @@number = 0 #クラス変数の定義

  attr_accessor :name, :sex, :age

 def initialize(name,sex,age)
   @name = name
   @sex = sex
   @age = age
   @@number = @@number + 1 #インスタンスが作成されるごとにクラス変数numberの数が増える
  end

  def self.number_show #クラスメソッドの定義
    puts @@number
  end

  def foge
   puts "私は#{@name}です。性別は#{@sex}です。歳は#{@age}です"
  end

end

member1 = Company.new("daichi","男",20) #Companyクラスからインスタンスを作成し、変数member1に代入

member2 = Company.new("jyon","男",22)

Company.number_show #クラスメソッドの呼び出し
#=> 2 (@@numberの数）

クラスメソッドを呼び出せましたね！！

まとめ

今回の記事ではRubyにおける「クラス」の概念のさわりの部分を扱いました。この記事が皆さんの理解を深めることにつながれば嬉しいです。
最後まで読んでくださりありがとうございました。

目的

Rubyを勉強し始めた時につまずきそうなところ
その中でも
・クラスメソッドとインスタンスメソッドの違いについて
・attr_accessorとは
この2つをまとめました。

目次

・クラスメソッドとインスタンスメソッド
・attr_accessor

クラスメソッドとインスタンスメソッド

Rubyでは、以下のようにすることでメソッドを定義することができます。

def number(a,b,c)
    puts a + b + c
end
number(1,2,3)
# 出力結果 => 6

通常、メソッドは以下のようにクラスの中に定義しますが、このままだとエラーになります。
クラスにメソッドを作成すると、それがインスタンスメソッドとなります。
そのため、numberはクラスに含まれたインスタンスメソッドになり、外から使用できなくなります。

class Add
    def number(a,b,c)
        puts a + b + c
    end
end
number(1,2,3)
# 出力結果 => エラー

回避方法1
selfをつけてクラスメソッドにすることで外から使用できるようにする

class Num
    def self.number(a,b,c)
        puts a + b + c
    end
end
Num.number(1,2,3)
# 出力結果 => 6

回避方法2
numberはインスタンスメソッドのため、インスタンスを作成しメソッドを呼び出す

class Num
    def number(a,b,c)
        puts a + b + c
    end
end
num = Num.new
num.number(1,2,3)
# またはNum.new.number(1,2,3)でも同じ
# 出力結果 => 6

その他の方法
initializeを使ってみる
以下のようにinitializeメソッドを定義することで、
classがnewされた際に呼び出され、classのデータの初期化処理を行ってくれます。

class Num
    def initialize(a,b,c)
        @result = a + b + c
    end

    def number
        puts @result
    end
end
num = Num.new(1,2,3)
num.number
# 出力結果 => 6

attr_accessorについて

class Person

  def initialize(name)
    @name = name
  end

  def name
    @name
  end

end

person = Person.new("taro")
puts person.name
# 出力結果 => taro

上記のコードでクラスの外からインスタンス変数(@name)を変更,更新したい！
と思って...

class Person

  def initialize(name)
    @name = name
  end

  def name
    @name
  end

end

person = Person.new("taro")
person.name = "jiro" #インスタンス変数の値を更新
puts person.name
# 出力結果 => エラー

インスタンスから直接nameを変えようとしましたが、nameというメソッドはここではゲッターの役割をしているため、値の更新はできないです。
person.@name = "jiro"としても、インスタンス変数には直接アクセスできないのでエラーになります。

値の更新をできるようにするためにはセッターが必要です。
そこで以下のようにセッターを定義すると無事に値が変更できます。
def name=(val) とは、person.name = "jiro"と「name」への代入式を書いた時に呼び出されるメソッドです。

class Person

  def initialize(name)
    @name = name
  end
#セッター↓
  def name=(val)
    @name = val
  end
#ゲッター↓
  def name
    @name
  end

end

person = Person.new("taro")
person.name = "jiro" 
puts person.name
# 実行結果　jiro

そして、ゲッターとセッターの両方の役割を持ったものが「attr_accessor」で、以下のようにすることで先ほどのコードよりも短く書くことができます。

class Person
  attr_accessor :name #追加

  def initialize(name)
    @name = name
  end

end

person = Person.new("taro")
person.name = "jiro" #インスタンス変数の値を上書き
puts person.name
# 実行結果　jiro

これでクラス外からインスタンス変数であるnameを操作できるようになりました。
attr_accessor :（インスタンス変数)　とすれば、指定されたインスタンス変数が外からでも変更できるようになります。

疑問点

Q.インスタンス変数の書き方attr_accessor :nameと@nameの違い
A.attr_accessorでシンボルを渡して宣言すると、そのシンボル名のインスタンス変数（@name）を中で生成している。

Q.クラスメソッド・インスタンスメソッド使い分け
A.基本的には、インスタンスメソッドで処理を実現できるか検討する。
外部からデータを取得する処理（外部ファイルからデータを取得し、インスタンスを作成する時など）は、クラスメソッドを使用する。

まとめ

・クラスにメソッドを作成すると、それがインスタンスメソッドとなる
・インスタンスメソッドはインスタンスを作成して使用できる
・セッターとゲッターを使うことで値の参照・更新をすることができる。
・セッターとゲッターの両方の役割を持ったものが「attr_accessor」

こんにちは！プログラミングスクールでメンターをしている野原です。

いきなりですが、自分がLINE bot APIとグルナビAPIを使って作成した以下のLINEbotをLINEの友達に追加してみてください。Web APIをどんどん学びたくなるはずです！！！

スマホの方はこちら

それでは、はじめにWeb APIに関して学び、その後に実際にWeb APIを使ったアプリの概要について見ていきます。

1. Web API を使うとこんなものが作れる！

上のQRコードを読み取って、使っていただいたようにWeb APIを使うと以下のようなアプリが作れます。

ここでは、LINEで自分の位置情報を送ることにより、自分がいる場所の近くにある飲食店を一つランダムに返しています。また地名やカテゴリーを送ることもできるようになっています。
このアプリは以下のURLでソースコードを公開しています。
https://github.com/NoharaMasato/tabetai

２. Web APIとは

APIとは「Application Programming Interface」の略です。これを聞いても難しいと思うのでみなさんが良く耳にするであろうUI (User Interface)との類似点を交えながら説明したいと思います！この２つの類似点は両方ともインターフェースであるという点です。

インターフェースとは日本語に直訳すると境界面や接点という意味があります。つまり、両方とも、何かと何かの境界面のことだと分かればざっくりとしたイメージがつかめると思います。

そして、Web APIとはHTTPという通信方式を用いてネットワーク越しに呼び出すAPIです。

３. アプリの構造

自分が作成したアプリの仕組みを簡単に図に表したのが以下の図です。

①．ユーザーが位置情報もしくは地名をLINEbotに送信する
②．LINEサーバが①のイベントを検知して、botで指定されているRailsアプリのURLにリクエストを送る
③．RailsアプリがLINEから送られてきた情報を元に、グルナビAPIにリクエストを送る。
④．グルナビAPIからのレスポンス（店舗の情報）をRailsアプリが受け取る。
⑤．受け取った情報をもとに、処理した内容をLINEサーバに送る
⑥．LINEサーバがスマホのLINEに通知を送信する

これでこのアプリの概要が分かっていただけましたか？

４. 作成のために必要な知識

ここでは自分が作成したものと同じものを作るために必要な知識をあげてみます。

１.APIに関して
２.Rubyに関して
３.Railsに関して
４.Herokuを使ったデプロイの仕方に関して
５.gitに関して

これらについての簡単な知識があれば作成ができます。

５. 作成の仕方の概要

手順

Step１　LINE bot APIの部分を設定する
Step２　グルナビAPIの部分を設定する
Step３　Railsの部分を実装する
Step４　アプリケーションをデプロイする

注意点としては、lien_botはhttpsのアドレスが必要なためローカル環境では特別な設定をしない限り、実行することができません。ここではHerokuにデプロイすることにします。自分は修正するたびにherokuにデプロイをして、実行結果を確認しながら作業を進めました。

６. 実装の仕方

ここでは簡単に説明していきます。
実際に作ってみたい方は、他の詳細な説明が書いてあるサイトも参考にしながらやってみてください。

Step１　LINE bot APIの部分を設定する

ここではLINE bot APIの設定を行います。まず、LINE Developersに登録し、新規チャンネルを作成します。ここで特に注意すべき点は以下の２点です。以下のサイトから行なってください。

１、Messaging APIを選択し、Channel Secretとアクセストークンが得られていることを確認する。
２、webhookを有効にする（webhook URLはherokuにデプロイした際にhttpsのURL
が与えられるのでそれを登録します。）

Step２　グルナビAPIの部分を設定する

以下のサイトからレストラン検索APIを使います。
登録するとアクセスキーが取得できます。
https://api.gnavi.co.jp/api/

ここまでで自分のアプリを作成する準備は完璧です。

Step３　Railsの部分を実装する

まず次のgemを入れます

gem 'line-bot-api'

ルーティングやコントローラーは以下の通りです。

class LinebotController < ApplicationController
   require 'line/bot'  # gem 'line-bot-api'
   # callbackアクションのCSRFトークン認証を無効
   protect_from_forgery :except => [:callback] 
   def client
     @client ||= Line::Bot::Client.new { |config| 
       config.channel_secret = ENV["LINE_CHANNEL_SECRET"]
       config.channel_token = ENV["LINE_CHANNEL_TOKEN"]
     } 
   end

   def callback
     body = request.body.read

     signature = request.env['HTTP_X_LINE_SIGNATURE']
     unless client.validate_signature(body, signature)
       error 400 do 'Bad Request' end
     end

     events = client.parse_events_from(body)

     #ここでlineに送られたイベントを検出している
     # messageのtext: に指定すると、返信する文字を決定することができる
     #event.message['text']で送られたメッセージを取得することができる
     events.each { |event|
       if event.message['text'] != nil
         place = event.message['text'] #ここでLINEで送った文章を取得
         result = `curl -X GET http://api.gnavi.co.jp/RestSearchAPI/20150630/?keyid='&'format=json'&'address=#{place}`#ここでぐるなびAPIを叩く
       else
         latitude = event.message['latitude']
         longitude = event.message['longitude']

         result = `curl -X GET http://api.gnavi.co.jp/RestSearchAPI/20150630/?keyid='&'format=json'&'latitude=#{latitude}'&'longitude=#{longitude}`#ここでぐるなびAPIを叩く
       end

       hash_result = JSON.parse result #レスポンスが文字列なのでhashにパースする
       shops = hash_result["rest"] #ここでお店情報が入った配列となる
       shop = shops.sample #任意のものを一個選ぶ

       #店の情報
       url = shop["url_mobile"] #サイトのURLを送る
       shop_name = shop["name"] #店の名前
       category = shop["category"] #カテゴリー
       open_time = shop["opentime"] #空いている時間
       holiday = shop["holiday"] #定休日

       if open_time.class != String #空いている時間と定休日の二つは空白の時にHashで返ってくるので、文字列に直そうとするとエラーになる。そのため、クラスによる場合分け。
         open_time = ""
      end
      if holiday.class != String
         holiday = ""
       end

       response = "【店名】" + shop_name + "\n" + "【カテゴリー】" + category + "\n" + "【営業時間と定休日】" + open_time + "\n" + holiday + "\n" + url
        case event #case文　caseの値がwhenと一致する時にwhenの中の文章が実行される(switch文みたいなもの)
       when Line::Bot::Event::Message
         case event.type
         when Line::Bot::Event::MessageType::Text,Line::Bot::Event::MessageType::Location
           message = {
             type: 'text',
             text: response
           }
           client.reply_message(event['replyToken'], message)
         end

       end
     } 

     head :ok
   end
 end

post '/callback' => 'linebot#callback'

Step４　アプリケーションをデプロイする

railsアプリケーションをherokuにデプロイします。この時にhttpsのURLが与えられるのでLINE bot APIのWebhook URLに追加します。
ポイントとしては、heroku logs -tでlogを見ながらデプロイやデバッグをすると何が起こっているか分かりやすいです。

終わりに

どうだったでしょうか？APIが何かわかりましたか？
以下のようなサイトにWeb APIが様々な種類載っています。面白そうなのがあれば実際に使ってみてください!
http://smsurf.app-rox.com/api/

参考

LINE bot API
https://qiita.com/y428_b/items/d2b1a376f5900aea30dc

heroku
https://qiita.com/kazukimatsumoto/items/a0daa7281a3948701c39

狙い

　本記事はプログラミングを始めたばかりの初心者や、機械学習とか興味あるけどイメージすら湧かない、くらいの方を対象しています。
　以上の層の方達にディープラーニングと機械学習の大まかなイメージだけでも掴んでいただこうと思い短い文でおおまかに書いた記事です。詳細というよりは、二つが似た者同士の親戚であるというイメージのみを伝えようといった内容です。

両者の共通点

大きく分けると「あらゆるパターン学習させる」と「学習済みのものを使う」二つのフェーズがあります。
その二つについて話します！（分類器を例に）

　学習

まず学習させることで猫の特徴などを覚えさせ、猫の画像を見たら「これは猫だ！」と判別できるようにします。
他にも犬や猿などあらゆる動物の画像をサンプルとして与え、正しく分類できるようにします。

　使用

こうして行われた学習後に適当な動物画像を与えるとその動物がなんなのかを９０％とかで正解できるようになる！っていうのが機械学習、ディープラーニングです。

ディープラーニングと機械学習の違い

　両者の概要については上の画像のイメージです。
　では違いは一体なんなのか。

　この部分が違います！ほとんど全部じゃんw
　できることは同じなのに、どんな具合に違うのだろう　といったことを雑くチェックしていきます。

　人間がその生き物を猫と判定するまでには、輪郭や鼻、耳などから判断すると思います。

　じゃあ、機械はどうやって判断するの？

ここに機械学習とディープラーニングの違いがあります。

　このブラックボックスの大きさの違いが両者の違いなのです。

　つまり？

　知っている人もいるかもしれないですが、機械学習は英語でマシーンラーニングといい、ディープラーニングはその仲間なのです。
　ディープラーニングをやりたいと思ったら機械学習から入っても遠回りではありません。

　他に違いは？

　学習方法、適応範囲など様々な違いはあります。でもこの流行りの二つの言葉は親戚であることに変わりはありません。一つを学んで見たら、もう一つも理解できてきたりします。

あとがき

　ディープラーニングを学ぶために必要な知識が多すぎたり、「ディープラーニングとは？」とか調べるとかなり難しい記事しか出てこなくて、初学者を遠ざけてる感があったので多少雑にでも解説するサイトも必要なのでは？と思いこの記事を投稿いたしました。
　入門、初心者向けでも結局文量が膨大になってしまうのがこの分野なので、噛み砕いて極力文量を減らせるように意識しました。
　もちろんしっかりと理解するためにはそれなりの時間、努力が必要であって最後まで理解させようと思って記事を書こうものなら既存のサイトと同じ長い文になるでしょう。そこに踏み込む前の軽いストレッチ的な役を担えればいいなと思います。→これが十分な説明を果たしているわけではないので興味を持っていただけた方はもっと調べて見てください！
今回の説明は分類器というものを例にしていて、他にも色々あります！

どうも！ジャニヲタです。
今回は、SQLを使って、ジャニヲタ用語を解説していきたいと思います。
なんでそんなことをしようと思ったのかというと、大好きなSnow Manというユニットを宣伝したかったから何事も新しいことを勉強するには身近なものに例えると覚えやすいよな〜と思ったからです。
「SQLで覚えるジャニヲタ用語」というタイトルにしましたが、SQLって何？という方もご安心ください。SQLとジャニヲタ用語が一気に身につけられる記事になっています。多分...

想定読者

• SQLって何？な方
• Rails初心者（SQLを直接触る機会が少ない方、コンソールに表示されるSQLの意味が分からない方）
• 仕事で使うデータを毎回エンジニアに取得依頼している方
• 彼女や奥さんがジャニヲタなエンジニア
• 非ヲタ・非エンジニア

SQLって何？

データベースの定義や操作を行うことができる言語です。
世の中のアプリケーションはデータベースに様々な情報を保存しています。
例えば何かのサイトに登録する時、名前やメールアドレス、住所などを登録しますよね。
それらの情報はデータベースに保存され、管理されています。
「この情報くれよ〜」「この情報保存しておいてよ〜」とデータベースに話しかけるための言語がSQLです。

Rails学習中の方は、アプリケーションを動かしているときにコンソールを見てみて下さい！
上記の画像では、「SELECT」で始まっている文がSQL文です！
実はSQL文を知らぬ間に実行してくれているんですね〜便利ですね〜◎

まずは準備をしよう

テーブルを用意する

まずは、 テーブル を作成します。
テーブルとは、 データを入れておく箱 のようなものと思って下さい。
データベースは、この箱の集まりです。

今回は、ジャニヲタ用語を説明するにあたって、下記のようなテーブルを用意します。

wotakusテーブル
ヲタク情報を管理するテーブルです。
ヲタクの名前や、好きなタレント名などを管理します。

unitsテーブル
グループ（ジャニーズJr.のユニット）を管理するテーブルです。
デビュー組はグループ、Jr.のグループはユニットと呼ぶことが多い気がするのでユニットとしました。
ユニット名などを管理します。

talentsテーブル
ジャニタレ情報を管理するテーブルです。
ジャニタレの氏名や、どのユニットに所属しているかなどを管理します。

テーブルの中に、「id」や「name」などの項目がありますね。これは、 カラム といって、箱の中の仕切りを意味します。
idには番号が、nameには名前が...というようにデータを整理します。
EXCELと同じようなイメージです！

下記が実際のSQL文です。
データベースの中にテーブルを作成するためには、「create文」という構文でSQLを書きます。

CREATE TABLE wotakus(id integer, name varchar(100), favorite_talent_id integer, 
 created_at datetime, updated_at datetime);
CREATE TABLE units(id integer, name varchar(100), 
 created_at datetime, updated_at datetime);
CREATE TABLE talents(id integer, name varchar(100), unit_id integer, 
 created_at datetime, updated_at datetime);

これでデータを入れておく箱と仕切りができました！
Railsの場合、migrationファイルに「create_table」と書きますが、実はこのようなSQLが生成されています。
Railsさん便利！！

テーブルにデータを入れる

テーブルを作っただけでは、中身は空っぽです。箱の中にデータを入れてみましょう！
テーブルにデータを投入する為には、「INSERT文」を実行します。

unitsテーブル
まずはユニットテーブルにデータを入れます。
今回は「兄組」と呼ばれている3組を入れておきます！

INSERT INTO units (id, name) VALUES (1, 'Snow Man');
INSERT INTO units (id, name) VALUES (2, 'SixTONES');
INSERT INTO units (id, name) VALUES (3, 'Travis Japan');

上記のSQL文を実行すると、下記のようにデータがデータベースに登録されます。
それぞれの行を レコード といいます。

３レコード投入されましたね！

talentsテーブル
次に、メンバー名を投入していきます。
ジャニーズのタレント全員書くとそれだけでスクロール半端なくなるので、
とりあえず、かつて「BAD BOYS J」というドラマに出演していたSnow Manのメンバー3名をサンプルで入れておきますね。

INSERT INTO talents (id, name, unit_id) VALUES (1, '岩本照', 1);
INSERT INTO talents (id, name, unit_id) VALUES (2, '深澤辰哉', 1);
INSERT INTO talents (id, name, unit_id) VALUES (3, '渡辺翔太', 1);

この3人はSnow Manのメンバーなので、unitテーブルの1番（Snow Man）をunit_idに入れておきます。
このように、他のテーブル（今回はunitテーブル）のレコードを参照して下さいね、という意味でもつカラムの値（今回はunit_id）を、 外部キー と呼びます。

wotakusテーブル

最後に、ヲタク情報を投入しましょう。

INSERT INTO wotakus (id, name, favorite_talent_id) VALUES (1, 'おがっぴ', 2);
INSERT INTO wotakus (id, name, favorite_talent_id) VALUES (2, 'ヲタ子', 3);
INSERT INTO wotakus (id, name, favorite_talent_id) VALUES (3, 'ジャニ美', 1);

おがっぴは私です。僭越ながら、id=1でINSERTさせていただきます。

さぁ、準備ができました！
早速SQL文とジャニヲタ用語を一緒に学んでいきましょう！

ジャニヲタ用語に触れよう

さぁ、SQLを使ってジャニヲタ用語を感じてみよう！

担当、自担

意味：一番好きなジャニーズタレントのこと。
用例：「私は深澤くん担当です！」「私の自担はSnow Manの深澤辰哉くんです！」

今回は私の大好きなユニットSnow Manのダイマを兼ねているので、ガンガンSnow Manメンバーの名前を使っていきたいと思います。
はい、私は「ふっか」こと深澤辰哉くんのことを応援しております。

先ほど実行したCREATE文で、wotakusテーブルに「favorite_talent_id」というカラムを作りました。
「好きなタレントid」...つまり、「自担id」です！
おがっぴの自担idは、wotakusテーブルのおがっぴレコードに入っているので、まずはおがっぴのレコード（id=1）を取得してみましょう！

SELECT * FROM wotakus WHERE id = 1;

これは、

「FROM wotakus」＝wotakusテーブルから
「WHERE id = 1」＝idが1番のレコードの
「SELECT * 」＝全てのカラム（*）を取得する

というSQL文です。このSQL文を実行すると、

このようにデータが取得できます。
おがっぴの自担idは「2」のようですね！
INSERT文では、自担idとtalentsテーブルのidに、対応するデータを入れています。
つまり、下記のようにおがっぴの自担名を辿ることができます。

「SELECT」の後に「*」と指定すると全カラム取得できますが、カラム名を指定して、ピンポイントで取得することもできます。

SELECT favorite_talent_id FROM wotakus WHERE id = 1;

上記のSQLを実行すると、

2

が返ってきます。

自担idではなく、「深澤辰哉」という名前で取得したい場合は、

SELECT name FROM talents
WHERE id = 2; -- 一つ前のSQLでゲットした深澤くんのtalent_id

こう書いてあげれば、

深澤辰哉

という文字列が返ってきます。

しかし、
① おがっぴのfavorite_talent_idを取得する
② ①で取得したidをキーにタレント名を取得する
と２段階で自担名を取得するのはちょっとまどろっこしいですね。

一発で「深澤辰哉」という文字列で取得したい場合は、下記のようなSQLでゲットできます。

SELECT name FROM talents
WHERE id = (
 SELECT favorite_talent_id FROM wotakus
 WHERE id = 1
);

急にややこしくなった気がしますね！ちょっと分解していきましょう。
まずは3,4行目だけ見てみましょう。

-- SELECT name FROM talents
-- WHERE id = (
  SELECT favorite_talent_id FROM wotakus
  WHERE id = 1
-- );

先ほど見た、「おがっぴの自担idをゲットする」というSQLです。
深澤くんの2番が返ってきますよね。

次は1,2行目です。
タレントidが？番の人の名前をタレントテーブルから取得するSQLです。

SELECT name FROM talents
WHERE id = (
--   SELECT favorite_talent_id FROM wotakus
--   WHERE id = 1
);

つまり、カッコ内でおがっぴの自担idをゲットして、それをキーにタレント名を取得していた、というだけでした！
これで一気に「深澤辰哉」という文字列がゲットできます！

自ユニ

意味：自分の応援しているグループ、自担が所属しているグループのこと
用例：「私の自ユニはSnow Manです！」

今回は、
「おがっぴが応援しているのは深澤くん。そんな深澤くんが所属しているのはどこのユニット？」
という問いかけへの答えをゲットしていきたいと思います。

SELECT name FROM units
WHERE id = (
 SELECT unit_id FROM talents 
 LEFT OUTER JOIN wotakus ON wotakus.favorite_talent_id = talents.id 
 WHERE wotakus.id = 1
);

は〜〜〜またややこしいSQL...
でも大丈夫。一つ一つ分解していきましょう。

今回欲しいのは、「Snow Man」というユニット名。

この「Snow Man」をゲットするためには、
① おがっぴの自担idをゲットする
② ①で取得したタレントが所属しているユニットのidをゲットする
③ ②で取得したidをキーに、ユニット名をゲットする
という3Stepが必要になって来ます。

まずは、3〜5行目を見てみます。

-- SELECT name FROM units
-- WHERE id = (
  SELECT unit_id FROM wotakus 
  LEFT OUTER JOIN talents ON wotakus.favorite_talent_id = talents.id 
  WHERE wotakus.id = 1
-- );

おやおや...見慣れない「LEFT OUTER JOIN」「ON」という単語が出て来ました...
これは、「複数のテーブルをくっつけて、ひとつのテーブルっぽく見せる」という技です。
上記の３行を実行すると、

1

が取得できます。
ちょっとややこしいので、上記３行のSQL

SELECT unit_id FROM wotakus 
LEFT OUTER JOIN talents ON wotakus.favorite_talent_id = talents.id 
WHERE wotakus.id = 1

の「unit_id」を「*」に変えて

SELECT * FROM wotakus 
LEFT OUTER JOIN talents ON wotakus.favorite_talent_id = talents.id 
WHERE wotakus.id = 1

としてみます。
「*」は、全カラムのデータを取得するよ！という呪文です。
結果は、こうなります。

※「wotakus.id」は、「wotakusテーブルのidカラム」を表現しています
※「created_at」「updated_at」は省略しています

つまり、
「ヲタクテーブルの自担カラムと、タレントテーブルのidが同じレコードを合体させるよ！」
（wotakus.favorite_talent_id = talents.id）
ということでした。

ですので、カッコ内の３行では、unit_id「1」が取得できた、というわけです。

あとはお馴染みのSELECT文です！

SELECT name FROM units
WHERE id = (
--   SELECT unit_id FROM wotakus 
--   LEFT OUTER JOIN talents ON wotakus.favorite_talent_id = talents.id 
--   WHERE wotakus.id = 1
-- ※↑上記３行で1が取れました
);

unitのidが１番のname（ユニット名）を取得です。
最終的に「Snow Man」がゲットできました！

担降り

意味：ファンをやめること。
用例：「ちょっと私xxの担当降りるわ」

ジャニタレの熱愛報道が出たら、「はてなブログ　担降り」で検索すると、
悲痛なブログが読めたりします。

タレントid=10が誰かは分かりませんが、ジャニ美ちゃんは担当を降りることを決めたそうな。
この10という値、悲しいけど消しましょう...

UPDATE wotakus SET favorite_talent_id = NULL WHERE id = 3

「UPDATE」は、レコードを更新できる構文です。
今回はジャニ美ちゃんのfavorite_talent_idをNULL（空っぽ）にしました。

必ずしも担当がいるジャニヲタだけではないので、favorite_talent_idはNULL可にしときましょう。

さて、ここがジャニヲタ用語の難しいところなんですが、もう１つ意味があるんですよね。
「私、ずっとxxくんのファンやってたけど、歌声聴いて惚れて 渡辺翔太くんに担降り した！」
のように、別のジャニタレに乗り換えたときも「担降り」を使うんですね！
つまりこういうことです。

UPDATE wotakus SET favorite_talent_id = '3' WHERE id = 3

ジャニ美ちゃんのfavorite_talent_idを「3」(渡辺翔太くんのタレントid)にUPDATEしました。

ヲタ卒

意味：ジャニヲタをやめること
用例：「歳も歳だしそろそろヲタ卒して婚活でもすっか〜」

まず、声を大にして言いたいのは、
「 いくつになってもジャニヲタでいていいだろ！一生ヲタク上等！ 」
ということです。
この度ヲタ子がヲタ卒をしてしまうそうです。悲しいけどテーブルから削除しましょう。

DELETE FROM wotakus WHERE id = 2

上記を実行したあと、ヲタクテーブルを見てみましょう。

SELECT * FROM wotakus

ヲタ子はヲタクテーブルから消滅してしまいました...
私がこのSQL文を流すことは一生なさそうです。

同担

意味：応援対象が自分と同じ人
用例：「自担がドラマに出たら一気に同担増えたわ〜」

自分と同じfavorite_talent_idを設定しているヲタクを取得します。
まずは深澤くんのタレントidをゲットして、そのidをfavorite_talent_idに設定しているヲタクをゲットしましょう。

SELECT id, name, favorite_talent_id FROM wotakus
WHERE favorite_talent_id = (
 SELECT id FROM talents WHERE name = '深澤辰哉'
);

同担が2人いました！
下記の書き方でも取れますね。

SELECT name FROM wotakus
WHERE favorite_talent_id = (
 SELECT favorite_talent_id FROM wotakus WHERE id = 1
);

同担が何人いるのか？を取得することもできます。

SELECT COUNT(*) FROM wotakus
WHERE favorite_talent_id = (
 SELECT favorite_talent_id FROM wotakus WHERE id = 1
);

「COUNT（数えたいカラム名）」で実行すると、何行HITするか数値でゲットできます。

同担拒否

意味：応援しているタレントが被る人とは絡みたくない
用例：（Twitter自己紹介等で）「xx君担です。同担拒否なので悪しからず」

乙女心って複雑ですよね〜。
今までid=2のように、「idが2番のデータをとる！」というSQLを書いてきましたが、「idが2番じゃないデータをとる！」という時はどうしたら良いのでしょう？

SELECT name FROM wotakus
WHERE favorite_talent_id <> (
 SELECT favorite_talent_id FROM wotakus WHERE id = 1
);

「<>」という書き方が出現しました。これは、「〜じゃない」を意味します。
上記の場合、favorite_talent_idが2じゃない人の名前を取得できます。
他にも、「<=」「>=」で〜以上・〜以下が表現できたりします。

ちなみに私は同担大歓迎です！！みんなでふっかを応援しよう！！

カケモ

意味：好きなタレントが複数いること（掛け持ちの略）
用例：（Twitter自己紹介等で）「阿部ちゃんとのえるのカケモです、よろしく！」

データベースの世界では、一つのカラム（仕切り）に一つのデータしか持てません。
現状のテーブル定義だと、1人のヲタクに対して1人の担当しか入れられません。
それでは、どうやってカケモを表現すればいいんだ〜！？

はい。 tantosテーブル （担当テーブル）を作成しました！
これで複数の担当を管理することができるようになります！

ヲタクテーブル

タレントテーブル

担当テーブル

ミーハー花子(wotaku_id=4)のレコードが、担当テーブルに２行ありますね。

SELECT * FROM tantos WHERE wotaku_id = 4

数字だけだと分かりづらいので、JOINしてみましょうか。

SELECT tanto.wotaku_id ,talents.id ,talents.name FROM tantos
LEFT OUTER JOIN talents ON talents.id = tantos.talent_id
WHERE tantos.wotaku_id = 4 

ミーハー花子は多分勉強できる人が好き。

古株、新規

意味：ファン歴が長い、ファン歴が短い
用例：「あの人は古株だから詳しいよね〜」「ド新規ですがよろしくお願いします」

「ごく出は永遠の新規」という言葉があります。
「ごくせん」からKAT-TUNファンになった人は、いつまで経っても新規、というパワーワードです。
もう、放送から13年経ってますが...！

担当テーブルには「created_at（レコード作成日）」を持っています。
このカラムを使えば、古株・新規が洗い出せそうです（怖い...！）

SELECT * FROM wotakus 
WHERE talent_id = 2
ORDER BY created_at ASC

「ORDER BY」はソートに使うカラムを指定、「ASC」は昇順指定です。
これで深澤担が古株順に並びます...こわひ...！

ちなみに、

SELECT * FROM wotakus 
WHERE talent_id = 2
ORDER BY created_at ASC
LIMIT 1

のように「LIMIT 数値」をつけてあげると、先頭から何行取得するか指定できます。
上記の場合、一番古株の人が取得できます...！

まとめ

はい、以上で基礎的なジャニヲタ用語のレクチャーを終わります。
出オチ感の強い記事だったかと思いますが、一応CRUDには触れてみました。
ぜひ皆さん、何か新しいことを勉強するときは、自分の好きなものや身の回りの事柄に例えて覚えてみて下さい！
最後まで読んでくれた方、サンキューサンキューで〜す！

はじめまして

はじめまして。最近はひたすら作ったシステムにRspec(system spec)+FactoryBotを書いてるエンジニアです。
この辺絶賛苦労中なんで落ち着いたら記事書きたいですね。

世の中の流行りってなんなんだろう

jsってすごい人気ですよね。（人気なんですよ）jsフレームワークがまだまだ流行っている今、何が流行っているのかってエンジニアとして気になります。こういうサイトをご存知でしょうか🤔
npmtrends

(※スクショは2018/12月のものです)
jsフレームワークたちのトレンドがグラフになっているサイトです。
ダウンロード数で見ると圧倒的React人気ですね。ReactNativeやReactNativeWebなど出て色んなプラットフォームに柔軟に対応できるからなのでしょうか？

Vueに注目してみましょう。比べてみるとダウンロード数少ないですね、、ですがGitHub Starsを見てください！なんと一位です！素晴らしいですねー。スターが多いということは優秀なエンジニアが多い証みたいなものなのでとても活発なフレームワークであるというのがわかりますね。
ReactもVueも人気あるんだなーっていうのが分かって是非とも触ってみたくなりますよね。

そこで

jsフレームワーク単体でも勿論色々と触ってはみたいですが、railsのアプリにもjsフレームワークを組み込むことができるので、既存RailsアプリにVue.jsつっこんでみようと思います。

なんでVue.js?

Reactの方が人気ですし、Vue.jsはLaravelのイメージ（あくまでイメージ）なんですが、学習コスト的にVue.jsの方が楽かなって思ったからです。特に深い意味はありません。今回は導入までですが今後Vueへの書き換えなども余力あれば記事にします。

さて

まずは自分の環境を簡単に見てみることにしました。
vagrant 2.2.2
ubuntu 18.0.4
Rails 5.2.1
Ruby 2.5.1
Rails5.1からReactやVueなども簡単に導入できると話題になってましたのでこのバージョンであればいけそうですね。rubyは最低限2.2以上にしておきましょう。

Ubuntuに最新安定版のNodeいれよう

なぜNodeがいるの？

VueをRailsで使うにはgemのwebpacker（あとで簡単に説明します）をインストールする必要があります。それにはYarnと呼ばれるnpmと互換性のあるJavaScriptのパッケージマネージャー(バージョンの依存関係など解決してくれるもの。installやupdateの管理を行ってくれるもの)が無いとエラーが起きてしまいます。
Yarnをインストールするにはnpmと呼ばれるNodeのパッケージマネージャー（Yarn ≒ npm）が不可欠です。
そしてnpmを入れるにはNodeが不可欠。ということでやっていきましょう。Nodeのインストール

本来、Macの環境であればHomebrewと呼ばれるパッケージ管理システムのコマンドでポチポチやればあっという間にNode入れられるのですが、Ubuntuの場合若干厄介です。
「Ubuntu Node インストール」と検索すると下の記事が目に止まります。
Ubuntuに最新のNode.jsを難なくインストールする
↑めちゃくちゃ参考になりました🙏が、ちょっとうまくいかなかったです。正確にはもう少し自分の環境では手を加える必要がありました。

記事通りになりますが、コマンド打っていきましょう。
まずNodeを入れるためにnodejsというものとnpmをaptコマンドでインストールします。

$ sudo apt-get install -y nodejs npm

こんな感じでセットアップのログが流れてきたら大丈夫です。

...
Setting up node-isexe (2.0.0-3) ...
Setting up node-spdx-correct (1.0.2-1) ...
Setting up node-async (0.8.0-3) ...
Setting up node-cookie-jar (0.3.1-1) ...
Setting up node-mute-stream (0.0.7-1) ...
Setting up node-form-data (0.1.0-1) ...
Setting up node-request (2.26.1-1) ...
Setting up node-concat-map (0.0.1-1) ...
Setting up node-ini (1.3.4-1) ...
Setting up node-mkdirp (0.5.1-1) ...
Setting up node-once (1.4.0-2ubuntu1) ...
Setting up nodejs-dev (8.10.0~dfsg-2ubuntu0.4) ...
Setting up node-sha (1.2.3-1) ...
Setting up node-fs.realpath (1.0.0-1) ...
Setting up node-brace-expansion (1.1.8-1) ...
Setting up node-ansi-color-table (1.0.0-1) ...
Setting up node-npmlog (0.0.4-1) ...
Setting up node-is-builtin-module (1.0.0-1) ...
Setting up node-nopt (3.0.6-3) ...
Setting up node-which (1.3.0-1) ...
Setting up node-lru-cache (4.1.1-1) ...
Setting up node-block-stream (0.0.9-1ubuntu1) ...
Setting up node-validate-npm-package-license (3.0.1-1) ...
Setting up node-inflight (1.0.6-1) ...
Setting up node-read (1.0.7-1) ...
Setting up node-minimatch (3.0.4-3) ...
Setting up node-normalize-package-data (2.3.5-2) ...
Setting up node-glob (7.1.2-4) ...
Setting up node-rimraf (2.6.2-1) ...
Setting up node-read-package-json (1.2.4-1) ...
Setting up node-fstream (1.0.10-1) ...
Setting up node-fstream-ignore (0.0.6-2) ...
Setting up node-tar (2.2.1-1) ...
Setting up node-gyp (3.6.2-1ubuntu1) ...
Setting up npm (3.5.2-0ubuntu4) ...
...

ディスクの容量確保のようなコマンドで必須ではないかもしれませんが、念の為キャッシュをクリアするコマンドを打ちます。

$ sudo npm cache clean

Ubuntu環境にnpmをインストールをします。

$ sudo npm install n -g

「n」というNodeのバージョンを簡単に変更できるプラグインをインストールします。stableとすると現在の安定版も一緒にインストールしくれます。
（現在は10系が安定です。Nodeは偶数が安定版で奇数が開発版だということをなんとなく覚えておくといいかと思います。）

$ sudo n stable

シンボリックリンクを貼ります。

$ sudo ln -sf /usr/local/bin/node /usr/bin/node

ここで安定版を入れたNodeのバージョンを確認しましょう。v10.xx.xなどであればとりあえず大丈夫です。（v8.xx.xでも大丈夫かと）

$ node -v
v10.14.0

バージョンを変更したい場合ですが、その時に「n」が役に立ちます。以下のコマンドを打ちましょう。

$ n v10.14.0

これでNodeのv10.14.0をインストール&設定してくれるので、改めてnode -vでバージョンを確認してみてください。
あわせてnpmのバージョンも確認してみましょう

$ npm -v
3.5.2

んーー、2018/12現在の最新安定版は6.4なのでaptでインストールしたnpmはかなり古いような気がしますね。。
aptでインストールしたnodejsというものはもうNodeを入れたので不要になります。npmも古いバージョンのものは不要なのでアンインストールしましょう。これでNode(v10.14.0)に内包されているnpmのバージョンになるはずです。

$ sudo apt-get purge -y nodejs npm

ここで再度Nodeのバージョン確認すると自分の環境ではエラーが起きてしまいました。

$ node -v
-bash: /usr/bin/node: No such file or directory

シンボリックリンクが外れてしまっていただけなので、もう一度貼り直せば動くはずです。（ここで少し悩みました🤔）

$ sudo ln -sf /usr/local/bin/node /usr/bin/node

最後にyarnをnpmコマンドでインストールしましょう

$ sudo npm install yarn -g

改めてバージョン確認しておきます。これで大丈夫です。

$ node -v
v10.14.0
$ npm -v
6.4.1
$ yarn -v
1.12.3

RailsにVueを入れよう

これで一通り準備は整いました。
これから既存RailsアプリにVueを入れていきます。

gem 'webpacker', git: 'https://github.com/rails/webpacker.git' # とりあえずファイルの一番下に書いておきましょう

webpackerはwebpackと呼ばれるjsの管理をしてくれる（分割したファイルの結合や圧縮など）便利ツールのgemになります。これを用いることで簡単にreactやvue、angularなどをrailsに取り込むことができます。

$ bundle install

bundle installが完了したら以下のコマンドを打ちます。下のコマンドは先ほど入れたYarnが無いとエラーが起きてしまいます。

$ bundle exec rails webpacker:install

しばらく色々なログが流れてきますが、こんな感じに絵文字が出てくればOKです

Done in 94.26s.
You need to allow webpack-dev-server host as allowed origin for connect-src.
This can be done in Rails 5.2+ for development environment in the CSP initializer
config/initializers/content_security_policy.rb with a snippet like this:
policy.connect_src :self, :https, "http://localhost:3035", "ws://localhost:3035" if Rails.env.development?
Webpacker successfully installed 🎉 🍰

ここでvueの登場です。vueではなくreactをインストールしたい場合は$ rails webpacker:install:reactにすれば大丈夫です

$ rails webpacker:install:vue

これで導入完了です😎🎉

├─ vue-template-es2015-compiler@1.6.0
└─ vue@2.5.19
Done in 91.83s.
You need to enable unsafe-eval rule.
This can be done in Rails 5.2+ for development environment in the CSP initializer
config/initializers/content_security_policy.rb with a snippet like this:
if Rails.env.development?
  policy.script_src :self, :https, :unsafe_eval
else
  policy.script_src :self, :https
end
Webpacker now supports Vue.js 🎉

ここでrailsが動くことを確認しておきましょう。

$ rails s

今回はここまで

Rails+Vue(or React)の導入の記事は世の中にたくさんありますが、自分の仮想環境内でやる上で少し手こずったので記事にしてみました。私と似た開発環境で是非導入してみたいという方の参考に少しでもなればと。
じゃあ実際vueをrailsで書き直すのはどうしたらいいの？といった話は冒頭でも申したようにいつか書きますので読んでほしいです。

流行についていくことが絶対的な正義ではないかと思いますが、それを使わずに称賛や非難するのはよくないと思うので是非食わず嫌いせず「まずは触ってみる」ことが大事だと思います。触ってみることで得られるものはあるはずなので。（仮にそれがすぐに廃れる技術であろうとです！）

長くなりましたが以上になります！ありがとうございました。

最後にVueの日本コミュニティのワークスペースがあるのでリンク貼っておきます。（meetupというチャンネルが勉強会の情報くれるのでオススメです）
https://vuejs-jp.slack.com

Railsを学んだけど...

「Rubyだけでなく他の言語も学んだ方がいいですか」みたいな話はちょくちょく聞いたことがあるのですが、個人的には初心者は複数の言語に手を出すよりかは、最初は一つの言語の勉強に集中して方がいいと思っています。これはフレームワークも同じで、例えば、Ruby on Railsの基礎的な流れを把握することができれば、メジャーな他のフレームワークはなんとなく理解できるようになると思います。

他のフレームワークをみてみよう！

とはいえ、他のフレームワークがどんなものか、知りたい人は一定数いる気がするので、今回はPHP言語のメジャーなフレームワークであるLaravelで"Hello World"を出力する過程を、Railsのそれと比較していきたいと思います！ちなみにLaravelは近年すごく使われ始めている言語で、githubスター数もrailsを抜いています。

また、Stack Overflow TrendsでもLaravelがRailsを約0.5％ほど上回っていますね。Laravelの人気の高さが伺えます。

本記事の対象者

• Railsを使って簡単なCRUDアプリを製作したことがある。
• MVCの基本的な流れについて理解している。
• 「Railsだけ勉強してるけど私大丈夫なの？？？」って思っている。

LaravelでHello Worldを作る過程で、Railsとの違いを解説していきます。
ちなみに僕はLaravelについてそんなに詳しいわけではないので、技術的な違いというよりは、Rails経験者がLaravelを初めて使用したときに「あ、なんか似てる！」って思うであろう部分について取り上げていきます。

※Railsの基礎について知りたい人は以下の記事をみてみてね！わかりやすいよ！
https://qiita.com/kouichi_s/items/6480586ab7f6356a91c3
https://qiita.com/kazukimatsumoto/items/14bdff681ec5ddac26d1

Composerのインストール

Laravelを使用する為には、Composerをインストールしなくてはいけないので、以下のPHPコマンドを打ってインストールしましょう。

$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
$ php -r "if (hash_file('sha384', 'composer-setup.php') === '93b54496392c062774670ac18b134c3b3a95e5a5e5c8f1a9f115f203b75bf9a129d5daa8ba6a13e2cc8a1da0806388a8') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
$ php composer-setup.php
$ php -r "unlink('composer-setup.php');"