flak 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in flak.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/flak

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'flak'
+
+Flak::CLI.start

data/flak.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "flak/version"
+
+Gem::Specification.new do |s|
+  s.name        = "flak"
+  s.version     = Flak::VERSION
+  s.authors     = ["Julian Mann"]
+  s.email       = ["julian.mann@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{build system for VFX tools}
+  s.description = %q{VFX tool build and documentation framework based on rake with thor generators}
+  s.add_dependency('thor')
+  s.rubyforge_project = "flak"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "awesome_print"
+  s.add_runtime_dependency "nanoc"
+
+
+  
+end
+
+
+

data/lib/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def camelize
+    self.split(/[^a-z0-9]/i).map{|w| w.capitalize}.join
+  end
+end

data/lib/flak/cpp.rb

@@ -0,0 +1,137 @@
+
+
+module Flak
+
+  # module methods in this module set up defaults when doing c++ builds
+  # some instance methods are provided - they will be inherited by target objects
+
+  module Cpp
+
+    
+    def self.resolve_settings( existing_settings )
+       f = existing_settings[:root] + '/config/cpp.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+      #override the build dir
+     h[:build_dir] = File.join("build", existing_settings[:product_revision] , existing_settings[:os], existing_settings[:configuration])
+
+      h
+    end
+
+    # path to target build: e.g. /hq/dev/jtools/build/2009.3/darwin/debug/jAnimal.bundle
+
+    # generate path to object build from source: e.g. /hq/dev/jtools/build/2009.3/darwin/debug/animal/sensor.o"
+    def object_file(source)
+      File.join(@settings[:build_dir], 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)
+      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(" ")
+      "#{compiler} #{compiler_options}  #{source} #{object}  #{inc_path} #{includes}"
+    end
+
+
+    def c_link_cmd
+        #puts "c_link_cmd" + ("*" * 10)
+       # puts @settings[:linker_options]
+    
+      linker = "\"#{@settings[:linker]}\""
+      objects = object_files.collect { |el| "\"#{el.to_s}\"" }
+      #  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]}\"#{filename}\" #{objects}"
+    end
+
+    def c_clean_cmd
+      objects = object_files.collect { |el| "\"#{el.to_s}\"" }
+      "rm -f \"#{filename}\" #{objects}"
+    end
+
+
+    def target_release_path  
+      File.join( @settings[:versioned_os_release_path], @settings[:target_release_prefix], self.filename.pathmap('%f'))   
+    end
+
+    def cpp_instance_tasks
+      files = @settings[:source_files]
+      unless files.nil?
+
+        # file tasks to compile objects from sources
+        ######################################################    
+        files.each do |f|
+          object = object_file(f)  
+          file object => f  do |t|
+            Flak.make_dir_for(object)
+
+            sh c_compile_cmd(f)
+          end
+          header = f.ext('h')
+          file object => header if File.exists?(header) 
+        end
+        ######################################################     
+
+        # file tasks to link targets
+        ######################################################
+        objects = object_files
+        file self.filename => objects do 
+          Flak.make_dir_for(self.filename)
+          sh c_link_cmd
+        end
+
+        namespace @settings[:name].to_sym do             
+          desc "build the #{@settings[:name].to_sym} binary"
+          task :build => self.filename # 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 c_clean_cmd
+          end
+        end
+        task :clean => "#{@settings[:name].to_sym}:clean"
+        ######################################################
+
+        # plugins and executables release tasks
+        ######################################################
+        released_binary = self.target_release_path
+        file released_binary => self.filename do
+          Flak.make_dir_for(released_binary)
+          rm_r released_binary  if File.exists?(released_binary)
+          cp self.filename, released_binary 
+          File.chmod 0755, released_binary 
+        end
+
+        namespace @settings[:name].to_sym do             
+          task :release => released_binary
+        end
+        task :release => "#{@settings[:name].to_sym}:release"
+        ######################################################
+
+      end
+    end
+ 
+ 
+ 
+  end
+end
+
+
+

data/lib/flak/delight.rb

@@ -0,0 +1,121 @@
+
+module Flak
+
+  module Delight
+    
+    # to resolve settings for a template, we have access to the full hash of existing settings
+    # so that we may use, for example, some existing paths to build new paths for this object.
+    # in the first place, we call flatten_settings with the configuration and os, which 
+    # definitely already exist.
+    def self.resolve_settings( existing_settings )
+
+     f = existing_settings[:root] + '/config/delight.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+
+      versioned_location = File.join("#{h[:delight_location]}-#{h[:delight_version]}")
+      
+      h[:lib_paths] =             [ File.join(versioned_location, "lib" ) ]
+      h[:include_paths] =         [ File.join(versioned_location, "include") ]
+      h[:shader_compiler] =       File.join(versioned_location, "bin","shaderdl")
+      h[:shader_build_dir] =      existing_settings[:build_dir]
+      h[:libs] =                  ["3delight"]
+      h[:shader_include_paths] = [File.join(versioned_location, "maya","rsl") ] 
+    
+      h
+    end
+
+    # all shader build files
+    def shader_files()
+      @settings[:sl_files].collect { |f| shader_file(f) }
+    end
+
+
+    # path to shader build: e.g. /hq/dev/jtools/build/2009.3/darwin/debug/goosebump.sdl
+    def shader_file(source)
+      File.join(@settings[:shader_build_dir], source.gsub("/src/","/").ext('sdl'))
+    end
+
+    def shader_release_path(file)
+      File.join(@settings[:versioned_os_release_path] , @settings[:shader_release_prefix], file.pathmap('%f'))
+    end
+
+    def delight_shader_compile_cmd(dest,src)  
+      include_path_string = (@settings[:sl_files].collect {|f| f.pathmap('%d')}.uniq | ( @settings[:shader_include_paths] || [] )).collect { |el| "-I#{el.to_s}" }.join(" ")
+      shader_type_string = "-DSHADER_TYPE_#{src.pathmap('%d').pathmap('%f')}"
+      "#{@settings[:shader_compiler]} #{shader_type_string}  #{include_path_string} -d #{dest} #{src}"
+    end
+
+
+    def delight_clean_cmd
+      "rm -f  #{shader_files}"
+    end
+
+
+    def delight_instance_tasks
+      # delight shader build and release tasks
+      ######################################################
+      files = @settings[:sl_files]
+      unless files.nil?
+
+        files.each do |f|
+
+
+
+          # file tasks to build shader from sources
+          ######################################################
+          target_shader = shader_file(f)    
+          file target_shader => f  do |t|
+            dest = Flak.make_dir_for(target_shader)
+            sh delight_shader_compile_cmd(dest,f) 
+          end
+
+          namespace @settings[:name].to_sym do        
+            desc "build the #{@settings[:name].to_sym} delight shaader"
+            task :build => target_shader
+          end
+          task :build => "#{@settings[:name].to_sym}:build"
+          ######################################################            
+
+
+
+          # file tasks to release shaders
+          ######################################################
+          released_shader = shader_release_path(target_shader)
+          file released_shader => target_shader do
+            Flak.make_dir_for(released_shader)
+            cp target_shader, released_shader 
+          end
+
+          namespace @settings[:name].to_sym do        
+            task :release => released_shader
+          end
+          task :release => "#{@settings[:name].to_sym}:release"
+          ######################################################       
+
+
+        end
+
+
+        # task to clean the build files
+        ######################################################
+        namespace @settings[:name].to_sym do     
+          desc "clean the #{@settings[:name].to_sym} build files"
+          task :clean do
+            sh delight_clean_cmd
+          end
+        end
+        task :clean => "#{@settings[:name].to_sym}:clean"
+        ######################################################
+
+
+
+
+
+
+      end
+    end
+
+
+  end
+end
+

data/lib/flak/doc.rb

@@ -0,0 +1,259 @@
+
+
+module Flak
+
+  module Doc
+
+    def self.resolve_settings( existing_settings )
+      f = existing_settings[:root] + '/config/doc.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+
+      h[:full_site_index_file] = File.join(existing_settings[:root],h[:site_index_file])
+     # puts "doc_release_root = #{existing_settings[:doc_release_root]}"
+     # puts "name = #{@settings[:name]}"
+     #  h[:doc_release_path]  = File.join( existing_settings[:doc_release_root] , existing_settings[:name])
+      h
+    end
+
+    def doc_dir
+      File.join( @settings[:target_root],"doc")
+    end
+    def output_dir()     
+      File.join(doc_dir ,"output")  
+    end
+
+    def content_dir()     
+      File.join(doc_dir ,"content")  
+    end
+
+    #h[:versioned_doc_release_path] =  File.join( h[:release_root] , "#{h[:product_revision]}-#{h[:os]}" )
+
+   #def doc_release_path
+   #  File.join( @settings[:doc_release_root] , @settings[:name])
+   ##   File.join(@settings[:release_root],  "#{@settings[:product_revision]}-doc")
+   #end
+    
+   def release_dir
+     File.join( @settings[:doc_release_root] , @settings[:name])
+   end
+
+    def copy_to_release_dir
+      r = release_dir
+      rm_rf r if File.exists? r
+      Flak.make_dir_for(r)
+      FileUtils.cp_r output_dir, r if File.exists? output_dir
+    end
+
+
+    # get the header information out of the index file so we can 
+    # build its site index entry
+    #def index_hash
+    #  h={}     
+    #  Dir.chdir(@root) do
+    #    h = YAML::load_file( File.join(self.content_dir,'index.txt') )
+    #  end
+    #  h    
+    #end
+
+
+    ######################################################
+    def site_index_hash
+      h = {
+        'title' => "#{@settings[:product_revision]}",
+        'author' => @settings[:author],
+        'email' => @settings[:email],
+        'created_at' => "#{Date.today.day} #{Date::MONTHNAMES[Date.today.month]} #{Date.today.year}",
+        'description' =>  "#{@settings[:product_revision]} documentation",
+        'doc_type'  => "Site Index",
+        'layout' =>  "tools_doc",
+        'filter' => ['erb', 'textile']
+      }
+    end
+
+
+
+    def write_site_index_header(f)
+      YAML.dump(site_index_hash, f)
+      f.puts '---'
+      f.puts "h3. Projects\n\n"
+      f.puts "table(d1)."
+      f.puts "|_(projname). Project Name |_(projauth). Author|_(projdate). Created|\n\n"
+    end
+
+
+
+    def write_header_to_site_index(f,hash)
+      unless hash.nil?
+        if hash.has_key?('description') && (!hash['description'].nil?)
+
+          doc_link = File.join(hash['title'],'index.html')
+          f.puts 'table(d1).'
+          f.puts "|(projname). \"#{hash['title']}\":#{doc_link} |(projauth). \"#{hash['author']}\":mailto:#{hash['email']} |(projdate). #{hash['created_at']}|"
+          f.puts '|\3(projdesc). '+ hash['description'] +'|'
+          f.puts "\n\n"
+        else
+          "WARNING: Problem with description for #{hash['title']}. Please check header in #{f}"
+        end
+      end
+    end
+
+
+    # List of documentation objects
+    ##############################################
+    def doc_objects
+      arr = Array.new
+      FileList.new('**/target.yml').each do |path|
+        path = File.join(@settings[:root],path)
+        h = YAML::load_file(path)
+        if h.has_key?('templates')
+          if (h['templates']).kind_of?(Array) 
+            if h['templates'].include?('doc')   
+              index_file = File.join(File.dirname(path) , 'doc/content/index.txt')
+              if File.exists?(index_file)
+                arr << YAML::load_file(index_file )
+              end
+            end
+          end
+        end
+      end
+      arr.sort! {|x,y| x['title'] <=> y['title'] }
+    end
+    ##############################################
+
+    def write_site_index
+      File.open(@settings[:full_site_index_file] , 'w') do |f|
+        self.write_site_index_header(f)
+        doc_objects.each do |hash| 
+          write_header_to_site_index(f,hash)
+        end
+      end
+    end
+
+    # if a command exists to do the conversion - make a file task for each of icon and out_icon 
+    # that is - one for the hypershade and one for the outliner
+    def doc_instance_tasks
+
+      namespace @settings[:name].to_sym do 
+        namespace :doc do
+
+          desc "build documentation for #{@settings[:name]}"
+          task :rebuild  do
+
+            write_site_index if @settings[:name] == 'jRelease'
+            puts "doc_dir #{doc_dir}"
+            Dir.chdir(doc_dir) do |d|
+              sh "webby rebuild"
+            end
+          end
+
+
+          desc "release documentation for #{@settings[:name]}"
+          task :release  => "#{@settings[:name].to_sym}:doc:rebuild"  do
+            # release_doc
+            Dir.chdir(@settings[:target_dir]) do |d|
+              self.copy_to_release_dir
+            end
+
+            if (@settings[:name] == "jRelease" )
+              index = File.join( self.release_dir, 'site_index.html' )
+             # rel_notes = File.join(@settings[:versioned_os_release_path], 'doc',@settings[:name],'release_notes.html' )
+              css = File.join(self.release_dir,'css' )
+              images = File.join(self.release_dir,'images' )
+              dest = File.join(@settings[:doc_release_root],'' )
+              mv index , dest 
+             # mv rel_notes , dest 
+             cp_r css , dest 
+             cp_r images , dest
+            end
+
+          end
+
+          desc "clobber documentation for #{@settings[:name]}"      
+          task :clobber do
+            Dir.chdir(doc_dir) do |d|
+              sh "webby clobber"
+            end
+            # d = self.release_dir
+            rm_rf self.release_dir if File.exists? self.release_dir
+          end
+
+
+
+
+
+
+          desc "initialize a project for documenation"    
+          task :init do
+            doc_dir = File.join(@settings[:target_dir],"doc")
+            flak_doc_dir = File.join(@settings[:root],"flak","doc")
+            index_erb_file = File.join(flak_doc_dir,"erb","index.txt.erb")
+            index_destination_file = File.join(content_dir,"index.txt")
+            
+            
+            FileUtils.mkdir_p doc_dir
+
+            Dir.chdir(doc_dir) do
+              Flak.copy_over File.join(flak_doc_dir,"Sitefile"), File.join(Dir.pwd, "Sitefile")
+              Flak.copy_over File.join(flak_doc_dir,"lib"), File.join(Dir.pwd, "lib")
+              Flak.copy_over File.join(flak_doc_dir,"tasks"), File.join(Dir.pwd, "tasks")
+              FileUtils.mkdir_p ["content","layouts","output","scenes"]
+              Dir.chdir("content") do
+                FileUtils.mkdir_p ["css","images","media"]
+                Dir.chdir("css") do
+                  Flak.copy_over File.join(flak_doc_dir,"content/css/page.css"), File.join(Dir.pwd, "page.css")
+                end
+                Dir.chdir("images") do
+                  [ "array.gif" , "connectable.gif" , "create.gif","edit.gif","forkme_right_red_aa0000.png","hidden.gif","input.gif","jToolsSnapon.jpg" ,"keyable.gif","logo.jpg","multiuse.gif","output.gif","query.gif","storable.gif","vfxoverflow_ribbon.png" ].each do |img|
+  #puts "******************"
+                    #puts File.exists?  File.join(flak_doc_dir,"content/images/",img)
+                   # puts Dir.pwd
+                  #  puts File.exists? img
+                    
+                    Flak.copy_over File.join(flak_doc_dir,"content/images/",img)  , File.join(Dir.pwd, img)
+                  end      
+                end
+              end
+              Dir.chdir("layouts") do
+                Flak.copy_over File.join(flak_doc_dir,"layouts/tools_doc.html"),  File.join(Dir.pwd, "tools_doc.html")
+              end
+
+              # make the index
+
+              write_erb_template(index_erb_file,index_destination_file, {:no_force => true}) 
+
+            end
+          end   
+
+        # desc "create index.txt with common textile markup examples"    
+        # task :create_skeleton_index =>  "#{@settings[:name].to_sym}:doc:create_doc_links" do
+        #     write_erb_template(index_erb_file,index_destination_file) 
+        # end
+        # 
+        # desc "initialize a project for documenation"    
+        # task :init =>  "#{@settings[:name].to_sym}:doc:create_skeleton_index" 
+
+
+        end
+      end
+
+
+      task :doc => "#{@settings[:name].to_sym}:doc:release"    
+
+      namespace :doc do
+        task :clobber => "#{@settings[:name].to_sym}:doc:clobber" 
+      end
+
+    end
+    ################################################################################
+
+
+    desc "release all documentation"
+    task :doc   
+
+    desc "clobber all documentation"   
+    namespace :doc do
+      task :clobber 
+    end
+  end
+end
+

data/lib/flak/gl.rb

@@ -0,0 +1,10 @@
+
+
+module Flak 
+  module Gl
+    def self.resolve_settings( existing_settings )
+      f = existing_settings[:root] + '/config/gl.yml' 
+      Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+    end
+  end
+end

data/lib/flak/mac.rb

@@ -0,0 +1,23 @@
+
+
+
+module Flak
+
+  module Mac
+
+
+    def self.resolve_settings( existing_settings )
+
+      f = existing_settings[:root] + '/config/mac.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+
+      h
+    end
+
+    def mac_app_release_path(file)     
+      File.join(@settings[:versioned_os_release_path], 'bin', "#{file.pathmap('%f').pathmap('%X')}-#{@settings[:product_revision]}#{file.pathmap('%x')}")   
+    end
+
+  end
+end
+

data/lib/flak/max.rb

@@ -0,0 +1,29 @@
+
+
+
+module Flak
+
+  module Max
+
+    def self.resolve_settings( existing_settings )
+
+      f = existing_settings[:root] + '/config/max.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+
+      case existing_settings[:os]
+      when /linux_64/ 
+        h[:nuke_location] = ""
+      when /darwin/
+        h[:nuke_location] = ""
+      when /win_64/
+        h[:nuke_location] = ""
+      end
+      h
+    end
+
+    def max_script_release_path(file)
+      File.join(@settings[:versioned_os_release_path], 'max', 'scripts', file.pathmap('%f'))
+    end
+  end
+end
+