Flash player Helper is a Rails plugin that presents an ActionView wrapper for rendering JW Flash Player 5.1 and Image Rotator

JW Flash Player is a popular open source Media player that supports most media formats. This Plugin is also backward compatible for version lesser than 5.1.

To use it you need to install plugin by running

script/plugin install git://github.com/bagwanpankaj/flash_player_helper.git

This will automatically setup JW Flash Player for your rails application. It also installs required files under public folder.

If required files are not copied autometically under public directory then you can copy them by running

rake flash_player:install

How to use

Include swfobject javascript into layout or view file

Now to use flash player

See here, no parameter are passed, so it works with all default parameters. only file parameter in flashvar is needed to be passed.

and for Image Rotator

The above command will render flash player or Image rotator with default configuration.
The helper method for flah player looks like:

player(player_options = {},config = {})

and for Image Rotator

image_rotator(player_options = {},config = {})

In which *player_options* contains options that you can pass for JW Flash Player, including flashvars supported by adobe flash.
Note: all the flashvars should be passed under :flahvars key in player_options as a hash like

@ 'true',:allowscriptaccess => 'true',{:flashvars => {:skin => '/swf/skins/bekle.swf', :height => '600', :file => '/sample.flv'}})%>

You can find list of supported flashvars for Flash Player here and flashvars for Image Rotator can be found here

It supports skin in both format either you can pass zip file or a swf file to skin flashvars.

Note: Given relative path should be relative to public folder of your application.

Credits

Credit for this plugin goes to JW Flash Player Team for making such a awsome flash player.

Future Addons

Adding Flash Chart functionality to this plugin.

More Info
Being very I am anable to provide detailed info here.
For any specific query or info you can write me at ‘bagwanpankaj[_at_]railsjaipur.in’

Silverlight Player Helper provides you an Action View Helper method available to all views and provides all required files that are needed to build the player.

JW Silverlight Player supports wmv, wma and mp3 file formats. List of all supported format can be found here

How To Use

To use silverlight_player_helper you first need to install it as a plugin

  script/plugin install git://github.com/bagwanpankaj/silverlight_player_helper.git

And you are done. This command will automatically copies all required files to default folers under your public folder.
If it doesn’t do it automatically then run:

  rake sl_player:install

this rake task will copies all files to required folders.

Now to use this plugin write

   '/path/to/your/file.wmv',:width => 640, :height => 480) %>

The minimum required options are nothing. If no file is provided then it runs default file (supplied with plugin).
You can provide all options supported by JW Silverlight Player. These options can be found here

For more info write me at
bagwan.pankaj[_at_]railsjaipur.in

For example in ActiveRecord, we have dynamic method on attributes name like

find_by_something(some_possible_values)
find_all_by_something(spv)
find_by_something_and_otherthing(some_value, other_value)

In this topic we will see how we can meta-program in Rails. Using Meta Programming one can reduce LOC to dramatic level and it also reduce headache in maintaining code base.

Here I am not going into details for class_eval and instanse_eval because there are many blog post out there. But I do give some examples.

Consider following:

class Testt

end

Testt.class_eval do
  def foo
    "I'll be available as instance method"
  end

  def self.foo
    "I'll be available as class method"
  end
end

Testt.new().foo
=> I'll be available as instance method
Testt.foo
=>I  be available as class method

Let me explain that class_eval evaluates a string or code block in context of class or module it is called upon.

Testt.instance_eval do
  def foo
    "I'll be available as class method"
  end

  def self.bar
    "I'll be available as class method"
  end
end

Testt.foo
=>I'll be available as class method
Testt.bar
=>I'll be available as class method

instance_eval can evaluate a string or a code block in the context of the receiver.

The third way to define a method in class or module is define_method.

class Testt
  define_method :foo do
    "welcome"
  end
end
Testt.new().foo
=> welcome

module Hello
  define_method :foo do |name|
    "welcome #{name}"
  end
end

include Hello
foo "Dave"
=> welcome Dave

Now we can spice our project with metaprogramming. See how?
Suppose in our project we had a model to maintain users

class User < ActiveRecord::Base
  #user has one role so association is
  has_one :role
end

We also have a Role model that belongs to user. Schema for role is suppose

Role(id: integer, name: string, user_id: integer)

At the initiation of project the role known were admin and user. So I have defined two method in User model named as is_admin? and is_user?. But after some time we need to add some other roles as we need to define same function for them as well.

So to get rid of this we flavoured our project with bits of metaprogramming. See here how

class User < ActiveRecord::Base
  #user has one role so association is
  has_one :role
  #First time when there is no method found; this method will catch that
  def self.method_missing(method_sym, *params)
    #Here we match the pattern of method and see if we can process it or not
    if method_sym.to_s =~ /^is_(.*)\?$/
      function = $1

      class_eval <<-END
	def method_sym.to_s
	  "#{role.name == function.to_s.upcase}"
        end
      END
      #Let's register this method with user class when it is invoked first time.
	send(method_sym)
    else
      super
    end
  end

  #Let this class respond for these methods
  def self.respond_to?(method_sym, *args, &block)
    method_sym.to_s =~ /^is_(.*)\?$/ ? true : super
  end
end

It came out to be our very own google’s fault. Yes! as the email server was hosted on google app. And our google uses SSL SMTP or to be precise STARTTLS for routing emails. So here I am writing down step by step, what worked for me.

1. Create #{RAILS_ROOT}/config/mailer_settings.yml with following code

development:
	enable_starttls_auto:  true
	address: "smtp.gmail.com"
	port: 587
	domain:  'http://'
	authentication: plain
	user_name: "user@domain_name"
	password:  your-password

production:
	enable_starttls_auto:  true
	address: "smtp.gmail.com"
	port: 587
	domain:  'http://'
	authentication: plain
	user_name: "user@domain_name"
	password: your-password

Note: you can use enable_starttls_auto directly if your rails version > 2.2 and ruby
version is >=1.8.7, because built-in support for starttls. If not, then also you can use it; but you first need to install this gem.

gem install ambethia-smtp-tls

make dependencies

#in "#{RAILS_ROOT}/config/environment.rb" write the following
config.gem "ambethia-smtp-tls", :lib => "smtp-tls", :source => "http://gems.github.com/"

2. Load mail configuration settings, if not in test environment

# Load mail configuration if not in test environment
if RAILS_ENV != 'test'
	email_settings = YAML::load(File.open("#{RAILS_ROOT}/config/mailer_settings.yml"))
	ActionMailer::Base.smtp_settings = email_settings[RAILS_ENV] unless email_settings[RAILS_ENV].nil?
end

Happy Boarding

To use them just download this file and put it under features/step_definitions/

You can copy below code clipboard

#Created By Bagwan Pankaj (RailsJaipur) “http://railsjaipur.in/”
#This file is an extension of default webrat steps. some of the webrat steps have been extended
#in this file so that one need not to write unrequired steps.
#Extends default
#USE: When I follow //
When /^I follow \/([^\/]*)\/$/ do |regexp_link|
  click_link(regexp_link)
end

#USE: When I follow // within ""
When /^I follow \/([^\/]*)\/ within "([^\"]*)"$/ do |regexp_link, parent|
  click_link_within(parent,regexp_link)
end

#USE: Then It should not include tag ""
Then /^It should not include tag "([^\"]*)"$/ do |tag|
  assert_have_no_selector(tag, :count => 0)
end

#USE: Then It should not include tag "" within ""
Then /^It should not include tag "([^\"]*)" within "([^\"]*)"$/ do |tag_match, parent|
  within parent do |scope|
    scope.should_not have_selector(tag_match, :count => 0)
  end
end

#USE: Then It should not include selector ""
Then /^It should not include selector "([^\"]*)"$/ do |tag|
  Then %{It should not include tag \"#{tag}\"}
end

#USE: Then It should not include selector "" within ""
Then /^It should not include selector "([^\"]*)" within "([^\"]*)"$/ do |tag_match, parent|
  Then %{It should not include tag \"#{tag_match}\" within \"#{parent.to_s}\"}
end

#USE: Then It should include tag ""
Then /^It should include tag "([^\"]*)"$/ do |tag|
  assert_have_selector(tag)
end

#USE: Then It should include tag "" within ""
Then /^It should include tag "([^\"]*)" within "([^\"]*)"$/ do |tag_match, parent|
  within parent do |scope|
    scope.should have_selector(tag_match)
  end
end

#USE: Then It should include selector ""
Then /^It should include selector "([^\"]*)"$/ do |tag|
  Then %{It should include tag \"#{tag}\"}
end

#USE: Then It should include selector "" within ""
Then /^It should include selector "([^\"]*)" within "([^\"]*)"$/ do |tag_match, parent|
  Then %{It should include tag \"#{tag_match}\" within \"#{parent.to_s}\"}
end

#USE: When I check // within “”
When /^I check \/([^\/]*)\/ within "([^\"]*)"$/ do |field, parent|
  within parent do |scope|
    regexp = Regexp.new(field)
    scope.check(regexp)
  end
end

#USE: When /^I check “([^\"]*)” within “”
When /^I check "([^\"]*)" within "([^\"]*)"$/ do |field, parent|
  within parent do |scope|
    scope.check(field)
  end
end

#USE: When /^(?:|I )check //
When /^(?:|I )check \/([^\/]*)\/$/ do |field|
  regexp = Regexp.new(field)
  check(regexp)
end

#USE: I should be able to see  "
"
Then /^I should be able to see (\d+) "([^\"]*)"$/ do |count,selector|
  assert_have_selector(selector, :count => count)
end

#USE: I should be able to see  "
" within "
"
Then /^I should be able to see (\d+) "([^\"]*)" within "([^\"]*)"$/ do |count,selector, parent|
  within parent do  |scope|
    scope.should have_selector(selector, :count => count)
  end
end

When /^(?:|I )choose "([^\"]*)" within "([^\"]*)"$/ do |field,parent|
  within parent do |scope|
    scope.choose(field)
  end
end

When /^(?:|I )choose \/([^\/]*)\/ within "([^\"]*)"$/ do |field,parent|
  within parent do |scope|
    regexp = Regexp.new(field)
    scope.choose(regexp)
  end
end

Now you can use above listed methods easily and I assure you that if you use them properly you do not have to write a single step definition.

Their uses can be found against USE in the downloaded file.

“Use the Rails the way Rails is”

Happy Boarding

Download PDF format

Before starting here are some useful links

	http://gitrdoc.com/brynary/webrat

http://groups.google.com/group/webrat

http://webrat.lighthouseapp.com/

http://github.com/brynary/webrat

	#webrat on Freenode

Simulating browser events

1. Visiting a URL

GET a URL, following any redirects, and making sure final page is successful

visit "/some/url"

• In general, elements can be located by their inner text, their ‘title’ attribute, their ‘name’ attribute, and their ‘id’ attribute.
• They can be selected using a String, which is converted to an escaped Regexp effectively making it a substring match, or using a Regexp.
• An exception is that using Strings for ids are compared exactly (using ==) rather than converted to a Regexp
• If the element you are trying to look up does not exist, an error occurs

2. Visiting Link

Links can be looked up by text, title, or id

for example To match… Click here to join!

we can write down like

click_link "Click here to join!"             # substring text
click_link /join/i                                    # regexp text
click_link "Sign up"                             # substring title
click_link /sign.*up/i                            # regexp title
click_link /signup.*link/i                       # regexp id
click_link "signup_link"                       # exact id

3. Filling Up a form

Note:

• All fields can be looked up by ID, name, or label inner text
• Text fields, password fields, and text areas can be filled in using fill_in

Enter your Email

fill_in "user_email", :with => "test@example.com"                     # exact id
fill_in /user.*email/, :with => "test@example.com"                   # regexp id
fill_in "user[email]", :with => "test@example.com"               # substring name
fill_in /user[.*mail.*]/, :with => "test@example.com"          # substring name
fill_in "Enter your Email", :with => "test@example.com"    # substring label text
fill_in /enter your email/i, :with => "test@example.com"    # regexp label text

Note: Hidden fields can also be set using

set_hidden_field 'user[l337_test]', :to => 'true'

4. Selecting from Drop Down

Select options can be ‘selected’ by inner text (an exact String or a Regexp to match). It can optionally be selected from a particular select field, using
the usual id, name, or label text.

select "Free account"
select "Free account", :from => "Account Types"
select "Free account", :from => "user[account_type]"
select "Free account", :from => "user_account_type"

5. Check Boxes

Check boxes can be ‘checked’ and ‘unchecked’

check 'Remember me'
uncheck 'Remember me'

6. Radio Buttons

Radio buttons can be also choosen, using the usual label text, name, or id.

choose "Yes"

7. Buttons

click_button "Register"

Assertions

check for text in the body of html tags
can be a string or regexp

assert_contain("Successfully created")
assert_contain(/trogdor/i)
assert_not_contain("peasants")

check for a css3 selector

assert_have_selector 'div.pagination'
assert_have_no_selector 'form input#name'

Note: Assertion does work not inside block

Matchers

check for text in the body of html tags
an be a string or regexp

response.should contain("BURNINATOR")
response.should contain(/trogdor/i)
response.should_not contain("peasants")

check for a css3 selector

response.should have_selector('div.pagination')
response.should_not have_selector('form input#name')

Targetted actions/matchers

within 'div.pagination' do |scope|
	scope.click_link "1"
end

within '.shows' do |scope|
	scope.should contain("NFL")
	# unfortunately, assertions don't support this currently
end

This Blog has been relocated to My Website

Happy Boarding…………………

There are three agile software development methodology out there.
first the XP(Extreme Programming), Second Crystal Clear and third one is SCRUM. SCRUM is what that fascinates me.

SCRUM is all about developing a software in an incremental iterative framework. In SCRUM we provide our client a single running module of project in an certain timeline (generally 2 to 4 week) called Sprint.

SCRUM

In scrum, there are three roles.
1. Product Owner (or client)

The role of Product owner is to just Prioritize the requirement that he/she/they wanted to be developed within a limited timespan.

2. ScrumMaster

The role of ScrumMaster  (or Project Manager) is to prioritize the product backlog (given by Product Owner) and Lead the Scrum meeting (Probably in every 24 hour). Requirements are frozen once they are in sprint backlog. No one allowed to change them even Product Owner.

3. The Team

The team of 5-10 people specializes in cross functional skills (Design, develop,test.. etc.) who does the actual work (build a shippable item in a sprint)

That’s really it.

In rake you can define dependencies of one rake task on other pre written
tasks.

When we run the rake command it looks for a rakefile to load the rake task for predefined or default rake tasks then it loads rake task passed to it as a parameter.

If one don’t pass it parameters then it lists all the defined rake task.

Here are some of them
GEM
1. Gem is a packaged ruby application using the packaging system defined by RubyGems.
2. Rails itself is a Gem
3. We can install,upgrade and query the gem version.
4. Gem installed for Ruby interpreter can be used system-wide by that interpreter.

Plugin

1. Plugin is an extension of Rails Framework.
2. Can not be upgraded by using a command. To upgrade one have to uninstall and then install upgraded version.
3. Has to be hooked into rails application. (has to have init.rb)
4. Have an install.rb file.
5. Can only be used application wide.