sproutcore 1.6.0.beta.2-x86-mingw32

data/lib/sproutcore/tools.rb

@@ -0,0 +1,419 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+#            and contributors
+# ===========================================================================
+
+require 'thor'
+
+module SC
+
+  # The tools module contain the classes that make up the command line tools
+  # available from SproutCore. In general, each command line tool has a peer
+  # class hosted in this module that implements the primary user interface.
+  #
+  # Internally SproutCore tools that chain together subtools (such as
+  # sc-build) will actually call these classes directly instead of taking the
+  # time to instantiate a whole new process.
+  #
+  # Each Tool class is implemented as a Thor subclass.  You can override
+  # methods in these classes in your own ruby code if you want to make a
+  # change to how these tools execute.  Any ruby you place in your Buildfile
+  # to modify one of these classes will actually be picked up by the
+  # tool itself when it runs.
+  #
+  class Tools < ::Thor
+    check_unknown_options!
+
+    def self.invoke(task_name)
+      start([task_name.to_s] + ARGV)
+    end
+
+    # All sproutcore tools can take some standard options.  These are
+    # processed automatically when the tool is loaded
+    class_option "project",      :type => :string
+    class_option "mode",         :type => :string
+    class_option "logfile",      :type => :string
+    class_option "build",        :type => :string
+    class_option "build-targets",:type => :string
+    class_option "yui-minification",     :type => :boolean
+    class_option "dont-minify",     :type => :boolean
+    class_option "verbose",      :type => :boolean, :aliases => "-v"
+    class_option "very-verbose", :type => :boolean, :aliases => "-V"
+    class_option "library",      :type => :string #deprecated
+    class_option "environment",  :type => :string #deprecated
+
+    default_task :banner
+
+    desc "help", "How to use the sproutcore command"
+    def banner
+      str = "SproutCore #{SC::VERSION} Usage"
+      puts "#{str}\n"+('='*str.length)+"\n\n"
+
+      help
+    end
+
+    map "--version" => :version
+    desc "version", "Show the SproutCore version number"
+    def version
+      puts "SproutCore #{SC::VERSION}"
+    end
+
+    # This is the core entry method used to run every tool.  Extend this
+    # method with any standard preprocessing you want all tools to do before
+    # they do their specific thing.
+    def initialize(*)
+      super
+      prepare_logger!
+      prepare_mode!
+      dont_minify!
+      prepare_app!
+      prepare_build_numbers!
+    end
+
+    no_tasks do
+
+      ################################################
+      ## EXCEPTIONS
+      ##
+
+      # Raise this type of exception when a fatal error occurs because the
+      # user did not pass the correct options.  This will be caught and
+      # displayed at the top level before exiting.  Note that if you raise
+      # an exception of some other type, then a backtrace may be displayed as
+      # well (Which is not preferred)
+      class FatalException < Exception
+      end
+
+      # Helper method.  Call this when an acception occurs that is fatal due
+      # to a problem with the user.
+      def fatal!(description)
+        raise FatalException, description
+      end
+
+      # Helper method.  Call this when you want to log an info message.  Logs
+      # to the standard logger.
+      def info(description)
+        SC.logger.info(description)
+      end
+
+      # Helper method.  Call this when you want to log a debug message.
+      def debug(description)
+        SC.logger.debug(description)
+      end
+
+      # Log this when you need to issue a warning.
+      def warn(description)
+        SC.logger.warn(description)
+      end
+
+      ################################################
+      ## GLOBAL OPTIONS
+      ##
+
+      # Make the options hash a HashStruct so that we can access each variable
+      # as a method
+      def options; @tool_options ||= HashStruct.new(super); end
+
+      # Configure the expected log level and log target.  Handles the
+      # --verbose, --very-verbose and --logfile options
+      def prepare_logger!
+        SC.env[:log_level] = options[:'very-verbose'] ? :debug : (options[:verbose] ? :info : :warn)
+        SC.env[:logfile] = File.expand_path(options[:logfile]) if options[:logfile]
+      end
+
+      # Configure the current build mode.  Handles the --mode and
+      # --environment options.  (--environment is provided for backwards
+      # compatibility)
+      def prepare_mode!(preferred_mode = 'production')
+        build_mode = (options[:mode] || options[:environment] || preferred_mode).to_s.downcase.to_sym
+        SC.build_mode = build_mode
+      end
+      
+      def prepare_app!
+        if options[:'build-targets']
+          SC.env[:build_targets] = options[:'build-targets'].split(',')
+        else
+          SC.env[:build_targets] = ''
+        end
+      end
+      
+      def dont_minify!
+        SC.env[:dont_minify] = options[:'dont-minify']
+      end
+
+      # Configure the current build numbers.  Handles the --build option.
+      def prepare_build_numbers!
+        return unless (numbers = options[:build])
+        numbers = numbers.split(',').map { |n| n.split(':') }
+        if numbers.size==1 && numbers.first.size==1
+          SC.env.build_number = numbers.first.first
+        else
+          hash = {}
+          numbers.each do |pair|
+            key = pair[0]
+            key = "/#{key}" if !(key =~ /^\//)
+            hash[key.to_sym] = pair[1]
+          end
+        end
+      end
+
+      ################################################
+      ## HELPER METHODS
+      ##
+
+      # Set the current project.  This is used mostly for unit testing.
+      def project=(a_project)
+        @project = a_project
+      end
+
+      def set_test_project(a_project)
+        @project = a_project
+        @discovered_project = true
+      end
+
+      # The current project.  This is discovered based on the passed --project
+      # option or based on the current working directory.  If no project can
+      # be found, this method will always return null.
+      def project
+        return @project if @discovered_project # cache - @project may be nil
+        @discovered_project = true
+
+        ret = nil
+        project_path = options[:project] || options[:library]
+
+        # if no project_path is named explicitly, attempt to autodiscover from
+        # working dir.  If none is found, just set project to nil
+        unless project_path
+          debug "No project path specified.  Searching for projects in #{Dir.pwd}"
+          ret = SC::Project.load_nearest_project Dir.pwd, :parent => SC.builtin_project
+
+        # if project path is specified, look there.  If no project is found
+        # die with a fatal exception.
+        else
+          debug "Project path specified at #{project_path}"
+          ret = SC::Project.load File.expand_path(project_path), :parent => SC.builtin_project
+          if ret.nil?
+            fatal! "Could not load project at #{project_path}"
+          end
+        end
+
+        info "Loaded project at: #{ret.project_root}" unless ret.nil?
+        @project = ret
+      end
+
+      # Attempts to discover the current project.  If no project can be found
+      # throws a fatal exception.  Use this method at the top of your tool
+      # method if you require a project to run.
+      def requires_project!
+        ret = project
+        if ret.nil?
+          fatal!("You do not appear to be inside of a project.  Try changing to your project directory or make sure your project as a Buildfile or sc-config")
+        end
+        return ret
+      end
+
+      # Find one or more targets with the passed target names in the current
+      # project.  Requires a project to function.
+      def find_targets(*targets)
+
+        debug "finding targets with names: '#{targets * "','"}'"
+        requires_project!
+
+        # Filter out any empty target names.  Sometimes this happens when
+        # processing arguments.
+        
+        targets.reject! { |x| x.nil? || x.size == 0}
+
+        # If targets are specified, find the targets project or parents...
+        if targets.size > 0
+          targets = targets.map do |target_name|
+            begin
+              ret = project.target_for(target_name)
+            rescue Exception => e
+              SC.logger.fatal("Exception when searching for target #{target_name}.  Perhaps your Buildfile is configured wrong?")
+              raise e
+            end
+
+            if ret.nil?
+              fatal! "No target named #{target_name} could be found in PROJECT:#{project.project_root}"
+            else
+              debug "Found target '#{target_name}' at PROJECT:#{ret.source_root.sub(/^#{project.project_root}\//,'')}"
+            end
+            ret
+          end
+
+        # IF no targets are specified, then just get all targets in project.
+        # If --all option was specified, include those that do not autobuild
+        else
+          targets = project.targets.values
+          unless options.all?
+            targets.reject! { |t| !t.config.autobuild? }
+          end
+        end
+
+        appnames = SC.env[:build_targets]
+
+        # if it has the appname argument only build the target with the appname        
+        if appnames.size > 0 
+          tar = []
+          targets.each do |target|
+            appnames.each do |appname|
+              if target.target_name.to_s.eql? '/'+appname
+                tar << target
+              end
+            end
+          end
+
+          targets = tar
+        end
+
+        # If include required was specified, merge in all required bundles as
+        # well. Note that we do this whether --build-targets is specified or not.
+        if options[:'include-required']
+          tar = targets.clone
+          targets.each do |target|
+            required = target.expand_required_targets :theme => true,
+             :debug => target.config.load_debug,
+             :tests => target.config.load_tests
+
+            required.each {|t| 
+              t.config[:minify_javascript] = false if not targets.include? t
+            }
+
+            tar += required
+          end
+
+          targets = tar.flatten.uniq.compact
+        end
+
+
+        targets
+
+      end
+
+      # Wraps around find_targets but raises an exception if no target is
+      # specified.
+      def requires_targets!(*target_names)
+        if target_names.size == 0
+          fatal! "You must specify a target with this command"
+        end
+
+        targets = find_targets(*target_names)
+        if targets.size == 0
+          fatal! "No targets matching #{target_names * ","} were found."
+        end
+
+        targets
+      end
+
+      # Requires exactly one target.
+      def requires_target!(*targets)
+        requires_targets!(*targets).first
+      end
+
+      # Discovers the languages requested by the user for a build.  Uses the
+      # --languages command line option or disovers in targets.
+      def find_languages(*targets)
+        # Use passed languages.  If none are specified, merge installed
+        # languages for all app targets.
+        unless (languages = options.languages)
+          languages = targets.map { |t| t.installed_languages }
+        else
+          languages = languages.split(',').map { |l| l.to_sym }
+        end
+        languages.flatten.uniq.compact
+      end
+
+      # Discovers build numbers requested for the build and sets them in the
+      # in the env if needed.
+      def find_build_numbers(*targets)
+        if options['build-numbers']
+          numbers = {}
+          options['build-numbers'].split(',').each do |pair|
+            pair = pair.split(':')
+            if pair.length < 2
+              fatal! "Could not parse build numbers! #{options['build-numbers']}"
+            end
+            numbers["/#{pair[0]}"] = pair[1]
+          end
+          SC.env.build_numbers = numbers
+          SC.logger.info "Using build numbers: #{numbers.map { |k,v| "#{k}: #{v}" }.join(',')}"
+        end
+      end
+
+      # Core method to process command line options and then build a manifest.
+      # Shared by sc-manifest, sc-build and sc-docs commands.
+      def build_manifests(*targets)
+
+        # setup build numbers
+        find_build_numbers(*targets)
+
+        requires_project! # get project
+        targets = find_targets(*targets) # get targets
+        languages = find_languages(*targets) # get languages
+
+        # log output
+        SC.logger.info "Building targets: #{targets.map { |t| t.target_name } * ","}"
+        SC.logger.info "Building languages: #{ languages * "," }"
+
+        # Now fetch the manifests to build.  One per target/language
+        manifests = targets.map do |target|
+          languages.map { |l| target.manifest_for :language => l }
+        end
+        manifests.flatten!
+
+        # Build'em
+        manifests.each do |manifest|
+          SC.logger.info "Building manifest for: #{manifest.target.target_name}:#{manifest.language}"
+          manifest.build!
+        end
+
+        return manifests
+      end
+
+      # Logs the contents of the passed file path to the logger
+      def log_file(path)
+        if !File.exists?(path)
+          warn "Could not display #{File.basename(path)} at #{File.dirname(path)} because it does not exist."
+        end
+        file_text = File.read(path)
+        SC.logger << file_text
+        SC.logger << "\n"
+      end
+
+      ################################################
+      ## MAIN ENTRYPOINT
+      ##
+
+      # Fix start so that it treats command-name like command_name
+      def self.start(args = ARGV)
+        # manually check for verbose in case we don't get far enough in
+        # regular processing to actually set the verbose mode.
+        is_verbose = %w(-v -V --verbose --very-verbose).any? { |x| args.include?(x) }
+        begin
+          super(args)
+        rescue Exception => e
+          SC.logger.fatal(e)
+          if is_verbose && !e.kind_of?(FatalException)
+            SC.logger.fatal("BACKTRACE:\n#{e.backtrace.join("\n")}\n")
+          end
+          exit(1)
+        end
+      end
+
+    end # no_tasks
+
+  end
+
+end
+
+require "sproutcore/tools/build"
+require "sproutcore/tools/build_number"
+require "sproutcore/tools/docs"
+require "sproutcore/tools/gen"
+require "sproutcore/tools/init"
+require "sproutcore/tools/manifest"
+require "sproutcore/tools/server"
+

data/lib/sproutcore/version.rb

@@ -0,0 +1,12 @@
+require 'yaml'
+module SproutCore
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+
+  VERSION_PATH = File.join(PATH, '..', 'VERSION.yml')
+  VERSION_INFO = YAML.load_file(VERSION_PATH)
+
+  VERSION = [VERSION_INFO[:major], VERSION_INFO[:minor], VERSION_INFO[:patch]].join('.')
+  # :startdoc:
+end

data/lib/sproutcore.rb

@@ -0,0 +1,169 @@
+# ===========================================================================
+# Project:   Abbot - SproutCore Build Tools
+# Copyright: ©2009 Apple Inc.
+#            portions copyright @2006-2011 Strobe Inc.
+# ===========================================================================
+
+require 'rubygems'
+require 'logger'
+require 'extlib'
+require 'yaml'
+
+$:.delete_if {|f| f =~ /json_pure-/ } if $:.any? {|f| f =~ /json-/ }
+
+# Ruby 1.8 Compatibility
+if (RUBY_VERSION.match(/1\.8/))
+  $KCODE = 'u'
+  require 'jcode'
+  class String ; def valid_encoding? ; true ; end ; end
+end
+
+# Ruby 1.9 Compatibility
+if (RUBY_VERSION.match(/1\.9/))
+  # Fix for Rack Ruby 1.9 incompatibility. This makes 404s render again.
+  class String
+    alias each each_line unless ''.respond_to?(:each)
+  end
+end
+
+# Makes code more readable
+YES = true
+NO = false
+
+require "sproutcore/version"
+
+module SproutCore
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Global variable that can store specific environmental settings.  This is
+  # where you will find the build mode among other things set by sc-build.
+  #
+  def self.env
+    @env ||= HashStruct.new(:build_mode => :debug, :buildfile_names => %w(Buildfile sc-config sc-config.rb))
+  end
+  def self.env=(hash); @env = HashStruct.new(hash); end
+
+  # Returns a standard logger object.  You can replace this with your own
+  # logger to redirect all SproutCore log output if needed.  Otherwise, a
+  # logger will bre created based on your env.log_level and env.logfile
+  # options.
+  def self.logger
+    return @logger unless @logger.nil?
+
+    if env[:logfile]
+      @logger = Logger.new env[:logfile], 10, 1024000
+    else
+      @logger = Logger.new $stderr
+
+      # if we are logging to the screen, no reason to use a std loggin fmt
+      @logger.formatter = lambda do |severity, time, progname, msg|
+        [severity, '~', msg.to_s, "\n"].join(' ')
+      end
+    end
+
+    @logger.level = (env[:log_level] == :debug) ? Logger::DEBUG : ((env[:log_level] == :info) ? Logger::INFO : Logger::WARN)
+
+    return @logger
+  end
+  attr_writer :logger
+
+  # Returns the current build mode. The build mode is determined based on the
+  # current environment build_mode settings.  Note that for backwards
+  # compatibility reasons, :development and :debug are treated as being
+  # identical.
+  def self.build_mode
+    ret = env[:build_mode] || :production
+    ret = ret.to_sym unless ret.nil?
+    ret = :debug if ret == :development # backwards compatibility
+    ret
+  end
+
+  def self.build_mode=(new_mode)
+    new_mode = new_mode.to_sym
+    new_mode = :debug if new_mode == :development
+    env[:build_mode] = new_mode
+    self.build_mode
+  end
+
+  # Returns a project instance representing the builtin library
+  def self.builtin_project
+    @builtin_project ||= SC::Project.new(PATH)
+  end
+
+  # Returns the current project, if defined.  This is normally only set
+  # when you start sc-server in interactive mode.
+  def self.project; @project; end
+  def self.project=(project); @project = project; end
+
+  # Attempts to load a project for the current working directory or from the
+  # passed directory location.  Returns nil if no project could be detected.
+  # This is just a shorthand for creating a Project object.  It is useful
+  # when using the build tools as a Ruby library
+  def self.load_project(path = nil, opts = {})
+    path = File.expand_path(path.nil? ? Dir.pwd : path)
+    if FalseClass === opts[:discover]
+      SC::Project.load path, :parent => SC.builtin_project
+    else # attempt to autodiscover unless disabled
+      SC::Project.load_nearest_project path, :parent => SC.builtin_project
+    end
+  end
+
+  def self.yui_jar
+    @yui_jar ||= begin
+      yui_root = File.expand_path("../../vendor/sproutcore/lib", __FILE__)
+      File.join(yui_root, 'yuicompressor-2.4.6.jar')
+    end
+  end
+
+  def self.profile(env)
+    if ENV[env]
+      require "ruby-prof"
+      RubyProf.start
+      yield
+      result = RubyProf.stop
+      printer = RubyProf::CallStackPrinter.new(result)
+      printer.print(File.open("output.html", "w"), :min_percent => 0)
+      exit!
+    else
+      yield
+    end
+  end
+
+end  # module SC
+
+SC = SproutCore # alias
+
+Encoding.default_external = "UTF-8" if defined?(Encoding)
+
+require "sproutcore/buildfile"
+require "sproutcore/tools"
+require "sproutcore/rack"
+require "sproutcore/helpers"
+require "sproutcore/deprecated/view_helper"
+require "sproutcore/builders"
+require "sproutcore/models"
+require "sproutcore/render_engines/erubis"
+require "sproutcore/render_engines/haml"
+
+# EOF

data/spec/buildtasks/build/copy_spec.rb

@@ -0,0 +1,60 @@
+require "buildtasks/build/spec_helper"
+
+describe "build:copy" do
+
+  include SC::SpecHelpers
+  include SC::BuildSpecHelpers
+
+  before do
+    std_before
+    @task_name = 'build:copy'
+
+    @entry = @manifest.entry_for('demo.html')
+    @src_path = @entry.source_path
+    @dst_path = @entry.build_path
+
+    @entry.build_task.should == 'build:copy' # precondition
+  end
+
+  after do
+    std_after
+  end
+
+  it "copies from source to dst_path if dst_path does not exist" do
+    File.exist?(@dst_path).should be_false # precondition
+
+    run_task @entry, @dst_path
+    files_eql(@src_path, @dst_path).should be_true
+  end
+
+  it "does not run if newer file exists at dst_path" do
+    write_dummy(@dst_path)
+    make_newer(@dst_path, @src_path)
+
+    run_task
+
+    is_dummy(@dst_path).should be_true # make sure task did not copy
+  end
+
+  it "replaces dst_path if older file exists at dst_path" do
+    write_dummy(@dst_path)
+    make_newer(@src_path, @dst_path)
+
+    run_task
+
+    is_dummy(@dst_path).should be_false # should overrwite older file
+    files_eql(@src_path, @dst_path).should be_true
+  end
+
+  it "does not run if dst_path == src_path" do
+    task = @buildfile.lookup('build:copy')
+    expected_count = task.execute_count
+
+    @dst_path = @src_path
+    run_task
+
+    task.execute_count.should == expected_count # did not execute!
+  end
+
+
+end

data/spec/buildtasks/build/spec_helper.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+module SC::BuildSpecHelpers
+
+  def std_before
+    @project = temp_project :real_world
+    @target = @project.target_for :sproutcore
+    @buildfile = @target.buildfile
+    @manifest = @target.manifest_for(:language => :fr)
+
+    @target.prepare! # make sure its ready for the manifest...
+    @manifest.build! # get a basic manifest good to go...
+  end
+
+  def std_after
+    @project.cleanup
+  end
+
+  def run_task(entry=nil, dst_path=nil)
+    entry ||= @entry
+    @buildfile.invoke @task_name,
+      :entry => entry,
+      :manifest => @manifest,
+      :target => @target,
+      :config => @target.config,
+      :project => @project,
+      :src_path => @src_path || entry.source_path,
+      :src_paths => @src_path.nil? ? entry.source_paths : [@src_path],
+      :dst_path => dst_path || @dst_path || entry.build_path
+  end
+
+  def entry_for(filename)
+    @manifest.entry_for filename, :hidden => true
+  end
+
+end