rook 0.0.2 → 0.1.0

data/lib/rook/main.rb

@@ -0,0 +1,280 @@
+##
+## $Rev: 29 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+require 'rook'
+require 'pp'
+
+#require 'rook/dsl'
+#include Rook::DslHelper
+
+require 'rook/helper/kernel'
+require 'rook/helper/enumerable'
+
+
+
+module Rook
+
+
+
+  class CommandOptionError < RookError
+  end
+
+
+
+  class Main
+
+
+    def initialize(argv=ARGV, stdout=$stdout, stderr=$stderr)
+      @argv   = argv
+      @stdout = stdout
+      @stderr = stderr
+      @options, @properties = parse_argv(@argv)
+      @options[?h] = true if @properties['help'] == true
+      @products = argv
+    end
+
+
+    def self.main(argv=ARGV, stdout=$stdout, stderr=$stderr)
+      status = 0
+      begin
+        main = self.new(argv, stdout, stderr)
+        main.execute()
+      rescue RookError => ex
+        status = 1
+        raise ex if $rook_debug
+        stderr.puts "*** error: #{ex.message}"
+      end
+      exit status
+    end
+
+
+    def execute
+      options    = @options
+      properties = @properties
+      products   = @products
+
+      ##
+      $rook_debug = true if @options[?D]    # or $DEBUG
+      $KCODE = @options[?k] if @options[?k]
+
+      ## help and version
+      if @options[?h] || @options[?v]
+        cmdname = File.basename($0)
+        #desc = "#{cmdname} - a SCM (software configuration management) tool like Make, Rake, Ant, or Cook.\n"
+        desc = "#{cmdname} - a SCM (Software Cooking Management) tool like Make, Rake, Ant, or Cook.\n"
+        @stdout.puts version() if @options[?v]
+        @stdout.puts desc      if @options[?h]
+        @stdout.puts help()    if @options[?h]
+        return
+      end
+
+      ## require libraries
+      @options[?r].split(/,/).each { |lib| require lib } if @options[?r]
+
+      ## bookname
+      bookname = @options[?f] || @options[?b]
+      if bookname
+        test(?f, bookname) or raise CommandOptionError.new("cookbook '#{bookname}' not found.")
+      else
+        ['.yaml', '.yml', '.rb', ''].each do |suffix|
+          break if test(?f, bookname = "Rookbook#{suffix}")
+          break if test(?f, bookname = "rookbook#{suffix}")
+          bookname = nil
+        end
+        bookname  or raise CommandOptionError.new("cookbook 'Rookbook.yaml' or 'Rookbook.rb' not found.")
+      end
+
+      ## properties filename
+      propfile = @options[?P]
+      if propfile
+        test(?f, propfile) or raise CommandOptionError.new("file '#{propfile}' not found.")
+      else
+        %w[Rookbook.props properties.yaml].each do |f|
+          break propfile = f if test(?f, f)
+        end
+      end
+      if propfile
+        props = YAML.load_file(propfile)
+        props.each do |k, v|
+          @properties[k] = v unless @properties.key?(k)
+        end
+      end
+
+      ## global options
+      $rook_verbose = @options[?V] ? true : (@options[?q] ? false : nil)
+      $rook_forced  = @options[?F]
+      $rook_noexec  = @options[?n] ? 1 : (@options[?N] ? 2 : nil)
+
+      # kitchen
+      props = { :verbose=>$rook_verbose, :forced=>$rook_forced, :noexec=>$rook_noexec }
+      kitchen = Kitchen.new(@properties, props)
+
+      ## cookbook
+      if bookname =~ /\.ya?ml\z/
+        flag_expand_tab = !options[?T]
+        begin
+          cookbook = Cookbook.new(bookname, true, flag_expand_tab)
+        rescue CookbookError => ex
+          @stderr.puts "validation error:"
+          ex.errors.each do |error|
+            e = error
+            @stderr.puts " - line #{e.linenum}: [#{e.path}] #{e.message}"
+          end
+          return
+        end
+        kitchen.load_book(cookbook)
+      else
+        kitchen.load_script(bookname)
+      end
+
+      ## list recipes
+      if @options[?l] || @options[?L]
+        show_all   = @options[?L] ? true : false
+        list_properties(kitchen, show_all)
+        @stdout.puts
+        list_recipes(kitchen, @options[?L])
+        return
+      end
+
+      ## show property value
+      if @options[?p]
+        @options[?p].split(/,/).each do |pname|
+          pp kitchen.get_property(pname)
+        end
+        return
+      end
+
+      ## target product
+      if @products && !@products.empty?
+        products = @products
+      elsif kitchen.find_specific_recipe(:default)
+        products = [ :default ]
+      elsif prod = kitchen.get_variable('rook_product')
+        products = [ prod ]
+      elsif prod = kitchen.get_property('rook_product')
+        products = [ prod ]
+      else
+        @stderr.puts "*** no product specified."
+        list_recipes(kitchen)
+        return
+      end
+
+      ## start cooking
+      products.each do |product|
+        product = product.sub(/\A:/, '').intern if product.is_a?(String) && product[0] == ?:
+        kitchen.start_cooking(product)
+      end
+
+    end
+
+
+    private
+
+
+    def list_properties(kitchen, show_all=false)
+      @stdout.puts "properites:"
+      kitchen.properties.each do |hash|
+        next unless show_all || hash['access'] == 'public'
+        @stdout.puts "  %-18s = %s" % [hash['name'], hash['value'].inspect]
+      end
+      return unless show_all
+      @stdout.puts "\nvariables:"
+      kitchen.variables.each do |hash|
+        @stdout.puts "  %-18s = %s" % [hash['name'], hash['value'].inspect]
+      end
+    end
+
+
+    def list_recipes(kitchen, show_all=false)
+      @stdout.puts "recipes:"
+      kitchen.recipes.each do |r|
+        @stdout.puts "  %-18s : %s" % [Util.to_str(r.product), r.desc] if show_all || r.public?
+      end
+    end
+
+
+    def help
+      cmdname = File.basename($0)
+      s = ""
+      #s << "       http://www.kuwata-lab.com/rook/\n"
+      s << "Usage: #{cmdname} [-hvTFnNqQVlLc] [-f bookname] [-k kanji] [-F[n]] product...\n"
+      s << "  -h           :  help\n"
+      s << "  -v           :  version\n"
+      s << "  -t           :  expand tab character in cookbook\n"
+      s << "  -T           :  don't expand tab character in cookbook\n"
+      s << "  -n           :  no execute\n"
+      s << "  -N           :  never execute\n"
+      s << "  -q           :  quiet\n"
+      s << "  -Q           :  more quiet\n"
+      s << "  -V           :  verbose\n"
+      s << "  -l           :  list public recipes and properties\n"
+      s << "  -L           :  list all recipes, properties, and variables\n"
+      s << "  -c           :  validation check of cookbook\n"
+      s << "  -F           :  execute forcelly\n"
+      s << "  -b bookname  :  cookbook name\n"
+      s << "  -f bookname  :  equal to `-b bookname'\n"
+      s << "  -p property  :  show property value in 'pp' format\n"
+      s << "  -k kanji     :  kanji code (euc/sjis/utf8)\n"
+      s << "  -r file[,..] :  require libraries\n"
+      s << "  --name=value :  property name and value\n"
+      return s
+    end
+
+
+    def version
+      return ('$Release: 0.1.0 $' =~ /[\.\d]+/) && $&
+    end
+
+
+    def parse_argv(argv)
+      options = {}
+      properties = {}
+      while !argv.empty? && argv[0][0] == ?-
+        optstr = argv.shift
+        break if optstr == '-'
+        if optstr[1] == ?-     # property
+          unless optstr =~ /\A--([a-zA-Z_]\w*)(?:=(.*))?\z/
+            raise CommandOptionError.new("#{optstr}: invalid option pattern.")
+          end
+          name = $1
+          value = YAML.load($2)
+          properties[name] = value
+        else                   # option
+          optstr = optstr.sub(/^-/, '')
+          while optstr && !optstr.empty?
+            optch = optstr[0]
+            optstr[0, 1] = ''
+            case optch
+            when ?h, ?v, ?c, ?t, ?T, ?n, ?N, ?q, ?Q, ?V, ?l, ?L
+              options[optch] = true
+            when ?f, ?b, ?k, ?r, ?p
+              arg = optstr.empty? ? argv.shift : optstr
+              unless arg
+                hash = { ?f => 'bookname', ?b => 'bookname', ?k => 'kanji code',
+                         ?r => 'library',  ?p => 'property', }
+                raise CommandOptionError.new("-#{optch.chr}: #{hash[optch]} required.")
+              end
+              options[optch] = arg
+              optstr = nil
+            when ?F, ?D
+              arg = optstr.empty? ? true : optstr
+              options[optch] = arg
+              optstr = nil
+            else
+              raise CommandOptionError.new("-#{optch.chr}: invalid option.")
+            end
+          end
+        end
+      end
+      return options, properties
+    end
+
+
+  end
+
+
+
+end

data/lib/rook/recipe.rb

@@ -0,0 +1,259 @@
+##
+## $Rev: 28 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+require 'rook/util'
+
+
+
+module Rook
+
+
+
+  ##
+  ## recipe
+  ##
+  ## ex.
+  ##   hash = {
+  ##     'product'=>'hello.o',
+  ##     'ingreds'=>['hello.c'],
+  ##     'options'=>['hello.h'],
+  ##   }
+  ##
+  ##   recipe1 = Recipe.new(hash) { gcc -o #{@product} #{@ingred} }
+  ##   recipe1.invoke()
+  ##
+  ##   hash['method'] = 'gcc -o #{@product} #{@ingred}'
+  ##   recipe2 = Recipe.new(hash)
+  ##   recipe2.invoke()
+  ##
+  class Recipe
+    include Assertion
+
+
+    alias __method__ method
+    alias __methods__ methods
+
+
+    def initialize(hash, &block)
+      @product  = hash['product']
+      @product  = eval @product if @product.is_a?(String) && @product =~ /\A\/(.*)\/\z/
+      @ingreds  = (hash['ingreds'] || []).flatten()
+      @coprods  = (hash['coprods'] || []).flatten()
+      @byprods  = (hash['byprods'] || []).flatten()
+      @options  = (hash['options'] || []).flatten()
+      @kind     = hash['kind'] || _detect_kind(@product)
+      @desc     = hash['desc']
+      @method   = hash['method']
+      @block    = block || hash['block']
+      @desc     = hash['desc'] || _default_desc(@product)
+      @access   = hash['access'] || (@desc ? 'public' : 'private')
+      @forced   = hash.key?('forced')   ? hash['forced']   : @product.is_a?(Symbol)
+      @symbolic = hash.key?('symbolic') ? hash['symbolic'] : @product.is_a?(Symbol)
+      @verbose  = hash['verbose']
+      @fingerprint = hash['fingerprint']
+      @bookname = hash['bookname']
+      @linenum  = hash['linenum']    # start linenumber of method part
+      @pattern  = _compile_pattern(@product) if @kind == 'generic'
+    end
+    attr_accessor :product, :ingreds, :coprods, :byprods, :options, :kind, :desc, :method
+    attr_accessor :block, :access, :forced, :symbolic, :verbose, :fingerprint
+    attr_accessor :bookname, :linenum, :pattern, :matches
+
+
+    #--
+    #def _member_names
+    #  return %w[product ingreds coprods byprods options desc kind method
+    #            block access forced symbolic verbose bookname linenum]
+    #end
+    #private :_member_names
+    #++
+
+
+    def match?(product)
+      return (@pattern || @product) === product
+    end
+
+
+    def public?
+      return @access == 'public'
+    end
+
+
+    def forced?
+      return @forced
+    end
+
+
+    def verbose?
+      return @verbose
+    end
+
+
+    def symbolic?
+      return @symbolic
+    end
+
+
+    def all_products
+      list = [ @product ]
+      list.concat @coprods if @coprods
+      list.concat @byprods if @byprods
+      return list
+    end
+
+
+    def all_ingredients
+      list = []
+      list.concat @ingreds if @ingreds
+      list.concat @options if @options
+      return list
+    end
+
+
+    def _default_desc(product)
+      return nil unless product.is_a?(Symbol)
+      case @product
+      when :all      ;  return 'cook all'
+      when :clean    ;  return 'remove all byproducts and itermediates'
+      when :clear    ;  return 'remove all byproducts, intermediates, and products'
+      when :compile  ;  return 'compile ingredients'
+      when :test     ;  return 'do test'
+      when :config   ;  return 'configure'
+      when :setup    ;  return 'do setup'
+      when :install  ;  return 'do install'
+      when :deploy   ;  return 'deploy modules'
+      when :package  ;  return 'create package'
+      when :doc      ;  return 'generate documents'
+      else           ;  return nil
+      end
+    end
+    private :_default_desc
+
+
+    def _detect_kind(product)
+      case product
+      when Symbol         ;  return 'specific'
+      when Regexp         ;  return 'generic'
+      #when /\A\/.*\/i?\z/ ;  return 'generic'
+      else
+        return Util.has_meta?(product) ? 'generic' : 'specific'
+      end
+    end
+    private :_detect_kind
+
+
+    def _compile_pattern(product)
+      return product       if product.is_a?(Regexp)
+      return eval(product) if product =~ /\A\/.*\/i?\z/
+      return Util.meta2regexp(product)
+    end
+    private :_compile_pattern
+
+
+    def to_specific(product)
+      return self unless @pattern
+      matches = @pattern.match(product)
+      matches  or raise RookError.new("product '#{product}' doesn't match to /#{@pattern.source}/")
+      hash = { 'product' => product }
+      instance_variables.each do |var|
+        next if var == '@product'
+        w = var[1, var.length-1]    # '@name' => 'name'
+        hash[w] = Util.expand_matches(instance_variable_get(var), matches)
+      end
+      hash['kind'] = 'specific'
+      recipe = Recipe.new(hash)
+      recipe.matches = matches
+      return recipe
+    end
+
+
+    def invoke(parameters)
+      Oven.new(self).bake(parameters)
+    end
+
+
+  end
+
+
+
+  class Oven   # :nodoc:
+    include Commands, Assertion
+
+
+    def initialize(recipe)
+      recipe.instance_variables.each do |name|
+        value = recipe.instance_variable_get(name)
+        instance_variable_set(name, value)
+      end
+      @ingred = @ingreds.first if @ingreds
+      @coprod = @coprods.first if @coprods
+      @byprod = @byprods.first if @byprods
+      @option = @options.first if @options
+    end
+
+
+    def bake(_parameters)
+      ## copy properties as instance variable
+      _parameters.property_names.each do |name|
+        instance_variable_set("@#{name}", _parameters.get_property(name))
+      end
+      ## invoke @block or @method
+      if @block
+        self.instance_eval(&@block)
+      elsif @method
+        ## set variables as local vars
+        @_vars = {}
+        _code = []
+        _parameters.variable_names.each do |name|
+          @_vars[name] = _parameters.get_variable(name)
+          _code << "#{name}=@_vars['#{name}'];"
+        end
+        _code << @method
+        self.instance_eval(_code.join, @bookname, @linenum)
+      end
+    end
+
+
+  end
+
+
+
+#  class SymbolicRecipe < Recipe
+#    def match?(product)
+#      @product == product
+#    end
+#    def to_specific(product)
+#      self
+#    end
+#  end
+#
+#  class SpecificRecipe < Recipe
+#    def match?(product)
+#      @product == product
+#    end
+#    def to_specific(product)
+#      self
+#    end
+#  end
+#
+#  class GenericRecipe < Recipe
+#    def match?(product)
+#      @pattern =~ product
+#    end
+#    def to_specific(product)
+#      matches = @pattern.match(product)
+#      hash = { 'product' => product }
+#      _member_names.each do |name|
+#        hash[name] = Util.expand_matches(instance_variable_get(name), matches)
+#      end
+#      SpecificRecipe.new(hash)
+#    end
+#  end
+
+
+
+end