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 = self.include_test
 126         end
 127
 128         # Searches the MEntity that matches `full_name`.
 129         fun mentity_by_full_name(full_name: String): nullable MEntity do
 130                 for mentity in mentities do
 131                         if mentity.full_name == full_name then return mentity
 132                 end
 133                 return null
 134         end
 135
 136         # Build an concerns tree with from `self`
 137         fun to_tree: MEntityTree do
 138                 var v = new ModelTreeVisitor
 139                 init_visitor(v)
 140                 for mpackage in mpackages do
 141                         v.enter_visit(mpackage)
 142                 end
 143                 return v.tree
 144         end
 145
 146         # Build the POSet of `mmodules` importation.
 147         fun mmodules_poset(mmodules: Set[MModule]): POSet[MModule] do
 148                 return model.mmodule_importation_hierarchy.sub(mmodules)
 149         end
 150
 151         # Build the POSet of `mclasses` hierarchy.
 152         fun mclasses_poset(mainmodule: MModule, mclasses: Set[MClass]): POSet[MClass] do
 153                 return mainmodule.flatten_mclass_hierarchy.sub(mclasses)
 154         end
 155 end
 156
 157 class LookupNamespaceVisitor
 158         super ModelVisitor
 159
 160         var namespace: String
 161
 162         private var parts: Array[String] is lazy do return namespace.split_with("::")
 163
 164         var results = new Array[MEntity]
 165
 166         redef fun visit(mentity) do mentity.accept_namespace_visitor(self)
 167 end
 168
 169 class ModelTreeVisitor
 170         super ModelVisitor
 171
 172         var tree = new MEntityTree
 173
 174         redef fun visit(mentity) do mentity.accept_tree_visitor(self)
 175 end
 176
 177 redef class MEntity
 178
 179         # Get a public view of the model
 180         fun public_view: ModelView do
 181                 var view = new ModelView(self.model)
 182                 view.min_visibility = public_visibility
 183                 return view
 184         end
 185
 186         # Get a public view of the model
 187         fun protected_view: ModelView do
 188                 var view = new ModelView(self.model)
 189                 view.min_visibility = protected_visibility
 190                 return view
 191         end
 192
 193         # Get a public view of the model
 194         fun private_view: ModelView do
 195                 var view = new ModelView(self.model)
 196                 view.min_visibility = private_visibility
 197                 return view
 198         end
 199
 200         private fun accept_namespace_visitor(v: LookupNamespaceVisitor) do
 201                 if v.parts.is_empty then return
 202                 if name != v.parts.first then return
 203                 v.parts.shift
 204                 if v.parts.is_empty then
 205                         v.results.add self
 206                         return
 207                 end
 208                 visit_all(v)
 209         end
 210
 211         private fun accept_tree_visitor(v: ModelTreeVisitor) do end
 212 end
 213
 214 redef class MPackage
 215         redef fun accept_tree_visitor(v) do
 216                 v.tree.add(null, self)
 217                 visit_all(v)
 218         end
 219 end
 220
 221 redef class MGroup
 222         redef fun accept_tree_visitor(v) do
 223                 var parent = self.parent
 224                 if parent != null then
 225                         v.tree.add(parent, self)
 226                 else
 227                         v.tree.add(mpackage, self)
 228                 end
 229                 visit_all(v)
 230         end
 231 end
 232
 233 redef class MModule
 234         redef fun accept_tree_visitor(v) do
 235                 v.tree.add(mgroup, self)
 236                 visit_all(v)
 237         end
 238 end
 239
 240 redef class MClass
 241         # We don't want to collect classes from full namespace.
 242         redef fun accept_namespace_visitor(v) do end
 243 end
 244
 245 redef class MClassDef
 246         redef fun accept_tree_visitor(v) do
 247                 v.tree.add(mmodule, self)
 248                 visit_all(v)
 249         end
 250 end
 251
 252 redef class MProperty
 253         # We don't want to collect properties from full namespace.
 254         redef fun accept_namespace_visitor(v) do end
 255 end
 256
 257 redef class MPropDef
 258         redef fun accept_tree_visitor(v) do
 259                 v.tree.add(mclassdef, self)
 260                 visit_all(v)
 261         end
 262 end