sproutit-sproutcore 1.0.0.20090407205609

data/lib/sproutcore/helpers/static_helper.rb

@@ -0,0 +1,268 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+# The helper methods here are used to build the main index template file for
+# a SproutCore application.  See the commented index.rhtml in the plugin for
+# example usage.
+#
+module SC
+  module Helpers
+
+    module StaticHelper
+
+      # This method will return the HTML to link to all the stylesheets
+      # required by the named bundle.  If you pass no options, the current
+      # client will be used.
+      #
+      # bundle_name = the name of the bundle to render or nil to use the
+      # current :language => the language to render. defaults to current
+      # language
+      #
+      def stylesheets_for_client(target_name = nil, opts = nil)
+
+        # normalize params
+        if target_name.kind_of?(Hash) && opts.nil?
+          opts = target_name
+          target_name = nil
+        end
+        opts = {} if opts.nil?
+
+        # process options
+        include_method = opts[:include_method] ||= :link
+        t = target_name ? target.target_for(target_name) : target
+
+        # collect urls from entries
+        urls = []
+        combine_stylesheets = t.config.combine_stylesheets
+        combined_entries(t, opts, 'stylesheet.css', 'stylesheet-packed.css') do |cur_target, cur_entry|
+          # include either the entry URL or URL of ordered entries
+          # depending on setup
+          if combine_stylesheets
+            urls << cur_entry.cacheable_url
+          else
+            urls += cur_entry.ordered_entries.map { |e| e.cacheable_url }
+          end
+          
+          # add any stylesheet libs from the target
+          urls += (cur_target.config.stylesheet_libs || [])
+        end
+          
+        # Convert to HTML and return
+        urls = urls.map do |url|
+          if include_method == :import
+            %(  @import url('#{url}');)
+          else
+            %(  <link href="#{url}" rel="stylesheet" type="text/css" />)
+          end
+        end
+        
+        # if include style is @import, surround with style tags
+        if include_method == :import
+          %(<style type="text/css">\n#{urls * "\n"}</style>)
+        else
+          urls.join("\n")
+        end
+      end
+
+      # This method will return the HTML to link to all the javascripts
+      # required by the client.  If you pass no options, the current client
+      # will be used.
+      #
+      # client_name = the name of the client to render or nil to use the
+      # current :language => the language to render. defaults to @language.
+      #
+      def javascripts_for_client(target_name = nil, opts = {})
+
+        # normalize params
+        if target_name.kind_of?(Hash) && opts.nil?
+          opts = target_name
+          target_name = nil
+        end
+        opts = {} if opts.nil?
+
+        # process options
+        t = target_name ? target.target_for(target_name) : target
+
+        # collect urls from entries
+        urls = []
+        combine_javascript = t.config.combine_javascript
+        combined_entries(t, opts, 'javascript.js', 'javascript-packed.js') do |cur_target, cur_entry|
+          
+          # include either the entry URL or URL of ordered entries
+          # depending on setup
+          if combine_javascript
+            urls << cur_entry.cacheable_url
+          else
+            urls += cur_entry.ordered_entries.map { |e| e.cacheable_url }
+          end
+          
+          # add any stylesheet libs from the target
+          urls += (cur_target.config.javascript_libs || [])
+        end
+
+        # Convert to HTML and return
+        urls = urls.map do |url|
+          %(  <script type="text/javascript" src="#{url}"></script>)
+        end
+
+        # Add preferred language definition...
+        urls << %(<script type="text/javascript">String.preferredLanguage = "#{language}";</script>)
+
+        urls.join("\n")
+      end
+
+      # Returns the URL for the named resource
+      def sc_static(resource_name, opts = {})
+        
+        # determine which manifest to search.  if a language is explicitly
+        # specified, lookup manifest for that language.  otherwise use 
+        # current manifest.
+        m = self.manifest 
+        if opts[:language]
+          m = target.manifest_for(:language => opts[:language]).build! 
+        end
+        
+        entry = m.find_entry(resource_name)
+        entry.nil? ? '' : entry.cacheable_url
+      end
+      alias_method :static_url, :sc_static
+
+      # Allows you to specify HTML resource this html template should be
+      # merged into.   Optionally also specify the layout file to use when
+      # building this resource.
+      #
+      # == Example
+      #   <% sc_resource :foo, :layout => 'sproutcore:lib/index.html' %>
+      #
+      def sc_resource(resource_name, opts = nil)
+        opts = opts.nil? ? (resource_name.kind_of?(Hash) ? resource_name : {}) : opts
+        @layout = opts[:layout] if opts[:layout]
+        return ''
+      end
+        
+      # Localizes the passed string, using the optional passed options.
+      def loc(string, opts = {})
+        string = string.nil? ? '' : string.to_s
+        language = opts[:language] || self.language
+        return strings_hash(language)[string] || string
+      end
+      
+      # Returns the CSS class name dictated by the current theme.  You can
+      # also pass an optional default value to use if no theme is specified
+      # in the config.  The value returned here will use either the 
+      # theme_name set in the target's config or the theme_name set by the
+      # theme framework, if set.
+      def theme_name(opts ={})
+        ret = opts[:default] || 'sc-theme'
+        if target.config.theme_name
+          ret = target.config.theme_name
+        elsif target.config.theme
+          if theme_target = target.target_for(target.config.theme)
+            ret = theme_target.config.theme_name || ret
+          end
+        end
+        return ret
+      end
+       
+      def title
+        target.config.title || target.target_name.to_s.sub(/^\//,'').gsub(/[-_\/]/,' ').split(' ').map { |x| x.capitalize }.join(' ')
+      end
+      
+      private 
+
+      # Returns a merged strings hash from all of the required bundles.  Used
+      # by loc()
+      #
+      # === Params
+      #  for_language:: the language you want the hash for
+      #
+      # === Returns
+      #  params hash
+      #
+      def strings_hash(for_language)
+        ret = (@strings_hashes ||= {})[for_language]
+        return ret unless ret.nil?
+        
+        # Need to generate hash. 
+        
+        # get the default manifest for the current target.  will be used to
+        # select other manifests.
+        m = (for_language == self.language) ? self.manifest : target.manifest_for(:language => for_language)
+        
+        # get all of the targets to merge...
+        ret = {}
+        targets = (target.expand_required_targets + [target])
+        targets.each do |t|
+          # get the manifest for the target
+          cur_manifest = (t == target) ? m : t.manifest_for(m.variation)
+          cur_manifest.build!
+          
+          # ...and find a strings entry, if there is one.
+          strings_entry = cur_manifest.entries(:hidden => true).find { |e| e.entry_type == :strings }
+          next if strings_entry.nil?
+
+          # then load the strings
+          strings_entry.stage!
+          next if !File.exist?(strings_entry.staging_path) 
+          strings_hash = YAML.load(File.read(strings_entry.staging_path)) 
+          next if strings_hash.nil? # could not load...
+
+          # if strings loaded, merge into ret...
+          ret = ret.merge(strings_hash)
+        end
+        
+        # save in cache.
+        @strings_hashes[for_language] = ret
+        return ret # done!
+      end
+
+      # Find all of the combined entries.
+      def combined_entries(t, opts, entry_name, packed_entry_name=nil, &block)
+        
+        # choose manifest variant.  default to current manifest variant 
+        # if no explicit language was passed.
+        v = opts[:language] ? { :language => opts[:language] } : manifest.variation
+        
+        # choose which targets to include packed and unpacked
+        targets = expand_required_targets(t)
+        if t.config.use_packed && packed_entry_name # must pass to activate
+          packed, unpacked = SC::Helpers::PackedOptimizer.optimize(targets)
+          unpacked << t # always use unpacked for main target
+        else
+          packed = []
+          unpacked = targets + [t] # always use unpacked
+        end
+        
+        # deal with packed targets...
+        packed.each do |t|
+          # get the manifest for the target
+          cur_manifest = t.manifest_for(v).build!
+          
+          # get the stylesheet or js entry for it...
+          entry = cur_manifest.entry_for packed_entry_name
+          next if entry.nil? || !entry.composite? # no stylesheet or js
+          
+          yield(t, entry)
+        end
+
+        unpacked.each do |t|
+          # get the manifest for the target
+          cur_manifest = t.manifest_for(v).build!
+
+          # get the stylesheet or js entry for it...
+          entry = cur_manifest.entry_for entry_name
+          next if entry.nil? || !entry.composite? # no stylesheet or js
+          
+          yield(t, entry)
+        end
+      end
+
+      
+    end
+
+  end
+end

data/lib/sproutcore/helpers/tag_helper.rb

@@ -0,0 +1,117 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+require 'cgi'
+require 'erb'
+
+# Borrowed from Rails 2.0.2
+
+module SC
+  module Helpers #:nodoc:
+    # Use these methods to generate HTML tags programmatically when you can't use
+    # a Builder. By default, they output XHTML compliant tags.
+    module TagHelper
+      include ERB::Util
+
+      # Returns an empty HTML tag of type +name+ which by default is XHTML
+      # compliant. Setting +open+ to true will create an open tag compatible
+      # with HTML 4.0 and below. Add HTML attributes by passing an attributes
+      # hash to +options+. For attributes with no value like (disabled and
+      # readonly), give it a value of true in the +options+ hash. You can use
+      # symbols or strings for the attribute names.
+      #
+      #   tag("br")
+      #    # => <br />
+      #   tag("br", nil, true)
+      #    # => <br>
+      #   tag("input", { :type => 'text', :disabled => true })
+      #    # => <input type="text" disabled="disabled" />
+      def tag(name, options = nil, open = false)
+        "<#{name}#{tag_options(options) if options}" + (open ? ">" : " />")
+      end
+
+      # Returns an HTML block tag of type +name+ surrounding the +content+. Add
+      # HTML attributes by passing an attributes hash to +options+. For attributes
+      # with no value like (disabled and readonly), give it a value of true in
+      # the +options+ hash. You can use symbols or strings for the attribute names.
+      #
+      #   content_tag(:p, "Hello world!")
+      #    # => <p>Hello world!</p>
+      #   content_tag(:div, content_tag(:p, "Hello world!"), :class => "strong")
+      #    # => <div class="strong"><p>Hello world!</p></div>
+      #   content_tag("select", options, :multiple => true)
+      #    # => <select multiple="multiple">...options...</select>
+      #
+      # Instead of passing the content as an argument, you can also use a block
+      # in which case, you pass your +options+ as the second parameter.
+      #
+      #   <% content_tag :div, :class => "strong" do -%>
+      #     Hello world!
+      #   <% end -%>
+      #    # => <div class="strong"><p>Hello world!</p></div>
+      def content_tag(name, content_or_options_with_block = nil, options = nil, &block)
+        if block_given?
+          options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
+          content = capture(&block)
+          content_tag = content_tag_string(name, content, options)
+          block_is_within_action_view?(block) ? concat(content_tag, block.binding) : content_tag
+        else
+          content = content_or_options_with_block
+          content_tag_string(name, content, options)
+        end
+      end
+
+      # Returns a CDATA section with the given +content+.  CDATA sections
+      # are used to escape blocks of text containing characters which would
+      # otherwise be recognized as markup. CDATA sections begin with the string
+      # <tt><![CDATA[</tt> and end with (and may not contain) the string <tt>]]></tt>.
+      #
+      #   cdata_section("<hello world>")
+      #    # => <![CDATA[<hello world>]]>
+      def cdata_section(content)
+        "<![CDATA[#{content}]]>"
+      end
+
+      # Returns the escaped +html+ without affecting existing escaped entities.
+      #
+      #   escape_once("1 > 2 &amp; 3")
+      #    # => "1 &lt; 2 &amp; 3"
+      def escape_once(html)
+        fix_double_escape(html_escape(html.to_s))
+      end
+
+      private
+        def content_tag_string(name, content, options)
+          tag_options = options ? tag_options(options) : ""
+          "<#{name}#{tag_options}>#{content}</#{name}>"
+        end
+
+        def tag_options(options)
+          cleaned_options = convert_booleans(options.stringify_keys.reject {|key, value| value.nil?})
+          ' ' + cleaned_options.map {|key, value| %(#{key}="#{escape_once(value)}")}.sort * ' ' unless cleaned_options.empty?
+        end
+
+        def convert_booleans(options)
+          %w( disabled readonly multiple ).each { |a| boolean_attribute(options, a) }
+          options
+        end
+
+        def boolean_attribute(options, attribute)
+          options[attribute] ? options[attribute] = attribute : options.delete(attribute)
+        end
+
+        # Fix double-escaped entities, such as &amp;amp;, &amp;#123;, etc.
+        def fix_double_escape(escaped)
+          escaped.gsub(/&amp;([a-z]+|(#\d+));/i) { "&#{$1};" }
+        end
+
+        def block_is_within_action_view?(block)
+          eval("defined? _erbout", block.binding)
+        end
+    end
+  end
+end

data/lib/sproutcore/helpers/text_helper.rb

@@ -0,0 +1,303 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple, Inc.
+#            portions copyright @2006-2009 Sprout Systems, Inc.
+#            and contributors
+# ===========================================================================
+
+require File.join(SC::LIBPATH, 'sproutcore', 'helpers', 'tag_helper')
+#require 'html/document'
+
+# Borrowed from Rails 2.0.2
+
+module SC
+  module Helpers #:nodoc:
+    # The TextHelper Module provides a set of methods for filtering, formatting
+    # and transforming strings that can reduce the amount of inline Ruby code in
+    # your views. These helper methods extend ActionView making them callable
+    # within your template files as shown in the following example which truncates
+    # the title of each post to 10 characters.
+    #
+    #   <% @posts.each do |post| %>
+    #     # post == 'This is my title'
+    #     Title: <%= truncate(post.title, 10) %>
+    #   <% end %>
+    #    => Title: This is my...
+    module TextHelper
+      # The preferred method of outputting text in your views is to use the
+      # <%= "text" %> eRuby syntax. The regular _puts_ and _print_ methods
+      # do not operate as expected in an eRuby code block. If you absolutely must
+      # output text within a code block, you can use the concat method.
+      #
+      #   <% concat "hello", binding %>
+      # is equivalent to using:
+      #   <%= "hello" %>
+      def concat(string, binding)
+        renderer.concat(string, binding)
+      end
+
+      # Highlights one or more +phrases+ everywhere in +text+ by inserting it into
+      # a +highlighter+ string. The highlighter can be specialized by passing +highlighter+
+      # as a single-quoted string with \1 where the phrase is to be inserted.
+      #
+      #   highlight('You searched for: rails', 'rails')
+      #   # => You searched for: <strong class="highlight">rails</strong>
+      #
+      #   highlight('You searched for: rails', ['for', 'rails'], '<em>\1</em>')
+      #   # => You searched <em>for</em>: <em>rails</em>
+      def highlight(text, phrases, highlighter = '<strong class="highlight">\1</strong>')
+        if text.blank? || phrases.blank?
+          text
+        else
+          match = Array(phrases).map { |p| Regexp.escape(p) }.join('|')
+          text.gsub(/(#{match})/i, highlighter)
+        end
+      end
+
+      # Attempts to pluralize the +singular+ word unless +count+ is 1. If +plural+
+      # is supplied, it will use that when count is > 1, if the ActiveSupport Inflector
+      # is loaded, it will use the Inflector to determine the plural form, otherwise
+      # it will just add an 's' to the +singular+ word.
+      #
+      #   pluralize(1, 'person')  => 1 person
+      #   pluralize(2, 'person')  => 2 people
+      #   pluralize(3, 'person', 'users')  => 3 users
+      def pluralize(count, singular, plural = nil)
+         "#{count || 0} " + if count == 1 || count == '1'
+          singular
+        elsif plural
+          plural
+        else
+          singular.plural
+        end
+      end
+
+      begin
+        unless Object.const_defined?(:RedCloth)
+          gem "RedCloth"
+          require 'redcloth'
+        end
+        
+        # Returns the text with all the Textile codes turned into HTML tags.
+        # <i>This method is only available if RedCloth[http://whytheluckystiff.net/ruby/redcloth/]
+        # is available</i>.
+        def textilize(text)
+          if text.blank?
+            ""
+          else
+            textilized = RedCloth.new(text, [ :hard_breaks ])
+            textilized.hard_breaks = true if textilized.respond_to?("hard_breaks=")
+            textilized.to_html
+          end
+        end
+
+        # Returns the text with all the Textile codes turned into HTML tags,
+        # but without the bounding <p> tag that RedCloth adds.
+        # <i>This method is only available if RedCloth[http://whytheluckystiff.net/ruby/redcloth/]
+        # is available</i>.
+        def textilize_without_paragraph(text)
+          textiled = textilize(text)
+          if textiled[0..2] == "<p>" then textiled = textiled[3..-1] end
+          if textiled[-4..-1] == "</p>" then textiled = textiled[0..-5] end
+          return textiled
+        end
+      rescue LoadError
+        # We can't really help what's not there
+      end
+
+      begin
+        unless Object.const_defined?(:BlueCloth)
+          begin
+            require 'bluecloth'
+          rescue
+            gem 'bluecloth'
+            require 'bluecloth'
+          end
+        end
+
+        # Returns the text with all the Markdown codes turned into HTML tags.
+        # <i>This method is only available if BlueCloth[http://www.deveiate.org/projects/BlueCloth]
+        # is available</i>.
+        def markdown(text)
+          text.blank? ? "" : BlueCloth.new(text).to_html
+        end
+      rescue LoadError
+        # We can't really help what's not there
+      end
+
+      # Returns +text+ transformed into HTML using simple formatting rules.
+      # Two or more consecutive newlines(<tt>\n\n</tt>) are considered as a
+      # paragraph and wrapped in <tt><p></tt> tags. One newline (<tt>\n</tt>) is
+      # considered as a linebreak and a <tt><br /></tt> tag is appended. This
+      # method does not remove the newlines from the +text+.
+      def simple_format(text)
+        content_tag 'p', text.to_s.
+          gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
+          gsub(/\n\n+/, "</p>\n\n<p>").           # 2+ newline  -> paragraph
+          gsub(/([^\n]\n)(?=[^\n])/, '\1<br />')  # 1 newline   -> br
+      end
+
+      # Turns all urls and email addresses into clickable links. The +link+ parameter
+      # will limit what should be linked. You can add html attributes to the links using
+      # +href_options+. Options for +link+ are <tt>:all</tt> (default),
+      # <tt>:email_addresses</tt>, and <tt>:urls</tt>.
+      #
+      #   auto_link("Go to http://www.rubyonrails.org and say hello to david@loudthinking.com") =>
+      #     Go to <a href="http://www.rubyonrails.org">http://www.rubyonrails.org</a> and
+      #     say hello to <a href="mailto:david@loudthinking.com">david@loudthinking.com</a>
+      #
+      # If a block is given, each url and email address is yielded and the
+      # result is used as the link text.
+      #
+      #   auto_link(post.body, :all, :target => '_blank') do |text|
+      #     truncate(text, 15)
+      #   end
+      def auto_link(text, link = :all, href_options = {}, &block)
+        return '' if text.blank?
+        case link
+          when :all             then auto_link_urls(auto_link_email_addresses(text, &block), href_options, &block)
+          when :email_addresses then auto_link_email_addresses(text, &block)
+          when :urls            then auto_link_urls(text, href_options, &block)
+        end
+      end
+
+      # Strips link tags from +text+ leaving just the link label.
+      #
+      #   strip_links('<a href="http://www.rubyonrails.org">Ruby on Rails</a>')
+      #    => Ruby on Rails
+      def strip_links(text)
+        text.gsub(/<a\b.*?>(.*?)<\/a>/mi, '\1')
+      end
+
+      # Creates a Cycle object whose _to_s_ method cycles through elements of an
+      # array every time it is called. This can be used for example, to alternate
+      # classes for table rows:
+      #
+      #   <% @items.each do |item| %>
+      #     <tr class="<%= cycle("even", "odd") -%>">
+      #       <td>item</td>
+      #     </tr>
+      #   <% end %>
+      #
+      # You can use named cycles to allow nesting in loops.  Passing a Hash as
+      # the last parameter with a <tt>:name</tt> key will create a named cycle.
+      # You can manually reset a cycle by calling reset_cycle and passing the
+      # name of the cycle.
+      #
+      #   <% @items.each do |item| %>
+      #     <tr class="<%= cycle("even", "odd", :name => "row_class")
+      #       <td>
+      #         <% item.values.each do |value| %>
+      #           <span style="color:<%= cycle("red", "green", "blue", :name => "colors") -%>">
+      #             value
+      #           </span>
+      #         <% end %>
+      #         <% reset_cycle("colors") %>
+      #       </td>
+      #    </tr>
+      #  <% end %>
+      def cycle(first_value, *values)
+        if (values.last.instance_of? Hash)
+          params = values.pop
+          name = params[:name]
+        else
+          name = "default"
+        end
+        values.unshift(first_value)
+
+        cycle = get_cycle(name)
+        if (cycle.nil? || cycle.values != values)
+          cycle = set_cycle(name, Cycle.new(*values))
+        end
+        return cycle.to_s
+      end
+
+      # Resets a cycle so that it starts from the first element the next time
+      # it is called. Pass in +name+ to reset a named cycle.
+      def reset_cycle(name = "default")
+        cycle = get_cycle(name)
+        cycle.reset unless cycle.nil?
+      end
+
+      class Cycle #:nodoc:
+        attr_reader :values
+
+        def initialize(first_value, *values)
+          @values = values.unshift(first_value)
+          reset
+        end
+
+        def reset
+          @index = 0
+        end
+
+        def to_s
+          value = @values[@index].to_s
+          @index = (@index + 1) % @values.size
+          return value
+        end
+      end
+
+      private
+        # The cycle helpers need to store the cycles in a place that is
+        # guaranteed to be reset every time a page is rendered, so it
+        # uses an instance variable of ActionView::Base.
+        def get_cycle(name)
+          @_cycles = Hash.new unless defined?(@_cycles)
+          return @_cycles[name]
+        end
+
+        def set_cycle(name, cycle_object)
+          @_cycles = Hash.new unless defined?(@_cycles)
+          @_cycles[name] = cycle_object
+        end
+
+        AUTO_LINK_RE = %r{
+                        (                          # leading text
+                          <\w+.*?>|                # leading HTML tag, or
+                          [^=!:'"/]|               # leading punctuation, or
+                          ^                        # beginning of line
+                        )
+                        (
+                          (?:https?://)|           # protocol spec, or
+                          (?:www\.)                # www.*
+                        )
+                        (
+                          [-\w]+                   # subdomain or domain
+                          (?:\.[-\w]+)*            # remaining subdomains or domain
+                          (?::\d+)?                # port
+                          (?:/(?:(?:[~\w\+%-]|(?:[,.;:][^\s$]))+)?)* # path
+                          (?:\?[\w\+%&=.;-]+)?     # query string
+                          (?:\#[\w\-]*)?           # trailing anchor
+                        )
+                        ([[:punct:]]|\s|<|$)       # trailing text
+                       }x unless const_defined?(:AUTO_LINK_RE)
+
+        # Turns all urls into clickable links.  If a block is given, each url
+        # is yielded and the result is used as the link text.
+        def auto_link_urls(text, href_options = {})
+          extra_options = tag_options(href_options.stringify_keys) || ""
+          text.gsub(AUTO_LINK_RE) do
+            all, a, b, c, d = $&, $1, $2, $3, $4
+            if a =~ /<a\s/i # don't replace URL's that are already linked
+              all
+            else
+              text = b + c
+              text = yield(text) if block_given?
+              %(#{a}<a href="#{b=="www."?"http://www.":b}#{c}"#{extra_options}>#{text}</a>#{d})
+            end
+          end
+        end
+
+        # Turns all email addresses into clickable links.  If a block is given,
+        # each email is yielded and the result is used as the link text.
+        def auto_link_email_addresses(text)
+          text.gsub(/([\w\.!#\$%\-+.]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/) do
+            text = $1
+            text = yield(text) if block_given?
+            %{<a href="mailto:#{$1}">#{text}</a>}
+          end
+        end
+    end
+  end
+end