ceedling 1.1.10 → 1.2.0

data/bin/mixin_standardizer.rb

@@ -15,8 +15,11 @@ class MixinStandardizer
 
   def smart_standardize(config:, mixin:, notices:)
     modified = false
-    modified |= smart_standardize_defines(config, mixin, notices)
-    modified |= smart_standardize_flags(config, mixin, notices)
+    # :defines ↳ <context> is one category level deep; :flags ↳ <context> ↳
+    # <operation> is two. Both bottom out at the same matcher-hash-or-array
+    # value standardize_matchers() knows how to reconcile.
+    modified |= smart_standardize_section(config, mixin, notices, :defines, depth: 1)
+    modified |= smart_standardize_section(config, mixin, notices, :flags, depth: 2)
     return modified
   end
 
@@ -24,73 +27,41 @@ class MixinStandardizer
 
   private
 
-  def smart_standardize_defines(config, mixin, notices)
+  # Walks a config section (:defines or :flags) through `depth` levels of
+  # matching category keys shared between config and mixin, then
+  # standardizes matcher conventions at the leaf value.
+  def smart_standardize_section(config, mixin, notices, section, depth:)
+    return false unless config[section] && mixin[section]
+
     modified = false
-    
-    # Bail out if config and mixin do noth both have :defines
-    return false unless config[:defines] && mixin[:defines]
-    
-    # Iterate over :defines ↳ <context> keys
-    # If both config and mixin contain the same key paths, process their (matcher) values
-    config[:defines].each do |context, context_hash|
-      if mixin[:defines][context]
 
-        # Standardize :defines ↳ <context> matcher conventions if they differ so they can be merged later
+    walk = lambda do |config_node, mixin_node, path, remaining_depth|
+      config_node.each do |key, value|
+        next unless mixin_node[key]
+
+        current_path = path + [key]
+
+        if remaining_depth > 1
+          walk.call( value, mixin_node[key], current_path, remaining_depth - 1 )
+          next
+        end
+
+        # Standardize matcher conventions at the leaf so they can be merged later
         standardized, notice = standardize_matchers(
-          config[:defines][context],
-          mixin[:defines][context],
-          config[:defines],
-          mixin[:defines],
-          context
+          value, mixin_node[key], config_node, mixin_node, key
         )
 
         if standardized
-          path, _ = @reportinator.generate_config_walk( [:defines, context] )
-          _notice = "At #{path}: #{notice}"
-          notices.push( _notice )
+          full_path, _ = @reportinator.generate_config_walk( [section] + current_path )
+          notices.push( "At #{full_path}: #{notice}" )
         end
 
         modified |= standardized
       end
     end
-    
-    return modified
-  end
 
-  def smart_standardize_flags(config, mixin, notices)
-    modified = false
-    
-    # Bail out if config and mixin do noth both have :flags
-    return false unless config[:flags] && mixin[:flags]
-    
-    # Iterate over :flags ↳ <context> ↳ <operation> keys
-    # If both config and mixin contain the same key paths, process their (matcher) values
-    config[:flags].each do |context, context_hash|
-      next unless mixin[:flags][context]
-      
-      context_hash.each do |operation, operation_hash|
-        if mixin[:flags][context][operation]
-
-          # Standardize :flags ↳ <context> ↳ <operation> matcher conventions if they differ so they can be merged later
-          standardized, notice = standardize_matchers(
-            config[:flags][context][operation],
-            mixin[:flags][context][operation],
-            config[:flags][context],
-            mixin[:flags][context],
-            operation
-          )
-
-          if standardized
-            path, _ = @reportinator.generate_config_walk( [:flags, context, operation] )
-            _notice = "At #{path}: #{notice}"
-            notices.push( _notice )
-          end
-
-          modified |= standardized
-        end
-      end
-    end
-    
+    walk.call( config[section], mixin[section], [], depth )
+
     return modified
   end
 
@@ -112,10 +83,9 @@ class MixinStandardizer
 
     # Promote config value list to all-matches matcher hash
     if config_value.is_a?(Array) && mixin_value.is_a?(Hash)
-      # Ensure all-matches matcher key is a symbol and not a string
-      if (deleted = mixin_value.delete( '*' ))
-        mixin_value[:*] = deleted
-      end
+      # mixin_value's own keys need no symbol/string normalization here --
+      # Mixinator#mixin already symbolizes every mixin key before this method
+      # ever runs, so a string '*' key is not possible on this side.
 
       # Replace the value of a simple array list with a matcher hash that stores the original list
       config_parent[key] = {:* => config_value}

data/bin/mixinator.rb

@@ -16,17 +16,6 @@ class Mixinator
     @standardinator = @mixin_standardizer
   end
 
-  def validate_cmdline_filepaths(paths)
-    validated = @path_validator.validate(
-      paths: paths,
-      source: 'Filepath argument',
-    )
-
-    if !validated
-      raise 'Mixins command line failed validation'
-    end
-  end
-
   def validate_cmdline_yaml_strings(yaml_strings)
     # Validate a list of inline YAML strings from --mixin "=..." command line arguments.
     # Errors are accumulated so the user sees all problems before the run aborts.
@@ -68,22 +57,32 @@ class Mixinator
   def fetch_env_filepaths(env)
     var_names = []
 
-    env.each do |var, filepath|
-      # Explicitly ignores CEEDLING_MIXIN_0
-      var_names << var if var =~ /CEEDLING_MIXIN_[1-9]\d*/
+    env.each_key do |var|
+      next unless var.start_with?( 'CEEDLING_MIXIN_' )
+
+      suffix = var.sub( 'CEEDLING_MIXIN_', '' )
+      unless suffix.match?( /\A\d+\z/ )
+        raise "Malformed mixin environment variable name '#{var}' — expected CEEDLING_MIXIN_<number>"
+      end
+
+      # Explicitly ignores CEEDLING_MIXIN_0 (a leading zero, e.g. CEEDLING_MIXIN_01,
+      # is otherwise treated the same as no leading zero)
+      var_names << var unless suffix.to_i() == 0
     end
 
-    # Extract numeric string (guranteed to exist) and convert to integer for ascending sorting
-    var_names.sort_by! {|name| name.match(/\d+$/)[0].to_i() }
+    # Ascending numeric order; to_i() ignores leading zeros so CEEDLING_MIXIN_01 sorts as 1
+    # -- meaning CEEDLING_MIXIN_1 and CEEDLING_MIXIN_01, two distinct, simultaneously-
+    # settable env var names, are a genuine tie here. Ruby's sort_by doesn't guarantee a
+    # stable order among ties, so the full original name is a second tiebreaker: both
+    # spellings resolve in a fixed, deterministic order instead of depending on sort
+    # stability for a case that can otherwise reach it.
+    var_names.sort_by! {|name| [name.sub( 'CEEDLING_MIXIN_', '' ).to_i(), name] }
 
     _vars = []
     # Iterate over sorted environment variable names
     var_names.each do |name|
-      # Duplicate the filepath string to get unfrozen copy
-      # Handle any Windows path shenanigans
-      # Insert in array {env var name => filepath}
-      path = env[name].dup()
-      @path_validator.standardize_paths( path )
+      # Handle any Windows path shenanigans; insert in array {env var name => filepath}
+      path = @path_validator.standardize_paths( env[name] ).first
       _vars << {name => path}
     end
 
@@ -121,11 +120,11 @@ class Mixinator
     #   3. Project configuration :enabled mixins (last → lowest dedup priority)
     #
     dedup = []
-    # cmdline entries are pre-tagged {source_label => value} hashes from configinator;
+    # cmdline entries are pre-tagged {source_label => value} hashes from composinator;
     # they carry either 'command line' (file/builtin) or 'command line (inline)' (YAML string)
     cmdline.each {|mixin| dedup << mixin}
     dedup += env
-    # config entries arrive pre-built from configinator as {'project configuration' => path, :_input => name}
+    # config entries arrive pre-built from composinator as {'project configuration' => path, :_input => name}
     config.each  {|entry| dedup << entry}
 
     # Remove duplicate mixins, keeping the highest-priority (first) occurrence.
@@ -157,7 +156,7 @@ class Mixinator
     return config_entries + env_entries + cmdline_entries
   end
 
-  def mixin(builtins:, config:, mixins:)
+  def mixin(config:, mixins:)
     mixins.each do |mixin|
       source = mixin.keys.first
       filepath = mixin.values.first
@@ -193,12 +192,11 @@ class Mixinator
         # Log what filepath we used for this mixin
         @loginator.lazy( Verbosity::OBNOXIOUS ) { " + Merging #{'(empty) ' if _mixin.nil?}#{source} mixin using #{filepath}" }
 
-      # Reference mixin from built-in hash-based mixins
+      # lookup_mixins() only ever hands back inline YAML or a real filepath for
+      # validated input -- reaching here means something upstream let an
+      # unresolved bare name through.
       else
-        _mixin = builtins[filepath.to_sym()]
-
-        # Log built-in mixin we used
-        @loginator.lazy( Verbosity::OBNOXIOUS ) { " + Merging built-in mixin '#{filepath}' from #{source}" }
+        raise "Mixin '#{filepath}' from #{source} could not be resolved to a file"
       end
 
       # Hnadle an empty mixin (it's unlikely but logically coherent and a good safety check)

data/bin/mixins.rb

@@ -5,10 +5,5 @@
 #   SPDX-License-Identifier: MIT
 # =========================================================================
 
-BUILTIN_MIXINS = {
-  # Mixin name as symbol => mixin config hash
-  # :mixin => {}
-}
-
 _vendor = defined?(CEEDLING_APPCFG) ? CEEDLING_APPCFG[:ceedling_vendor_path] : File.expand_path( File.join( File.dirname(__FILE__), '..', 'vendor' ) )
 BUILTIN_MIXIN_LOAD_PATHS = [ File.join( _vendor, UNITY_ROOT_PATH, 'test', 'targets' ) ].freeze

data/bin/objects.yml

@@ -11,8 +11,13 @@
 #
 
 file_wrapper:
+  compose:
+    - loginator
+    - verbosinator
 
 yaml_wrapper:
+  compose:
+    - file_wrapper
 
 ruby_expandinator:
 
@@ -29,7 +34,6 @@ rake_task_registry:
 loginator:
   compose:
     - verbosinator
-    - file_wrapper
     - system_wrapper
 
 #
@@ -37,17 +41,20 @@ loginator:
 # ----------------
 #
 
-actions_wrapper:
+actionator:
+  compose:
+    - file_wrapper
+    - loginator
 
 # Separation of logic from CLI user interface
 cli_handler:
   compose:
-    - configinator
+    - composinator
     - projectinator
     - cli_helper
     - path_validator
     - rake_task_registry
-    - actions_wrapper
+    - actionator
     - loginator
 
 cli_helper:
@@ -55,7 +62,7 @@ cli_helper:
     - file_wrapper
     - config_walkinator
     - path_validator
-    - actions_wrapper
+    - actionator
     - rake_task_registry
     - loginator
     - reportinator
@@ -89,13 +96,19 @@ projectinator:
     - path_validator
     - yaml_wrapper
     - loginator
-    - system_wrapper
+
+mixin_resolvinator:
+  compose:
+    - file_wrapper
+    - path_validator
+    - loginator
     - ruby_expandinator
 
-configinator:
+composinator:
   compose:
     - config_walkinator
     - projectinator
+    - mixin_resolvinator
     - mixinator
 
 

data/bin/path_validator.rb

@@ -36,12 +36,13 @@ class PathValidator
     return validated
   end
 
-  # Ensure any Windows backslashes are converted to Ruby path forward slashes
-  # Santization happens inline
+  # Ensure any Windows backslashes are converted to Ruby path forward slashes.
+  # Returns new values in the same order as the arguments given, rather than
+  # mutating the caller's own String objects in place.
   def standardize_paths( *paths )
-    paths.each do |path|
-      next if path.nil? or path.empty?
-      path.gsub!( "\\", '/' )
+    paths.map do |path|
+      next path if path.nil? or path.empty?
+      path.tr( "\\", '/' )
     end
   end
 

data/bin/projectinator.rb

@@ -12,22 +12,26 @@ class Projectinator
 
   PROJECT_FILEPATH_ENV_VAR = 'CEEDLING_PROJECT_FILE'
   DEFAULT_PROJECT_FILEPATH = './' + DEFAULT_PROJECT_FILENAME
+  # #1250 -- self-documenting alternative default project filename, tried only
+  # alongside DEFAULT_PROJECT_FILEPATH during default discovery below.
+  ALTERNATE_PROJECT_FILEPATH = './' + ALTERNATE_PROJECT_FILENAME
   DEFAULT_YAML_FILE_EXTENSION = '.yml'
 
-  constructor :file_wrapper, :path_validator, :yaml_wrapper, :loginator, :system_wrapper, :ruby_expandinator
+  constructor :file_wrapper, :path_validator, :yaml_wrapper, :loginator
 
   # Discovers project file path and loads configuration.
   # Precendence of attempts:
   #  1. Explcit flepath from argument
   #  2. Environment variable
-  #  3. Default filename in working directory
+  #  3. Default filename in working directory (project.yml or ceedling.yml --
+  #     #1250 -- an error if both exist, since neither is "preferred" over the other)
   # Returns:
   #  - Absolute path of project file found and used
   #  - Config hash loaded from project file
   def load(filepath:nil, env:{}, silent:false)
     # Highest priority: command line argument
     if filepath
-      @path_validator.standardize_paths( filepath )
+      filepath = @path_validator.standardize_paths( filepath ).first
       _filepath = File.expand_path( filepath )
       config = load_and_log( _filepath, 'from command line argument', silent )
       config[:history] = { config: [{type: :file, path: filepath, mechanism: :project}] }
@@ -35,9 +39,7 @@ class Projectinator
 
     # Next priority: environment variable
     elsif env[PROJECT_FILEPATH_ENV_VAR]
-      # ENV lookup is frozen so dup() to operate on the string
-      filepath = env[PROJECT_FILEPATH_ENV_VAR].dup()
-      @path_validator.standardize_paths( filepath )
+      filepath = @path_validator.standardize_paths( env[PROJECT_FILEPATH_ENV_VAR] ).first
       _filepath = File.expand_path( filepath )
       config = load_and_log(
         _filepath,
@@ -47,21 +49,38 @@ class Projectinator
       config[:history] = { config: [{type: :file, path: filepath, mechanism: :project}] }
       return _filepath, config
 
-    # Final option: default filepath
-    elsif @file_wrapper.exist?( DEFAULT_PROJECT_FILEPATH )
-      filepath = DEFAULT_PROJECT_FILEPATH
-      _filepath = File.expand_path( filepath )
-      config = load_and_log( _filepath, "from working directory", silent )
-      config[:history] = { config: [{type: :file, path: filepath, mechanism: :project}] }
-      return _filepath, config
-
-    # If no user-provided filepath and the default filepath does not exist, we have a big problem
+    # Final option: default filepath(s) in the working directory
     else
-      raise "No project filepath provided and default #{DEFAULT_PROJECT_FILEPATH} not found"
-    end
+      default_exists     = @file_wrapper.exist?( DEFAULT_PROJECT_FILEPATH )
+      alternate_exists    = @file_wrapper.exist?( ALTERNATE_PROJECT_FILEPATH )
+
+      # #1250 -- two default project files in one directory is almost certainly a
+      # mistake (which one would silently win?) -- error out rather than guess.
+      if default_exists && alternate_exists
+        raise CeedlingException.new( ambiguous_default_message() )
+      end
 
-    # We'll never get here but return nil/empty for completeness
-    return nil, {}
+      filepath =
+        if default_exists
+          DEFAULT_PROJECT_FILEPATH
+        elsif alternate_exists
+          ALTERNATE_PROJECT_FILEPATH
+        end
+
+      if filepath
+        _filepath = File.expand_path( filepath )
+        config = load_and_log( _filepath, "from working directory", silent )
+        config[:history] = { config: [{type: :file, path: filepath, mechanism: :project}] }
+        return _filepath, config
+
+      # If no user-provided filepath and neither default filepath exists, we have a big problem
+      else
+        raise CeedlingException.new(
+          "No project filepath provided and neither default " \
+          "#{DEFAULT_PROJECT_FILEPATH} nor #{ALTERNATE_PROJECT_FILEPATH} found"
+        )
+      end
+    end
   end
 
 
@@ -82,137 +101,27 @@ class Projectinator
   end
 
 
-  def lookup_yaml_extension(config:)
-    return DEFAULT_YAML_FILE_EXTENSION if config[:extension].nil?
-
-    return DEFAULT_YAML_FILE_EXTENSION if config[:extension][:yaml].nil?
-
-    return config[:extension][:yaml]
-  end
-
-
-  # Pick apart a :mixins projcet configuration section and return components
-  # Layout mirrors :plugins section
-  def extract_mixins(config:)
-    # Get mixins config hash
-    _mixins = config[:mixins]
-
-    # If no :mixins section, return:
-    #  - Empty enabled list
-    #  - Empty load paths
-    return [], [] if _mixins.nil?
-
-    # Build list of load paths
-    # Configured load paths are higher in search path ordering
-    load_paths = _mixins[:load_paths] || []
-
-    # Get list of mixins
-    enabled = _mixins[:enabled] || []
-    enabled = enabled.clone # Ensure it's a copy of configuration section
-
-    # Handle any inline Ruby string expansion
-    load_paths.each do |load_path|
-      load_path.replace( @ruby_expandinator.expand( load_path, source: ":mixins ↳ :load_paths" ) )
-    end
-
-    enabled.each do |mixin|
-      mixin.replace( @ruby_expandinator.expand( mixin, source: ":mixins ↳ :enabled" ) )
-    end
-
-    # Remove the :mixins section of the configuration
-    config.delete( :mixins )
-
-    return enabled, load_paths
-  end
-
-
-  # Validate :load_paths from :mixins section in project configuration
-  def validate_mixin_load_paths(load_paths)
-    validated = @path_validator.validate(
-      paths: load_paths,
-      source: 'Config :mixins ↳ :load_paths =>',
-      type: :directory
-    )
+  # The extensions of mixin files found by name, as a list. A project may set one or
+  # several with :extension ↳ :yaml, which is read here, from the project file, before
+  # configuration processing. Nothing after configuration processing uses the setting.
+  def lookup_yaml_extensions(config:)
+    extensions = config[:extension][:yaml] if config[:extension].is_a?( Hash )
 
-    if !validated
-      raise 'Project configuration file section :mixins failed validation'
-    end
+    return Array( extensions || DEFAULT_YAML_FILE_EXTENSION )
   end
 
 
-  # Validate mixins list
-  def validate_mixins(mixins:, load_paths:, builtins:, source:, yaml_extension:)
-    validated = true
-
-    mixins.each do |mixin|
-      # Validate mixin filepaths
-      if @path_validator.filepath?( mixin )
-        if !@file_wrapper.exist?( mixin )
-          @loginator.log( "Cannot find mixin at #{mixin}", Verbosity::ERRORS )
-          validated = false
-        end
-
-      # Otherwise, validate that mixin name can be found in load paths or builtins
-      else
-        found = false
-        load_paths.each do |path|
-          if @file_wrapper.exist?( File.join( path, mixin + yaml_extension ) )
-            found = true
-            break
-          end
-        end
-
-        builtins.keys.each {|key| found = true if (mixin == key.to_s)}
-
-        if !found
-          msg = "#{source} '#{mixin}' cannot be found in mixin load paths as '#{mixin + yaml_extension}' or among built-in mixins"
-          @loginator.log( msg, Verbosity::ERRORS )
-          validated = false
-        end
-      end
-    end
-
-    return validated
-  end
-
-
-  # Yield ordered list of filepaths or built-in mixin names
-  def lookup_mixins(mixins:, load_paths:, builtins:, yaml_extension:)
-    _mixins = []
-
-    # Already validated, so we know:
-    #  1. Any mixin filepaths exists
-    #  2. Built-in mixin names exist in the internal hash
-
-    # Fill filepaths array with filepaths or builtin names
-    mixins.each do |mixin|
-      # Handle explicit filepaths
-      if @path_validator.filepath?( mixin )
-        _mixins << mixin
-        next # Success, move on in mixin iteration
-      end
-
-      # Look for mixin in load paths.
-      # Move on in mixin iteration if mixin is found.
-      next if load_paths.any? do |path|
-        filepath = File.join( path, mixin + yaml_extension )
-        exist = @file_wrapper.exist?( filepath )
-        _mixins << filepath if exist
-        exist
-      end
-
-      # Finally, fall through to simply add the unmodified name to the list.
-      # It's a built-in mixin.
-      _mixins << mixin
-    end
-
-    return _mixins
-  end
-
   ### Private ###
 
   private
 
+  # #1250 -- mirrors PathMatcher's own ambiguous-file message style (path_matcher.rb).
+  def ambiguous_default_message
+    "Ambiguous default project file: both #{DEFAULT_PROJECT_FILEPATH} and " \
+    "#{ALTERNATE_PROJECT_FILEPATH} exist in the working directory. " \
+    "Remove or rename one, or specify which to use with --project/-p."
+  end
+
   def load_and_log(filepath, method, silent)
     begin
       # Load the filepath we settled on as our project configuration

data/bin/rake_patches.rb

@@ -13,7 +13,7 @@ module CaptureHelpOutput
     original_stdout = $stdout
     output_string = StringIO.new
     $stdout = output_string
-    
+
     begin
       # Call the original method that writes directly to $stdout with printf()
       display_tasks_and_comments
@@ -24,8 +24,42 @@ module CaptureHelpOutput
 
     # Restore original stdout
     $stdout = original_stdout
-    
+
     # Return the captured output
     output_string.string
   end
 end
+
+# On Windows, a `rule()`-matched task name containing a *second* colon (e.g.
+# "release:compile:foo.c" from the ad hoc release:compile:<file>/release:assemble:<file>
+# tasks -- lib/ceedling/rakefiles/release/rules_release.rake) makes File.mtime raise Errno::EINVAL instead
+# of the Errno::ENOENT FileTask#needed?/#timestamp already rescue elsewhere. A rule()
+# match is never a real file -- Rake synthesizes a FileTask named after the literal
+# matched string -- so on POSIX, File.mtime on that nonexistent name correctly raises
+# ENOENT and FileTask's own rescue treats it as "always stale, build it." Windows raises
+# EINVAL instead specifically because a second colon in a path only parses as valid NTFS
+# Alternate Data Stream syntax when followed by one of a handful of recognized stream-type
+# tokens ($DATA, etc.) -- an arbitrary filename like "foo.c" isn't one, so the OS rejects
+# the whole path as malformed rather than merely absent. (A single colon, as in every
+# other rule()-matched task name in this codebase -- e.g. "test:TestFoo.c" -- parses as
+# ordinary ADS "base:stream" syntax and correctly reports ENOENT when the base doesn't
+# exist, which is why only these two release tasks are affected.) Wrapping both methods
+# to treat EINVAL the same as ENOENT lets Rake's own existing "not really a file, build
+# it" handling apply on Windows too, rather than crashing the whole build.
+module Rake
+  module ColonTaskNameFileTaskPatch
+    def needed?
+      super
+    rescue Errno::EINVAL
+      true
+    end
+
+    def timestamp
+      super
+    rescue Errno::EINVAL
+      Rake::LATE
+    end
+  end
+
+  FileTask.prepend( ColonTaskNameFileTaskPatch )
+end

data/bin/recursive_merger.rb

@@ -35,7 +35,8 @@
 ##   Single value merged into a config list:
 ##     The mixin's single value is wrapped in a one-element list and then
 ##     placed BEFORE the config list entries, consistent with the general
-##     list rule above.
+##     list rule above. The same [:tools, <tool name>, :arguments] exception
+##     applies here too: a single value at that path is appended instead.
 ##
 ##   List merged into a config single value:
 ##     The mixin's list replaces the config value outright. This is flagged
@@ -87,6 +88,11 @@ class RecursiveMerger
             # appears first in the combined list (e.g. include search paths).
             config[key] = mixin_val + config_val
           end
+        elsif tool_arguments_path?(current_path)
+          # EXCEPTION: same left-to-right override guarantee as the list + list
+          # case above applies here too, even though this mixin value is a
+          # single value rather than the expected Array.
+          config[key] = config_val + [mixin_val]
         else
           # Mixin has a single value (or hash treated as a value) where config
           # has a list. Wrap the mixin value in a one-element list and prepend

data/bin/versionator.rb

@@ -25,7 +25,6 @@ class Versionator
     ##
 
     @ceedling_install_path = ceedling_root_path.clone()
-    ceedling_git_sha = nil
 
     # Set Ceedling tag
     @ceedling_tag = Ceedling::Version::TAG
@@ -74,8 +73,8 @@ class Versionator
         raise CeedlingException.new( "Could not collect version information for vendor component ⏩️ #{filename}" )
       end
 
-      # Splat version and evaluate it to create Versionator object accessor
-      eval("@#{name.downcase}_tag = '#{version.join(".")}'")
+      # Set the version tag accessor directly instead of building and evaling a string
+      instance_variable_set("@#{name.downcase}_tag", version.join('.'))
     end
   end
 end