tla-sbuilder 0.1.0 → 0.2.1

data/lib/sbuilder/default-sbuilder.yaml

@@ -57,7 +57,7 @@ generate:
 
              - desc: Interface types 
                template: interface_types.mustache
-               modelData: interfaces
+               modelData: interface_types  # = interfaces (not filtered)
 
              - desc: Start of plc block
                template: tla/plc_header.mustache
@@ -240,10 +240,15 @@ generate:
                # --------------------
                # extension point: extend_invariant.cfg
                
-             - desc: Extension pointo to activate specification invariants
+             - desc: Extension point to activate specification invariants - DEPRECATED
                template: extend/extend_invariant_cfg.mustache
                modelData: none
 
+             - desc: Activate invariants defined in sbuilder.yaml
+               template: invariant_activate.mustache
+               modelData: invariants
+               
+
              - desc: End of module
                template: cfg/module_footer.mustache
                modelData: none
@@ -271,9 +276,14 @@ generate:
                modelData: none
 
              - desc: Setup domain values
-               template: domains_run.mustache
+               template: setup/domains_run.mustache
                modelData: domains
 
+             - desc: Activate assumptions on setup
+               template: setup/assumptions_activate.mustache
+               modelData: assumptions
+               
+
              # - desc: interface calls in setup
              #   template: interface_steps.mustache
              #   modelData: interfaces
@@ -301,6 +311,10 @@ generate:
              template: data-model-dump.mustache
              modelData: interfaces
 
+           - desc: Model interface_types (=request/reponse for all interfaces)
+             template: data-model-dump.mustache
+             modelData: interface_types
+
            - desc: Model infrastructureServices
              template: data-model-dump.mustache
              modelData: infrastructureServices
@@ -321,6 +335,14 @@ generate:
              template: data-model-dump.mustache
              modelData: steps
 
+           - desc: Active invariants
+             template: data-model-dump.mustache
+             modelData: invariants
+             
+           - desc: Active assumptions
+             template: data-model-dump.mustache
+             modelData: assumptions
+             
            - desc: Model footer 
              template: data-model-footer.mustache
              modelData: none

data/lib/sbuilder/domain.rb

@@ -15,7 +15,7 @@ module Sbuilder
 
     def initialize( options = {} )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
     end
 
     def to_s

data/lib/sbuilder/domain_cardinality.rb

@@ -14,7 +14,7 @@ module Sbuilder
     def initialize( options = {} )
       super( options )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
       
       # default values one
       @cardinality = 1

data/lib/sbuilder/domain_value.rb

@@ -14,7 +14,7 @@ module Sbuilder
     def initialize( options = {} )
       super( options )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
       
       # default values one
       @values = []

data/lib/sbuilder/exception.rb

@@ -1,26 +1,32 @@
 module Sbuilder
 
-  class TemplateReaderException < Exception
+  class SbuilderException < Exception
+  end
+
+  class TemplateReaderException < SbuilderException
   end
 
   
-  class ResolverException < Exception
+  class ResolverException < SbuilderException
   end
 
-  class ExtensionException < Exception
+  class ExtensionException < SbuilderException
   end
   
   
-  class DomainException < Exception
+  class DomainException < SbuilderException
   end
   
-  class ControllerException < Exception
+  class ControllerException < SbuilderException
   end
 
-  class ModelException < Exception
+  class ModelException < SbuilderException
+  end
+  
+  class LoaderException < SbuilderException
   end
   
-  class LoaderException < Exception
+  class FactoryException < SbuilderException
   end
   
 

data/lib/sbuilder/extension_loader.rb

@@ -26,7 +26,7 @@ module Sbuilder
     
     def initialize( options = {} )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
       self
     end
 
@@ -229,6 +229,9 @@ module Sbuilder
         # NB: expandedStepExtensionDef = stepExtensionDef['input']
         mustacheTemplateData = extendStepDefaults( interface, expandedStepExtensionDef, mustacheTemplateData )
 
+        # assign unique number to hash element in 'mustacheTemplateData'
+        mustacheTemplateData = extendNumbering( mustacheTemplateData )        
+
         # added to stepParameterSet
         return mustacheTemplateData
       
@@ -467,6 +470,41 @@ module Sbuilder
 
     end
 
+    # ------------------------------------------------------------------
+    # number elements
+
+    # assign '_first' element for hash within 'mustacheTemplateData'
+    #
+    # @param mustacheTemplateData [Hash]
+    # @return [Hash] 'mustacheTemplateData' with record elements numbered
+    def extendNumbering( mustacheTemplateData )
+
+      recurseHash( mustacheTemplateData ) do |h,k,v,i|
+        v["_index"] = i
+      end
+      return mustacheTemplateData
+    end
+
+    # recurse hash, and yield 'hash', 'key', 'value', 'index' for each
+    # entry within the hash structure, which is_a?(Hash).
+    
+    def recurseHash( hash, &block )
+
+      hash && hash.each_with_index do |(k,v),index|
+        if  v.is_a?( Hash )  then
+          yield  hash, k, v, index
+          recurseHash( v, &block)
+        elsif v.is_a?( Array )  then
+          v.each_with_index do |array_element,i|
+            if array_element.is_a?(Hash)
+              yield  hash, k, array_element, i 
+              recurseHash( array_element, &block)
+            end
+          end
+        end
+      end
+    end
+
     # ------------------------------------------------------------------
     # recurse 'stepExtensionInputs' configuration and create a hash
     # structure, which can be passed to mustache template
@@ -589,22 +627,38 @@ module Sbuilder
     # >>  : end array
     def recurseStepInputs( stepExtensionInputs, keys=[], row=0, &block )
       stepExtensionInputs.each do |parameterName, parameterDef|
-        if parameterDef.is_a?( Array ) then
-          yield "<<", keys + [parameterName], nil, 0
-          parameterDef.each.with_index do |parameterDefRow,index|
-            yield "<<", keys + [parameterName], nil, index+1
-            recurseStepInputs( parameterDefRow, keys + [parameterName], index+1, &block )
-            yield ">>", keys + [parameterName], nil, index+1
+        begin 
+          if parameterDef.is_a?( Array ) then
+            yield "<<", keys + [parameterName], nil, 0
+            parameterDef.each.with_index do |parameterDefRow,index|
+              yield "<<", keys + [parameterName], nil, index+1
+              recurseStepInputs( parameterDefRow, keys + [parameterName], index+1, &block )
+              yield ">>", keys + [parameterName], nil, index+1
+            end
+            yield ">>", keys + [parameterName], nil, 0
+            
+          elsif parameterDef.is_a?( Hash ) then
+            yield "[", keys + [parameterName], nil, row          
+            recurseStepInputs( parameterDef, keys + [parameterName], row, &block  )
+            yield "]", keys + [parameterName], nil, row          
+          else
+            # do not process "meta fields" e.g '_default'
+            yield "=", keys + [parameterName], parameterDef, row
           end
-          yield ">>", keys + [parameterName], nil, 0
-          
-        elsif parameterDef.is_a?( Hash ) then
-          yield "[", keys + [parameterName], nil, row          
-          recurseStepInputs( parameterDef, keys + [parameterName], row, &block  )
-          yield "]", keys + [parameterName], nil, row          
-        else
-          # do not process "meta fields" e.g '_default'
-          yield "=", keys + [parameterName], parameterDef, row
+        rescue SbuilderException => e
+          msg = <<-EOS.gsub( /^\s*/, '' )
+          Error:
+
+          #{e.message}  
+
+
+          when processing parameter #{parameterName} with definition:
+
+          #{parameterDef.to_yaml}
+
+          EOS
+          @logger.error( "#{__method__} #{msg}" )
+          raise Sbuilder::LoaderException.new, msg, e.backtrace
         end
       end
     end # recurseStepInputs
@@ -695,7 +749,7 @@ module Sbuilder
             :parameter_name => parameterName,
             "rows" => false,
             "columns" => false,
-            "_comma" => "",
+            "_comma" => ",",     # assume that comma get removed if -needed
       }
     end
 
@@ -707,7 +761,10 @@ module Sbuilder
       
       # la
       columns['columns'].last["_comma"] = ',' if columns['columns'].length > 0
-      
+
+      # no comma here
+      column["_comma"] = ''
+
       columns['columns'] << column
       return column
     end

data/lib/sbuilder/facade/api_loader.rb

@@ -0,0 +1,293 @@
+module Sbuilder
+
+  # Facade to Sbuilder for api loaders.
+  #
+  # Class implements following service groups
+  #
+  # - for controller to configure the facade (this part is not visible for api)
+  #
+  # - for api loader to read/cache api configuration, to create
+  #   model objects, and build sbuilder model
+  #
+  
+  class ApiLoader
+
+    extend Forwardable                        # for easy delegation
+
+    # facade configuration
+
+    attr_reader :infrastructureServices       # default 'false'
+
+    # string to prefix to all definitions (default 'nil' ie. no
+    # prefix). Allow homonymous API definition names ie. same
+    # name in separata definitions.
+    attr_reader :namespace                 
+    
+    attr_reader :cacheFile                    # controller sets before
+                                              # loader called
+
+    # facade collaborators
+    
+    attr_reader :factory                      # to create stuff
+    attr_accessor :controller                 # get sets when load starts
+
+    def_delegators :controller,
+                   :modelDefinition,          # 
+                   :modelInterface
+    
+
+    def_delegators :factory,
+                   :createParamSet,           # @return[Sbuilder::ParamSet]
+                   :createParameter           # @return[Sbuilder::Parameter]    
+
+    # ------------------------------------------------------------------
+    
+    
+    # progname for logger
+    PROGNAME = "ApiLoader"
+    
+    include Sbuilder::Utils::MyLogger    # mix logger
+
+
+    # ------------------------------------------------------------------
+    # @!group Constructore
+    
+    def initialize( factory, options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+
+      # collaborators init
+      setFactory( factory )
+      @controller = nil
+      
+      # configuration init
+      @infrastructureServices = false
+      @namespace = nil
+      
+      @cacheFile = nil
+      @options = options
+      
+    end
+
+    # @!endgroup
+    
+    # ------------------------------------------------------------------
+    # @!group Interface used by controller to configure the facade
+
+    # Allow facade to access controller services
+    # @param controller [Sbuilder::Controller] controller sets self
+    def setController( controller )
+      @controller = controller
+    end
+
+    # Facade delagates the task to create new objects to `factory
+    # @param factory [Sbuilder::Factory] to create new obejcts
+    def setFactory( factory )
+      @factory = factory
+    end
+    
+    # Tag all interfaces created using this facadate with property 'infrastructureServices'
+    #
+    # @param infrastructureServices [Boolean] true/false set on all interfaces
+    #
+    def configureInfrastructureService( infrastructureServices )
+      @infrastructureServices = infrastructureServices
+    end
+
+    # Prefix all definititions with "#{namespace}." string
+    #
+    # @param namespace [String] string to prefix to all definitions
+    #
+    def configureNamespace( namespace )
+      @namespace = namespace
+    end
+
+    # Cache string read into 'cacheFile'
+    #
+    # @param cacheFile [String] name of file to cache content in this facade
+    #
+    def setInterfaceCacheFilePath( cacheFile )
+      @cacheFile = cacheFile
+    end
+
+    # @!endgroup    
+
+    # ------------------------------------------------------------------
+    # @!group Read and cache api content
+    
+    # Reader service: read String of interface definitions from
+    # 'location'. The string is cached in '@cacheFile', which
+    # controller has configured.
+    #
+    # @param location [String] uri/file/block parameter from which to
+    # read the string
+    #
+    # @param blk [yield] yield block to read if no block given use
+    # 'Sbuilder::Utils::NetIo.read_lines'. Block should return a
+    # string.
+    #
+    # @return [String] read from 'location' (or from @cacheFile)
+    def read_cached( location, &blk )
+      # return cached
+      line = get_cached 
+      return line if line
+      if block_given?
+        line = yield( location )
+      else
+        line = Sbuilder::Utils::NetIo.read_lines( location )
+      end
+      cache_line( line )
+      return line
+    end
+
+    # Read previously cached content (@see cache_line)
+    # @param what [String] sub-content in cache
+    # @return [String] cached content (nil if no cached content
+    def get_cached( what=nil )
+      Sbuilder::Utils::CacheLines.cache_read( get_cachefile(what)  ) if doCache?
+    end
+
+    # Service for loader to save 'line' into cache
+    # @param line [String] content to store
+    # @param what [String] sub-content in cache
+    def cache_line( line, what=nil )
+      Sbuilder::Utils::CacheLines.cache_write( get_cachefile(what), line ) if doCache? && line
+    end
+
+    # @return [Boolean] true if cache i.e. when cacheFile defined
+    def doCache?
+      !cacheFile.nil?
+    end
+
+    # @!endgroup
+    # ------------------------------------------------------------------
+
+    # ------------------------------------------------------------------
+    # @!group Build model
+
+    # Add 'newDefinition' to model
+    # @param newDefinition [Sbuilder::ParamSetDef] definition to add
+    def modelDefinition( newDefinition )
+      controller.modelDefinition( newDefinition ) 
+    end
+
+    # Add 'newInterface' to model
+    # @param newInterface [Sbuilder::ParamSet_If] interface to add
+    def modelInterface( newInterface )
+      controller.modelInterface( newInterface ) 
+    end
+
+    # @!endgroup    
+
+    # ------------------------------------------------------------------
+    # @!group Construct model objects
+    
+    # 
+    # @param definitionName [String] name of defintition to create
+    # @param isArray [Boolean] if array defined
+    #
+    # @return [Sbuilder::ParamSetDef] New definition object created
+    def newDefinition( definitionName, isArray=false )
+      paramSet =  createParamSet( Sbuilder::Constants::SWAGGER_DEFINITION )
+      # optionally prefix within namespace
+      definitionName = namespacedReferenceName( definitionName )
+      paramSet.setDefinition( definitionName )
+      paramSet.setIsArray(  isArray )
+      return paramSet
+    end
+
+    # Create new interface paramtereter sert (and response parameter set)
+    #
+    # @param path [String] path of restfull interface operation
+    #
+    # @param op [String] rest operation (get, put, post,...), defaults
+    # to 'response' (ie. definiting return from a operation)
+    #
+    # @return [Sbuilder::ParamSet_If] New interface param set createds
+    # for request. Use #response to access response object.
+    def newInterface( path, op  )
+      interfaceParamSet = newParamset( path, op )
+      paramSetResponse = newParamset( path )
+      interfaceParamSet.setResponse( paramSetResponse )
+      return interfaceParamSet
+    end
+
+    # Cretate new pojo for a simple paramter
+    # @param name [String] name of the simple paramter to create
+    # @param isArray [Boolean] true if array
+    # @return [Sbuilder::Parameter_Dom] new parmater created
+    def newParameter( name, isArray=false )
+      swagger_parameter = createParameter( Sbuilder::Constants::PARAMETER  )
+      swagger_parameter.setName( name )
+      # default for parameter 'not array' - set exlicitely array
+      swagger_parameter.setIsArray( isArray )
+      return swagger_parameter
+    end
+
+    # Create new pojo for a reference to a definition
+    #
+    # @param name [String] name of the simple paramter to create
+    # @param referenceName [String] definition name referenced
+    # @param isArray [Boolean] true if array
+    # @return [Sbuilder::Parameter_Ref] new parmater created
+    
+    def newParameterReference( name, referenceName, isArray )
+      swagger_parameter = createParameter( Sbuilder::Constants::PARAMETER_REF  )
+      swagger_parameter.setName( name )
+      # namespace.name
+      referenceName = namespacedReferenceName( referenceName )      
+      swagger_parameter.setReference( referenceName )
+      swagger_parameter.setIsArray( isArray )
+      return swagger_parameter
+    end
+
+    # @!endgroup
+    # ------------------------------------------------------------------
+
+    # ------------------------------------------------------------------
+    # @!group misc
+
+    # @return [String] semver number
+    def version
+      "1.0.2"
+    end
+
+    # @param logname [String] progname to set on logger
+    # @return [Logger] new logger object
+    def createLogger( logname )
+      getLogger( logname, @options )
+    end
+    
+    # @!endgroup    
+
+    # ------------------------------------------------------------------
+    # Private
+
+    private
+
+    # @return [Sbuilder::ParamSet_If] New interface param set created    
+    def newParamset( path, op ='response' )
+      interfaceParamSet =  createParamSet( Sbuilder::Constants::INTERFACE_OPERATION )
+      interfaceParamSet.setIdentity( path, op )
+      interfaceParamSet.setInfrastructureService( infrastructureServices )
+      return interfaceParamSet
+    end
+
+    # @return [String] path to cachefile
+    def  get_cachefile( what )
+      "#{cacheFile}#{ what ? '.' + what : '' }"
+    end
+
+    # @return [String] 'definitionName' optionallayy prefixed with namespace
+    def namespacedReferenceName( definitionName )
+      if namespace 
+        definitionName = "#{namespace}.#{definitionName}"
+      end
+      return definitionName
+    end
+    
+
+  end # class ApiLoader
+
+
+end # module