sproutcore 1.0.1046 → 1.0.1049.pre.1

data/lib/sproutcore/helpers/tag_helper.rb

@@ -84,9 +84,9 @@ module SC
         fix_double_escape(html_escape(html.to_s))
       end
 
-      # Simple link_to can wrap a passed string with a link to a specified 
+      # Simple link_to can wrap a passed string with a link to a specified
       # target or static asset.  If you pass a block then the block will be
-      # invoked and its resulting content linked.  You can also pass 
+      # invoked and its resulting content linked.  You can also pass
       # :popup, :title, :id, :class, and :style
       def link_to(content, opts=nil, &block)
         if block_given?
@@ -98,12 +98,12 @@ module SC
           opts = content
           content = nil
         end
-        
+
         opts = { :href => opts } if opts.instance_of? String
         opts = HashStruct.new(opts)
         html_attrs = HashStruct.new
         is_target = false
-        
+
         if opts.href
           html_attrs.href = opts.href
         elsif opts.target
@@ -116,7 +116,7 @@ module SC
             content = title(cur_target) if cur_target
             content = opts.target if content.nil?
           end
-                    
+
           # if current==false, then don't link if current target matches
           if !opts.current.nil? && (opts.current==false) && is_target
             return %(<span class="anchor current">#{content}</span>)
@@ -126,21 +126,21 @@ module SC
         elsif opts.static
           html_attrs.href = sc_static(opts.static, :language => opts.language)
         end
-        
+
         if opts.popup
           popup = opts.popup
           html_attrs.target = popup.instance_of?(String) ? popup : '_blank'
         end
-        
+
         %w[title id class style].each do |key|
           html_attrs[key] = opts[key] if opts[key]
         end
-        
+
         # add "current" class name
         if is_target
           html_attrs[:class] = [html_attrs[:class], 'current'].compact.join(' ')
         end
-        
+
         ret = ["<a "]
         html_attrs.each { |k,v| ret << [k,'=','"',v,'" '].join('') }
         ret << '>'
@@ -148,7 +148,7 @@ module SC
         ret << '</a>'
         return ret.join('')
       end
-          
+
       private
         def content_tag_string(name, content, options)
           tag_options = options ? tag_options(options) : ""

data/lib/sproutcore/helpers/text_helper.rb

@@ -5,7 +5,7 @@
 #            and contributors
 # ===========================================================================
 
-require File.join(SC::LIBPATH, 'sproutcore', 'helpers', 'tag_helper')
+require "sproutcore/helpers/tag_helper"
 #require 'html/document'
 
 # Borrowed from Rails 2.0.2
@@ -77,7 +77,7 @@ module SC
           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>.

data/lib/sproutcore/models.rb

@@ -0,0 +1,8 @@
+require "sproutcore/models/generator"
+require "sproutcore/models/hash_struct"
+require "sproutcore/models/manifest"
+require "sproutcore/models/manifest_entry"
+require "sproutcore/models/project"
+require "sproutcore/models/target"
+
+

data/lib/sproutcore/models/generator.rb

@@ -8,8 +8,8 @@
 require 'extlib'
 
 module SC
-  
-  # A generator is a special kind of project that can process some input 
+
+  # A generator is a special kind of project that can process some input
   # templates to generate some default content in a target project.
   #
   # === Setup Process
@@ -20,16 +20,16 @@ module SC
   #  1. Process any passed :arguments hash (also saved as 'arguments')
   #  2. Invoke any defined generator:prepare task to do further set'
   #  3. Search the target project for a target with the target_name if set.
-  #  
+  #
   #
   # === Standard Options
   #
   # These options are automatically added to the generator if possible.  Your
   # generator code should expect to work with them.  The following examples
-  # assume you pass as an argument either "AddressBook.Contact" or 
+  # assume you pass as an argument either "AddressBook.Contact" or
   # "address_book/contact".
   #
-  #  target_name:: 
+  #  target_name::
   #    the name of the target to use as the root.  Defaults to the snake case
   #    version of the passed namepace.  This can be overridden by passing the
   #    "target_name" option to new().  example: "address_book"
@@ -41,13 +41,13 @@ module SC
   #  build_root::
   #    If target is not nil, set to the source_root for the target.  If no
   #    target, set to the project_root for the current target project.  If no
-  #    project is defined, set to the current working directory.  May be 
+  #    project is defined, set to the current working directory.  May be
   #    overridden with build_root option to new().  example:
   #    /Users/charles/projects/my_project/apps/address_book
   #
   #  filename::
   #    The filename as passed in arguments.  example: "contact"
-  # 
+  #
   #  namespace::
   #    The classified version of the target name.  example: "AddressBook"
   #
@@ -55,25 +55,25 @@ module SC
   #    The classified version of the filename.  example: "Contact"
   #
   #  method_name::
-  #    If a full three-part Namespace.ClassName.methodName is passed, this 
+  #    If a full three-part Namespace.ClassName.methodName is passed, this
   #    property will be set to the method name.  example: nil (no method name
   #    included)
   #
   class Generator < HashStruct
-    
+
     # the target project to build in or nil if no target provided
     attr_reader :target_project
 
     attr_reader :logger
-    
+
     ################################################
     ## SETUP
     ##
-    
+
     # Discover all installed generators for a particular project.
     def self.installed_generators_for(project)
       ret = []
-      while project 
+      while project
         %w(generators sc_generators gen).each do |dirname|
           Dir.glob(project.project_root / dirname / '**').each do |path|
             ret << File.basename(path) if File.directory?(path)
@@ -83,23 +83,23 @@ module SC
       end
       return ret.uniq.compact.sort
     end
-    
+
     # Creates a new generator.  Expects you to pass at least a generator name
     # and additional options including the current target project.  This will
     # search for a generator source directory in the target project and any
     # parent projects.  The source directory must live inside a folder called
-    # "gen" or "generators".  The source directory must contain a Buildfile 
+    # "gen" or "generators".  The source directory must contain a Buildfile
     # and a templates directory to be considered a valid generator.
     #
-    # If no valid generator can be found matching the generator name, this 
+    # If no valid generator can be found matching the generator name, this
     # method will return null
     #
     def self.load(generator_name, opts={})
-      
+
       # get the project to search and look for the generator
       target_project = project = opts[:target_project] || SC.builtin_project
       path = ret = nil
-      
+
       # attempt to discover the the generator
       while project && path.nil?
         %w(generators sc_generators gen).each do |dirname|
@@ -113,17 +113,17 @@ module SC
         end
         project = project.parent_project
       end
-      
+
       # Create project if possible
       ret = self.new(generator_name, opts.merge(:source_root => path, :target_project => target_project)) if path
-      return ret 
-    end  
-      
+      return ret
+    end
+
     def initialize(generator_name, opts = {})
       super()
-      
+
       @target_project = opts[:target_project] || opts['target_project']
-      @logger = opts[:logger] || opts['logger'] || SC.logger 
+      @logger = opts[:logger] || opts['logger'] || SC.logger
       @buildfile = nil
 
       # delete special options
@@ -131,19 +131,19 @@ module SC
         opts.delete(key)
         opts.delete(key.to_sym)
       end
-      
+
       # copy any remaining options onto generator
       opts.each { |key, value| self[key] = value }
       self.generator_name = generator_name
-      
+
     end
 
     ################################################
     ## Buildfile
     ##
-    
+
     # The current buildfile for the generator.  The buildfile is calculated by
-    # merging the buildfile for the generator with the default generator 
+    # merging the buildfile for the generator with the default generator
     # buildfile.  Buildfiles should be named "Buildfile" and should be placed
     # in the generator root directory.
     #
@@ -154,17 +154,17 @@ module SC
       return @buildfile unless @buildfile.nil?
 
       @buildfile = Buildfile.new
-      
+
       # First try to load the shared buildfile
       path = File.join(SC.builtin_project.project_root, 'gen', 'Buildfile')
       if !@buildfile.load!(path).loaded_paths.include?(path)
-        SC.logger.warn("Could not load shared generator buildfile at #{buildfile_path}") 
+        SC.logger.warn("Could not load shared generator buildfile at #{buildfile_path}")
       end
-      
+
       # Then try to load the buildfile for the generator
       path = File.join(source_root, 'Buildfile')
       @buildfile.load!(path)
-      
+
       return @buildfile
     end
 
@@ -181,8 +181,8 @@ module SC
 
     ################################################
     ## MAIN ENTRYPOINTS
-    ##    
-    
+    ##
+
     # Prepares the generator state by parsing any passed arguments and then
     # invokes the 'generator:prepare' task from the Buildfile, if one exists.
     # Once a generator has been prepared, you can then build it.
@@ -191,57 +191,57 @@ module SC
       @is_prepared = true
 
       parse_arguments!
-      
-      has_project = target_project && target_project != SC.builtin_project 
+
+      has_project = target_project && target_project != SC.builtin_project
       if target_name && has_project && target.nil?
         self.target = target_project.target_for(target_name)
       end
 
       # Attempt to build a reasonable default build_root.  Usually this should
-      # be the target path, but if a target can't be found, use the project 
+      # be the target path, but if a target can't be found, use the project
       # path.  If a project is not found or the target project is the builtin
       # project, then use the current working directory
       if target
         self.build_root = target.source_root
-      else 
+      else
         self.build_root = has_project ? target_project.project_root : Dir.pwd
       end
-      
+
       # Execute prepare task - give the generator a chance to fixup defaults
       buildfile.invoke 'generator:prepare', :generator => self
       return self
     end
 
-    # Executes the generator based on the current config options.  Raises an 
-    # exception if anything failed during the build.  This will copy each 
+    # Executes the generator based on the current config options.  Raises an
+    # exception if anything failed during the build.  This will copy each
     # file from the source, processing it with the rhtml template.
     def build!
       prepare! # if needed
       buildfile.invoke 'generator:build', :generator => self
-      return self 
+      return self
     end
 
     ################################################
     ## LOGGING
     ##
-    
+
     # Helper method.  Call this when an acception occurs that is fatal due to
     # a problem with the user.
     def fatal!(description)
       raise description
     end
-    
+
     # Helper method.  Call this when you want to log an info message.  Logs to
     # the standard logger.
     def info(description); logger.info(description); end
-    
+
     # Helper method.  Call this when you want to log a debug message.
     def debug(description); logger.debug(description); end
-    
+
     # Log this when you need to issue a warning.
     def warn(description); logger.warn(description); end
-    
-    
+
+
     # Logs the pass file to the logger after first processing it with Erubis.
     # This is the code helper method used to log out USAGE and README files.
     #
@@ -258,18 +258,18 @@ module SC
         warn "Could not find #{File.basename(src_path)} in generator source"
       else
         require 'erubis'
-        a_logger << Erubis::Eruby.new(File.read(src_path)).result(binding()) 
+        a_logger << Erubis::Eruby.new(File.read(src_path)).result(binding())
         a_logger << "\n"
       end
-      return self 
+      return self
     end
-    
+
     # Logs the README file in the source_root if found or logs a warning.
     def log_readme(a_logger=nil)
       src_path = self.source_root / "README"
       log_file(src_path, a_logger)
     end
-    
+
     # Logs the USAGE file in the source_root if found or logs a warning.
     def log_usage(a_logger=nil)
       src_path = self.source_root / 'USAGE'
@@ -278,7 +278,7 @@ module SC
 
     ################################################
     ## UTILITY METHODS
-    ##    
+    ##
 
     # Returns the full namespace and class name if both are defined.
     def namespace_class_name
@@ -289,7 +289,7 @@ module SC
     def namespace_instance_name
       [self.namespace, self.instance_name].compact.join '.'
     end
-    
+
     # Verifies that the passed array of keys are defined on the object.  If
     # you pass an optional block, the block will be invoked for each key so
     # you can validate the value as well.  Otherwise, this will raise an error
@@ -305,7 +305,7 @@ module SC
       end
       return self
     end
-    
+
     # Converts a path with optional template variables into a regular path
     # by looking up said variables on the receiver.  Variables in the pathname
     # must appear inside of a pair of @@.
@@ -313,7 +313,7 @@ module SC
       path = path.gsub(/@(.*?)@/) { self.send($1) || $1 }
       File.expand_path path
     end
-    
+
     # Calls your block for each file and directory in the source template
     # passing the expanded source path and the expanded destination directory
     #
@@ -328,13 +328,13 @@ module SC
     # === Param
     #  source_dir:: optional source directory.  Defaults to templates
     #  build_dir::  optional build directory.  Defaults to build_root
-    # === Returns 
+    # === Returns
     #  self
     #
-    def each_template(source_dir = nil, build_dir=nil) 
+    def each_template(source_dir = nil, build_dir=nil)
       source_dir = self.source_root / 'templates' if source_dir.nil?
       build_dir = self.build_root if build_dir.nil?
-      
+
       Dir.glob(source_dir / '**' / '*').each do |src_path|
         filename = src_path.sub(source_dir / '', '')
         dst_path = build_dir / filename
@@ -342,7 +342,7 @@ module SC
       end
       return self
     end
-    
+
     # Copies from source to destination, running the contents through ERB
     # if the file appears to be a text file.  The destination file must not
     # exist or else a warning will be logged.
@@ -350,56 +350,56 @@ module SC
     # === Returns
     #  true if copied successfully.  false otherwise
     #
-    def copy_file(src_path, dst_path) 
+    def copy_file(src_path, dst_path)
 
       # interpolate dst_path to include any variables
       dst_path = expand_path(dst_path)
-      
+
       src_filename = src_path.sub(self.source_root / '', '')
       dst_filename = dst_path.sub(self.build_root / '', '')
-      ret = true 
+      ret = true
 
       # if the source path does not exist, just log a warning and return
       if !File.exist? src_path
         warn "Did not copy #{src_filename} because the source does not exist."
         ret = false
-        
+
       # when copying a directory just make the dir if needed
       elsif File.directory?(src_path)
         logger << " ~ Created directory at #{dst_filename}\n" if !File.exist?(dst_path)
         FileUtils.mkdir_p(dst_path) unless self.dry_run
-        
+
       # if destination already exists, just log warning
       elsif File.exist?(dst_path) && !self.force
         warn "Did not overwrite #{dst_filename} because it already exists."
         ret = false
-        
+
       # process file through erubis and copy
       else
         require 'erubis'
-        
+
         input = File.read(src_path)
         eruby = ::Erubis::Eruby.new input
         output = eruby.result(binding())
-        
+
         unless self.dry_run
           FileUtils.mkdir_p(File.dirname(dst_path))
           file = File.new(dst_path, 'w')
           file.write output
           file.close
         end
-        
+
         logger << " ~ Created file at #{dst_filename}\n"
       end
-      return ret 
+      return ret
     end
 
     # Converts a string to snake case.  This method will accept any variation
     # of camel case or snake case and normalize it into a format that can be
-    # converted back and forth to camel case.  
+    # converted back and forth to camel case.
     #
     # === Examples
-    # 
+    #
     #   snake_case("FooBar")           #=> "foo_bar"
     #   snake_case("HeadlineCNNNews")  #=> "headline_cnn_news"
     #   snake_case("CNN")              #=> "cnn"
@@ -410,17 +410,17 @@ module SC
     #
     #  str:: the string to snake case
     #
-    def snake_case(str='') 
+    def snake_case(str='')
       str = str.gsub(/([^A-Z_])([A-Z][^A-Z]?)/,'\1_\2') # most cases
       str = str.gsub(/([^_])([A-Z][^A-Z])/,'\1_\2') # HeadlineCNNNews
       str.downcase
     end
-    
+
     ABBREVIATIONS = %w(html css xml)
-    
+
     # Converts a string to CamelCase.  If you pass false for the second param
     # then the first letter will be lower case rather than upper.  This will
-    # first snake_case the passed string.  This version differs from the 
+    # first snake_case the passed string.  This version differs from the
     # standard camel_case provided by extlib by supporting a few standard
     # abbreviations that are always make upper case.
     #
@@ -429,21 +429,21 @@ module SC
     #  camel_case("foo_bar")                #=> "FooBar"
     #  camel_case("headline_cnn_news")      #=> "HeadlineCnnNews"
     #  camel_case("html_formatter")     #=> "HTMLFormatter"
-    #  
+    #
     # === Params
-    # 
+    #
     #  str:: the string to camel case
     #  capitalize:: capitalize first character if true (def: true)
     #
     def camel_case(str, capitalize=true)
       str = snake_case(str) # normalize
-      str.gsub(capitalize ? /(\A|_+)([^_]+)/ : /(_+)([^_]+)/) do 
+      str.gsub(capitalize ? /(\A|_+)([^_]+)/ : /(_+)([^_]+)/) do
         ABBREVIATIONS.include?($2) ? $2.upcase : $2.capitalize
       end
     end
-    
+
     protected
-    
+
     # Standardized parsing of arguments.  This will accept an argument that
     # is either a class name or a path name and generate both a class name and
     # a pathname from it.
@@ -452,7 +452,7 @@ module SC
       name  = (self.arguments || [])[1]
       parts = name.include?('/') ? name.split('/') : name.split('.')
 
-      # method_name would be extracted from for instance Todos.Task.methodName 
+      # method_name would be extracted from for instance Todos.Task.methodName
       # for generators that allow it
       if parts[2] && self.method_name.nil?
         self.method_name = camel_case(parts[2], false)
@@ -460,34 +460,34 @@ module SC
 
       # target_name is first part snake_cased, unless already defined
       if parts[0] && self.target_name.nil?
-        self.target_name = snake_case(parts[0]) 
+        self.target_name = snake_case(parts[0])
       end
-      
-      # namespace is first part CamelCases if defined.  Otherwise use 
+
+      # namespace is first part CamelCases if defined.  Otherwise use
       # target_name if defined
       if (parts[0] || self.target_name) && self.namespace.nil?
         self.namespace = camel_case(parts[0] || self.target_name)
-      end 
+      end
 
       # filename is second part snake_cased, unless already defined
       if parts[1] && self.filename.nil?
         self.filename = snake_case(parts[1])
       end
-      
-      # class_name is second part CamcelCased if defined.  Otherwise use 
+
+      # class_name is second part CamcelCased if defined.  Otherwise use
       # filename if defined.
       if (parts[1] || self.filename) && self.class_name.nil?
         self.class_name = camel_case(parts[1] || self.filename)
       end
-      
+
       # object_name is class name with first letter lower case.  Used in case
       # the template wants to define an instance instead of class.
       if self.class_name && self.instance_name.nil?
         self.instance_name = self.class_name.sub(/^(.)/) { |x| x.downcase }
       end
-      
+
     end
-    
+
   end
-  
-end
+
+end