rtext 0.2.0

data/lib/rtext/language.rb

@@ -0,0 +1,257 @@
+require 'rgen/ecore/ecore'
+require 'rgen/ecore/ecore_ext'
+require 'rgen/serializer/opposite_reference_filter'
+require 'rgen/serializer/qualified_name_provider'
+
+module RText
+
+class Language
+  
+  # Creates an RText language description for the metamodel described by +root_epackage+
+  # Valid options include:
+  #
+  #  :feature_provider
+  #     a Proc which receives an EClass and should return a subset of this EClass's features
+  #     this can be used to filter and/or reorder the features
+  #     note that in most cases, this Proc will have to filter opposite references
+  #     default: all features filtered using OppositeReferenceFilter 
+  #
+  #  :unlabled_arguments
+  #     a Proc which receives an EClass and should return this EClass's feature names which are
+  #     to be serialized without lables in the given order and before all labled arguments
+  #     the features must also occur in :feature_provider if :feature_provider is provided
+  #     if unlabled arguments are not part of the current class's features, they will be ignored
+  #     default: no unlabled arguments
+  #
+  #  :unquoted_arguments
+  #     a Proc which receives an EClass and should return this EClass's string typed attribute
+  #     names which are to be serialized without quotes. input data my still be quoted.
+  #     the serializer will take care to insert quotes if the data is not a valid identifier
+  #     the features must also occur in :feature_provider if :feature_provider is provided
+  #     default: no unquoted arguments
+  #  
+  #  :argument_format_provider
+  #     a Proc which receives an EAttribute and should return a format specification string
+  #     (in sprintf syntax) which will be used by the serializer for integers and floats.
+  #     default: if not present or the proc returns nil, then #to_s is used
+  #
+  #  :short_class_names
+  #     if true, the metamodel is searched for classes by unqualified class name recursively
+  #     if false, classes can only be found in the root package, not in subpackages 
+  #     default: true
+  #
+  #  :reference_regexp  
+  #     a Regexp which is used by the tokenizer for identifying references 
+  #     it must only match at the beginning of a string, i.e. it should start with \A
+  #     it must be built in a way that does not match other language constructs
+  #     in particular it must not match identifiers (word characters not starting with a digit)
+  #     identifiers can always be used where references are expected
+  #     default: word characters separated by at least one slash (/) 
+  #
+  #  :identifier_provider
+  #     a Proc which receives an element and its containing element or nil and should return 
+  #     the element's identifier as a string
+  #     the identifier must be unique for the element unless "per_type_identifier" is set to true,
+  #     in which case they must be unique for each element of the same type
+  #     identifiers may be relative to the given containing element. in this case a globally unique 
+  #     identifer must be resonstructed by the proc specified using the :reference_qualifier option.
+  #     if the containing element is nil, the identifier returned must be globally unique.
+  #     default: identifiers calculated by QualifiedNameProvider
+  #              in this case options to QualifiedNameProvider may be provided and will be passed through
+  #
+  #  :per_type_identifier
+  #     if set to true, identifiers may be reused for elements of different type
+  #     default: false
+  #
+  #  :reference_qualifier
+  #     a Proc which receives an element identifier as returned by the identifier provider and 
+  #     another element which uses this identifier to reference the element.
+  #     it must return the globally unique version of the identifier.
+  #     in case the received identifier is already globally unique, it must be returned as is.
+  #     the received element might only be similar to the original referencing element. the reason
+  #     is that this element may need to be constructed using only partially parsable data.
+  #     it is garantueed though that the element's chain of containing elements is complete and
+  #     that (non-containment) references are resolved as far as possible.
+  #     default: no reference qualifier, i.e. all identifiers returned by the identifier provider 
+  #              must be globally unique
+  #
+  #  :line_number_attribute
+  #     the name of the attribute which will be used to associate the line number with a model element
+  #     default: no line number
+  #
+  #  :file_name_attribute
+  #     the name of the attribute which will be used to associate the file name with a model element
+  #     default: no file name
+  #
+  #  :fragment_ref_attribute
+  #     the name of the attribute which will be used to associate a model fragment with a model element
+  #
+  #  :comment_handler 
+  #     a Proc which will be invoked when a new element has been instantiated. receives an 
+  #     element, the comment as a string, and the environment to which the element has been
+  #     added to. then environment may be nil.  it should add the comment to the element and 
+  #     return true. if the element can take no comment, it should return false.
+  #     default: no handling of comments 
+  #  
+  #  :comment_provider
+  #     a Proc which receives an element and should return this element's comment as a string or nil
+  #     the Proc may also modify the element to remove information already part of the comment
+  #     default: no comments
+  #
+  #  :indent_string
+  #     the string representing one indent, could be a tab or spaces
+  #     default: 2 spaces
+  #
+  #  :command_name_provider
+  #     a Proc which receives an EClass object and should return an RText command name
+  #     default: class name
+  #
+  def initialize(root_epackage, options={})
+    @root_epackage = root_epackage
+    @feature_provider = options[:feature_provider] || 
+      proc { |c| RGen::Serializer::OppositeReferenceFilter.call(c.eAllStructuralFeatures) }
+    @unlabled_arguments = options[:unlabled_arguments]
+    @unquoted_arguments = options[:unquoted_arguments]
+    @argument_format_provider = options[:argument_format_provider]
+    @class_by_command = {}
+    command_name_provider = options[:command_name_provider] || proc{|c| c.name}
+    ((!options.has_key?(:short_class_names) || options[:short_class_names]) ?
+      root_epackage.eAllClasses : root_epackage.eClasses).each do |c|
+        next if c.abstract
+        command_name = command_name_provider.call(c)
+        raise "ambiguous command name #{command_name}" if @class_by_command[command_name]
+        @class_by_command[command_name] = c.instanceClass
+      end
+    # there can't be multiple commands for the same class as the command name provider
+    # can only return one command per class
+    @command_by_class = @class_by_command.invert 
+    @reference_regexp = options[:reference_regexp] || /\A\w*(\/\w*)+/
+    @identifier_provider = options[:identifier_provider] || 
+      proc { |element, context|
+        @qualified_name_provider ||= RGen::Serializer::QualifiedNameProvider.new(options)
+        @qualified_name_provider.identifier(element)
+      }
+    @reference_qualifier = options[:reference_qualifier]
+    @line_number_attribute = options[:line_number_attribute]
+    @file_name_attribute = options[:file_name_attribute]
+    @fragment_ref_attribute = options[:fragment_ref_attribute]
+    @comment_handler = options[:comment_handler]
+    @comment_provider = options[:comment_provider]
+    @indent_string = options[:indent_string] || "  "
+    @per_type_identifier = options[:per_type_identifier]
+  end
+
+  attr_reader :root_epackage
+  attr_reader :reference_regexp
+  attr_reader :identifier_provider
+  attr_reader :line_number_attribute
+  attr_reader :file_name_attribute
+  attr_reader :fragment_ref_attribute
+  attr_reader :comment_handler
+  attr_reader :comment_provider
+  attr_reader :indent_string
+  attr_reader :per_type_identifier
+
+  def class_by_command(command)
+    @class_by_command[command]
+  end
+
+  def command_by_class(clazz)
+    @command_by_class[clazz]
+  end
+
+  def containments(clazz)
+    features(clazz).select{|f| f.is_a?(RGen::ECore::EReference) && f.containment}
+  end
+
+  def non_containments(clazz)
+    features(clazz).reject{|f| f.is_a?(RGen::ECore::EReference) && f.containment}
+  end
+
+  def labled_arguments(clazz)
+    non_containments(clazz) - unlabled_arguments(clazz)
+  end
+
+  def unlabled_arguments(clazz)
+    return [] unless @unlabled_arguments
+    uargs = @unlabled_arguments.call(clazz) || []
+    uargs.collect{|a| non_containments(clazz).find{|f| f.name == a}}.compact
+  end
+
+  def unquoted?(feature)
+    return false unless @unquoted_arguments
+    @unquoted_arguments.call(feature.eContainingClass).include?(feature.name)
+  end
+
+  def argument_format(feature)
+    @argument_format_provider && @argument_format_provider.call(feature)
+  end
+
+  def concrete_types(clazz)
+    ([clazz] + clazz.eAllSubTypes).select{|c| !c.abstract}
+  end
+
+  def containments_by_target_type(clazz, type)
+    map = {}
+    clazz.eAllReferences.select{|r| r.containment}.each do |r|
+      concrete_types(r.eType).each {|t| (map[t] ||= []) << r}
+    end
+    ([type]+type.eAllSuperTypes).inject([]){|m,t| m + (map[t] || []) }.uniq
+  end
+
+  def feature_by_name(clazz, name)
+    clazz.eAllStructuralFeatures.find{|f| f.name == name}
+  end
+
+  def file_name(element)
+    @file_name_attribute && element.respond_to?(@file_name_attribute) && element.send(@file_name_attribute)
+  end
+
+  def line_number(element)
+    @line_number_attribute && element.respond_to?(@line_number_attribute) && element.send(@line_number_attribute)
+  end
+
+  def fragment_ref(element)
+    @fragment_ref_attribute && element.respond_to?(@fragment_ref_attribute) && element.send(@fragment_ref_attribute)
+  end
+
+  def qualify_reference(identifier, element)
+    if @reference_qualifier
+      @reference_qualifier.call(identifier, element)
+    else
+      identifier
+    end
+  end
+
+  private
+
+  def features(clazz)
+    @feature_provider.call(clazz)
+  end
+
+  # caching
+  [ :containments,
+    :non_containments,
+    :unlabled_arguments,
+    :labled_arguments,
+    :unquoted?,
+    :argument_format,
+    :concrete_types,
+    :containments_by_target_type,
+    :feature_by_name
+  ].each do |m|
+    ms = m.to_s.sub('?','_')
+    module_eval <<-END
+      alias #{ms}_orig #{m}
+      def #{m}(*args)
+        @#{ms}_cache ||= {}
+        return @#{ms}_cache[args] if @#{ms}_cache.has_key?(args)
+        @#{ms}_cache[args] = #{ms}_orig(*args)
+      end
+    END
+  end
+
+end
+
+end
+

data/lib/rtext/parser.rb

@@ -0,0 +1,251 @@
+module RText 
+
+class Parser
+
+  def initialize(reference_regexp)
+    @reference_regexp = reference_regexp
+  end
+
+  def parse(str, &visitor)
+    @visitor = visitor
+    @tokens = tokenize(str, @reference_regexp)
+    @last_line = @tokens.last && @tokens.last.line 
+    while next_token
+      parse_statement(true, true)
+    end
+  end
+
+  # parse a statement with optional leading comment or an unassociated comment
+  def parse_statement(is_root=false, allow_unassociated_comment=false)
+    comments = [] 
+    comment = parse_comment 
+    if (next_token && next_token == :identifier) || !allow_unassociated_comment
+      comments << [ comment, :above] if comment
+      command = consume(:identifier)
+      arg_list = []
+      parse_argument_list(arg_list)
+      element_list = []
+      if next_token == "{"
+        parse_statement_block(element_list, comments)
+      end
+      eol_comment = parse_eol_comment
+      comments << [ eol_comment, :eol ] if eol_comment
+      consume(:newline)
+      @visitor.call(command, arg_list, element_list, comments, is_root)
+    elsif comment
+      # if there is no statement, the comment is non-optional
+      comments << [ comment, :unassociated ]
+      @visitor.call(nil, nil, nil, comments, nil)
+      nil
+    else
+      # die expecting an identifier (next token is not an identifier)
+      consume(:identifier)
+    end
+  end
+
+  def parse_comment
+    result = nil 
+    while next_token == :comment
+      result ||= []
+      result << consume(:comment)
+      consume(:newline)
+    end
+    result
+  end
+
+  def parse_eol_comment
+    if next_token == :comment
+      consume(:comment)
+    else
+      nil
+    end
+  end
+
+  def parse_statement_block(element_list, comments)
+    consume("{")
+    eol_comment = parse_eol_comment
+    comments << [ eol_comment, :eol ] if eol_comment
+    consume(:newline)
+    while next_token && next_token != "}"
+      parse_block_element(element_list, comments)
+    end
+    consume("}")
+  end
+
+  def parse_block_element(element_list, comments)
+    if next_token == :label
+      label = consume(:label)
+      element_list << [label, parse_labeled_block_element(comments)]
+    else
+      statement = parse_statement(false, true)
+      element_list << statement if statement 
+    end
+  end
+
+  def parse_labeled_block_element(comments)
+    if next_token == "["
+      parse_element_list(comments)
+    else
+      eol_comment = parse_eol_comment
+      comments << [ eol_comment, :eol ] if eol_comment
+      consume(:newline)
+      parse_statement
+    end
+  end
+
+  def parse_element_list(comments)
+    consume("[")
+    eol_comment = parse_eol_comment
+    comments << [ eol_comment, :eol ] if eol_comment
+    consume(:newline)
+    result = []
+    while next_token && next_token != "]"
+      statement = parse_statement(false, true)
+      result << statement if statement 
+    end
+    consume("]")
+    eol_comment = parse_eol_comment
+    comments << [ eol_comment, :eol ] if eol_comment
+    consume(:newline)
+    result
+  end
+
+  def parse_argument_list(arg_list)
+    first = true
+    while !["{", :comment, :newline].include?(next_token)
+      consume(",") unless first
+      first = false
+      parse_argument(arg_list)
+    end
+  end
+
+  def parse_argument(arg_list)
+    if next_token == :label
+      label = consume(:label)
+      arg_list << [label, parse_argument_value]
+    else
+      arg_list << parse_argument_value
+    end
+  end
+
+  def parse_argument_value
+    if next_token == "["
+      parse_argument_value_list
+    else
+      parse_value
+    end
+  end
+
+  def parse_argument_value_list
+    consume("[")
+    first = true
+    result = []
+    while next_token != "]"
+      consume(",") unless first
+      first = false
+      result << parse_value
+    end
+    consume("]")
+    result
+  end
+
+  def parse_value
+    consume(:identifier, :integer, :float, :string, :boolean, :reference)
+  end
+
+  def next_token
+    @tokens.first && @tokens.first.kind
+  end
+
+  class Error < Exception
+    attr_reader :message, :line
+    def initialize(message, line)
+      @message, @line = message, line
+    end
+  end
+
+  def consume(*args)
+    t = @tokens.shift
+    if t.nil?
+      raise Error.new("Unexpected end of file, expected #{args.join(", ")}", @last_line)
+    end
+    if args.include?(t.kind)
+      t
+    else
+      if t.kind == :error
+        raise Error.new("Parse error on token '#{t.value}'", t.line)
+      else
+        value = " '#{t.value}'" if t.value
+        raise Error.new("Unexpected #{t.kind}#{value}, expected #{args.join(", ")}", t.line)
+      end
+    end
+  end
+
+  Token = Struct.new(:kind, :value, :line)
+   
+  def tokenize(str, reference_regexp)
+    result = []
+    str.split(/\r?\n/).each_with_index do |str, idx|
+      idx += 1
+      if str =~ /^\s*#(.*)/
+        result << Token.new(:comment, $1, idx) 
+      else
+        until str.empty?
+          case str
+          when reference_regexp
+            str = $'
+            result << Token.new(:reference, $&, idx)
+          when /\A[-+]?\d+\.\d+(?:e[+-]\d+)?\b/
+            str = $'
+            result << Token.new(:float, $&.to_f, idx)
+          when /\A0[xX][0-9a-fA-F]+\b/
+            str = $'
+            result << Token.new(:integer, $&.to_i(16), idx)
+          when /\A[-+]?\d+\b/
+            str = $'
+            result << Token.new(:integer, $&.to_i, idx)
+          when /\A"((?:[^"\\]|\\.)*)"/
+            str = $'
+            result << Token.new(:string, $1.
+              gsub('\\\\','\\').
+              gsub('\\"','"').
+              gsub('\\n',"\n").
+              gsub('\\r',"\r").
+              gsub('\\t',"\t").
+              gsub('\\f',"\f").
+              gsub('\\b',"\b"), idx)
+          when /\A(?:true|false)\b/
+            str = $'
+            result << Token.new(:boolean, $& == "true", idx)
+          when /\A([a-zA-Z_]\w*)\b(?:\s*:)?/
+            str = $'
+            if $&[-1] == ?: 
+              result << Token.new(:label, $1, idx)
+            else
+              result << Token.new(:identifier, $&, idx)
+            end
+          when /\A[\{\}\[\]:,]/
+            str = $'
+            result << Token.new($&, nil, idx)
+          when /\A#(.*)/
+            str = ""
+            result << Token.new(:comment, $1, idx)
+          when /\A\s+/
+            str = $'
+            # ignore
+          when /\A\S+/
+            str = $'
+            result << Token.new(:error, $&, idx)
+          end
+        end
+      end
+      result << Token.new(:newline, nil, idx) \
+        unless result.empty? || result.last.kind == :newline
+    end
+    result
+  end
+
+end
+
+end
+