linecook 0.6.2 → 1.0.0

data/lib/linecook/cookbook.rb

@@ -1,18 +1,26 @@
-require 'linecook/package'
-require 'yaml'
+require 'linecook/utils'
+require 'lazydoc'
 
 module Linecook
   class Cookbook
     class << self
-      def config_file(dir)
-        Dir.glob(File.join(dir, '{C,c}ookbook')).first
+      def config_file(project_dir='.')
+        Dir.glob(File.join(project_dir, '{C,c}ookbook')).first
       end
+      
+      def setup(config={}, project_dir='.')
+        unless config.kind_of?(Hash)
+          config = Utils.load_config(config)
+        end
         
-      def init(dir)
-        path   = config_file(dir)
-        config = path ? YAML.load_file(path) : nil
+        config[PATHS_KEY] ||= [project_dir]
+        config[GEMS_KEY]  ||= gems
         
-        new(dir, config || {})
+        new(config, project_dir)
+      end
+      
+      def init(project_dir='.')
+        setup config_file(project_dir), project_dir
       end
       
       def gems
@@ -26,65 +34,44 @@ module Linecook
       end
     end
     
-    PATTERNS  = [
-      File.join('attributes', '**', '*.rb'),
-      File.join('files',      '**', '*'),
-      File.join('recipes',    '**', '*.rb'),
-      File.join('templates',  '**', '*.erb')
-    ]
+    MANIFEST_KEY  = 'manifest'
+    PATHS_KEY     = 'paths'
+    GEMS_KEY      = 'gems'
+    REWRITE_KEY   = 'rewrite'
+    
+    PATTERNS  = {
+      'attributes' => ['attributes', '.rb'],
+      'files'      => ['files'],
+      'recipes'    => ['recipes', '.rb'],
+      'templates'  => ['templates', '.erb']
+    }
     
-    attr_reader :dir
+    attr_reader :project_dir
     attr_reader :config
     
-    def initialize(dir='.', config={})
-      @dir = File.expand_path(dir)
-      @config = {
-         'manifest' => {},
-         'paths'    => ['.'],
-         'gems'     => self.class.gems
-       }.merge(config)
+    def initialize(config={}, project_dir='.')
+      @project_dir = project_dir
+      @config = config
     end
     
-    def manifest
-      @manifest ||= begin
-        manifest  = {}
-        
-        paths = split config['paths']
-        gems  = split config['gems']
-        gems  = resolve gems
-        
-        (gems + paths).each do |path|
-          path  = File.expand_path(path, dir)
-          start = path.length + 1
-          
-          PATTERNS.each do |pattern|
-            Dir.glob(File.join(path, pattern)).each do |full_path|
-              next unless File.file?(full_path)
-              
-              rel_path = full_path[start, full_path.length - start]
-              manifest[rel_path] = full_path
-            end
-          end
-        end
-        
-        overrides = config['manifest']
-        manifest.merge!(overrides)
-        manifest
-      end
+    def paths
+      Utils.arrayify config[PATHS_KEY]
     end
     
-    def env(path=nil)
-      Package.env(manifest, path)
+    def gems
+      Utils.arrayify config[GEMS_KEY]
     end
     
-    private
+    def rewrites
+      config[REWRITE_KEY]
+    end
     
-    def split(str) # :nodoc:
-      str.kind_of?(String) ? str.split(':') : str
+    def overrides
+      config[MANIFEST_KEY]
     end
     
-    def resolve(gems) # :nodoc:
-      return gems if gems.empty?
+    def full_gem_paths
+      return [] if gems.empty?
       specs = latest_specs
       
       gems.collect do |name| 
@@ -93,6 +80,76 @@ module Linecook
       end
     end
     
+    def rewrite(manifest)
+      replacements = {}
+      
+      rewrites.each_pair do |pattern, substitution|
+        manifest.keys.each do |key|
+          replacement = key.sub(pattern, substitution)
+          next if key == replacement
+          raise "multiple replacements for: #{key}" if replacements.has_key?(key)
+          
+          replacements[key] = replacement
+        end
+      end if rewrites
+      
+      replacements.each do |key, replacement|
+        manifest[replacement] = manifest.delete(key)
+      end
+      
+      manifest
+    end
+    
+    def glob(*paths)
+      manifest = Hash.new {|hash, key| hash[key] = {} }
+      
+      paths.each do |path|
+        PATTERNS.each_pair do |type, (dirname, extname)|
+          resource_dir = File.expand_path(File.join(path, dirname), project_dir)
+          
+          pattern = File.join(resource_dir, "**/*#{extname}")
+          
+          Dir.glob(pattern).each do |full_path|
+            next unless File.file?(full_path)
+            
+            name = relative_path(resource_dir, full_path)
+            name.chomp!(extname) if extname
+            
+            manifest[type][name] = full_path
+          end
+        end
+      end
+      
+      manifest
+    end
+    
+    def manifest
+      manifest = glob(*(full_gem_paths + paths))
+      
+      if overrides
+        manifest = Utils.deep_merge(manifest, overrides)
+      end
+      
+      manifest.each_key do |key|
+        manifest[key] = rewrite manifest[key]
+      end
+      
+      manifest
+    end
+    
+    def merge(config={})
+      duplicate = dup
+      dup.config.merge!(config)
+      dup
+    end
+    
+    private
+    
+    def relative_path(dir, path) # :nodoc:
+      start = dir.length + 1
+      path[start, path.length - start]
+    end
+    
     def latest_specs # :nodoc:
       latest = {}
       Gem.source_index.latest_specs.each do |spec|

data/lib/linecook/package.rb

@@ -1,137 +1,344 @@
-require 'linecook/utils'
+require 'linecook/cookbook'
+require 'linecook/recipe'
+require 'linecook/template'
 require 'tempfile'
 
 module Linecook
   class Package
     class << self
-      def load_env(path)
-        (path ? YAML.load_file(path) : nil) || {}
-      end
-      
-      def env(manifest, path)
-        default   = {CONFIG_KEY => {MANIFEST_KEY => manifest}}
-        overrides = load_env(path)
-        Utils.serial_merge(default, overrides)
+      def setup(env, cookbook=nil)
+        unless env.kind_of?(Hash)
+          env = Utils.load_config(env)
+        end
+        
+        package = new(env)
+        
+        if cookbook
+          manifest = package.manifest
+          manifest.replace cookbook.manifest
+        end
+        
+        package
       end
       
-      def init(env={})
-        env.kind_of?(Package) ? env : new(env)
+      def init(package_file=nil, project_dir=nil)
+        cookbook = Cookbook.init(project_dir)
+        package  = setup(package_file, cookbook)
+        
+        if package_file
+          package.context[PACKAGE_KEY] ||= begin
+            name = File.basename(package_file).chomp(File.extname(package_file)) 
+            {'recipes' => { 'run' => name }}
+          end
+        end
+        
+        package
       end
     end
     
-    CONFIG_KEY    = 'linecook'
+    CONTEXT_KEY   = 'linecook'
+    COOKBOOK_KEY  = 'cookbook'
     MANIFEST_KEY  = 'manifest'
+    PACKAGE_KEY   = 'package'
     REGISTRY_KEY  = 'registry'
-    CACHE_KEY     = 'cache'
+    
     FILES_KEY     = 'files'
     TEMPLATES_KEY = 'templates'
     RECIPES_KEY   = 'recipes'
-    PATHS_KEY     = 'paths'
-    GEMS_KEY      = 'gems'
     
+    # The package environment
     attr_reader :env
     
+    # An array of tempfiles generated by self (used to cleanup on close)
+    attr_reader :tempfiles
+    
+    # A hash of counters used by variable.
+    attr_reader :counters
+    
+    # A hash of callbacks registered with self
+    attr_reader :callbacks
+    
     def initialize(env={})
       @env = env
+      @tempfiles = []
+      @counters  = Hash.new(0)
+      @callbacks = Hash.new {|hash, key| hash[key] = StringIO.new }
     end
     
-    def config
-      env[CONFIG_KEY] ||= {}
-    end
-    
-    def cache
-      config[CACHE_KEY] ||= {}
+    # Returns the linecook context in env, as keyed by CONTEXT_KEY. Defaults
+    # to an empty hash.
+    def context
+      env[CONTEXT_KEY] ||= {}
     end
     
+    # Returns the manifest in config, as keyed by MANIFEST_KEY. Defaults to an
+    # empty hash.
     def manifest
-      config[MANIFEST_KEY] ||= {}
+      context[MANIFEST_KEY] ||= {}
     end
     
+    # Returns the registry in config, as keyed by REGISTRY_KEY. Defaults to an
+    # empty hash.  A hash of (target_name, source_path) pairs identifying
+    # files that should be included in a package
     def registry
-      config[REGISTRY_KEY] ||= {}
+      context[REGISTRY_KEY] ||= {}
     end
     
-    def reverse_registry
-      cache[:reverse_registry] ||= {}
+    # Returns the linecook configs in env, as keyed by CONFIG_KEY.  Defaults
+    # to an empty hash.
+    def config
+      context[PACKAGE_KEY] ||= {}
     end
     
-    def tempfiles
-      cache[:tempfiles] ||= []
+    # Returns the hash of (source, target) pairs identifying which of the
+    # files will be built into self by build.  Files are identified by
+    # FILES_KEY in config, and normalized the same way as recipes.
+    def files
+      config[FILES_KEY] = Utils.hashify(config[FILES_KEY])
     end
     
-    def register(source_path, build_path=nil)
+    # Returns the hash of (source, target) pairs identifying which templates
+    # will be built into self by build. Templates are identified by
+    # TEMPLATES_KEY in config, and normalized the same way as recipes.
+    def templates
+      config[TEMPLATES_KEY] = Utils.hashify(config[TEMPLATES_KEY])
+    end
+    
+    # Returns the hash of (source, target) pairs identifying which recipes
+    # will be built into self by build.  Recipes are identified by RECIPES_KEY
+    # in config.
+    #
+    # Non-hash recipes are normalized by expanding arrays into a redundant
+    # hash, such that each entry has the same source and target (more
+    # concretely, the 'example' recipe is registered as the 'example' script).
+    # Strings are split along colons into an array and then expanded.
+    #
+    # For example:
+    #
+    #   package = Package.new('linecook' => {'package' => {'recipes' => 'a:b:c'}})
+    #   package.recipes   # => {'a' => 'a', 'b' => 'b', 'c' => 'c'}
+    #
+    def recipes
+      config[RECIPES_KEY] = Utils.hashify(config[RECIPES_KEY])
+    end
+    
+    # Registers the source_path to target_name in the registry and
+    # revese_registry.  Raises an error if the source_path is already
+    # registered.
+    def register(target_name, source_path, mode=0600)
       source_path = File.expand_path(source_path)
-      build_path ||= File.basename(source_path)
       
+      if registry.has_key?(target_name) && registry[target_name] != [source_path, mode]
+        raise "already registered: #{target_name} (%s, %o)" % registry[target_name]
+      end
+      
+      registry[target_name] = [source_path, mode]
+      target_name
+    end
+    
+    # Increments target_name until an unregistered name is found and returns
+    # the result.
+    def next_target_name(target_name='file')
       count = 0
-      registry.each_key do |path|
-        if path.kind_of?(String) && path.index(build_path) == 0
+      registry.each_key do |key|
+        if key.index(target_name) == 0
           count += 1
         end
       end
       
       if count > 0
-        build_path = "#{build_path}.#{count}"
+        target_name = "#{target_name}.#{count}"
       end
       
-      registry[build_path] = source_path
-      reverse_registry[source_path.to_sym] = build_path
+      target_name
+    end
+    
+    # Returns a package-unique variable with base 'name'.
+    def next_variable_name(context)
+      context = context.to_s
       
-      build_path
+      count = counters[context]
+      counters[context] += 1
+      
+      "#{context}#{count}"
     end
     
-    def registered?(source_path)
-      source_path = File.expand_path(source_path)
-      reverse_registry.has_key?(source_path.to_sym)
+    # Returns true if there is a path for the specified resource in manifest.
+    def resource?(type, path)
+      resources = manifest[type]
+      resources && resources.has_key?(path)
+    end
+    
+    # Returns the path to the resource in manfiest.  Raises an error if there
+    # is no such resource.
+    def resource_path(type, path)
+      resources = manifest[type]
+      resource_path = resources ? resources[path] : nil
+      resource_path or raise "no such resource in manifest: #{type.inspect} #{path.inspect}"
+    end
+    
+    # Returns the resource_path the named attributes file (ex 'attributes/name.rb').
+    def attributes_path(attributes_name)
+      resource_path('attributes', attributes_name)
+    end
+    
+    # Returns the resource_path the named file (ex 'files/name')
+    def file_path(file_name)
+      resource_path('files', file_name)
+    end
+    
+    # Returns the resource_path the named template file (ex 'templates/name.erb').
+    def template_path(template_name)
+      resource_path('templates', template_name)
     end
     
-    def built?(build_path)
-      registry.has_key?(build_path)
+    # Returns the resource_path the named recipe file (ex 'recipes/name.rb').
+    def recipe_path(recipe_name)
+      resource_path('recipes', recipe_name)
     end
     
+    # Loads the attributes file with the specified name and evaluates in the
+    # context of Attributes.  Returns the new Attributes object.
+    def load_attributes(attributes_name=nil)
+      attributes = Attributes.new
+      
+      if attributes_name
+        path = attributes_path(attributes_name)
+        attributes.instance_eval(File.read(path), path)
+      end
+      
+      attributes
+    end
+    
+    # Load the template file with the specified name and wraps as a Template. 
+    # Returns the new Template object.
+    def load_template(template_name)
+      Template.new template_path(template_name)
+    end
+    
+    # Loads and returns the helper constant specified by helper_name.  The
+    # helper_name is underscored to determine a require path and camelized to
+    # determine the constant name.
+    def load_helper(helper_name)
+      require Utils.underscore(helper_name)
+      Utils.constantize(helper_name)
+    end
+    
+    # Returns a recipe bound to self.
+    def setup_recipe(target_name = next_target_name, mode=0700)
+      Recipe.new(self, target_name, mode)
+    end
+    
+    # Generates a tempfile for the target path and registers it with self. As
+    # with register, the target_name will be incremented as needed.  Returns
+    # the open tempfile.
+    def setup_tempfile(target_name = next_target_name, mode=0600)
+      tempfile = Tempfile.new File.basename(target_name)
+      
+      register(target_name, tempfile.path, mode)
+      tempfiles << tempfile
+      
+      tempfile
+    end
+    
+    # Returns true if the source_path is for a tempfile generated by self.
     def tempfile?(source_path)
-      tempfiles.find {|tempfile| tempfile.path == source_path }
+      tempfiles.any? {|tempfile| tempfile.path == source_path }
     end
     
-    def build(build_path, source_path=nil)
-      case
-      when built?(build_path)
-        raise "already built: #{build_path}"
-        
-      when source_path
-        register(source_path, build_path)
-        
-      else
-        tempfile = Tempfile.new File.basename(build_path)
-
-        register(tempfile.path, build_path)
-        tempfiles << tempfile
-
-        tempfile
+    # Looks up the file with the specified name using file_path and registers
+    # it to target_name.  Raises an error if the target is already registered.
+    def build_file(target_name, file_name=target_name, mode=0600)
+      register target_name, file_path(file_name), mode
+      self
+    end
+    
+    # Looks up the template with the specified name using template_path,
+    # builds, and registers it to target_name.  The locals will be set for
+    # access in the template context.  Raises an error if the target is
+    # already registered. Returns self.
+    def build_template(target_name, template_name=target_name, mode=0600, locals={'attrs' => env})
+      content = load_template(template_name).build(locals)
+      
+      target = setup_tempfile(target_name, mode)
+      target << content
+      target.close
+      self
+    end
+    
+    # Looks up the recipe with the specified name using recipe_path, evaluates
+    # it, and registers the result to target_name.  Raises an error if the
+    # target is already registered. Returns self.
+    def build_recipe(target_name, recipe_name=target_name, mode=0700)
+      path = recipe_path(recipe_name)
+      recipe = setup_recipe(target_name, mode)
+      recipe.instance_eval(File.read(path), path)
+      recipe.close
+      
+      self
+    end
+    
+    # Builds the files, templates, and recipes for self.  Returns self.
+    def build
+      files.each do |target_name, file_name|
+        build_file(target_name, *file_name)
+      end
+      
+      templates.each do |target_name, template_name|
+        build_template(target_name, *template_name)
+      end
+      
+      recipes.each do |target_name, recipe_name|
+        build_recipe(target_name, *recipe_name)
       end
+      
+      self
     end
     
-    def build_path(source_path)
-      source_path = File.expand_path(source_path)
-      reverse_registry[source_path.to_sym]
+    # Returns the content of the source_path for target_name, as registered in
+    # self.  Returns nil if the target is not registered.
+    def content(target_name, length=nil, offset=nil)
+      path = source_path(target_name)
+      path ? File.read(path, length, offset) : nil
     end
     
-    def source_path(build_path)
-      registry[build_path]
+    # Returns the source_path for target_name, as registered in self.  Returns
+    # nil if the target is not registered.
+    def source_path(target_name)
+      entry = registry[target_name]
+      entry ? entry[0] : nil
     end
     
-    def files
-      normalize(FILES_KEY)
+    # Returns the mode for target_name, as registered in self.  Returns nil if
+    # the target is not registered.
+    def mode(target_name)
+      entry = registry[target_name]
+      entry ? entry[1] : nil
     end
     
-    def templates
-      normalize(TEMPLATES_KEY)
+    # Closes all tempfiles and returns self.
+    def close
+      tempfiles.each do |tempfile|
+        tempfile.close unless tempfile.closed?
+      end
+      self
     end
     
-    def recipes
-      normalize(RECIPES_KEY)
+    # Closes and clears all tempfiles, the registry, callbacks, and counters.
+    def reset
+      close
+      registry.clear
+      tempfiles.clear
+      callbacks.clear
+      counters.clear
+      self
     end
     
+    # Closes self and exports the registry to dir by copying or moving the
+    # registered source paths to the target path under dir.  By default
+    # tempfiles are moved while all other files are copied.
+    #
+    # Returns registry, which is re-written to reflect the new source paths.
     def export(dir, options={})
       close
       
@@ -141,57 +348,34 @@ module Linecook
       
       allow_move = options[:allow_move]
       
-      results = {}
-      registry.each_pair do |build_path, source_path|
-        target_path = File.join(dir, build_path)
-        target_dir  = File.dirname(target_path)
+      if File.exists?(dir)
+        FileUtils.rm_r(dir)
+      end
+      
+      registry.each_key do |target_name|
+        export_path = File.join(dir, target_name)
+        export_dir  = File.dirname(export_path)
+        source_path, mode = registry[target_name]
+        
+        next if source_path == export_path
         
-        unless File.exists?(target_dir)
-          FileUtils.mkdir_p(target_dir)
+        unless File.exists?(export_dir)
+          FileUtils.mkdir_p(export_dir)
         end
         
         if allow_move && tempfile?(source_path)
-          FileUtils.mv(source_path, target_path)
+          FileUtils.mv(source_path, export_path)
         else
-          FileUtils.cp(source_path, target_path)
+          FileUtils.cp(source_path, export_path)
         end
         
-        results[build_path] = target_path
-      end
-      results
-    end
-    
-    def close
-      tempfiles.each do |tempfile|
-        tempfile.close unless tempfile.closed?
-      end
-      self
-    end
-    
-    private
-    
-    def normalize(key)
-      obj = config[key]
-      
-      case obj
-      when Hash
-        obj
-        
-      when nil
-        config[key] = {}
+        FileUtils.chmod(mode, export_path)
         
-      when Array
-        hash = {}
-        obj.each {|entry| hash[entry] = entry }
-        config[key] = hash
-      
-      when String
-        config[key] = obj.split(':')
-        normalize(key)
-      
-      else
-        raise "invalid #{key}: #{obj.inspect}"
+        registry[target_name] = [export_path, mode]
       end
+      
+      tempfiles.clear
+      registry
     end
   end
 end