DZone Snippets: ruby code

ActiveRecord each_by_page

duncanbeevers (Duncan Beevers) — Tue, 20 Feb 2007 23:59:50 GMT

Perform an operation on a set of models including ActiveRecord callbacks, without instantiating all models at once.

Step through and instantiate each member of the class and execute on it, but instantiate no more than per_page instances at any given time.
Safe for destructive actions or actions that modify the fields your :order or :conditions clauses operate on.



module ActiveRecord

  class Base

    def each_by_page per_page, options = {}, &block

      # By-id for model-modifying blocks

      # Build SQL to get ids of all matching records using the options provided by the user

      sql = construct_finder_sql(options.dup.merge({ :select => 'id' }))

      # Get the results as an array of tiny hashes { "id" => "1" } and flatten them out to just the ids

      all_ids = connection.select_all(sql).map { |h| h['id'] }

      at_a_time = 0..(per_page-1)

 

      # chop apart the all_ids array a segment at a time

      begin

        ids = all_ids.slice!(at_a_time)

        ids_cases = []

        ids.each_with_index { |id, i| ids_cases << "WHEN #{id} THEN #{i}" }

        ids_cases = ids_cases.join(' ')

 

        # Do the deed on this page of results

        find(:all, options.merge(

          :conditions => [ 'id IN (?)', ids ],

          :order => "CASE id #{ids_cases} END"

        )).each &block

 

      end until all_ids.empty?

    end

  end

end

link to blog entry

Split String into roughly equal-sized chunks.

duncanbeevers (Duncan Beevers) — Thu, 21 Sep 2006 00:29:28 GMT

Split a string into an array of roughly equal sized chunks based on a string or regular expression delimiter.
Delimiter is preserved in output.



class String

  def chunk_string(average_segment_size = 40, sclice_on = /\s+/)

    out = []

    slices_estimate = self.size.divmod(average_segment_size)

    slice_count = (slices_estimate[1] > 0 ? slices_estimate[0] + 1 : slices_estimate[0])

    slice_guess = self.size / slice_count

    previous_slice_location = 0

    (1..slice_count - 1).each do

      |i|

      slice_location = self.nearest_split(slice_guess * i, sclice_on)

      out << self.slice(previous_slice_location..slice_location)

      previous_slice_location = slice_location + 1

    end

    out << self.slice(previous_slice_location..self.size)

    out

  end



  def nearest_split(slice_start, slice_on)

    left_scan_location  = (self.slice(0..slice_start).rindex(slice_on)).to_i

    right_scan_location = (self.slice((slice_start+1)..self.size).index(slice_on)).to_i + slice_start

    ((slice_start - left_scan_location) < (right_scan_location - slice_start) ? left_scan_location : right_scan_location)

  end

end

Return the extension from a file name

duncanbeevers (Duncan Beevers) — Thu, 07 Sep 2006 02:06:00 GMT

// Return the extension from a file name



/(.*\.)(.*$)/.match(File.basename(file_name))[2]