src/model/model_views.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 module model_views
  16
  17 import model_visitor
  18
  19 # Provide a configurable view to a model.
  20 #
  21 # This can be useful when you need to filter some mentities from a model
  22 # like private or fictive.
  23 #
  24 # TODO doc usage
  25 class ModelView
  26         super ModelVisitor
  27
  28         # The model to view through `self`.
  29         var model: Model
  30
  31         # MPackages visible through `self`.
  32         var mpackages: Set[MPackage] is lazy do
  33                 var mpackages = new HashSet[MPackage]
  34                 for mpackage in model.mpackages do
  35                         if not accept_mentity(mpackage) then continue
  36                         mpackages.add mpackage
  37                 end
  38                 return mpackages
  39         end
  40
  41         # MGroups visible through `self`.
  42         var mgroups: Set[MGroup] is lazy do
  43                 var mgroups = new HashSet[MGroup]
  44                 for mpackage in mpackages do
  45                         for mgroup in mpackage.mgroups do
  46                                 if not accept_mentity(mgroup) then continue
  47                                 mgroups.add mgroup
  48                         end
  49                 end
  50                 return mgroups
  51         end
  52
  53         # MModules visible through `self`.
  54         var mmodules: Set[MModule] is lazy do
  55                 var mmodules = new HashSet[MModule]
  56                 for mmodule in model.mmodules do
  57                         if not accept_mentity(mmodule) then continue
  58                         mmodules.add mmodule
  59                 end
  60                 return mmodules
  61         end
  62
  63         # MClasses visible through `self`.
  64         var mclasses: Set[MClass] is lazy do
  65                 var mclasses = new HashSet[MClass]
  66                 for mclass in model.mclasses do
  67                         if not accept_mentity(mclass) then continue
  68                         mclasses.add mclass
  69                 end
  70                 return mclasses
  71         end
  72
  73         # MClassDefs visible through `self`.
  74         var mclassdefs: Set[MClassDef] is lazy do
  75                 var mclassdefs = new HashSet[MClassDef]
  76                 for mclass in mclasses do
  77                         for mclassdef in mclass.mclassdefs do
  78                                 if not accept_mentity(mclassdef) then continue
  79                                 mclassdefs.add mclassdef
  80                         end
  81                 end
  82                 return mclassdefs
  83         end
  84
  85         # MProperties visible through `self`.
  86         var mproperties: Set[MProperty] is lazy do
  87                 var mproperties = new HashSet[MProperty]
  88                 for mproperty in model.mproperties do
  89                         if not accept_mentity(mproperty) then continue
  90                         mproperties.add mproperty
  91                 end
  92                 return mproperties
  93         end
  94
  95         # MPropdefs visible through `self`.
  96         var mpropdefs: Set[MPropDef] is lazy do
  97                 var mpropdefs = new HashSet[MPropDef]
  98                 for mproperty in mproperties do
  99                         for mpropdef in mproperty.mpropdefs do
 100                                 if not accept_mentity(mpropdef) then continue
 101                                 mpropdefs.add mpropdef
 102                         end
 103                 end
 104                 return mpropdefs
 105         end
 106
 107         # Lists all MEntities visible through `self`.
 108         var mentities: Set[MEntity] is lazy do
 109                 var res = new HashSet[MEntity]
 110                 res.add_all mpackages
 111                 res.add_all mgroups
 112                 res.add_all mmodules
 113                 res.add_all mclasses
 114                 res.add_all mclassdefs
 115                 res.add_all mproperties
 116                 res.add_all mpropdefs
 117                 return res
 118         end
 119
 120         private fun init_visitor(v: ModelVisitor) do
 121                 v.min_visibility = self.min_visibility
 122                 v.include_fictive = self.include_fictive
 123                 v.include_empty_doc = self.include_empty_doc
 124                 v.include_attribute = self.include_attribute
 125                 v.include_test_suite = self.include_test_suite
 126         end
 127
 128         # Searches MEntities that match `name`.
 129         fun mentities_by_name(name: String): Array[MEntity] do
 130                 var res = new Array[MEntity]
 131                 for mentity in mentities do if mentity.name == name then res.add mentity
 132                 return res
 133         end
 134
 135         # Looks up a MEntity by its full `namespace`.
 136         #
 137         # Usefull when `mentities_by_name` returns conflicts.
 138         #
 139         # Namespaces must be of the form `package::core::module::Class::prop`.
 140         fun mentities_by_namespace(namespace: String): Array[MEntity] do
 141                 var v = new LookupNamespaceVisitor(namespace)
 142                 init_visitor(v)
 143                 for mpackage in mpackages do
 144                         v.enter_visit(mpackage)
 145                 end
 146                 return v.results
 147         end
 148
 149         # Build an concerns tree with from `self`
 150         fun to_tree: MEntityTree do
 151                 var v = new ModelTreeVisitor
 152                 init_visitor(v)
 153                 for mpackage in mpackages do
 154                         v.enter_visit(mpackage)
 155                 end
 156                 return v.tree
 157         end
 158
 159         # Build the POSet of `mmodules` importation.
 160         fun mmodules_poset(mmodules: Set[MModule]): POSet[MModule] do
 161                 return model.mmodule_importation_hierarchy.sub(mmodules)
 162         end
 163
 164         # Build the POSet of `mmodules` hierarchy.
 165         fun mclasses_poset(mainmodule: MModule, mclasses: Set[MClass]): POSet[MClass] do
 166                 return mainmodule.flatten_mclass_hierarchy.sub(mclasses)
 167         end
 168 end
 169
 170 class LookupNamespaceVisitor
 171         super ModelVisitor
 172
 173         var namespace: String
 174
 175         private var parts: Array[String] is lazy do return namespace.split_with("::")
 176
 177         var results = new Array[MEntity]
 178
 179         redef fun visit(mentity) do mentity.accept_namespace_visitor(self)
 180 end
 181
 182 class ModelTreeVisitor
 183         super ModelVisitor
 184
 185         var tree = new MEntityTree
 186
 187         redef fun visit(mentity) do mentity.accept_tree_visitor(self)
 188 end
 189
 190 redef class MEntity
 191
 192         # Get a public view of the model
 193         fun public_view: ModelView do
 194                 var view = new ModelView(self.model)
 195                 view.min_visibility = public_visibility
 196                 return view
 197         end
 198
 199         # Get a public view of the model
 200         fun protected_view: ModelView do
 201                 var view = new ModelView(self.model)
 202                 view.min_visibility = protected_visibility
 203                 return view
 204         end
 205
 206         # Get a public view of the model
 207         fun private_view: ModelView do
 208                 var view = new ModelView(self.model)
 209                 view.min_visibility = private_visibility
 210                 return view
 211         end
 212
 213         private fun accept_namespace_visitor(v: LookupNamespaceVisitor) do
 214                 if v.parts.is_empty then return
 215                 if name != v.parts.first then return
 216                 v.parts.shift
 217                 if v.parts.is_empty then
 218                         v.results.add self
 219                         return
 220                 end
 221                 visit_all(v)
 222         end
 223
 224         private fun accept_tree_visitor(v: ModelTreeVisitor) do end
 225 end
 226
 227 redef class MPackage
 228         redef fun accept_tree_visitor(v) do
 229                 v.tree.add(null, self)
 230                 visit_all(v)
 231         end
 232 end
 233
 234 redef class MGroup
 235         redef fun accept_tree_visitor(v) do
 236                 var parent = self.parent
 237                 if parent != null then
 238                         v.tree.add(parent, self)
 239                 else
 240                         v.tree.add(mpackage, self)
 241                 end
 242                 visit_all(v)
 243         end
 244 end
 245
 246 redef class MModule
 247         redef fun accept_tree_visitor(v) do
 248                 v.tree.add(mgroup, self)
 249                 visit_all(v)
 250         end
 251 end
 252
 253 redef class MClass
 254         # We don't want to collect classes from full namespace.
 255         redef fun accept_namespace_visitor(v) do end
 256 end
 257
 258 redef class MClassDef
 259         redef fun accept_tree_visitor(v) do
 260                 v.tree.add(mmodule, self)
 261                 visit_all(v)
 262         end
 263 end
 264
 265 redef class MProperty
 266         # We don't want to collect properties from full namespace.
 267         redef fun accept_namespace_visitor(v) do end
 268 end
 269
 270 redef class MPropDef
 271         redef fun accept_tree_visitor(v) do
 272                 v.tree.add(mclassdef, self)
 273                 visit_all(v)
 274         end
 275 end