flak 0.0.1

data/lib/flak/maya.rb

@@ -0,0 +1,142 @@
+
+
+
+module Flak
+
+  module Maya
+
+
+    def self.resolve_settings( existing_settings )
+
+      f = existing_settings[:root] + '/config/maya.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+
+      maya_string =''
+      case existing_settings[:os]
+      when /linux_64/ 
+        maya_string = "maya#{h[:maya_version]}-x64"
+      when /darwin/
+        maya_string = "maya#{h[:maya_version]}"
+      when /win_64/
+        maya_string = "Maya#{h[:maya_version]}"
+      end
+      
+      h[:maya_location] = File.join(h[:autodesk_location],maya_string)
+      h[:maya_release_path] = File.join(existing_settings[:versioned_os_release_path],'maya' )
+      h
+    end
+
+
+    def maya_script_release_path(file)
+      File.join(@settings[:maya_release_path] , 'scripts', file.pathmap('%f'))
+    end
+
+    def maya_icon_release_path(file)
+      File.join(@settings[:maya_release_path] ,'icons', file.pathmap('%f'))   
+    end
+
+    def maya_scripted_plugin_release_path(file)
+      File.join(@settings[:maya_release_path] , 'plug-ins' , file.pathmap('%f'))
+    end
+
+    def maya_precompiled_plugin_release_path(file)
+      File.join(@settings[:maya_release_path] , 'plug-ins' , file.pathmap('%f'))
+    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 maya_instance_tasks
+      namespace @settings[:name].to_sym do     
+        
+        
+        if ( @settings.has_key?(:dg_convert_cmd ) && @settings.has_key?(:outliner_convert_cmd ) )
+          files = @settings[:maya_node_icon_files]
+          unless files.nil?
+
+            # file tasks to convert icons for outliner and hypershade
+            ######################################################    
+            files.each do |f|
+
+              icon_release = File.join(@settings[:maya_release_path] , 'icons', f.pathmap('%f').ext('xpm'))   
+              out_icon_release = File.join(@settings[:maya_release_path] , 'icons', "out_#{f.pathmap('%f').ext('xpm')}" )   
+
+              icon = File.join("build", @settings[:product_revision] , 'icons', f.pathmap('%f').ext('xpm'))  
+              out_icon =  File.join("build", @settings[:product_revision], 'icons', "out_#{f.pathmap('%f').ext('xpm')}" )  
+
+
+              file icon => f do |t|
+                Flak.make_dir_for(icon)
+                cmd = "#{@settings[:dg_convert_cmd]} #{f} #{icon}"
+                sh cmd
+              end
+
+              # dry this up
+              file out_icon => f do |t|
+                Flak.make_dir_for(out_icon)
+                cmd = "#{@settings[:outliner_convert_cmd]} #{f} #{out_icon}"
+                sh cmd
+              end
+
+              file icon_release => icon do |t|
+                Flak.make_dir_for(icon_release)
+                cp icon, icon_release 
+              end         
+
+              file out_icon_release => out_icon do |t|
+                Flak.make_dir_for(out_icon_release)
+                cp out_icon, out_icon_release 
+              end
+
+              task :release =>[ icon_release , out_icon_release]
+            end
+            ######################################################
+          end
+        end
+        
+        
+        
+        if ( @settings.has_key?(:maya_convert_cmd ) )
+          files = @settings[:maya_icon_files]
+          unless files.nil?
+
+            # file tasks to convert icons for outliner and hypershade
+            ######################################################    
+            files.each do |f|
+
+              icon_release = File.join(@settings[:maya_release_path] , 'icons', f.pathmap('%f').ext('xpm'))   
+
+              icon = File.join("build", @settings[:product_revision] , 'icons', f.pathmap('%f').ext('xpm'))  
+              
+
+              file icon => f do |t|
+                Flak.make_dir_for(icon)
+                cmd = "#{@settings[:maya_convert_cmd]} #{f} #{icon}"
+                sh cmd
+              end
+
+
+              file icon_release => icon do |t|
+                Flak.make_dir_for(icon_release)
+                cp icon, icon_release 
+              end         
+
+  
+              task :release =>[ icon_release ]
+            end
+            ######################################################
+          end
+        end
+        
+        
+      end
+    end
+    ################################################################################
+
+
+
+
+  end
+end
+

data/lib/flak/maya_app.rb

@@ -0,0 +1,45 @@
+
+
+module Flak
+
+  module MayaApp
+
+    def self.resolve_settings( existing_settings )
+
+      f = existing_settings[:root] + '/config/maya_app.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+
+      lib_path = File.join(existing_settings[:maya_location], h[:maya_relative_lib_path])
+
+      h[:lib_paths] = [ lib_path ] 
+
+
+        more_linker_opts = []
+      case existing_settings[:os]
+      when /linux_64/ 
+        h[:include_paths] = [ File.join(existing_settings[:maya_location], "include" ) ]  
+        more_linker_opts =  ["-Wl,-rpath,#{lib_path}"]
+      when /darwin/
+        more_linker_opts =  ["-Wl,-executable_path,#{lib_path}"]
+        h[:include_paths] = [ File.join(existing_settings[:maya_location],"devkit", "include" ) ]  
+      when /win_64/
+        h[:include_paths] = [ File.join(existing_settings[:maya_location], "include" ) ]  
+      end
+      
+      h[:linker_options] ||= []
+      h[:linker_options] |= more_linker_opts 
+
+      
+      h[:compiler_options] |=  [
+        "-D\"PLUGIN_VERSION=\\\"#{existing_settings[:product_revision]}\\\"\"",
+        "-D\"PLUGIN_VENDOR=\\\"#{existing_settings[:author_name].gsub(' ','')}\\\"\"",
+        "-D\"MAYA_VERSION=\\\"#{existing_settings[:maya_version]}\\\"\""
+      ]
+
+      h
+    end
+    
+  end
+  
+end
+

data/lib/flak/maya_plugin.rb

@@ -0,0 +1,47 @@
+
+
+module Flak
+
+
+  module MayaPlugin
+
+
+    def self.resolve_settings( existing_settings )
+
+
+     f = existing_settings[:root] + '/config/maya_plugin.yml' 
+      h =Flak.flatten_settings(f,existing_settings[:configuration], existing_settings[:os] )
+        
+
+      lib_path = File.join(existing_settings[:maya_location], h[:maya_relative_lib_path])
+
+      h[:lib_paths] = [ lib_path ] 
+
+      more_linker_opts = []
+      case existing_settings[:os]
+      when /linux_64/ 
+        h[:include_paths] = [ File.join(existing_settings[:maya_location], "include" ) ]  
+        more_linker_opts =  ["-Wl,-rpath,#{lib_path}"]
+      when /darwin/
+        more_linker_opts =  ["-Wl,-executable_path,#{lib_path}"]
+        h[:include_paths] = [ File.join(existing_settings[:maya_location],"devkit", "include" ) ]  
+      when /win_64/
+        h[:include_paths] = [ File.join(existing_settings[:maya_location], "include" ) ]  
+      end
+      
+      h[:linker_options] ||= []
+      h[:linker_options] |= more_linker_opts 
+
+
+      h[:compiler_options] |=  [
+        "-D\"PLUGIN_VERSION=\\\"#{existing_settings[:product_revision]}\\\"\"",
+        "-D\"PLUGIN_VENDOR=\\\"#{existing_settings[:author_name].gsub(' ','')}\\\"\"",
+        "-D\"MAYA_VERSION=\\\"#{existing_settings[:maya_version]}\\\"\""
+      ]
+
+      h
+    end     
+  end
+end
+
+

data/lib/flak/nuke.rb

@@ -0,0 +1,29 @@
+
+
+
+module Flak
+
+  module Nuke
+
+    def self.resolve_settings( existing_settings )
+
+      f = existing_settings[:root] + '/config/nuke.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] = "/Applications/Nuke#{h[:nuke_version]}-32/Nuke#{h[:nuke_version]}.app/Contents"
+      when /win_64/
+        h[:nuke_location] = ""
+      end
+      h
+    end
+
+    def nuke_script_release_path(file)
+      File.join(@settings[:versioned_os_release_path], 'nuke', 'scripts', file.pathmap('%f'))
+    end
+  end
+end
+

data/lib/flak/target.rb

@@ -0,0 +1,120 @@
+
+
+
+
+# This is where we prepare a target. 
+# The target will "inherit" settings and instance methods from modules specified in the target.yml file
+module Flak
+
+  class Target
+
+    attr_accessor :settings
+
+
+
+
+    def initialize(root, target_file=nil)
+
+      @settings = Hash.new
+      # start building the settings hash
+      # need the config settings to bootstrap the process
+      self.extend( Flak )
+      @settings[:root] = root
+      #puts "TTTTTTTTTTTTT #{@settings[:root]}"
+      tmp = YAML::load_file(  @settings[:root]  + '/config/env.yml' )
+      @settings[:configuration] =  tmp['configuration']
+      @settings[:os] =  Flak.os
+
+      # settings goes in as config and os, and comes back fully resolved
+
+      h = Hash.new
+
+      # puts "RRRRRRRRRRRRR #{@settings[:root]}"
+      @settings = Flak.resolve_settings(@settings)
+
+
+      if File.exists?(target_file)
+        @settings[:target_file] =  target_file 
+        @settings[:target_dir] =  File.dirname(target_file) 
+
+      #  puts "TTTTTTTTTTTTT #{@settings[:target_dir]}"
+      #  puts "RRRRRRRRRRRRR #{@settings[:root]}"
+        @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'] || []
+
+        # after integrate templates is done, all the settings in those
+        # templates will be flattened and merged into the settings hash
+        integrate_templates template_array
+      end
+
+      # now merge the settings from this target
+      @settings = Flak.merge_settings(@settings, Target.resolve_settings(@settings))
+
+      expand_filelists
+      instance_tasks
+    end
+
+
+    def self.resolve_settings(existing_settings)
+      Flak.flatten_settings(existing_settings[:target_file], existing_settings[:configuration],existing_settings[:os] )
+    end
+
+
+
+    # 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 below 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
+        self.extend( mod )
+        @settings = Flak.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
+    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
+          end
+        end        
+      end
+    end
+
+  end
+end

data/lib/flak/thor/cli.rb

@@ -0,0 +1,7 @@
+
+module Flak
+  class CLI < Thor
+    map "g" => :generate    
+    register(Generate, 'generate', 'generate <something>', 'Type flak generate for more help.')
+  end
+end

data/lib/flak/thor/generate.rb

@@ -0,0 +1,295 @@
+module Flak
+
+  class Generate < Thor
+
+    TEMPLATES = ["env", "cpp", "delight","gl","mac","maya","maya_app","maya_plugin", "nuke"]
+
+    MAYA_PLUGIN_TEMPLATES = ["cpp", "gl","maya","maya_plugin"]
+
+    MAYA_APP_TEMPLATES = ["cpp", "gl","maya","maya_app"]
+
+    include Thor::Actions
+
+    attr_accessor :name, :tool_options, :project_options
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), "templates")
+    end
+
+    no_tasks do
+
+      def project_wizard
+        opts = Hash.new
+        say("In order to set up paths, I need to know what will be included in this project")
+        opts[:maya_module] = yes?("Will this project contain a Maya module? (y/n)")
+        opts[:delight] = yes?("Will this project contain 3delight tools? (y/n)")
+        opts[:nuke] = yes?("Will this project contain nuke tools? (y/n)")
+        opts
+      end
+
+      def project_options
+        @project_options ||= project_wizard  
+      end
+
+      def project_target_file_hash
+        h = Hash.new
+
+        h['name'] = "FlakProject#{name.camelize}"
+
+        if project_options[:maya_module]
+          # To copy the module mel file that will kick off the whole shebang
+            h['maya_script_copy_files'] = ["config/script/maya/*.mel","config/script/maya/*.py","config/script/maya/*.pyc"]
+            h['maya_script_erb_files'] = ["config/script/maya/erb/*.mel.erb","config/script/maya/erb/*.py.erb"]
+            h['templates'] = ["maya"]
+        end
+
+        h['shell_script_copy_files'] = ["config/script/shell/*.sh"] 
+        h['shell_script_erb_files'] = ["config/script/shell/erb/*.erb"] 
+        h
+      end
+
+    end
+
+
+    desc "project [name]", "Create a project"
+    map "p" => :project    
+    def project(name)
+      empty_directory(name) 
+      inside name do  
+        invoke :config
+      end
+    end
+
+
+    desc "config [name]", "Makes all config and project based files"
+    def config(name)
+      opts = self.project_options
+      self.name= name
+      empty_directory("build") 
+      
+      copy_file("product.mel.tt", "config/script/maya/erb/#{name}.mel.erb")
+      copy_file("INSTALL.tt", "config/script/shell/erb/INSTALL.erb")
+      template("product.sh.tt", "config/script/shell/#{name}.sh")
+
+      create_file  "target.yml" do 
+        YAML::dump( project_target_file_hash )
+      end
+      
+      # templates
+      TEMPLATES.each do |t|
+        template("#{t}.tt", "config/#{t}.yml")
+      end
+      
+      # rakefile
+      template  "Rakefile.tt",  "Rakefile.rb"
+    end
+    
+
+    no_tasks do
+
+      
+      def tool_target_file_hash
+        h = Hash.new
+        maya_c_compile = true if tool_options[:maya_plugin] || tool_options[:maya_app] 
+        c_compile = true if (maya_c_compile  || tool_options[:bin] ) 
+
+        h['name'] = name.camelize
+
+        if tool_options[:maya]
+          h['maya_script_copy_files'] = ["maya/script/**/*.mel","maya/script/**/*.py","maya/script/**/*.pyc"]
+          h['maya_scripted_plugin_copy_files'] = ["maya/script/plugin/**/*.py","maya/script/plugin/**/*.pyc"]
+
+          h['maya_node_icon_files'] = ["maya/icons/node/*"]
+          h['maya_icon_files'] = ["maya/icons/*.jpg"]
+          h['maya_icon_copy_files'] = ["maya/icons/*.png","maya/icons/*.xbm","maya/icons/*.xpm"]
+        end
+
+        h['nuke_script_copy_files'] =  ["nuke/python/*.py", "nuke/gizmo/*.gizmo", "nuke/scenes/*.nk"] if tool_options[:nuke]
+
+        h['include_paths'] = ["../../shared/src"] if c_compile 
+        h['include_paths'] << "../../shared/src/maya" if maya_c_compile
+        h['libs'] = ["OpenMayaAnim","OpenMayaUI","OpenMayaRender","OpenMayaFX"]  if maya_c_compile
+
+        h['templates'] = []
+        h['templates'] << "cpp" if c_compile
+        h['templates'] << "maya" if tool_options[:maya]
+        h['templates'] << "maya_plugin" if tool_options[:maya_plugin]
+        h['templates'] << "maya_app" if  tool_options[:maya_app] 
+        h['templates'] << "gl" if maya_c_compile
+        h['templates'] << "delight" if tool_options[:delight]
+
+        h['source_files'] = []
+        h['source_files'] << "maya/src/*.cpp" if maya_c_compile
+        h['source_files'] << "shell/src/*.cpp" if  tool_options[:bin]
+
+        h['shell_script_copy_files'] = ["shell/script/*"]  if tool_options[:shell]
+        h
+      end
+
+      def tool_wizard
+        opts = Hash.new
+        opts[:all] = yes?("Would you like to create a full project and pare it down later?: ")
+
+        if opts[:all]
+          opts[:maya] = true
+          opts[:maya_plugin] = true
+          opts[:maya_app] = false
+          opts[:delight] = true
+          opts[:shell] = true
+          opts[:bin] = false
+          opts[:applescript] = true
+        else
+
+          opts[:maya] = yes?("Will this tool contain files for Autodesk's Maya? (y/n)")
+          if opts[:maya] # always make scripts for maya projects
+            opts[:maya_plugin] = yes?("Is this tool a Maya plugin? (y/n)")
+            if (! opts[:maya_plugin] )
+              opts[:maya_app] = yes?("Is this tool a Maya standalone application? (y/n)") 
+            end
+          end
+
+          opts[:delight] = yes?("Will this tool contain 3delight shaders filters or DSOs? (y/n)") 
+
+          opts[:nuke] = yes?("Will this tool contain Nuke scripts or plugins? (y/n)") 
+
+          opts[:shell] = yes?("Will this tool contain shell scripts? (y/n)")
+
+          #can only have one target
+          if (! (opts[:maya_plugin] || opts[:maya_app] )) 
+            opts[:bin] = yes?("Will this tool contain a standalone compiled shell command? (y/n)")
+          end
+
+          opts[:applescript] = yes?("Will this tool contain Applescript files? (y/n)") 
+        end
+        opts
+      end
+
+      def tool_options
+        @tool_options ||= tool_wizard  
+      end
+
+
+    end
+
+
+
+    desc "tool [name]", "Make a tool"
+    #method_options  %w( maya_script -s) => :boolean,  %w( maya_app -a)  => :boolean,   %w( maya_plugin -p) => :boolean
+    map "t" => :tool    
+    def tool(name)
+      #  puts "DDD RRR #{destination_root}"
+
+      opts = self.tool_options
+      self.name= name
+
+      create_file  "#{name}/target.yml" do 
+        YAML::dump( tool_target_file_hash )
+      end
+
+      inside name, :verbose => true do 
+
+        invoke :create_common_files
+        invoke :create_maya_tree if opts[:maya]
+        invoke :create_maya_plugin_tree if opts[:maya_plugin]
+        invoke :create_maya_app_tree if opts[:maya_app]
+        invoke :create_nuke_tree if opts[:nuke]
+        invoke :create_applescript_tree if opts[:applescript]
+        invoke :create_delight_tree if opts[:delight]
+        invoke :create_shell_tree if opts[:shell]
+        invoke :create_shell_cmd_tree if opts[:bin]
+      end
+      #end
+    end
+
+
+    #####################################
+    desc "create_common_files [name]", "Makes files that will be in every tool"
+    def create_common_files(name)
+      empty_directory('examples') 
+      empty_directory('doc') 
+      create_file "README.md"
+      create_file "LICENSE.md"
+      create_file "INSTALL.md"
+    end
+    #####################################
+
+
+    #####################################
+    desc "maya_script_tool [name]", "Makes tool files needed for Maya script development"
+    def create_maya_tree(name)
+      self.name= name
+      # create_file "maya/script/#{name}.py"
+       empty_directory("maya/script") 
+      empty_directory("maya/icons/node") 
+    end
+
+    desc "maya_plugin_tool [name]", "Makes tool files needed for Maya plugin development"
+    def create_maya_plugin_tree(name)
+      invoke :create_maya_app_tree
+      create_file "maya/src/plugin.cpp"
+      empty_directory("maya/script/plugin")
+    end
+
+    desc "maya_app_tool [name]", "Makes tool files needed for Maya app development"
+    def create_maya_app_tree(name)
+      invoke :create_maya_tree
+      create_file "maya/src/#{name}.cpp"
+      create_file "maya/src/#{name}.h"
+    end
+    #####################################
+
+    #####################################
+    desc "create_nuke_tree [name]", "Makes tool files needed for Maya script development"
+    def create_nuke_tree(name)
+      empty_directory('nuke/gizmo') 
+      empty_directory('nuke/python') 
+      empty_directory('nuke/scenes')
+    end
+    #####################################
+
+    #####################################
+    desc "create_delight_tree [name]", "Makes tool files needed for Maya script development"
+    def create_delight_tree(name)
+      empty_directory('delight/shader/include') 
+      empty_directory('delight/shader/light') 
+      empty_directory('delight/shader/surface') 
+      empty_directory('delight/dso') 
+      empty_directory('delight/filter') 
+    end
+    #####################################
+
+    #####################################
+    desc "create_applescript_tree [name]", "Makes tool files needed for Maya script development"
+    def create_applescript_tree(name)
+      empty_directory('applescript') 
+    end
+    #####################################
+
+    #####################################
+    desc "create_shell_tree [name]", "Makes tool files needed for Maya script development"
+    def create_shell_tree(name)
+      empty_directory('shell/script') 
+    end
+    #####################################
+
+    #####################################
+    desc "create_shell_cmd_tree [name]", "Makes tool files needed for Maya script development"
+    def create_shell_cmd_tree(name)
+      invoke :create_shell_tree
+      empty_directory('shell/src') 
+    end
+    #####################################
+
+    def self.banner(task, namespace = false, subcommand = true)
+      task.formatted_usage(self, true, subcommand).split(':').join(' ')
+    end
+
+  end
+
+end
+
+
+
+
+
+