Mandeep Simak

Tag: framework

  • Ruby on Rails – Blog Application (Rails 2 App)

    Creating the Blog Application

    For creating this application you must install Ruby on Rails on your system and also install the database to add the backend for your applicaton.

    Click here for installing Ruby on Rails and MySQL Database.

    Follow the steps for creating your blog application in Ruby on Rails :

      1. Open a terminal, navigate to a folder where you have rights to create files, and type :

        $ rails blog -d mysql

        -d mysql option create database with MySQL connectivity.

      2. Now move to blog folder using :

        $ cd blog

      3. Database Configuration

        Open the database.yml file to edit the database settings.
        For this enter following commands in terminal:

        $ cd config/
        $ gedit database.yml

        Replace username and password with your MySQL Username and password.
        Update these changes in all three sections : development, test and production.

        After saving these changes, run this command in terminal:
        $ cd ..

      4. Database Creation

        Run the following command in terminal to create database :

        $ rake db:create

      5. Starting up Web Server

        Run this command in terminal to run default webpage in browser:

        $ script/server

      6. Creating Controller

        Run this command in terminal:

        ruby script/generate controller home index

      7. Edit Home Page

        Open app/views/home/index.html.erb file. Run these commands in terminal:

        $ cd app/views/home/
        $ gedit index.html.erb

        Add following line and Save the file.(You can also delete the previous text)


        <h1>Hello Rails !</h1>

      8. Remove index.html from public folder

        $ cd
        $ cd Desktop/blog
        $ rm pulic/index.html

      9. Setting the Application Home Page

        Open routes.rb file.
        $ gedit config/routes.rb

        Find the line beginning with root :root and uncomment it.
        Replace that line with this :

        map:root :controller => ‘home’, :action => ‘index’

        Now save that file and if you navigate to http://localhost:3000 in your browser, you’ll see the home/index view.

      10. Creating a Resource

        In the case of the blog application, you can start by generating a scaffolded Post resource. To do this, enter this command in your terminal:

        $ script/generate scaffold Post name:string title:string content:text

      11. Running a Migration

        Use following command to create tables:

        $ rake db:migrate

      12. Add a Link

        Open index.html.erb file to add link to My Blog page.

        $ cd app/views/home/index.html.erb

        Add this line at last,

        <%= link_to “My Blog”, posts_path %>

        and save the file.

        The link_to method is one of Rails’ built-in view helpers. It creates a hyperlink based on text to display and where to go – in this case, to the path for posts.

      13. Test Your Blog Application

        $ script/server

        Now open http://localhost:3000/ in browser.

      By these steps your blog is created and if you find any error then feel free to ask and share it through comments.

  • Ruby on Rails

    What is Rails?Ruby on Rails

    Rails is a web development framework written in the Ruby language. It is designed to make programming web applications easier by making several assumptions about what every developer needs to get started. It allows you to write less code while accomplishing more than many other languages and frameworks. Longtime Rails developers also report that it makes web application development more fun. Rails is opinionated software. That is, it assumes that there is a best way to do things, and it’s designed to encourage that best way – and in some cases discourage alternatives. If you learn “The Rails Way” you’ll probably discover a tremendous increase in productivity. If you persist in bringing old habits from other languages to your Rails development, and trying to use patterns you learned elsewhere, you may have a less happy experience. The Rails philosophy includes several guiding principles:

    • DRY – “Don’t Repeat Yourself” – suggests that writing the same code over and over again is a bad thing.
    • Convention Over Configuration – means that Rails makes assumptions about what you want to do and how you’re going to do it, rather than letting you tweak every little thing through endless configuration files.
    • REST is the best pattern for web applications – organizing your application around resources and standard HTTP verbs is the fastest way to go.

    The MVC Architecture

    Rails is organized around the Model, View, Controller architecture, usually just called MVC. MVC benefits include:

    • Isolation of business logic from the user interface
    • Ease of keeping code DRY
    • Making it clear where different types of code belong for easier maintenance

    Models

    A model represents the information (data) of the application and the rules to manipulate that data. In the case of Rails, models are primarily used for managing the rules of interaction with a corresponding database table. In most cases, one table in your database will correspond to one model in your application. The bulk of your application’s business logic will be concentrated in the models.

    Views

    Views represent the user interface of your application. In Rails, views are often HTML files with embedded Ruby code that performs tasks related solely to the presentation of the data. Views handle the job of providing data to the web browser or other tool that is used to make requests from your application.

    Controllers

    Controllers provide the “glue” between models and views. In Rails, controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation.

    The Components of Rails

    Rails provides a full stack of components for creating web applications, including:

    • Action Controller
    • Action View
    • Active Record
    • Action Mailer
    • Active Resource
    • Railties
    • Active Support

    Action Controller

    Action Controller is the component that manages the controllers in a Rails application. The Action Controller framework processes incoming requests to a Rails application, extracts parameters, and dispatches them to the intended action. Services provided by Action Controller include session management, template rendering, and redirect management.

    Action View

    Action View manages the views of your Rails application. It can create both HTML and XML output by default. Action View manages rendering templates, including nested and partial templates, and includes built-in AJAX support.

    Active Record

    Active Record is the base for the models in a Rails application. It provides database independence, basic CRUDfunctionality, advanced finding capabilities, and the ability to relate models to one another, among other services.

    Action Mailer

    Action Mailer is a framework for building e-mail services. You can use Action Mailer to send emails based on flexible templates, or to receive and process incoming email.

    Active Resource

    Active Resource provides a framework for managing the connection between business objects an RESTful web services. It implements a way to map web-based resources to local objects with CRUD semantics.

    Railties

    Railties is the core Rails code that builds new Rails applications and glues the various frameworks together in any Rails application.

    Active Support

    Active Support is an extensive collection of utility classes and standard Ruby library extensions that are used in the Rails, both by the core code and by your applications.