rtext 0.2.0

data/lib/rtext/context_element_builder.rb

@@ -0,0 +1,112 @@
+module RText
+
+# ContextElementBuilder build a partial model from a set of context lines.
+#
+# Context lines are lines from an RText file which contain a (context) command and all 
+# the parent commands wrapped around it. Any sibling commands can be omitted as well as
+# any lines containing closing braces and brackets.
+#
+# The resulting partial model contains a (context) model element and all its parent
+# elements. Further references are not resolved.
+#
+module ContextElementBuilder
+
+  class << self
+
+  # Instantiates the context element based on a set of +content_lines+. Content lines
+  # are the RText lines containing the nested command headers in the original order.
+  # The last line of +context_lines+ is the one which will create the context element.
+  # +position_in_line+ is the cursor column position within the last line
+  def build_context_element(language, context_lines, position_in_line)
+    context_info = fix_context(context_lines)
+    return nil unless context_info
+    element = instantiate_context_element(language, context_info)
+    unless element
+      fix_current_line(context_info, position_in_line)
+      element = instantiate_context_element(language, context_info)
+    end
+    element
+  end
+
+  private
+
+  def instantiate_context_element(language, context_info)
+    root_elements = []
+    problems = []
+    Instantiator.new(language).instantiate(context_info.lines.join("\n"),
+      :root_elements => root_elements, :problems => problems)
+    if root_elements.size > 0
+      find_leaf_child(root_elements.first, context_info.num_elements-1)
+    else
+      nil
+    end
+  end
+
+  def find_leaf_child(element, num_required_children)
+    childs = element.class.ecore.eAllReferences.select{|r| r.containment}.collect{|r|
+      element.getGenericAsArray(r.name)}.flatten
+    if childs.size > 0
+      find_leaf_child(childs.first, num_required_children-1)
+    elsif num_required_children == 0
+      element
+    else
+      nil
+    end
+  end
+
+  ContextInfo = Struct.new(:lines, :num_elements, :pos_leaf_element)
+
+  # extend +context_lines+ into a set of lines which can be processed by the RText
+  # instantiator: cut of curly brace from current line if present and add missing
+  # closing curly braces and square brackets
+  # returns a ContextInfo containing the new set of lines, the number of model elements
+  # contained in this model snipped and the number of the line containing the leaf element
+  def fix_context(context_lines)
+    context_lines = context_lines.dup
+    line = context_lines.last
+    return nil if line.nil? || is_non_element_line(line)
+    context_lines << strip_curly_brace(context_lines.pop)
+    pos_leaf_element = context_lines.size-1
+    num_elements = 1
+    context_lines.reverse.each do |l|
+      if l =~ /\{\s*$/
+        context_lines << "}"
+        num_elements += 1
+      elsif l =~ /\[\s*$/
+        context_lines << "]"
+      end
+    end
+    ContextInfo.new(context_lines, num_elements, pos_leaf_element)
+  end
+
+  def is_non_element_line(line)
+    line = line.strip
+    line == "" || line == "}" || line == "]" || line =~ /^#/ || line =~ /^\w+:$/
+  end
+
+  def strip_curly_brace(line)
+    line.sub(/\{\s*$/,'') 
+  end
+
+  def fix_current_line(context_info, pos_in_line)
+    context_info.lines[context_info.pos_leaf_element] = 
+      cut_current_argument(context_info.lines[context_info.pos_leaf_element], pos_in_line)
+  end
+
+  def cut_current_argument(line, pos_in_line)
+    left_comma_pos = line.rindex(",", pos_in_line-1)
+    if left_comma_pos
+      line[0..left_comma_pos-1]
+    elsif line =~ /^\s*\w+/
+      $&
+    else
+      ""
+    end
+  end
+
+  end
+
+end
+
+end
+

data/lib/rtext/default_loader.rb

@@ -0,0 +1,137 @@
+require 'rgen/environment'
+require 'rgen/util/file_change_detector'
+require 'rgen/fragment/model_fragment'
+require 'rtext/instantiator'
+
+module RText
+
+# Loads RText files into a FragmentedModel.
+#
+# A glob pattern or file provider specifies the files which should be loaded. The load method
+# can be called to load and to reload the model. Only changed files will be reloaded. 
+#
+# Optionally, the loader can use a fragment cache to speed up loading.
+#
+class DefaultLoader
+
+  # Create a default loader for +language+, loading into +fragmented_model+.
+  # It will find files either by evaluating the glob pattern given with +:pattern+ 
+  # (see Dir.glob) or by means of a +file_provider+. Options:
+  #
+  #  :pattern
+  #    a glob pattern or an array of glob patterns
+  #    alternatively, a +:file_provider+ may be specified
+  #
+  #  :file_provider
+  #    a proc which is called without any arguments and should return the files to load
+  #    this is an alternative to providing +:pattern+
+  #
+  #  :cache
+  #    a fragment cache to be used for loading
+  #
+  def initialize(language, fragmented_model, options={})
+    @lang = language
+    @model = fragmented_model
+    @change_detector = RGen::Util::FileChangeDetector.new(
+      :file_added => method(:file_added),
+      :file_removed => method(:file_removed),
+      :file_changed => method(:file_changed))
+    @cache = options[:cache]
+    @fragment_by_file = {}
+    pattern = options[:pattern]
+    @file_provider = options[:file_provider] || proc { Dir.glob(pattern) }
+  end
+
+  # Loads or reloads model fragments from files using the file patterns or file provider 
+  # specified in the constructor. Options:
+  #
+  #  :before_load
+  #    a proc which is called before a file is actually loaded, receives the fragment to load
+  #    into and a symbol indicating the kind of loading: :load, :load_cached, :load_update_cache
+  #    default: no before load proc
+  # 
+  def load(options={})
+    @before_load_proc = options[:before_load]
+    files = @file_provider.call 
+    @change_detector.check_files(files)
+    @model.resolve(:fragment_provider => method(:fragment_provider),
+      :use_target_type => @lang.per_type_identifier)
+  end
+
+  private
+
+  def file_added(file)
+    fragment = RGen::Fragment::ModelFragment.new(file, 
+      :identifier_provider => @lang.identifier_provider)
+    load_fragment_cached(fragment)
+    @model.add_fragment(fragment)
+    @fragment_by_file[file] = fragment
+  end
+
+  def file_removed(file)
+    @model.remove_fragment(@fragment_by_file[file])
+    @fragment_by_file.delete(file)
+  end
+
+  def file_changed(file)
+    file_removed(file)
+    file_added(file)
+  end
+
+  def fragment_provider(element)
+    fr = @lang.fragment_ref(element)
+    fr && fr.fragment
+  end
+
+  def load_fragment_cached(fragment)
+    if @cache
+      begin
+        result = @cache.load(fragment)
+      rescue ArgumentError => e
+        # Marshal#load raises an ArgumentError if required classes are not present
+        if e.message =~ /undefined class\/module/
+          result = :invalid
+        else
+          raise
+        end
+      end
+      if result == :invalid
+        @before_load_proc && @before_load_proc.call(fragment, :load_update_cache)
+        load_fragment(fragment)
+        @cache.store(fragment)
+      else
+        @before_load_proc && @before_load_proc.call(fragment, :load_cached)
+      end
+    else
+      @before_load_proc && @before_load_proc.call(fragment, :load)
+      load_fragment(fragment)
+    end
+  end
+
+  def load_fragment(fragment)
+    env = RGen::Environment.new
+    urefs = []
+    problems = []
+    root_elements = []
+    inst = RText::Instantiator.new(@lang)
+    File.open(fragment.location) do |f|
+      inst.instantiate(f.read,
+        :env => env,
+        :unresolved_refs => urefs,
+        :problems => problems,
+        :root_elements => root_elements,
+        :fragment_ref => fragment.fragment_ref,
+        :file_name => fragment.location)
+    end
+    fragment.data = {:problems => problems}
+    fragment.set_root_elements(root_elements,
+      :unresolved_refs => urefs, 
+      :elements => env.elements)
+    fragment.build_index
+    fragment.resolve_local(:use_target_type => @lang.per_type_identifier)
+  end
+
+end
+
+end
+

data/lib/rtext/default_service_provider.rb

@@ -0,0 +1,153 @@
+module RText
+
+class DefaultServiceProvider
+
+  def initialize(language, fragmented_model, model_loader)
+    @lang = language
+    @model = fragmented_model
+    @loader = model_loader 
+    @element_name_index = nil
+    @model.add_fragment_change_listener(proc {|fragment, kind|
+      @element_name_index = nil
+    })
+  end
+
+  def load_model
+    @loader.load
+  end
+
+  ReferenceCompletionOption = Struct.new(:identifier, :type)
+  def get_reference_completion_options(reference, context)
+    if @model.environment
+      targets = @model.environment.find(:class => reference.eType.instanceClass)
+    else
+      clazz = reference.eType.instanceClass
+      targets = @model.index.values.flatten.select{|e| e.is_a?(clazz)}
+    end
+    targets.collect{|t| 
+      ident = @lang.identifier_provider.call(t, context)
+      if ident
+        ReferenceCompletionOption.new(ident, t.class.ecore.name)
+      else
+        nil
+      end
+    }.compact.sort{|a,b| a.identifier <=> b.identifier}
+  end
+
+  ReferenceTarget = Struct.new(:file, :line, :display_name)
+  def get_reference_targets(identifier, context, lines, linepos)
+    result = []
+    identifier = @lang.qualify_reference(identifier, context)
+    targets = @model.index[identifier]
+    if targets && @lang.per_type_identifier
+      current_line = lines.last
+      linestart = current_line[0..linepos-1]
+      if linestart =~ /\s*(\w+)\s+(?:[^,]+,)*\s*(\w+):\s*(\S*)$/
+        command, fn, prefix = $1, $2, $3
+        clazz = @lang.class_by_command(command)
+        feature = clazz && @lang.non_containments(clazz.ecore).find{|f| f.name == fn}
+        if feature
+          targets = targets.select{|t| t.is_a?(feature.eType.instanceClass)}
+        end
+      end
+    end 
+    targets && targets.each do |t|
+      if @lang.fragment_ref(t)
+        path = File.expand_path(@lang.fragment_ref(t).fragment.location)
+        result << ReferenceTarget.new(path, @lang.line_number(t), "#{identifier} [#{t.class.ecore.name}]")
+      end
+    end
+    result
+  end
+
+  def get_referencing_elements(identifier, context)
+    result = []
+    targets = @model.index[@lang.identifier_provider.call(context, nil)]
+    if targets && @lang.per_type_identifier
+      targets = targets.select{|t| t.class == context.class}
+    end
+    if targets && targets.size == 1
+      target = targets.first
+      elements = target.class.ecore.eAllReferences.select{|r|
+        r.eOpposite && !r.containment && !r.eOpposite.containment}.collect{|r|
+          target.getGenericAsArray(r.name)}.flatten
+      elements.each do |e|
+        if @lang.fragment_ref(e)
+          path = File.expand_path(@lang.fragment_ref(e).fragment.location)
+          display_name = ""
+          ident = @lang.identifier_provider.call(e, nil)
+          display_name += "#{ident} " if ident
+          display_name += "[#{e.class.ecore.name}]"
+          result << ReferenceTarget.new(path, @lang.line_number(e), display_name)
+        end
+      end
+    end
+    result
+  end
+
+  FileProblems = Struct.new(:file, :problems)
+  Problem = Struct.new(:severity, :line, :message)
+  def get_problems
+    load_model
+    result = []
+    @model.fragments.sort{|a,b| a.location <=> b.location}.each do |fragment|
+      problems = []
+      if fragment.data && fragment.data[:problems]
+        fragment.data[:problems].each do |p|
+          problems << Problem.new("Error", p.line, p.message)
+        end
+      end
+      fragment.unresolved_refs.each do |ur|
+        # TODO: where do these proxies come from?
+        next unless ur.proxy.targetIdentifier
+        problems << Problem.new("Error", @lang.line_number(ur.element), "unresolved reference #{ur.proxy.targetIdentifier}")
+      end
+      if problems.size > 0
+        result << FileProblems.new(File.expand_path(fragment.location), problems)
+      end
+    end
+    result
+  end
+
+  OpenElementChoice = Struct.new(:display_name, :file, :line)
+  def get_open_element_choices(pattern)
+    result = []
+    return result unless pattern
+    sub_index = element_name_index[pattern[0..0].downcase]
+    sub_index && sub_index.each_pair do |ident, elements|
+      if ident.split(/\W/).last.downcase.index(pattern.downcase) == 0
+        elements.each do |e|
+          if @lang.fragment_ref(e)
+            non_word_index = ident.rindex(/\W/)
+            if non_word_index
+              name = ident[non_word_index+1..-1]
+              scope = ident[0..non_word_index-1]
+            else
+              name = ident
+              scope = ""
+            end
+            display_name = "#{name} [#{e.class.ecore.name}]"
+            display_name += " - #{scope}" if scope.size > 0
+            path = File.expand_path(@lang.fragment_ref(e).fragment.location)
+            result << OpenElementChoice.new(display_name, path, @lang.line_number(e))
+          end
+        end
+      end
+    end
+    result.sort{|a,b| a.display_name <=> b.display_name}
+  end
+
+  def element_name_index
+    return @element_name_index if @element_name_index
+    @element_name_index = {}
+    @model.index.each_pair do |ident, elements|
+      key = ident.split(/\W/).last[0..0].downcase
+      @element_name_index[key] ||= {} 
+      @element_name_index[key][ident] = elements
+    end
+    @element_name_index
+  end
+
+end
+
+end

data/lib/rtext/instantiator.rb

@@ -0,0 +1,284 @@
+require 'rgen/ecore/ecore_ext'
+require 'rgen/instantiator/reference_resolver'
+require 'rtext/parser'
+
+module RText
+
+class Instantiator
+
+  # A problem found during instantiation
+  # if the file is not known, it will be nil
+  InstantiatorProblem = Struct.new(:message, :file, :line)
+
+  # Creates an instantiator for RText::Language +language+ 
+  #
+  def initialize(language)
+    @lang = language
+  end
+
+  # instantiate +str+, +options+ include:
+  #
+  #  :env
+  #    environment to which model elements will be added
+  #
+  #  :problems
+  #    an array to which problems will be appended
+  #  
+  #  :unresolved_refs
+  #    an array to which unresolved references will be appended
+  # 
+  #  :root_elements
+  #    an array which will hold the root elements
+  #
+  #  :file_name
+  #    name of the file being instantiated, will be set on model elements
+  #
+  #  :fragment_ref
+  #    object which references the fragment being instantiated, will be set on model elements 
+  #
+  def instantiate(str, options={})
+    @line_numbers = {}
+    @env = options[:env]
+    @problems = options[:problems] || []
+    @unresolved_refs = options[:unresolved_refs]
+    @root_elements = options[:root_elements] || []
+    @file_name = options[:file_name]
+    @fragment_ref = options[:fragment_ref]
+    parser = Parser.new(@lang.reference_regexp)
+    begin
+      @root_elements.clear
+      parser.parse(str) do |*args|
+        if args[0]
+          create_element(*args)
+        else
+          unassociated_comments(args[3])
+        end
+      end
+    rescue Parser::Error => e
+      problem(e.message, e.line)
+      @unresolved_refs.clear if @unresolved_refs
+      @root_elements.clear
+    end
+    if @unresolved_refs
+      @unresolved_refs.each do |ur|
+        ur.proxy.targetIdentifier = @lang.qualify_reference(ur.proxy.targetIdentifier, ur.element)
+      end
+    end
+  end
+
+  private
+
+  def unassociated_comments(comments)
+    comments.each do |c|
+      handle_comment(c, nil)
+    end
+  end
+
+  def create_element(command, arg_list, element_list, comments, is_root)
+    clazz = @lang.class_by_command(command.value)  
+    if !clazz 
+      problem("Unknown command '#{command.value}'", command.line)
+      return
+    end
+    if clazz.ecore.abstract
+      problem("Unknown command '#{command.value}' (metaclass is abstract)", command.line)
+      return
+    end
+    element = clazz.new
+    @env << element if @env
+    @root_elements << element if is_root
+    unlabled_args = @lang.unlabled_arguments(clazz.ecore).name
+    di_index = 0
+    defined_args = {}
+    arg_list.each do |a|
+      if is_labeled(a) 
+        set_argument(element, a[0].value, a[1], defined_args, command.line)
+      else
+        if di_index < unlabled_args.size 
+          set_argument(element, unlabled_args[di_index], a, defined_args, command.line)
+          di_index += 1
+        else
+          problem("Unexpected unlabled argument, #{unlabled_args.size} unlabled arguments expected", command.line)
+        end
+      end
+    end
+    element_list.each do |e|
+      if is_labeled(e)
+        add_children(element, e[1], e[0].value, e[0].line)
+      else
+        add_children(element, e, nil, nil)
+      end
+    end
+    set_line_number(element, command.line)
+    set_file_name(element)
+    set_fragment_ref(element)
+    comments.each do |c|
+      handle_comment(c, element)
+    end
+    element
+  end
+
+  def add_children(element, children, role, role_line)
+    if role
+      feature = @lang.feature_by_name(element.class.ecore, role)
+      if !feature
+        problem("Unknown child role '#{role}'", role_line)
+        return
+      end
+      if !feature.is_a?(RGen::ECore::EReference) || !feature.containment
+        problem("Role '#{role}' can not take child elements", role_line)
+        return
+      end
+      children = [children] unless children.is_a?(Array)
+      children.compact!
+      if children.size == 0
+        return
+      end
+      if !feature.many && 
+        (element.getGenericAsArray(role).size > 0 || children.size > 1)
+        problem("Only one child allowed in role '#{role}'", line_number(children[0]))
+        return
+      end
+      expected_type = @lang.concrete_types(feature.eType)
+      children.each do |c|
+        if !expected_type.include?(c.class.ecore)
+          problem("Role '#{role}' can not take a #{c.class.ecore.name}, expected #{expected_type.name.join(", ")}", line_number(c))
+        else
+          element.setOrAddGeneric(feature.name, c)
+        end
+      end
+    else
+      raise "if there is no role, children must not be an Array" if children.is_a?(Array)
+      child = children
+      return if child.nil?
+      feature = @lang.containments_by_target_type(element.class.ecore, child.class.ecore)
+      if feature.size == 0
+        problem("This kind of element can not be contained here", line_number(child))
+        return
+      end
+      if feature.size > 1
+        problem("Role of element is ambiguous, use a role label", line_number(child))
+        return
+      end
+      feature = feature[0]
+      if element.getGenericAsArray(feature.name).size > 0 && !feature.many
+        problem("Only one child allowed in role '#{feature.name}'", line_number(child))
+        return
+      end
+      element.setOrAddGeneric(feature.name, child)
+    end
+  end
+
+  def set_argument(element, name, value, defined_args, line)
+    feature = @lang.feature_by_name(element.class.ecore, name)
+    if !feature
+      problem("Unknown argument '#{name}'", line)
+      return
+    end
+    if feature.is_a?(RGen::ECore::EReference) && feature.containment
+      problem("Argument '#{name}' can only take child elements", line)
+      return
+    end
+    if defined_args[name]
+      problem("Argument '#{name}' already defined", line)
+      return
+    end
+    value = [value] unless value.is_a?(Array)
+    if value.size > 1 && !feature.many
+      problem("Argument '#{name}' can take only one value", line)
+      return
+    end
+    expected_kind = expected_token_kind(feature)
+    value.each do |v|
+      if !expected_kind.include?(v.kind)
+        problem("Argument '#{name}' can not take a #{v.kind}, expected #{expected_kind.join(", ")}", line)
+      elsif feature.eType.is_a?(RGen::ECore::EEnum) 
+        if !feature.eType.eLiterals.name.include?(v.value)
+          problem("Argument '#{name}' can not take value #{v.value}, expected #{feature.eType.eLiterals.name.join(", ")}", line)
+        else
+          element.setOrAddGeneric(feature.name, v.value.to_sym)
+        end
+      elsif feature.is_a?(RGen::ECore::EReference)
+        proxy = RGen::MetamodelBuilder::MMProxy.new(v.value)
+        if @unresolved_refs
+          @unresolved_refs << 
+            RGen::Instantiator::ReferenceResolver::UnresolvedReference.new(element, feature.name, proxy)
+        end
+        element.setOrAddGeneric(feature.name, proxy)
+      else
+        element.setOrAddGeneric(feature.name, v.value)
+      end
+    end
+    defined_args[name] = true
+  end
+
+  def handle_comment(comment_desc, element)
+    if @lang.comment_handler
+      kind = comment_desc[1]
+      if kind == :eol
+        comment = comment_desc[0].value
+      else
+        comment = comment_desc[0].collect{|c| c.value}.join("\n")
+      end
+      success = @lang.comment_handler.call(comment, kind, element, @env)
+      if !success 
+        if element.nil? 
+          problem("Unassociated comment not allowed", comment_desc[0][0].line)
+        else
+          problem("This kind of element can not take this comment", line_number(element))
+        end
+      end
+    end
+  end
+
+  def is_labeled(a)
+    a.is_a?(Array) && a[0].respond_to?(:kind) && a[0].kind == :label
+  end
+
+  def expected_token_kind(feature)
+    if feature.is_a?(RGen::ECore::EReference)
+      [:reference, :identifier]
+    elsif feature.eType.is_a?(RGen::ECore::EEnum)
+      [:identifier, :string]
+    else
+      { String => [:string, :identifier],
+        Integer => [:integer],
+        Float => [:float],
+        RGen::MetamodelBuilder::DataTypes::Boolean => [:boolean]
+      }[feature.eType.instanceClass] 
+    end
+  end
+
+  def set_line_number(element, line)
+    @line_numbers[element] = line
+    if @lang.line_number_attribute && element.respond_to?("#{@lang.line_number_attribute}=")
+      element.send("#{@lang.line_number_attribute}=", line)
+    end
+  end
+
+  def set_file_name(element)
+    if @file_name && 
+      @lang.file_name_attribute && element.respond_to?("#{@lang.file_name_attribute}=")
+        element.send("#{@lang.file_name_attribute}=", @file_name)
+    end
+  end
+
+  def set_fragment_ref(element)
+    if @fragment_ref && 
+      @lang.fragment_ref_attribute && element.respond_to?("#{@lang.fragment_ref_attribute}=")
+        element.send("#{@lang.fragment_ref_attribute}=", @fragment_ref)
+    end
+  end
+
+  def line_number(e)
+    @line_numbers[e]
+  end
+
+  def problem(msg, line)
+    @problems << InstantiatorProblem.new(msg, @file_name, line) 
+  end
+
+end
+
+end
+