Class: MMEdit::DataProvider

Inherits:
Object
  • Object
show all
Includes:
MMGen::MetamodelGenerator
Defined in:
lib/mmedit/data_provider.rb

Constant Summary collapse

BuiltInIdent = 
"_builtin"

Instance Method Summary collapse

Constructor Details

#initialize(workingSet, mm, indexBuilder, logger) ⇒ DataProvider

Returns a new instance of DataProvider.



18
19
20
21
22
23
24
25
26
27
 
# File 'lib/mmedit/data_provider.rb', line 18

def initialize(workingSet, mm, indexBuilder, logger)
  @workingSet = workingSet
  @mm = mm
  @indexBuilder = indexBuilder
  @logger = logger
  @jsonModelCache = Concrete::FileCacheMap.new(".mmedit", ".json")
  @jsonModelCache.versionInfo = MMEDIT_VERSION
  @jsonIndexCache = Concrete::FileCacheMap.new(".mmedit", ".index")
  @jsonIndexCache.versionInfo = MMEDIT_VERSION
end

Instance Method Details

#createModule(fileIdent) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/mmedit/data_provider.rb', line 66

def createModule(fileIdent)
  return if fileIdent =~ /\.\./
  newfile = Pathname.new(@workingSet.rootPath + "/" + fileIdent).cleanpath.to_s

  unless File.exist?(newfile)
    @logger.info("Creating module #{newfile}")
    FileUtils.mkdir_p(File.dirname(newfile))

    root = RGen::ECore::EPackage.new(:name => "Untitled")
    if fileIdent =~ /\.ecore$/
      File.open(newfile,"w") do |f|
        ser = RGen::Serializer::XMI20Serializer.new(f)
        ser.serialize(root)
      end
    else
      generateMetamodel(root, newfile)
    end
  else
    @logger.info("Using existing module #{newfile}")
  end

  @workingSet.addFile(newfile)
end

#getAllJsonIndex ⇒ Object 



119
120
121
122
123
124
 
# File 'lib/mmedit/data_provider.rb', line 119

def getAllJsonIndex
puts "load index"
  "[" + (@workingSet.fileIdentifiers + [BuiltInIdent]).collect do |ident|
    '{ "_class": "Module", "name": "'+ident+'", "elements":'+"\n"+getJsonIndex(ident)+"}"
  end.join(",\n") + "]"
end

#getJsonModel(fileIdent) ⇒ Object 



58
59
60
61
62
63
64
 
# File 'lib/mmedit/data_provider.rb', line 58

def getJsonModel(fileIdent)
  if (fileIdent == BuiltInIdent)
    builtInJsonModel
  else
    cachedData(fileIdent, @jsonModelCache)
  end
end

#indexMetamodelAsJson ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/mmedit/data_provider.rb', line 44

def indexMetamodelAsJson
  return @indexMetamodelAsJson if @indexMetamodelAsJson

  env = RGen::Environment.new
  trans = Concrete::Metamodel::ECoreToConcrete.new(nil, env)
  trans.trans(@indexBuilder.indexMetamodel.ecore.eAllClasses)

  writer = Concrete::Util::StringWriter.new
  ser = RGen::Serializer::JsonSerializer.new(writer, :leadingSeparator => false)
  ser.serialize(env.find(:class => Concrete::Metamodel::ConcreteMMM::Classifier))

  @indexMetamodelAsJson = "var IndexMetamodel = "+writer.string+";"
end

#metamodelAsJson ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/mmedit/data_provider.rb', line 29

def metamodelAsJson
  return @metamodelAsJson if @metamodelAsJson

  env = RGen::Environment.new

  trans = Concrete::Metamodel::ECoreToConcrete.new(nil, env, :featureFilter => proc{|f| !f.derived && f.name != "eSubTypes"})
  trans.trans(@mm.ecore.eAllClasses)

  writer = Concrete::Util::StringWriter.new
  ser = RGen::Serializer::JsonSerializer.new(writer, :leadingSeparator => false)
  ser.serialize(env.find(:class => Concrete::Metamodel::ConcreteMMM::Classifier))

  @metamodelAsJson = "var Metamodel = "+writer.string+";"
end

#setJsonModel(fileIdent, data) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/mmedit/data_provider.rb', line 90

def setJsonModel(fileIdent, data)
  return if (fileIdent == BuiltInIdent)

  env = RGen::Environment.new

  inst = RGen::Instantiator::JsonInstantiator.new(env, @mm, :separator => "/", :leadingSeparator => true)
  unresolvedReferences = inst.instantiate(data)

  resolveReferencesToBuiltins(unresolvedReferences)

  outfile = @workingSet.getFile(fileIdent)
  return unless outfile

  tempfile = outfile+".mmedit.tmp"
  root = env.find(:class => RGen::ECore::EPackage).find{|p| p.eSuperPackage.nil?}
  if fileIdent =~ /\.ecore$/
    File.open(tempfile,"w") do |f|
      ser = RGen::Serializer::XMI20Serializer.new(f)
      ser.serialize(root)
    end
  else
    generateMetamodel(root, tempfile)
  end
  FileUtils.mv(tempfile, outfile)

  @jsonModelCache.storeData(outfile, data)
  generateJsonIndex(outfile, root)
end