flak 0.0.4 → 0.0.5

data/lib/core_ext/string.rb

@@ -1,5 +1,46 @@
 class String
+
+  # Find words, capitalize and join
+  # @return [String] camel cased string
   def camelize
     self.split(/[^a-z0-9]/i).map{|w| w.capitalize}.join
   end
+
+
+
+  # Find words breaks and insert underscores
+  # @return [String] underscorized string
+  def underscoreize
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+
+
+
+  # Remove the erb extension if there is one
+  # @return [String] string with no erb extension
+  def no_erb
+    self.sub(/\.erb$/,'')
+  end
+
+
+  # Replace dollar-curly braces, with
+  # the value of environment variable
+  # @return [String] string with all environment variables replaced
+  def substitute_env_vars
+    str = String.new(self)
+    str.scan(/\$\{([A-Z][A-Z,0-9,_]*)\}/).uniq.each do |m|
+      begin
+        str.gsub!("${#{m[0]}}", ENV[m[0]])
+      rescue
+        $stderr.puts "problem with enviroment variable #{m[0]}."
+      end
+    end
+    str
+  end
+
 end

data/lib/flak.rb

@@ -10,20 +10,28 @@ require "thor/group"
 require "ap"
 require 'nanoc'
 require 'core_ext/string'
+require 'core_ext/hash'
 
-require 'flak/rake/cpp'
-require 'flak/rake/delight'
-require 'flak/rake/doc'
-require 'flak/rake/gl'
-require 'flak/rake/mac'
-require 'flak/rake/max'
-require 'flak/rake/maya'
-require 'flak/rake/maya_app'
-require 'flak/rake/maya_plugin'
-require 'flak/rake/nuke'
+
+require 'flak/rake/file_actions'
+require 'flak/rake/os'
+require 'flak/rake/errors'
 require 'flak/rake/target'
-require 'flak/rake/base'
-require 'flak/rake/mod'
+
+require 'flak/rake/templates/merge_engine'
+
+require 'flak/rake/templates/environment'
+require 'flak/rake/templates/maya'
+require 'flak/rake/templates/nuke'
+require 'flak/rake/templates/release'
+require 'flak/rake/templates/doc'
+require 'flak/rake/templates/maya_plugin'
+require 'flak/rake/templates/maya_app'
+require 'flak/rake/templates/shell'
+require 'flak/rake/templates/gl'
+require 'flak/rake/templates/delight'
+require 'flak/rake/templates/cpp'
+
 
 require 'flak/version'
 require 'flak/thor/wizard'

data/lib/flak/rake/errors.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Flak
+
+  # Module that contains flak error functions
+  module Errors
+
+
+
+    # Assert that a variable exists and has the correct type.
+    # Prints a bright red informative message if not.
+    # @param var [String] the variable's name
+    # @param type [String] the variable's type
+    # @param bind [Binding] the binding for the calling object so that the variable can be evaluated.
+    # @param file [String] the filename where the call for this assertion came from.
+    # @return [String] formatted error message.
+    def self.assert(var, type, bind, file)
+      param = eval(var,bind)
+      ap "#{var} is not a #{type}. It is a #{param.class}. (#{File.basename(file)})" , :color => {:string => :red}  unless param.class == Kernel.const_get(type)
+    end
+
+
+
+
+
+  end
+
+end

data/lib/flak/rake/file_actions.rb

@@ -0,0 +1,70 @@
+module Flak
+
+  module FileActions
+
+
+
+
+    # in order to make a symlink, we need to remove it 
+    # if it already exists
+
+
+    # Create a symlink.
+    # Remove it if it already exists.
+    # @param target_file [String] the file to point the new file at.
+    # @param new_file [String] the new file.
+    def rebuild_symlink(target_file,new_file)
+      if File.symlink?(new_file)
+        File.unlink(new_file)
+      end
+      File.symlink(target_file, new_file)
+    end
+
+
+
+
+    # Remove a file and copy a new file over. 
+    # If we just copy source to destination and destination exists and is a directory, 
+    # then the src is put in the destination, as opposed to overwriting it. For
+    # this reason, we delete destination first.
+    # @param source [String] the source file.
+    # @param destination [String] the destination file.
+    def remove_and_copy(source,destination)
+      remove_file(destination, true) 
+      cp_r source, destination
+    end
+
+
+
+
+    # Make a directory to contain a file.
+    # Create directories recursively if necessary.
+    # @param file [String] the file that needs a directory.    
+    def make_directory_for(file)
+      FileUtils.mkdir_p file.pathmap('%d')
+    end
+
+
+
+    # Create a destination file by filtering a source file through ERB.
+    # @param erb_file [String] the file to be filtered.    
+    # @param released_file [String] the result filename.  
+    # @param opts [Hash] the options.
+    # @option opts :chmod [String] The file mode.
+    def write_erb_template(erb_file,released_file, opts={})
+      if (!(opts[:no_force] && File.exists?(released_file) ))
+        template = ERB.new( File.read(erb_file) , 0, "%<>")
+        File.open(released_file, 'w') do |f|
+          puts "template #{erb_file} #{released_file}"
+          f.puts(template.result(binding))
+          f.chmod(opts[:chmod].to_i)   if opts[:chmod]
+        end
+      end
+    end
+
+
+  end
+
+
+
+end

data/lib/flak/rake/os.rb

@@ -0,0 +1,18 @@
+module Flak
+  # Provide a slightly nicer OS string than the 
+  # RUBY_PLATFORM variable
+  # @return [String] Either 'linux_64', 'linux_32', 'darwin', or 'win_64'
+  def self.os
+    case RUBY_PLATFORM 
+    when /64-linux/ 
+      'linux_64'
+    when /i686_linux/
+      'linux_32'
+    when /darwin/
+      'darwin'
+    when /i386-cygwin/
+      'win_64'
+    end
+  end
+
+end

data/lib/flak/rake/target.rb

@@ -1,110 +1,88 @@
 # This is where we prepare a target. 
-# The target will "inherit" settings and instance methods from modules specified in the target.yml file
+# The target will "get" settings and methods from modules specified in the target.yml file
+
 module Flak
 
   class Target
 
+    include Flak::FileActions
+
     attr_accessor :settings
 
-    def initialize(root, target_file=nil)
+    # Constructs a target object.
+    #
+    # @param root [String] the directory containing the Rakefile.
+    # @param target_file [String] the root-relative file that specifies how to build this target. Either project.yml or tool.yml
+    def initialize(root, target_file)
 
-      @settings = Hash.new
-      # start building the settings hash
-      # need the config settings to bootstrap the process
-      self.extend( Flak::Base )
+      tmp_env = YAML::load_file( root  + '/config/environment.yml' )
+      tmp_goal = YAML::load_file( target_file )
+      
+      @settings = Hash.new     
+      @settings[:configuration] =  tmp_env['configuration']
+      @settings[:templates] = tmp_goal['templates'] 
+      @settings[:os] =  Flak.os
       @settings[:root] = root
+      @settings[:target_file] =  target_file 
+      @settings[:full_target_file] =  File.join(@settings[:root], target_file )
+      @settings[:relative_goal_root] =  File.dirname(target_file) 
+      @settings[:goal_root] = File.dirname( @settings[:full_target_file] ) 
+      @settings[:templates] = (["environment"] | @settings[:templates])
       
-      tmp = YAML::load_file(  @settings[:root]  + '/config/env.yml' )
-      @settings[:configuration] =  tmp['configuration']
-      @settings[:os] =  Flak::Base.os
-
-      # settings goes in as config and os, and comes back fully resolved
-
-      h = Hash.new
-
-      @settings = Flak::Base.resolve_settings(@settings)
+    end
 
 
-      if File.exists?(target_file)
-        @settings[:target_file] =  target_file 
-        @settings[:target_dir] =  File.dirname(target_file) 
+    # After the Target has been constructed, generate settings and tasks.
+    def build
+      generate_settings
+      generate_tasks
+    end
 
-        @settings[:target_root] =  File.join(@settings[:root], @settings[:target_dir] )
 
-        # to find out what templates to use, we need to look in the target.yml
-        h = YAML::load_file( target_file )
-        template_array = h['templates'] || []
+    # Extend this Target with settings and methods from templates declared in the target file 
+    def generate_settings
 
-        # after integrate templates is done, all the settings in those
-        # templates will be flattened and merged into the settings hash
-        integrate_templates template_array
+      @settings[:templates].each do |template_name|
+        mod = Flak::Template.const_get("#{template_name.camelize}")
+        mod = mod.const_get("Settings")
+        raise TypeError, "#{mod.inspect} must be a Module" unless mod.kind_of? Module
+        self.extend( mod )
       end
 
-      # now merge the settings from this target
-      @settings = Flak::Base.merge_settings(@settings, Target.resolve_settings(@settings))
-
+      yml = Flak::Template::MergeEngine.flatten_yaml_file(@settings, @settings[:target_file])
+      @settings = @settings.flak_merge(yml)
       expand_filelists
-      instance_tasks
-    end
-
-
-    def self.resolve_settings(existing_settings)
-      Flak::Base.flatten_settings(existing_settings[:target_file], existing_settings[:configuration],existing_settings[:os] )
+      
     end
 
 
+    # Extend this Target with tasks from templates declared in the target file 
+    def generate_tasks
 
-    # Integrate the templates into the target, 
-    # The templates are modules and by "integrating templates", we are:
-    # 1. extending (picking up the module's instance methods)
-    # 2. then we build our own @settings instance data by merging in the settings from the modules
-    # See the merge settings method in base for details of the merging strategy
-    def integrate_templates(template_array)
-      template_array.each do |template_name|
-        mod = Flak.const_get(template_name.split('_').collect {|w| w.capitalize}.join())
-        unless mod.kind_of? Module
-          raise TypeError, "#{mod.inspect} must be a Module"
-        end
+      @settings[:templates].each do |template_name|
+        mod = Flak::Template.const_get("#{template_name.camelize}")
+        mod = mod.const_get("Tasks")
+        raise TypeError, "#{mod.inspect} must be a Module" unless mod.kind_of? Module
         self.extend( mod )
-        @settings = Flak::Base.merge_settings(@settings, mod.resolve_settings(@settings))
       end
-    end
 
-
-
-    # run all task synthesis methods that have been mixed in to this instance
-    # the convention is to name these tasks <filename>_instance_tasks in the module files
-    # in which they are defined.
-    # only make tasks if the target has a name - a target with no has probably been limited
-    # to only generate tasks for a specific OS (or configuration)
-    def instance_tasks
-      unless (@settings[:name].nil?)
-        self.public_methods.grep(/_instance_tasks/).each do |t|
-          self.send t
-        end
-      end
     end
 
 
 
     private
 
-    # resolve filename globs and prepend target_dir to file globs 
-    # and path arrays. Its important that when specifying files in 
-    #the yaml, the user sets the key names to be "<something>_files"
-    # or "<something>_paths".
-    # If the path given is relative, we prepend the path to 
-    # the target file (target_dir) so that Rake has somewhere to work from
+    # Expand FileList objects into arrays so that calling inspect on a target gives a more readable output.
     def expand_filelists
       @settings.each do |k,v|
         if k.to_s =~ /_files$|_paths$/
           unless v.nil?
-            v = v.collect { |el| (el[0] == '/') || (el[1] ==":") ?  el : File.join(@settings[:target_dir],el) }
-            @settings[(k.to_sym)] =  k.to_s =~ /_files$/ ? FileList[v] : v
+            v = v.collect { |el| (el[0] == '/') || (el[1] ==":") ?  el : File.join(@settings[:relative_goal_root],el) }
+            @settings[(k.to_sym)] =  k.to_s =~ /_files$/ ? FileList[v].to_a : v
           end
         end        
       end
     end
-    
+
   end
 end

data/lib/flak/rake/templates/cpp.rb

@@ -0,0 +1,211 @@
+module Flak::Template
+  module Cpp
+
+    module Settings
+
+      extend Flak::Template::MergeEngine
+
+      def self.extended target
+        infuse target
+      end
+
+
+
+
+      # these methods will become instance methods of the target
+      # and as such will have access to te @settings instance variable
+      ###################################################
+      def build_filename
+        bind = binding()
+        Flak::Errors.assert("@settings[:build_directory]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:name]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:target_extension]", "String", bind,__FILE__)
+        File.join(@settings[:build_directory],'products',@settings[:name].ext(@settings[:target_extension])) 
+      end
+
+      def release_filename 
+        bind = binding()
+        Flak::Errors.assert("@settings[:path_to_revision]", "String", bind,__FILE__)
+        File.join( @settings[:path_to_revision], 'bin', build_filename.pathmap('%f'))   
+      end
+
+      # generate path to object file from source: e.g. /hq/dev/jtools/build/2009.3/darwin/debug/animal/sensor.o"
+      def object_file(source)
+        bind = binding()
+        Flak::Errors.assert("@settings[:build_directory]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:object_extension]", "String", bind,__FILE__)
+        File.join(@settings[:build_directory], source.gsub("/src/","/").ext( @settings[:object_extension] ))
+      end
+
+      # collect all object files for this target
+      def object_files
+        @settings[:source_files].collect { |s| object_file(s) }
+      end
+
+      def c_compile_cmd(source)
+        bind = binding()
+        Flak::Errors.assert("@settings[:compiler]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:object_flag]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:include_flag]", "String", bind,__FILE__)
+
+        compiler = "\"#{@settings[:compiler]}\""
+        object = "#{@settings[:object_flag]}\"#{object_file(source)}\""
+        source = "\"#{source}\""
+        inc_path = (@settings[:source_files].collect {|f| f.pathmap('%d')}.uniq | ( @settings[:include_paths] || [] )).collect { |el| "#{@settings[:include_flag]}\"#{el.to_s}\"" }.join(" ")
+        includes = ( @settings[:includes] || [] ).collect { |el| "-include  \"#{el.to_s}\"" }.join(" ")
+        compiler_options = (@settings[:compiler_options] || [] ).collect { |el| el.to_s }.join(" ")
+        # puts "*" * 80
+        # puts @settings[:compiler_options]
+        # puts "*" * 80
+        "#{compiler} #{compiler_options}  #{source} #{object}  #{inc_path} #{includes}"
+      end
+
+
+      def c_link_cmd
+        bind = binding()
+        Flak::Errors.assert("@settings[:linker]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:lib_flag]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:lib_ext]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:libpath_flag]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:framework_flag]", "String", bind,__FILE__)
+        Flak::Errors.assert("@settings[:outputfile_flag]", "String", bind,__FILE__)
+
+
+        linker = "\"#{@settings[:linker]}\""
+        objects = object_files.collect { |el| "\"#{el.to_s}\"" }.join(" ")
+        #  libstr =  ((@settings[:libs] || []).collect { |el| "-l#{el.to_s}" } |  (@settings[:static_libs] || []).collect { |el| "#{@settings[:static_prefix_flag]} -l#{el.to_s}" }).join(" ")
+        libstr =  (@settings[:libs] || []).collect { |el| "#{@settings[:lib_flag]}#{el.to_s}#{@settings[:lib_ext]}" }.join(" ")
+        libpathstr = (@settings[:lib_paths] || []).collect { |el| "#{@settings[:libpath_flag]}\"#{el.to_s}\"" }.join(" ")
+        linkflagstr = ( @settings[:linker_options]  || [] ).collect { |el| el.to_s }.join(" ")
+        dso_flagstr = (@settings[:dso_options] || [] ).collect { |el| el.to_s }.join(" ")
+        fwrk = (@settings[:frameworks] || [] ).collect { |el| "#{@settings[:framework_flag]} #{el.to_s}" }.join(" ")
+        "#{linker}  #{dso_flagstr} #{linkflagstr}  #{libpathstr} #{libstr} #{fwrk}   #{@settings[:outputfile_flag]}\"#{build_filename}\" #{objects}"
+      end
+
+
+      def c_clean_cmd
+        objects = object_files.collect { |el| "\"#{el.to_s}\"" }
+        "rm -f \"#{build_filename}\" #{objects}"
+      end
+      ###################################################
+
+
+
+
+    end
+
+
+
+
+
+    module Tasks
+      def self.extended target
+        task_factory target
+      end
+
+
+      def self.task_factory target
+        settings = target.settings
+
+
+        files = settings[:source_files]
+        unless files.nil?
+
+
+
+
+          # file tasks to compile objects from sources
+          # make sure the object file depends on the 
+          # source and header if it exists
+          ######################################################    
+          files.each do |f|
+            object = target.object_file(f)  
+            file object => f  do |t|
+              target.make_directory_for(object)
+              sh target.c_compile_cmd(f)
+            end
+            header = f.ext('h')
+            file object => header if File.exists?(header) 
+          end
+          ######################################################     
+
+
+
+
+
+          # file tasks to link targets
+          ######################################################
+          objects = target.object_files
+          build_file = target.build_filename
+          file build_file => objects do 
+            target.make_directory_for(build_file)
+            sh target.c_link_cmd
+          end
+
+          namespace settings[:name].to_sym do             
+            desc "build the #{settings[:name].to_sym} binary"
+            task :build => build_file # add named target
+          end
+          task :build => "#{settings[:name].to_sym}:build"
+          ######################################################
+
+
+
+
+
+
+
+          # tasks to clean the build
+          ######################################################
+          namespace settings[:name].to_sym do     
+            desc "clean the #{settings[:name].to_sym} build files"
+            task :clean do
+              sh target.c_clean_cmd
+            end
+          end
+          task :clean => "#{settings[:name].to_sym}:clean"
+          ######################################################
+
+
+
+
+
+
+
+          # plugins and executables release tasks
+          ######################################################
+          release_binary = target.release_filename
+          build_file = target.build_filename  
+          file release_binary => build_file do
+            target.make_directory_for(release_binary)
+            rm_r release_binary  if File.exists?(release_binary)
+            cp build_file, release_binary 
+            File.chmod 0755, release_binary 
+          end
+          ######################################################
+
+
+
+
+
+          # add the release_binary file task to the tool's release task
+          # and add the tool's release task to the release task
+          # in the global namespace
+          ######################################################
+          namespace settings[:name].to_sym do             
+            task :release => release_binary
+          end
+
+          task :release => "#{settings[:name].to_sym}:release"
+          ######################################################
+
+        end
+
+
+
+      end
+
+    end
+  end
+end
+