ibm_db 2.5.0 → 2.5.5

data/CHANGES

@@ -1,5 +1,10 @@
 Change Log
 ==============
+2010/07/15 (IBM_DB adapter 2.5.5, driver 2.5.5) :
+  - Support for datatype Graphic and Vargraphic in driver and adapter [27965]
+  - Support for Bigint datatype in adapter.
+  - Fixed bug [28295] --> IBM_DB, Unicode Version, fails with encoding error against Informix Server
+
 2010/05/12 (IBM_DB adapter 2.5.0, driver 2.5.0) :
   - Support for Unicode with Ruby 1.9 [Data from the IBM_DB driver is returned in UTF8 format]
   - Fixed bug [27954] --> Fixed Truncation of char for bit data containing a Null Terminator

data/README

@@ -1,5 +1,5 @@
 =====================================================================
-README for the IBM_DB Adapter (2.5.0) and Driver (2.5.0) (2010/05/12)
+README for the IBM_DB Adapter (2.5.5) and Driver (2.5.5) (2010/07/15)
 For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 

data/ext/ibm_db.c

@@ -12,7 +12,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "2.5.0"
+#define MODULE_RELEASE "2.5.5"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -515,6 +515,8 @@ static void _ruby_ibm_db_free_result_struct(stmt_handle* handle)
           case SQL_WCHAR:
           case SQL_VARCHAR:
           case SQL_WVARCHAR:
+          case SQL_GRAPHIC:
+          case SQL_VARGRAPHIC:
 #ifndef PASE /* i5/OS SQL_LONGVARCHAR is SQL_VARCHAR */
           case SQL_LONGVARCHAR:
           case SQL_WLONGVARCHAR:
@@ -1629,16 +1631,19 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
     column_type =  stmt_res->column_info[i].type;
     row_data    =  &stmt_res->row_data[i].data;
 
+    bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
+
     switch(column_type) {
       case SQL_CHAR:
       case SQL_WCHAR:
       case SQL_VARCHAR:
       case SQL_WVARCHAR:
+      case SQL_GRAPHIC:
+      case SQL_VARGRAPHIC:
 #ifndef PASE /* i5/OS EBCIDIC<->ASCII related - we do getdata call instead */
       case SQL_LONGVARCHAR:
       case SQL_WLONGVARCHAR:
 
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
 #ifdef UNICODE_SUPPORT_VERSION
         bindCol_args->TargetType      =  SQL_C_WCHAR;
         bindCol_args->buff_length     =  (stmt_res->column_info[i].size+1) * sizeof(SQLWCHAR);
@@ -1647,6 +1652,13 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
 #else
         bindCol_args->TargetType      =  SQL_C_CHAR;
         bindCol_args->buff_length     =  stmt_res->column_info[i].size+1;
+        if( column_type == SQL_GRAPHIC || column_type == SQL_VARGRAPHIC ){
+          /* Graphic string is 2 byte character string.
+           * Size multiply by 2 is required only for non-unicode support version because the W equivalent functions return 
+           * SQLType as wchar or wvarchar, respectively. Hence is handled properly.        
+           */
+          bindCol_args->buff_length     =  bindCol_args->buff_length * 2;
+        }
         row_data->str_val             =  ALLOC_N(char, bindCol_args->buff_length);
 #endif
         bindCol_args->TargetValuePtr  =  row_data->str_val;
@@ -1668,7 +1680,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
       case SQL_LONGVARBINARY:
 #endif /* PASE */
       case SQL_VARBINARY:
-        bindCol_args->col_num           =  (SQLUSMALLINT) i+1;
         bindCol_args->out_length        =  (SQLLEN *) (&stmt_res->row_data[i].out_length);
 
         if ( stmt_res->s_bin_mode == CONVERT ) {
@@ -1703,7 +1714,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
       case SQL_TYPE_TIMESTAMP:
       case SQL_BIGINT:
       case SQL_DECFLOAT:
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  SQL_C_CHAR;
         bindCol_args->buff_length     =  stmt_res->column_info[i].size+1;
         row_data->str_val             =  ALLOC_N(char, bindCol_args->buff_length);
@@ -1719,7 +1729,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
         break;
 
       case SQL_SMALLINT:
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  SQL_C_DEFAULT;
         bindCol_args->buff_length     =  sizeof(row_data->s_val);
         bindCol_args->TargetValuePtr  =  &row_data->s_val;
@@ -1734,7 +1743,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
         break;
 
       case SQL_INTEGER:
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  SQL_C_DEFAULT;
         bindCol_args->buff_length     =  sizeof(row_data->i_val);
         bindCol_args->TargetValuePtr  =  &row_data->i_val;
@@ -1750,7 +1758,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
 
       case SQL_REAL:
       case SQL_FLOAT:
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  SQL_C_DEFAULT;
         bindCol_args->buff_length     =  sizeof(row_data->f_val);
         bindCol_args->TargetValuePtr  =  &row_data->f_val;
@@ -1765,7 +1772,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
         break;
 
       case SQL_DOUBLE:
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  SQL_C_DEFAULT;
         bindCol_args->buff_length     =  sizeof(row_data->d_val);
         bindCol_args->TargetValuePtr  =  &row_data->d_val;
@@ -1781,7 +1787,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
 
       case SQL_DECIMAL:
       case SQL_NUMERIC:
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  SQL_C_CHAR;
         bindCol_args->buff_length     =  stmt_res->column_info[i].size +
                                            stmt_res->column_info[i].scale + 2 + 1;
@@ -1801,7 +1806,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
         stmt_res->row_data[i].out_length  =  0;
         stmt_res->column_info[i].loc_type =  SQL_CLOB_LOCATOR;
 
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  stmt_res->column_info[i].loc_type;
         bindCol_args->buff_length     =  4;
         bindCol_args->TargetValuePtr  =  &stmt_res->column_info[i].lob_loc;
@@ -1818,7 +1822,6 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
         stmt_res->row_data[i].out_length  =  0;
         stmt_res->column_info[i].loc_type =  SQL_BLOB_LOCATOR;
 
-        bindCol_args->col_num         =  (SQLUSMALLINT) i+1;
         bindCol_args->TargetType      =  stmt_res->column_info[i].loc_type;
         bindCol_args->buff_length     =  4;
         bindCol_args->TargetValuePtr  =  &stmt_res->column_info[i].lob_loc;
@@ -5638,13 +5641,20 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
               curr->ivalue = curr->param_size;
             }
           } else {
-            if (curr->ivalue < ( curr->param_size * sizeof(SQLWCHAR) ) ) {
-              curr->ivalue = curr->param_size * sizeof(SQLWCHAR);
+            if (curr->ivalue < ( (curr->param_size + 1) * sizeof(SQLWCHAR) ) ) {
+              curr->ivalue = (curr->param_size + 1)* sizeof(SQLWCHAR);
             }
           }
 #else
           if (curr->ivalue < curr->param_size ) {
-            curr->ivalue = curr->param_size;
+            curr->ivalue = curr->param_size + 1;
+          }
+
+          if ( curr->data_type == SQL_GRAPHIC || curr->data_type == SQL_VARGRAPHIC ){
+           /* graphic strings are 2 byte characters.
+            * Not required for unicode support, as datatype is w equivalent of char.
+           */
+           curr->ivalue = curr->ivalue * 2; 
           }
 #endif
         } else {
@@ -5663,6 +5673,12 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
             if( curr->size > curr->ivalue ) {
               curr->ivalue = curr->size + 1;
             }
+            if ( curr->data_type == SQL_GRAPHIC || curr->data_type == SQL_VARGRAPHIC ){
+             /* graphic strings are 2 byte characters.
+              * Not required for unicode support, as datatype is w equivalent of char.
+              */
+             curr->ivalue = curr->ivalue * 2;
+            }
 #endif
           } else {
 #ifdef UNICODE_SUPPORT_VERSION
@@ -5673,6 +5689,12 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
               }
 #else
               curr->ivalue = curr->size + 1;
+              if ( curr->data_type == SQL_GRAPHIC || curr->data_type == SQL_VARGRAPHIC ){
+               /* graphic strings are 2 byte characters.
+                * Not required for unicode support, as datatype is w equivalent of char.
+                */
+               curr->ivalue = curr->ivalue * 2;
+              }
 #endif
           }
         }
@@ -5699,11 +5721,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
             paramValuePtr                    =  (SQLPOINTER)curr->svalue;
           } else if (curr->param_type == SQL_PARAM_INPUT_OUTPUT) {
             curr->bind_indicator             =  origlen;
-#ifdef UNICODE_SUPPORT_VERSION
-            bindParameter_args->buff_length  =  curr->ivalue/sizeof(SQLWCHAR);
-#else
             bindParameter_args->buff_length  =  curr->ivalue;
-#endif
             paramValuePtr                    =  (SQLPOINTER)curr->svalue;
           } else {
             curr->bind_indicator = SQL_DATA_AT_EXEC;
@@ -5752,20 +5770,17 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
 
         /* This option should handle most other types such as DATE, VARCHAR etc */
         default:
-          if ( curr->param_type == SQL_PARAM_OUTPUT ) {
-            curr->bind_indicator             =  curr->ivalue;
-            bindParameter_args->buff_length  =  curr->ivalue;
-          } else if (curr->param_type == SQL_PARAM_INPUT_OUTPUT) {
+          if ( curr->param_type == SQL_PARAM_INPUT_OUTPUT ) {
             curr->bind_indicator             =  origlen;
-#ifdef UNICODE_SUPPORT_VERSION
-            bindParameter_args->buff_length  =  curr->ivalue/sizeof(SQLWCHAR);
-#else
-            bindParameter_args->buff_length  =  curr->ivalue;
-#endif
           } else {
-            curr->bind_indicator             =  curr->ivalue;
-            bindParameter_args->buff_length  =  curr->ivalue/sizeof(SQLWCHAR);
+            if( curr->param_type == SQL_PARAM_INPUT && 
+                (curr->data_type == SQL_GRAPHIC || curr->data_type == SQL_VARGRAPHIC)){
+              curr->bind_indicator             =  origlen;
+            } else {
+              curr->bind_indicator             =  curr->ivalue;
+            }
           }
+          bindParameter_args->buff_length  =  curr->ivalue;
 #ifdef UNICODE_SUPPORT_VERSION
           valueType = SQL_C_WCHAR;
 #else
@@ -8266,6 +8281,8 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
     case SQL_WCHAR:
     case SQL_VARCHAR:
     case SQL_WVARCHAR:
+    case SQL_GRAPHIC:
+    case SQL_VARGRAPHIC:
 #ifndef PASE /* i5/OS SQL_LONGVARCHAR is SQL_VARCHAR */
     case SQL_LONGVARCHAR:
     case SQL_WLONGVARCHAR:
@@ -8275,6 +8292,13 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
       out_ptr = (SQLPOINTER)ALLOC_N(SQLWCHAR,in_length);
       memset(out_ptr, '\0', in_length * sizeof(SQLWCHAR) );
 #else
+      if( column_type == SQL_GRAPHIC || column_type == SQL_VARGRAPHIC ) {
+          /* Graphic string is 2 byte character string.
+           * Size multiply by 2 is required only for non-unicode support version because the W equivalent functions return
+           * SQLType as wchar or wvarchar, respectively. Hence is handled properly.
+          */
+        in_length = in_length * 2;
+      }
       out_ptr = (SQLPOINTER)ALLOC_N(char,in_length);
       memset(out_ptr, '\0', in_length);
 #endif
@@ -8797,6 +8821,8 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
         case SQL_WCHAR:
         case SQL_VARCHAR:
         case SQL_WVARCHAR:
+        case SQL_GRAPHIC:
+        case SQL_VARGRAPHIC:
 #ifndef PASE /* i5/OS SQL_LONGVARCHAR is SQL_VARCHAR */
         case SQL_LONGVARCHAR:
         case SQL_WLONGVARCHAR:
@@ -9750,11 +9776,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 #ifndef UNICODE_SUPPORT_VERSION
   char buffer11[11];
   char buffer255[255];
-  char buffer2k[2048];
+  char buffer3k[3072]; /*Informix server returns SQL_KEYWORDS data, which requires 2608*/
 #else
   SQLWCHAR buffer11[11];
   SQLWCHAR buffer255[255];
-  SQLWCHAR buffer2k[2048];
+  SQLWCHAR buffer3k[3072]; /*Informix server returns SQL_KEYWORDS data, which requires 2608*/
 #endif
 
   SQLSMALLINT bufferint16;
@@ -9889,11 +9915,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   /* KEYWORDS */
   getInfo_args->infoType     =  SQL_KEYWORDS;
-  getInfo_args->infoValue    =  (SQLPOINTER)buffer2k;
-  getInfo_args->buff_length  =  sizeof( buffer2k );
+  getInfo_args->infoValue    =  (SQLPOINTER)buffer3k;
+  getInfo_args->buff_length  =  sizeof( buffer3k );
   out_length                 =  0;
 
-  memset(buffer2k, '\0', sizeof(buffer2k));
+  memset(buffer3k, '\0', sizeof(buffer3k));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
@@ -9903,10 +9929,10 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
     VALUE keywordsStr, keywordsArray;
 
 #ifdef UNICODE_SUPPORT_VERSION
-    keywordsStr   =  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer2k, out_length);
+    keywordsStr   =  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer3k, out_length);
     keywordsArray =  rb_str_split(keywordsStr, RSTRING_PTR(_ruby_ibm_db_export_char_to_utf8_rstr(",")) );
 #else
-    keywordsStr   = rb_str_new2( buffer2k );
+    keywordsStr   = rb_str_new2( buffer3k );
     keywordsArray = rb_str_split(keywordsStr, ",");
 #endif
 

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -232,6 +232,8 @@ module ActiveRecord
             :binary
           when /smallint/i
             :boolean
+          when /bigint/i
+            :bigint
           when /int|serial/i
             :integer
           when /decimal|numeric|decfloat/i
@@ -244,7 +246,11 @@ module ActiveRecord
             :time
           when /date/i
             :date
-          when /clob|text|graphic/i
+          when /vargraphic/i
+            :vargraphic
+          when /graphic/i
+            :graphic
+          when /clob|text/i
             :text
           when /xml/i
             :xml
@@ -283,9 +289,9 @@ module ActiveRecord
         if args.last.is_a?(Hash) 
           options = args.delete_at(args.length-1)
         end
-        sql = "ALTER TABLE #{@base.quote_table_name(@table_name)} ADD COLUMN "
+        sql_segment = "ALTER TABLE #{@base.quote_table_name(@table_name)} ADD COLUMN "
         args.each do | name | 
-          sql << "#{@base.quote_column_name(name)} xml"
+          sql =  sql_segment + " #{@base.quote_column_name(name)} xml"
           @base.execute(sql,"add_xml_column")
         end  
         return self
@@ -303,6 +309,21 @@ module ActiveRecord
         return self
       end
 
+      def graphic(*args)
+        ibm_parse_column_attributes_args('graphic',*args)
+        return self
+      end
+
+      def vargraphic(*args)
+        ibm_parse_column_attributes_args('vargraphic',*args)
+        return self
+      end
+
+      def bigint(*args)
+        ibm_parse_column_attributes_args('bigint',*args)
+        return self
+      end
+
       #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
       def char(*args)
         ibm_parse_column_attributes_args('char',*args)
@@ -343,6 +364,21 @@ module ActiveRecord
         return self
       end
 
+      def graphic(*args)
+        ibm_parse_column_attributes_args('graphic',*args)
+        return self
+      end
+
+      def vargraphic(*args)
+        ibm_parse_column_attributes_args('vargraphic',*args)
+        return self
+      end
+
+      def bigint(*args)
+        ibm_parse_column_attributes_args('bigint',*args)
+        return self
+      end
+
       #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
       def char(*args)
         ibm_parse_column_attributes_args('char',*args)
@@ -456,6 +492,7 @@ module ActiveRecord
           @set_quoted_literal_replacement = IBM_DB::QUOTED_LITERAL_REPLACEMENT_ON
         end
         
+        @app_user = @account = @application = @workstation = nil
         # Caching database connection options (auditing and billing support)
         @app_user         = conn_options[:app_user]     if conn_options.has_key?(:app_user)
         @account          = conn_options[:account]      if conn_options.has_key?(:account)
@@ -1236,12 +1273,15 @@ module ActiveRecord
           :serial      => { :name => "serial" }, # rowid is a supported datatype on Informix Dynamic Server
           :char        => { :name => "char" },
           :double      => { :name => @servertype.get_double_mapping },
-          :decfloat    => { :name => "decfloat"}
+          :decfloat    => { :name => "decfloat"},
+          :graphic     => { :name => "graphic", :limit => 1},
+          :vargraphic  => { :name => "vargraphic", :limit => 1},
+          :bigint      => { :name => "bigint"}
         }
       end
 
       # IBM data servers do not support limits on certain data types (unlike MySQL)
-      # Limit is supported for the {float, decimal, numeric, varchar, clob, blob} data types.
+      # Limit is supported for the {float, decimal, numeric, varchar, clob, blob, graphic, vargraphic} data types.
       def type_to_sql(type, limit = nil, precision = nil, scale = nil)
         if type.to_sym == :decfloat
           sql_segment = native_database_types[type.to_sym][:name].to_s
@@ -1502,7 +1542,7 @@ module ActiveRecord
                      !column_type =~ /char|lob|graphic/i
                 if column_type =~ /decimal/i
                   column_type << "(#{column_length},#{column_scale})"
-                elsif column_type =~ /smallint|integer|double|date|time|timestamp|xml/i
+                elsif column_type =~ /smallint|integer|double|date|time|timestamp|xml|bigint/i
                   column_type << ""  # override native limits incompatible with table create
                 else
                   column_type << "(#{column_length})"
@@ -1791,11 +1831,16 @@ To remove the column, the table must be dropped and recreated without the #{colu
       end
 
       def limit_not_supported_types
-        [:integer, :double, :date, :time, :timestamp, :xml]
+        [:integer, :double, :date, :time, :timestamp, :xml, :bigint]
       end
     end # class IBM_DataServer
 
     class IBM_DB2 < IBM_DataServer
+      def initialize(adapter)
+        super(adapter)
+        @limit = @offset = nil
+      end
+
       def rename_column(table_name, column_name, new_column_name)
         raise NotImplementedError, "rename_column is not implemented yet in the IBM_DB Adapter"
       end
@@ -1872,12 +1917,9 @@ The column datatype change to [#{data_type}] is not supported by this data serve
       # DB2 specific ALTER TABLE statement to add a default clause
       def change_column_default(table_name, column_name, default)
         # SQL statement which alters column's default value
-        if default.nil?
-          change_column_sql = "ALTER TABLE #{table_name} ALTER #{column_name} DROP DEFAULT"   
-        else
-          change_column_sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} \
+        change_column_sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} \
 SET WITH DEFAULT #{@adapter.quote(default)}"
-        end
+
         stmt = execute(change_column_sql)
         reorg_table(table_name)
         ensure
@@ -1889,16 +1931,17 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         if !default.nil?
           change_column_default(table_name, column_name, default)
         end 
-        #reorg_table(table_name)
+
         if !null.nil? 
           if null
             change_column_sql = "ALTER TABLE #{table_name} ALTER #{column_name} DROP NOT NULL"
           else
             change_column_sql = "ALTER TABLE #{table_name} ALTER #{column_name} SET NOT NULL"
-          end     
+          end
+          stmt = execute(change_column_sql)
+          reorg_table(table_name)
         end
-        stmt = execute(change_column_sql)
-        reorg_table(table_name)
+
         ensure
           IBM_DB.free_stmt(stmt) if stmt   
       end
@@ -2200,7 +2243,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       # Cobra supports parameterised timestamp, 
       # hence overriding following method to allow timestamp datatype to be parameterised
       def limit_not_supported_types
-        [:integer, :double, :date, :time, :xml]
+        [:integer, :double, :date, :time, :xml, :bigint]
       end
 
       # Alter table column for renaming a column
@@ -2445,10 +2488,11 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
             change_column_sql = "ALTER TABLE #{table_name} MODIFY #{column_name} #{sql_type} NOT NULL"
           else
             change_column_sql = "ALTER TABLE #{table_name} MODIFY #{column_name} #{sql_type}"     
-          end 
+          end
+          stmt = execute(change_column_sql)
+          reorg_table(table_name)
         end
-        stmt = execute(change_column_sql)
-        reorg_table(table_name)
+
         ensure
           IBM_DB.free_stmt(stmt) if stmt
       end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 2
   - 5
-  - 0
-  version: 2.5.0
+  - 5
+  version: 2.5.5
 platform: ruby
 authors: 
 - IBM
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-12 00:00:00 +05:30
+date: 2010-07-14 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency