linecook 1.2.1 → 2.0.0

data/lib/linecook/proxy.rb

@@ -1,19 +1,13 @@
 module Linecook
   # A proxy used to chain method calls back to a recipe.
-  class Proxy
+  class Proxy < BasicObject
     def initialize(recipe)
       @recipe = recipe
     end
-    
-    # Proxies to recipe.chain.
+
+    # Invokes method via recipe.chain.
     def method_missing(*args, &block)
-      @recipe.chain(*args, &block)
-    end
-    
-    # Returns an empty string, such that the proxy makes no text when it is
-    # accidentally put into a target by a helper.
-    def to_s
-      ''
+      @recipe.chain.__send__(*args, &block)
     end
   end
 end

data/lib/linecook/recipe.rb

@@ -1,369 +1,289 @@
-require 'linecook/attributes'
-require 'linecook/proxy'
-require 'linecook/utils'
-require 'erb'
-require 'stringio'
-
-module Linecook
-  # Recipe is the context in which recipes are evaluated (literally).  Recipe
-  # uses compiled ERB snippets to build text using method calls. For example:
-  #
-  #   module Helper
-  #     # This is an ERB template compiled to write to a Recipe.
-  #     #
-  #     #   compiler = ERB::Compiler.new('<>')
-  #     #   compiler.put_cmd = "write"
-  #     #   compiler.insert_cmd = "write"
-  #     #   compiler.compile("echo '<%= args.join(' ') %>'\n")
-  #     #
-  #     def echo(*args)
-  #       write "echo '"; write(( args.join(' ') ).to_s); write "'\n"
-  #     end
-  #   end
-  #
-  #   package = Package.new
-  #   recipe  = package.setup_recipe
-  #
-  #   recipe.extend Helper
-  #   recipe.instance_eval do
-  #     echo 'a', 'b c'
-  #     echo 'X Y'.downcase, :z
-  #   end
-  #
-  #   "\n" + recipe.result
-  #   # => %{
-  #   # echo 'a b c'
-  #   # echo 'x y z'
-  #   # }
-  #
-  class Recipe
-    
-    # The recipe package
-    attr_reader :_package_
-    
-    # The recipe target
-    attr_reader :_target_
-    
-    # The target name of self in package
-    attr_reader :_target_name_
-    
-    # The recipe proxy
-    attr_reader :_proxy_
-    
-    # The current target for self set as needed during captures; equal to
-    # _target_ otherwise.
-    attr_reader :target
-    
-    # The current target_name for self set as needed during captures; equal to
-    # _target_name_ otherwise.
-    attr_reader :target_name
-    
-    def initialize(package, target_name, mode)
-      @_package_     = package
-      @_target_name_ = target_name
-      @_target_      = package.setup_tempfile(target_name, mode)
-      @_proxy_       = Proxy.new(self)
-      
-      @target_name   = @_target_name_
-      @target        = @_target_
-      
-      @chain       = false
-      @attributes  = {}
-      @indents     = []
-      @outdents    = []
-    end
-    
-    # Closes _target_ and returns self.
-    def close
-      unless closed?
-        _target_.close
-      end
-      self
-    end
-    
-    # Closes _target_ and returns self, and unregisters _target_ from the
-    # package.  Useful for recipes that only generate other files.
-    def close!
-      _package_.registry.delete _target_name_
-      close
-    end
-    
-    # Returns true if _target_ is closed.
-    def closed?
-      _target_.closed?
-    end
-    
-    # Returns the current contents of target, or the contents of _target_ if
-    # closed? is true.
-    def result
-      if closed?
-        _package_.content(_target_name_)
-      else
-        target.flush
-        target.rewind
-        target.read
-      end
-    end
-    
-    # Loads the specified attributes file and merges the results into attrs. A
-    # block may be given to specify attrs as well; it will be evaluated in the
-    # context of an Attributes instance.
-    def attributes(attributes_name=nil, &block)
-      attributes = _package_.load_attributes(attributes_name)
-      
-      if block_given?
-        attributes.instance_eval(&block)
-      end
-      
-      @attributes = Utils.deep_merge(@attributes, attributes.to_hash)
-      @attrs = nil
-      self
-    end
-    
-    # Returns the package env merged over any attrs specified by attributes.
-    # The attrs hash should be treated as if it were read-only because changes
-    # could alter the package env and thereby spill over into other recipes.
-    def attrs
-      @attrs ||= Utils.deep_merge(@attributes, _package_.env)
-    end
-    
-    # Looks up and extends self with the specified helper.
-    def helpers(helper_name)
-      extend _package_.load_helper(helper_name)
-    end
-    
-    # Returns an expression that evaluates to the package dir, assuming that
-    # $0 evaluates to the full path to the current recipe.
-    def package_dir
-      "${0%/#{target_name}}"
-    end
-    
-    # The path to the named target as it should be referenced in the final
-    # script, specifically target_name joined to package_dir.
-    def target_path(target_name)
-      File.join(package_dir, target_name)
-    end
-    
-    # Registers the specified file into package and returns the target_path to
-    # the file.
-    def file_path(file_name, target_name=file_name, mode=0600)
-      _package_.build_file(target_name, file_name, mode)
-      target_path target_name
-    end
-    
-    # Looks up, builds, and registers the specified template and returns the
-    # target_path to the resulting file.
-    def template_path(template_name, target_name=template_name.chomp('.erb'), mode=0600, locals={'attrs' => attrs})
-      _package_.build_template(target_name, template_name, mode, locals)
-      target_path target_name
-    end
-    
-    # Looks up, builds, and registers the specified recipe and returns the
-    # target_path to the resulting file.
-    def recipe_path(recipe_name, target_name=recipe_name, mode=0700)
-      _package_.build_recipe(target_name, recipe_name, mode)
-      target_path target_name
-    end
-    
-    # Captures the output for a block, registers it, and returns the
-    # target_path to the resulting file.  The current target and target_name
-    # are updated for the duration of the block.
-    def capture_path(target_name, mode=0600)
-      tempfile = _package_.setup_tempfile(target_name, mode)
-      capture_block(tempfile) do
-        current = @target_name
-        
-        begin
-          @target_name = target_name
-          yield
-        ensure
-          @target_name = current
-        end
-        
-      end
-      tempfile.close
-      
-      target_path target_name
-    end
-    
-    # Captures output to the target for the duration of a block.  Returns the
-    # capture target.
-    def capture_block(target=StringIO.new)
-      current = @target
-
-      begin
-        @target = target
-        yield
-      ensure
-        @target = current
-      end
-
-      target
-    end
-    
-    # Captures and returns output for the duration of a block by redirecting
-    # target to a temporary buffer.
-    def capture_str
-      capture_block { yield }.string
-    end
-    
-    # Writes input to target using 'write'.  Returns self.
-    def write(input)
-      target.write input
-      self
-    end
-    
-    # Writes input to target using 'puts'.  Returns self.
-    def writeln(input)
-      target.puts input
-      self
-    end
-    
-    # Truncates the contents of target starting at the first match of pattern
-    # and returns the resulting match data. If a block is given then rewrite
-    # yields the match data to the block and returns the block result.
-    # 
-    # ==== Notes
-    #
-    # Rewrites can be computationally expensive because they require the
-    # current target to be flushed, rewound, and read in it's entirety.  In
-    # practice the performance of rewrite is almost never an issue because
-    # recipe output is usually small in size.
-    #
-    # If performance becomes an issue, then wrap the rewritten bits in a
-    # capture block to reassign the current target to a StringIO (which is
-    # much faster to rewrite), and to limit the scope of the rewritten text.
-    def rewrite(pattern)
-      if match = pattern.match(result)
-        start = match.begin(0)
-        target.pos = start
-        target.truncate start
-      end
-      
-      block_given? ? yield(match) : match
-    end
-    
-    # Strips whitespace from the end of target and returns the stripped
-    # whitespace, or an empty string if no whitespace is available.
-    def rstrip
-      match = rewrite(/\s+\z/)
-      match ? match[0] : ''
-    end
-    
-    # Indents the output of the block.  Indents may be nested. To prevent a
-    # section from being indented, enclose it within outdent which resets
-    # indentation to nothing for the duration of a block.
-    #
-    # Example:
-    #
-    #   writeln 'a'
-    #   indent do
-    #     writeln 'b'
-    #     outdent do
-    #       writeln 'c'
-    #       indent do
-    #         writeln 'd'
-    #       end
-    #       writeln 'c'
-    #     end
-    #     writeln 'b'
-    #   end
-    #   writeln 'a'
-    #
-    #   "\n" + result
-    #   # => %q{
-    #   # a
-    #   #   b
-    #   # c
-    #   #   d
-    #   # c
-    #   #   b
-    #   # a
-    #   # }
-    #
-    def indent(indent='  ')
-      @indents << @indents.last.to_s + indent
-      str = capture_str { yield }
-      @indents.pop
-
-      unless str.empty?
-        str.gsub!(/^/, indent)
-
-        if @indents.empty?
-          @outdents.each do |flag|
-            str.gsub!(/#{flag}(\d+):(.*?)#{flag}/m) do
-              $2.gsub!(/^.{#{$1.to_i}}/, '')
-            end
-          end
-          @outdents.clear
-        end
-
-        writeln str
-      end
-
-      self
-    end
-
-    # Resets indentation to nothing for a section of text indented by indent.
-    #
-    # === Notes
-    #
-    # Outdent works by setting a text flag around the outdented section; the
-    # flag and indentation is later stripped out using regexps.  For that
-    # reason, be sure flag is not something that will appear anywhere else in
-    # the section.
-    #
-    # The default flag is like ':outdent_N:' where N is a big random number.
-    def outdent(flag=nil)
-      current_indent = @indents.last
-      
-      if current_indent.nil?
-        yield
-      else
-        flag ||= ":outdent_#{rand(10000000)}:"
-        @outdents << flag
-        
-        write "#{flag}#{current_indent.length}:#{rstrip}"
-        @indents << ''
-        
-        yield
-        
-        @indents.pop
-        
-        write "#{flag}#{rstrip}"
-      end
-      
-      self
-    end
-    
-    # Sets chain? to true and calls the method (thereby allowing the method to
-    # invoke chain-specific behavior).  Chain is invoked via the chain_proxy
-    # which is returned by helper methods.
-    def chain(method_name, *args, &block)
-      @chain = true
-      send(method_name, *args, &block)
-    end
-    
-    # Returns true if the current context was invoked through chain.
-    def chain?
-      @chain
-    end
-    
-    # Sets chain to false and returns the proxy.
-    def chain_proxy
-      @chain = false
-      _proxy_
-    end
-    
-    # Captures a block of output and concats to the named callback.
-    def callback(name)
-      target = _package_.callbacks[name]
-      capture_block(target) { yield }
-    end
-    
-    # Writes the specified callback to the current target.
-    def write_callback(name)
-      write _package_.callbacks[name].string
-    end
-  end
-end
+require 'erb'
+require 'tilt'
+require 'linecook/attributes'
+require 'linecook/cookbook'
+require 'linecook/package'
+require 'linecook/utils'
+require 'linecook/proxy'
+
+module Linecook
+  # Recipe is the context in which recipes are evaluated (literally).  Recipe
+  # uses compiled ERB snippets to build text using method calls. For example:
+  #
+  #   module Helper
+  #     # This is an ERB template compiled to write to a Recipe.
+  #     #
+  #     #   compiler = ERB::Compiler.new('<>')
+  #     #   compiler.put_cmd = "write"
+  #     #   compiler.insert_cmd = "write"
+  #     #   compiler.compile("echo '<%= args.join(' ') %>'\n")
+  #     #
+  #     def echo(*args)
+  #       write "echo '"; write(( args.join(' ') ).to_s); write "'\n"
+  #     end
+  #   end
+  #
+  #   recipe = Recipe.new do
+  #     _extend_ Helper
+  #     echo 'a', 'b c'
+  #     echo 'X Y'.downcase, :z
+  #   end
+  #
+  #   "\n" + recipe.to_s
+  #   # => %{
+  #   # echo 'a b c'
+  #   # echo 'x y z'
+  #   # }
+  #
+  class Recipe < BasicObject
+    # The recipe Proxy
+    attr_reader :_proxy_
+
+    # The recipe Package
+    attr_reader :_package_
+
+    attr_reader :_package_path_
+
+    attr_reader :_package_opts_
+
+    # The recipe Cookbook
+    attr_reader :_cookbook_
+
+    # The target recieving writes
+    attr_reader :target
+
+    def initialize(package = Package.new, cookbook = Cookbook.new, target = "")
+      @_proxy_    = Proxy.new(self)
+      @_package_  = package
+      @_cookbook_ = cookbook
+      @_package_path_ = nil
+      @_package_opts_ = nil
+      @target     = target
+      @chain      = false
+      @attributes = {}
+      @attrs      = nil
+
+      if Kernel.block_given?
+        instance_eval(&Proc.new)
+      end
+    end
+
+    # Overridden to look up constants as normal.
+    def self.const_missing(name)
+      ::Object.const_get(name)
+    end
+
+    # Returns the singleton class for self.  Used by clone to access modules
+    # included in self (ex via _extend_).
+    def _singleton_class_
+      class << self
+        SINGLETON_CLASS = self
+        def _singleton_class_
+          SINGLETON_CLASS
+        end
+      end
+
+      # this and future calls go to the _singleton_class_ as defined above.
+      _singleton_class_
+    end
+
+    # Returns the class for self.
+    def _class_
+      _singleton_class_.superclass
+    end
+
+    # Extends self with the module.
+    def _extend_(mod)
+      mod.__send__(:extend_object, self)
+    end
+
+    # Callback to initialize a clone of self. Passes forward all state,
+    # including local data and attributes.
+    def _initialize_clone_(orig)
+      @_proxy_    = Proxy.new(self)
+      @_package_  = orig._package_
+      @_cookbook_ = orig._cookbook_
+      @_package_path_ = orig._package_path_
+      @_package_opts_ = orig._package_path_
+      @target     = orig.target
+      @chain      = orig.chain?
+      @attributes = orig.attributes
+      @attrs      = nil
+    end
+
+    # Returns a clone of self, kind of like Object#clone.
+    #
+    # Note that unlike Object.clone this currently does not carry forward
+    # tainted/frozen state, nor can it carry forward singleton methods.
+    # Modules and internal state only.
+    def _clone_
+      clone = _class_.allocate
+      clone._initialize_clone_(self)
+      _singleton_class_.included_modules.each {|mod| clone._extend_ mod }
+      clone
+    end
+
+    # Callback to initialize children created by _beget_.  Sets a new target
+    # by calling dup.clear on the original target, and unchains.  Note that
+    # the child shares the same attributes as the parent, and so can
+    # (un)intentionally cause changes in the parent.
+    def _initialize_child_(orig)
+      @target = orig.target.dup.clear
+      @_package_path_ = nil
+      @_package_opts_ = nil
+      unchain
+    end
+
+    # Returns a clone of self created by _clone_, but also calls
+    # _initialize_child_ on the clone.
+    def _beget_
+      clone = _clone_
+      clone._initialize_child_(self)
+      clone
+    end
+
+    # Returns a child of self with a new target.  Writes str to the child, and
+    # evaluates the block in the context of the child, if given.
+    def _(str=nil, &block)
+      child = _beget_
+      child.write str if str
+      child.instance_eval(&block) if block
+      child
+    end
+
+    def register_as(path, options={})
+      @_package_path_ = path
+      @_package_opts_ = options
+      self
+    end
+
+    def register_to(package, path = _package_path_, options = _package_opts_)
+      package.add(path, options) {|io| io << to_s }
+    end
+
+    # Loads the specified attributes file and merges the results into attrs. A
+    # block may be given to specify attrs as well; it will be evaluated in the
+    # context of an Attributes instance.
+    #
+    # Returns a hash representing all attributes loaded thusfar (specifically
+    # attrs prior to merging in the package env). The attributes hash should
+    # be treated as if it were read-only.
+    def attributes(source_name=nil, &block)
+      if source_name || block
+        attributes = Attributes.new
+
+        if source_name
+          if source_path = _cookbook_.find(:attributes, source_name, attributes.load_attrs_extnames)
+            attributes.load_attrs(source_path)
+          end
+        end
+
+        if block
+          attributes.instance_eval(&block)
+        end
+
+        @attributes = Utils.deep_merge(@attributes, attributes.to_hash)
+        @attrs = nil
+      end
+
+      @attributes
+    end
+
+    # Returns the package env merged over any attrs specified by attributes.
+    #
+    # The attrs hash should be treated as if it were read-only because changes
+    # could alter the package env and thereby spill over into other recipes.
+    def attrs
+      @attrs ||= Utils.deep_merge(@attributes, _package_.env)
+    end
+
+    # Looks up and extends self with the specified helper(s).
+    def helpers(*helper_names)
+      helper_names.each do |helper|
+        unless helper.respond_to?(:extend_object)
+          helper_name = helper
+          module_name = Utils.camelize(helper_name)
+
+          helper = Utils.constantize(module_name) do
+            # Don't use Kernel because that may evade RubyGems
+            Utils.__send__(:require, Utils.underscore(helper_name))
+            Utils.constantize(module_name)
+          end
+        end
+        helper.__send__(:extend_object, self)
+      end
+      self
+    end
+
+    def register(package_path, options={})
+      source_path = _cookbook_.find(:files, options[:source] || package_path)
+      _package_.register(package_path, source_path, options)
+    end
+
+    # Captures writes during the block to a new target.  Returns the target.
+    def capture(target = "")
+      current = @target
+      begin
+        @target = target
+        yield
+      ensure
+        @target = current
+      end
+      target
+    end
+
+    def capture_to(package_path, options={})
+      str = capture { yield }
+      _package_.add(package_path, options) {|io| io << str }
+    end
+
+    # Writes input to target using `<<`. Stringifies input using to_s. Returns
+    # self.
+    def write(input)
+      target << input.to_s
+      self
+    end
+
+    # Writes input to self, writes a newline, and returns last.
+    def writeln(input=nil)
+      write input
+      write "\n"
+      self
+    end
+
+    # Looks up a template in _cookbook_ and renders it.
+    def render(template_name, locals=attrs)
+      file = _cookbook_.find(:templates, template_name, ['.erb'])
+      Tilt.new(file).render(Object.new, locals)
+    end
+
+    # Causes chain? to return true.  Returns self.
+    def chain
+      @chain = true
+      self
+    end
+
+    # Causes chain? to return false.  Returns self.
+    def unchain
+      @chain = false
+      self
+    end
+
+    # Returns the proxy.  Unchains first to ensure that if the proxy is not
+    # called, then the previous chain is stopped.
+    def chain_proxy
+      unchain
+      _proxy_
+    end
+
+    # Returns true as per chain/unchain.
+    def chain?
+      @chain
+    end
+
+    # Returns target.to_s.
+    def to_s
+      target.to_s
+    end
+  end
+end