bivouac 0.0.6 → 0.0.7

data/examples/bivouac_sample/public/stylesheets/autocomplete.css

@@ -0,0 +1,22 @@
+div.autocomplete {
+  position:absolute;
+  width:250px;
+  background-color:white;
+  border:1px solid #888;
+  margin:0px;
+  padding:0px;
+}
+div.autocomplete ul {
+  list-style-type:none;
+  margin:0px;
+  padding:0px;
+}
+div.autocomplete ul li.selected { background-color: #ffb;}
+div.autocomplete ul li {
+  list-style-type:none;
+  display:block;
+  margin:0;
+  padding:2px;
+  height:32px;
+  cursor:pointer;
+}

data/examples/bivouac_sample/public/stylesheets/coderay.css

@@ -0,0 +1,104 @@
+.CodeRay {
+  background-color: #f8f8f8;
+  border: 1px solid silver;
+  font-family: 'Courier New', 'Terminal', monospace;
+  color: #100;
+}
+.CodeRay pre { margin: 0px }
+
+div.CodeRay { }
+
+span.CodeRay { white-space: pre; border: 0px; padding: 2px }
+
+table.CodeRay { border-collapse: collapse; width: 100%; padding: 2px }
+table.CodeRay td { padding: 2px 4px; vertical-align: top }
+
+.CodeRay .line_numbers, .CodeRay .no {
+  background-color: #def;
+  color: gray;
+  text-align: right;
+}
+.CodeRay .line_numbers tt { font-weight: bold }
+.CodeRay .no { padding: 0px 4px }
+.CodeRay .code { width: 100% }
+
+ol.CodeRay { font-size: 10pt }
+ol.CodeRay li { white-space: pre }
+
+.CodeRay .code pre { overflow: auto }
+
+.CodeRay .af { color:#00C }
+.CodeRay .an { color:#007 }
+.CodeRay .av { color:#700 }
+.CodeRay .aw { color:#C00 }
+.CodeRay .bi { color:#509; font-weight:bold }
+.CodeRay .c  { color:#888 }
+
+.CodeRay .ch { color:#04D }
+.CodeRay .ch .k { color:#04D }
+.CodeRay .ch .dl { color:#039 }
+
+.CodeRay .cl { color:#B06; font-weight:bold }
+.CodeRay .co { color:#036; font-weight:bold }
+.CodeRay .cr { color:#0A0 }
+.CodeRay .cv { color:#369 }
+.CodeRay .df { color:#099; font-weight:bold }
+.CodeRay .di { color:#088; font-weight:bold }
+.CodeRay .dl { color:black }
+.CodeRay .do { color:#970 }
+.CodeRay .ds { color:#D42; font-weight:bold }
+.CodeRay .e  { color:#666; font-weight:bold }
+.CodeRay .en { color:#800; font-weight:bold }
+.CodeRay .er { color:#F00; background-color:#FAA }
+.CodeRay .ex { color:#F00; font-weight:bold }
+.CodeRay .fl { color:#60E; font-weight:bold }
+.CodeRay .fu { color:#06B; font-weight:bold }
+.CodeRay .gv { color:#d70; font-weight:bold }
+.CodeRay .hx { color:#058; font-weight:bold }
+.CodeRay .i  { color:#00D; font-weight:bold }
+.CodeRay .ic { color:#B44; font-weight:bold }
+
+.CodeRay .il { background: #eee }
+.CodeRay .il .il { background: #ddd }
+.CodeRay .il .il .il { background: #ccc }
+.CodeRay .il .idl { font-weight: bold; color: #888 }
+
+.CodeRay .in { color:#B2B; font-weight:bold }
+.CodeRay .iv { color:#33B }
+.CodeRay .la { color:#970; font-weight:bold }
+.CodeRay .lv { color:#963 }
+.CodeRay .oc { color:#40E; font-weight:bold }
+.CodeRay .on { color:#000; font-weight:bold }
+.CodeRay .op { }
+.CodeRay .pc { color:#038; font-weight:bold }
+.CodeRay .pd { color:#369; font-weight:bold }
+.CodeRay .pp { color:#579 }
+.CodeRay .pt { color:#339; font-weight:bold }
+.CodeRay .r  { color:#080; font-weight:bold }
+
+.CodeRay .rx { background-color:#fff0ff }
+.CodeRay .rx .k { color:#808 }
+.CodeRay .rx .dl { color:#404 }
+.CodeRay .rx .mod { color:#C2C }
+.CodeRay .rx .fu  { color:#404; font-weight: bold }
+
+.CodeRay .s  { background-color:#fff0f0 }
+.CodeRay .s  .s { background-color:#ffe0e0 }
+.CodeRay .s  .s  .s { background-color:#ffd0d0 }
+.CodeRay .s  .k { color:#D20 }
+.CodeRay .s  .dl { color:#710 }
+
+.CodeRay .sh { background-color:#f0fff0 }
+.CodeRay .sh .k { color:#2B2 }
+.CodeRay .sh .dl { color:#161 }
+
+.CodeRay .sy { color:#A60 }
+.CodeRay .sy .k { color:#A60 }
+.CodeRay .sy .dl { color:#630 }
+
+.CodeRay .ta { color:#070 }
+.CodeRay .tf { color:#070; font-weight:bold }
+.CodeRay .ts { color:#D70; font-weight:bold }
+.CodeRay .ty { color:#339; font-weight:bold }
+.CodeRay .v  { color:#036 }
+.CodeRay .xt { color:#444 }

data/examples/bivouac_sample/script/generate

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'bivouac/commands/generate'

data/examples/bivouac_sample/script/server

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+app = File.dirname(__FILE__) + "/../app/bivouac_sample.rb"
+
+system "ruby #{app} #{ARGV.join(' ')}"

data/lib/bivouac/helpers/view/goh/base.rb

@@ -0,0 +1,16 @@
+# bivouac/helpers/view/base
+
+module BivouacHelpers
+  module BaseView
+    #   render( :hello, :object => @my_object )
+    # is equivalent to
+    #   @object = @my_object
+    #   hello( )
+    def render( partial, options = {} )
+      options.each do |k, v|
+        self.instance_variable_set( "@#{k.to_s}".to_sym, v )
+      end
+      self.send( partial.to_sym )
+    end
+  end
+end

data/lib/bivouac/helpers/view/goh/form.rb

@@ -0,0 +1,170 @@
+# bivouac/helpers/view/form
+
+module BivouacHelpers
+  module FormView
+    # Adds AJAX autocomplete functionality to the text input field with the DOM ID specified by +field_id+.
+    def auto_complete_field( field_id, options = nil )
+      if options.has_key?( :indicator ) 
+        data = options[:indicator]
+        options[:indicator] = "indicator_#{field_id}"
+        span( data, :id => options[:indicator], :style => "display: none" )
+      end
+      
+      choises_id = "choises_#{field_id}"
+      div( :id => choises_id, :class => "autocomplete" ) do; end
+      url = options.delete( :url )
+      javascript_tag "new Ajax.Autocompleter( '#{field_id}', '#{choises_id}', '#{url}', #{options_for_javascript(options)} );"
+    end
+    
+    # Autocomplete options :
+    # 
+    # +:url+:                 URL to call for autocompletion results
+    # +:tokens+:              
+    # +:frequency+:
+    # +:minChars+:
+    # +:indicator+:           When sending the Ajax request Autocompleter shows this
+    # +:updateElement+:       Hook for a custom function called after the element has been updated (i.e. when the user has selected an entry). 
+    # +:afterUpdateElement+:  Hook for a custom function called after the element has been updated (i.e. when the user has selected an entry).
+    # +:callback+:            This function is called just before the Request is actually made, allowing you to modify the querystring that is sent to the server.
+    # +:parameters+:          If you need to send any additional parameters through your search form, add them here, in the usual {field: 'value',another: 'value'} or 'field=value&another=value' manner.
+    def text_field(field_name, value = "", options = {})
+      autocomplete_options = nil
+      
+      if options.has_key?( :autocomplete )
+        unless ["on", "off"].include?( options[:autocomplete] )
+          autocomplete_options = Hash.new( )
+          autocomplete_options[:url] = options.delete( :autocomplete )
+          # options[:autocomplete] = "off"
+        end
+      end
+
+          
+      [:tokens, :frequency, :minChars, :indicator, :updateElement, :afterUpdateElement, :callback, :parameters].each do |op|
+        if options.has_key?( op )
+          if autocomplete_options.nil?
+            options.delete( op )
+          else
+            autocomplete_options[op] = options.delete( op )
+          end
+        end
+      end
+      
+      options = { :id => "default_#{Time.now.to_i}", :type => "text", :name => field_name, :value => value }.merge( options )
+      input( options )
+      auto_complete_field( options[:id], autocomplete_options ) unless autocomplete_options.nil?      
+    end
+    
+    # Returns a button that'll trigger a JavaScript function using the onclick 
+    # handler.
+    # 
+    # The function argument can be omitted in favor of an update_page block, 
+    # which evaluates to a string when the template is rendered (instead of 
+    # making an Ajax request first).
+    def button_to_function(name, *args, &block)
+      html_options = args.last.is_a?(Hash) ? args.pop : {}
+      function = args[0] || ''
+    
+      function = update_page(&block) if block_given?
+      
+      input( html_options.merge({ 
+        :type => "button", :value => name, 
+        :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};" 
+      }))
+    end
+    
+    # Returns a button input tag that will submit form using XMLHttpRequest 
+    # in the background instead of regular reloading POST arrangement. 
+    # <tt>options</tt> argument is the same as in <tt>form_remote_tag</tt>.
+    def submit_to_remote(name, value, options = {})
+      options[:with] ||= 'Form.serialize(this.form)'
+
+      options[:html] ||= {}
+      options[:html][:type] = 'button'
+      options[:html][:onclick] = "#{remote_function(options)}; return false;"
+      options[:html][:name] = name
+      options[:html][:value] = value
+
+      input options[:html]
+    end
+    
+    # Starts a form tag that points the action to an url. The method for the form defaults to POST.
+    #
+    # Examples:
+    # * <tt>form_tag('/posts') => <form action="/posts" method="post"></tt>
+    # * <tt>form_tag('/upload', :multipart => true) => <form action="/upload" method="post" enctype="multipart/form-data"></tt>
+    # 
+    # Example:
+    #   form_tag R(Post) do
+    #     div do; input( :type => 'submit', :name => 'submit' :value => 'Save' ); end
+    #   end
+    #
+    # Will output:
+    #   <form action="/posts" method="post"><input type="submit" name="submit" value="Save" /></div></form>
+    #
+    # Options:
+    # * <tt>:multipart</tt> - If set to true, the enctype is set to "multipart/form-data".
+    # * <tt>:method</tt>    - The method to use when submitting the form, usually either "get" or "post".
+    #                         If "put", "delete", or another verb is used, a hidden input with name _method 
+    #                         is added to simulate the verb over post.
+    def form_tag(url, options = {}, &block)
+      options[:enctype] = "multipart/form-data" if options.delete(:multipart)
+      options[:action]  = url
+
+      method_tag = false
+      
+      case method = options.delete(:method).to_s
+        when /^get$/i # must be case-insentive, but can't use downcase as might be nil
+          options[:method] = "get"
+        when /^post$/i, "", nil
+          options[:method] = "post"
+        else
+          options[:method] = "post"
+          method_tag = true
+      end
+      
+      if block_given?
+        form( options ) do
+          yield( )
+          input( :type => "hidden", :name => "_method", :value => method ) if method_tag
+        end
+      else
+        form( options ) do; end
+      end
+    end
+    
+    # Returns a form tag that will submit using XMLHttpRequest in the 
+    # background instead of the regular reloading POST arrangement. Even 
+    # though it's using JavaScript to serialize the form elements, the form
+    # submission will work just like a regular submission as viewed by the
+    # receiving side. The options for specifying the target with :url and 
+    # defining callbacks is the same as
+    # link_to_remote.
+    #
+    # A "fall-through" target for browsers that doesn't do JavaScript can be
+    # specified with the :action/:method options on :html.
+    #
+    # Example:
+    #   form_remote_tag :html => { :url => R(SomePlace) }
+    #
+    # The Hash passed to the :html key is equivalent to the options (2nd) 
+    # argument in the form_tag method.
+    #
+    # By default the fall-through action is the same as the one specified in 
+    # the :url (and the default method is :post).
+    #
+    # form_remote_tag takes a block, like form_tag:
+    #   form_remote_tag :url => '/posts' do
+    #     div do; input( :type => 'submit', :name => 'submit' :value => 'Save' ); end
+    #   end
+    def form_remote_tag(options = {}, &block)
+      options[:form] = true
+
+      options[:html] ||= {}
+      options[:html][:onsubmit] = 
+        (options[:html][:onsubmit] ? options[:html][:onsubmit] + "; " : "") + 
+        "#{remote_function(options)}; return false;"
+
+      form_tag( options[:html].delete(:url), options[:html], &block )
+    end
+  end
+end

data/lib/bivouac/helpers/view/goh/html.rb

@@ -0,0 +1,138 @@
+# bivouac/helpers/view/html
+
+module BivouacHelpers
+  module HtmlView
+    @@javascript_default_sources = %w{prototype.js scriptaculous.js tooltip.js}
+    
+    # Returns a stylesheet link tag for the sources specified as arguments. If
+    # you don't specify an extension, .css will be appended automatically.
+    # You can modify the link attributes by passing a hash as the last argument.
+    #
+    #   stylesheet_link_tag "style" # =>
+    #     <link href="/public/stylesheets/style.css" media="screen" rel="Stylesheet" type="text/css" />
+    #
+    #   stylesheet_link_tag "style", :media => "all" # =>
+    #     <link href="/public/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
+    #
+    #   stylesheet_link_tag "random.styles", "/css/stylish" # =>
+    #     <link href="/public/stylesheets/random.styles" media="screen" rel="Stylesheet" type="text/css" />
+    #     <link href="/public/stylesheets/css/stylish.css" media="screen" rel="Stylesheet" type="text/css" />
+    def stylesheet_link_tag( *data )
+      options = data.last.is_a?(Hash) ? data.pop : { }
+      options[:rel]   = "Stylesheet"
+      options[:type]  = "text/css"
+      data.collect do |file|
+        file << ".css" if File.extname(file).blank?
+        options[:href] = "/public/stylesheets/#{file}"
+        link( options )
+      end
+    end
+    
+    # Returns an html script tag for each of the +sources+ provided. You
+    # can pass in the filename (.js extension is optional) of javascript files
+    # that exist in your public/javascripts directory for inclusion into the
+    # current page. To include the Prototype and Scriptaculous javascript 
+    # libraries in your application, pass :defaults as the source.
+    #
+    #   javascript_include_tag "xmlhr" # =>
+    #     <script type="text/javascript" src="/public/javascripts/xmlhr.js"></script>
+    #
+    #   javascript_include_tag "common.javascript", "elsewhere/cools" # =>
+    #     <script type="text/javascript" src="/public/javascripts/common.javascript"></script>
+    #     <script type="text/javascript" src="/public/javascripts/elsewhere/cools.js"></script>
+    def javascript_include_tag( *sources )
+      options = sources.last.is_a?(Hash) ? sources.pop : { }
+      options[:type] = "text/javascript"
+      
+      if sources.include?(:defaults) 
+        sources = sources[0..(sources.index(:defaults))] + 
+          @@javascript_default_sources.dup + 
+          sources[(sources.index(:defaults) + 1)..sources.length]
+      
+        sources.delete(:defaults) 
+      end
+      sources.collect do |file|
+        file = file.to_s
+        file << ".js" if File.extname(file).blank?
+        options[:src] = "/public/javascripts/#{file}"
+        script( options ) {}
+      end
+    end
+    
+    # Returns an html image tag for the +source+. The +source+ must be a file 
+    # that exists in your public images directory (public/images). 
+    # You can add html attributes using the +options+. If no alt text is given, 
+    # the file name part of the +source+ is used (capitalized and without the 
+    # extension)
+    #
+    #  image_tag("icon.png")  # =>
+    #    <img src="/public/images/icon.png" alt="Icon" />
+    # 
+    #  image_tag("icon.png", :alt => "Edit Entry")  # =>
+    #    <img src="/public/images/icon.png" alt="Edit Entry" />
+    def image_tag( source, options = {} )
+      options[:src] = "/public/images/#{source}"
+      options[:alt] ||= File.basename(options[:src], '.*').split('.').first.capitalize
+      
+      img( options )
+    end
+    
+    # Creates a link tag of the given +name+ using +address+ has the href for 
+    # the link
+    #
+    # The +options+ will accept a hash of html attributes for the link tag.
+    # It also accepts 2 modifiers that specialize the link behavior. 
+    # 
+    # * <tt>:confirm => 'question?'</tt>: This will add a JavaScript confirm 
+    #   prompt with the question specified. If the user accepts, the link is 
+    #   processed normally, otherwise no action is taken.
+    # * <tt>:popup => true || array of window options</tt>: This will force the
+    #   link to open in a popup window. By passing true, a default browser window
+    #   will be opened with the URL. You can also specify an array of options 
+    #   that are passed-thru to JavaScripts window.open method.
+    #   
+    # You can mix and match the +options+.
+    #   
+    #   link_to "Documentation", "http://camping.rubyforge.org/", :confirm => "Are you sure?"
+    #   link_to "Help", R( Help ), :popup => true
+    #   link_to image_tag( "thumb.png" ), "/public/images/fullsize.png", :popup => ['My house', 'height=300,width=600']
+    def link_to(name, address, options = {})
+      options = javascript_options( options )
+      options[:href] = address
+      
+      a( options ) do; name; end
+    end
+    
+    private
+    
+    def javascript_options( options )
+      unless options.is_a?(Hash)
+        raise ArgumentError, "options must be a Hash!"
+      end
+      
+      confirm, popup = options.delete(:confirm), options.delete(:popup)
+      options["onclick"] = case
+      when confirm && popup
+        "if (#{confirm_javascript_function(confirm)}) { #{popup_javascript_function(popup)} };return false;"
+      when confirm
+        "return #{confirm_javascript_function(confirm)};"
+      when popup
+        popup_javascript_function(popup) + 'return false;'
+      else
+        options["onclick"]        
+      end
+      
+      return options
+    end
+    
+    # From Rails !!!!
+    def confirm_javascript_function(confirm)
+      "confirm('#{confirm}')"
+    end
+
+    # From Rails !!!!
+    def popup_javascript_function(popup)
+      popup.is_a?(Array) ? "window.open(this.href,'#{popup.first}','#{popup.last}');" : "window.open(this.href);"
+    end
+  end
+end