instedd-pigeon 0.1.1

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache
+spec/dummy/config/initializers/pigeon.rb
+
+

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@pigeon --create

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pigeon.gemspec
+gemspec
+
+gem 'rspec-rails'
+gem 'sqlite3'
+gem 'rspec-html-matchers', :group => :test
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ary Borenszweig
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+# Pigeon
+
+This gem handles creating, updating and destroying
+[Nuntium](http://nuntium.instedd.org) and
+[Verboice](http://verboice.instedd.org) channels in your Rails application.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'instedd-pigeon', :require => 'pigeon'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Create an initializer to configure Pigeon (eg. `config/initializers/pigeon.rb`):
+
+    Pigeon.setup do |config|
+        config.application_name = 'My application'
+
+        config.nuntium_host = 'http://nuntium.instedd.org'
+        config.nuntium_account = 'nuntium_account'
+        config.nuntium_app = 'nuntium_application'
+        config.nuntium_app_password = 'password'
+
+        config.verboice_host = 'http://verboice.instedd.org'
+        config.verboice_account = 'account@example.com'
+        config.verboice_password = 'password'
+        config.verboice_default_call_flow = 'Default Call Flow'
+
+        # If you want to support Nuntium Twitter channels, get your Twitter
+        # consumer keys from https://dev.twitter.com/apps
+        config.twitter_consumer_key = 'CONSUMER_KEY'
+        config.twitter_consumer_secret = 'CONSUMER_SECRET'
+    end
+
+Add Pigeon assets to your application, for example by adding to
+`app/assets/javascripts/application.js` the line
+
+    //= require pigeon
+
+and to `app/assets/stylesheets/application.css`
+
+    /*
+    *= require pigeon
+    */
+
+If you need to support Nuntium Twitter channels, mount the Pigeon engine by
+adding to your `routes.rb`
+
+    mount Pigeon::Engine => '/pigeon'
+
+It is **strongly advised** to filter the engine's request through
+authentication. If your application uses Devise, you can easily do it by
+mounting the engine with `authenticate`:
+
+    authenticate :user do
+        mount Pigeon::Engine => '/pigeon'
+    end
+
+Once properly configured, the gem provides a couple of classes
+`Pigeon::NuntiumChannel` and `Pigeon::VerboiceChannel` to manipulate channels
+which act as ActiveModels and provide a similar API to
+[ActiveResource](https://github.com/rails/activeresource).
+
+Pigeon channels should have a `kind` linking them to schemas which provide
+information about the specific attributes required to configure each channel
+type. The class methods `schemas` and `find_schema` provide access to all known
+schemas.
+
+Sample interaction session:
+
+    > c = Pigeon::NuntiumChannel.new name: 'foo', kind: 'pop3'
+    => #<Pigeon::NuntiumChannel:0xa45938c>
+    > c.schema.kind
+    => "pop3"
+    > c.attributes
+    => {"protocol"=>"mailto", "priority"=>100, "enabled"=>true, "direction"=>"bidirectional", "configuration"=>{}, "name"=>"foo", "kind"=>"pop3"}
+    > c.schema.user_attributes
+    => ["configuration[host]", "configuration[port]", "configuration[user]", "configuration[password]", "configuration[use_ssl]", "configuration[remove_quoted_text_or_text_after_first_empty_line]"]
+    > c.configuration[:host] = 'example.com'
+    => "example.com"
+    > c.assign_attributes('configuration[user]' => 'foo', 'configuration[password]' => 'bar')
+    => {"configuration[user]"=>"foo", "configuration[password]"=>"bar"}
+    > c.save
+    => false
+    > c.errors.full_messages
+    => ["port is not a number"]
+    > c.write_attribute('configuration[port]', 110)
+    => 110
+    > c.new_record?
+    => true
+    > c.save
+    => true
+    > Pigeon::NuntiumChannel.list
+    => ["foo"]
+    > c = Pigeon::NuntiumChannel.find('foo')
+    => #<Pigeon::NuntiumChannel:0xb027708>
+    > c.kind
+    => "pop3"
+    > c.new_record?
+    => false
+    > c.destroy
+    => true
+    > c.destroyed?
+    => true
+
+The gem also provides helpers to aid in the rendering of the channel's
+configuration form. The most important ones are
+`pigeon_nuntium_channel_kinds_for_select` and
+`pigeon_verboice_channel_kinds_for_select` to use as options generators for the
+`select_tag` Rails helper, and `pigeon_render_channel` which will render
+the fields required for a user to configure the given channel.
+
+For example, in the view:
+
+    <%= form_tag('/channels') do %>
+        <%= hidden_field_tag :name, @channel.name %>
+        <%= pigeon_render_channel @channel %>
+    <%= end %>
+
+Then in the controller:
+
+    def update
+        @channel = Pigeon::NuntiumChannel.find(params[:name])
+        @channel.assign_attributes(params[:channel])
+        @channel.save!
+        redirect_to channels_path
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/assets/javascripts/pigeon/qst-server-wizard.js.coffee

@@ -0,0 +1,58 @@
+#= require pigeon/wizard
+
+class QstServerWizard extends PigeonWizard
+  onPhoneType: (type) ->
+    @pages.each (index, page) ->
+      page_phone_type = $(page).data('phone-type')
+      if page_phone_type
+        page.disabled = page_phone_type != type
+      true
+    @attribute('phone_type').val(type)
+    @updateNavigation()
+
+  initPhoneType: (type) ->
+    @phone_type_radios.each (index, radio) ->
+      $(radio).attr('checked', radio.value == type)
+    @onPhoneType type
+
+  initWizard: ->
+    self = this
+
+    @navigation.show()
+    @pages[0].disabled = true
+
+    @ticket_code_fields = $('.ticket_code', @div)
+    @phone_type_radios = $('.phone_type', @div)
+
+    @initPhoneType @attribute('phone_type').val()
+    @phone_type_radios.click ->
+      self.onPhoneType @value
+
+    @ticket_code_fields.change ->
+      # update both ticket_code fields to make sure the current value gets
+      # posted
+      self.attribute('ticket_code').val(@value)
+
+    password_field = @attribute('configuration[password]')
+    if password_field.val() == ''
+      password_field.val(@generatePassword())
+
+    @attribute('ticket_message').val("This phone will be used for #{@app_name}.")
+    @attribute('use_ticket').val(true)
+
+  initPersisted: ->
+    $('#qst-reconfigure', @div).click =>
+      @initWizard()
+      @selectPage 1
+    @navigation.hide()
+    @selectPage 0
+
+  run: ->
+    if @persisted
+      @initPersisted()
+    else
+      @initWizard()
+      @selectDefaultPage()
+
+PigeonWizard.registerClass 'qst-server', QstServerWizard
+

data/app/assets/javascripts/pigeon/template.js.coffee

@@ -0,0 +1,43 @@
+class PigeonTemplate
+  @klasses = {}
+
+  @registerClass: (type, klass) ->
+    @klasses[type] = klass
+
+  constructor: (@div) ->
+    div = $(@div)
+    @scope = div.data('scope')
+    @channel_name = div.data('name')
+    @channel_kind = div.data('kind')
+    @persisted = div.data('persisted')
+    @app_name = div.data('application-name') || 'Pigeon'
+
+  scoped_name: (name) ->
+    if @scope
+      bracket = name.indexOf('[')
+      if bracket >= 0
+        @scope + '[' + name[0..bracket-1] + ']' + name[bracket..-1]
+      else
+        @scope + '[' + name + ']'
+    else
+      name
+
+  attribute: (name) ->
+    $("[name=\"#{@scoped_name(name)}\"]", @div)
+
+  run: ->
+
+window.PigeonTemplate = PigeonTemplate
+
+jQuery.fn.pigeonTemplate = ->
+  @each (index, template) ->
+    type = $(template).data('type')
+    klass = PigeonTemplate.klasses[type]
+    if klass
+      new klass(template).run()
+    else
+      new PigeonTemplate(template).run()
+
+jQuery ->
+  $('.pigeon.pigeon_template').pigeonTemplate()
+

data/app/assets/javascripts/pigeon/twitter-template.js.coffee

@@ -0,0 +1,38 @@
+#= require pigeon/template
+
+class TwitterTemplate extends PigeonTemplate
+  onAuthorized: ->
+    $('.twitter_not_authorized').hide()
+    $('.twitter_authorized').show()
+    $('.screen_name').text(@screen_name.val())
+
+  beginTwitterAuthorization: ->
+    callback = 'pigeon_callback_' + (Math.round(Math.random() * 1000000))
+    window[callback] = (token, secret, screen_name) =>
+      @token.val(token)
+      @secret.val(secret)
+      @screen_name.val(screen_name)
+      @onAuthorized()
+
+    url = @twitter_auth_url + '?js_callback=' + callback
+    window.open(url, 'pigeon_twitter', 'menubar=no,location=yes,width=593,height=533')
+
+  run: ->
+    @screen_name = @attribute('configuration[screen_name]')
+    @token = @attribute('configuration[token]')
+    @secret = @attribute('configuration[secret]')
+
+    @button = $('.twitter_authorize_button')
+    @twitter_auth_url = $(@div).data('twitter-path')
+
+    if @screen_name.val() != ''
+      @onAuthorized()
+    else
+      $('.twitter_not_authorized').show()
+      $('.twitter_authorized').hide()
+
+    @button.click =>
+      @beginTwitterAuthorization()
+
+PigeonTemplate.registerClass 'twitter', TwitterTemplate
+

data/app/assets/javascripts/pigeon/wizard.js.coffee

@@ -0,0 +1,95 @@
+#= require pigeon/template
+
+class PigeonWizard extends PigeonTemplate
+  @klasses = {}
+
+  @registerClass: (type, klass) ->
+    @klasses[type] = klass
+
+  constructor: (@div) ->
+    super
+    @prevButton = $('<button type="button">Prev</button>')
+    @nextButton = $('<button type="button">Next</button>')
+    @pages = $(@div).find('.pigeon_wizard_page')
+    @navigation = $('<div class="pigeon_wizard_navigation"></div>').append(@prevButton).append(@nextButton).appendTo(@div)
+    @current = -1
+
+    @prevButton.click =>
+      prev = @prevActivePage(@current)
+      @selectPage prev if prev >= 0
+
+    @nextButton.click =>
+      next = @nextActivePage(@current)
+      @selectPage next if next >= 0
+              
+  prevActivePage: (index) ->
+    index--
+    while index >= 0 && @pages[index].disabled
+      index--
+    index
+
+  nextActivePage: (index) ->
+    index++
+    while index < @pages.length && @pages[index].disabled
+      index++
+    if index >= @pages.length then -1 else index
+
+  selectPage: (index) ->
+    $(@pages[@current]).removeClass('active') unless @current < 0
+    $(@pages[index]).addClass('active')
+    @current = index
+    @updateNavigation()
+
+  updateNavigation: ->
+    if @prevActivePage(@current) < 0
+      @prevButton.attr('disabled', 'disabled')
+    else
+      @prevButton.removeAttr('disabled')
+    if @nextActivePage(@current) < 0
+      @nextButton.attr('disabled', 'disabled')
+    else
+      @nextButton.removeAttr('disabled')
+    
+  selectDefaultPage: ->
+    # If any active page has a field with an error, select that
+    # Otherwise, select the first active page
+    pages_with_errors = $('.field_with_errors').
+      parents('.pigeon_wizard_page').filter -> !@disabled
+    found = -1
+    if pages_with_errors.length > 0
+      pages_with_errors.each (index, page) =>
+        index_in_pages = $.inArray(page, @pages)
+        if found < 0 || (index_in_pages >= 0 && index_in_pages < found)
+          found = index_in_pages
+
+    if found >= 0
+      @selectPage found
+    else
+      @selectPage @nextActivePage(-1)
+
+  run: ->
+    @selectDefaultPage()
+    
+  generatePassword: (length = 8) ->
+    charset = "abcdefghijklnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+    retVal = ""
+    n = charset.length
+    for i in [0..length]
+      retVal += charset.charAt(Math.floor(Math.random() * n))
+    retVal
+
+
+window.PigeonWizard = PigeonWizard
+
+jQuery.fn.pigeonWizard = ->
+  @each (index, wizard) ->
+    type = $(wizard).data('type')
+    klass = PigeonWizard.klasses[type]
+    if klass
+      new klass(wizard).run()
+    else
+      new PigeonWizard(wizard).run()
+
+jQuery ->
+  $('.pigeon.pigeon_wizard').pigeonWizard()
+

data/app/assets/javascripts/pigeon.js

@@ -0,0 +1,2 @@
+//= require_self
+//= require_tree ./pigeon

data/app/assets/stylesheets/pigeon.css.sass

@@ -0,0 +1,13 @@
+.pigeon
+  &.pigeon_template
+    .pigeon_attribute
+      margin-top: 20px
+      input[type=text], input[type=password], input[type=email], input[type=url]
+        width: 300px
+
+  &.pigeon_wizard
+    .pigeon_wizard_page
+      display: none
+      &.active
+        display: block
+

data/app/controllers/pigeon/twitter_controller.rb

@@ -0,0 +1,44 @@
+require 'twitter_oauth'
+
+module Pigeon
+  class TwitterController < ActionController::Base
+    def begin
+      client = new_twitter_client
+
+      request_token = client.request_token(:oauth_callback => twitter_callback_url)
+      session[:pigeon] ||= {}
+      session[:pigeon][:twitter] = { 
+        token: request_token.token, 
+        secret: request_token.secret 
+      }
+      session[:pigeon][:js_callback] = params[:js_callback]
+      redirect_to request_token.authorize_url
+    end
+
+    def callback
+      if session[:pigeon].nil? || session[:pigeon][:twitter].nil?
+        redirect_to twitter_url
+      end
+
+      client = new_twitter_client
+
+      request_token = session[:pigeon][:twitter]
+      @access_token = client.authorize(
+        request_token[:token],
+        request_token[:secret],
+        :oauth_verifier => params[:oauth_verifier]
+      )
+      @callback = session[:pigeon][:js_callback] || 'pigeon_twitter_callback'
+      @screen_name = client.info['screen_name']
+    end
+
+  private
+
+    def new_twitter_client
+      client = TwitterOAuth::Client.new(
+        :consumer_key => Pigeon.config.twitter_consumer_key,
+        :consumer_secret => Pigeon.config.twitter_consumer_secret
+      )
+    end
+  end
+end

data/app/helpers/pigeon/channel_helper.rb

@@ -0,0 +1,93 @@
+module Pigeon
+  module ChannelHelper
+    include ActionView::Helpers::CaptureHelper
+    include ActionView::Helpers::FormHelper
+    include ActionView::Helpers::FormOptionsHelper
+
+    def pigeon_attribute_field(attribute, value = nil, options = {})
+      scope = options.delete(:scope)
+      field_name = attribute.scoped_name(scope)
+      field_value = value || ''
+      forced_type = options.delete(:type)
+      render_type = (forced_type || attribute.type).to_s
+
+      case render_type
+      when "string"
+        text_field_tag(field_name, field_value, options)
+      when "password"
+        password_field_tag(field_name, field_value, options)
+      when "integer"
+        number_field_tag(field_name, field_value, options)
+      when "enum"
+        choices = attribute.options
+        if choices.length > 0 && choices[0].is_a?(Hash)
+          choices = choices.map { |h| [h["display"], h["value"]] }
+        end
+        select_tag(field_name, options_for_select(choices, field_value), options)
+      when "timezone"
+        select_tag(field_name, time_zone_options_for_select(field_value), options)
+      when "boolean"
+        check_box_tag(field_name, '1', field_value.present?, options)
+      when "hidden"
+        hidden_field_tag(field_name, field_value, options)
+      else
+        text_field_tag(field_name, field_value, 
+                       { :type => render_type }.merge(options))
+      end
+    end
+
+    def pigeon_attribute_label(attribute, options = {})
+      return '' if attribute.type == :hidden
+      scope = options.delete(:scope)
+      field_name = attribute.scoped_name(scope)
+      label_tag(field_name, attribute.label, options)
+    end
+
+    def pigeon_attribute(attribute, value = nil, options = {})
+      scope = options.delete(:scope)
+      field_with_errors = options.delete(:field_with_errors)
+      content_tag :div, options do
+        label = pigeon_attribute_label(attribute, scope: scope)
+        field = pigeon_attribute_field(attribute, value, scope: scope)
+        if field_with_errors.present?
+          field = content_tag :div, field, :class => 'field_with_errors'
+        end
+        if attribute.type == :boolean
+          safe_join([field, label])
+        elsif attribute.type == :hidden
+          field
+        else
+          safe_join([label, tag(:br), field])
+        end
+      end
+    end
+
+    def pigeon_channel_attribute_field(channel, attr_name, options = {})
+      value = channel.read_attribute(attr_name)
+      attribute = channel.schema.try(:find_attribute, attr_name)
+      attribute ||= ChannelAttribute.build_default(attr_name, value)
+      field = pigeon_attribute_field(attribute, value, options)
+      if channel.errors.include?(attr_name.to_sym)
+        content_tag :div, field, :class => 'field_with_errors'
+      else
+        field
+      end
+    end
+
+    def pigeon_channel_attribute_label(channel, attr_name, options = {})
+      attribute = channel.schema.try(:find_attribute, attr_name)
+      attribute ||= ChannelAttribute.build_default(attr_name)
+      pigeon_attribute_label(attribute, options)
+    end
+
+    def pigeon_channel_attribute(channel, attr_name, options = {})
+      value = channel.read_attribute(attr_name)
+      attribute = channel.schema.try(:find_attribute, attr_name)
+      attribute ||= ChannelAttribute.build_default(attr_name, value)
+      if channel.errors.include?(attr_name.to_sym)
+        options[:field_with_errors] = true
+      end
+      pigeon_attribute(attribute, value, options)
+    end
+  end
+end