1. Add the SVPullToRefresh pod
2. Add the Quartz Framework

# In your Rakefile
Motion::Project::App.setup do |app|
  # ...
  app.frameworks += ['QuartzCore']

  app.pods do
    pod 'SVPullToRefresh'
    # ...
  end

end

def viewDidLoad
   # ....
    tableView.addPullToRefreshWithActionHandler Proc.new {
      loadMagicalData(tableView)
     # do some other magic
     # then don't forget to:
      tableView.pullToRefreshView.stopAnimating
    }

  # ...

end

Motion::Project::App.setup do |app|
  #...
  app.pods do
    # ...
    pod 'NUI'
  end
end

rake clean & rake

app_delegate.rb

class AppDelegate

  @@nui_settings = NUISettings.init
  @@nui_settings.setAutoUpdatePath("/absolute/path/to/project/and/theme.nss")

  def application(application, didFinishLaunchingWithOptions:launchOptions)

    @nui = NUIAppearance.init
    # ...
  end

end

rake

theme.nss

Applications are grown.[1]

There’s quite the range of differences between building an application and growing one, but I’ll focus here on few main ones.

Building something is associated with a resulting rigid structure and components. It takes effort to put together, but once build – it’s static. All what’s left is usage, admiration & maintenance.

On the other hand, growing something is an organic process. It rarely stops. It requires a continuous labour of love. You can reap benefits but as you do, you always have to give back, care and nurture.

Growing is more appropriate to the act of developing software. Applications doesn’t (or shouldn’t) reach a static rigid state, they always benefit from continuous assessment, reevaluation and changes. They adjust to surroundings. They evolve, transform and get bigger (but not necessarily more complex).
 
So – next time you’re discussing new applications – try to see how close the word ‘growing’ is to everyone.

[1] I wish I could remember where first I heard that or who said it.

Well

SurveyPoint

class Well < ActiveRecord::Base
  has_many :survey_points
end

class SurveyPoint < ActiveRecord::Base
  belongs_to :well
end

Say, we’d like to implement a filtration mechanism that allows us to query the wells – and for those set of wells we’d like to conditionally present the set of survey_points for those set of filtered wells.

A method ‘

Well.search

@wells

Using the power of AREL chaining, we could then conditionally extract the SurveyPoints using the following:

def SurveyPoint.find_for_wells(wells)
 scope.where(:well_id => wells.select(:id))
end

This roughly translates into the query:

SELECT * FROM SURVEY_POINTS WHERE WELL_ID IN (SELECT ID FROM WELLS WHERE ....)

The challenge here is that if both results is large, depending on the cardinality – the database engine might not be able to make use of defined indexes and the outer query might not be optimizable.

Instead – if we use pluck instead of select:

def self.find_for_wells(wells)
 scope.where(:well_id => wells.pluck(:id))
end

Rails would fire two queries instead of an inner one. Pluck would first extract the list of ids (val_1, val_2, …) in an array before passing it to the main query. This roughly translates into:

SELECT * FROM SURVEY_POINTS WHERE WELL_ID IN (val_1, val_2, val_3, ....)

No inner query is used in that case and the main one is easy to optimize.

can't convert Hash into String

This had the hallmarks that the application was still under the 1.8 mode (after a deploy to tomcat). The following XML entry in web.xml was essential to enforce the 1.9 mode:

<context-param>
    <param-name>jruby.compat.version</param-name>
    <param-value>1.9</param-value>
  </context-param>

To resolve (following suggestions on the trinidad google group):

# config/initializers/newrelic.rb
if defined?(JRUBY_VERSION) && Rails.env == "development"
  require 'newrelic_rpm'
  NewRelic::Agent.manual_start({:dispatcher => :trinidad, :agent_enabled => true})
end

# Gemfile
group :development do
  gem 'newrelic_rpm', '3.3.0', :require => false
end

According to Nick Sieger’s gist – “NewRelic isn’t detecting Trinidad at the moment” – Although I could see trinidad’s detection mechanism implemented in newrelic’s most recent (3.5.0.1)

I’ve tried it with more recent versions of newrelic – but it seems 3.3.0 is the most stable.
JRuby 1.6.8 (1.9 mode)
trinidad 1.4.4
newrelic_rpm 3.3.0

Getting another error of

undefined method `first' for true:TrueClass

Since I’m using the oracle_enhanced_adapter, the current newrelic “EXPLAIN” query wouldn’t work – hence an error is thrown. However, the error consumption by newrelic returns true rather than nil.

Changing

handle_exception_in_explain

def handle_exception_in_explain
        yield
      rescue Exception => e
        begin
          # guarantees no throw from explain_sql
          NewRelic::Control.instance.log.error("Error getting query plan: #{e.message}")
          NewRelic::Control.instance.log.debug(e.backtrace.join("\n"))
          # UPDATE: Added to prevent issues when drilling down deep into SQL (explain not working)
          nil
        rescue Exception
          # double exception. throw up your hands
        end
      end

First off – a local server that supports streaming is required. The only one I could find was trinidad which is moving to the likely defacto for JRuby/Rails projects. Trinidad uses tomcat-core as it’s servlet container and server.

Then make sure you grab the latest jruby-rack resolving most recent issues (1.1.10 at the time of writing).

This StackOverflow answer, along with this guide offer a comprehensive support as to what options work with Rails version as well as some gotchas (newrelic, caching, haml, …).

For Rails 3.2.x – It boils down to assigning an object that responds to an each method call to the response_body of a controller’s action. However – this doesn’t allow you to set a :stream =>true where it explicitly tells Rails to stream the respons. To resolve that I opted to use a render call, with a passed option hash as follows:

# Controller
def streaming_action
  @objs = MyObj.where(:foo => 'bar')
  render :nothing => true, :stream => true #setting the response to stream while rendering nothing
  self.response_body = Streamer.new(@objs) # the object responding to 'each' call
end

#models/streamer.rb
class Streamer
  attr_accssor :objs

  def initialize(objs)
    @objs = objs
  end

  # all the magic
  def each
    yield "Some initial output for header"
    @objs.each do |obj|
      yield "#{obj.attr}\n"
    end
  end
end

This works with the following releases: JRuby 1.6.8 Rails 3.2.8 jruby-rack 1.1.10 trinidad 1.4.4

[{"id":"aaa","id_and_ba_name":"bbb"}, ...]

var auto = $("#lc").autocomplete({
      minLength: 3,
      delay: 600,
      dataType: 'json',
      source: '/remote/action',
      open: function() {
         $("ul.ui-autocomplete").remove(); //removes the ul styling for dropdown
      }
    })
    auto.data("autocomplete")._renderMenu= function(element, items) {
      //treats the DOM element as the menu where items are to be placed
      var self = this;
      $('#the_select_element').show().html('');
      $.each( items, function( index, item ) {
        self._renderItem($('#the_select_element'), item );
      });
    }
    auto.data("autocomplete")._renderItem= function(element, item) {
       // generate options elements and adds them to menu
       return $("<option></option>")
        .data("item.autocomplete",item)
        .attr("value",item.id)
        .append(item.id_and_ba_name)
        .appendTo(element);
    }