Git vs. SVN - Basic Commandline Syntax Reference

Learning the git workflow takes a bit of brain retraining, but since I've been using SVN almost entirely via commandline (because Subversive sucks and locks up my Eclipse when I try to use it for anything beyond synching/updating/committing a handful of files), adopting git's commandline syntax is reasonably similar. Consider these simple operations:

Initial checkout from existing repo for a given branch	git clone http://github.com/sonatype/sonatype-tycho.git; cd sonatype-tycho; git checkout origin/tycho-0.10.x	svn checkout http://anonsvn.jboss.org/repos/jbosstools/branches/jbosstools-3.2.0.Beta1/
Update locally checked out files from central repo	git pull	svn update
List locally changes files/folders	git status	svn stat
Diff locally changed file	git diff somefile.txt	svn diff somefile.txt
Revert locally changed file*	git checkout somefile.txt	svn revert somefile.txt
Revert ALL local changes (except untracked files)*	git reset --hard HEAD	svn revert . -R
Add new file	git add file.txt	svn add file.txt
Add new folder recursively	git add folder	svn add folder
Delete file	git rm file.txt	svn rm file.txt
Delete folder	git rm -r folder (non-recursive by default; use -r to recurse)	svn rm folder (recursive by default; use -N to not recurse)
Commit changed file to central repo	git commit -m "message" file.txt; git push	svn ci -m "message" file.txt
Ignore files/folders (in the current folder)	echo "target *.class bin" > .gitignore; \ git ci -m "gitignore" .gitignore	svn propset svn:ignore "target *.class bin" .; \ svn ci -N -m "svn:ignore" .

Obviously you can do a lot more w/ Git than with SVN (like stashing local changes temporarily), but for the sake of simply moving from a VCS to a DVCS and being able to continue to work the same way you already do, the above table should provide a good introduction.

15 Best Ruby on Rails Gem Used for an application

Devise (https://rubygems.org/gems/devise): Since some years ago, it represents the authentication mechanism preferred by all Rails developers. Powerful, flexible, allows to integrate with OAuth authentication systems with a minimal effort.

Haml (https://rubygems.org/gems/haml): Allows you to write valid XHTML concisely. The learning curve is relatively short.

Gritter (https://rubygems.org/gems/gritter): After years of flash messages in the classic div in the page, we moved to Growl like notifications. Thanks to these pop-ups, we can show our flash messages in any page in a completely non-invasive and elegant way.

Cells (https://rubygems.org/gems/cells): Cells can really keep our controllers very skinny. We use it to represent and caching some boxes, like “recommended items”, “top users” and so on. I really like Cells over the use of helpers.

FriendlyId (https://rubygems.org/gems/friendly_id): A perfect gem to make our url seo friendly.

SimpleForm (https://rubygems.org/gems/simple_form): We use it primarily for its excellent integration with Bootstrap and for its ease of use.

Paperclip (https://rubygems.org/gems/paperclip): Despite the years, it still remains the reference point for attachments management .

Kaminari (https://rubygems.org/gems/kaminari): Useful gem to manage paginated collections .

Cancan (https://rubygems.org/gems/cancan): Our choice to manage permissions. We never have had the need to use some other solution .

Resque (https://rubygems.org/gems/resque) or Delayed Job (https://rubygems.org/gems/delayed_job): Both are valuable supports to manage background processes. If you do not have enough resources to set up a Redis server, we recommend Delayed Job.

Sunspot (https://rubygems.org/gems/sunspot): After a brief period with thinking_sphinx, we have moved to this very powerful indexing engine. Thanks to Solr, we can easily implement geolocated full text searches. The only problem is that you need to configure a dedicated Tomcat server. If you do not have these resources, we recommend using pg_search (https://rubygems.org/gems/pg_search) with a Postgres database or the old but still valid meta_search (http://rubygems.org/gems/meta_search) .

ActiveAdmin (https://rubygems.org/gems/activeadmin): When it is necessary to set up a back office administration in a short time, here is the right gem. Powerful, fairly customizable, ideal for simple administration interfaces.

Letter opener (https://rubygems.org/gems/letter_opener): Useful to test sending emails simply by opening them in a browser window .

RSpec (https://rubygems.org/gems/rspec): A perfect gem to test our models in a BDD way.

Capybara (https://rubygems.org/gems/capybara) : In addition to unit test the models, we like to create a suite of acceptance tests. Capybara allows you to test all the application’s user stories relatively quickly.

How to migrate from Heroku Shared-database to Dev or Basic Postgres

First, we installed the postgres add-on:
heroku addons:add heroku-postgresql:basic

When you run the command it created a new database:
Attached as HEROKU_POSTGRESQL_SOMECOLOR
You can see it by typing heroku config

Most of our apps were already running pgbackups:monthly (free), on one of them we ran:
heroku addons:add pgbackups

Put the app in maintenance mode:
heroku maintenance:on

Capture a backup of the current database:
heroku pgbackups:capture --expire
(Took under 2 minutes for a 12 MB database)

Now push that data into the new database:
heroku pgbackups:restore HEROKU_POSTGRESQL_SOMECOLOR

Now make the new database the current database:
heroku pg:promote HEROKU_POSTGRESQL_SOMECOLOR
(Replaces the heroku config variable DATABASE_URL with the URL for the new database. The old shared-database and it’s URL are still there, but they are not the default anymore.)

Check the new database is working:
heroku pg:psql HEROKU_POSTGRESQL_SOMECOLOR
=> select count(*) from users;
(To quit the CLI type \q )

Turn off maintenance mode:
heroku maintenance:off


Short steps ::

heroku pgbackups:capture --expire

heroku pgbackups:url

curl -o latest_dump_file.dump DATABASE_URL

heroku maintenance:on

heroku pgbackups:restore HEROKU_POSTGRESQL_WHITE_URL

heroku pg:promote HEROKU_POSTGRESQL_WHITE_URL

heroku pg:psq HEROKU_POSTGRESQL_WHITE_URL

heroku pg:psql HEROKU_POSTGRESQL_WHITE_URL

heroku maintenance:off

New project setup from heroku

New project setup from heroku 

ssh-keygen -t rsa -C YOUR EMAIL ID

ssh-add ~/.ssh/id_rsa

heroku login

heroku keys:add

git clone git@heroku.com:project.git

cd project/

rvm gemset create project

rvm gemset use project

bundle install

Change in database.yml

rake db:create

rake db:migrate

rails s

5 Ways to Make Ajax Calls with jQuery

What is AJAX

 AJAX stands for asynchronous JavaScript and XML. If you see another term XHR, which is shorthand for XML HTTP request, it’s the same thing. Don’t be afraid of this jargon; AJAX is not rocket science.

The key to AJAX’s concept is “asynchronous”. This means something happens to the page after it’s loaded. Traditionally, when a page is loaded, the content remains the same until the user leaves the page. With AJAX, JavaScript grabs new content from the server and makes changes to the current page. This all happena within the lifetime of the page, no refresh or redirection is needed.

Caching AJAX

For static content, we may want the response cached. But for dynamic content, which can change in a second’s time, caching AJAX becomes a bug, right? It should be noted that Internet Explorer always caches AJAX calls, while other browsers behave differently. So we’d better tell the browser explicitly whether or not AJAX should be cached. With jQuery, we can accomplish this simply by typing:

1. $.ajaxSetup ({  
2.     cache: false  
3. }); 

• load(): Load a piece of html into a container DOM.
• $.getJSON(): Load a JSON with GET method.
• $.getScript(): Load a JavaScript.
• $.get(): Use this if you want to make a GET call and play extensively with the response.
• $.post(): Use this if you want to make a POST call and don’t want to load the response to some container DOM.
• $.ajax(): Use this if you need to do something when XHR fails, or you need to specify ajax options (e.g. cache: true) on the fly.

1. load(): Load HTML From a Remote URL and Inject it into the DOM

    $.ajaxSetup ({
        cache: false
    });
    var ajax_load = "<img src='img/load.gif' alt='loading...' />";
   
//    load() functions
    var loadUrl = "ajax/load.php";
    $("#load_basic").click(function(){
        $("#result").html(ajax_load).load(loadUrl);
    });

2. $.getJSON(): Retrieve JSON from a Remote Location

//    $.getJSON()
    var jsonUrl = "ajax/json.php";
    $("#getJSONForm").submit(function(){
        var q = $("#q").val();
        if (q.length == 0) {
            $("#q").focus();
        } else {
            $("#result").html(ajax_load);
            $.getJSON(
                jsonUrl,
                {q: q},
                function(json) {
                    var result = "Language code is \"<strong>" + json.responseData.language + "\"";
                    $("#result").html(result);
                }
            );
        }
        return false;
    });

 

3. $.getScript(): Load JavaScript from a Remote Location

//    $.getScript()
    var scriptUrl = "ajax/script.php";
    $("#getScript").click(function(){
        $("#result").html(ajax_load);
        $.getScript(scriptUrl, function(){
            $("#result").html("");
        });
    });

4. $.get(): Make GET Requests

 //    $.get()
    $("#get").click(function(){
        $("#result").html(ajax_load);
        $.get(
            loadUrl,
            {language: "php", version: 5},
            function(responseText){
                $("#result").html(responseText);
            },
            "html"
        );
    });

5. $.post(): Make POST Requests

//    $.post()
    $("#post").click(function(){
        $("#result").html(ajax_load);
        $.post(
            loadUrl,
            {language: "php", version: 5},
            function(responseText){
                $("#result").html(responseText);
            },
            "html"
        );
    });

Finally… $.ajax():
Up to this point, we’ve examined five commonly used jQuery AJAX functions. They bear different names but, behind the scenes, they generally do the exact same job with slightly different configurations. If you need maximum control over your requests, check out the $.ajax() function.
 

 

 

 

PDFKit for ruby on rails

http://stackoverflow.com/questions/68569/text-watermark-on-website-how-to-do-it

<style type="text/css">
  #watermark {
    color: #d0d0d0;
    font-size: 200pt;
    -webkit-transform: rotate(-45deg);
    -moz-transform: rotate(-45deg);
    position: absolute;
    width: 100%;
    height: 100%;
    margin: 0;
    z-index: -1;
    left:-100px;
    top:-200px;
  }
</style>

<div id="watermark">
  <p>This is the test version.</p>
</div>

http://stackoverflow.com/questions/5399458/render-to-string-does-not-find-partials-pdfkit-controller-response

respond_to do |format|
  format.html
  format.pdf {
    html = render_to_string(:layout => false , :action => "constitution.pdf.haml")
    kit = PDFKit.new(html)
    kit.stylesheets << "#{Rails.root}/public/stylesheets/pdf.css"
    send_data(kit.to_pdf, :filename => "#{@organisation_name} Constitution.pdf",
    :type => 'application/pdf', :disposition => 'inline')        
    return
  }
end

http://metaskills.net/2011/03/20/pdfkit-overview-and-advanced-usage/

/* Page Breaks */

.pb_before { page-break-before:always !important; }
.pb_after  { page-break-after:always !important; }
.pbi_avoid { page-break-inside:avoid !important; }

# My with authentication (sending session cookie name and value)

kit = PDFKit.new(model_url(@model), 'margin-left' => '10mm', 'margin-right' => '10mm',
page_size: 'A5', cookie: "#{Rails::Application.config.session_options[:key]}
 #{cookies[Rails::Application.config.session_options[:key]]}")

file = kit.to_file("#{Rails.root}/tmp/invoices/#{@invoice.id}.pdf")

# My way, rendering file 

# config/initializers/mime_types.rb

Mime::Type.register 'application/pdf', :pdf

#Controller

def show
  @invoice = Model.find(params[:id])
  respond_to do |format|

  format.html { render layout: 'invoice' }

  format.pdf  { 
    unless File.exist?("#{Rails.root}/tmp/model/#{@model.id}.pdf")
      file = pdf_kit.to_file("#{Rails.root}/tmp/model/#{@model.id}.pdf")
    end
  send_file "#{Rails.root}/tmp/model/#{@model.id}_pre.pdf", :type => 'application/pdf' 
  }
  format.xml  { render :xml => @invoice }
  end
end

private

def pdf_kit
  html = render_to_string(action: :show, layout: 'invoice')
  kit = PDFKit.new(html, 'margin-left' => '10mm', 'margin-right' => '10mm', page_size: 'A5',)
  kit.stylesheets << "#{Rails.root}/public/stylesheets/model_pdf.css
  kit
end

PostgreSQL installation in Ubuntu 12.04

PostgreSQL is a powerful and reliable object-relational database system. It’s a great alternative for MySQL. It is as easy to set up, performs better and offers far more features.

1. Make sure you already have install python-software-properties
$sudo apt-get install python-software-properties

2.Add PPA repository to my Ubuntu.
$sudo add-apt-repository ppa:pitti/postgresql

3. After adding PPA, update your system apt:
$sudo apt-get update

4.Finally install postgresql-9.1:
$sudo apt-get install postgresql
if you having any error, make sure you already install libpq-dev.The libpq-dev package is for compiling wrappers/clients against libpq.

$sudo apt-get install postgresql-9.1 libpq-dev
5.Now check it out installation is successful or…..

$ locate postgresql
6. If done!!!, Cheers …………..                      Check the install version.

$psql -V
7.Now let’s take look to postgres console

$su postgres

7(a) Setup Root User ‘posrgres’

$sudo passwd postgres

give the postgres user a (unix) password,Now we can switch to the user postgres using command 

$ su postgres 

8. create user
     create user <username> with password '<password>';
   to create user as super user run this
     alter user <username> superuser;
   now quite from postgres console by
     \q

9. now restart your postgres
     $sudo service postgresql restart