right-rails 0.3.0

data/lib/right_rails/helpers/basic.rb

@@ -0,0 +1,111 @@
+#
+# Basic RightRails feature helpers container
+#
+module RightRails::Helpers::Basic
+  
+  #
+  # Automatically generates the javascript include tags
+  #
+  # USAGE:
+  #   <%= rightjs_scripts %>
+  #
+  #   you can also predefine the list of modules to load
+  #
+  #   <%= rightjs_scripts 'lightbox', 'calendar' %>
+  #
+  def rightjs_scripts(*modules)
+    scripts = ['right']
+    
+    # including the submodules
+    rightjs_include_module *modules
+    ((@_right_scripts || []) + ['rails']).each do |package|
+      scripts << "right/#{package}"
+    end
+    
+    # use the sources in the development environment
+    if defined? RAILS_ENV && RAILS_ENV == 'development'
+      scripts.collect!{ |name| name + '-src' }
+    end
+    
+    # include the localization script if available
+    if defined?(I18n) && defined?(RAILS_ROOT)
+      locale_file = "right/i18n/#{I18n.locale.to_s.downcase}"
+      scripts << locale_file if File.exists? "#{RAILS_ROOT}/public/javascripts/#{locale_file}.js"
+    end
+    
+    javascript_include_tag *scripts
+  end
+  
+  #
+  # The javascript generator access from the templates
+  #
+  # USAGE:
+  #   Might be used both directly or with a block
+  #
+  #   <%= link_to 'Delete', '#', :onclick => rjs[@record].hide('fade') %>
+  #   <%= link_to 'Delete', '#', :onclick => rjs{|page| page[@record].hide('fade') }
+  #
+  def rjs(&block)
+    generator = RightRails::JavaScriptGenerator.new(self)
+    yield(generator) if block_given?
+    generator
+  end
+  
+  #
+  # Same as the rjs method, but will wrap the generatated code
+  # in a <script></script> tag
+  #
+  # EXAMPLE:
+  #   <%= rjs_tag do |page|
+  #     page.alert 'boo'
+  #   end %>
+  #
+  def rjs_tag(&block)
+    javascript_tag do
+      rjs(&block)
+    end
+  end
+  
+# protected
+  
+  #
+  # Notifies the scripts collection that the user needs the module
+  #
+  def rightjs_include_module(*list)
+    @_right_scripts ||= []
+    list.each do |name|
+      @_right_scripts << name.to_s unless @_right_scripts.include?(name.to_s)
+    end
+  end
+  
+  #
+  # Collects the RightJS unit options out of the given list of options
+  #
+  # NOTE: will nuke matching keys out of the original options object
+  #
+  # @param user's options
+  # @param allowed unit options keys
+  #
+  def rightjs_unit_options(options, unit_keys)
+    unit_options = []
+    
+    options.dup.each do |key, value|
+      c_key = key.to_s.camelize.gsub!(/^[A-Z]/){ |m| m.downcase }
+      
+      if unit_keys.include?(c_key)
+        value = options.delete key
+        
+        value = case value.class.name.to_sym
+          when :NilClass then 'null'
+          when :Symbol   then "#{value}"
+          when :String   then "'#{value}'"
+          else                value.inspect
+        end
+        
+        unit_options << "#{c_key}:#{value}"
+      end
+    end
+    
+    "{#{unit_options.sort.join(',')}}"
+  end
+end

data/lib/right_rails/helpers/forms.rb

@@ -0,0 +1,239 @@
+#
+# RightJS specific form features module
+#
+module RightRails::Helpers::Forms
+  CALENDAR_OPTION_KEYS = %w{
+    format
+    showTime
+    twentyFourHour
+    timePeriod
+    showButtons
+    minDate
+    maxDate
+    firstDay
+    numberOfMonths
+    listYears
+  }
+  
+  AUTOCOMPLETER_OPTION_KEYS = %w{
+    param
+    method
+    minLength
+    threshold
+    cache
+    local
+    fxName
+    fxDuration
+    spinner
+  }
+  
+  SLIDER_OPTION_KEYS = %w{
+    min
+    max
+    snap
+    value
+    direction
+    update
+    round
+  }
+  
+  RATER_OPTION_KEYS = %w{
+    size
+    value
+    update
+    disabled
+    disableOnVote
+    url
+    param
+    Xhr
+  }
+  
+  #
+  # Generates the calendar field tag
+  #
+  # The options might contain the usual html options along with the RightJS Calendar options
+  #
+  def calendar_field_tag(name, value=nil, options={})
+    text_field_tag name, value, __add_calendar_field_options(options)
+  end
+  
+  #
+  # The form_for level calendar field generator
+  #
+  def calendar_field(object_name, method, options={})
+    options = __add_calendar_field_options(options)
+    ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_calendar_field_tag(options)
+  end
+  
+  #
+  # Autocompletion field tag
+  #
+  # The options should contain an url or a list of local options
+  #
+  def autocomplete_field_tag(name, value, options)
+    text_field_tag name, value, __add_autocomplete_field_options(options)
+  end
+  
+  #
+  # The form_for level autocomplete-field generator
+  #
+  def autocomplete_field(object_name, method, options)
+    options = __add_autocomplete_field_options(options)
+    ActionView::Helpers::InstanceTag.new(object_name, method, self, options.delete(:object)).to_autocomplete_field_tag(options)
+  end
+  
+  #
+  # The slider widget generator
+  #
+  def slider_tag(name, value=nil, options={})
+    hidden_field_tag(name, value, __add_slider_options(options)) + "\n" + __slider_generator(options.merge(:value => value), name)
+  end
+  
+  #
+  # The form_for level slider widget generator
+  #
+  def slider(object_name, method, options={})
+    ActionView::Helpers::InstanceTag.new(object_name, method, self,
+      options.delete(:object)).to_slider_tag(__add_slider_options(options)) +
+      "\n" + __slider_generator(options, object_name, method)
+  end
+  
+  #
+  # The rater widget basic generator
+  #
+  def rater_tag(name, value, options={})
+    hidden_field_tag(name, value, __add_rater_options(options)) + "\n" + __rater_generator(options.merge(:value => value), name)
+  end
+  
+  #
+  # The form level rater generator
+  #
+  def rater(object_name, method, options={})
+    ActionView::Helpers::InstanceTag.new(object_name, method, self,
+      options.delete(:object)).to_rater_tag(__add_rater_options(options)) +
+      "\n" + __rater_generator(options, object_name, method)
+  end
+  
+  #
+  # Builds a dummy rater, just for displaying purposes
+  #
+  def rater_display(value, options={})
+    content_tag :div, (0...(options[:size] || 5)).to_a.collect{ |i|
+      content_tag :div, '★', :class => i < value ? 'right-rater-glow' : nil
+    }.join(''), :class => 'right-rater right-rater-disabled'
+  end
+  
+private
+
+  def __add_calendar_field_options(options={})
+    rightjs_include_module 'calendar'
+    
+    options['rel'] = 'calendar'
+    
+    calendar_options = rightjs_unit_options(options, CALENDAR_OPTION_KEYS)
+    options['data-calendar-options'] = calendar_options unless calendar_options == '{}'
+    
+    options
+  end
+  
+  def __add_autocomplete_field_options(options)
+    rightjs_include_module 'autocompleter'
+    
+    options['rel'] = "autocompleter[#{escape_javascript(url_for(options.delete(:url)))}]"
+    
+    autocompleter_options = rightjs_unit_options(options, AUTOCOMPLETER_OPTION_KEYS)
+    options['data-autocompleter-options'] = autocompleter_options unless autocompleter_options == '{}'
+    options['autocomplete'] = 'off'
+    
+    options
+  end
+  
+  def __add_slider_options(options)
+    rightjs_include_module 'dnd', 'slider'
+    options.reject { |key, value| SLIDER_OPTION_KEYS.include?(key.to_s) }
+  end
+  
+  def __slider_generator(options, name, method=nil)
+    value   = options[:value]
+    value ||= ActionView::Helpers::InstanceTag.value_before_type_cast(instance_variable_get("@#{name}"), method.to_s) if method
+    name    = "#{name}[#{method}]" if method
+    id      = options[:id] || sanitize_to_id(name)
+    options = rightjs_unit_options(options.merge(:value => value), SLIDER_OPTION_KEYS)
+    javascript_tag "new Slider(#{options}).insertTo('#{id}','after').assignTo('#{id}');"
+  end
+  
+  def __add_rater_options(options)
+    rightjs_include_module 'rater'
+    options.reject { |key, value| RATER_OPTION_KEYS.include?(key.to_s) }
+  end
+  
+  def __rater_generator(options, name, method=nil)
+    value   = options[:value]
+    value ||= ActionView::Helpers::InstanceTag.value_before_type_cast(instance_variable_get("@#{name}"), method.to_s) if method
+    name    = "#{name}[#{method}]" if method
+    id      = options[:id] || sanitize_to_id(name)
+    options = rightjs_unit_options(options.merge(:value => value), RATER_OPTION_KEYS)
+    javascript_tag "new Rater(#{options}).insertTo('#{id}','after').assignTo('#{id}');"
+  end
+  
+  
+  
+###################################################################################
+#
+# The ActiveView native form-builder extensions
+#
+###################################################################################
+  
+  module FormBuilderMethods
+    def calendar_field(name, options={})
+      @template.calendar_field(@object_name, name, objectify_options(options))
+    end
+    
+    def autocomplete_field(name, options={})
+      @template.autocomplete_field(@object_name, name, objectify_options(options))
+    end
+    
+    def slider(name, options={})
+      @template.slider(@object_name, name, objectify_options(options))
+    end
+    
+    def rater(name, options={})
+      @template.rater(@object_name, name, objectify_options(options))
+    end
+  end
+  
+  module InstanceTagMethods
+    def to_calendar_field_tag(options)
+      options = options.stringify_keys
+      
+      # formatting the date/time value if the format is specified
+      if !options["value"] && options["data-calendar-options"]
+        format = options["data-calendar-options"].scan(/format:('|")(.+?)\1/)
+        time = value_before_type_cast(object)
+        if time && time.respond_to?(:to_time) && format.size == 1
+          options["value"] = time.to_time.strftime(format[0][1])
+        end
+      end
+      
+      to_input_field_tag('text', options)
+    end
+    
+    def to_autocomplete_field_tag(options)
+      to_input_field_tag('text', options)
+    end
+    
+    def to_slider_tag(options)
+      to_input_field_tag('hidden', options)
+    end
+    
+    def to_rater_tag(options)
+      to_input_field_tag('hidden', options)
+    end
+  end
+  
+  def self.included(base)
+    ActionView::Helpers::FormBuilder.instance_eval{ include FormBuilderMethods }
+    ActionView::Helpers::InstanceTag.instance_eval{ include InstanceTagMethods }
+  end
+  
+end

data/lib/right_rails/helpers/misc.rb

@@ -0,0 +1,164 @@
+#
+# Misc view helpers for RightJS
+#
+module RightRails::Helpers::Misc
+  #
+  # Just a simple flashes generator, might be replaced in the application
+  #
+  def flashes
+    content_tag(:div, flash.collect{ |key, text|
+      content_tag(:div, text, :class => key)
+    }.sort, :id => :flashes, :style => (flash.empty? ? 'display: none' : nil))
+  end
+  
+  
+  #
+  # the autocompletion list result
+  #
+  # USAGE:
+  #   it might work in several ways
+  #
+  #   autocomplete_result(list_of_strings)
+  #   autocomplete_result(list_of_strings, :highlight => 'search')
+  #   autocomplete_result(list_of_strings, :highlight => 'search', :escape => false)
+  #
+  #   autocomplete_result(list_of_objects, method)
+  #   autocomplete_result(list_of_objects, method, :highlight => 'search')
+  #
+  def autocomplete_result(entries, *args)
+    return if entries.empty?
+    
+    options   = args.last.is_a?(Hash) ? args.pop : {}
+    highlight = options[:highlight]
+    escape    = options[:escape].nil? ? true : options[:escape]
+    field     = args.first
+    
+    content_tag :ul, entries.collect{ |entry|
+      entry = entry.send(field) if field
+      content_tag :li, highlight ? highlight(entry, highlight) : escape ? h(entry) : entry
+    }
+  end
+  
+  
+  #
+  # Generates a link that whil load the refered address in a lightbox
+  #
+  # USAGE:
+  #   Same as the #link_to method, plus you might specify the :roadtrip argument
+  #   to make it a link to a lightbox roadtrip
+  #
+  #   <%= link_to_lightbox image_tag('/image.thmb'), '/image.full', :roadtrip => true %>
+  #
+  def link_to_lightbox(name, url={}, html_options=nil, &block)
+    rightjs_include_module 'lightbox'
+    
+    html_options ||= {}
+    html_options[:rel] = 'lightbox'
+    html_options[:rel] << "[roadtrip]" if html_options.delete(:roadtrip)
+    
+    link_to name, url, html_options, &block
+  end
+  
+  #
+  # Tabs container generator
+  #
+  # USAGE:
+  #
+  #   <% tabs do %>
+  #     <% tab "Tab 1", :id => :my-tab-1 do %>
+  #       content for tab 1
+  #     <% end -%>
+  #     <% tab "Tab 2", :url => tab2_path %>
+  #   <% end -%>
+  #
+  #  You also can use the :type option with :carousel or :harmonica value
+  #  and you can pass along any standard Tabs unit options along with it
+  #
+  #   <% tabs :type => :carousel, :url => '/tabs/%{id}', :cache => true do %>
+  #      <% tab image_tag(image1.thumb_url), :id => image1.id %>
+  #      <% tab image_tag(image2.thumb_url), :id => image2.id %>
+  #
+  def tabs(options={}, &block)
+    rightjs_include_module 'tabs'
+    @__tabs = []
+    yield()
+    
+    options.stringify_keys!
+    
+    tabs_type = options.delete('type')
+    options['id'] = options.delete('id') || "tabs-#{rand.to_s.split('.').last}"
+    
+    # checking for the carousel class
+    if tabs_type == :carousel
+      options['class'] ||= ''
+      options['class'] << (options['class'] == '' ? '' : ' ') + 'right-tabs-carousel'
+    end
+    
+    tabs_options = rightjs_unit_options(options, TABS_OPTION_KEYS)
+    options['data-tabs-options'] = tabs_options unless tabs_options == '{}'
+    
+    # extracting the tab id prefix option
+    tab_id_prefix = tabs_options.scan(/idPrefix:('|")(.+?)\1/)
+    tab_id_prefix = tab_id_prefix.size == 1 ? tab_id_prefix[0][1] : ''
+    
+    # simple tabs and carousels generator
+    content = if tabs_type != :harmonica
+      content_tag(:ul,
+        # tabs list
+        content_tag(:ul,
+          @__tabs.collect{ |tab|
+            content_tag(:li, content_tag(:a, tab[:title],
+              :href => tab[:options][:id] ? "##{tab[:options][:id]}" : tab[:options][:url]
+            ))
+          }.join("\n")
+        ) + "\n"+
+        
+        # contents list
+        @__tabs.collect{|tab|
+          tab[:content] ? content_tag(:li, tab[:content], :id => "#{tab_id_prefix}#{tab[:options][:id]}") + "\n" : ''
+        }.join(""),
+        options
+      )
+    else
+    # the harmonicas generator
+      content_tag(:dl,
+        @__tabs.collect{ |tab|
+          content_tag(:dt, content_tag(:a, tab[:title],
+            :href => tab[:options][:id] ? "##{tab[:options][:id]}" : tab[:options][:url]
+          )) + "\n" +
+          content_tag(:dd, tab[:content] || '', :id => tab[:options][:id] ? "#{tab_id_prefix}#{tab[:options][:id]}" : nil)
+        }.join("\n"),
+        options
+      )
+      
+    end
+    
+    concat(content + "\n" + javascript_tag("new Tabs('#{options['id']}');"))
+  end
+  
+  def tab(title, options={}, &block)
+    options[:id] = "tab-#{rand.to_s.split('.').last}" if !options[:id] && !options[:url]
+    
+    @__tabs << {
+      :title   => title,
+      :options => options,
+      :content => block_given? ? capture(&block) : nil
+    }
+  end
+  
+  TABS_OPTION_KEYS = %w{
+    idPrefix
+    resizeFx
+    resizeDuration
+    scrollTabs
+    scrollDuration
+    selected
+    disabled
+    closable
+    url
+    cache
+    Xhr
+    Cookie
+  }
+  
+end

data/lib/right_rails/helpers/rails.rb

@@ -0,0 +1,166 @@
+#
+# This module contains the ruby-on-rails native (Prototype) helper replacements
+#
+module RightRails::Helpers::Rails
+  #
+  # Replacing the prototype's javascript generator with our own javascript generator
+  # so that the #link_to_function method was working properly
+  #
+  def update_page(&block)
+    rjs(&block)
+  end
+  
+  def remote_function(options)
+    cmd = build_xhr_request(options)
+    
+    cmd =  "#{options[:before]};#{cmd}" if options[:before]
+    cmd << ";#{options[:after]}"        if options[:after]
+    
+    cmd = "if(#{options[:condition]}){#{cmd}}" if options[:condition]
+    cmd = "if(confirm('#{escape_javascript(options[:confirm])}')){#{cmd}}" if options[:confirm]
+    
+    cmd
+  end
+  
+  def submit_to_remote(name, value, options = {})
+    options[:submit] ||= '$(this.form)'
+
+    html_options = options.delete(:html) || {}
+    html_options[:name] = name
+
+    button_to_remote(value, options, html_options)
+  end
+  
+  def periodically_call_remote(options={})
+    frequency = options[:frequency] || 10 # every ten seconds by default
+    code = "function(){#{remote_function(options)}}.periodical(#{frequency * 1000})"
+    javascript_tag(code)
+  end
+  
+  # stubbing the draggables generator to make our autoscripts stuff working
+  def draggable_element_js(*args)
+    rightjs_include_module 'dnd'
+    
+    super *args
+  end
+  
+  # stubbing the droppables generator
+  def drop_receiving_element_js(*args)
+    rightjs_include_module 'dnd'
+    
+    super(*args).gsub!('Droppables.add', 'new Droppable'
+      ).gsub!('element.id', 'draggable.element.id'
+      ).gsub!('(element)', '(draggable)')
+  end
+  
+  # catching the sortables generator
+  def sortable_element_js(id, options={})
+    rightjs_include_module 'dnd', 'sortable'
+    
+    script = "new Sortable('#{id}'"
+    
+    # processing the options
+    options[:url] = escape_javascript(url_for(options[:url])) if options[:url]
+    s_options = rightjs_unit_options(options, SORTABLE_OPTION_KEYS)
+    script << ",#{s_options}" unless s_options == '{}'
+    
+    script << ")"
+  end
+  
+protected
+
+  SORTABLE_OPTION_KEYS = %w{
+    url
+    direction
+    tags
+    method
+    idParam
+    posParam
+    parseId
+  }
+
+  XHR_OPTION_KEYS = %w{
+    method
+    encoding
+    async
+    evalScripts
+    evalResponse
+    evalJSON
+    secureJSON
+    urlEncoded
+    spinner
+    spinnerFx
+    params
+  }
+
+  # builds the xhr request string
+  def build_xhr_request(options)
+    xhr = options[:submit] ? "new Xhr(" : "Xhr.load("
+    
+    # assigning the url address
+    url = options[:url]
+    url = url.merge(:escape => false) if url.is_a?(Hash)
+    xhr << "'#{escape_javascript(url_for(url))}'"
+    
+    # building the options
+    xhr_options = { :onSuccess => '',  :onFailure => '', :onComplete => '' }
+    
+    # grabbing the standard XHR options
+    options.each do |key, value|
+      if XHR_OPTION_KEYS.include?(key.to_s)
+        xhr_options[key] = case value.class.name.to_sym
+          when :NilClass then 'null'
+          when :Symbol   then "#{value}"
+          when :String   then "'#{value}'"
+          else                value.inspect
+        end
+      end
+    end
+    
+    # checking the parameters options
+    xhr_options[:params] = options[:with]        if options[:with]
+    
+    # checking the callbacks
+    xhr_options[:onSuccess]  = "#{options[:success]};"  if options[:success]
+    xhr_options[:onFailure]  = "#{options[:failure]};"  if options[:failure]
+    xhr_options[:onComplete] = "#{options[:complete]};" if options[:complete]
+    
+    # checking the update option
+    if options[:update]
+      template = options[:position] ? "$('%s').insert(this.text,'%s')" : "$('%s').update(this.text)%s"
+      
+      if options[:update].is_a?(Hash)
+        xhr_options[:onSuccess]  << template % [options[:update][:success], options[:position]] if options[:update][:success]
+        xhr_options[:onFailure]  << template % [options[:update][:failure], options[:position]] if options[:update][:failure]
+      else
+        xhr_options[:onComplete] << template % [options[:update], options[:position]]
+      end
+    end
+    
+    # converting the callbacks
+    [:onSuccess, :onFailure, :onComplete].each do |key|
+      if xhr_options[key] == '' then xhr_options.delete key
+      else xhr_options[key] = "function(request){#{xhr_options[key]}}"
+      end
+    end
+    
+    # ebbedding the xhr options
+    pairs = xhr_options.collect do |key, value|
+      if value == '' then nil
+      else
+        "#{key}:#{value}"
+      end
+    end.compact.sort
+    
+    xhr << ",{#{pairs.join(',')}}" unless pairs.empty?
+    
+    xhr << ')'
+    
+    # forms sending adjustements
+    xhr << ".send(#{options[:submit]})" if options[:submit]
+    xhr.gsub! /^.+?,/, '$(this).send('  if options[:form]
+    
+    xhr
+  end
+  
+end

data/lib/right_rails/helpers.rb

@@ -0,0 +1,5 @@
+#
+# Just a namespace for the helpers
+#
+module RightRails::Helpers
+end