rgen 0.5.4 → 0.6.0

data/lib/rgen/util/cached_glob.rb

@@ -0,0 +1,67 @@
+module RGen
+
+module Util
+
+# WARNING: the mechanism of taking timestamps of directories in order to find out if the
+# content has changed doesn't work reliably across all kinds of filesystems
+#
+class CachedGlob
+
+  def initialize(dir_glob, file_glob)
+    @dir_glob = dir_glob
+    @file_glob = file_glob
+    @root_dirs = []
+    @dirs = {}
+    @files = {}
+    @timestamps = {}
+  end
+
+  # returns all files contained in directories matched by +dir_glob+ which match +file_glob+.
+  # +file_glob+ must be relative to +dir_glob+.
+  # dir_glob "*/a" with file_glob "**/*.txt" is basically equivalent with Dir.glob("*/a/**/*.txt")
+  # the idea is that the file glob will only be re-eavluated when the content of one of the 
+  # directories matched by dir_glob has changed.
+  # this will only be faster than a normal Dir.glob if the number of dirs matched by dir_glob is
+  # relatively large and changes in files affect only a few of them at a time.
+  def glob
+    root_dirs = Dir.glob(@dir_glob)
+    (@root_dirs - root_dirs).each do |d|
+      remove_root_dir(d)
+    end
+    (@root_dirs & root_dirs).each do |d|
+      update_root_dir(d) if dir_changed?(d)
+    end
+    (root_dirs - @root_dirs).each do |d|
+      update_root_dir(d)
+    end
+    @root_dirs = root_dirs
+    @root_dirs.sort.collect{|d| @files[d]}.flatten
+  end
+
+  private
+
+  def dir_changed?(dir)
+    @dirs[dir].any?{|d| File.mtime(d) != @timestamps[dir][d]}
+  end
+
+  def update_root_dir(dir)
+    @dirs[dir] = Dir.glob(dir+"/**/")
+    @files[dir] = Dir.glob(dir+"/"+@file_glob)
+    @timestamps[dir] = {}
+    @dirs[dir].each do |d|
+      @timestamps[dir][d] = File.mtime(d)
+    end
+  end
+
+  def remove_root_dir(dir)
+    @dirs.delete(dir)
+    @files.delete(dir)
+    @timestamps.delete(dir)
+  end
+
+end
+
+end
+
+end
+

data/lib/rgen/util/file_cache_map.rb

@@ -0,0 +1,104 @@
+require 'digest'
+require 'fileutils'
+
+module RGen
+
+module Util
+
+# Implements a cache for storing and loading data associated with arbitrary files.
+# The data is stored in cache files within a subfolder of the folder where
+# the associated files exists.
+# The cache files are protected with a checksum and loaded data will be
+# invalid in case either the associated file are the cache file has changed.
+#
+class FileCacheMap
+  # optional program version info to be associated with the cache files
+  # if the program version changes, cached data will also be invalid
+  attr_accessor :version_info
+
+  # +cache_dir+ is the name of the subfolder where cache files are created
+  # +postfix+ is an extension appended to the original file name for 
+  # creating the name of the cache file
+  def initialize(cache_dir, postfix)
+    @postfix = postfix
+    @cache_dir = cache_dir
+  end
+
+  # load data associated with file +key_path+
+  # returns :invalid in case either the associated file or the cache file has changed
+  def load_data(key_path)
+    cf = cache_file(key_path)
+    return :invalid unless File.exist?(cf)
+    result = nil
+    File.open(cf, "rb") do |f|
+      header = f.read(41)
+      return :invalid unless header
+      checksum = header[0..39]
+      data = f.read
+      if calc_sha1(data) == checksum
+        if calc_sha1_keydata(key_path) == data[0..39]
+          result = data[41..-1]
+        else
+          result = :invalid
+        end
+      else
+        result = :invalid
+      end
+    end 
+    result
+  end
+
+  # store data +value_data+ associated with file +key_path+
+  def store_data(key_path, value_data)
+    data = calc_sha1_keydata(key_path) + "\n" + value_data
+    data = calc_sha1(data) + "\n" + data
+    cf = cache_file(key_path)
+    FileUtils.mkdir(File.dirname(cf)) rescue Errno::EEXIST
+    File.open(cf, "wb") do |f|
+      f.write(data)
+    end 
+  end
+
+  # remove cache files which are not associated with any file in +key_paths+
+  # will only remove files within +root_path+
+  def clean_unused(root_path, key_paths)
+    raise "key paths must be within root path" unless key_paths.all?{|p| p.index(root_path) == 0}
+    used_files = key_paths.collect{|p| cache_file(p)}
+    files = Dir[root_path+"/**/"+@cache_dir+"/*"+@postfix] 
+    files.each do |f|
+      FileUtils.rm(f) unless used_files.include?(f)
+    end
+  end
+
+private
+  
+  def cache_file(path)
+    File.dirname(path) + "/"+@cache_dir+"/" + File.basename(path) + @postfix 
+  end
+
+  def calc_sha1(data)
+    sha1 = Digest::SHA1.new
+    sha1.update(data)
+    sha1.hexdigest
+  end
+
+  def keyData(path)
+    File.read(path)+@version_info.to_s
+  end
+
+  # this method is much faster than calling +keyData+ and putting the result in +calc_sha1+
+  # reason is probably that there are not so many big strings being created
+  def calc_sha1_keydata(path)
+    sha1 = Digest::SHA1.new
+    sha1.file(path)
+    sha1.update(@version_info.to_s)
+    sha1.hexdigest
+  end
+   
+end
+
+end
+
+end
+
+

data/lib/rgen/util/file_change_detector.rb

@@ -0,0 +1,78 @@
+require 'digest'
+
+module RGen
+
+module Util
+
+# The FileChangeDetector detects changes in a set of files.
+# Changes are detected between successive calls to check_files with a give set of files.
+# Changes include files being added, removed or having changed their content.
+#
+class FileChangeDetector
+
+  FileInfo = Struct.new(:timestamp, :digest)
+
+  # Create a FileChangeDetector, options include:
+  #
+  #  :file_added
+  #    a proc which is called when a file is added, receives the filename
+  #
+  #  :file_removed
+  #    a proc which is called when a file is removed, receives the filename
+  #
+  #  :file_changed
+  #    a proc which is called when a file is changed, receives the filename
+  #
+  def initialize(options={})
+    @file_added = options[:file_added]
+    @file_removed = options[:file_removed]
+    @file_changed = options[:file_changed]
+    @file_info = {}
+  end
+
+  # Checks if any of the files has changed compared to the last call of check_files.
+  # When called for the first time on a new object, all files will be reported as being added.
+  # 
+  def check_files(files)
+    files_before = @file_info.keys
+    used_files = {} 
+    files.each do |file|
+      used_files[file] = true
+      if @file_info[file]
+        if @file_info[file].timestamp != File.mtime(file)
+          @file_info[file].timestamp = File.mtime(file)
+          digest = calc_digest(file)
+          if @file_info[file].digest != digest
+            @file_info[file].digest = digest 
+            @file_changed && @file_changed.call(file)
+          end
+        end
+      else
+        @file_info[file] = FileInfo.new
+        @file_info[file].timestamp = File.mtime(file)
+        @file_info[file].digest = calc_digest(file)
+        @file_added && @file_added.call(file)
+      end
+    end
+    files_before.each do |file|
+      if !used_files[file]
+        @file_info.delete(file)
+        @file_removed && @file_removed.call(file)
+      end
+    end
+  end
+
+  private
+
+  def calc_digest(file)
+    sha1 = Digest::SHA1.new
+    sha1.file(file)
+    sha1.hexdigest
+  end
+
+end
+
+end
+
+end
+

data/lib/rgen/{method_delegation.rb → util/method_delegation.rb}

@@ -1,4 +1,6 @@
 module RGen
+
+module Util
   
 module MethodDelegation
 
@@ -46,7 +48,7 @@ class << self
   end
   
   def createDelegatingMethod(object, method)
-    if object.methods.include?(method.to_s)
+    if hasMethod(object, method)
       object.instance_eval <<-END
         class << self
           alias #{aliasMethodName(method)} #{method}
@@ -71,7 +73,7 @@ class << self
   end
 
   def removeDelegatingMethod(object, method)
-    if object.methods.include?(aliasMethodName(method))
+    if hasMethod(object, aliasMethodName(method))
       # there is an aliased original, restore it
       object.instance_eval <<-END
         class << self
@@ -89,6 +91,16 @@ class << self
     end
   end
   
+  def hasMethod(object, method)
+    # in Ruby 1.9, #methods returns symbols
+    if object.methods.first.is_a?(Symbol)
+      method = method.to_sym
+    else
+      method = method.to_s
+    end
+    object.methods.include?(method)
+  end
+
   def aliasMethodName(method)
     "#{method}_delegate_original"
   end    
@@ -96,4 +108,7 @@ end
 
 end
 
-end
+end
+
+end
+

data/lib/rgen/{model_comparator.rb → util/model_comparator.rb}

@@ -2,6 +2,8 @@ require 'rgen/ecore/ecore'
 
 module RGen
 
+module Util
+
 module ModelComparator
 
 # This method compares to models regarding equality
@@ -27,10 +29,18 @@ def _modelEqual_internal(a, b, featureIgnoreList, path)
       puts "#{path.inspect}\n  Array size differs: #{a.size} vs. #{b.size}"
       return false 
     end
-    as = a
-    as = a.sort if a.all?{|o| o.respond_to?('<=>')}
-    bs = b
-    bs = b.sort if b.all?{|o| o.respond_to?('<=>')}
+    begin
+      # in Ruby 1.9 every object has the <=> operator but the default one returns
+      # nil and thus sorting won't work (ArgumentError)
+      as = a.sort
+    rescue ArgumentError, NoMethodError
+      as = a
+    end
+    begin
+      bs = b.sort
+    rescue ArgumentError, NoMethodError
+      bs = b
+    end
     a.each_index do |i|
       return false unless _modelEqual_internal(as[i], bs[i], featureIgnoreList, path+[i])
     end
@@ -53,4 +63,6 @@ end
 end
 
 end
-    
+
+end
+ 

data/lib/rgen/{model_comparator_base.rb → util/model_comparator_base.rb}

@@ -1,6 +1,8 @@
 require 'andand'
 
 module RGen
+
+module Util
 	
 class ModelComparatorBase
 	
@@ -134,4 +136,7 @@ class ModelComparatorBase
 	
 end
 
-end
+end
+
+end
+

data/lib/rgen/{model_dumper.rb → util/model_dumper.rb}

@@ -1,5 +1,7 @@
 module RGen
 
+module Util
+
 module ModelDumper
 
 	def dump(obj=nil)
@@ -21,4 +23,7 @@ module ModelDumper
 
 end
 
-end
+end
+
+end
+

data/lib/rgen/{name_helper.rb → util/name_helper.rb}

@@ -3,6 +3,8 @@
 
 module RGen
 
+module Util
+
 module NameHelper
 
 	def normalize(name)
@@ -34,4 +36,7 @@ module NameHelper
   end
 end
 
-end
+end
+
+end
+

data/lib/rgen/util/pattern_matcher.rb

@@ -0,0 +1,329 @@
+module RGen
+
+module Util
+
+# A PatternMatcher can be used to find, insert and remove patterns on a given model.
+#
+# A pattern is specified by means of a block passed to the add_pattern method.
+# The block must take an Environment as first parameter and at least one model element
+# as connection point as further parameter. The pattern matches if it can be found
+# in a given environment and connected to the given connection point elements.
+#
+class PatternMatcher
+
+  Match = Struct.new(:root, :elements, :bound_values)
+  attr_accessor :debug
+
+  def initialize
+    @patterns = {} 
+    @insert_mode = false
+    @debug = false
+  end
+
+  def add_pattern(name, &block)
+    raise "a pattern needs at least 2 block parameters: " + 
+      "an RGen environment and a model element as connection point" \
+      unless block.arity >= 2
+    @patterns[name] = block
+  end
+
+  def find_pattern(env, name, *connection_points)
+    match = find_pattern_internal(env, name, *connection_points)
+  end
+
+  def insert_pattern(env, name, *connection_points)
+    @insert_mode = true
+    root = evaluate_pattern(name, env, connection_points)
+    @insert_mode = false
+    root
+  end
+
+  def remove_pattern(env, name, *connection_points)
+    match = find_pattern_internal(env, name, *connection_points)
+    if match
+      match.elements.each do |e|
+        disconnect_element(e)
+        env.delete(e)
+      end
+      match
+    else
+      nil
+    end
+  end
+
+  def lazy(&block)
+    if @insert_mode
+      block.call
+    else
+      Lazy.new(&block)
+    end
+  end
+
+  class Lazy < RGen::MetamodelBuilder::MMGeneric
+    def initialize(&block)
+      @block = block
+    end
+    def _eval
+      @block.call
+    end
+  end
+
+  private
+
+  class Proxy < RGen::MetamodelBuilder::MMProxy
+    attr_reader :_target
+    def initialize(target)
+      @_target = target
+    end
+    def method_missing(m, *args)
+      result = @_target.send(m, *args)
+      if result.is_a?(Array)
+        result.collect do |e|
+          if e.is_a?(RGen::MetamodelBuilder::MMBase)
+            Proxy.new(e)
+          else
+            e
+          end
+        end
+      else
+        if result.is_a?(RGen::MetamodelBuilder::MMBase)
+          Proxy.new(result)
+        else
+          result 
+        end
+      end
+    end
+  end
+
+  class Bindable < RGen::MetamodelBuilder::MMGeneric
+    # by being an Enumerable, Bindables can be used for many-features as well
+    include Enumerable
+    def initialize
+      @bound = false
+      @value = nil
+      @many = false
+    end
+    def _bound?
+      @bound
+    end
+    def _many?
+      @many
+    end
+    def _bind(value)
+      @value = value
+      @bound = true
+    end
+    def _value
+      @value
+    end
+    def to_s
+      @value.to_s
+    end
+    # pretend this is an enumerable which contains itself, so the bindable can be
+    # inserted into many-features, when this is done the bindable is marked as a many-bindable
+    def each
+      @many = true
+      yield(self)
+    end
+    def method_missing(m, *args)
+      raise "bindable not bound" unless _bound?
+      @value.send(m, *args)
+    end
+  end
+
+  TempEnv = RGen::Environment.new
+  class << TempEnv
+    def <<(el); end
+  end
+
+  def find_pattern_internal(env, name, *connection_points)
+    proxied_args = connection_points.collect{|a| 
+      a.is_a?(RGen::MetamodelBuilder::MMBase) ?  Proxy.new(a) : a }
+    bindables = create_bindables(name, connection_points)
+    pattern_root = evaluate_pattern(name, TempEnv, proxied_args+bindables)
+    candidates = candidates_via_connection_points(pattern_root, connection_points)
+    candidates ||= env.find(:class => pattern_root.class)
+    candidates.each do |e|
+      # create new bindables for every try, otherwise they can could be bound to old values
+      bindables = create_bindables(name, connection_points) 
+      pattern_root = evaluate_pattern(name, TempEnv, proxied_args+bindables)
+      matched = match(pattern_root, e)
+      return Match.new(e, matched, bindables.collect{|b| b._value}) if matched 
+    end
+    nil
+  end
+
+  def create_bindables(pattern_name, connection_points)
+    (1..(num_pattern_variables(pattern_name) - connection_points.size)).collect{|i| Bindable.new}
+  end
+
+  def candidates_via_connection_points(pattern_root, connection_points)
+    @candidates_via_connection_points_refs ||= {}
+    refs = (@candidates_via_connection_points_refs[pattern_root.class] ||= 
+      pattern_root.class.ecore.eAllReferences.reject{|r| r.derived || r.many || !r.eOpposite})
+    candidates = nil 
+    refs.each do |r|
+      t = pattern_root.getGeneric(r.name)
+      cp = t.is_a?(Proxy) && connection_points.find{|cp| cp.object_id == t._target.object_id}
+      if cp
+        elements = cp.getGenericAsArray(r.eOpposite.name)
+        candidates = elements if candidates.nil? || elements.size < candidates.size 
+      end
+    end
+    candidates
+  end
+  
+  def match(pat_element, test_element)
+    visited = {}
+    check_later = []
+    return false unless match_internal(pat_element, test_element, visited, check_later)
+    while cl = check_later.shift
+      pv, tv = cl.lazy._eval, cl.value
+      if cl.feature.is_a?(RGen::ECore::EAttribute)
+        unless pv == tv
+          match_failed(cl.feature, "wrong attribute value (lazy): #{pv} vs. #{tv}")
+          return false 
+        end
+      else
+        if pv.is_a?(Proxy)
+          unless pv._target.object_id == tv.object_id
+            match_failed(f, "wrong target object")
+            return false 
+          end
+        else
+          unless (pv.nil? && tv.nil?) || (!pv.nil? && !tv.nil? && match_internal(pv, tv, visited, check_later))
+            return false 
+          end
+        end
+      end
+    end
+    visited.keys
+  end
+
+  CheckLater = Struct.new(:feature, :lazy, :value)
+  def match_internal(pat_element, test_element, visited, check_later)
+    return true if visited[test_element]
+    visited[test_element] = true
+    unless pat_element.class == test_element.class
+      match_failed(nil, "wrong class: #{pat_element.class} vs #{test_element.class}")
+      return false 
+    end
+    all_structural_features(pat_element).each do |f|
+      pat_values = pat_element.getGeneric(f.name)
+      # nil values must be kept to support size check with Bindables
+      pat_values = [ pat_values ] unless pat_values.is_a?(Array)
+      test_values = test_element.getGeneric(f.name)
+      test_values = [ test_values] unless test_values.is_a?(Array)
+      if pat_values.size == 1 && pat_values.first.is_a?(Bindable) && pat_values.first._many?
+        unless match_many_bindable(pat_values.first, test_values)
+          return false
+        end
+      else
+        unless pat_values.size == test_values.size
+          match_failed(f, "wrong size #{pat_values.size} vs. #{test_values.size}")
+          return false 
+        end
+        pat_values.each_with_index do |pv,i|
+          tv = test_values[i]
+          if pv.is_a?(Lazy)
+            check_later << CheckLater.new(f, pv, tv)
+          elsif pv.is_a?(Bindable)
+            if pv._bound?
+              unless pv._value == tv
+                match_failed(f, "value does not match bound value #{pv._value.class}:#{pv._value.object_id} vs. #{tv.class}:#{tv.object_id}")
+                return false 
+              end
+            else
+              pv._bind(tv)
+            end
+          else
+            if f.is_a?(RGen::ECore::EAttribute)
+              unless pv == tv 
+                match_failed(f, "wrong attribute value")
+                return false 
+              end
+            else
+              if pv.is_a?(Proxy)
+                unless pv._target.object_id == tv.object_id
+                  match_failed(f, "wrong target object")
+                  return false 
+                end
+              else
+                unless both_nil_or_match(pv, tv, visited, check_later)
+                  return false 
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+    true
+  end
+
+  def match_many_bindable(bindable, test_values)
+    if bindable._bound? 
+      bindable._value.each_with_index do |pv,i|
+        tv = test_values[i]
+        if f.is_a?(RGen::ECore::EAttribute)
+          unless pv == tv 
+            match_failed(f, "wrong attribute value")
+            return false 
+          end
+        else
+          unless both_nil_or_match(pv, tv, visited, check_later)
+            return false 
+          end
+        end
+      end
+    else
+      bindable._bind(test_values.dup)
+    end
+    true
+  end
+
+  def both_nil_or_match(pv, tv, visited, check_later)
+    (pv.nil? && tv.nil?) || (!pv.nil? && !tv.nil? && match_internal(pv, tv, visited, check_later))
+  end
+
+  def match_failed(f, msg)
+    puts "match failed #{f&&f.eContainingClass.name}##{f&&f.name}: #{msg}" if @debug
+  end
+
+  def num_pattern_variables(name)
+    prok = @patterns[name]
+    prok.arity - 1
+  end
+
+  def evaluate_pattern(name, env, connection_points)
+    prok = @patterns[name]
+    raise "unknown pattern #{name}" unless prok
+    raise "wrong number of arguments, expected #{prok.arity-1} connection points)" \
+      unless connection_points.size == prok.arity-1
+    prok.call(env, *connection_points)
+  end
+
+  def disconnect_element(element)
+    return if element.nil?
+    all_structural_features(element).each do |f|
+      if f.many
+        element.setGeneric(f.name, [])
+      else
+        element.setGeneric(f.name, nil)
+      end
+    end
+  end
+
+  def all_structural_features(element)
+    @all_structural_features ||= {}
+    return @all_structural_features[element.class] if @all_structural_features[element.class]
+    @all_structural_features[element.class] = 
+     element.class.ecore.eAllStructuralFeatures.reject{|f| f.derived}
+  end
+
+end
+
+end
+
+end
+