RGen::ModelBuilder::BuilderContext

# File lib/rgen/model_builder/builder_context.rb, line 303
def associateWithContextElement(element, contextElement, asRole)
  return unless contextElement
  contextClass = contextElement.class.ecore
  if asRole
    asRoleRef = eAllReferences(contextClass).find{|r| r.name == asRole.to_s}
    raise "Context class #{contextClass.name} has no reference named #{asRole}" unless asRoleRef
    ref = asRoleRef
  else
    possibleContainmentRefs = containmentRefs(contextClass, element.class.ecore)
    if possibleContainmentRefs.size == 1
      ref = possibleContainmentRefs.first
    elsif possibleContainmentRefs.size == 0
      raise "Context class #{contextClass.name} can not contain a #{element.class.ecore.name}"
    else
      raise "Context class #{contextClass.name} has several containment references to a #{element.class.ecore.name}." +
        " Clearify using \":as => <role>\""
    end
  end
  if ref.many
    contextElement.addGeneric(ref.name, element)
  else
    contextElement.setGeneric(ref.name, element)
  end
end

# File lib/rgen/model_builder/builder_context.rb, line 35
def const_missing(name)
  if @@currentBuilderContext
    ConstPathElement.new(name, @@currentBuilderContext)
  else
    super
  end
end

# File lib/rgen/model_builder/builder_context.rb, line 295
def containmentRefs(contextClass, eClass)
  @containmentRefs ||= {}
  @containmentRefs[[contextClass, eClass]] ||=
    eAllReferences(contextClass).select do |r| 
      r.containment && (eClass.eAllSuperTypes << eClass).include?(r.eType)
    end
end

# File lib/rgen/model_builder/builder_context.rb, line 31
def currentBuilderContext=(bc)
 @@currentBuilderContext = bc
end

# File lib/rgen/model_builder/builder_context.rb, line 290
def eAllReferences(eClass)
  @eAllReferences ||= {}
  @eAllReferences[eClass] ||= eClass.eAllReferences
end

# File lib/rgen/model_builder/builder_context.rb, line 254
def filterArgHash(argHash, eClass)
  resolverJobs = []
  asRole, helperName = nil, nil
  refByName = {}
  eAllReferences(eClass).each {|r| refByName[r.name] = r}
  argHash.each_pair do |k,v|
    if k == :as
      asRole = v
      argHash.delete(k)
    elsif k == :name && !hasNameAttribute(eClass)
      helperName = v          
      argHash.delete(k)
    elsif v.is_a?(String)
      ref = refByName[k.to_s]#eAllReferences(eClass).find{|r| r.name == k.to_s}
      if ref
        argHash.delete(k)
        resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil,  v)
      end
    elsif v.is_a?(Array)
      ref = refByName[k.to_s] #eAllReferences(eClass).find{|r| r.name == k.to_s}
      ref && v.dup.each do |e|
        if e.is_a?(String)
          v.delete(e)
          resolverJobs << ReferenceResolver::ResolverJob.new(nil, ref, nil, e)
        end
      end
    end
  end
  [ resolverJobs, asRole, helperName ]
end

# File lib/rgen/model_builder/builder_context.rb, line 285
def hasNameAttribute(eClass)
  @hasNameAttribute ||= {}
  @hasNameAttribute[eClass] ||= eClass.eAllAttributes.any?{|a| a.name == "name"}
end

# File lib/rgen/model_builder/builder_context.rb, line 11
def initialize(package, extensionsModule, resolver, env=nil)
  package = package.ecore unless package.is_a?(RGen::ECore::EPackage)
  raise "First argument must be a metamodel package"        unless package.is_a?(RGen::ECore::EPackage)
  @rootPackage, @env = package, env
  @commandResolver = CommandResolver.new(package, extensionsModule, self)
  @package = @rootPackage
  @resolver = resolver
  @contextStack = []
  @toplevelElements = []
  @helperNames = {}
end

# File lib/rgen/model_builder/builder_context.rb, line 237
def processArguments(args)
  unless (args.size == 2 && args.first.is_a?(String) && args.last.is_a?(Hash)) ||
    (args.size == 1 && (args.first.is_a?(String) || args.first.is_a?(Hash))) ||
    args.size == 0
    raise "Provide a Hash to set feature values, " +
      "optionally the first argument may be a String specifying " + 
      "the value of the \"name\" attribute."
  end
  if args.last.is_a?(Hash)
    argHash = args.last
  else
    argHash = {}
  end
  nameArg = args.first if args.first.is_a?(String)
  [nameArg, argHash]
end

# File lib/rgen/model_builder/builder_context.rb, line 214
def resolvePackage(contextPackage, rootPackage, path)
  begin
    return resolvePackageDownwards(contextPackage, path)
  rescue PackageNotFoundException
    if contextPackage.eSuperPackage && contextPackage != rootPackage
      return resolvePackage(contextPackage.eSuperPackage, rootPackage, path)
    else
      raise
    end
  end
end

# File lib/rgen/model_builder/builder_context.rb, line 226
def resolvePackageDownwards(contextPackage, path)
  first, *rest = path
  package = contextPackage.eSubpackages.find{|p| p.name == first}
  raise PackageNotFoundException.new("Could not resolve package: #{first} is not a subpackage of #{contextPackage.name}") unless package
  if rest.empty?
    package 
  else
    resolvePackageDownwards(package, rest)
  end
end

# File lib/rgen/model_builder/builder_context.rb, line 109
def _context(depth=1)
  @contextStack[-depth]
end

# File lib/rgen/model_builder/builder_context.rb, line 102
def _using(constPathElement, &block)
  @package, oldPackage = 
    self.class.resolvePackage(@package, @rootPackage, constPathElement.constPath), @package
  instance_eval(&block)
  @package = oldPackage
end

# File lib/rgen/model_builder/builder_context.rb, line 24
def const_missing_delegated(delegator, const)
  ConstPathElement.new(const, self)
end

# File lib/rgen/model_builder/builder_context.rb, line 68
def method_missing(m, *args, &block)
  package, classOrContainer = @commandResolver.resolveCommand(m, @package)
  return super if package.nil?
  return classOrContainer.send(m, *args, &block) if classOrContainer.is_a?(ExtensionContainerFactory::ExtensionContainer)
  eClass = classOrContainer
  nameArg, argHash = self.class.processArguments(args)
  internalName = nameArg || argHash[:name]
  argHash[:name] ||= nameArg if nameArg && self.class.hasNameAttribute(eClass)
  resolverJobs, asRole, helperName = self.class.filterArgHash(argHash, eClass)
  element = eClass.instanceClass.new(argHash)
  @resolver.setElementName(element, internalName)
  @env << element if @env
  contextElement = @contextStack.last
  if contextElement
    self.class.associateWithContextElement(element, contextElement, asRole)
  else
    @toplevelElements << element
  end
  resolverJobs.each do |job|
    job.receiver = element
    job.namespace = contextElement
    @resolver.addJob(job)
  end
  # process block
  if block
    @contextStack.push(element)
    @package, oldPackage = package, @package
    instance_eval(&block)
    @package = oldPackage
    @contextStack.pop
  end
  element
end