Menggabungkan Laravel 4 dan Backbone

() translation by (you can also view the original English article)

Untuk tutorial ini, kita akan membangun satu halaman aplikasi menggunakan Laravel 4 dan Backbone.js. Kerangka kedua membuatnya sangat mudah untuk menggunakan mesin template yang berbeda selain default mereka masing-masing, jadi kita akan menggunakan kumis, yang merupakan mesin yang umum untuk kedua. Dengan menggunakan bahasa template yang sama pada kedua sisi dari aplikasi kami, kami akan dapat berbagi kami betweem pemandangan mereka, menyelamatkan kita dari keharusan untuk mengulangi pekerjaan kami beberapa kali.

Aplikasi tulang punggung kami akan didukung oleh Laravel 4 JSON API yang kita akan mengembangkan bersama-sama. Laravel 4 dilengkapi dengan beberapa fitur baru yang membuat pengembangan API ini sangat mudah. Saya akan menunjukkan Anda beberapa trik sepanjang jalan untuk memungkinkan Anda untuk tetap sedikit lebih terorganisir.

Semua dependensi kita akan dikelola oleh manajer paket, tidak akan ada manual men-download atau memperbarui perpustakaan untuk aplikasi ini! Selain itu, aku akan menunjukkan kepada Anda bagaimana memanfaatkan kekuatan tambahan kecil dari beberapa dependensi kita.

Untuk proyek ini kita akan menggunakan:

Laravel 4: Besar PHP framework.
Mustache.php: PHP mesin render untuk kumis.
Mustache.js: JavaScript mesin render untuk kumis.
Jeffrey cara Generator untuk Laravel 4: kita dapat meningkatkan alur kerja kami dengan menghasilkan beberapa kode boilerplate bagi kita menggunakan generator ini.
Twitter Bootstrap: Sebuah front-end perpustakaan untuk membantu dalam styling kami.
PHPUnit: PHP pengujian suite.
Ejekan: Digunakan untuk mengejek obyek PHP saat pengujian.
Backbone.js: MVC Javascript untuk aplikasi satu halaman kami.
Underscore.js: Ketergantungan tulang punggung, dan sebuah toolkit kecil besar fungsi.

Untuk menyelesaikan tutorial ini, Anda akan memerlukan item berikut diinstal:

Komposer: Anda dapat men-download ini dari situs, saya merekomendasikan petunjuk instalasi global terletak di sini.
Node + NPM: installer pada homepage akan menginstal kedua item.
Compiler kurang: Jika Anda pada Mac, saya merekomendasikan CodeKit. Namun, terlepas dari sistem operasi Anda, atau jika Anda tidak merasa seperti membayar untuk CodeKit, Anda dapat menginstal kompilator kurang untuk Node.js dengan mengetik npm menginstal -g kurang pada prompt perintah.

Bagian 1: Arsitektur dasar

Hal pertama yang pertama, kita perlu untuk mendapatkan setup aplikasi kita sebelum kita dapat mulai menambahkan logika bisnis kami. Kami akan melakukan setup dasar 4 Laravel dan mendapatkan semua dependensi kita diinstal menggunakan Manajer paket kami.

Git

Mari kita mulai dengan menciptakan sebuah repositori git untuk bekerja di. Untuk referensi, repo seluruh ini akan dibuat tersedia untuk umum di https://github.com/conarwelsh/nettuts-laravel4-and-backbone.

1	mkdir project && cd project
2	git init

Laravel 4 instalasi

Laravel 4 menggunakan komposer untuk menginstal semua dependensi, tapi pertama kita akan membutuhkan struktur aplikasi untuk menginstal ke dalam. Cabang "mengembangkan" Laravel's Github repositori adalah rumah bagi struktur aplikasi ini. Namun, pada saat menulis artikel ini, Laravel 4 adalah masih dalam versi beta, jadi saya perlu dipersiapkan untuk struktur ini untuk mengubah setiap saat. Dengan menambahkan Laravel sebagai repositori berjarak, kita dapat menarik perubahan ini setiap kali kita perlu. Bahkan, sementara sesuatu dalam modus beta, itu adalah praktik yang baik untuk menjalankan perintah tersebut setelah setiap update komposer. Namun, Laravel 4 sekarang adalah versi terbaru, stabil.

1	git remote add laravel https://github.com/laravel/laravel
2	git fetch laravel
3	git merge laravel/develop
4	git add . && git commit -am "commit the laravel application structure"

Jadi kita memiliki struktur aplikasi, tetapi semua file perpustakaan yang Laravel tidak belum diinstal. Anda akan melihat akar dari aplikasi kita ada file bernama composer.json. Ini adalah file yang akan terus melacak jumlah semua dependensi yang memerlukan aplikasi Laravel kami. Sebelum kami memberitahu komposer men-download dan menginstal mereka, mari kita pertama kali menambahkan beberapa dependensi yang lebih banyak bahwa kita akan membutuhkan. Kami akan menambahkan:

Jeffrey cara Generator: beberapa perintah yang sangat berguna untuk lebih meningkatkan alur kerja kami dengan secara otomatis menghasilkan file tersembunyi: bagi kita.
Kumis Laravel 4: Ini akan memungkinkan kita untuk mulus menggunakan Mustache.php di proyek Laravel kami, sama seperti kita Blade.
Twitter Bootstrap: Kami akan menggunakan file kurang dari proyek ini untuk mempercepat pembangunan front-end kami.
PHPUnit: Kami akan melakukan beberapa TDD untuk API JSON kami, PHPUnit akan mesin pengujian kami.
Ejekan: Ejekan akan membantu kita "mengejek" objek selama pengujian kami.

PHPUnit dan olok-olok hanya diperlukan dalam lingkungan pengembangan kami, jadi kita akan menentukan bahwa dalam file composer.json kami.

Composer.JSON

{
  "require": {
    "laravel/framework": "4.0.*",
    "way/generators": "dev-master",
    "twitter/bootstrap": "dev-master",
    "conarwelsh/mustache-l4": "dev-master"
  },
  "require-dev": {
    "phpunit/phpunit": "3.7.*",
    "mockery/mockery": "0.7.*"
  },
  "autoload": {
    "classmap": [
      "app/commands",
      "app/controllers",
      "app/models",
      "app/database/migrations",
      "app/database/seeds",
      "app/tests/TestCase.php"
    ]
  },
  "scripts": {
    "post-update-cmd": "php artisan optimize"
  },
  "minimum-stability": "dev"
}

Sekarang kita hanya perlu memberitahu komposer untuk melakukan semua pekerjaan kaki kami! Di bawah ini, melihat--dev beralih, kami memberitahu komposer bahwa kita berada dalam lingkungan pengembangan kami dan bahwa hal itu juga harus menginstal semua dependensi kita terdaftar dalam "memerlukan-dev".

1	composer install --dev

Setelah itu selesai menginstal, kita akan perlu menginformasikan Laravel beberapa dependensi kita. Laravel menggunakan "penyedia jasa" untuk tujuan ini. Penyedia layanan ini pada dasarnya hanya mengatakan kepada Laravel bagaimana kode mereka akan berinteraksi dengan aplikasi dan untuk menjalankan prosedur setup diperlukan. Buka app/config/app.php dan menambahkan dua item berikut ke array "penyedia". Tidak semua paket memerlukan ini, hanya mereka yang akan meningkatkan atau mengubah fungsi Laravel.

App/config/App.php

...

'Way\Generators\GeneratorsServiceProvider',
'Conarwelsh\MustacheL4\MustacheL4ServiceProvider',

...

Terakhir, kita hanya perlu melakukan beberapa tweak aplikasi generik untuk menyelesaikan instalasi Laravel kami. Mari kita membuka bootstrap/start.php dan memberitahu Laravel nama mesin kami sehingga dapat menentukan apa lingkungan yang dalam.

bootstrap/Start.php

/*
|--------------------------------------------------------------------------
| Detect The Application Environment
|--------------------------------------------------------------------------
|
| Laravel takes a dead simple approach to your application environments
| so you can just specify a machine name or HTTP host that matches a
| given environment, then we will automatically detect it for you.
|
*/

$env = $app->detectEnvironment(array(

  'local' => array('your-machine-name'),

));

Ganti "your-mesin-name" dengan apa pun yang host untuk mesin Anda. Jika Anda tidak yakin tentang apa nama mesin yang tepat, Anda dapat hanya jenis hostname pada prompt perintah (pada Mac atau Linux), mencetak apa pun merupakan nilai yang dimiliki dalam pengaturan ini.

Kami ingin pandangan kami mampu disajikan kepada klien kami dari permintaan web. Saat ini, pandangan kami disimpan di luar kami folder publik, yang berarti bahwa mereka tidak dapat diakses oleh publik. Untungnya, Laravel membuatnya sangat mudah untuk memindahkan atau menambahkan folder Lihat lainnya. Buka app/config/view.php dan mengubah jalan pengaturan untuk menunjuk ke folder publik kami. Pengaturan ini bekerja seperti pribumi PHP termasuk jalan, itu akan memeriksa di setiap folder sampai menemukan file tampilan pencocokan, sehingga merasa bebas untuk menambahkan beberapa di sini:

App/config/View.php

1	'paths' => array(__DIR__.'/../../public/views'),

Selanjutnya Anda akan perlu untuk mengkonfigurasi database Anda. Buka app/config/database.php dan menambahkan dalam pengaturan database Anda.

Catatan: Dianjurkan untuk menggunakan 127.0.0.1 bukan localhost. Anda mendapatkan sedikit dorongan kinerja pada kebanyakan sistem, dan dengan beberapa konfigurasi sistem, localhost akan tidak bahkan terhubung dengan benar.

Akhirnya, Anda hanya perlu memastikan bahwa folder penyimpanan dapat ditulisi.

1	chmod -R 755 app/storage

Laravel sekarang terinstal, dengan semua dependensi, serta dependensi kita sendiri. Sekarang mari kita setup instalasi tulang punggung kami!

Seperti composer.json kami dipasang semua dependensi sisi server kami, kami akan membuat package.json di folder publik kami untuk menginstal semua dependensi sisi klien kami.

Untuk dependensi sisi klien kami, kami akan menggunakan:

Underscore.js: Ini adalah ketergantungan dari Backbone.js, dan toolbelt berguna fungsi.
Backbone.js: Ini adalah MVC sisi klien kami bahwa kami akan menggunakan untuk membangun keluar aplikasi kita.
Mustache.js: Versi Javascript Perpustakaan template kami, dengan menggunakan bahasa template yang sama baik pada klien dan server, kita dapat berbagi dilihat, sebagai lawan dari duplikasi logika.

Public/Package.JSON

{
  "name": "nettuts-laravel4-and-backbone",
  "version": "0.0.1",
  "private": true,
  "dependencies": {
    "underscore": "*",
    "backbone": "*",
    "mustache": "*"
  }
}

Sekarang hanya beralih ke dalam folder publik, dan menjalankan instalasi npm. Setelah itu selesai, memungkinkan beralih kembali ke akar aplikasi kami sehingga kita siap untuk sisa dari kami perintah.

1	cd public
2	npm install
3	cd ..

Manajer paket menyelamatkan kita dari satu ton kerja, jika Anda ingin memperbarui salah satu perpustakaan ini, Semua harus Anda lakukan adalah menjalankan npm update atau update komposer. Juga, jika Anda ingin mengunci salah satu perpustakaan tersebut dalam versi tertentu, Semua harus Anda lakukan adalah menentukan nomor versi, dan manajer paket akan menangani sisanya.

Untuk menyelesaikan proses setup kami kita hanya akan menambahkan dalam semua proyek dasar file dan folder yang akan kita butuhkan, dan kemudian mengujinya untuk memastikan hal itu semua bekerja seperti yang diharapkan.

Kita harus menambahkan folder berikut:

masyarakat views
Umum/views/layouts
Umum/js
Umum/css

Dan file-file berikut:

Public/CSS/Styles.Less
Public/JS/App.js
Public/views/App.mustache

Untuk mencapai hal ini, kita dapat menggunakan satu-kapal:

1	mkdir public/views public/views/layouts public/js public/css && touch public/css/styles.less public/js/app.js public/views/app.mustache

Twitter Bootstrap juga memiliki dua dependensi JavaScript yang akan kita butuhkan, jadi mari kita hanya menyalin mereka dari folder Penjual ke folder publik kami. Mereka adalah:

html5shiv.js: memungkinkan kita untuk menggunakan unsur-unsur HTML5 tanpa takut browser lama yang tidak mendukung mereka
bootstrap.min.js: mendukung JavaScript perpustakaan untuk Twitter Bootstrap

1	cp vendor/twitter/bootstrap/docs/assets/js/html5shiv.js public/js/html5shiv.js
2	cp vendor/twitter/bootstrap/docs/assets/js/bootstrap.min.js public/js/bootstrap.min.js

Untuk file tata letak kami, Twitter Bootstrap juga menyediakan kami dengan beberapa template bagus starter untuk bekerja dengan, jadi mari kita menyalin satu ke folder layout kami untuk kepala mulai:

1	cp vendor/twitter/bootstrap/docs/examples/starter-template.html public/views/layouts/application.blade.php

Perhatikan bahwa saya menggunakan ekstensi pisau di sini, ini bisa sama seperti mudah template kumis, tapi aku ingin menunjukkan kepada Anda betapa mudahnya untuk mencampur mesin template. Karena letak kami akan diberikan pada beban halaman, dan tidak perlu kembali diberikan oleh klien, kami aman untuk menggunakan PHP di sini secara eksklusif. Jika karena alasan tertentu Anda menemukan diri Anda perlu untuk membuat file ini pada sisi klien, Anda akan ingin untuk beralih file ini menggunakan mesin template kumis sebaliknya.

Sekarang bahwa kita memiliki semua file dasar kami di tempat, mari kita menambahkan beberapa konten starter yang bisa kita gunakan untuk menguji bahwa semuanya bekerja seperti yang kita harapkan. Aku menyediakan Anda dengan beberapa Rintisan bertopik dasar untuk Anda mulai.

Public/CSS/Styles.Less

Kami hanya akan mengimpor kericau Bootstrap file dari direktori vendor dibandingkan dengan menyalin mereka. Hal ini memungkinkan kita untuk update Twitter Bootstrap dengan apa-apa kecuali sebuah update komposer.

Kita mendeklarasikan variabel kami pada akhir file, kompilator kurang akan mengetahui nilai semua variabel yang sebelum melakukan penguraian yang kurang ke dalam CSS. Ini berarti bahwa dengan mendefinisikan ulang variabel Twitter Bootstrap pada akhir file, nilai akan benar-benar berubah untuk semua file yang disertakan, yang mengijinkan kita melakukan menimpa sederhana tanpa memodifikasi file inti Twitter Bootstrap.

/**
 * Import Twitter Bootstrap Base File
 ******************************************************************************************
 */
@import "../../vendor/twitter/bootstrap/less/bootstrap";


/**
 * Define App Styles
 * Do this before the responsive include, so that it can override properly as needed.
 ******************************************************************************************
 */
body {
  padding-top: 60px; /* 60px to make the container go all the way to the bottom of the topbar */
}

/* this will set the position of our alerts */
#notifications {
  width: 300px;
  position: fixed;
  top: 50px;
  left: 50%;
  margin-left: -150px;
  text-align: center;
}

/**
 * Import Bootstrap's Responsive Overrides
 * now we allow bootstrap to set the overrides for a responsive layout
 ******************************************************************************************
 */
@import "../../vendor/twitter/bootstrap/less/responsive";


/**
 * Define our variables last, any variable declared here will be used in the includes above
 * which means that we can override any of the variables used in the bootstrap files easily
 * without modifying any of the core bootstrap files
 ******************************************************************************************
 */

// Scaffolding
// -------------------------
@bodyBackground:    #f2f2f2;
@textColor:       #575757;

// Links
// -------------------------
@linkColor:       #41a096;

// Typography
// -------------------------
@sansFontFamily:    Arial, Helvetica, sans-serif;

Public/JS/App.js

Sekarang kita akan bungkus semua kode kami segera-menerapkan--fungsi anonim yang melewati beberapa objek global. Kami akan kemudian alias objek-objek ini global untuk sesuatu yang lebih berguna bagi kami. Juga, kita akan cache beberapa jQuery objek dalam fungsi siap dokumen.

//alias the global object
//alias jQuery so we can potentially use other libraries that utilize $
//alias Backbone to save us on some typing
(function(exports, $, bb){

  //document ready
  $(function(){

    /**
     ***************************************
     * Cached Globals
     ***************************************
     */
    var $window, $body, $document;

    $window  = $(window);
    $document = $(document);
    $body   = $('body');


  });//end document ready

}(this, jQuery, Backbone));

Public/views/layouts/Application.Blade.php

Berikutnya adalah hanya sebuah sederhana tata letak file HTML. Kami namun menggunakan penolong aset dari Laravel untuk membantu kami dalam membuat jalan untuk aset kami. Ini adalah praktik yang baik untuk menggunakan jenis pembantu, karena jika Anda pernah terjadi untuk memindahkan proyek Anda ke sub-folder, semua link akan masih bekerja.

Kita memastikan bahwa kita termasuk semua dependensi kita dalam file ini, dan juga menambahkan ketergantungan jQuery. Aku memilih untuk meminta jQuery dari Google CDN, karena kemungkinan pengguna mengunjungi situs ini sudah akan memiliki salinan dari CDN yang di-cache dalam browser mereka, menyelamatkan kita dari keharusan untuk menyelesaikan permintaan HTTP untuk itu.

Satu hal penting yang perlu diperhatikan di sini adalah cara di mana kita Apakah bersarang pandangan kami. Kumis tidak memiliki blok bagian seperti pisau melakukannya, sebaliknya, isi dari tampilan bersarang akan dibuat tersedia di bawah sebuah variabel dengan nama bagian. Aku akan menunjuk ini keluar kapan kami memberikan pandangan ini dari rute kami.

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="utf-8">
 <title>Laravel4 & Backbone | Nettuts</title>
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <meta name="description" content="A single page blog built using Backbone.js, Laravel, and Twitter Bootstrap">
 <meta name="author" content="Conar Welsh">

 <link href="{{ asset('css/styles.css') }}" rel="stylesheet">

 <!-- HTML5 shim, for IE6-8 support of HTML5 elements -->
 <!--[if lt IE 9]>
 <script src="{{ asset('js/html5shiv.js') }}"></script>
 <![endif]-->
</head>
<body>

 <div id="notifications">
 </div>

 <div class="navbar navbar-inverse navbar-fixed-top">
  <div class="navbar-inner">
   <div class="container">
    <button type="button" class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
     <span class="icon-bar"></span>
     <span class="icon-bar"></span>
     <span class="icon-bar"></span>
    </button>
    <a class="brand" href="#">Nettuts Tutorial</a>
    <div class="nav-collapse collapse">
     <ul class="nav">
      <li class="active"><a href="#">Blog</a></li>
     </ul>
    </div><!--/.nav-collapse -->
   </div>
  </div>
 </div>

 <div class="container" data-role="main">
  {{--since we are using mustache as the view, it does not have a concept of sections like blade has, so instead of using @yield here, our nested view will just be a variable that we can echo--}}

  {{ $content }}

 </div> <!-- /container -->

 <!-- Placed at the end of the document so the pages load faster -->
 <script src="//ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script> <!-- use Google CDN for jQuery to hopefully get a cached copy -->
 <script src="{{ asset('node_modules/underscore/underscore-min.js') }}"></script>
 <script src="{{ asset('node_modules/backbone/backbone-min.js') }}"></script>
 <script src="{{ asset('node_modules/mustache/mustache.js') }}"></script>
 <script src="{{ asset('js/bootstrap.min.js') }}"></script>
 <script src="{{ asset('js/app.js') }}"></script>
 @yield('scripts')
</body>
</html>

Public/views/App.mustache

Berikutnya adalah hanya pandangan sederhana yang kita akan sarang menjadi layout kami.

1	<dl>
2	<dt>Q. What did Biggie say when he watched inception?</dt>
3	<dd>A. "It was all a dream!"</dd>
4	</dl>

App/Routes.php

Laravel harus sudah menyediakan Anda dengan rute standar, semua yang kita lakukan di sini adalah mengubah nama tampilan yang rute yang akan membuat.

Ingat dari atas, saya katakan bahwa pandangan bersarang akan menjadi tersedia di bawah variabel bernama apa pun adalah bagian orangtua? Nah, ketika Anda sarang pandangan, parameter pertama ke fungsi adalah nama bagian:

1	View::make('view.path')->nest($sectionName, $nestedViewPath, $viewVariables);

Dalam perintah sarang kita kita dipanggil bagian "konten", yang berarti jika kami echo $content dari tata letak kami, kami akan mendapatkan isi diberikan pandangan itu. Jika kita ingin kembali View::make('layouts.application')-> sarang ('foobar', 'apl'); maka kita lihat bersarang akan tersedia di bawah sebuah variabel yang bernama $foobar.

<?php

//backbone app route
Route::get('/', function()
{
  //change our view name to the view we created in a previous step
  //notice that we do not need to provide the .mustache extension
  return View::make('layouts.application')->nest('content', 'app');
});

Dengan semua file kita dasar di tempat, kita dapat menguji untuk memastikan semuanya berjalan OK. Laravel 4 memanfaatkan baru PHP web server untuk menyediakan kami dengan sebuah lingkungan pengembangan kecil yang besar. Begitu lama untuk hari-hari memiliki pengaturan virtual host juta pada mesin pengembangan Anda untuk setiap proyek yang Anda bekerja pada!

Catatan: Pastikan bahwa Anda telah menyusun file Anda kurang pertama!

1	php artisan serve

Jika Anda mengikuti dengan benar, Anda harus tertawa histeris di mengerikan saya rasa humor, dan semua aset kami harus dimasukkan dengan benar ke halaman.

Bagian 2: Laravel 4 JSON API

Sekarang kita akan membangun API yang akan kekuatan aplikasi tulang punggung kami. Laravel 4 membuat ini proses yang mudah.

Pedoman API

Pertama mari kita pergi ke beberapa pedoman umum untuk menjaga dalam pikiran ketika kita membangun API kami:

Kode status: Tanggapan harus menjawab dengan kode status yang tepat, melawan godaan untuk hanya menempatkan {kesalahan: "ini adalah pesan galat"} dalam tubuh tanggapan Anda. Menggunakan protokol HTTP penuhnya!
- 200: sukses
- 201: sumber daya yang dibuat
- 204: sukses, tapi tidak ada konten untuk kembali
- 400: permintaan tidak terpenuhi kesalahan //validation
- 401: tidak dikonfirmasi
- 403: penolakan untuk menanggapi //wrong identitasnya, tidak memiliki izin (UN dimiliki sumber daya)
- 404: tidak ditemukan
- 500: kesalahan lainnya
Metode sumber daya: meskipun controller akan melayani berbagai sumber daya, mereka masih harus memiliki perilaku yang sangat mirip. Lebih diprediksi API Anda adalah, semakin mudah untuk menerapkan dan mengadopsi.
- Indeks: kembali koleksi sumber.
- Tampilkan: kembali sumber daya tunggal.
- membuat: kembalikan formulir. Formulir ini harus detail kolom yang harus diisi, validasi, dan label sebaik mungkin. Serta hal lainnya yang dibutuhkan untuk benar menciptakan sumber daya. Meskipun ini adalah JSON API, hal ini sangat berguna untuk mengembalikan sebuah formulir di sini. Komputer dan seseorang dapat mengurai melalui formulir ini, dan sangat mudah memecahkan item yang diperlukan untuk mengisi successsfully formulir ini. Ini adalah cara yang sangat mudah untuk "dokumen" kebutuhan Anda API.
- Toko: toko baru sumber daya dan kembali dengan kode status tepat: 201.
- mengedit: kembalikan formulir diisi dengan keadaan saat ini sumber daya. Formulir ini harus detail kolom yang harus diisi, validasi, dan label sebaik mungkin. Serta hal lainnya yang dibutuhkan untuk benar mengedit sumber daya.
- Update: Update sumber daya yang ada dan kembali dengan kode status yang tepat.
- Hapus: menghapus sumber daya yang ada dan kembali dengan kode status tepat: 204.

Routing & versi

API dirancang untuk menjadi sekitar untuk sementara. Hal ini tidak seperti situs web di mana Anda hanya dapat mengubah fungsionalitas di drop dari sepeser pun. Jika Anda memiliki program yang menggunakan API Anda, mereka tidak akan bahagia dengan Anda jika Anda mengubah hal-hal di sekitar dan istirahat program mereka. Untuk alasan ini, sangat penting bahwa Anda menggunakan versi.

Kami selalu dapat membuat "versi dua" dengan tambahan, atau berubah fungsi, dan memungkinkan program kami subscribing untuk opt-in untuk perubahan ini, daripada dipaksakan.

Laravel menyediakan kami dengan kelompok-kelompok rute yang sempurna untuk tempat ini, kode berikut di atas rute pertama kami:

<?php

//create a group of routes that will belong to APIv1
Route::group(array('prefix' => 'v1'), function()
{
  //... insert API routes here...
});

Menghasilkan sumber daya

Kita akan menggunakan generator Jeffrey cara untuk menghasilkan sumber daya kami. Ketika kita menghasilkan sumber daya, itu akan membuat item berikut untuk kami:

Controller
Model
Pemandangan (index.blade.php, show.blade.php, create.blade.php, edit.blade.php)
Migrasi
Benih

Kami hanya akan membutuhkan dua sumber daya untuk aplikasi ini: sumber daya pos dan sumber daya komentar.

Catatan: di update terbaru Generator, saya telah menerima izin kesalahan karena server web saya cara setup. Untuk memperbaiki masalah ini, Anda harus membiarkan hak akses menulis ke folder yang Generator menulis temp file.

1	sudo chmod -R 755 vendor/way/generators/src/Way/

Jalankan perintah menghasilkan: sumber daya

1	php artisan generate:resource post --fields="title:string, content:text, author_name:string"
2
3	php artisan generate:resource comment --fields="content:text, author_name:string, post_id:integer"

Anda sekarang harus berhenti sejenak untuk menyelidiki semua file yang generator menciptakan bagi kita.

Menyesuaikan sumber daya yang dihasilkan

Perintah menghasilkan: sumber daya menyelamatkan kita banyak pekerjaan, tetapi karena kami konfigurasi yang unik, kita masih akan perlu membuat beberapa modifikasi.

Pertama-tama generator ditempatkan pandangan itu diciptakan di folder app dilihat, jadi kita perlu memindahkan mereka ke folder umum dilihat

1	mv app/views/posts public/views/posts
2	mv app/views/comments public/views/comments

App/Routes.php

Kami memutuskan bahwa kami ingin API kami menjadi berversi, jadi kita perlu memindahkan rute yang generator menciptakan kita ke dalam kelompok versi. Kita akan juga ingin namespace controller kami dengan versi yang sesuai, sehingga kita dapat memiliki set yang berbeda untuk setiap versi yang kita membangun. Juga sumber komentar perlu bersarang di bawah sumber posting.

<?php

//create a group of routes that will belong to APIv1
Route::group(array('prefix' => 'v1'), function()
{
  //... insert API routes here...
  Route::resource('posts', 'V1\PostsController'); //notice the namespace
  Route::resource('posts.comments', 'V1\PostsCommentsController'); //notice the namespace, and the nesting
});

//backbone app route
Route::get('/', function()
{
  //change our view name to the view we created in a previous step
  //notice that we do not need to provide the .mustache extension
  return View::make('layouts.application')->nest('content', 'app');
});

Karena kita ber-namespace controller kami, kami harus memindahkan mereka ke dalam folder mereka sendiri untuk organisasi, mari kita membuat folder bernama V1 dan memindahkan controller kami dihasilkan ke dalamnya. Juga, karena kami bersarang kami controller komentar di bawah posting controller, mari kita mengubah nama dari controller yang mencerminkan hubungan.

1	mkdir app/controllers/V1
2	mv app/controllers/PostsController.php app/controllers/V1/
3	mv app/controllers/CommentsController.php app/controllers/V1/PostsCommentsController.php

Kita akan perlu untuk memperbarui file controller untuk mencerminkan perubahan kami juga. Pertama-tama kita perlu namespace mereka, dan karena mereka ber-namespace, setiap kelas di luar namespace yang akan perlu untuk diimpor secara manual dengan menggunakan pernyataan.

app/controllers/PostsController.php

<?php
//use our new namespace
namespace V1;

//import classes that are not in this new namespace
use BaseController;

class PostsController extends BaseController {

app/controllers/PostsCommentsController.php

Kita juga perlu untuk memperbarui CommentsController kami dengan nama baru kami: PostsCommentsController

<?php
//use our new namespace
namespace V1;

//import classes that are not in this new namespace
use BaseController;

//rename our controller class
class PostsCommentsController extends BaseController {

Menambahkan dalam repositori

Secara default, repositori bukan merupakan bagian dari Laravel. Laravel ini sangat fleksibel meskipun, dan membuatnya sangat mudah untuk menambahkan mereka. Kita akan menggunakan repositori untuk membantu kita memisahkan logika kami untuk kembali kode kegunaan, serta untuk pengujian. Untuk sekarang kita akan hanya mendapatkan setup untuk menggunakan repositori, kami akan menambahkan pada logika tepat kemudian.

Mari kita membuat folder untuk menyimpan repositori kami di:

1	mkdir app/repositories

Untuk membiarkan kami auto-loader tahu tentang folder baru ini, kita perlu untuk menambahkannya ke file composer.json kami. Lihatlah bagian diperbarui "autoload" file kami, dan Anda akan melihat bahwa kita ditambahkan dalam folder repositori.

Composer.JSON

{
  "require": {
    "laravel/framework": "4.0.*",
    "way/generators": "dev-master",
    "twitter/bootstrap": "dev-master",
    "conarwelsh/mustache-l4": "dev-master"
  },
  "require-dev": {
    "phpunit/phpunit": "3.7.*",
    "mockery/mockery": "0.7.*"
  },
  "autoload": {
    "classmap": [
      "app/commands",
      "app/controllers",
      "app/models",
      "app/database/migrations",
      "app/database/seeds",
      "app/tests/TestCase.php",
      "app/repositories"
    ]
  },
  "scripts": {
    "post-update-cmd": "php artisan optimize"
  },
  "minimum-stability": "dev"
}

Penyemaian Database kami

Benih database adalah alat yang berguna, mereka memberikan kami dengan cara yang mudah untuk mengisi database kami dengan beberapa konten. Generator memberikan kita dengan dasar file untuk pembibitan, kita hanya perlu menambahkan beberapa biji yang sebenarnya.

app/database/seeds/PostsTableSeeder.php

<?php

class PostsTableSeeder extends Seeder {

  public function run()
  {
    $posts = array(
      array(
        'title'    => 'Test Post',
        'content'   => 'Lorem ipsum Reprehenderit velit est irure in enim in magna aute occaecat qui velit ad.',
        'author_name' => 'Conar Welsh',
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
      array(
        'title'    => 'Another Test Post',
        'content'   => 'Lorem ipsum Reprehenderit velit est irure in enim in magna aute occaecat qui velit ad.',
        'author_name' => 'Conar Welsh',
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
    );

    // Uncomment the below to run the seeder
    DB::table('posts')->insert($posts);
  }

}

app/database/seeds/CommentsTableSeeder.php

<?php

class CommentsTableSeeder extends Seeder {

  public function run()
  {
    $comments = array(
      array(
        'content'   => 'Lorem ipsum Nisi dolore ut incididunt mollit tempor proident eu velit cillum dolore sed',
        'author_name' => 'Testy McTesterson',
        'post_id'   => 1,
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
      array(
        'content'   => 'Lorem ipsum Nisi dolore ut incididunt mollit tempor proident eu velit cillum dolore sed',
        'author_name' => 'Testy McTesterson',
        'post_id'   => 1,
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
      array(
        'content'   => 'Lorem ipsum Nisi dolore ut incididunt mollit tempor proident eu velit cillum dolore sed',
        'author_name' => 'Testy McTesterson',
        'post_id'   => 2,
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
    );

    // Uncomment the below to run the seeder
    DB::table('comments')->insert($comments);
  }

}

Jangan lupa untuk menjalankan komposer dump-autoload untuk membiarkan komposer auto loader tahu tentang file migrasi baru!

1	composer dump-autoload

Sekarang kita dapat menjalankan migrasi dan benih kami database. Laravel menyediakan kami dengan satu perintah untuk melakukan keduanya:

1	php artisan migrate --seed

Tes

Pengujian adalah salah satu topik tersebut dalam pengembangan yang tidak ada yang bisa berdebat pentingnya, namun kebanyakan orang cenderung untuk mengabaikan hal itu karena kurva belajar. Pengujian benar-benar tidak sulit dan dapat secara dramatis meningkatkan aplikasi Anda. Untuk tutorial ini, kita akan setup beberapa tes dasar untuk membantu kami memastikan bahwa API kami berfungsi dengan baik. Kita akan membangun gaya API TDD ini. Aturan TDD menyatakan bahwa kita tidak diperbolehkan untuk menulis kode produksi sampai kita telah gagal tes yang menjamin itu. Namun, jika saya untuk memandu Anda melalui setiap tes secara individual, ini akan membuktikan untuk menjadi sebuah tutorial yang sangat panjang, sehingga kepentingan keringkasannya, aku hanya akan menyediakan Anda dengan beberapa tes untuk bekerja dari, dan kemudian kode yang benar untuk membuat mereka tes lulus sesudahnya.

Sebelum kita menulis tes apapun meskipun, kita harus terlebih dahulu memeriksa status pengujian saat ini aplikasi kita. Karena kita diinstal PHPUnit melalui komposer, kami memiliki binari tersedia bagi kita untuk menggunakan. Semua yang perlu Anda lakukan adalah menjalankan:

1	vendor/phpunit/phpunit/phpunit.php

Whoops! Kita sudah memiliki kegagalan! Ujian yang gagal adalah benar-benar sebuah contoh tes yang datang pra-instal di struktur aplikasi Laravel kami, tes ini terhadap route default yang juga diinstal dengan struktur aplikasi Laravel. Karena kami diubah rute ini, kita tidak bisa terkejut bahwa tes gagal. Kita bisa Namun, hanya menghapus tes ini sama sekali karena tidak berlaku untuk aplikasi kita.

1	rm app/tests/ExampleTest.php

Jika Anda menjalankan perintah PHPUnit lagi, Anda akan melihat bahwa tidak ada tes dieksekusi, dan kami memiliki yang bersih untuk pengujian.

Catatan: mungkin bahwa jika Anda memiliki versi dari Jeffrey cara generator yang Anda benar-benar akan memiliki beberapa tes di sana yang diciptakan oleh orang Generator, dan tes tersebut mungkin gagal. Hanya menghapus atau menimpa tes itu dengan yang ditemukan di bawah ini untuk melanjutkan.

Untuk tutorial ini kita akan menguji controller kami dan kami repositori. Mari kita membuat beberapa folder untuk menyimpan tes ini di:

1	mkdir app/tests/controllers app/tests/repositories

Sekarang untuk test file. Kita akan menggunakan ejekan untuk mengejek kami repositori untuk pengujian controller kami. Objek olok-olok lakukan seperti namanya mereka, mereka "mengejek" objek dan melaporkan kembali kepada kami pada bagaimana objek-objek yang berinteraksi dengan.

Dalam kasus tes controller, kita tidak benar-benar ingin repositori untuk dipanggil, setelah semua, ini adalah tes controller, tidak tes repositori. Jadi ejekan akan mengatur kita objek untuk menggunakan bukan repositori kami, dan biarkan kami tahu apakah objek tersebut dipanggil sebagai kami mengharapkan mereka.

Untuk tarik ini, kita akan memiliki untuk memberitahu controller menggunakan benda kami "diejek" bukan hal yang nyata. Kami hanya akan memberitahu aplikasi kita untuk menggunakan contoh yang diejek waktu berikutnya kelas tertentu yang diminta. Perintah seperti ini:

1	App::instance($classToReplace, $instanceOfClassToReplaceWith);

Proses mengejek secara keseluruhan akan pergi sesuatu seperti ini:

Membuat objek olok-olok baru, memberikan nama kelas yang untuk mengejek.
Memberitahu ejekan objek metode yang itu harus mengharapkan untuk menerima, berapa kali ini harus menerima metode, dan apa metode yang harus kembali.
Gunakan perintah yang ditunjukkan di atas untuk memberitahu aplikasi kita untuk menggunakan objek olok-olok baru ini bukan default.
Menjalankan controller metode seperti biasa.
Menyatakan respon.

app/tests/controllers/CommentsControllerTest.php

<?php

class CommentsControllerTest extends TestCase {

  /**
   ************************************************************************
   * Basic Route Tests
   * notice that we can use our route() helper here!
   ************************************************************************
   */

  //test that GET /v1/posts/1/comments returns HTTP 200
  public function testIndex()
  {
    $response = $this->call('GET', route('v1.posts.comments.index', array(1)) );
    $this->assertTrue($response->isOk());
  }

  //test that GET /v1/posts/1/comments/1 returns HTTP 200
  public function testShow()
  {
    $response = $this->call('GET', route('v1.posts.comments.show', array(1,1)) );
    $this->assertTrue($response->isOk());
  }

  //test that GET /v1/posts/1/comments/create returns HTTP 200
  public function testCreate()
  {
    $response = $this->call('GET', route('v1.posts.comments.create', array(1)) );
    $this->assertTrue($response->isOk());
  }

  //test that GET /v1/posts/1/comments/1/edit returns HTTP 200
  public function testEdit()
  {
    $response = $this->call('GET', route('v1.posts.comments.edit', array(1,1)) );
    $this->assertTrue($response->isOk());
  }

  /**
   *************************************************************************
   * Tests to ensure that the controller calls the repo as we expect
   * notice we are "Mocking" our repository
   *
   * also notice that we do not really care about the data or interactions
   * we merely care that the controller is doing what we are going to want
   * it to do, which is reach out to our repository for more information
   *************************************************************************
   */

  //ensure that the index function calls our repository's "findAll" method
  public function testIndexShouldCallFindAllMethod()
  {
    //create our new Mockery object with a name of CommentRepositoryInterface
    $mock = Mockery::mock('CommentRepositoryInterface');

    //inform the Mockery object that the "findAll" method should be called on it once
    //and return a string value of "foo"
    $mock->shouldReceive('findAll')->once()->andReturn('foo');

    //inform our application that we have an instance that it should use
    //whenever the CommentRepositoryInterface is requested
    App::instance('CommentRepositoryInterface', $mock);

    //call our controller route
    $response = $this->call('GET', route('v1.posts.comments.index', array(1)));

    //assert that the response is a boolean value of true
    $this->assertTrue(!! $response->original);
  }

  //ensure that the show method calls our repository's "findById" method
  public function testShowShouldCallFindById()
  {
    $mock = Mockery::mock('CommentRepositoryInterface');
    $mock->shouldReceive('findById')->once()->andReturn('foo');
    App::instance('CommentRepositoryInterface', $mock);

    $response = $this->call('GET', route('v1.posts.comments.show', array(1,1)));
    $this->assertTrue(!! $response->original);
  }

  //ensure that our create method calls the "instance" method on the repository
  public function testCreateShouldCallInstanceMethod()
  {
    $mock = Mockery::mock('CommentRepositoryInterface');
    $mock->shouldReceive('instance')->once()->andReturn(array());
    App::instance('CommentRepositoryInterface', $mock);

    $response = $this->call('GET', route('v1.posts.comments.create', array(1)));
    $this->assertViewHas('comment');
  }

  //ensure that the edit method calls our repository's "findById" method
  public function testEditShouldCallFindByIdMethod()
  {
    $mock = Mockery::mock('CommentRepositoryInterface');
    $mock->shouldReceive('findById')->once()->andReturn(array());
    App::instance('CommentRepositoryInterface', $mock);

    $response = $this->call('GET', route('v1.posts.comments.edit', array(1,1)));
    $this->assertViewHas('comment');
  }

  //ensure that the store method should call the repository's "store" method
  public function testStoreShouldCallStoreMethod()
  {
    $mock = Mockery::mock('CommentRepositoryInterface');
    $mock->shouldReceive('store')->once()->andReturn('foo');
    App::instance('CommentRepositoryInterface', $mock);

    $response = $this->call('POST', route('v1.posts.comments.store', array(1)));
    $this->assertTrue(!! $response->original);
  }

  //ensure that the update method should call the repository's "update" method
  public function testUpdateShouldCallUpdateMethod()
  {
    $mock = Mockery::mock('CommentRepositoryInterface');
    $mock->shouldReceive('update')->once()->andReturn('foo');
    App::instance('CommentRepositoryInterface', $mock);

    $response = $this->call('PUT', route('v1.posts.comments.update', array(1,1)));
    $this->assertTrue(!! $response->original);
  }

  //ensure that the destroy method should call the repositories "destroy" method
  public function testDestroyShouldCallDestroyMethod()
  {
    $mock = Mockery::mock('CommentRepositoryInterface');
    $mock->shouldReceive('destroy')->once()->andReturn(true);
    App::instance('CommentRepositoryInterface', $mock);

    $response = $this->call('DELETE', route('v1.posts.comments.destroy', array(1,1)));
    $this->assertTrue( empty($response->original) );
  }


}

app/tests/controllers/PostsControllerTest.php

Selanjutnya, kita akan mengikuti prosedur yang tepat sama untuk tes PostsController

<?php

class PostsControllerTest extends TestCase {

  /**
   * Test Basic Route Responses
   */
  public function testIndex()
  {
    $response = $this->call('GET', route('v1.posts.index'));
    $this->assertTrue($response->isOk());
  }

  public function testShow()
  {
    $response = $this->call('GET', route('v1.posts.show', array(1)));
    $this->assertTrue($response->isOk());
  }

  public function testCreate()
  {
    $response = $this->call('GET', route('v1.posts.create'));
    $this->assertTrue($response->isOk());
  }

  public function testEdit()
  {
    $response = $this->call('GET', route('v1.posts.edit', array(1)));
    $this->assertTrue($response->isOk());
  }

  /**
   * Test that controller calls repo as we expect
   */
  public function testIndexShouldCallFindAllMethod()
  {
    $mock = Mockery::mock('PostRepositoryInterface');
    $mock->shouldReceive('findAll')->once()->andReturn('foo');
    App::instance('PostRepositoryInterface', $mock);

    $response = $this->call('GET', route('v1.posts.index'));
    $this->assertTrue(!! $response->original);
  }

  public function testShowShouldCallFindById()
  {
    $mock = Mockery::mock('PostRepositoryInterface');
    $mock->shouldReceive('findById')->once()->andReturn('foo');
    App::instance('PostRepositoryInterface', $mock);

    $response = $this->call('GET', route('v1.posts.show', array(1)));
    $this->assertTrue(!! $response->original);
  }

  public function testCreateShouldCallInstanceMethod()
  {
    $mock = Mockery::mock('PostRepositoryInterface');
    $mock->shouldReceive('instance')->once()->andReturn(array());
    App::instance('PostRepositoryInterface', $mock);

    $response = $this->call('GET', route('v1.posts.create'));
    $this->assertViewHas('post');
  }

  public function testEditShouldCallFindByIdMethod()
  {
    $mock = Mockery::mock('PostRepositoryInterface');
    $mock->shouldReceive('findById')->once()->andReturn(array());
    App::instance('PostRepositoryInterface', $mock);

    $response = $this->call('GET', route('v1.posts.edit', array(1)));
    $this->assertViewHas('post');
  }

  public function testStoreShouldCallStoreMethod()
  {
    $mock = Mockery::mock('PostRepositoryInterface');
    $mock->shouldReceive('store')->once()->andReturn('foo');
    App::instance('PostRepositoryInterface', $mock);

    $response = $this->call('POST', route('v1.posts.store'));
    $this->assertTrue(!! $response->original);
  }

  public function testUpdateShouldCallUpdateMethod()
  {
    $mock = Mockery::mock('PostRepositoryInterface');
    $mock->shouldReceive('update')->once()->andReturn('foo');
    App::instance('PostRepositoryInterface', $mock);

    $response = $this->call('PUT', route('v1.posts.update', array(1)));
    $this->assertTrue(!! $response->original);
  }

  public function testDestroyShouldCallDestroyMethod()
  {
    $mock = Mockery::mock('PostRepositoryInterface');
    $mock->shouldReceive('destroy')->once()->andReturn(true);
    App::instance('PostRepositoryInterface', $mock);

    $response = $this->call('DELETE', route('v1.posts.destroy', array(1)));
    $this->assertTrue( empty($response->original) );
  }

}

app/tests/repositories/EloquentCommentRepositoryTest.php

Sekarang untuk tes repositori. Dalam menulis tes controller kami, kami cukup banyak sudah memutuskan apa yang sebagian besar antarmuka akan terlihat seperti untuk repositori. Controller kami diperlukan metode berikut:

findById($id)
findAll()
instance($data)
Store($data)
Update ($id, $data)
Destroy($id)

Hanya metode lainnya yang kita akan ingin menambahkan di sini adalah metode validasi. Ini terutama akan menjadi metode pribadi untuk repositori untuk memastikan bahwa data aman untuk menyimpan atau update.

Tes ini, kita juga akan ditambahkan metode setUp, yang akan memungkinkan kita untuk menjalankan beberapa kode di kelas kami, sebelum pelaksanaan setiap tes. Metode setUp kami akan sangat sederhana, kami hanya memastikan bahwa setiap metode setUp yang didefinisikan di kelas induk juga disebut menggunakan parent:: setUp() dan kemudian menambahkan variabel kelas yang menyimpan instance dari repositori kami.

Kita akan menggunakan kekuatan Laravel's IoC wadah lagi untuk mendapatkan instance dari repositori kami. Perintah App::make() akan mengembalikan instance kelas diminta, sekarang tampaknya aneh bahwa kami tidak hanya melakukan $this-> repo = EloquentCommentRepository() baru, namun terus pikiran itu, kita akan kembali ke sana sejenak. Anda mungkin menyadari bahwa kami meminta untuk kelas yang disebut EloquentCommentRepository, tetapi dalam tes controller kami di atas, kita memanggil kami repositori CommentRepositoryInterface... menempatkan ini berpikir di belakang-kompor serta... explainations untuk keduanya datang, aku berjanji!

<?php

class EloquentCommentRepositoryTest extends TestCase {

  public function setUp()
  {
    parent::setUp();
    $this->repo = App::make('EloquentCommentRepository');
  }

  public function testFindByIdReturnsModel()
  {
    $comment = $this->repo->findById(1,1);
    $this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
  }

  public function testFindAllReturnsCollection()
  {
    $comments = $this->repo->findAll(1);
    $this->assertTrue($comments instanceof Illuminate\Database\Eloquent\Collection);
  }

  public function testValidatePasses()
  {
    $reply = $this->repo->validate(array(
      'post_id'   => 1,
      'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
      'author_name' => 'Testy McTesterson'
    ));

    $this->assertTrue($reply);
  }

  public function testValidateFailsWithoutContent()
  {
    try {
      $reply = $this->repo->validate(array(
        'post_id'   => 1,
        'author_name' => 'Testy McTesterson'
      ));
    }
    catch(ValidationException $expected)
    {
      return;
    }

    $this->fail('ValidationException was not raised');
  }

  public function testValidateFailsWithoutAuthorName()
  {
    try {
      $reply = $this->repo->validate(array(
        'post_id'   => 1,
        'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.'
      ));
    }
    catch(ValidationException $expected)
    {
      return;
    }

    $this->fail('ValidationException was not raised');
  }

  public function testValidateFailsWithoutPostId()
  {
    try {
      $reply = $this->repo->validate(array(
        'author_name' => 'Testy McTesterson',
        'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.'
      ));
    }
    catch(ValidationException $expected)
    {
      return;
    }

    $this->fail('ValidationException was not raised');
  }

  public function testStoreReturnsModel()
  {
    $comment_data = array(
      'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
      'author_name' => 'Testy McTesterson'
    );

    $comment = $this->repo->store(1, $comment_data);

    $this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
    $this->assertTrue($comment->content === $comment_data['content']);
    $this->assertTrue($comment->author_name === $comment_data['author_name']);
  }

  public function testUpdateSaves()
  {
    $comment_data = array(
      'content' => 'The Content Has Been Updated'
    );

    $comment = $this->repo->update(1, 1, $comment_data);

    $this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
    $this->assertTrue($comment->content === $comment_data['content']);
  }

  public function testDestroySaves()
  {
    $reply = $this->repo->destroy(1,1);
    $this->assertTrue($reply);

    try {
      $this->repo->findById(1,1);
    }
    catch(NotFoundException $expected)
    {
      return;
    }

    $this->fail('NotFoundException was not raised');
  }

  public function testInstanceReturnsModel()
  {
    $comment = $this->repo->instance();
    $this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
  }

  public function testInstanceReturnsModelWithData()
  {
    $comment_data = array(
      'title' => 'Un-validated title'
    );

    $comment = $this->repo->instance($comment_data);
    $this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
    $this->assertTrue($comment->title === $comment_data['title']);
  }

}

app/tests/repositories/EloquentPostRepositoryTest.php

<?php

class EloquentPostRepositoryTest extends TestCase {

  public function setUp()
  {
    parent::setUp();
    $this->repo = App::make('EloquentPostRepository');
  }

  public function testFindByIdReturnsModel()
  {
    $post = $this->repo->findById(1);
    $this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
  }

  public function testFindAllReturnsCollection()
  {
    $posts = $this->repo->findAll();
    $this->assertTrue($posts instanceof Illuminate\Database\Eloquent\Collection);
  }

  public function testValidatePasses()
  {
    $reply = $this->repo->validate(array(
      'title'    => 'This Should Pass',
      'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
      'author_name' => 'Testy McTesterson'
    ));

    $this->assertTrue($reply);
  }

  public function testValidateFailsWithoutTitle()
  {
    try {
      $reply = $this->repo->validate(array(
        'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
        'author_name' => 'Testy McTesterson'
      ));
    }
    catch(ValidationException $expected)
    {
      return;
    }

    $this->fail('ValidationException was not raised');
  }

  public function testValidateFailsWithoutAuthorName()
  {
    try {
      $reply = $this->repo->validate(array(
        'title'    => 'This Should Pass',
        'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.'
      ));
    }
    catch(ValidationException $expected)
    {
      return;
    }

    $this->fail('ValidationException was not raised');
  }

  public function testStoreReturnsModel()
  {
    $post_data = array(
      'title'    => 'This Should Pass',
      'content'   => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
      'author_name' => 'Testy McTesterson'
    );

    $post = $this->repo->store($post_data);

    $this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
    $this->assertTrue($post->title === $post_data['title']);
    $this->assertTrue($post->content === $post_data['content']);
    $this->assertTrue($post->author_name === $post_data['author_name']);
  }

  public function testUpdateSaves()
  {
    $post_data = array(
      'title' => 'The Title Has Been Updated'
    );

    $post = $this->repo->update(1, $post_data);

    $this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
    $this->assertTrue($post->title === $post_data['title']);
  }

  public function testDestroySaves()
  {
    $reply = $this->repo->destroy(1);
    $this->assertTrue($reply);

    try {
      $this->repo->findById(1);
    }
    catch(NotFoundException $expected)
    {
      return;
    }

    $this->fail('NotFoundException was not raised');
  }

  public function testInstanceReturnsModel()
  {
    $post = $this->repo->instance();
    $this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
  }

  public function testInstanceReturnsModelWithData()
  {
    $post_data = array(
      'title' => 'Un-validated title'
    );

    $post = $this->repo->instance($post_data);
    $this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
    $this->assertTrue($post->title === $post_data['title']);
  }

}

Sekarang bahwa kita memiliki semua pengujian kami di tempat, mari kita jalankan PHPUnit lagi untuk menonton mereka gagal!

1	vendor/phpunit/phpunit/phpunit.php

Anda harus memiliki seluruh ton kegagalan, dan pada kenyataannya, suite tes mungkin tidak bahkan tamat pengujian sebelum jatuh. Ini adalah OK, berarti kita telah mengikuti aturan TDD dan menulis gagal tes sebelum kode produksi. Meskipun, biasanya tes ini akan ditulis satu per satu waktu dan Anda tidak akan melanjutkan untuk tes berikutnya sampai Anda memiliki kode yang diperbolehkan tes sebelumnya untuk lulus. Terminal Anda mungkin harus terlihat seperti tambang saat:

Apa yang benar-benar gagal adalah metode assertViewHas dalam tes controller kami. Memang agak mengintimidasi untuk berurusan dengan jenis kesalahan ketika kita memiliki dikelompok bersama semua pengujian kami tanpa produksi setiap kode sama sekali. Inilah sebabnya mengapa Anda harus selalu menulis tes satu pada satu waktu, karena Anda akan menemukan kesalahan ini dengan tenang, bukan hanya kekacauan besar kesalahan sekaligus. Untuk saat ini, hanya mengikuti memimpin saya ke implementasi kode kita.

Diskusi sidebar

Sebelum kita melanjutkan dengan implementasi, mari kita istirahat untuk cepat sidebar diskusi tentang tanggung jawab dari pola MVC.

Dari geng empat:

Model adalah objek aplikasi, yang adalah presentasi layar, dan Controller mendefinisikan cara bereaksi antarmuka pengguna untuk input pengguna.

Titik menggunakan struktur seperti ini adalah untuk tetap dikemas dan fleksibel, memungkinkan kita untuk pertukaran dan penggunaan kembali komponen. Mari kita pergi melalui setiap bagian dari pola MVC dan berbicara tentang usabilitas dan fleksibilitas:

Pemandangan

Saya pikir sebagian besar orang akan setuju bahwa pandangan ini seharusnya menjadi representasi visual sederhana data dan tidak boleh mengandung banyak logika. Dalam kasus kami, sebagai pengembang untuk web, pandangan kita cenderung menjadi HTML atau XML.

Reusable: selalu, hampir apa pun yang dapat membuat tampilan
fleksibel: tidak memiliki logika apapun nyata dalam lapisan-lapisan ini membuat ini sangat fleksibel

Controller

Jika Controller "mendefinisikan cara bereaksi antarmuka pengguna untuk input pengguna", maka tanggung jawab harus mendengarkan input pengguna (Dapatkan, posting, header, dll), dan membangun keadaan saat ini aplikasi. Menurut pendapat saya, Controller harus sangat ringan dan tidak boleh mengandung kode lebih daripada yang diperlukan untuk mencapai di atas.

Reusable: kita harus ingat bahwa controller kami kembali pandangan dogmatis, sehingga kita tidak pernah memanggil metode Controller dalam cara yang praktis untuk menggunakan salah satu logika di dalamnya. Oleh karena itu logika apapun yang ditempatkan dalam Controller metode, harus spesifik untuk metode Controller, jika logika dapat digunakan kembali, itu harus ditempatkan di tempat lain.
fleksibel: dalam kebanyakan PHP MVCs Controller terkait langsung dengan rute, yang tidak meninggalkan kita fleksibilitas sangat banyak. Laravel perbaikan masalah ini dengan memungkinkan kita untuk menyatakan rute yang menggunakan controller, sehingga kita sekarang dapat swap keluar controller kami dengan implementasi yang berbeda jika perlu:

1	Route::get('/', array(
2	'uses' => 'SomeController@action'
3	));

Model

Model adalah "objek aplikasi" dalam definisi kita dari Gang of Four. Ini adalah definisi yang sangat generik. Selain itu, kami hanya memutuskan untuk offload logika apapun yang dapat digunakan kembali dari Controller kami, dan karena Model adalah satu-satunya komponen yang tersisa dalam struktur didefinisikan kita, logis untuk mengasumsikan bahwa ini adalah rumah baru untuk logika. Namun, saya pikir Model tidak boleh mengandung logika apapun seperti ini. Menurut pendapat saya, kita harus berpikir tentang kami "objek aplikasi", dalam hal ini sebagai objek yang mewakili tempatnya dalam lapisan data, apakah itu sebuah tabel, baris, atau koleksi sepenuhnya tergantung pada negara. Model harus berisi tidak lebih dari Getter dan setter untuk data (termasuk hubungan).

Reusable: jika kita mengikuti praktek di atas dan membuat model kami menjadi sebuah obyek yang mewakili tempatnya dalam database, objek ini tetap sangat dapat digunakan kembali. Setiap bagian dari sistem kami dapat menggunakan model ini dan dengan melakukan begitu mendapatkan lengkap dan unopinionated akses ke database.
fleksibel: mengikuti praktek di atas, Model kami adalah pada dasarnya penerapan ORM, ini memungkinkan kita untuk menjadi fleksibel, karena kita sekarang memiliki kekuatan untuk mengubah ORM's setiap kali kita ingin hanya dengan menambahkan Model baru. Kita mungkin harus memiliki antarmuka yang ditetapkan yang Model kita harus mematuhi, seperti: semua, menemukan, membuat, memperbarui, menghapus. Pelaksanaan ORM baru akan menjadi sederhana seperti memastikan bahwa antarmuka disebutkan sebelumnya adalah lobi.

Repositori

Hanya dengan hati-hati menentukan komponen MVC kami, kami yatim semua jenis logika ke dalam tanah tak bertuan. Ini adalah di mana repositori datang untuk mengisi kekosongan. Repositori menjadi perantara controller dan model. Permintaan khas akan menjadi sesuatu seperti ini:

Controller menerima semua input pengguna dan menyalurkannya ke repositori.
Repositori melakukan tindakan "pra-mengumpulkan" seperti validasi data, otorisasi, otentikasi, dll. Jika tindakan "pra-berkumpul" ini berhasil, maka permintaan dilewatkan ke Model untuk diproses.
Model akan memproses semua data ke dalam lapisan data, dan kembali keadaan saat ini.
Repositori akan menangani apapun rutinitas "pasca-gathering" dan kembali keadaan saat ini ke controller.
Controller ini kemudian akan menciptakan tampilan yang tepat menggunakan informasi yang disediakan oleh repositori.

Kami repositori berakhir sebagai fleksibel dan terorganisir seperti kita telah membuat kami controller dan model, memungkinkan kita untuk menggunakan kembali ini di sebagian besar sistem kami, serta mampu untuk swap keluar untuk implementasi lain jika diperlukan.

Kita telah melihat contoh menukar repositori untuk implementasi lain dalam tes Controller di atas. Alih-alih menggunakan default kami repositori, kami meminta wadah IoC untuk menyediakan controller dengan instance objek olok-olok. Kami memiliki kekuatan yang sama ini untuk semua komponen kami.

Apa kami telah accomplised di sini dengan menambahkan lapisan lain MVC kami, adalah sistem yang sangat terorganisir, terukur dan diuji. Mari kita mulai menempatkan potongan-potongan di tempat dan mendapatkan kami tes untuk lulus.

Implementasi controller

Jika Anda mengambil membaca melalui tes controller, Anda akan melihat bahwa kita benar-benar peduli tentang adalah bagaimana controller berinteraksi dengan repositori. Jadi mari kita melihat betapa ringan dan sederhana yang membuat controller kami.

Catatan: dalam TDD, tujuannya adalah untuk tidak lagi bekerja dari yang diperlukan untuk membuat tes Anda lulus. Jadi kita ingin melakukan mutlak minimal di sini.

app/controllers/V1/PostsController.php

<?php
namespace V1;

use BaseController; 
use PostRepositoryInterface; 
use Input;
use View;

class PostsController extends BaseController {

  /**
   * We will use Laravel's dependency injection to auto-magically
   * "inject" our repository instance into our controller
   */
  public function __construct(PostRepositoryInterface $posts)
  {
    $this->posts = $posts;
  }

  /**
   * Display a listing of the resource.
   *
   * @return Response
   */
  public function index()
  {
    return $this->posts->findAll();
  }

  /**
   * Show the form for creating a new resource.
   *
   * @return Response
   */
  public function create()
  {
    $post = $this->posts->instance();
    return View::make('posts._form', compact('post'));
  }

  /**
   * Store a newly created resource in storage.
   *
   * @return Response
   */
  public function store()
  {
    return $this->posts->store( Input::all() );
  }

  /**
   * Display the specified resource.
   *
   * @param int $id
   * @return Response
   */
  public function show($id)
  {
    return $this->posts->findById($id);
  }

  /**
   * Show the form for editing the specified resource.
   *
   * @param int $id
   * @return Response
   */
  public function edit($id)
  {
    $post = $this->posts->findById($id);
    return View::make('posts._form', compact('post'));
  }

  /**
   * Update the specified resource in storage.
   *
   * @param int $id
   * @return Response
   */
  public function update($id)
  {
    return $this->posts->update($id, Input::all());
  }

  /**
   * Remove the specified resource from storage.
   *
   * @param int $id
   * @return Response
   */
  public function destroy($id)
  {
    $this->posts->destroy($id);
    return '';
  }

}

app/controllers/PostsCommentsController.php

<?php
namespace V1;

use BaseController; 
use CommentRepositoryInterface; 
use Input;
use View;

class PostsCommentsController extends BaseController {

  /**
   * We will use Laravel's dependency injection to auto-magically
   * "inject" our repository instance into our controller
   */
  public function __construct(CommentRepositoryInterface $comments)
  {
    $this->comments = $comments;
  }

  /**
   * Display a listing of the resource.
   *
   * @return Response
   */
  public function index($post_id)
  {
    return $this->comments->findAll($post_id);
  }

  /**
   * Show the form for creating a new resource.
   *
   * @return Response
   */
  public function create($post_id)
  {
    $comment = $this->comments->instance(array(
      'post_id' => $post_id
    ));

    return View::make('comments._form', compact('comment'));
  }

  /**
   * Store a newly created resource in storage.
   *
   * @return Response
   */
  public function store($post_id)
  {
    return $this->comments->store( $post_id, Input::all() );
  }

  /**
   * Display the specified resource.
   *
   * @param int $id
   * @return Response
   */
  public function show($post_id, $id)
  {
    return $this->comments->findById($post_id, $id);
  }

  /**
   * Show the form for editing the specified resource.
   *
   * @param int $id
   * @return Response
   */
  public function edit($post_id, $id)
  {
    $comment = $this->comments->findById($post_id, $id);

    return View::make('comments._form', compact('comment'));
  }

  /**
   * Update the specified resource in storage.
   *
   * @param int $id
   * @return Response
   */
  public function update($post_id, $id)
  {
    return $this->comments->update($post_id, $id, Input::all());
  }

  /**
   * Remove the specified resource from storage.
   *
   * @param int $id
   * @return Response
   */
  public function destroy($post_id, $id)
  {
    $this->comments->destroy($post_id, $id);
    return '';
  }

}

Tidak bisa jauh lebih sederhana daripada itu, Semua kontroler lakukan adalah membagi input data ke repositori, mengambil respon dari itu, dan menyerahkannya ke tampilan, yang dalam kasus kita adalah hanya JSON untuk sebagian besar metode kami. Ketika kami kembali fasih koleksi, atau Model fasih controller dalam Laravel 4, objek parsing ke JSON auto-ajaib, yang membuat pekerjaan kami sangat mudah.

Catatan: Perhatikan bahwa kita menambahkan beberapa lebih "menggunakan" pernyataan ke atas dari file untuk mendukung kelas-kelas lain yang kami menggunakan. Jangan lupa ini ketika Anda bekerja dalam sebuah namespace.

Satu-satunya hal yang agak sedikit rumit dalam controller ini adalah konstruktor. Perhatikan kita melewati dalam variabel diketik sebagai ketergantungan untuk Controller ini, namun ada gunanya bahwa kita memiliki akses ke Instansiasi controller ini untuk benar-benar memasukkan bahwa kelas... Selamat datang di ketergantungan injeksi! Apa yang kita benar-benar lakukan di sini adalah mengisyaratkan kami controller yang kita memiliki ketergantungan yang diperlukan untuk menjalankan kelas ini dan apa nama kelas (atau namanya mengikat IoC). Laravel menggunakan App::make() untuk membuat controller yang sebelum memanggil mereka. App::Make() akan mencoba untuk menyelesaikan item dengan mencari setiap binding yang kita mungkin telah dinyatakan, dan/atau menggunakan auto-loader untuk memberikan contoh. Selain itu, juga akan menyelesaikan semua dependensi yang diperlukan untuk instantiate kelas bagi kita, oleh lebih-atau-kurang secara rekursif panggilan App::make() pada masing-masing dari dependensi.

Jeli, akan melihat bahwa apa yang kita coba untuk lulus dalam ketergantungan adalah antarmuka, dan seperti yang Anda tahu, antarmuka tidak dapat instantiated. Ini adalah tempat hal keren dan kami benar-benar sudah melakukan hal yang sama dalam pengujian kami. Dalam pengujian kami Namun, kami menggunakan App::instance() untuk memberikan contoh sudah dibuat bukan antarmuka. Untuk controller kami, kami benar-benar akan memberitahu Laravel bahwa setiap kali sebuah instance dari PostRepositoryInterface diminta, untuk mengembalikan instance dari EloquentPostRepository.

Buka file app/routes.php Anda dan tambahkan baris berikut ke bagian atas dari file

1	App::bind('PostRepositoryInterface', 'EloquentPostRepository');
2	App::bind('CommentRepositoryInterface', 'EloquentCommentRepository');

Setelah menambahkan baris tersebut, Kapan saja meminta App::make() untuk contoh PostRepositoryInterface, itu akan menciptakan sebuah instance dari EloquentPostRepository, yang diduga untuk menerapkan PostRepositoryInterface. Jika Anda pernah berubah repositori Anda sebaliknya menggunakan ORM berbeda daripada fasih, atau mungkin berbasis file driver, Semua harus Anda lakukan adalah mengubah dua baris dan Anda baik untuk pergi, controller Anda akan tetap bekerja seperti biasa. Ketergantungan sebenarnya controller adalah objek yang mengimplementasikan antarmuka tersebut dan kita dapat menentukan pada saat run-time apa bahwa penerapan sebenarnya adalah.

PostRepositoryInterface dan CommentRepositoryInterface yang harus benar-benar ada dan binding harus benar-benar mengimplementasikannya. Jadi mari kita membuat mereka sekarang:

app/repositories/PostRepositoryInterface.php

<?php

interface PostRepositoryInterface {
  public function findById($id);
  public function findAll();
  public function paginate($limit = null);
  public function store($data);
  public function update($id, $data);
  public function destroy($id);
  public function validate($data);
  public function instance();
}

app/repositories/CommentRepositoryInterface.php

<?php

interface CommentRepositoryInterface {
  public function findById($post_id, $id);
  public function findAll($post_id);
  public function store($post_id, $data);
  public function update($post_id, $id, $data);
  public function destroy($post_id, $id);
  public function validate($data);
  public function instance();
}

Sekarang bahwa kita memiliki dua antarmuka kami dibangun, kita harus menyediakan implementasi antarmuka ini. Mari kita membangun mereka sekarang.

app/repositories/EloquentPostRepository.php

Sebagai implementasi ini namanya, kami mengandalkan fasih, yang kita dapat memanggil secara langsung. Jika Anda punya dependensi lain, ingat bahwa App::make() yang digunakan untuk menyelesaikan repositori ini, sehingga Anda dapat merasa bebas untuk menggunakan metode konstruktor yang sama kami digunakan dengan controller kami untuk menyuntikkan dependensi.

<?php

class EloquentPostRepository implements PostRepositoryInterface {

  public function findById($id)
  {
    $post = Post::with(array(
        'comments' => function($q)
        {
          $q->orderBy('created_at', 'desc');
        }
      ))
      ->where('id', $id)
      ->first();

    if(!$post) throw new NotFoundException('Post Not Found');
    return $post;
  }

  public function findAll()
  {
    return Post::with(array(
        'comments' => function($q)
        {
          $q->orderBy('created_at', 'desc');
        }
      ))
      ->orderBy('created_at', 'desc')
      ->get();
  }

  public function paginate($limit = null)
  {
    return Post::paginate($limit);
  }

  public function store($data)
  {
    $this->validate($data);
    return Post::create($data);
  }

  public function update($id, $data)
  {
    $post = $this->findById($id);
    $post->fill($data);
    $this->validate($post->toArray());
    $post->save();
    return $post;
  }

  public function destroy($id)
  {
    $post = $this->findById($id);
    $post->delete();
    return true;
  }

  public function validate($data)
  {
    $validator = Validator::make($data, Post::$rules);
    if($validator->fails()) throw new ValidationException($validator);
    return true;
  }

  public function instance($data = array())
  {
    return new Post($data);
  }

}

app/repositories/EloquentCommentRepository.php

<?php

class EloquentCommentRepository implements CommentRepositoryInterface {

  public function findById($post_id, $id)
  {
    $comment = Comment::find($id);
    if(!$comment || $comment->post_id != $post_id) throw new NotFoundException('Comment Not Found');
    return $comment;
  }

  public function findAll($post_id)
  {
    return Comment::where('post_id', $post_id)
      ->orderBy('created_at', 'desc')
      ->get();
  }

  public function store($post_id, $data)
  {
    $data['post_id'] = $post_id;
    $this->validate($data);
    return Comment::create($data);
  }

  public function update($post_id, $id, $data)
  {
    $comment = $this->findById($post_id, $id);
    $comment->fill($data);
    $this->validate($comment->toArray());
    $comment->save();
    return $comment;
  }

  public function destroy($post_id, $id)
  {
    $comment = $this->findById($post_id, $id);
    $comment->delete();
    return true;
  }

  public function validate($data)
  {
    $validator = Validator::make($data, Comment::$rules);
    if($validator->fails()) throw new ValidationException($validator);
    return true;
  }

  public function instance($data = array())
  {
    return new Comment($data);
  }

}

Jika Anda melihat di repositori kami, ada beberapa pengecualian yang kita membuang, mana tidak asli, atau apakah mereka milik Laravel. Mereka adalah pengecualian kustom yang kita gunakan untuk menyederhanakan kode kita. Dengan menggunakan pengecualian kustom, kami akan dapat dengan mudah menghentikan perkembangan aplikasi jika kondisi tertentu terpenuhi. Misalnya, jika posting tidak ditemukan, kita hanya dapat melemparkan NotFoundException dan aplikasi akan menangani hal itu sesuai, tetapi, bukan oleh menampilkan 500 error seperti biasa, sebaliknya kita akan penangan kesalahan kustom setup. Atau Anda bisa menggunakan App::abort(404) atau sesuatu di sepanjang baris tersebut, tapi saya menemukan bahwa metode ini menyelamatkan saya banyak pernyataan bersyarat dan ulangi kode, serta memungkinkan saya untuk menyesuaikan pelaksanaan kesalahan pelaporan dalam satu tempat sangat mudah.

Pertama mari kita menetapkan pengecualian kustom. Buat sebuah file dalam folder app disebut errors.php

1	touch app/errors.php

App/Errors.php

<?php

class PermissionException extends Exception {

  public function __construct($message = null, $code = 403)
  {
    parent::__construct($message ?: 'Action not allowed', $code);
  }

}

class ValidationException extends Exception {

  protected $messages;

  /**
   * We are adjusting this constructor to receive an instance
   * of the validator as opposed to a string to save us some typing
   * @param Validator $validator failed validator object
   */
  public function __construct($validator)
  {
    $this->messages = $validator->messages();
    parent::__construct($this->messages, 400);
  }

  public function getMessages()
  {
    return $this->messages;
  }

}

class NotFoundException extends Exception {

  public function __construct($message = null, $code = 404)
  {
    parent::__construct($message ?: 'Resource Not Found', $code);
  }

}

Ini adalah pengecualian yang sangat sederhana, perhatikan untuk ValidationException, kami hanya dapat melewati itu contoh validator gagal dan ini akan menangani pesan kesalahan yang sesuai!

Sekarang kita perlu menentukan penangan kesalahan kami yang akan dipanggil ketika salah satu pengecualian ini dilemparkan. Pada dasarnya ini adalah pendengar acara, setiap kali salah satu pengecualian ini dibuang, itu dianggap sebagai suatu peristiwa dan memanggil fungsi sesuai. Hal ini sangat sederhana untuk menambahkan penebangan atau penanganan prosedur berikut kesalahan lain.

App/Filters.php

...

/**
 * General HttpException handler
 */
App::error( function(Symfony\Component\HttpKernel\Exception\HttpException $e, $code)
{
  $headers = $e->getHeaders();

  switch($code)
  {
    case 401:
      $default_message = 'Invalid API key';
      $headers['WWW-Authenticate'] = 'Basic realm="CRM REST API"';
    break;

    case 403:
      $default_message = 'Insufficient privileges to perform this action';
    break;

    case 404:
      $default_message = 'The requested resource was not found';
    break;

    default:
      $default_message = 'An error was encountered';
  }

  return Response::json(array(
    'error' => $e->getMessage() ?: $default_message
  ), $code, $headers);
});

/**
 * Permission Exception Handler
 */
App::error(function(PermissionException $e, $code)
{
  return Response::json($e->getMessage(), $e->getCode());
});

/**
 * Validation Exception Handler
 */
App::error(function(ValidationException $e, $code)
{
  return Response::json($e->getMessages(), $code);
});

/**
 * Not Found Exception Handler
 */
App::error(function(NotFoundException $e)
{
  return Response::json($e->getMessage(), $e->getCode());
});

Kita sekarang perlu untuk membiarkan kami auto-loader tahu tentang file baru ini. Jadi kita harus memberitahu komposer mana untuk memeriksa mereka:

Composer.JSON

Perhatikan bahwa kita menambahkan baris "app/errors.php".

{
  "require": {
    "laravel/framework": "4.0.*",
    "way/generators": "dev-master",
    "twitter/bootstrap": "dev-master",
    "conarwelsh/mustache-l4": "dev-master"
  },
  "require-dev": {
    "phpunit/phpunit": "3.7.*",
    "mockery/mockery": "0.7.*"
  },
  "autoload": {
    "classmap": [
      "app/commands",
      "app/controllers",
      "app/models",
      "app/database/migrations",
      "app/database/seeds",
      "app/tests/TestCase.php",
      "app/repositories",
      "app/errors.php"
    ]
  },
  "scripts": {
    "post-update-cmd": "php artisan optimize"
  },
  "minimum-stability": "dev"
}

Kita sekarang harus memberitahu komposer untuk benar-benar memeriksa file ini dan memasukkan mereka dalam registri auto-beban.

1	composer dump-autoload

Besar, begitu kami telah menyelesaikan controller kami dan kami repositori, dua item dalam MVRC kita bahwa kita harus mengurus adalah model dan pemandangan, yang keduanya cukup lurus ke depan.

app/models/Post.php

<?php
/**
 * Represent a Post Item, or Collection
 */
class Post extends Eloquent {

  /**
   * Items that are "fillable"
   * meaning we can mass-assign them from the constructor
   * or $post->fill()
   * @var array
   */
  protected $fillable = array(
    'title', 'content', 'author_name'
  );

  /**
   * Validation Rules
   * this is just a place for us to store these, you could
   * alternatively place them in your repository
   * @var array
   */
  public static $rules = array(
    'title'    => 'required',
    'author_name' => 'required'
  );

  /**
   * Define the relationship with the comments table
   * @return Collection collection of Comment Models
   */
  public function comments()
  {
    return $this->hasMany('Comment');
  }

}

app/models/Comment.php

<?php
/**
 * Represent a Comment Item, or Collection
 */
class Comment extends Eloquent {

  /**
   * Items that are "fillable"
   * meaning we can mass-assign them from the constructor
   * or $comment->fill()
   * @var array
   */
  protected $fillable = array(
    'post_id', 'content', 'author_name'
  );

  /**
   * Validation Rules
   * this is just a place for us to store these, you could
   * alternatively place them in your repository
   * @var array
   */
  public static $rules = array(
    'post_id'   => 'required|numeric',
    'content'   => 'required',
    'author_name' => 'required'
  );

  /**
   * Define the relationship with the posts table
   * @return Model parent Post model
   */
  public function post()
  {
    return $this->belongsTo('Post');
  }

}

Sejauh menyangkut dilihat, aku hanya akan untuk menandai beberapa halaman bootstrap ramah sederhana. Ingatlah untuk mengubah setiap file ekstensi untuk .mustache meskipun, karena generator kami berpikir bahwa kami akan menggunakan. blade.php. Kami juga akan membuat beberapa pemandangan "sebagian" menggunakan konvensi Rails awalan mereka dengan _ menandakan parsial.

Catatan: saya melewatkan beberapa pemandangan, kami tidak akan menggunakan mereka dalam tutorial ini.

Public/views/Posts/index.mustache

Tampilan halaman indeks kami akan hanya loop melalui semua posting kami, menampilkan posting parsial untuk masing-masing.

1	{{#posts}}
2	{{> posts._post}}
3	{{/posts}}

Public/views/Posts/Show.mustache

Tampilkan tampilan kami akan menunjukkan seluruh posting dan komentar:

<article>
  <h3>
    {{ post.title }} {{ post.id }}
    <small>{{ post.author_name }}</small>
  </h3>
  <div>
    {{ post.content }}
  </div>
</article>

<div>
  <h2>Add A Comment</h2>
  {{> comments._form }}

  <section data-role="comments">
    {{#post.comments}}
      <div>
        {{> comments._comment }}
      </div>
    {{/post.comments}}
  </section>
</div>

Public/views/Posts/_POST.mustache

Berikut ini adalah sebagian yang kita akan gunakan untuk menampilkan posting dalam daftar. Ini digunakan pada tampilan indeks kami.

1	<article data-toggle="view" data-target="posts/{{ id }}">
2	<h3>{{ title }} {{ id }}</h3>
3	<cite>{{ author_name }} on {{ created_at }}</cite>
4	</article>

Public/views/Posts/_form.mustache

Inilah bentuk parsial diperlukan untuk membuat posting, kita akan menggunakan ini dari API kami, tetapi ini juga bisa menjadi pandangan yang berguna dalam admin panel dan tempat lain, itulah sebabnya mengapa kita memilih untuk membuatnya parsial.

{{#exists}}
  <form action="/v1/posts/{{ post.id }}" method="post">
    <input type="hidden" name="_method" value="PUT" />
{{/exists}}
{{^exists}}
  <form action="/v1/posts" method="post">
{{/exists}}

  <fieldset>

    <div class="control-group">
      <label class="control-label"></label>
      <div class="controls">
        <input type="text" name="title" value="{{ post.title }}" />
      </div>
    </div>

    <div class="control-group">
      <label class="control-label"></label>
      <div class="controls">
        <input type="text" name="author_name" value="{{ post.author_name }}" />
      </div>
    </div>

    <div class="control-group">
      <label class="control-label"></label>
      <div class="controls">
        <textarea name="content">{{ post.content }}"</textarea>
      </div>
    </div>

    <div class="form-actions">
      <input type="submit" class="btn btn-primary" value="Save" />
    </div>

  </fieldset>
</form>

Public/views/Comments/_comment.mustache

Berikut adalah komentar parsial yang digunakan untuk mewakili satu komentar dalam daftar komentar:

<h5>
  {{ author_name }}
  <small>{{ created_at }}</small>
</h5>
<div>
  {{ content }}
</div>

Public/views/Comments/_form.mustache

Formulir yang diperlukan untuk membuat komentar - keduanya digunakan dalam API dan pemandangan Tampilkan Post:

{{#exists}}
  <form class="form-horizontal" action="/v1/posts/{{ comment.post_id }}/{{ id }}" method="post">
    <input type="hidden" name="_method" value="PUT" />
{{/exists}}
{{^exists}}
  <form class="form-horizontal" action="/v1/posts/{{ comment.post_id }}" method="post">
{{/exists}}

  <fieldset>

    <div class="control-group">
      <label class="control-label">Author Name</label>
      <div class="controls">
        <input type="text" name="author_name" value="{{ comment.author_name }}" />
      </div>
    </div>

    <div class="control-group">
      <label class="control-label">Comment</label>
      <div class="controls">
        <textarea name="content">{{ comment.content }}</textarea>
      </div>
    </div>

    <div class="form-actions">
      <input type="submit" class="btn btn-primary" value="Save" />
    </div>

  </fieldset>
</form>

Public/views/layouts/_notification.mustache

Dan di sini adalah pandangan penolong parsial untuk memungkinkan kita untuk menunjukkan pemberitahuan:

1	<div class="alert alert-{{type}}">
2	{{message}}
3	</div>

Besar, kita memiliki semua komponen API kami di tempat. Mari kita jalankan unit kami tes untuk melihat mana kita berada di!

1	vendor/phpunit/phpunit/phpunit.php

Pertama menjalankan tes ini harus lulus dengan terbang warna (hijau). Namun, jika Anda adalah untuk menjalankan tes ini lagi, Anda akan melihat bahwa gagal sekarang dengan beberapa kesalahan, dan itu adalah karena kami tes repositori benar-benar diuji database, dan dengan demikian dihapus beberapa catatan pengujian kami sebelumnya digunakan untuk menegaskan nilai-nilai. Ini adalah memperbaiki yang mudah, Semua harus kita lakukan adalah memberitahu kami tes bahwa mereka perlu kembali benih database setelah setiap tes. Selain itu, kami tidak menerima kesalahan yang terlihat untuk ini, tapi kami pun tidak menutup ejekan setelah setiap tes yang baik, ini merupakan syarat ejekan yang dapat Anda temukan di Documents mereka. Jadi mari kita menambahkan kedua metode yang hilang.

Buka app/tests/TestCase.php dan menambahkan dua metode berikut:

/**
 * setUp is called prior to each test
 */
public function setUp()
{
  parent::setUp();
  $this->seed();
}

/**
 * tearDown is called after each test
 * @return [type] [description]
 */
public function tearDown()
{
  Mockery::close();
}

Ini sangat bagus, kita sekarang mengatakan bahwa di setiap "setUp", yang dijalankan sebelum setiap tes, untuk kembali benih database. Namun kita masih memiliki satu masalah, setiap kali Anda kembali benih, itu hanya akan untuk menambahkan baris baru ke dalam tabel. Pengujian kami mencari item dengan ID baris satu, jadi kita masih memiliki beberapa perubahan untuk membuat. Kita hanya perlu memberitahu database untuk memotong meja kami ketika penyemaian:

app/database/seeds/CommentsTableSeeder.php

Sebelum kita menyisipkan baris baru, kita akan memotong Meja, menghapus semua baris dan reset auto-increment counter.

<?php

class CommentsTableSeeder extends Seeder {

  public function run()
  {
    $comments = array(
      array(
        'content'   => 'Lorem ipsum Nisi dolore ut incididunt mollit tempor proident eu velit cillum dolore sed',
        'author_name' => 'Testy McTesterson',
        'post_id'   => 1,
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
      array(
        'content'   => 'Lorem ipsum Nisi dolore ut incididunt mollit tempor proident eu velit cillum dolore sed',
        'author_name' => 'Testy McTesterson',
        'post_id'   => 1,
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
      array(
        'content'   => 'Lorem ipsum Nisi dolore ut incididunt mollit tempor proident eu velit cillum dolore sed',
        'author_name' => 'Testy McTesterson',
        'post_id'   => 2,
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
    );

    //truncate the comments table when we seed
    DB::table('comments')->truncate();
    DB::table('comments')->insert($comments);
  }

}

app/database/seeds/PostsTableSeeder.php

<?php

class PostsTableSeeder extends Seeder {

  public function run()
  {
    $posts = array(
      array(
        'title'    => 'Test Post',
        'content'   => 'Lorem ipsum Reprehenderit velit est irure in enim in magna aute occaecat qui velit ad.',
        'author_name' => 'Conar Welsh',
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      ),
      array(
        'title'    => 'Another Test Post',
        'content'   => 'Lorem ipsum Reprehenderit velit est irure in enim in magna aute occaecat qui velit ad.',
        'author_name' => 'Conar Welsh',
        'created_at' => date('Y-m-d H:i:s'),
        'updated_at' => date('Y-m-d H:i:s'),
      )
    );

    //truncate the posts table each time we seed
    DB::table('posts')->truncate();
    DB::table('posts')->insert($posts);
  }

}

Sekarang Anda harus mampu menjalankan tes beberapa kali dan mendapatkan melewati tes setiap kali! Itu berarti kita telah memenuhi siklus TDD kami dan kami tidak diizinkan untuk menulis lagi kode produksi untuk API kami!! Mari kita hanya melakukan perubahan kami repo kami dan pindah ke aplikasi Backbone!

1	git add . && git commit -am "built out the API and corresponding tests"

Tulang punggung App

Sekarang bahwa kita telah menyelesaikan semua pekerjaan pendukungnya, kita dapat bergerak maju untuk menciptakan bagus user interface untuk mengakses semua data itu. Kami akan membuat ini bagian dari proyek sedikit di sisi yang lebih sederhana, dan saya memperingatkan Anda bahwa pendekatan saya dapat dianggap satu dogmatis. Saya telah melihat banyak orang dengan begitu banyak metode yang berbeda untuk penataan aplikasi tulang punggung. Cobaan dan kesalahan saya telah membawa saya untuk metode saya saat ini, jika Anda tidak setuju dengan hal itu, harapan saya adalah bahwa itu dapat menginspirasi Anda untuk menemukan Anda sendiri!

Kita akan menggunakan mesin template kumis bukan Underscore, ini akan memungkinkan kita untuk berbagi pandangan kami antara klien dan server! Kuncinya adalah dalam bagaimana Anda memuat pandangan, kita akan menggunakan AJAX dalam tutorial ini, tetapi hanya sebagai mudah untuk memuat mereka semua ke dalam template utama, atau precompile mereka.

Router

Pertama kita akan mendapatkan kami akan router. Ada dua bagian ini, Laravel router, dan router tulang punggung.

Laravel Router

Ada dua pendekatan utama yang dapat kita ambil di sini:

Pendekatan #1: Catch-semua

Ingat saya katakan ketika Anda telah menambahkan jalur sumber daya itu penting bahwa Anda menempatkan mereka di atas jalur app?? Metode menangkap-semua adalah alasan untuk pernyataan itu. Tujuan keseluruhan dari metode ini adalah memiliki setiap rute yang memiliki tidak menemukan kecocokan di Laravel, tertangkap dan dikirim ke tulang punggung. Menerapkan metode ini mudah:

App/Routes.php

// change your existing app route to this:
// we are basically just giving it an optional parameter of "anything"
Route::get('/{path?}', function($path = null)
{
  return View::make('app');
})
->where('path', '.*'); //regex to match anything (dots, slashes, letters, numbers, etc)

Sekarang, setiap rute selain rute API kami akan membuat pandangan app kami.

Selain itu, jika Anda memiliki multi-halaman app (beberapa satu halaman aplikasi), Anda dapat menetapkan beberapa ini menangkap-alls:

Route::get('someApp1{path?}', function($path = null)
{
  return View::make('app');
})
->where('path', '.*');

Route::get('anotherApp/{path?}', function($path = null)
{
  return View::make('app');
})
->where('path', '.*');

Route::get('athirdapp{path?}', function($path = null)
{
  return View::make('app');
})
->where('path', '.*');

Catatan: Perlu diingat '/' sebelum {jalan?}. Jika garis miring yang ada, itu akan diminta dalam URL (dengan pengecualian rute indeks), kadang-kadang ini diinginkan dan kadang-kadang tidak.

Pendekatan #2:

Karena kami depan dan belakang berbagi pandangan... Bukankah akan sangat mudah untuk hanya menentukan rute di kedua tempat? Anda bahkan dapat melakukannya selain pendekatan menangkap-semua jika Anda ingin.

Rute yang kita akan berakhir dengan mendefinisikan untuk app adalah hanya:

1	GET /
2	GET /posts/:id

App/Routes.php

<?php

App::bind('PostRepositoryInterface', 'EloquentPostRepository'); 
App::bind('CommentRepositoryInterface', 'EloquentCommentRepository'); 





//create a group of routes that will belong to APIv1
Route::group(array('prefix' => 'v1'), function()
{
  Route::resource('posts', 'V1\PostsController');
  Route::resource('posts.comments', 'V1\PostsCommentsController');
});



/**
 * Method #1: use catch-all
 * optionally commented out while we use Method 2
 */
// change your existing app route to this:
// we are basically just giving it an optional parameter of "anything"
// Route::get('/{path?}', function($path = null)
// {
//   return View::make('layouts.application')->nest('content', 'app');
// })
// ->where('path', '.*'); //regex to match anything (dots, slashes, letters, numbers, etc)



/**
 * Method #2: define each route
 */
Route::get('/', function()
{
  $posts = App::make('PostRepositoryInterface')->paginate();
  return View::make('layouts.application')->nest('content', 'posts.index', array(
    'posts' => $posts
  ));
});

Route::get('posts/{id}', function($id)
{
  $post = App::make('PostRepositoryInterface')->findById($id);
  return View::make('layouts.application')->nest('content', 'posts.show', array(
    'post' => $post
  ));
});

Cukup keren ya?! Terlepas dari metode yang kita gunakan, atau kombinasi keduanya, router tulang punggung Anda akan berakhir umumnya sama.

Perhatikan bahwa kita menggunakan repositori kami lagi, ini adalah alasan lain mengapa repositori adalah tambahan yang berguna untuk kerangka kami. Kita sekarang dapat menjalankan hampir semua logika yang controller, tetapi tanpa mengulangi hampir tidak ada kode!

Perlu diingat beberapa hal saat memilih metode yang digunakan, jika Anda menggunakan menangkap-semua, akan melakukan seperti namanya... catch-semua. Ini berarti tidak ada hal seperti 404 situs Anda lagi. Tidak peduli atas permintaan, yang mendarat di halaman app (kecuali jika Anda secara manual melemparkan pengecualian di suatu tempat seperti repositori Anda). Invers adalah, dengan mendefinisikan setiap rute, sekarang Anda memiliki dua set rute untuk mengelola. Kedua metode memiliki mereka pasang dan surut, tetapi keduanya sama mudah untuk menangani.

Pandangan dasar

Satu pandangan untuk memerintah mereka semua! BaseView ini adalah pandangan bahwa semua pandangan-pandangan kami akan mewarisi dari. Untuk tujuan kita, pandangan ini memiliki tetapi satu pekerjaan... template! Dalam aplikasi yang lebih besar pandangan ini adalah tempat yang baik untuk menempatkan logika lain bersama.

Kami hanya akan memperpanjang Backbone.View dan tambahkan fungsi template yang akan kembali pandangan kita dari cache jika ada, atau mendapatkannya melalui AJAX dan menempatkannya dalam cache. Kita harus menggunakan AJAX sinkron karena cara bahwa Mustache.js mengambil parsial, tetapi karena kita hanya mengambil pandangan ini jika mereka tidak di-cache, kita tidak boleh menerima banyak pertunjukan hit sini.

/**
 ***************************************
 * Array Storage Driver
 * used to store our views
 ***************************************
 */
var ArrayStorage = function(){
  this.storage = {};
};
ArrayStorage.prototype.get = function(key)
{
  return this.storage[key];
};
ArrayStorage.prototype.set = function(key, val)
{
  return this.storage[key] = val;
};



/**
 ***************************************
 * Base View
 ***************************************
 */
var BaseView = bb.View.extend({

  /**
   * Set our storage driver
   */
  templateDriver: new ArrayStorage,

  /**
   * Set the base path for where our views are located
   */
  viewPath: '/views/',

  /**
   * Get the template, and apply the variables
   */
  template: function()
  {
    var view, data, template, self;

    switch(arguments.length)
    {
      case 1:
        view = this.view;
        data = arguments[0];
        break;
      case 2:
        view = arguments[0];
        data = arguments[1];
        break;
    }

    template = this.getTemplate(view, false);
    self = this;

    return template(data, function(partial)
    {
      return self.getTemplate(partial, true);
    });
  },

  /**
   * Facade that will help us abstract our storage engine,
   * should we ever want to swap to something like LocalStorage
   */
  getTemplate: function(view, isPartial)
  {
    return this.templateDriver.get(view) || this.fetch(view, isPartial);
  },

  /**
   * Facade that will help us abstract our storage engine,
   * should we ever want to swap to something like LocalStorage
   */
  setTemplate: function(name, template)
  {
    return this.templateDriver.

1	<?php
2
3	class CommentsControllerTest extends TestCase {
4
5	/**
6	************************************************************************
7	* Basic Route Tests
8	* notice that we can use our route() helper here!
9	************************************************************************
10	*/
11
12	//test that GET /v1/posts/1/comments returns HTTP 200
13	public function testIndex()
14	{
15	$response = $this->call('GET', route('v1.posts.comments.index', array(1)) );
16	$this->assertTrue($response->isOk());
17	}
18
19	//test that GET /v1/posts/1/comments/1 returns HTTP 200
20	public function testShow()
21	{
22	$response = $this->call('GET', route('v1.posts.comments.show', array(1,1)) );
23	$this->assertTrue($response->isOk());
24	}
25
26	//test that GET /v1/posts/1/comments/create returns HTTP 200
27	public function testCreate()
28	{
29	$response = $this->call('GET', route('v1.posts.comments.create', array(1)) );
30	$this->assertTrue($response->isOk());
31	}
32
33	//test that GET /v1/posts/1/comments/1/edit returns HTTP 200
34	public function testEdit()
35	{
36	$response = $this->call('GET', route('v1.posts.comments.edit', array(1,1)) );
37	$this->assertTrue($response->isOk());
38	}
39
40	/**
41	*************************************************************************
42	* Tests to ensure that the controller calls the repo as we expect
43	* notice we are "Mocking" our repository
44	*
45	* also notice that we do not really care about the data or interactions
46	* we merely care that the controller is doing what we are going to want
47	* it to do, which is reach out to our repository for more information
48	*************************************************************************
49	*/
50
51	//ensure that the index function calls our repository's "findAll" method
52	public function testIndexShouldCallFindAllMethod()
53	{
54	//create our new Mockery object with a name of CommentRepositoryInterface
55	$mock = Mockery::mock('CommentRepositoryInterface');
56
57	//inform the Mockery object that the "findAll" method should be called on it once
58	//and return a string value of "foo"
59	$mock->shouldReceive('findAll')->once()->andReturn('foo');
60
61	//inform our application that we have an instance that it should use
62	//whenever the CommentRepositoryInterface is requested
63	App::instance('CommentRepositoryInterface', $mock);
64
65	//call our controller route
66	$response = $this->call('GET', route('v1.posts.comments.index', array(1)));
67
68	//assert that the response is a boolean value of true
69	$this->assertTrue(!! $response->original);
70	}
71
72	//ensure that the show method calls our repository's "findById" method
73	public function testShowShouldCallFindById()
74	{
75	$mock = Mockery::mock('CommentRepositoryInterface');
76	$mock->shouldReceive('findById')->once()->andReturn('foo');
77	App::instance('CommentRepositoryInterface', $mock);
78
79	$response = $this->call('GET', route('v1.posts.comments.show', array(1,1)));
80	$this->assertTrue(!! $response->original);
81	}
82
83	//ensure that our create method calls the "instance" method on the repository
84	public function testCreateShouldCallInstanceMethod()
85	{
86	$mock = Mockery::mock('CommentRepositoryInterface');
87	$mock->shouldReceive('instance')->once()->andReturn(array());
88	App::instance('CommentRepositoryInterface', $mock);
89
90	$response = $this->call('GET', route('v1.posts.comments.create', array(1)));
91	$this->assertViewHas('comment');
92	}
93
94	//ensure that the edit method calls our repository's "findById" method
95	public function testEditShouldCallFindByIdMethod()
96	{
97	$mock = Mockery::mock('CommentRepositoryInterface');
98	$mock->shouldReceive('findById')->once()->andReturn(array());
99	App::instance('CommentRepositoryInterface', $mock);
100
101	$response = $this->call('GET', route('v1.posts.comments.edit', array(1,1)));
102	$this->assertViewHas('comment');
103	}
104
105	//ensure that the store method should call the repository's "store" method
106	public function testStoreShouldCallStoreMethod()
107	{
108	$mock = Mockery::mock('CommentRepositoryInterface');
109	$mock->shouldReceive('store')->once()->andReturn('foo');
110	App::instance('CommentRepositoryInterface', $mock);
111
112	$response = $this->call('POST', route('v1.posts.comments.store', array(1)));
113	$this->assertTrue(!! $response->original);
114	}
115
116	//ensure that the update method should call the repository's "update" method
117	public function testUpdateShouldCallUpdateMethod()
118	{
119	$mock = Mockery::mock('CommentRepositoryInterface');
120	$mock->shouldReceive('update')->once()->andReturn('foo');
121	App::instance('CommentRepositoryInterface', $mock);
122
123	$response = $this->call('PUT', route('v1.posts.comments.update', array(1,1)));
124	$this->assertTrue(!! $response->original);
125	}
126
127	//ensure that the destroy method should call the repositories "destroy" method
128	public function testDestroyShouldCallDestroyMethod()
129	{
130	$mock = Mockery::mock('CommentRepositoryInterface');
131	$mock->shouldReceive('destroy')->once()->andReturn(true);
132	App::instance('CommentRepositoryInterface', $mock);
133
134	$response = $this->call('DELETE', route('v1.posts.comments.destroy', array(1,1)));
135	$this->assertTrue( empty($response->original) );
136	}
137
138
139	}

1	<?php
2
3	class PostsControllerTest extends TestCase {
4
5	/**
6	* Test Basic Route Responses
7	*/
8	public function testIndex()
9	{
10	$response = $this->call('GET', route('v1.posts.index'));
11	$this->assertTrue($response->isOk());
12	}
13
14	public function testShow()
15	{
16	$response = $this->call('GET', route('v1.posts.show', array(1)));
17	$this->assertTrue($response->isOk());
18	}
19
20	public function testCreate()
21	{
22	$response = $this->call('GET', route('v1.posts.create'));
23	$this->assertTrue($response->isOk());
24	}
25
26	public function testEdit()
27	{
28	$response = $this->call('GET', route('v1.posts.edit', array(1)));
29	$this->assertTrue($response->isOk());
30	}
31
32	/**
33	* Test that controller calls repo as we expect
34	*/
35	public function testIndexShouldCallFindAllMethod()
36	{
37	$mock = Mockery::mock('PostRepositoryInterface');
38	$mock->shouldReceive('findAll')->once()->andReturn('foo');
39	App::instance('PostRepositoryInterface', $mock);
40
41	$response = $this->call('GET', route('v1.posts.index'));
42	$this->assertTrue(!! $response->original);
43	}
44
45	public function testShowShouldCallFindById()
46	{
47	$mock = Mockery::mock('PostRepositoryInterface');
48	$mock->shouldReceive('findById')->once()->andReturn('foo');
49	App::instance('PostRepositoryInterface', $mock);
50
51	$response = $this->call('GET', route('v1.posts.show', array(1)));
52	$this->assertTrue(!! $response->original);
53	}
54
55	public function testCreateShouldCallInstanceMethod()
56	{
57	$mock = Mockery::mock('PostRepositoryInterface');
58	$mock->shouldReceive('instance')->once()->andReturn(array());
59	App::instance('PostRepositoryInterface', $mock);
60
61	$response = $this->call('GET', route('v1.posts.create'));
62	$this->assertViewHas('post');
63	}
64
65	public function testEditShouldCallFindByIdMethod()
66	{
67	$mock = Mockery::mock('PostRepositoryInterface');
68	$mock->shouldReceive('findById')->once()->andReturn(array());
69	App::instance('PostRepositoryInterface', $mock);
70
71	$response = $this->call('GET', route('v1.posts.edit', array(1)));
72	$this->assertViewHas('post');
73	}
74
75	public function testStoreShouldCallStoreMethod()
76	{
77	$mock = Mockery::mock('PostRepositoryInterface');
78	$mock->shouldReceive('store')->once()->andReturn('foo');
79	App::instance('PostRepositoryInterface', $mock);
80
81	$response = $this->call('POST', route('v1.posts.store'));
82	$this->assertTrue(!! $response->original);
83	}
84
85	public function testUpdateShouldCallUpdateMethod()
86	{
87	$mock = Mockery::mock('PostRepositoryInterface');
88	$mock->shouldReceive('update')->once()->andReturn('foo');
89	App::instance('PostRepositoryInterface', $mock);
90
91	$response = $this->call('PUT', route('v1.posts.update', array(1)));
92	$this->assertTrue(!! $response->original);
93	}
94
95	public function testDestroyShouldCallDestroyMethod()
96	{
97	$mock = Mockery::mock('PostRepositoryInterface');
98	$mock->shouldReceive('destroy')->once()->andReturn(true);
99	App::instance('PostRepositoryInterface', $mock);
100
101	$response = $this->call('DELETE', route('v1.posts.destroy', array(1)));
102	$this->assertTrue( empty($response->original) );
103	}
104
105	}

1	<?php
2
3	class EloquentCommentRepositoryTest extends TestCase {
4
5	public function setUp()
6	{
7	parent::setUp();
8	$this->repo = App::make('EloquentCommentRepository');
9	}
10
11	public function testFindByIdReturnsModel()
12	{
13	$comment = $this->repo->findById(1,1);
14	$this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
15	}
16
17	public function testFindAllReturnsCollection()
18	{
19	$comments = $this->repo->findAll(1);
20	$this->assertTrue($comments instanceof Illuminate\Database\Eloquent\Collection);
21	}
22
23	public function testValidatePasses()
24	{
25	$reply = $this->repo->validate(array(
26	'post_id' => 1,
27	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
28	'author_name' => 'Testy McTesterson'
29	));
30
31	$this->assertTrue($reply);
32	}
33
34	public function testValidateFailsWithoutContent()
35	{
36	try {
37	$reply = $this->repo->validate(array(
38	'post_id' => 1,
39	'author_name' => 'Testy McTesterson'
40	));
41	}
42	catch(ValidationException $expected)
43	{
44	return;
45	}
46
47	$this->fail('ValidationException was not raised');
48	}
49
50	public function testValidateFailsWithoutAuthorName()
51	{
52	try {
53	$reply = $this->repo->validate(array(
54	'post_id' => 1,
55	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.'
56	));
57	}
58	catch(ValidationException $expected)
59	{
60	return;
61	}
62
63	$this->fail('ValidationException was not raised');
64	}
65
66	public function testValidateFailsWithoutPostId()
67	{
68	try {
69	$reply = $this->repo->validate(array(
70	'author_name' => 'Testy McTesterson',
71	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.'
72	));
73	}
74	catch(ValidationException $expected)
75	{
76	return;
77	}
78
79	$this->fail('ValidationException was not raised');
80	}
81
82	public function testStoreReturnsModel()
83	{
84	$comment_data = array(
85	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
86	'author_name' => 'Testy McTesterson'
87	);
88
89	$comment = $this->repo->store(1, $comment_data);
90
91	$this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
92	$this->assertTrue($comment->content === $comment_data['content']);
93	$this->assertTrue($comment->author_name === $comment_data['author_name']);
94	}
95
96	public function testUpdateSaves()
97	{
98	$comment_data = array(
99	'content' => 'The Content Has Been Updated'
100	);
101
102	$comment = $this->repo->update(1, 1, $comment_data);
103
104	$this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
105	$this->assertTrue($comment->content === $comment_data['content']);
106	}
107
108	public function testDestroySaves()
109	{
110	$reply = $this->repo->destroy(1,1);
111	$this->assertTrue($reply);
112
113	try {
114	$this->repo->findById(1,1);
115	}
116	catch(NotFoundException $expected)
117	{
118	return;
119	}
120
121	$this->fail('NotFoundException was not raised');
122	}
123
124	public function testInstanceReturnsModel()
125	{
126	$comment = $this->repo->instance();
127	$this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
128	}
129
130	public function testInstanceReturnsModelWithData()
131	{
132	$comment_data = array(
133	'title' => 'Un-validated title'
134	);
135
136	$comment = $this->repo->instance($comment_data);
137	$this->assertTrue($comment instanceof Illuminate\Database\Eloquent\Model);
138	$this->assertTrue($comment->title === $comment_data['title']);
139	}
140
141	}

1	<?php
2
3	class EloquentPostRepositoryTest extends TestCase {
4
5	public function setUp()
6	{
7	parent::setUp();
8	$this->repo = App::make('EloquentPostRepository');
9	}
10
11	public function testFindByIdReturnsModel()
12	{
13	$post = $this->repo->findById(1);
14	$this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
15	}
16
17	public function testFindAllReturnsCollection()
18	{
19	$posts = $this->repo->findAll();
20	$this->assertTrue($posts instanceof Illuminate\Database\Eloquent\Collection);
21	}
22
23	public function testValidatePasses()
24	{
25	$reply = $this->repo->validate(array(
26	'title' => 'This Should Pass',
27	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
28	'author_name' => 'Testy McTesterson'
29	));
30
31	$this->assertTrue($reply);
32	}
33
34	public function testValidateFailsWithoutTitle()
35	{
36	try {
37	$reply = $this->repo->validate(array(
38	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
39	'author_name' => 'Testy McTesterson'
40	));
41	}
42	catch(ValidationException $expected)
43	{
44	return;
45	}
46
47	$this->fail('ValidationException was not raised');
48	}
49
50	public function testValidateFailsWithoutAuthorName()
51	{
52	try {
53	$reply = $this->repo->validate(array(
54	'title' => 'This Should Pass',
55	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.'
56	));
57	}
58	catch(ValidationException $expected)
59	{
60	return;
61	}
62
63	$this->fail('ValidationException was not raised');
64	}
65
66	public function testStoreReturnsModel()
67	{
68	$post_data = array(
69	'title' => 'This Should Pass',
70	'content' => 'Lorem ipsum Fugiat consectetur laborum Ut consequat aliqua.',
71	'author_name' => 'Testy McTesterson'
72	);
73
74	$post = $this->repo->store($post_data);
75
76	$this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
77	$this->assertTrue($post->title === $post_data['title']);
78	$this->assertTrue($post->content === $post_data['content']);
79	$this->assertTrue($post->author_name === $post_data['author_name']);
80	}
81
82	public function testUpdateSaves()
83	{
84	$post_data = array(
85	'title' => 'The Title Has Been Updated'
86	);
87
88	$post = $this->repo->update(1, $post_data);
89
90	$this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
91	$this->assertTrue($post->title === $post_data['title']);
92	}
93
94	public function testDestroySaves()
95	{
96	$reply = $this->repo->destroy(1);
97	$this->assertTrue($reply);
98
99	try {
100	$this->repo->findById(1);
101	}
102	catch(NotFoundException $expected)
103	{
104	return;
105	}
106
107	$this->fail('NotFoundException was not raised');
108	}
109
110	public function testInstanceReturnsModel()
111	{
112	$post = $this->repo->instance();
113	$this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
114	}
115
116	public function testInstanceReturnsModelWithData()
117	{
118	$post_data = array(
119	'title' => 'Un-validated title'
120	);
121
122	$post = $this->repo->instance($post_data);
123	$this->assertTrue($post instanceof Illuminate\Database\Eloquent\Model);
124	$this->assertTrue($post->title === $post_data['title']);
125	}
126
127	}

1	<?php
2	namespace V1;
3
4	use BaseController;
5	use CommentRepositoryInterface;
6	use Input;
7	use View;
8
9	class PostsCommentsController extends BaseController {
10
11	/**
12	* We will use Laravel's dependency injection to auto-magically
13	* "inject" our repository instance into our controller
14	*/
15	public function __construct(CommentRepositoryInterface $comments)
16	{
17	$this->comments = $comments;
18	}
19
20	/**
21	* Display a listing of the resource.
22	*
23	* @return Response
24	*/
25	public function index($post_id)
26	{
27	return $this->comments->findAll($post_id);
28	}
29
30	/**
31	* Show the form for creating a new resource.
32	*
33	* @return Response
34	*/
35	public function create($post_id)
36	{
37	$comment = $this->comments->instance(array(
38	'post_id' => $post_id
39	));
40
41	return View::make('comments._form', compact('comment'));
42	}
43
44	/**
45	* Store a newly created resource in storage.
46	*
47	* @return Response
48	*/
49	public function store($post_id)
50	{
51	return $this->comments->store( $post_id, Input::all() );
52	}
53
54	/**
55	* Display the specified resource.
56	*
57	* @param int $id
58	* @return Response
59	*/
60	public function show($post_id, $id)
61	{
62	return $this->comments->findById($post_id, $id);
63	}
64
65	/**
66	* Show the form for editing the specified resource.
67	*
68	* @param int $id
69	* @return Response
70	*/
71	public function edit($post_id, $id)
72	{
73	$comment = $this->comments->findById($post_id, $id);
74
75	return View::make('comments._form', compact('comment'));
76	}
77
78	/**
79	* Update the specified resource in storage.
80	*
81	* @param int $id
82	* @return Response
83	*/
84	public function update($post_id, $id)
85	{
86	return $this->comments->update($post_id, $id, Input::all());
87	}
88
89	/**
90	* Remove the specified resource from storage.
91	*
92	* @param int $id
93	* @return Response
94	*/
95	public function destroy($post_id, $id)
96	{
97	$this->comments->destroy($post_id, $id);
98	return '';
99	}
100
101	}