DZone Snippets: key code

Reference of keyCodes

jrobertson (James Robertson) — Wed, 02 Apr 2008 22:31:34 GMT



    switch (oEvent.keyCode) {

       case 38: //up arrow  

       case 40: //down arrow

       case 37: //left arrow

       case 39: //right arrow

       case 33: //page up  

       case 34: //page down  

       case 36: //home  

       case 35: //end                  

       case 13: //enter  

       case 9: //tab  

       case 27: //esc  

       case 16: //shift  

       case 17: //ctrl  

       case 18: //alt  

       case 20: //caps lock

       case 8: //backspace  

       case 46: //delete

           return true;

           break;



       default:

Note: When capturing combination keys there is dedicated boolean attributes for each of the special keys (CTRL, SHIFT, ALT).
Reference: Make Life Easy With Autocomplete Textboxes [JavaScript & AJAX Tutorials] [sitepoint.com]

Copy Public Key To Host In One Line

timmorgan (Tim Morgan) — Wed, 19 Mar 2008 18:23:53 GMT



ssh username@host "echo `cat ~/.ssh/id_dsa.pub` >> ~/.ssh/authorized_keys"

Random Characters with Ruby

timmorgan (Tim Morgan) — Thu, 18 Oct 2007 03:24:39 GMT

Use for a password or salt or whatever...



(0..25).inject('') { |r, i| r << rand(93) + 33 }

Api key (or any kind of key) generator

leethal (August Lilleaas) — Mon, 15 Oct 2007 13:03:21 GMT

Generates a random key for API neatness.



class KeyGenerator

  require "digest/sha1"

  def self.generate(length = 10)

    Digest::SHA1.hexdigest(Time.now.to_s + rand(12341234).to_s)[1..length]

  end

end

Recursively dump imbricated Map of Maps

Archanciel (Jean-Pierre Schnyder) — Wed, 12 Sep 2007 12:58:09 GMT

// description of your code here



    public void dumpMapOfMap(Map map) {

        Set s = map.entrySet();

        Iterator sit = s.iterator();

        boolean isFirst = true;



        while (sit.hasNext()) {

            Map.Entry elem = (Map.Entry)sit.next();

            String key = (String)elem.getKey();

            Object value = elem.getValue();



            if (value instanceof String) {

                // recursivity stop condition

                System.out.print(key);

                System.out.print(" : ");

                System.out.println(value);

            } else {

                if (!isFirst) {

                    System.out.println("");

                } else {

                    isFirst = false;

                }

                System.out.println(key);

                Map valueMap = (Map)elem.getValue();

                dumpMapOfMap(valueMap);

            }

        }

    }

Using 64 bit primary keys with migrations

sanj (Sanjay Vakil) — Wed, 15 Aug 2007 13:23:00 GMT

I've got an application which may need more IDs than the standard 32 bit ones typically provide. MySQL has a BIGINT variable type, but it is a little tricky to convince Rails and Migrations to use it. The instructions are for MySQL, but should be easily transferable to other DBs.

1. Monkeypatch ActiveRecord::ConnectionAdapters::MysqlAdapter#native_database_types by appending it to config/environment.rb and add two new types. I've named them int64 and int64_pk



class ActiveRecord::ConnectionAdapters::MysqlAdapter

  def native_database_types #:nodoc:

    {

      :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",

      :int64_pk    => "bigint DEFAULT NULL auto_increment PRIMARY KEY",

      :int64       => { :name => "bigint" },

      :string      => { :name => "varchar", :limit => 255 },

      :text        => { :name => "text" },

      :integer     => { :name => "int", :limit => 11 },

      :float       => { :name => "float" },

      :decimal     => { :name => "decimal" },

      :datetime    => { :name => "datetime" },

      :timestamp   => { :name => "datetime" },

      :time        => { :name => "time" },

      :date        => { :name => "date" },

      :binary      => { :name => "blob" },

      :boolean     => { :name => "tinyint", :limit => 1 },

    }

  end

end

2. In the table creation migration, create the table WITHOUT a primary key column, and then add the column manually, referencing int64_pk above:



create_table :slices, :id => false do |t|

       t.column :cheese_id, :integer

       t.column :plant, :string

       t.column :date, :datetime

     end

    add_column :events, :id, :int64_pk

end

3. In tables referencing this one, mark the foreign_id fields as int64:



create_table :fondues do |t|

      t.column :cheese_id, :int64

      t.column :party_id, :integer

      t.column :kirsch_id, :integer

end

4. It turns out that the c-based mysql bindings do NOT do let you set primary keys via the sequence because it coerces the
insert_id into 32 bits at mysql.c:532. There are two way to fix this:

a. Use the pure-ruby gem (ie, remove the c-gem)

b. Patch and rebuild the c-gem by changing line 352 (in version 2.7):



   return INT2NUM(mysql_insert_id(GetHandler(obj)));

Extending this to use LL2NUM solves the issue:



   return LL2NUM(mysql_insert_id(GetHandler(obj)));

5. One last thing, in environment.rb:



  # Use SQL instead of Active Record's schema dumper when creating the test database.

  # This is necessary if your schema can't be completely dumped by the schema dumper,

  # like if you have constraints or database-specific column types

  config.active_record.schema_format = :sql

We need to deal with sql, rather than ruby, schemas.

----------------------

Note that I've decided that ONLY the cheese table needs 64bit IDs -- other references are still integers. If you wanted ALL primary keys to be 64 bits, you could have the monkeypatch look like:





class ActiveRecord::ConnectionAdapters::MysqlAdapter

  def native_database_types #:nodoc:

    {

      :primary_key    => "bigint DEFAULT NULL auto_increment PRIMARY KEY",

.

.

.

Simulating a foreign key constraint in ActiveRecord (Ruby on Rails)

eddiewould (Eddie) — Thu, 01 Feb 2007 00:55:54 GMT

Say for example we have products and a business rule that every product must have a category. Before ActiveRecord we would have done this with a NOT NULL foreign key constraint at the database level.

It wasn't entirely obvious (to me) how to achieve this in an ActiveRecord model - you need *both* of the following two lines:



  validates_presence_of :category, :message => " must be specified" 

  validates_associated :category

Hope this helps someone.

Google Maps API key for http://localhost/

duncanponting (Duncan Ponting) — Mon, 25 Dec 2006 01:03:11 GMT

// you just paste this in the script tag per the google documentation. I've stuck it hear because I use it a lot for local development.



ABQIAAAAnfs7bKE82qgb3Zc2YyS-oBT2yXp_ZAY8_ufC3CFXhHIE1NvwkxSySz_REpPq-4WZA27OwgbtyR3VcA

Convert an array to a hash with key definitions

El_Oy (Eloy Duran) — Thu, 27 Jul 2006 15:24:09 GMT

First of all I'm relatively new to Ruby, so if there's a easier way
of doing this I would love to know about it :)



class Array

  def to_h(key_definition)

    result_hash = Hash.new()

    

    counter = 0

    key_definition.each do |definition|

      if not self[counter] == nil then

        result_hash[definition] = self[counter].strip

      else

        # Insert the key definition with a empty value.

        # Because we probably still want the hash to contain the key.

        result_hash[definition] = ""

      end

      # For some reason counter.next didn't work here....

      counter = counter + 1

    end

    

    return result_hash

  end

end

Use it like this:



key_definitions = Array['foo', 'bar', 'foobar', 'extra']

some_values     = Array['bla', 99, 'blabla']



some_values.to_h(key_definitions)   # => {'foo' => 'bla', 'bar' => 99, 'foobar' => 'blabla', 'extra' => ''}

Extracting all keys from a multi-dimensional hash

ntk () — Wed, 12 Apr 2006 20:29:09 GMT

Extract all complete key sequences from a multi-dimensional hash (with the last key not pointing to another hash; cf. h[1][2][3] vs h[1][2][3][4] below).





class Hash



   def extract_keys



      keys = []



      each_pair do |k1, v1|



         if v1.is_a?(Hash)



            v1.each_pair { |k2, v2|

               if !v2.is_a?(Hash) then keys << [k1, k2]; next end

            v2.each_pair { |k3, v3|

               if !v3.is_a?(Hash) then keys << [k1, k2, k3]; next end

            v3.each_pair { |k4, v4|

               if !v4.is_a?(Hash) then keys << [k1, k2, k3, k4]; next end

            v4.each_pair { |k5, v5|

               if !v5.is_a?(Hash) then keys << [k1, k2, k3, k4, k5]; next end

            v5.each_pair { |k6, v6|

               if !v6.is_a?(Hash) then keys << [k1, k2, k3, k4, k5, k6]; next end

               # add more v[n].each_pair ... loops to process more hash dimensions

            } } } } }      # "}" * 5



         else

            keys << [k1]

         end



      end

      

      keys



   end





   def all_values

      extract_keys.map do |subar|

         key = ""

         subar.size.times { |i| key << "[subar[#{i}]]" }

         hash_str = "self" << key << " rescue nil"   # example: "self[subar[0]][subar[1]][subar[2]][subar[3]] rescue nil"

         hash_value = eval(hash_str) 

      end

   end





#-------------------------





   # Find every path and it's value in a Hash, http://snippets.dzone.com/posts/show/3565

   # Author: Florian Aßmann



   def each_path

      raise ArgumentError unless block_given?

      self.class.each_path(self) { |path, object| yield(path, object) }

   end



   protected

   #def self.each_path(object, path = '', &block)

   def self.each_path(object, path = [], &block)   # alternative

      if object.is_a?(Hash)

         object.each do |key, value|

            #self.each_path(value, "#{ path }#{ key }/", &block)

            self.each_path(value, [path , key].flatten, &block)   # alternative

         end

      else 

         yield(path, object)

      end

   end 



end





h = {"a"=>"b", "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}}}} 



puts h[1][2].class          # Hash

puts h[1][2]["e"].class     # String



extracted_keys = h.extract_keys

puts extracted_keys.inspect         # [["a"], [1, 2, "e"], [1, 2, 3, 4], ["c"]]



puts h[1][2].has_key?("e")                 # true

puts extracted_keys.include?([1, 2, "e"])  # true





h = {700=>{4=>"value"}, "a"=>"b", 3=>{4=>"value"}, "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}, 300=>{4=>"value"}}}} 

p h

p h.extract_keys    #=> [["a"], [1, 2, "e"], [1, 2, 300, 4], [1, 2, 3, 4], ["c"], [700, 4], [3, 4]]

p h.all_values      #=> ["b", "f", "value", "value", "d", "value", "value"]





#-----------------





paths = []

complex_hash = Hash[

  :a => { :aa => '1', :ab => '2' },

  :b => { :ba => '3', :bb => '4' }

]

complex_hash.each_path { |path, value| paths << [ path, value ] }



p paths    # => [[[:b, :ba], "3"], [[:b, :bb], "4"], [[:a, :ab], "2"], [[:a, :aa], "1"]]

puts





h = {"a"=>"b", "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}}}} 

h = {"a"=>"b", "l" => lambda { |x| x+1 }, 1=>{2=>{"e"=>"f", 3=>{4=>"value"}}}} 

h = {700=>{4=>"value"}, "a"=>"b", nil => "NILVALUE", 3=>{4=>"value"}, "c"=>"d", 1=>{2=>{"e"=>"f", 3=>{4=>"value"}, 300=>{4=>"value"}}}} 



p h

p h.extract_keys



keys = []

h.each_path { |path, value| keys << path }

p keys   # complete key sequences (with last key not pointing to another hash)



paths = []

h.each_path { |path, value| paths << [ path, value ] }

p paths   # complete key sequences plus values



vals = []

h.each_path { |path, value| vals << value }

p vals   # all values of complete key sequences



p h.all_values   # same