Mxx_ru 1.1.0

data/lib/mxx_ru/abstract_target.rb

@@ -0,0 +1,283 @@
+#--
+# Copyright (c) 1996-2004, Yauheni Akhotnikau
+# Copyright (c) 2004-2006, JSC Intervale
+# Copyright (c) 2006, The Mxx_ru Project
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+require 'mxx_ru/ex'
+
+require 'mxx_ru/util'
+
+module Mxx_ru
+
+  # File name of root project file.
+  BUILD_ROOT = "build.rb"
+
+  # Target status description.
+  class Target_state
+    # Target is absent or rebuild is required.
+    ABSENT = 0
+    # Target was rebuilt.
+    REBUILT = 1
+    # Target exists and up-to-date.
+    EXISTS = 2
+
+    attr_reader :state
+
+    def initialize( a_state = ABSENT )
+      @state = a_state
+    end
+
+    # Detect target status.
+    # Target_state object returned.
+    #
+    # [_name_] Target name.
+    # [_depends_] Dependencies list. Array of String.
+    def Target_state.detect( name, depends )
+
+      state = ABSENT
+
+      # In dry-run mode we always return that target is absent.
+      if !Mxx_ru::Util::Mode.instance.is_dry_run
+        if FileTest.exists?( name )
+          # It's necessary to detect time of target and it's dependencies.
+          target_mtime = File.mtime( name )
+          if nil != depends.find { |d|
+              if !FileTest.exists?( d )
+                raise Mxx_ru::Missing_depend_file_ex.new( d, name )
+              end
+              depend_mtime = File.mtime( d )
+              target_mtime < depend_mtime
+            }
+            # More young dependency found.
+            state = REBUILT
+          else
+            # Target is up-to-date.
+            state = EXISTS
+          end
+        end
+      end
+
+      return Target_state.new( state )
+    end
+
+  end # Class Target_state
+
+  # Map of targets loaded.
+  # Key is target alias -- file name with definition of a target.
+  @@defined_targets = Hash.new
+
+  # Root target alias.
+  # This target will be used in setup_target function to start building process.
+  @@first_target_alias = nil
+
+  def Mxx_ru.try_set_first_target_alias( a_alias )
+    if nil == @@first_target_alias
+      @@first_target_alias = a_alias.clone
+    end
+  end
+
+  def Mxx_ru.setup_target( target, build_enabled = true )
+    begin
+      if !( target_defined_for?( target.prj_alias ) )
+        @@defined_targets[ target.prj_alias ] = target;
+      end
+
+      if build_enabled && nil != @@first_target_alias &&
+        @@first_target_alias == target.prj_alias
+        # It is a root project, required to build.
+
+        # If this project is not root project file and root project file exists,
+        # then we will load root project file and start build process after that.
+        if BUILD_ROOT != target.prj_alias
+          if FileTest.exists?( BUILD_ROOT )
+            require BUILD_ROOT
+          end
+        end
+
+        if Mxx_ru::Util::Mode.instance.is_clean
+          target.clean
+        else
+          Mxx_ru::Util::build_call_wrapper( target )
+        end
+      end
+
+      return target
+    rescue Mxx_ru::Ex => ex
+      $stderr.print "<<<[#{ex.class.name}]\t#{ex}>>>\n"
+      exit( -2 )
+    end
+  end
+
+  def Mxx_ru.query_target( prj_alias, mandatory )
+    target = @@defined_targets[ prj_alias ]
+
+    # If target was required, we already should found it.
+    # Build should be stopper otherwise.
+    if target.nil? && mandatory
+      raise Target_unknown_ex.new( prj_alias )
+    end
+
+    return target
+  end
+
+  def Mxx_ru.target_defined_for?(prj_alias)
+    return true if @@defined_targets.has_key?( prj_alias )
+    return false
+  end
+
+  # Base class for all source code generators.
+  class Abstract_generator
+    # This method is called to generate source code required.
+    # Should be redefined in a child class.
+    #
+    # [_target_] Target, generator belongs to.
+    def build( target )
+      raise Abstract_method_ex.new( "Mxx_ru::Abstract_generator::build" )
+    end
+
+    # This method is called to cleanup of generated source code files.
+    #
+    # [_target_] Target, generator belongs to.
+    def clean( target )
+      raise Abstract_method_ex.new( "Mxx_ru::Abstract_generator::clean" )
+    end
+  end
+
+  # Base class for all targets.
+  class Abstract_target
+    # List of full file names, created during a build of the target.
+    # It may be an empty array if target doesn't create any files.
+    # For example, if target is a composite or unittest.
+    attr_reader :mxx_full_targets_names
+
+    # Vector of subordinated projects.
+    attr_reader :mxx_required_prjs
+
+    # Vector of source code generators.
+    attr_reader :mxx_generators
+
+    def initialize( a_prj_alias )
+      @mxx_full_targets_names = Array.new
+      @mxx_prj_alias = a_prj_alias
+      @mxx_required_prjs = Array.new
+      @mxx_generators = Array.new
+
+      Mxx_ru.try_set_first_target_alias( a_prj_alias )
+    end
+
+    # Add one more file, created during a target build.
+    def mxx_add_full_target_name( a_full_name )
+      @mxx_full_targets_names << a_full_name
+    end
+
+    def prj_alias
+      return @mxx_prj_alias
+    end
+
+    # Add one more project in a list of subordinated projects.
+    #
+    # Returns target object, which is defined in subordinated project.
+    def required_prj( a_prj )
+      # If project is not loaded yet, loding it.
+      # Then adding created target object to the list ofd subordinated projects.
+      # If no target will be created, exception would be thrown.
+      if !Mxx_ru::target_defined_for?( a_prj )
+        require a_prj
+      end
+
+      target = Mxx_ru::query_target( a_prj, true )
+      @mxx_required_prjs << target
+
+      return target
+    end
+
+    # Add one more generator to the target.
+    # Reference to the target is returned.
+    def generator( a_generator )
+      @mxx_generators << a_generator
+      return a_generator
+    end
+
+    # Child classes should redefine this method.
+    # Target_state object is returned.
+    def build
+      raise Abstract_method_ex.new( "Abstract_target::build" )
+    end
+
+    # Child classes should redefine this method.
+    def clean
+      raise Abstract_method_ex.new( "Abstract_target::clean" )
+    end
+
+    # Executing command line given.
+    #
+    # [a_cmd_lines] Array of String
+    # [a_to_destroy_on_fail] Files required to be cleaned up if any of given command fail.
+    def Abstract_target.run( a_cmd_lines, a_to_destroy_on_fail )
+
+      a_cmd_lines.each { |c|
+          if Mxx_ru::Util::Mode.instance.is_show_cmd
+            puts "<<< #{c} >>>"
+          end
+
+          # Do not actually execute in dry-run mode.
+          if !Mxx_ru::Util::Mode.instance.is_dry_run
+            if !system( c )
+              a_to_destroy_on_fail.each { |d|
+                Mxx_ru::Util::delete_file( d ) }
+              raise Build_ex.new( c, $? )
+            end
+          end
+        }
+    end
+
+  protected
+    # Build of all projects required for the target.
+    # Returns Mxx_ru::Target_state.
+    def build_required_projects
+      state = Mxx_ru::Target_state::EXISTS
+      @mxx_required_prjs.each { |p|
+          prj_state = Mxx_ru::Util::build_call_wrapper( p )
+          if Mxx_ru::Target_state::EXISTS != prj_state.state
+            state = prj_state.state
+          end
+        }
+
+      return Mxx_ru::Target_state.new( state )
+    end
+
+    # Cleanup of all projects required for the target.
+    # Executed only if dry-run mode is disabled.
+    def clean_required_prjs
+      if !Mxx_ru::Util::Mode.instance.is_dry_run
+        @mxx_required_prjs.each { |p| p.clean }
+      end
+    end
+
+  end
+
+end
+

data/lib/mxx_ru/binary_target.rb

@@ -0,0 +1,89 @@
+#--
+# Copyright (c) 1996-2004, Yauheni Akhotnikau
+# Copyright (c) 2004-2006, JSC Intervale
+# Copyright (c) 2006, The Mxx_ru Project
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+require 'mxx_ru/abstract_target'
+require 'mxx_ru/ex'
+
+# Base class for all targets, which are binary executables, binary shared libraries or
+# binary static libraries.
+module Mxx_ru
+
+  class Binary_target < Mxx_ru::Abstract_target
+    def initialize( a_prj_alias )
+      super( a_prj_alias )
+
+      # Libraries list, which would be required to the user of current target.
+      @mxx_required_libs = Array.new
+      # Attribute showing that before return from mxx_required_libs
+      # dublicates should be removed.
+      @mxx_required_libs_changed = true
+      # Folder list, where libraries, encountered in mxx_required_libs, 
+      # should be searched for
+      @mxx_required_lib_paths = Array.new
+      # Attribute showing that before return from mxx_required_lib_paths
+      # dublicates should be removed.
+      @mxx_required_lib_paths_changed = true
+    end
+
+    # Get all libraries list, which are required to be linked to for
+    # correct usage of given target.
+    # Returns array of strings.
+    def mxx_required_libs
+      if @mxx_required_libs_changed
+        @mxx_required_libs.flatten!
+        @mxx_required_libs_changed = false
+      end
+      return @mxx_required_libs
+    end
+
+    # Add library to list of requirements.
+    def mxx_add_required_lib( a_lib )
+      @mxx_required_libs << a_lib
+      @mxx_required_libs_changed = true
+    end
+
+    # Get list of all paths to libraries, which should be used to search libraries,
+    # returned by mxx_required_libs method.
+    # Returns array of strings.
+    def mxx_required_lib_paths
+      if @mxx_required_lib_paths_changed
+        @mxx_required_lib_paths.flatten!
+        @mxx_required_lib_paths_changed = false
+      end
+      return @mxx_required_lib_paths
+    end
+
+    # Add folder to search folders list.
+    def mxx_add_required_lib_path( a_path )
+      @mxx_required_lib_paths << a_path
+      @mxx_required_lib_paths_changed = true
+    end
+
+  end
+
+end

data/lib/mxx_ru/binary_unittest.rb

@@ -0,0 +1,130 @@
+#--
+# Copyright (c) 1996-2004, Yauheni Akhotnikau
+# Copyright (c) 2004-2006, JSC Intervale
+# Copyright (c) 2006, The Mxx_ru Project
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#++
+
+require 'mxx_ru/ex'
+require 'mxx_ru/abstract_target'
+
+module Mxx_ru
+
+# Class describing a target, which is unit-test binary application.
+#
+# The idea is, that there is project file, which controls the build process
+# of unit-test application. In that project file target object is created,
+# inherited from Mxx_ru::Binary_target.
+# To initialize unit-test it's required to create one more file, where
+# target object of Mxx_ru::Binary_unittest_target class is created.
+# For example:
+#
+# File to compile unit-test.
+#  Mxx_ru::setup_target(
+#    Mxx_ru::Cpp::Exe_target.new( "test/pack/prj.rb" ) {
+#      ...
+#    }
+#  )
+#
+# File to run unit-test.
+#  Mxx_ru::setup_target(
+#    Mxx_ru::Binary_unittest_target.new( 
+#      "test/pack/ut.rb",
+#      "test/pack/prj.rb ) )
+# 
+# File to use unit-test.
+#  Mxx_ru::setup_target(
+#    Mxx_ru::Cpp::Composite_target( Mxx_ru::BUILD_ROOT ) {
+#      required_prj( "some/project/prj.rb" )
+#      required_prj( "test/pack/ut.rb" )
+#    }
+#  )
+#
+class Binary_unittest_target < Abstract_target
+
+  # Exception, thrown if subordinated project created more then one result name.
+  class Must_be_one_target_name_ex < Ex
+    # [_a_names_] Generated result names.
+    def initialize( a_names )
+      super( "Only one name expected in [#{a_names.join(';')}]" )
+    end
+  end
+
+  # Target, responsible for build of unit-test application.
+  attr_reader :mxx_target_project
+  # Attribute, showing that build method was already executed.
+  attr_reader :mxx_build_state
+
+  # Constructor.
+  #
+  # [_a_alias_] Self alias.
+  # [_a_target_project_] Project, responsible for build of unit-test
+  #                      application.
+  def initialize( a_alias, a_target_project )
+    super( a_alias )
+
+    @mxx_build_state = nil
+
+    @mxx_target_project = required_prj( a_target_project )
+  end
+
+  # Build subordinated project and run it.
+  #
+  # If unit-test application returns result, other then 0,
+  # exception is thrown.
+  def build
+    if !@mxx_build_state
+      @mxx_target_project.build
+
+      # Determining application name.
+      full_names = @mxx_target_project.mxx_full_targets_names
+      if 1 != full_names.size
+        raise Must_be_one_target_name_ex.new( full_names )
+      end
+
+      # In dry-run do not actually execute anything.
+      if !Mxx_ru::Util::Mode.instance.is_dry_run
+        puts "running unit test: #{full_names[0]}..."
+        if !system( full_names[ 0 ] )
+          puts "\n\nunit test '#{full_names[0]}' FAILED! #{$?}"
+          raise Build_ex.new( full_names[ 0 ], $? )
+        end
+      end
+
+      @mxx_build_state = Target_state.new( Target_state::REBUILT )
+    end
+
+    return @mxx_build_state
+  end
+
+  # Project cleanup.
+  #
+  # Just execute clean method from subordinated project.
+  def clean
+    @mxx_target_project.clean
+  end
+end
+
+end
+