concrete 0.2.0

data/lib/concrete/config.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+
+module Concrete
+
+class Config
+
+  def initialize(filename)
+    @filename = filename
+  end
+
+  def loadValue(key)
+    config = loadConfig
+    config[key] if config.is_a?(Hash)
+  end
+
+  def storeValue(key, value)
+    config = loadConfig
+    config[key] = value
+    File.open(@filename, "w") do |f|
+      YAML.dump(config, f)
+    end
+  end
+  
+  private
+  
+  def loadConfig
+    if File.exist?(@filename)
+      YAML.load_file(@filename) 
+    else
+      {}
+    end
+  end
+
+end
+
+end 

data/lib/concrete/file_cache_map.rb

@@ -0,0 +1,88 @@
+require 'digest'
+require 'fileutils'
+
+module Concrete
+
+# 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 :versionInfo
+
+  # +cacheDir+ is the name of the subfolder where cache files are created
+  # +postfix+ is an extension appended to the original file name in order to
+  # create the name of the cache file
+  def initialize(cacheDir, postfix)
+    @postfix = postfix
+    @cacheDir = cacheDir
+  end
+
+  # load data associated with file +keyPath+
+  # returns :invalid in case either the associated file or the cache file has changed
+  def loadData(keyPath)
+    cf = cacheFile(keyPath)
+    return :invalid unless File.exist?(cf)
+    result = nil
+    File.open(cf, "rb") do |f|
+      checksum = f.read(41)[0..39]
+      data = f.read
+      if calcSha1(data) == checksum
+        if calcSha1(keyData(keyPath)) == data[0..39]
+          result = data[41..-1]
+        else
+          result = :invalid
+        end
+      else
+        result = :invalid
+      end
+    end 
+    result
+  end
+
+  # store data +valueData+ associated with file +keyPath+
+  def storeData(keyPath, valueData)
+    data = calcSha1(keyData(keyPath)) + "\n" + valueData
+    data = calcSha1(data) + "\n" + data
+    cf = cacheFile(keyPath)
+    FileUtils.mkdir(File.dirname(cf)) unless File.exist?(File.dirname(cf))
+    File.open(cf, "wb") do |f|
+      f.write(data)
+    end 
+  end
+
+  # remove cache files which are not associated with any file in +keyPaths+
+  # will only remove files within +rootPath+
+  def cleanUnused(rootPath, keyPaths)
+    raise "key paths must be within root path" unless keyPaths.all?{|p| p.index(rootPath) == 0}
+    usedFiles = keyPaths.collect{|p| cacheFile(p)}
+    files = Dir[rootPath+"/**/"+@cacheDir+"/*"+@postfix] 
+    files.each do |f|
+      FileUtils.rm(f) unless usedFiles.include?(f)
+    end
+  end
+
+private
+  
+  def keyData(path)
+    File.read(path)+@versionInfo.to_s
+  end
+
+  def cacheFile(path)
+    File.dirname(path) + "/"+@cacheDir+"/" + File.basename(path) + @postfix 
+  end
+
+  def calcSha1(data)
+    sha1 = Digest::SHA1.new
+    sha1.update(data)
+    sha1.hexdigest
+  end
+   
+end
+
+end
+

data/lib/concrete/index_builder.rb

@@ -0,0 +1,108 @@
+require 'mmgen/metamodel_generator'
+require 'andand'
+require 'tempfile'
+
+module Concrete
+
+class IndexBuilder
+
+  include MMGen::MetamodelGenerator
+
+  def initialize(mm, options={})
+    @mm = mm
+    @identName = options[:identifierName] || "name"
+    @ignoreReferences = options[:ignoreReferences]
+    @moduleClassName = options[:moduleClassName] || "Module"
+  end
+
+  def indexMetamodel
+    @indexMM ||= buildIndexMetamodel
+  end
+
+  def buildIndex(root)
+    buildIndexInternal(root)
+  end
+
+  private
+
+  def buildIndexMetamodel
+    env = RGen::Environment.new
+
+    allContainersCache = {}
+    processedClasses = {}
+    referencedClasses = []
+    @mm.ecore.eAllClasses.eReferences.each do |r|
+      next if r.containment || r.derived
+      next if @ignoreReferences.andand.call(r)
+      next if processedClasses[r.eType]
+      processedClasses[r.eType] = true
+      allNamedSubclasses(r.eType).each do |c|
+        referencedClasses |= ([c] + allContainers(c, allContainersCache))
+      end
+    end
+
+    package = env.new(RGen::ECore::EPackage, :name => "IndexMetamodel")
+    indexElement = env.new(RGen::ECore::EClass, :name => "IndexElement", :ePackage => package)
+    env.new(RGen::ECore::EAttribute, :name => "name", :eType => RGen::ECore::EString, :eContainingClass => indexElement)
+    env.new(RGen::ECore::EReference, :name => "elements", :upperBound => -1, :containment => true, :eType => indexElement, :eContainingClass => indexElement)
+    env.new(RGen::ECore::EClass, :name => @moduleClassName, :eSuperTypes => [indexElement], :ePackage => package)
+    
+    @mm.ecore.eAllClasses.each do |c|
+      if !c.abstract && referencedClasses.include?(c) 
+        env.new(RGen::ECore::EClass, :name => c.name, :eSuperTypes => [indexElement], :ePackage => package)
+      end
+    end
+
+    loadIndexMetamodel(package)
+  end
+
+  def allNamedSubclasses(clazz)
+    if clazz.eAllStructuralFeatures.any?{|f| f.name == @identName}
+      [clazz] + clazz.eAllSubTypes
+    else
+      clazz.eAllSubTypes.select{|t| t.eAllStructuralFeatures.any?{|f| f.name == @identName}}
+    end
+  end
+
+  def loadIndexMetamodel(indexMMPackage)
+    mmFile = Tempfile.new("index_metamodel")
+    mmFile.close 
+    generateMetamodel(indexMMPackage, mmFile.path)
+    containerName = "MMContainer"+self.object_id.to_s
+    eval("module "+containerName+"; end")
+    container = self.class.const_get(containerName) 
+    container.module_eval(File.read(mmFile.path))
+    mmFile.unlink
+    container.const_get(indexMMPackage.name)
+  end
+
+  def buildIndexInternal(element)
+    return unless indexMetamodel.const_defined?(element.class.ecore.name)
+    return unless element.respond_to?(@identName)
+    ie = indexMetamodel.const_get(element.class.ecore.name).new
+    ie.name = element.getGeneric(@identName)
+    element.class.ecore.eAllReferences.select{|r| r.containment}.each do |r|
+      values = element.getGenericAsArray(r.name).compact
+      values.each do |v|
+        ie.addElements(buildIndexInternal(v))
+      end
+    end
+    ie
+  end
+
+  def containers(c)
+    types = c.eAllReferences.select{|r| r.eOpposite && r.eOpposite.containment}.eType
+    types + types.eAllSubTypes
+  end
+
+  def allContainers(c, cache)
+    return cache[c] if cache[c]
+    cache[c] = []
+    cons = containers(c)
+    cache[c] = cons | cons.collect{|cn| allContainers(cn, cache)}.flatten
+  end
+
+  end
+
+end
+

data/lib/concrete/metamodel/concrete_mmm.rb

@@ -0,0 +1,45 @@
+require 'rgen/metamodel_builder'
+
+module Concrete
+
+module Metamodel
+
+# Concrete meta-metamodel
+module ConcreteMMM
+  extend RGen::MetamodelBuilder::ModuleExtension
+  include RGen::MetamodelBuilder::DataTypes
+
+  FeatureKindType = Enum.new(:name => "FeatureKind", :literals =>[ :attribute, :reference, :containment ])
+
+  class Classifier < RGen::MetamodelBuilder::MMBase
+    abstract
+    has_attr 'name', String
+  end
+
+  class Class < Classifier 
+    has_attr 'abstract', Boolean
+  end
+  Class.has_many 'superTypes', Class
+
+  class Datatype < Classifier
+  end
+
+  class Enum < Datatype
+    has_many_attr 'literals', String
+  end
+
+  class Feature < RGen::MetamodelBuilder::MMBase
+    has_attr 'name', String
+    has_attr 'kind', FeatureKindType
+    has_attr 'lowerLimit', Integer
+    has_attr 'upperLimit', Integer
+    has_one 'type', Classifier
+  end
+  Class.contains_many 'features', Feature, 'containingClass'
+
+end
+
+end
+
+end
+

data/lib/concrete/metamodel/ecore_to_concrete.rb

@@ -0,0 +1,80 @@
+require 'rgen/transformer'
+require 'rgen/ecore/ecore'
+require 'concrete/metamodel/concrete_mmm'
+
+module Concrete
+
+module Metamodel
+
+class ECoreToConcrete < RGen::Transformer
+  include RGen::ECore
+
+  def initialize(env_in, env_out, opts={})
+    super
+    @featureFilter = opts[:featureFilter]
+  end
+   
+  def transform
+    uniqueClassNameCheck
+    trans(:class => EClass)
+  end
+
+  transform EClass, :to => ConcreteMMM::Class do
+    { :name => name,
+      :abstract => abstract, 
+      :features => trans(eStructuralFeatures.reject{ |f| 
+        (f.is_a?(RGen::ECore::EReference) && f.eOpposite && f.eOpposite.containment) || 
+        (@featureFilter && !@featureFilter.call(f)) }),
+      :superTypes => trans(eSuperTypes)
+    }
+  end
+ 
+  transform EStructuralFeature, :to => ConcreteMMM::Feature do
+    if eType.is_a?(EDataType) && !eType.is_a?(EEnum)
+      _type = primitiveType(eType)
+    else
+      _type = trans(eType)
+    end
+    { :name => name,
+      :type => _type,
+      :kind => (@current_object.is_a?(EAttribute) ? :attribute : (containment ? :containment : :reference)),
+      :lowerLimit => lowerBound,
+      :upperLimit => upperBound
+    } 
+  end
+  
+  transform EEnum, :to => ConcreteMMM::Enum do
+    { :name => name,
+      :literals => eLiterals.collect{|l| l.name}
+    }
+  end
+ 
+  def primitiveType(eType)
+    @primitiveType ||= {}
+    return @primitiveType[eType] if @primitiveType[eType]
+    if eType == EString
+      @primitiveType[eType] = @env_out.new(ConcreteMMM::Datatype, :name => "String")
+    elsif eType == EInt
+      @primitiveType[eType] = @env_out.new(ConcreteMMM::Datatype, :name => "Integer")
+    elsif eType == EFloat
+      @primitiveType[eType] = @env_out.new(ConcreteMMM::Datatype, :name => "Float")
+    elsif eType == EBoolean
+      @primitiveType[eType] = @env_out.new(ConcreteMMM::Datatype, :name => "Boolean")
+    else
+      # ignore unsupported datatype
+    end
+  end
+
+  def uniqueClassNameCheck
+    classNames = {}
+    @env_in.find(:class => EClass).each do |c|
+      raise "unqualified class names not unique, concrete does not support packages" if classNames[c.name]
+      classNames[c.name] = true
+    end
+  end
+end 
+
+end
+
+end
+

data/lib/concrete/server.rb

@@ -0,0 +1,92 @@
+require 'webrick'
+
+module Concrete
+
+class Server
+
+	def initialize(workingSet, dataProvider, syntaxProvider, htmlRoot, options={})
+    @workingSet = workingSet
+    @dataProvider = dataProvider
+    @syntaxProvider = syntaxProvider 
+    @htmlRoot = htmlRoot
+    @mutex = Mutex.new
+		@server = WEBrick::HTTPServer.new(:Port => (options[:port] || 1234))
+		@server.mount_proc("/") do |req, res|
+      handleRequest(req, res)
+		end
+	end
+	
+	def start
+		@server.start do |sock|
+			@server.run(sock)
+		end
+	end
+	
+	private
+
+	def handleRequest(req, res)
+		if req.path == "/"
+      editorHtml = File.read(@htmlRoot+"/editor.html")
+      editorHtml.sub!(/<!--\s+html templates\s+-->/, @syntaxProvider.selectedSyntax.htmlTemplates) if @syntaxProvider.andand.selectedSyntax.andand.htmlTemplates
+			res.body = editorHtml 
+		elsif req.path =~ /^\/html\/(.*)/
+      File.open(@htmlRoot+"/"+$1, "rb") do |f|
+        res.body = f.read
+      end
+    elsif req.path =~ /^\/syntax\/(.*)/ && @syntaxProvider.selectedSyntax
+      File.open(@syntaxProvider.selectedSyntax.dir+"/"+$1, "rb") do |f|
+        res.body = f.read
+      end
+		elsif req.path =~ /^\/concrete\/(.*)/
+      File.open(File.dirname(__FILE__)+"/../../"+$1, "rb") do |f|
+        res.body = f.read
+      end
+		elsif req.path =~ /^\/doc\/(.*)/
+      File.open(File.dirname(__FILE__)+"/../../doc/"+$1, "rb") do |f|
+        res.body = f.read
+      end
+		elsif req.path == "/loadIndex"
+      @mutex.synchronize do
+        res.body = @dataProvider.getAllJsonIndex
+      end
+    elsif req.path == "/loadModule"
+      @mutex.synchronize do
+        res.body = @dataProvider.getJsonModel(req.query["module"])
+      end
+    elsif req.path == "/storeModule"
+      @mutex.synchronize do
+        identDelim = req.body.index("\n")
+        ident = req.body[0..identDelim-1]
+        body = req.body[identDelim+1..-1]
+        @dataProvider.setJsonModel(ident, body)
+      end
+    elsif req.path == "/createModule"
+      @mutex.synchronize do
+        @dataProvider.createModule(req.query["module"])
+        res.body = ""
+      end
+    elsif req.path == "/concreteSyntaxes"
+      res.body = @syntaxProvider.syntaxesAsJson 
+    elsif req.path == "/setConcreteSyntax"
+      @syntaxProvider.selectSyntax(req.query["ident"])
+    elsif req.path =~ /\bmetamodel\.js/
+      @mutex.synchronize do
+        res.body = @dataProvider.metamodelAsJson 
+      end
+    elsif req.path =~ /\bindex_metamodel\.js/
+      @mutex.synchronize do
+        res.body = @dataProvider.indexMetamodelAsJson 
+      end
+		elsif req.path == "/exit"
+			@server.shutdown
+    elsif req.path =~ /favicon\.ico/
+      res.body = ""
+    else
+      # error
+		end
+	end	
+		
+end
+
+end
+