cbt 0.0.1

data/examples/config/components.yml

@@ -0,0 +1,19 @@
+components:
+  utils:
+    lua_modules: [util, timer]  
+    tag: utils
+  LiveObject:
+    tag: ui.base
+  Panel:
+    lua_modules: [Panel<LiveObject]
+    tag: ui.full
+
+tags:
+  _default: {shape: record, style: filled, fillcolor: beige}
+  utils: {fillcolor: bisque3}
+  ui: {shape: Mrecord}
+  ui.base: {fillcolor: bisque3}
+  ui.full: {fillcolor: cornflowerblue}
+
+# relations: -- for erd
+  

data/lib/cbt.rb

@@ -0,0 +1,13 @@
+require "cbt/girc"
+require "cbt/component"
+require "cbt/digester"
+require "cbt/app"
+require "cbt/creator"
+require "cbt/checkout"
+require "cbt/cleanup"
+require "cbt/diagram"
+
+require "luobo/cbt"
+require "luobo/lua"
+require "luobo/spec"
+require "luobo/settings"

data/lib/cbt/app.rb

@@ -0,0 +1,93 @@
+require 'find'
+require 'logger'
+require 'yaml'
+
+module Cbt
+  class App
+    attr_accessor :options, :git, :components
+    def initialize options = {}
+      @options = options
+      @git = Girc.new('git', @options[:verbose])
+      
+      # initialize logger
+      @logger = Logger.new(STDOUT)
+      @logger.level = @options[:verbose] ? Logger::INFO : Logger::WARN
+      @logger.formatter = proc {|severity, datetime, progname, msg| "#{msg.to_s}\n"}
+      
+      @config = YAML.load(File.open(@options[:config_file]).read)
+      # parse a components name=>object list
+      @components = Hash.new
+      @config["components"].each do |name, conf|
+        @components[name] = Component.new(name, conf)
+      end
+
+      # merge tag attributes recursively
+      @config["tags"].each do |t,v|
+        tv = @config["tags"]["_default"].clone || {} 
+        p = nil
+        t.split('.').each do |pt|
+          p = p ? [p, pt].join('.') : pt # merge in order: tv < a < a.b < a.b.c, ...
+          # puts "merge from #{p} to #{t}"
+          tv.merge! @config["tags"][p] if @config["tags"][p]
+        end
+        @config["tags"][t] = tv
+      end
+      
+      # check uniqueness for assets and lua module
+      luam, assets = Hash.new, Hash.new
+      @components.each do |cname, comp|
+        comp.assets.each do |aname, asset|
+          error "asset #{aname} defined in both components #{cname} and #{assets[aname]}" if assets[aname]
+          assets[aname] = cname
+        end
+
+        comp.modules.each do |mname, lua|
+          error "lua module #{mname} defined in both components #{cname} and #{luam[mname]}" if luam[mname]
+          luam[mname] = cname
+        end
+      end
+    end
+
+    # log message handler
+    # ------------------------------
+    def error msg
+      @logger.fatal ("[ERROR] " + msg).bold.red
+      exit
+    end
+
+    def warn msg
+      @logger.warn ("[WARN] " + msg).yellow
+    end
+
+    def info msg
+      @logger.info "[INFO] " + msg
+    end
+
+    # find current components from the command line option 
+    # or from the git branch name
+    def current_component_names
+      component_list = Array.new
+      error "you can not specify component name with '--all' option" if @options[:component] and @options[:all]
+
+      if @options[:component] 
+        component_list = @options[:component].split(",") 
+      elsif @options[:all]
+        component_list = @components.keys
+      else
+        if @git.in_git_dir? and /^(comp|component|ct)\/.+/.match(@git.current_branch)
+          info "parse component names from git branch (#{@git.current_branch})"
+          component_list << @git.current_branch.gsub(/^(comp|component|ct)\//, '')
+        end
+      end
+
+      component_list.each { |n| error "unknown component name '#{n}'" unless @components[n] }
+      component_list
+    end
+
+    # return the tag definition from config file.
+    def tags tag
+      @config["tags"][tag.to_s] || {}
+    end
+
+  end
+end

data/lib/cbt/checkout.rb

@@ -0,0 +1,155 @@
+require 'fileutils'
+
+module Cbt
+  class Checkout < App
+
+    # copy file from s to t, use luobo if convert class defined
+    def cp_file s, t
+      converted = false
+      if /\.(?<ext_>\w+)$/ =~ s
+        if ext_
+          begin
+            klass = Module.const_get(ext_.capitalize + 'Luobo')
+          rescue Exception => e
+          end
+          
+          if klass and klass.is_a?(Class)
+            info "Use #{klass} to convert #{s}"
+            klass.cp! s, t, @options[:platform]
+            converted = true
+          end
+        end
+      end
+
+      # if no any luobo class converted the file, copy as it is
+      FileUtils.cp s, t unless converted
+
+      # add to consistency list
+      @digester.add_history s
+      @digester.add_history t
+    end
+
+    def add_copy_list sfile, tfile
+      # only add source file that has changed unless no_consistency_check
+      @file_list[sfile] = tfile if @options[:no_consistency_check] or @digester.changed?(sfile) 
+      if @file_list[sfile] and @digester.changed?(tfile) and File.exists? tfile
+        error "target file #{tfile} changed. use --force to force overwrite" unless @options[:force]
+      end
+    end
+
+    # copy asset files for all components
+    def copy_assets! comp, ws_dir
+      comp.assets.each do |aname, asset|
+        comp_dir = comp.dir(@options[:components_dir])
+       
+        # detect if an asset file saved both in global and component space
+        sfile = asset.path([comp_dir], @options[:platform])
+        global_file = asset.path([@options[:assets_dir]], @options[:platform])
+        warn "#{sfile} will overwrite #{global_file}" if sfile and global_file
+
+        sfile = global_file unless sfile
+        error "asset file for #{aname}, component #{comp.name} not found" unless sfile
+
+        tfile = m.target(ws_dir)
+        add_copy_list sfile, tfile
+      end
+    end
+
+    # copy required component assets and files
+    def copy_require! comp, ws_dir
+      comp.modules.each do |mname, m|
+        next if mname == 'main' # skip main file from the application core component
+        comp_dir = comp.dir(@options[:components_dir])
+        
+        sfile = m.path([comp_dir], @options[:require_platform])
+        tfile = m.target(ws_dir)
+        error "no file find for module lua file #{mname}, component #{comp.name}" unless sfile
+         
+        # add lua module file int copy waiting list
+        add_copy_list sfile, tfile
+      end
+      # copy all 
+    end
+
+    # copy lua/spec files for a component
+    def process_component! comp
+      info "checkout component #{comp.name}"
+     
+      # the copy candidate files list
+      @file_list = Hash.new
+
+      comp_dir = comp.dir(@options[:components_dir])
+      ws_dir = comp.ws_dir(@options[:workspace_dir], @options[:platform])
+      unless File.directory? ws_dir
+        info "create workspace directory #{ws_dir}"
+        FileUtils.mkdir_p ws_dir
+      end
+
+      @digester = Digester.new(ws_dir + ".yml")
+
+      # copy assets files for all components
+      @components.each do |cname, c|
+        copy_assets! c, ws_dir unless cname == comp.name
+      end
+      copy_assets! comp, ws_dir # copy the current component at last
+
+      # copy require files for all components other than current component
+      @components.each do |cname, c|
+        copy_require! c, ws_dir unless cname == comp.name
+      end
+
+      # for each lua module, error if no file
+      comp.modules['main'] = LuaModule.new(comp.name, 'main') unless comp.modules['main']
+      comp.modules.each do |mname, m|
+        sfile = m.path([comp_dir], @options[:platform])
+        tfile = m.target(ws_dir)
+        error "no file find for module lua file #{mname}, component #{comp.name}" unless sfile
+         
+        # add lua module file int copy waiting list
+        add_copy_list sfile, tfile
+      end
+      
+      # for all spec files
+      spec_dir = comp_dir
+      spec_dir = @options[:components_dir] if @options[:all_spec]
+      Dir[spec_dir + "/*_spec.lua"].each do |lua|
+        add_copy_list lua, File.join(ws_dir, File.basename(lua))
+      end
+
+      # check if t registered twice
+      tlist = Hash.new
+      @file_list.each do |s,t| 
+        warn "#{s} will overwrite #{tlist[t]} (for #{t})" if tlist[t]
+        tlist[t] = s
+
+        if @options[:simulation]
+          puts "#{s} -> #{t}"
+        else
+          info "copy #{s} -> #{t}"
+          cp_file s, t
+          @digester.add_history s
+          @digester.add_history t
+        end
+      end
+    end
+
+    # wrap for all components
+    def process!
+      unless File.directory? @options[:workspace_dir]
+        info "create workspace directory #{@options[:workspace_dir]}"
+        FileUtils.mkdir_p @options[:workspace_dir]
+      end
+
+      if @options[:build] == true
+        warn "set require platform to #{@options[:platform]}" unless @options[:require_platform] == @options[:platform]
+        @options[:require_platform] = @options[:platform]
+      end
+      
+      # process for all component
+      current_component_names.each do |cname|
+        comp = @components[cname]
+        process_component! comp
+      end
+    end
+  end
+end

data/lib/cbt/cleanup.rb

@@ -0,0 +1,7 @@
+module Cbt
+  class Cleanup < App
+    def process!
+
+    end
+  end
+end

data/lib/cbt/component.rb

@@ -0,0 +1,91 @@
+module Cbt
+
+  # handle file platform versinn and copy
+  class SrcFile
+    attr_accessor :component_name
+    def initialize component_name, basename, ext=nil
+      unless ext
+        if /^(?<basename_>.+?)\.(?<ext_>\w+)$/ =~ basename
+          basename, ext = basename_, ext_
+        end
+      end
+      @component_name, @basename, @ext = component_name, basename, ext
+    end
+
+    # search up for the source file for the current file object
+    # with @name as the basename
+    def path dir = [], platform = 'debug'
+      # search up for each dir in row
+      dir.each do |d|
+        [".#{platform}.", "."].each do |filename|
+          file_path = File.join(d, @basename + filename + @ext)
+          # end search and return the file first found in the given directories
+          # return File.expand_path(file_path) if File.exists? file_path
+          return file_path if File.exists? file_path
+        end
+      end
+      nil
+    end
+
+    # file copy to under workspace 
+    def target workspace_dir
+      File.join(workspace_dir, @basename + '.' + @ext)
+    end
+
+  end # class file
+
+  # module lua file object holds file contents digest to
+  # prevent accedental over-write
+  class LuaModule < SrcFile
+    attr_accessor :name, :super_class
+
+    def initialize component_name, name
+      @name, @super_class = name.split("<")
+      super(component_name, @name, 'lua')
+    end
+  end
+
+  # assets files 
+  class AssetFile < SrcFile
+
+  end
+
+  class Component
+    attr_accessor :name, :modules, :assets
+
+    def initialize name, conf
+      @name, @conf = name, conf
+      
+      # if no modules defined, use the name as default
+      @conf["lua_modules"] = Array.new unless @conf["lua_modules"] 
+      @conf["lua_modules"] << @name if @conf["lua_modules"].size == 0
+        
+      @conf["assets"] = Array.new unless @conf["assets"]
+
+      # parse module definitions, convert to objects
+      @modules, @assets = {}, {} # name => object pair
+      @conf["lua_modules"].each do |lname|
+        raise "invalid lua module name '#{lname}'" unless /^[a-zA-Z][\<a-zA-Z_0-9]+$/.match(lname)
+        @modules[lname] = LuaModule.new(@name, lname)
+      end
+
+      @conf["assets"].each do |asset|
+        @assets[asset] = AssetFile.new(@name, asset)
+      end
+    end
+
+    def tag
+      @conf["tag"]
+    end
+
+    # where the module/asset files are located
+    def dir base_dir
+      File.join(base_dir, @name).gsub(/\/$/, '')
+    end
+
+    # target working space directory
+    def ws_dir base_dir, platform
+      File.join(base_dir, @name + '_' + platform).gsub(/\/$/, '')
+    end
+  end
+end

data/lib/cbt/creator.rb

@@ -0,0 +1,75 @@
+require "fileutils"
+require "erubis"
+
+module Cbt
+  class Creator < App
+
+    # find the template file from local or gem folders
+    def find_tpl_file tt
+      # first find the template under the current folder
+      tpl = File.join("template", tt)
+      
+      # if not find there, use the default template come from the gem
+      unless File.exists? tpl
+        tpl = File.expand_path(File.dirname(__FILE__)) + "/../../templates/" + tt
+      end
+      File.expand_path(tpl)
+    end
+    
+    # find template file name
+    def find_tpl luamod, mock = false
+      tt = ""
+      if luamod.name =~ /^[A-Z]/
+        tt = luamod.super_class ? "Class_with_super" : "Class"
+      else
+        tt = luamod.super_class ? "part_with_super" : "part"
+      end
+
+      tt = mock ? tt + ".mock.lua.erb" : tt + ".lua.erb"
+      find_tpl_file(tt)
+    end
+
+    # create skeleton files based on filename, module objects and template filename
+    def create! filename, luamod, template 
+      if (not File.exists?(filename)) or @options[:force]
+        info "create file #{filename}"
+        fh = File.open(filename, 'w:utf-8')
+        fh.puts Erubis::Eruby.new(File.open(template, 'r:utf-8').read).result({
+          "super_class" => luamod.super_class, "name" => luamod.name, 
+          "label" => sprintf("(component: %s)", luamod.component_name)
+        })
+        fh.close
+      else
+        info "skip existing file #{filename}"
+      end
+    end
+
+    # create initial lua files based on templates
+    def process!
+      comps = current_component_names
+      warn "no component specified." unless comps.size > 0
+      comps.each do |cname|
+        comp = @components[cname]
+        raise "undefined components #{cname}" unless comp
+
+        # create each module lua files
+        rep_dir = comp.dir(@options[:components_dir])
+        comp.modules.each do |name, mod|
+          unless File.directory? rep_dir
+            info "create directory #{rep_dir}"
+            FileUtils.mkdir_p rep_dir
+          end
+
+          # create file:
+          create!(File.join(rep_dir, mod.name + ".mock.lua"), mod, find_tpl(mod, true)) 
+          create!(File.join(rep_dir, mod.name + ".lua"), mod, find_tpl(mod, false)) 
+          create!(File.join(rep_dir, mod.name + "_spec.lua"), mod, find_tpl_file('spec.lua.erb')) unless name == 'main'
+        end
+
+        create!(File.join(rep_dir, "main.lua"), LuaModule.new(cname, 'main'), find_tpl_file('main.lua.erb')) unless comp.modules['main']
+      end # component names
+    end
+
+  end
+end
+