rook 0.0.2 → 0.1.0

data/lib/rook/cookbook.rb

@@ -0,0 +1,237 @@
+##
+## $Rev: 31 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+require 'kwalify'
+
+require 'rook/util'
+
+
+
+module Rook
+
+
+
+  class CookbookValidator < Kwalify::Validator
+
+
+    filename = nil
+    path = $:.find { |dir| test(?f, filename = "#{dir}/rook/rookbook.schema.yaml") }
+    path  or raise RookError.new("schema file ('rookbook.schema.yaml') is not found.")
+    parser = Kwalify::YamlParser.new(File.read(filename))
+    @@schema = parser.parse()
+
+
+    def initialize()
+      super(@@schema)
+    end
+
+
+    def create_error(path, message)
+      return Kwalify::ValidationError.new(message, path)
+    end
+
+
+    #PROPERTY_NAME_PATTERN = /\A[a-zA-Z_][-\w]*\*?\z/
+
+
+    ##
+    def validate_hook(value, rule, path, errors)
+      case rule.name
+      when 'MATERIAL'
+        unless value.is_a?(String) || value.is_a?(Symbol)
+          errors << create_error(path, "String or Symbol is required.")
+        end
+      when 'PROPERTY'
+        unless value.key?('value') || value.key?('expr')
+          errors << create_error(path, "either 'value' or 'expr' is required.")
+        end
+      when 'PROP'
+        value.each do |k, v|
+          if !k.is_a?(String)
+            errors << error("#{path}/#{k}", "property name is not a string.")
+          elsif k !~ /\A[a-zA-Z_][-\w]*\*?\z/ && k != '.desc'
+            errors << error("#{path}/#{k}", "invlaid property name.")
+          elsif k[-1] == ?* && !v.is_a?(String)
+            errors << create_error("#{path}/#{k}", "expr is not a string.")
+          end
+        end
+      end if rule.name
+    end
+
+
+  end
+
+
+
+  class CookbookError < RookError
+
+
+    def initialize(message, validation_errors)
+      @errors = validation_errors
+    end
+    attr_reader :errors
+
+
+  end
+
+
+
+  ##
+  ## represents cookbook
+  ##
+  ## ex.
+  ##   cookbooks, errors = Cookbook.load_yamlfile('Rookbook.yaml')
+  ##   if errors && !errors.empty?
+  ##     puts "%d: [%s] %s" % [errors.linenum, errors.path, errors.message]
+  ##   end
+  ##
+  class Cookbook
+    include Assertion
+    #include DslHelper
+
+
+    @@validator = CookbookValidator.new
+
+
+    ##
+    def initialize(bookname=nil, load_yaml=true, expand_tab=true)
+      @precookings = []
+      @properties  = []
+      @variables   = []
+      @materials   = []
+      @recipes     = []
+      @bookname    = bookname
+      load_yamlfile(bookname, expand_tab) if bookname && load_yaml
+    end
+    attr_reader :properties, :variables, :recipes, :materials, :precookings
+    attr_accessor :bookname
+
+
+    def precooking
+      return @precookings.map { |hash| hash['code'] }.join("\n")
+    end
+
+
+    def load_yamlfile(bookname, tab_expand=true)
+      yaml_str = File.read(bookname)
+      yaml_str = Util.untabify(yaml_str) if tab_expand
+      return load_yamlstr(yaml_str)
+    end
+
+
+    def load_yamlstr(yaml_str)
+      parser = Kwalify::YamlParser.new(yaml_str)
+      errors = []
+      while parser.has_next?
+        ydoc = parser.parse()
+        next if ydoc.nil?
+        errs = @@validator.validate(ydoc)
+        if errs && !errs.empty?
+          parser.set_errors_linenum(errs)
+          errors += errs
+        else
+          load_ydoc(ydoc, parser)
+        end
+      end
+      errors.empty?  or raise CookbookError.new("invalid cookbook", errors)
+    end
+
+
+    def load_ydoc(ydoc, parser=nil)
+      ydoc = ydoc.dup
+      #
+      code = ydoc['precooking']
+      ydoc['precookings'] = [ { 'code'=>code } ] if code
+      #
+      [ 'properties', 'variables' ].each do |key|
+        next unless ydoc[key]
+        list = []
+        ydoc[key].each_with_index do |prop, i|
+          opts = {}
+          prop.keys.each do |k| opts[k.to_s] = prop[k] if k.is_a?(Symbol) end
+          prop.each do |name, val|
+            next unless name.is_a?(String)
+            vkey = name[-1] == ?* ? 'expr' : 'value'
+            #name[-1,1] = '' if name[-1] == ?*   # TypeError: can't modify frozen string
+            name = name[0, name.length-1] if name[-1] == ?*
+            h = { 'name'=>name, vkey=>val }
+            h.update(opts)
+            list << h
+          end
+        end
+        ydoc[key] = list
+      end
+      #
+      @precookings += _load_section(ydoc['precookings'], 'code', parser, 1) { |h, i| "/precooking" }
+      @recipes     += _load_section(ydoc['recipes'],  'method', parser, 1) { |h, i| "/recipes/#{i}/method" }
+      @properties  += _load_section(ydoc['properties*'], 'expr', parser, 0) { |h, i| "/properties*/#{i}/expr" }
+      @variables   += _load_section(ydoc['variables*'], 'expr', parser, 0) { |h, i| "/variables*/#{i}/expr" }
+      @properties  += _load_section(ydoc['properties'], 'expr', parser, 0) { |h, i| "/properties/#{i}/#{h['name']}*" }
+      @variables   += _load_section(ydoc['variables'], 'expr', parser, 0) { |h, i| "/variables/#{i}/#{h['name']}*" }
+      #
+      list = ydoc['materials']
+      @materials += list if list
+    end
+
+
+    def _load_section(section, attr, parser, delta)
+      list = []
+      section.each_with_index do |hash, i|
+        if parser && hash[attr]
+          path = yield(hash, i)
+          hash['linenum'] = parser.path_linenum(path) + delta
+        end
+        list << hash
+      end if section
+      return list
+    end
+    private :_load_section
+
+
+    #--
+    #def load_dsl(ruby_code)
+    #  eval(ruby_code, binding(), @bookname, 1)
+    #end
+    #++
+
+
+    #--
+    #def self.load_yamlfile(bookname, tab_expand=true)
+    #  str = File.read(bookname)
+    #  str = Util.untabify(str) if tab_expand
+    #  return load_yamlstr(str, bookname)
+    #end
+    #
+    #
+    #def self.load_yamlstr(yaml_str, bookname)
+    #  parser = Kwalify::YamlParser.new(yaml_str)
+    #  ydocs = []
+    #  errors = []
+    #  books = []
+    #  while parser.has_next?
+    #    ydoc = parser.parse()
+    #    errs = @@validator.validate(ydoc)
+    #    if errs && !errs.empty?
+    #      errors += errs
+    #    else
+    #      cookbook = self.new
+    #      cookbook.bookname = bookname
+    #      cookbook.load_ydoc(ydoc, parser)
+    #      books << cookbook
+    #    end
+    #  end
+    #  errors.empty?  or raise CookbookError.new("invalid cookbook", errors)
+    #  return books
+    #end
+    #++
+
+
+  end
+
+
+
+end

data/lib/rook/helper/bz2.rb

@@ -0,0 +1,39 @@
+##
+## $Rev: 20 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+## download 'bz2' from http://raa.ruby-lang.org/project/bz2/
+
+require 'bz2'
+
+
+module BZ2
+
+
+  class Reader
+
+    alias _initialize initialize
+
+    def initialize(object, small=false)
+      _initialize(object, small)
+      @_io = object
+    end
+
+    def pos
+      @_io.pos
+    end
+
+    def pos=(index)
+      @_io.pos = index
+    end
+
+    def rewind
+      @_io.rewind
+    end
+
+  end
+
+
+end

data/lib/rook/helper/digest.rb

@@ -0,0 +1,76 @@
+##
+## $Rev$
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+require 'digest'
+
+
+
+class Digest::Base
+
+
+  ##
+  ## create digest object from file content
+  ##
+  ## ex.
+  ##   require 'digest/md5'
+  ##   digest = Digest::MD5.create_from_file('largefile.mov')
+  ##   puts digest.hexdigest
+  ##
+  ## this is faster than 'Digest::MD5.new(File.read("largefile.mov"))'
+  ## when file size is large.
+  ##
+  def self.create_from_file(filename)
+    digest = self.new
+    File.open(filename) do |f|
+      #size =   4 * 1024   #   4KB
+      #size =   8 * 1024   #   8KB
+       size =  16 * 1024   #  16KB
+      #size =  32 * 1024   #  32KB
+      #size =  64 * 1024   #  64KB
+      #size = 128 * 1024   # 128KB
+      #size = 256 * 1024   # 256KB
+      #size = 512 * 1024   # 512KB
+      #size = 1 * 1024 * 1024  # 1MB
+      #size = 4 * 1024 * 1024  # 4MB
+      buf = ''
+      digest.update(buf) while f.read(size, buf)
+    end
+    return digest
+  end
+
+
+  ##
+  ## return hex-digest value of file content
+  ##
+  ## ex.
+  ##   require 'digest/md5'
+  ##   puts Digest::MD5.hex_digest('largefile.mov')
+  ##
+  ## this is faster than 'Digest::MD5.hex_digest(File.read(filename))'
+  ## when file size is large.
+  ##
+  def self.file_hexdigest(filename)
+    return self.create_from_file(filename).hexdigest
+  end
+
+
+  ##
+  ## return digest value of file content
+  ##
+  ## ex.
+  ##   require 'digest/md5'
+  ##   puts Digest::MD5.digest('largefile.mov')
+  ##
+  ## this is faster than 'Digest::MD5.digest(File.read(filename))'
+  ## when file size is large.
+  ##
+  def self.file_digest(filename)
+    return self.create_from_file(filename).digest
+  end
+
+
+end

data/lib/rook/helper/enumerable.rb

@@ -0,0 +1,121 @@
+##
+## $Rev: 20 $
+## $Release: 0.1.0 $
+## copyright(c) 2006 kuwata-lab.com all rights reserved.
+##
+
+
+module Enumerable
+
+
+  ##
+  ## apply method with args
+  ##
+  ## ex.
+  ##  [1, 2, 3].apply(:'+', 5)  #=> [6, 7, 8]
+  ##
+  def apply(method_name, *args)
+    return self.collect { |item| item.__send__(method_name, *args) }
+  end
+
+
+  ##
+  ## add prefix for each item
+  ##
+  ## ex.
+  ##  ['a', 'b', 'c'].add_prefix('dir/') #=> ["dir/a", "dir/b", "dir/c"]
+  ##
+  def add_prefix(prefix)
+    return self.collect { |item| "#{prefix}#{item}" }
+  end
+
+
+  ##
+  ## add suffix for each item
+  ##
+  ## ex.
+  ##  ['a', 'b', 'c'].add_suffix('.txt') #=> ["a.txt", "b.txt", "c.txt"]
+  ##
+  def add_suffix(suffix)
+    return self.collect { |item| "#{item}#{suffix}" }
+  end
+
+
+  ##
+  ## add prefix and suffix for each item
+  ##
+  ## ex.
+  ##  ['a','b','c'].sandwich('p/', '.s') #=> ["p/a.s", "p/b.s", "p/c.s"]
+  ##
+  def sandwich(prefix, suffix)
+    return self.collect { |item| "#{prefix}#{item}#{suffix}" }
+  end
+
+
+  ##
+  ## apply 'sub()' method to each item
+  ##
+  ## ex.
+  ##  ['a.txt', 'b.txt'].each_sub(/\.txt$/, '.html') #=> ["a.html", "b.html"]
+  ##
+  def each_sub(pattern, replace, &block)
+    if replace
+      return self.collect { |item| item.sub(pattern, replace) }
+    else
+      return self.collect { |item| item.sub(pattern, &block) }
+    end
+  end
+
+
+  ##
+  ## apply 'gsub()' method to each item
+  ##
+  ## ex.
+  ##  ['a.txt', 'b.txt'].each_gsub(/\.txt$/, '.html') #=> ["a.html", "b.html"]
+  ##
+  def each_gsub(pattern, replace, &block)
+    if replace
+      return self.collect { |item| item.gsub(pattern, replace) }
+    else
+      return self.collect { |item| item.gsub(pattern, &block) }
+    end
+  end
+
+
+  ##
+  ## delete suffix for each item
+  ##
+  ## ex.
+  ##  ['a.txt', 'b.txt'].delete_suffix() #=> ["a", "b"]
+  ##
+  def delete_suffix(suffix=/\.\w+\z/)
+    unless suffix.is_a?(Regexp)
+      suffix = Regexp.compile("#{suffix.to_s}\\z")
+    end
+    return self.collect { |item| item.sub(suffix, '') }
+  end
+
+
+  ##
+  ## get basename of each item
+  ##
+  ## ex.
+  ##   ['dir1/a.txt', 'b.txt'].basenames() #=> ['a.txt', 'b.txt']
+  ##
+  def basenames
+    return self.collect { |item| File.basename(item) }
+  end
+
+
+  ##
+  ## get dirname of each item
+  ##
+  ## ex.
+  ##   ['dir1/a.txt', 'b.txt'].dirnames() #=> ['dir1', '.']
+  ##
+  def dirnames
+    return self.collect { |item| File.dirname(item) }
+  end
+
+
+end