linecook 0.6.2

data/lib/linecook/cookbook.rb

@@ -0,0 +1,104 @@
+require 'linecook/package'
+require 'yaml'
+
+module Linecook
+  class Cookbook
+    class << self
+      def config_file(dir)
+        Dir.glob(File.join(dir, '{C,c}ookbook')).first
+      end
+        
+      def init(dir)
+        path   = config_file(dir)
+        config = path ? YAML.load_file(path) : nil
+        
+        new(dir, config || {})
+      end
+      
+      def gems
+        return [] unless Object.const_defined?(:Gem)
+        
+        Gem.source_index.latest_specs.select do |spec|
+          config_file(spec.full_gem_path) != nil
+        end.collect do |spec|
+          spec.name
+        end
+      end
+    end
+    
+    PATTERNS  = [
+      File.join('attributes', '**', '*.rb'),
+      File.join('files',      '**', '*'),
+      File.join('recipes',    '**', '*.rb'),
+      File.join('templates',  '**', '*.erb')
+    ]
+    
+    attr_reader :dir
+    attr_reader :config
+    
+    def initialize(dir='.', config={})
+      @dir = File.expand_path(dir)
+      @config = {
+         'manifest' => {},
+         'paths'    => ['.'],
+         'gems'     => self.class.gems
+       }.merge(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
+    end
+    
+    def env(path=nil)
+      Package.env(manifest, path)
+    end
+    
+    private
+    
+    def split(str) # :nodoc:
+      str.kind_of?(String) ? str.split(':') : str
+    end
+    
+    def resolve(gems) # :nodoc:
+      return gems if gems.empty?
+      specs = latest_specs
+      
+      gems.collect do |name| 
+        spec = specs[name] or raise "no such gem: #{name.inspect}"
+        spec.full_gem_path
+      end
+    end
+    
+    def latest_specs # :nodoc:
+      latest = {}
+      Gem.source_index.latest_specs.each do |spec|
+        latest[spec.name] = spec
+      end
+      latest
+    end
+  end
+end

data/lib/linecook/helper.rb

@@ -0,0 +1,117 @@
+require 'linecook/template'
+
+module Linecook
+  class Helper < Template
+    attr_reader :const_name
+    attr_reader :sources
+    
+    def initialize(const_name, sources)
+      @const_name = const_name
+      @sources    = sources.select {|source| File.file?(source) }
+      @section_paths, @definition_paths = @sources.partition {|path| File.basename(path)[0] == ?_ }
+      super()
+    end
+    
+    def build
+      eval MODULE_TEMPLATE, binding, __FILE__, MODULE_TEMPLATE_LINE
+      result
+    end
+    
+    def sections
+      @sections ||= begin
+        sections = {}
+        
+        @section_paths.each do |path|
+          key = File.basename(path)[1..-1]
+          key.chomp! File.extname(path)
+          sections[key.to_sym] = File.read(path)
+        end
+        
+        sections
+      end
+    end
+    
+    def definitions
+      @definitions ||= @definition_paths.collect do |path|
+        name = File.basename(path).chomp File.extname(path)
+        desc, signature, body = parse File.read(path)
+        
+        eval ERB_TEMPLATE, binding, __FILE__, ERB_TEMPLATE_LINE
+      end
+    end
+    
+    private
+    
+    def parse(str)
+      head, body = str.split(/^--.*\n/, 2)
+      head, body = '', head if body.nil?
+      signature, desc = parse_head(head)
+      
+      [desc.join("\n"), signature.join("\n"), body]
+    end
+    
+    def parse_head(head)
+      found_signature = false
+      head.split("\n").partition do |line|
+        found_signature = true if line =~ /^\s*\(.*?\)/
+        found_signature
+      end
+    end
+    
+    def method_name(name)
+      case name
+      when /_check$/ then name.sub(/_check$/, '?')
+      when /_bang$/  then name.sub(/_bang$/, '!')
+      else name
+      end
+    end
+    
+    def module_nest(const_name, indent="  ", line_sep="\n")
+      nestings = const_name.split(/::/).collect {|name| ["module #{name}", "end"]} 
+      nestings << {:indent => indent, :line_sep => line_sep}
+      
+      nest(*nestings) { yield }
+    end
+    
+    MODULE_TEMPLATE_LINE = __LINE__ + 2
+    MODULE_TEMPLATE = "self." + ERB.new(<<-DOC, nil, '<>').src
+require 'erb'
+<%= sections[:header] %>
+
+# Generated by Linecook, do not edit.
+<% module_nest(const_name, '') do %>
+<%= sections[:head] %>
+<% definitions.each do |definition| %>
+
+<%= definition %>
+<% end %>
+<%= sections[:tail] %>
+<% end %>
+
+<%= sections[:footer] %>
+DOC
+    
+    ERB_TEMPLATE_LINE = __LINE__ + 2
+    ERB_TEMPLATE = ERB.new(<<-DOC, nil, '<>').src
+# :stopdoc:
+<%= name.upcase %>_LINE = __LINE__ + 2
+<%= name.upcase %> = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<%= body %>
+
+END_OF_TEMPLATE
+# :startdoc:
+
+<% desc.each do |line| %>
+# <%= line %>
+<% end %>
+def <%= method_name(name) %><%= signature %>
+  eval(<%= name.upcase %>, binding, __FILE__, <%= name.upcase %>_LINE)
+  nil
+end
+
+def _<%= method_name(name) %>(*args, &block) # :nodoc:
+  capture { <%= method_name(name) %>(*args, &block) }
+end
+DOC
+  end
+end

data/lib/linecook/package.rb

@@ -0,0 +1,197 @@
+require 'linecook/utils'
+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)
+      end
+      
+      def init(env={})
+        env.kind_of?(Package) ? env : new(env)
+      end
+    end
+    
+    CONFIG_KEY    = 'linecook'
+    MANIFEST_KEY  = 'manifest'
+    REGISTRY_KEY  = 'registry'
+    CACHE_KEY     = 'cache'
+    FILES_KEY     = 'files'
+    TEMPLATES_KEY = 'templates'
+    RECIPES_KEY   = 'recipes'
+    PATHS_KEY     = 'paths'
+    GEMS_KEY      = 'gems'
+    
+    attr_reader :env
+    
+    def initialize(env={})
+      @env = env
+    end
+    
+    def config
+      env[CONFIG_KEY] ||= {}
+    end
+    
+    def cache
+      config[CACHE_KEY] ||= {}
+    end
+    
+    def manifest
+      config[MANIFEST_KEY] ||= {}
+    end
+    
+    def registry
+      config[REGISTRY_KEY] ||= {}
+    end
+    
+    def reverse_registry
+      cache[:reverse_registry] ||= {}
+    end
+    
+    def tempfiles
+      cache[:tempfiles] ||= []
+    end
+    
+    def register(source_path, build_path=nil)
+      source_path = File.expand_path(source_path)
+      build_path ||= File.basename(source_path)
+      
+      count = 0
+      registry.each_key do |path|
+        if path.kind_of?(String) && path.index(build_path) == 0
+          count += 1
+        end
+      end
+      
+      if count > 0
+        build_path = "#{build_path}.#{count}"
+      end
+      
+      registry[build_path] = source_path
+      reverse_registry[source_path.to_sym] = build_path
+      
+      build_path
+    end
+    
+    def registered?(source_path)
+      source_path = File.expand_path(source_path)
+      reverse_registry.has_key?(source_path.to_sym)
+    end
+    
+    def built?(build_path)
+      registry.has_key?(build_path)
+    end
+    
+    def tempfile?(source_path)
+      tempfiles.find {|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
+      end
+    end
+    
+    def build_path(source_path)
+      source_path = File.expand_path(source_path)
+      reverse_registry[source_path.to_sym]
+    end
+    
+    def source_path(build_path)
+      registry[build_path]
+    end
+    
+    def files
+      normalize(FILES_KEY)
+    end
+    
+    def templates
+      normalize(TEMPLATES_KEY)
+    end
+    
+    def recipes
+      normalize(RECIPES_KEY)
+    end
+    
+    def export(dir, options={})
+      close
+      
+      options = {
+        :allow_move => true
+      }.merge(options)
+      
+      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)
+        
+        unless File.exists?(target_dir)
+          FileUtils.mkdir_p(target_dir)
+        end
+        
+        if allow_move && tempfile?(source_path)
+          FileUtils.mv(source_path, target_path)
+        else
+          FileUtils.cp(source_path, target_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] = {}
+        
+      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}"
+      end
+    end
+  end
+end

data/lib/linecook/recipe.rb

@@ -0,0 +1,103 @@
+require 'linecook/template'
+require 'linecook/attributes'
+require 'linecook/package'
+require 'linecook/utils'
+
+module Linecook
+  class Recipe < Template
+    class << self
+      def build(env)
+        package = Package.new(env)
+        
+        package.recipes.each do |recipe_name, target_name|
+          new(target_name, env).evaluate(recipe_name)
+        end
+        
+        package.close
+        package
+      end
+    end
+    
+    alias target erbout
+    
+    attr_reader :target_name
+    
+    def initialize(target_name, env={})
+      @target_name = target_name
+      @package     = Package.init(env)
+      @attributes  = Attributes.new(@package.env)
+      @erbout      = @package.build(target_name)
+    end
+    
+    def source_path(*relative_path)
+      path = File.join(*relative_path)
+      @package.manifest[path] or raise "no such file in manifest: #{path.inspect}"
+    end
+    
+    def target_path(source_path)
+      @package.build_path(source_path) ||
+      @package.register(source_path, File.join("#{target_name}.d", File.basename(source_path)))
+    end
+    
+    def target_file(name, content=nil)
+      tempfile = @package.build File.join("#{target_name}.d", name)
+      
+      tempfile << content if content
+      yield(tempfile) if block_given?
+      
+      target_path tempfile.path
+    end
+    
+    def attrs
+      @attributes.current
+    end
+    
+    def attributes(attributes_name)
+      path = source_path('attributes', "#{attributes_name}.rb")
+      
+      @attributes.instance_eval(File.read(path), path)
+      @attributes.reset(false)
+      self
+    end
+    
+    def helpers(helper_name)
+      require Utils.underscore(helper_name)
+      extend Utils.constantize(helper_name)
+    end
+    
+    def evaluate(recipe_name=target_name)
+      path = source_path('recipes', "#{recipe_name}.rb")
+      instance_eval(File.read(path), path)
+      self
+    end
+    
+    def file_path(file_name)
+      path = source_path('files', file_name)
+      target_path path
+    end
+    
+    def capture_path(name, &block)
+      content = capture(false) { instance_eval(&block) }
+      target_file(name, content)
+    end
+    
+    def recipe_path(recipe_name, target_name = recipe_name)
+      source_path = 
+        @package.built?(target_name) ?
+        @package.source_path(target_name) :
+        Recipe.new(target_name, @package).evaluate(recipe_name).target.path
+      
+      target_path source_path
+    end
+    
+    def template_path(template_name, locals={})
+      path = source_path('templates', "#{template_name}.erb")
+      target_file template_name, Template.build(File.read(path), locals, path)
+    end
+    
+    def close
+      @package.close
+      @package.registry
+    end
+  end
+end

data/lib/linecook/shell/posix.rb

@@ -0,0 +1,145 @@
+require 'erb'
+
+# Generated by Linecook, do not edit.
+module Linecook
+module Shell
+module Posix
+# :stopdoc:
+COMMENT_LINE = __LINE__ + 2
+COMMENT = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+# <%= str %>
+END_OF_TEMPLATE
+# :startdoc:
+
+# Writes a comment
+def comment(str)
+  eval(COMMENT, binding, __FILE__, COMMENT_LINE)
+  nil
+end
+
+def _comment(*args, &block) # :nodoc:
+  capture { comment(*args, &block) }
+end
+
+# :stopdoc:
+HEREDOC_LINE = __LINE__ + 2
+HEREDOC = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<<<%= options[:indent] ? '-' : ' '%><%= options[:quote] ? "\"#{delimiter}\"" : delimiter %>
+<% yield %>
+<%= delimiter %>
+
+END_OF_TEMPLATE
+# :startdoc:
+
+# Makes a heredoc statement surrounding the contents of the block.  Options:
+
+# 
+
+#   delimiter   the delimiter used, by default HEREDOC_n where n increments
+
+#   indent      add '-' before the delimiter
+
+#   quote       quotes the delimiter
+
+def heredoc(options={})
+  delimiter = options[:delimiter] || begin
+    @heredoc_count ||= -1
+    "HEREDOC_#{@heredoc_count += 1}"
+  end
+  eval(HEREDOC, binding, __FILE__, HEREDOC_LINE)
+  nil
+end
+
+def _heredoc(*args, &block) # :nodoc:
+  capture { heredoc(*args, &block) }
+end
+
+# :stopdoc:
+NOT_IF_LINE = __LINE__ + 2
+NOT_IF = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+only_if("! #{cmd}", &block)
+END_OF_TEMPLATE
+# :startdoc:
+
+def not_if(cmd, &block)
+  eval(NOT_IF, binding, __FILE__, NOT_IF_LINE)
+  nil
+end
+
+def _not_if(*args, &block) # :nodoc:
+  capture { not_if(*args, &block) }
+end
+
+# :stopdoc:
+ONLY_IF_LINE = __LINE__ + 2
+ONLY_IF = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+if <%= cmd %>
+then
+<% indent { yield } %>
+fi
+
+END_OF_TEMPLATE
+# :startdoc:
+
+def only_if(cmd)
+  eval(ONLY_IF, binding, __FILE__, ONLY_IF_LINE)
+  nil
+end
+
+def _only_if(*args, &block) # :nodoc:
+  capture { only_if(*args, &block) }
+end
+
+# :stopdoc:
+SET_LINE = __LINE__ + 2
+SET = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<% if block_given? %>
+<% reset_file = "LINECOOK_RESET_OPTIONS_#{next_count}" %>
+<%= reset_file %>=`mktemp /tmp/line_cook_reset_fileXXXXXX`
+set -o | sed 's/\(.*\)	on/set -o \1/' | sed 's/\(.*\)	off/set +o \1/' > $<%= reset_file %>
+<% end %><% options.keys.sort_by {|opt| opt.to_s }.each do |opt| %>
+set <%= options[opt] ? '-' : '+' %>o <%= opt %>
+<% end %>
+<% if block_given? %>
+
+<% indent { yield }  %>
+
+source $<%= reset_file %>
+<% end %>
+
+END_OF_TEMPLATE
+# :startdoc:
+
+# Sets bash options for the duration of a block.  If no block is given,
+
+# set simply sets the options as specified.
+def set(options)
+  eval(SET, binding, __FILE__, SET_LINE)
+  nil
+end
+
+def _set(*args, &block) # :nodoc:
+  capture { set(*args, &block) }
+end
+
+# :stopdoc:
+UNSET_LINE = __LINE__ + 2
+UNSET = "self." + ERB.new(<<'END_OF_TEMPLATE', nil, '<>').src
+<% keys.each do |key| %>
+unset <%= key %>
+<% end %>
+END_OF_TEMPLATE
+# :startdoc:
+
+# Unsets a list of variables.
+def unset(*keys)
+  eval(UNSET, binding, __FILE__, UNSET_LINE)
+  nil
+end
+
+def _unset(*args, &block) # :nodoc:
+  capture { unset(*args, &block) }
+end
+end
+end
+end