tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/mustache/template_reader.rb

@@ -11,7 +11,7 @@ module Sbuilder
   class TemplateReader
 
     include Sbuilder::Utils::MyLogger   # mix logger
-    PROGNAME = "treader"                # progname for logger
+    PROGNAME = nil                      # progname for logger use default class name
 
     
     # ------------------------------------------------------------------
@@ -22,6 +22,10 @@ module Sbuilder
     attr_writer :partials            # f: partial-name --> template string
     attr_writer :templates           # f: template-name --> template string
 
+    # [Sbuilder::Controller]  set in init
+    attr_reader :controller             
+    
+
     # ------------------------------------------------------------------
     # Constructor
     
@@ -29,42 +33,22 @@ module Sbuilder
       @logger = getLogger( PROGNAME, options )
       @logger.info( "#{__method__} created, options='#{options}" )
 
-      # use default templates - prefix with user specified templates
-      @template_paths = options[:default_templates]
-      # for mustache templates
-      if options[:templates] then
-        @template_paths = options[:templates] + (options[:default_templates] || [] )
-      end
-      
-      # # init partial cache
-      # @partials = {}
+      @controller = controller
 
+      # use default templates - prefix with user specified templates
+      # @template_paths = options[:default_templates] || []
+      # # for mustache templates
+      # if options[:templates] then
+      #   @template_paths = options[:templates] + (options[:default_templates] || [] )
+      # end
+      @template_paths = controller.templateRenderDirectories
     end
 
+
     # ------------------------------------------------------------------
-    # Config - after contructor
 
-    # Null operation: no configuration actions taken. Maybe subclasses
-    # will implement something usefull
-    #
-    # @param steps [Hash] from 'model#templateData('steps')' with "steps"=>{'process', 'interface_name'}
-    # @param interfaces [Hash] from 'model#templateData('interfaces')' with "interface"=>{'interface_name', 'implementation'}    
+    # @!group Rules to identify template types
     
-    # def configSetup( steps, interfaces )
-    #   @logger.info( "#{__method__} steps=#{steps["steps"].join('\n')}" )
-    #   interfaces = interfaces["interfaces"] ? interfaces["interfaces"] : []
-    #   @logger.info( "#{__method__} interfaces=#{interfaces.join('\n')}" )
-    # end
-
-
-    # ------------------------------------------------------------------
-    # filter actions
-    
-    # default template when filtered
-    # @return [String] emptpy string for filtered templtae
-    def filtered_template
-      ""
-    end
 
     # To override in sub-classes
     #
@@ -72,12 +56,17 @@ module Sbuilder
     def show_template( name )
       true
     end
+
     
+    # @!endgroup    
     
 
     # ------------------------------------------------------------------
     # Services
 
+    # @!group public services
+    
+
     # Check whether template 'name' should be be shown, next resolve
     # location of a template file, and do 'File.read' on the file path
     #
@@ -96,23 +85,35 @@ module Sbuilder
 
     end # get_template( name )
 
-    # @param path [String] path name to template
-    # @return [String] for template content    
-    def template_read( path )
-      File.read( path  )
+
+    # @!endgroup    
+
+    # ------------------------------------------------------------------
+    # @!group Special template content 
+    
+    # default template when filtered
+    # @return [String] emptpy string for filtered templtae
+    def filtered_template
+      ""
     end
-                       
-          
 
 
-    # return path to an existing template file name
+    # @!endgroup    
+    
+    
+    # ------------------------------------------------------------------
+    # @!group Access template files 
+    
+
+    # @return path to an existing template file name
+    #
     # @exception if template not found
     def get_template_filepath( name ) 
 
       @template_paths.each do |directory_or_gemname|
         
         template_path = get_template_filepath_resolve( directory_or_gemname, name ) 
-        return template_path if template_path && File.exists?( template_path ) 
+        return template_path if template_path && File.exists?( template_path ) && File.file?( template_path )
 
       end # each 
 
@@ -127,12 +128,9 @@ module Sbuilder
       
     end
 
-    # ------------------------------------------------------------------
-    # private
-
-    private
+    
     # return path to plain 'directory' or to gem directory
-    def get_template_filepath_resolve( directory_or_gemname, template_file )
+    private def get_template_filepath_resolve( directory_or_gemname, template_file )
       @logger.info( "#{__method__} directory_or_gemname=#{directory_or_gemname}" )
       if directory_or_gemname[-1] == '/' then
         return get_template_filepath_in_directory( directory_or_gemname[0..-2], template_file )
@@ -143,7 +141,7 @@ module Sbuilder
     end
 
     # return directory to 'gemspec'
-    def gemname_to_directory( gemname_and_spec ) 
+    private def gemname_to_directory( gemname_and_spec ) 
 
       # The version requirements are optional.
       # You can also specify multiple version requirements, just append more at the end
@@ -175,7 +173,7 @@ module Sbuilder
     
 
     # return path to 'template_file' in an existing 'directory'
-    def get_template_filepath_in_directory( directory, template_file ) 
+    private def get_template_filepath_in_directory( directory, template_file ) 
       @logger.debug( "#{__method__} directory=#{directory}, template_file=#{template_file}" )
 
       if ! File.exists?( directory ) then
@@ -199,6 +197,18 @@ module Sbuilder
 
     end
 
+    # Read template from file
+    #
+    # @param path [String] path name to template
+    # @return [String] for template content    
+    private def template_read( path )
+      File.read( path  )
+    end
+                       
+    
+
+    # @!endgroup        
+
   end # class
 
 end # module

data/lib/sbuilder/mustache/template_reader_context.rb

@@ -1,35 +1,27 @@
-require 'tla-parser-s'       # TLA+ parser && resolver
-
 module Sbuilder
 
   
   # ------------------------------------------------------------------
-  # Use setup configuration to filter out part of reander templates.
+  # Use setup configuration to render only templates, which are
+  # reachable for setup entry points (getEntryPoints +
+  # getSetupPossibilities + getModelInvariants + getSetupAssumes).
   #
   # Implementation overrides 'whitelist' method in 'TemplateReader'.
-  # Uses 'TlaParserS::Resolver' to parse TLA+ snippets, and resolve
-  # modules to put in whitelist'
-  #
-  # Overview:
-  #
-  # - configSetup -methods receives 'steps' ie. array of interface
-  #   names called in setup, and array of 'interfaces', which map
-  #   interfaces to interface implementations
+  # uses 'Sbuilder::ParserFacade' to parse TLA+ snippets, and resolve
+  # modules to put in whitelist'.  `show_template` - method overrides
+  # default 'show-all' method in parent class, and says true only for
+  # templates, which are reachable for entry points.
   #
-  # - TlaParserS::Resolver#initSnippets parses tla-sbuilder code
-  # - repository
-  #
-  # - TlaParserS::Resolver#entryPoints resolves modules required to
-  #   satisfy interface implementations used in setup
 
   class TemplateContextReader < TemplateReader
 
     extend Forwardable                  # for easy delegation
     
     def_delegators :controller,
-                   :getEntryPoints,     # [String:Array] of
+                   :getEntryPoints,     # [String:Array] of 
+                                        # interface operation
                                         # implemenation names
-                                        # extracted from 'configSetup'
+                                        # defined for current setup 
                    :getSetupPossibilities,
                                         # [String:Array] names of
                                         # possiblity operators defined
@@ -44,97 +36,62 @@ module Sbuilder
                    :getModelNames       # [String:Array] of names in model
 
     # ------------------------------------------------------------------
-    # constructore
-
+    # Add logger
 
     include Sbuilder::Utils::MyLogger   # mix logger
-    PROGNAME = "creader"                # progname for logger
+    PROGNAME = nil
 
-    # TLA+ standard library symbols
-    GLOBALS = %w( TRUE FALSE Cardinality)
-
-    # Sbuilder constant symbols
-    SBUILDER = %w( Nil InfrastructureServiceReturn InfrastructureServiceGetStatus 
-    InfrastructureServiceGetResponse InTransaction)
-
-    # these directories not unmustached
-    DOC_DIRS= [ "docs", "doc" ]
-    
     # ------------------------------------------------------------------
     # Attributes
-    attr_reader :options                # hash{:filter_list}
+    # @attr [Hash] options
+    attr_reader :options                
 
-    attr_reader :resolver               # [TlaParserS::Resolver] to
-                                        # resolve entry point modules
 
 
-    attr_reader :controller             # [Sbuilder::Controller] 
+    attr_reader :setupName              # setup being currently generated
 
-
-    attr_reader :setupName              # currently generating
+    # @attr parserFacade [Sbuilder::ParserFacade] object to access parser
+    attr_reader :parserFacade
     
     # ------------------------------------------------------------------
-    # Constructor
+    # @!group Constructor && configure
+
+    # Constructor method
     
     def initialize( controller, options={} )
       super( controller, options )
       @logger = getLogger( PROGNAME, options )
       @logger.info( "#{__method__} created, options='#{options}" )
 
-      @controller = controller
+      # Init object providing access to parser resolver
+      @parserFacade = controller.factory.createParserFacade
 
       @options = options
 
-
-      # # create '@resolver' && parse snippet repository
-      # if  isOptFilterSrc then
-      # end
-      
-    end
-
-    # ------------------------------------------------------------------
-    # Lazy intialize (so that configuration can take place)
-    def resolver
-      return @resolver if @resolver
-
-      raise "No option :cache_dir" unless options[:cache_dir] && !options[:cache_dir].empty?
-      unmustache_dir = "#{options[:cache_dir]}/unmustache"
-
-      # copy unmustached version for templates
-      unmustache( unmustache_dir )
-
-      # init resovelver using 'unmustache_dir'
-      @resolver = initResolver( unmustache_dir, options )
-      return @resolver
     end
 
-    # ------------------------------------------------------------------
-    # Options
-
-
-    # @return [string] file path for filter list
-    def filter_list
-      options[:filter_list]
-    end
-
-
-    # ------------------------------------------------------------------
-    # config
+    # Controller uses this method to inform template reader of the
+    # setup currently being processed.
+    # 
 
     def setSetupName( setupName )
       @logger.info( "#{__method__} setupName=#{setupName}" )
       @setupName = setupName
     end
+
+    # @!endgroup        
     
+
     # ------------------------------------------------------------------
-    #
+    # @!group Override default `show_template` in parent class
+    
     # Try to find a reason to show template
     # 
     # @param [String] name of template to check @return [boolean] true
     # when template should be shown normally, else false
     #
     # @return [Bool,String] show and text description
-    def show_template_do( name )
+    private def show_template_do( name )
 
       @logger.debug( "#{__method__}: check name=#{name}" )
       
@@ -144,7 +101,6 @@ module Sbuilder
       # show template witout extesions
       return true, "no extension" if /^[^\/\.]*$/ =~ name
 
-      # show template if name is in whitelist 'opts[:filter_list]'
       # puts "#{whitelist.join(',')}: '#{name}'--> #{whitelist.include?(name)}"
       return true, "in whitelist" if whitelist.include?( name.to_s  )
 
@@ -164,181 +120,55 @@ module Sbuilder
       ret[0]
     end
 
-    # ------------------------------------------------------------------
-    # whitelist
+    # @!endgroup
 
-    # Return whitelisted template names.
-    #
-    # Implementation reads, and caches lines, in a file pointed by
-    # options[:filter_list]
-    #
-    # @return [Array] of whitelistes template names
-    def whitelist_file
-      return [] unless filter_list
-      File.readlines( filter_list ).each {|l| l.chomp! } || []
-    end
+    # ------------------------------------------------------------------
+    # @!group Access resolver
 
-    # Add Globals, Sbuilder and model symbols to resolver
-    # 
+    # Get access to parser resolver from parser facade.
     #
-    def initResolverContext( resolver )
-
-      output( 1, " Initialize resolver context symbols" )
-
-      
-      output( 2, "   TLA+ symbols: #{GLOBALS.join( ',')}" )      
-      output( 1, "   #{GLOBALS.length} TLA+ symbols" )
-      resolver.initContext( GLOBALS )
-
-      output( 2, "   Sbuilder symbols: #{SBUILDER.join( ',')}" )            
-      output( 1, "   #{SBUILDER.length} SBuilder symbols" )
-      resolver.initContext( SBUILDER )
-
-      model_names = getModelNames
-      output( 2, "   Model symbols: #{model_names.join( ',')}" )            
-      output( 1, "   #{model_names.length} model symbols" )
-      resolver.initContext( model_names )
-
-      output( 1, " Initialize resolver context symbols - done" )      
-      
-    end
-
-    # Access controller to get information needed in un-mustache
-    # operation
-    def unmustache( unmustache_dir )
-      
-      if ! Dir.exists?( unmustache_dir )
-        `mkdir #{unmustache_dir}`
-        exit unless $?.success?
-      end
-      
-      unmustacheDo( controller.getCodeRepository, unmustache_dir, controller.getPreferencesData(setupName) )
-    end
-
-    # Unmustache files in 'src_dir' to 'target_dir'. Pass preferences
-    # json to mustache rendering
+    # At this point parser resolver is most likely already initialized
+    # (i.e. snippets parsed) becase snippets are sorted in correct
+    # order before a decission to prune out unreachable snippets is
+    # done in this class.
     #
-    # @param src_dir [String] path source directory
-    # @param dest_dir [String] path destination directory    
-    
-    def unmustacheDo( src_dir, target_dir, preferences )
-      @logger.info( "#{__method__}, src_dir=#{src_dir}, target_dir=#{target_dir}, preferences=#{preferences}" )
-
-      output( 1, "Unmustache  #{src_dir} --> #{target_dir} - start" )
-
-      source_files = Dir::glob(  "#{src_dir}/**/*" )
-      source_files.each do |file|
-        
-        next if File.directory?( file )
-
-        # extract relatve path in respect to src_dir
-        source = Pathname.new( File.expand_path( file) )
-        source_root = Pathname.new( File.expand_path( src_dir )  )
-        src = source.relative_path_from( source_root )
-
-        # do not unmustache anythins under docs, doc directory
-        if DOC_DIRS.include?( File.dirname( src ).split(File::SEPARATOR).first )
-          output( 1, "   document file  #{src} not unmustached" )          
-          next
-        end
-
-        
-        target = "#{target_dir}/#{src}"
-        # puts "#{source} --> #{target}"
-        
-        if !File.exists?( File.dirname(target) )
-          cmd = "mkdir -p #{File.dirname(target)}"
-          output( 1, cmd )
-          `#{cmd}`
-          exit unless $?.success?
-        end # create dir
-
-        if !File.exists?(target) or (File.mtime( source ) > File.mtime(target))
-          cmd =  "echo '#{preferences.to_json}' | mustache - #{source} > #{target}"
-          output( 2, "   " + cmd )
-          `#{cmd}`
-          exit unless $?.success?
-        end # create file
-      end
-
-      output( 1, "Unmustache  #{src_dir} --> #{target_dir} - done" )
+    # @return [TlaParserS::Resolver] parser resolver ready to use
+    private def getResolver
 
+      parserFacade.getResolver( controller )
       
     end
     
+    # @!endgroup    
     
 
-    # Create '@resolver' and initSnippets in 'snippet_repository'
-    #
-    # @param options [Hash] defining options for 'Resolver'
-    def initResolver( snippet_repository, options={} )
-      
-      
-      output( 1, "Parse snippet from repository #{snippet_repository} - start" )
-
-      cnt = 0
-      resolver = nil
-      Dir.chdir( snippet_repository ) do
-        
-        @logger.info( "#{__method__}: init snippets in snippet_repository=#{snippet_repository}" )
-        snippet_files = Dir.glob( "**/*").map { |fileName| File.new(fileName)}
-        resolver =  TlaParserS::Resolver.new( options )
-
-        # Add Globals, Sbuilder and model symbols to resolver
-        initResolverContext( resolver )
-
-        # Parse 'snippet_files' - 
-        resolver.initSnippets( snippet_files ) do |stat,entry,e|
-          
-          if stat
-            # success output dots no newline
-            output( 1, ".", false )
-            cnt += 1
-            true
-          else
-
-            # parses error
-            if filter_list
-              msg = <<-EOS
-
-              Parser error: option '--filter-list' set --> continue
-              #{e.message} 
-              EOS
-              @logger.error( msg )
-              warn msg
-              true
-            else
-              msg = <<-EOS
-              Parser error:  option '--filter-list' not set --> exiting
-              #{e.message} 
-              EOS
-              @logger.error( msg )
-              warn msg
-              false
-            end # if filter_list
-            
-          end # else - false: error
-        end # block
-        
-      end # chdir
-      
-      # start new line
-      output( 1, "" )
-      output( 1, "Parse snippet from repository #{snippet_repository} - done: parsed #{cnt} snippets" )
+    # ------------------------------------------------------------------
+    # @!group Whitelist
 
-      resolver
+    # Return whitelisted template names. Implementation returns empty
+    # list.
+    #
+    # @return [Array] of whitelistes template names
+    private def whitelist_file
+      return []
     end
     
+    
     # Call resolver#resolveModule to find out the whitelist modules.
     # Implementation uses 'entry_points' configured in 'configSetup'
     #
     # @return [String:Array] of white listed modules
-    def whitelist_resolved
-      rslv = resolver
+    private def whitelist_resolved
+
+      # initialize resolver when called for the first time
+      parserResolver = getResolver
       output( 1, "Resolving symbols - start" )
       entrypoints = getEntryPoints + getSetupPossibilities + getModelInvariants + getSetupAssumes
       @logger.debug("#{__method__}: entrypoints=#{entrypoints}")
-      ret =  rslv.resolveModules( entrypoints  ) do |type,arr|
+      ret =  parserResolver.resolveModules( entrypoints  ) do |type,arr|
+
+        # output summary 
+        
         case type
         when "unresolved"
           # defult to output unresolved - if some unresolved symbols
@@ -353,20 +183,20 @@ module Sbuilder
       return ret
     end
     
-
-    # Return whitelisted template names.
+    # Cache + return template names for resolved whitelisted modules,
+    # and for modules listed in separate file.
     #
     #
     # @return [Array] of whitelistes template names
     
-    def whitelist
+    private def whitelist
       return @whitelist if @whitelist      
       @whitelist = whitelist_file + whitelist_resolved
       @logger.info( "#{__method__}, whitelist=#{@whitelist}" )
       @whitelist
     end
 
-    private
+    # @!endgroup        
 
 
   end