basechip 0.0.1

data/lib/base_chip/dsl.rb

@@ -0,0 +1,593 @@
+# Copyright 2011 Tommy Poulter
+#
+# This file is part of basechip.
+#
+# basechip is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+# 
+# basechip is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with basechip.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'active_support/core_ext/hash'
+
+module Boolean; end
+class TrueClass ; include Boolean; end
+class FalseClass; include Boolean; end
+
+module BaseChip
+  # class ConfigHash < Hash
+  #   def [](key)
+  #     value = super(key)
+  #     value.configure
+  #     value
+  #   end
+  #   def each
+  #   end
+  # end
+  module Dsl
+    def self.included mod
+      mod.extend Dsl::ClassMethods
+      mod.class_eval do
+        include Reporting
+        include Dsl::InstanceMethods
+        attr_accessor :name
+        attr_reader   :foster
+        attr_reader   :parent
+        attr_accessor :settings         
+        attr_accessor :children
+        attr_accessor :possible_settings
+        attr_reader   :configured
+        attr_accessor :blks
+        attr_accessor :abstract
+
+                 @settings    = Hash.new
+        @possible_settings    = Hash.new
+                 @child_types = Hash.new
+        @possible_child_types = Hash.new
+      end
+    end
+    module ClassMethods
+      # class instance variables
+      attr_accessor :settings         
+      attr_accessor :child_types   
+      attr_accessor :possible_settings
+
+      def define_settings(h); h.each { |name, legal_types| define_setting name, legal_types } end                               
+      def define_children(h); h.each { |name, type       | define_child   name, type        } end
+
+      def define_setting(name,legal_types)
+        @possible_settings[name] = legal_types
+                 @settings[name] = legal_types
+        define_settings_methods(name,legal_types)
+      end
+      def define_child(name,type)
+        @possible_settings   .merge! type.possible_settings
+        @possible_child_types.merge! type.possible_child_types
+        @possible_child_types[name] = type
+                 @child_types[name] = type
+        type.possible_settings   .each { |name, legal_types| define_settings_methods name, legal_types }
+        type.possible_child_types.each { |name, type       |    define_child_methods name, type        }
+        define_child_methods(name,type)
+      end
+
+      def define_settings_methods(name,type)
+        # if name =~ /s$/
+        #   define_method name.to_s.singularize do |index,value|
+        #     hash = (instance_variable_get("@#{name}") || HashWithIndifferentAccess.new)
+        #             instance_variable_set "@#{name}", hash
+        #     hash[index] = value
+        #   end
+        # end
+        define_method name do |value=:base_chip_get_operation|
+          unless value == :base_chip_get_operation
+            check_type(name,value,type)
+            if value.is_a? Hash
+              instance_variable_set "@#{name}", value.with_indifferent_access
+            else
+              instance_variable_set "@#{name}", value
+            end
+          end
+          if (value = instance_variable_get "@#{name}") and value.is_a? Hash
+            value.with_indifferent_access
+          else
+            value
+          end
+        end
+
+        define_method "prepend_#{name}" do |value|
+          check_type(name,value,type)
+          if value && (current_value = instance_variable_get("@#{name}"))
+            if    value.is_a? Hash
+                instance_variable_set "@#{name}", current_value.merge(  value).with_indifferent_access
+            elsif value.is_a?(String) || value.is_a?(Symbol)
+              if current_value.is_a? Array 
+                instance_variable_set "@#{name}", current_value.unshift(value)
+              else
+                instance_variable_set "@#{name}",                    "#{value} " + current_value
+              end
+            else
+                instance_variable_set "@#{name}",                       value    + current_value
+            end
+          else
+                instance_variable_set "@#{name}",                       value
+          end
+          if (value = instance_variable_get "@#{name}") and value.is_a? Hash
+            value.with_indifferent_access
+          else
+            value
+          end
+        end
+
+        define_method "append_#{name}" do |value|
+          check_type(name,value,type)
+          if value && (current_value = instance_variable_get("@#{name}"))
+            if    value.is_a? Hash
+                instance_variable_set("@#{name}", current_value.merge(  value).with_indifferent_access)
+            elsif value.is_a?(String) || value.is_a?(Symbol)
+              if current_value.is_a? Array 
+                instance_variable_set "@#{name}", current_value <<      value
+              else
+                instance_variable_set "@#{name}", current_value +   " #{value}"
+              end
+            else
+                instance_variable_set "@#{name}", current_value +       value
+            end
+          else
+                instance_variable_set "@#{name}",                       value
+          end
+          if (value = instance_variable_get "@#{name}") and value.is_a? Hash
+            value.with_indifferent_access
+          else
+            value
+          end
+        end
+      end
+      def define_child_methods(child_name,type)
+        child_name_plural = child_name.to_s.pluralize.to_sym
+        attr_accessor child_name_plural
+        define_method child_name do |name=nil,&blk| # why is this an accessor also?
+          if name
+            hash           =  instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
+            tmp            =  (hash[name] ||= type.new)
+            tmp.name       =  name
+            tmp.parent     =  self
+            tmp.blks       << blk if blk
+            tmp
+          else
+            instance_variable_get("@#{name}")
+          end
+        end
+        define_method "abstract_#{child_name}" do |name=nil,&blk|
+          tmp = send(child_name, name, &blk)
+          tmp.abstract = true
+        end
+        define_method "import_#{child_name}" do |name,object|
+          fault        "attempting to import object #{object.name} of type #{object.class} into #{child_name_plural} of type #{type}" if object.class != type
+          hash       = instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
+          fault        "#{child_name} '#{name} already exists.  Import is not possible" if hash[name]
+          tmp        = (hash[name] = object.clone)
+          tmp.name   = name
+          tmp.foster = tmp.parent
+          tmp.parent = self
+        end
+
+        define_method "remove_#{child_name}" do |name|
+          hash       = instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
+          hash.delete name
+        end
+
+        # FIXME this only works on defined objects
+        define_method "all_#{child_name_plural}" do |&blk|
+          hash       = instance_variable_or_equal(child_name_plural,HashWithIndifferentAccess.new)
+          hash.each_value do |value|
+            value.blks << blk
+          end
+        end
+      end
+
+      def settings            ; @settings             end
+      def child_types         ; @child_types          end
+      def possible_settings   ; @possible_settings    end
+      def possible_child_types; @possible_child_types end
+
+      def to_doc_hash
+        doc_settings             = {}
+        doc_child_types          = {}
+        doc_possible_settings    = {}
+        doc_possible_child_types = {}
+
+        settings          .each { |name,types|                                     doc_settings[name] = types.map{|t|t.to_s}    }
+        possible_settings .each { |name,types| unless doc_settings[name]; doc_possible_settings[name] = types.map{|t|t.to_s} end}
+
+        child_types          .each { |k,v|          doc_child_types[k.to_s] = v.to_s }
+        possible_child_types .each { |k,v| doc_possible_child_types[k.to_s] = v.to_s unless doc_child_types[k.to_s] }
+
+        doc_method_list = instance_methods - Object.methods
+        doc_methods = {}
+        doc_method_list.each do |m|
+          im = instance_method(m)
+          doc_methods[m] = {
+            :inputs  =>  im.parameters,
+            :expects => (im.parameters.empty? ? "This method takes no inputs." : nil)
+          }
+        end
+
+        possible_settings.keys.each do |n|
+          [ n                   , 
+           "append_#{ n}".to_sym,
+           "prepend_#{n}".to_sym
+          ].each do |m|
+            doc_methods[m][:setting] = n.to_s
+          end
+        end
+        possible_child_types.keys.each do |n|
+          [ n                            ,
+                     "remove_#{n}".to_sym,
+                   "abstract_#{n}".to_sym,
+                     "import_#{n}".to_sym,
+              "all_#{n}".pluralize.to_sym,
+                  n.to_s.pluralize.to_sym,
+            "#{n.to_s.pluralize}=".to_sym
+          ].each do |m|
+            doc_methods[m][:object] = n.to_s
+          end
+        end
+
+        h = { self.to_s => { :type                 => self.to_s                      ,
+                             :child_types          => doc_child_types                ,
+                             :settings             => doc_settings                   ,
+                             :possible_child_types => doc_possible_child_types       ,
+                             :possible_settings    => doc_possible_settings          ,
+                             :methods              => doc_methods                    }
+            }
+        child_types.each_value do |v|
+          next if v == self
+          h.merge! v.to_doc_hash
+        end
+        h
+      end
+    end
+    module InstanceMethods
+      def initialize(*args)
+        super(*args)
+        @blks = []
+        @modes = []
+        @base_types = []
+      end
+      def parent=(parent)
+        @parent = parent
+      end
+
+      #   # and then the settings
+      #   @settings          = Hash.new
+      #   @children          = Hash.new
+      #   @possible_settings = Hash.new
+
+      #   (self.class.         settings).each { |n,s| s2 = s.dup; s2.parent = self;          @settings[n] = s2 }
+      #   (self.class.possible_settings).each { |n,s| s2 = s.dup; s2.parent = self; @possible_settings[n] = s2 }
+      # end
+      def check_type(setting,value,types)
+        return if value.nil?
+        if types.is_a? Array
+          types.each do |t|
+            return if value.is_a? t
+          end
+        else
+          return if value.is_a? type
+        end
+        raise "setting '#{setting}' is set to #{value.inspect} which is of type '#{value.class}', but should have been set to a #{types.map{|t|"'#{t}'"}.join(' or a ')}"
+      end
+      def deep_configure
+        configure
+        self.class.child_types.each_key do |name|
+          next unless hash = self.send(name.to_s.pluralize)
+          hash.each_value do |child|
+            child.deep_configure
+          end
+        end
+      end
+      def clear
+        self.class.possible_settings   .each_key {|s| self.send s, nil                               }
+        self.class.possible_child_types.each_key {|s| (hash = self.send s) and hash.delete_if {true} }
+        @configured = false
+      end
+      def configure
+        return if @configured
+
+        if foster ; foster.configure ; @modes += foster.modes end
+        if parent ; parent.configure ; @modes += parent.modes end
+        @modes.uniq!
+
+        verbose "configuring #{@name}"
+
+        find_parent_values(:foster)
+        find_parent_values(:parent)
+        
+        @base_types.each do |t|
+          instance_calls(t.blks)
+        end
+        instance_calls(@blks)
+
+        @configured = true
+      end
+      def instance_calls(blks)
+        blks.each do |b|
+          if b.parameters.empty?
+            self.instance_exec(&b)
+          else
+            b.call(self)
+          end
+        end
+      end
+      # def eat_settings_hash(h,file)
+      #   h.each do |str,v|
+      #     k = str.to_sym
+      #     if s = (@settings[k] || @possible_settings[k])
+      #       s.set(v,file)
+      #     elsif c = @children[k]
+      #       if v.is_a? Array
+      #         str = str.sub(/s$/,'_array')
+      #         k = str.to_sym
+      #         c = @children[k]
+      #       end
+      #       if c.is_a? Hash
+      #         t = self.class.child_types[k]
+      #         # FIXME fault if v is not also hash ?? Maybe support strings and arrays also ??
+      #         raise "v is a #{v.class}" unless v.is_a? Hash
+      #         v.each do |kc,vc|
+      #           tmp = (c[kc] ||= t.new(self))
+      #           tmp.name = kc
+      #           tmp.eat_settings_hash(vc,file) if vc
+      #         end
+      #       elsif c.is_a? Array
+      #         t = self.class.child_types[k]
+      #         # FIXME fault if v is not also hash ?? Maybe support strings and arrays also ??
+      #         raise "v is a #{v.class}" unless v.is_a? Array
+      #         v.each do |vc|
+      #           c << (tmp = t.new(self))
+      #           tmp.eat_settings_hash(vc,file) if vc
+      #         end
+      #       else
+      #         c.eat_settings_hash(v,file)
+      #       end
+      #     end
+      #   end
+      # end
+      def find_parent_values(parent_type)
+        if parent = self.send(parent_type)
+          raise "parent #{parent.name} of type #{parent.class.class_string} has not yet been configured" unless parent.configured
+        end
+        self.class.possible_settings.each_key do |name|
+          next unless (self.send name).nil? # PROB UNNECESSARY
+          next unless parent = (self.send parent_type)
+          self.send name, (parent.send name)
+        end
+        self.class.possible_child_types.each do |name,type|
+          next unless parent = self.send(parent_type)
+          plural = name.to_s.pluralize
+          next unless child_defaults = parent.send(plural)
+          hash = instance_variable_or_equal(plural,HashWithIndifferentAccess.new)
+          child_defaults.each do |name,object|
+            object2            = (hash[name] ||= type.new)
+            object2.name     ||= name
+            object2.parent   ||= self
+            object2.blks       = object.blks + object2.blks
+            object2.abstract ||= object.abstract
+          end
+        end
+      end
+      def instance_variable_or_equal(name,value)
+        value = instance_variable_get("@#{name}") || value
+                instance_variable_set "@#{name}", value
+        value
+      end
+      # def meaningful_settings
+      #   return @meaningful_settings if @meaningful_settings
+      #   @meaningful_settings = Hash.new
+      #   @settings.each do |n,s|
+      #     @meaningful_settings[n] = s.value if s.value_set
+      #   end
+      #   @meaningful_settings
+      # end
+      # def to_hash
+      #   h = meaningful_settings.dup
+      #   @children.each do |t,c_hash|
+      #     h[t] = h2 = Hash.new
+      #     c_hash.each{|n,c| h2[n] = c.to_hash}
+      #   end
+      #   h
+      # end
+      # def to_regex(data)
+      #   data = data.join('|') if data.respond_to? :join
+      #   /#{data}/
+      # end
+      # def print_configuration
+      #   puts configuration_hash.to_yaml
+      # end
+      # def configuration_hash
+      #   h = {         :settings => settings_to_hash(@settings         ),
+      #        :possible_settings => settings_to_hash(@possible_settings),
+      #        :children          => {}                                  }
+      #   @children.each do |type,children|
+      #     h[:children][type] = children.class.new
+      #     children.each do |name,child|
+      #       if child
+      #         h[:children][type][name] = child.configuration_hash
+      #       else
+      #         h[:children][type] << name.configuration_hash
+      #       end
+      #     end
+      #   end
+      #   h
+      # end
+      # def settings_to_hash(settings)
+      #   h = {}
+      #   @settings.each do |n,s|
+      #     if s.value_set
+      #       h[n] = s.value
+      #     end
+      #   end
+      #   h
+      # end
+      # methods that probably shouldn't be here, common to project and block
+      def find_file(file) 
+        found = nil
+        @search_paths ||= ['', @work_dir+'/', @top_dir+'/', @project.project_root+'/'].uniq
+        @search_paths.each do |p|
+          return found if File.exist?(found = "#{p}#{file}")
+        end
+        fault "Could not resolve path to file #{file.inspect}.  Attempted the following:\n#{@search_paths.map{|p| "  '#{p}#{file}'"}.join("\n")}"
+      end
+      def full_name
+        if self == BaseChip.project
+          nil
+        elsif @parent and @parent.full_name
+          "#{@parent.full_name}:#{@name}"
+        else
+          @name
+        end
+      end
+      alias task_name full_name
+      def steal_settings(object)
+        self.class.settings.each_key do |name|
+          if (value = object.send(name))
+            self.send(name, value)
+          end
+        end
+      end
+      def steal_children(object)
+        self.class.child_types.each_key do |name|
+          plural = name.to_s.pluralize
+          ohash = HashWithIndifferentAccess.new
+          if ihash = object.send(plural)
+            ihash.each do |key,value|
+              ohash[key] = value.clone if value
+            end
+            self.send("#{plural}=", ohash)
+          end
+        end
+      end
+      def clone
+        c = super
+        c.steal_children(self)
+        c
+      end
+      def file(f=nil)
+        if f
+          @file = absolute_path(f)
+          if File.exist? @file
+            instance_eval(File.read(@file),@file)
+          else
+            fault "file '#{@file}' could not be found for #{self.class_string.downcase} '#{@name}'" +
+              (self.parent ? " in #{self.parent.class_string.downcase} '#{self.parent.name}'" : '')
+          end
+        else
+          @file
+        end
+      end
+      def absolute_path(f)
+        if f =~ /^\//
+          f
+        else
+          "#{BaseChip.root}/#{f}"
+        end
+      end
+    end
+    attr_accessor :modes
+    def add_child_mode_as_child(child_name,mode)
+      if c = @children[child_name.to_sym]
+        c2       = c.clone
+        c2.blks  = c.blks # copy has the same blocks
+        c2.modes << mode
+      else
+        fault "add_child_mode_as_child could not find child '#{child_name}'"
+      end
+    end
+    def mode(name, &blk)
+      if mode? name
+        blk.call
+      end
+    end
+    def mode?(name)
+      # fault "Attempted to use mode '#{name}', which isn't registered with the project.  Call register_mode(#{name}) in project.rb to allow." unless project.registered_modes.include? name.to_s
+      if modes.include? name.to_s
+        ".#{name}"
+      end # else return nil
+    end
+    def type_plural
+      if    is_a? Project      ; 'project.subprojects'
+      elsif is_a? Block        ; 'project.blocks'
+      elsif is_a? Configuration; 'block.configurations'
+      elsif is_a? Action       ; 'configuration.actions'
+      elsif is_a? TestList     ; 'configuration.test_lists'
+      elsif is_a? Test         ; 'test_list.test'
+      else  fault "Could not determine type of '#{full_name}' in order to make 'inherit' call"
+      end
+    end
+    def inherit(name)
+      return if @base_types.map{|t|t.name}.include? name
+      things = parent.instance_eval(type_plural)
+      fault "'#{full_name}' tried to inherit from #{name.inspect}, but there are no '#{type_plural}' in '#{parent.full_name}'to extend'" unless things
+      thing  = things[name.to_sym]
+      fault "'#{full_name}' tried to inherit from #{name.inspect}, but '#{parent.full_name}.#{type_plural}[#{name.inspect}]' is nil'" unless thing
+      @base_types << thing
+    end
+
+    # only used in block and project
+    # def determine_dirs_to_top(dir = nil)
+    #   dir ||= @work_dir
+    #   @dirs_to_top = []
+    #   loop do
+    #     @dirs_to_top << dir
+    #     break if File.exist? dir + '/.cs_top'
+
+    #     if dir == '/'
+    #       fault "Couldn't find file '.cs_top' in any directory above #{@pwd}.\n" +
+    #             "'.cs_top' is an empty file expected to reside at the top of the checked out project.\n" +
+    #             "Go to the top of your check-out and type 'touch .cs_top'"
+    #     end
+    #     dir = File.expand_path(dir + '/../')
+    #   end
+    #   $environment['PROJECT_ROOT'] = $project_root = @project_root = dir
+    # end
+    # only used in block and project
+    # def read_settings_files(settings_files)
+    #   @settings_files = settings_files
+    #   @project_root = @project.project_root
+
+    #   # @settings_files += @supplimental_yaml if @supplimental_yaml
+    #   # @project.dirs_to_top.each do |d|
+    #   #   if File.exist? (file = d + '/settings.yaml')
+    #   #     @settings_files << file
+    #   #   end
+    #   # end
+
+    #   # print_configuration
+    #   @settings_files.each do |sf|
+    #     found = nil
+    #     sf = sf.gsub(/\$([A-Z_]+)/) { instance_variable_get "@#{$1.downcase}" }
+    #     sf = find_file sf
+    #     if h = YAML.load_file(sf)
+    #       self.eat_settings_hash(h,sf)
+    #       self.find_parent_values
+    #     end
+    #   end
+
+    #   # FIXME TODAY unless self.aliases.size > 0
+    #   # FIXME TODAY   fault "No aliases found"
+    #   # FIXME TODAY end
+
+    #   # FIXME TODAY unless self.actions.size > 0
+    #   # FIXME TODAY   fault "No action definitions were found in any of the following settings files:\n#{@settings_files.join("\n")}"
+    #   # FIXME TODAY end
+    #   
+    # end
+
+  end
+end

data/lib/base_chip/exit_error.rb

@@ -0,0 +1,20 @@
+# Copyright 2011 Tommy Poulter
+#
+# This file is part of basechip.
+#
+# basechip is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+# 
+# basechip is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with basechip.  If not, see <http://www.gnu.org/licenses/>.
+
+module BaseChip
+  class ExitError < RuntimeError
+  end
+end

data/lib/base_chip/generator_menu.rb

@@ -0,0 +1,64 @@
+# Copyright 2011 Tommy Poulter
+#
+# This file is part of basechip.
+#
+# basechip is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3 as
+# published by the Free Software Foundation.
+# 
+# basechip is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with basechip.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'base_chip/menu'
+module BaseChip
+  class GeneratorMenu < Menu
+    include Cli
+    option :git, :description=>"Check in generated files", :type=>:boolean, :alias=>[:g,:r,:repo]
+
+    desc "Generate a block"
+    def block(name)
+      BaseChip.load_environment
+      BaseChip.find_root(dir = nil)
+      @block_name = name
+      BaseChip.build_directory_structure(name,BaseChip.block_directories)
+      BaseChip.erb_template "#{BaseChip::GEM_DIR}/collateral/block/block.rb.erb", "#{BaseChip.root}/#{name}/base_chip/block.rb"
+      FileUtils.cd BaseChip.root
+      puts "block generation complete"
+
+      if options.git
+        system "git add ./#{name}"
+        system "git commit -m 'Initial automated block build of '#{name}' BaseChip.' ./#{name}"
+
+        normal "block '#{name}' has been created."
+      end
+    end
+
+    desc "Generate a configuration"
+    def configuration(name)
+      BaseChip.load_environment
+      BaseChip.find_root(dir = nil)
+      @configuration_name = name
+      BaseChip.build_directory_structure(name,BaseChip.configuration_directories)
+      BaseChip.erb_template "#{BaseChip::GEM_DIR}/collateral/configuration/configuration.rb.erb", "#{BaseChip.root}/#{name}/base_chip/configuration.rb"
+      FileUtils.cd BaseChip.root
+      puts "configuration generation complete"
+
+      if options.git
+        system "git add ./#{name}"
+        system "git commit -m 'Initial automated configuration build of '#{name}' BaseChip.' ./#{name}"
+
+        normal "configuration '#{name}' has been created."
+      end
+    end
+
+    desc "Generate a tool config file"
+    def tool(name)
+      puts "tool generation complete"
+    end
+  end
+end