tla-sbuilder 0.1.0

data/lib/sbuilder/factory.rb

@@ -0,0 +1,234 @@
+
+module Sbuilder
+  
+  # signleton class
+  class Factory
+
+    @@singleton=nil                   # initiallly no factory object
+    attr_reader :options              # remembers options
+
+    attr_reader :paramSetLoaders      # hash[Name->Class:ParamSetLoader]
+    attr_reader :mapperRules          # hash[Name->Class:ResolverRule]
+    attr_reader :mapperLoaders        # hash[Name->Class:ResolverLoader]    
+    attr_reader :parameters           # hash[Name->Class:Parameter]     
+    attr_reader :paramSets            # hash[Name->Class:ParameterSet]
+    attr_reader :domains              # hash[Name->Class:Domain]    
+    attr_reader :extension_loaders    # hash[Name->Class:ExtensionLoader]
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "Factory"        # progname for logger
+    include Sbuilder::Utils::MyLogger # mix logger
+
+   
+
+    # ------------------------------------------------------------------
+    # constructore
+
+    def initialize( options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized options=#{options}" )
+      @options = options
+      initializeFactories
+    end
+
+    def initializeFactories
+      @extension_loaders={
+        Sbuilder::Constants::EXTENSION_LOADER_YAML => ExtensionLoader,
+      }
+      @parameters={
+        Sbuilder::Constants::PARAMETER => Parameter_Dom,
+        Sbuilder::Constants::PARAMETER_REF => Parameter_Ref,
+      }
+      @paramSets = {
+        Sbuilder::Constants::SWAGGER => ParamSet_If,
+        Sbuilder::Constants::SWAGGER_DEFINITION => ParamSetDef,
+        Sbuilder::Constants::PARAM_SET_STEPS => ParamSetStep,
+      }
+      
+      @paramSetLoaders = {
+        Sbuilder::Constants::SWAGGER => ParamSetLoaderSwagger
+      }
+      @mapperLoaders = {
+        Sbuilder::Constants::MAPPER_YAML => ResolverLoader_YAML
+      }
+      @mapperRules = {
+        Sbuilder::Constants::MAPPER_RULE_MATCH => ResolverRuleMatch,
+        Sbuilder::Constants::MAPPER_RULE_REF => ResolverRuleRef,
+      }
+
+      @domains = {
+        Sbuilder::Constants::TYPE_DOMAIN => Domain,
+        Sbuilder::Constants::TYPE_VALUE_DOMAIN => DomainValue ,
+        Sbuilder::Constants::TYPE_CARDINALITY_DOMAIN => DomainCardinality ,               
+      }
+      
+    end
+    
+    # ------------------------------------------------------------------
+    # singleton 
+    class << self
+
+      def getFactory( options={} )
+        return @@singleton unless @@singleton.nil?
+        @@singleton = new( options )
+      end
+
+      private :new
+      
+    end # class methods
+
+    # ------------------------------------------------------------------
+    # loaders
+    
+
+    # return object to load mappers
+    def getResolverLoader(  type )
+      if mapperLoaders[type].nil? then
+        msg = <<-EOS
+        Unknown mapper type #{type}
+
+        Valid types: #{mapperLoaders.keys}
+        EOS
+        
+        @logger.error( "#{__method__} #{msg}" )
+        raise NameError.new( msg  )
+      end
+          
+      return mapperLoaders[type].new( Factory.getFactory(options), options )      
+    end
+
+
+    # return object to load parameter sets
+    def getParamSetLoader( type )
+      if paramSetLoaders[type].nil? then
+        msg = <<-EOS
+        Unknown parameter type #{type}"
+
+        Validate types #{paramSetLoaders.keys}
+        EOS
+        
+        @logger.error( "#{__method__} #{msg}" )
+        raise NameError.new( msg  ) 
+      end
+      return paramSetLoaders[type].new( Factory.getFactory(options), options )
+    end
+    
+    # ------------------------------------------------------------------
+    # template reader
+
+    # Create file reader for template generator if
+    # options[:filter_src]-> return TemplateContextReader else
+    # return TemplateReader 
+    # 
+    # @return [TemplateReader|TemplateContextReader] implementing
+    # 'get_template' -method for template generator.
+    def getTemplateReader( controller )
+      if options[:filter_src]
+        Sbuilder::TemplateContextReader.new( controller, @options )
+      else
+        Sbuilder::TemplateReader.new( controller, @options )
+      end
+      # return @template_reader if @template_reader
+      # @template_reader = Sbuilder::TemplateReader.new( @options )
+      # @template_reader
+    end
+
+    # ------------------------------------------------------------------
+    # generate
+    #
+    # @return [Template] mustache template generator
+    def getTemplate( reader )
+      Template.new( reader, @options )
+      # return @template if @template
+      # @template = Template.new( getTemplateReader, @options )
+      # @template
+    end
+    
+    # ------------------------------------------------------------------
+    # model
+    def createModel
+      Sbuilder::Model.new( self, options )
+    end
+    
+    # ------------------------------------------------------------------
+    # domainLoader
+    
+    def getExtensionLoader( type )
+      if extension_loaders[type].nil? then
+        
+        msg = <<-EOS
+        Unknown extension loader type #{type}"
+
+        Valid extension loader types #{extension_loaders.keys}
+        EOS
+        @logger.error( "#{__method__} #{msg}" )
+        raise NameError.new( msg  )
+      end
+      extension_loaders[type].new( options )
+      # Sbuilder::ExtensionLoader.new( options )
+    end
+
+    # ------------------------------------------------------------------
+    # mapper
+
+    # create new Resolver object
+    def createResolver( type )
+      return Resolver.new( options )
+    end
+
+    # create new ResolverRule object
+    def createResolverRule( type )
+      if mapperRules[type].nil? then
+        msg = "Unknown mapper rule type #{type}"
+        @logger.error( "#{__method__} #{msg}" )        
+        raise NameError.new( msg  )
+      end
+
+      return mapperRules[type].new( options )
+    end
+
+    # ------------------------------------------------------------------
+    # domain
+
+    def createDomain( type = Sbuilder::Constants::TYPE_DOMAIN )
+      if domains[type].nil? then
+        msg = <<-EOS
+        Unknown domain type #{type}"
+
+        Validate types #{domains.keys}
+        EOS
+        
+        @logger.error( "#{__method__} #{msg}" )
+        raise NameError.new( msg  ) 
+      end
+
+      return domains[type].new( options )      
+    end
+
+    # ------------------------------------------------------------------
+    # param sets
+
+    # create new Resolver object
+    def createParamSet( type )
+      if paramSets[type].nil? then
+        msg = "Unknown parameter type #{type}"
+        @logger.error( "#{__method__} #{msg}" )        
+        raise NameError.new( msg  )
+      end
+      return paramSets[type].new( options )
+    end
+
+    def createParameter( type )
+      if parameters[type].nil? then
+        msg = "Unknown parameter type #{type}"
+        @logger.error( "#{__method__} #{msg}" )        
+        raise NameError.new( msg  )
+      end
+      parameters[type].new( options )
+    end
+    
+
+  end # class Factory
+
+end # module

data/lib/sbuilder/model.rb

@@ -0,0 +1,356 @@
+module Sbuilder
+
+  class Model
+
+    attr_reader   :domains                    # hash name => Domain
+    attr_reader   :factory                    # to create domain
+    attr_reader   :interfaceExtensions        # hash : { paramSet.getId -> { matcher -> ..., implementation -> .. } } 
+    attr_reader   :interfaces                 # hash of interfaffces { paramSet.get -> paramSet }
+    attr_reader   :definitions                # hash : { paramSet.getId -> paramSet } of swagger definitions
+    attr_reader   :steps                      # array of paramSetSteps
+    attr_reader   :possibility                # [String] of setup possibility - may be nil
+    attr_reader   :possibilities              # [String:Array] possibilities in setup
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "Model"                        # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    @@validInterfaceExtensionProperties  = ["matcher", "implementation"]
+
+    # ------------------------------------------------------------------
+    # constructore
+    
+    def initialize( factory, options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      @factory = factory
+
+      # model content
+      # @paramSets = []                       
+      @domains = {}
+      # create a hash capable for topological sorting
+      @definitions = Sbuilder::ParamSets.create( self )
+      @interfaces = {}
+      @steps = []
+      @possibility = nil
+      @possibilities = []
+      
+      @interfaceExtensions = {}
+      
+
+    end
+
+    # ------------------------------------------------------------------
+    # possibility stuff
+    
+    def setPossibility( possi )
+      @possibility = possi
+    end
+    
+    def setPossibilities( possis )
+      @possibilities = possis || []
+      @logger.info( "#{__method__} @possibilities=#{@possibilities}" )
+    end
+
+    # ------------------------------------------------------------------
+    # domain stuff
+    
+    def getDomain( domainName )
+      ret = domains[domainName]
+      raise ModelException.new  "Could not locate domain set #{domainName}" unless ret
+      return ret
+    end
+
+    # called when loading mappers for each domain encountered, return domain
+    def domainEncountered( domainName )
+      @logger.info( "#{__method__} domainName #{domainName}" )
+      return createOrUpdateDomain( domainName, nil )
+    end
+
+
+    # called from a separte plase
+    def extendDomain( domain )
+      @logger.info( "#{__method__} domain=#{domain}" )
+      raise ModelException.new <<-EOS  unless domains[domain.name]
+      Unknown domain.name=#{domain.name}
+
+      Trying to extend domain '#{domain.name}', which not among resolved domains.
+
+      Known domain names are: #{domains.keys.join(', ' )}
+
+      EOS
+      domains[domain.name].setExtension( domain )
+      # return createOrUpdateDomain( domain.name, domain.cardinality  )      
+    end
+
+    # DRY method to create or update
+    private def createOrUpdateDomain( domainName, cardinality=1 )
+      @logger.info( "#{__method__} domainName #{domainName}, cardinality='#{cardinality}'" )
+      domain = domains[domainName]
+
+      # create if it does not exist
+      if domain.nil? then
+        domain = factory.createDomain
+        domain.setName( domainName )
+      end
+
+      # option to set cardinality
+      domain.setCardinality( cardinality ) if cardinality
+
+      # update model state
+      domains[domainName] = domain
+
+      return domain
+    end
+
+    # ------------------------------------------------------------------
+    # collection of  all param sets: intefaces + definitions
+    def paramSets
+      interfaces.values + definitions.values
+    end
+
+    # resolve 'paramSetName' 
+    def getParamset( paramSetName )
+      ret = paramSets.select { |p| p.getId == paramSetName }.first
+      raise ModelException.new  "Could not locate param set #{paramSetName}" unless ret
+      ret
+    end
+
+    # ------------------------------------------------------------------
+    # step stuff
+    def extendStep( stepExtension )
+      @steps << stepExtension
+    end
+
+    
+    # ------------------------------------------------------------------
+    # interface stuff
+
+    # accept parameters set to model
+    def interfaceEncountered( paramSet )
+      @interfaces[paramSet.getId] = paramSet
+      
+      # # collect all paramsets
+      # addParamSet( paramSet )
+    end
+
+
+    # extend
+    def extendInterface( interfaceExtensionDef )
+
+      # validate properties 'interfaceExtensionDef'
+      begin
+        validateProperties( interfaceExtensionDef, @@validInterfaceExtensionProperties )
+      rescue ModelException => me
+        @logger.info( "#{__method__} model exception #{me}" )
+        raise ExtensionException.new( me )
+      end
+
+      # locate interface being extended
+      interfaceParamSet = getInterface( interfaceExtensionDef['matcher'] )
+
+      # record extension in '@interfaceExtensions'
+      putImplementationExtension( interfaceParamSet, interfaceExtensionDef )
+
+      # return the extended interface
+      interfaceParamSet
+
+    end
+
+    # locate 'interface' using 'matcher' (string or regexp),raise exception if not found
+    def getInterface( matcher )
+      
+      @logger.debug( "#{__method__} matcher=#{matcher}" )
+      
+      interfaces.values.each do |interfaceParamSet|
+        if interfaceParamSet.matchesWithParamSet(  matcher ) then
+          return interfaceParamSet
+        end
+      end
+
+      # error w. instructios of valid intefaces - should not reach this point
+      raise ExtensionException.new <<-EOS
+
+        Could not find interface matching '#{matcher}'
+      
+        Known interfaces: #{interfaceIds.join(',')}
+
+      EOS
+      
+    end
+
+    # record extension in '@interfaceExtensions'
+    def putImplementationExtension( interfaceParamSet, interfaceExtensionDef )
+      @interfaceExtensions[interfaceParamSet.getId] = interfaceExtensionDef
+    end
+
+    # provide information on extension implementation during generation phase
+    def getImplementationExtension( interfaceParamSet )
+       interfaceExtensions[interfaceParamSet.getId] ? interfaceExtensions[interfaceParamSet.getId]['implementation'] : nil
+    end
+
+    # array of known interface ids
+    def interfaceIds
+      interfaces.values.map { |interface| interface.getId }
+    end
+
+    # ------------------------------------------------------------------
+    # definition stuff
+            
+    def definitionEncountered( paramSet )
+      @logger.info( "#{__method__} paramSet=#{paramSet}, paramSet.class=#{paramSet.class}" )
+
+      # collect definitions
+      @definitions[paramSet.getId] = paramSet
+
+      # # collect all paramsets
+      # addParamSet( paramSet )
+      
+    end
+
+    
+    # ------------------------------------------------------------------
+    # generate phase
+
+    # none: nil
+    # domains:
+    #     - name:
+    #       domain_name:
+    #       cardinality
+    #       domain_values:
+    #           - value:
+    #             index:
+    #             _comma:
+    # variables:
+    #     - array
+    # interfaces:
+    #     - getName:
+    #       parameter_defintions:
+    #            - name:
+    #              parameter_name:
+    #              domain:
+    #
+    # 
+
+    # return hash for mustache for 'templateName' in 'interfaces', 'domains', 'variables'
+    def templateData( domainName )
+
+      case domainName
+      when 'interfaces'
+        templateDataInterfaces( domainName, false )
+      when 'infrastructureServices'
+        templateDataInterfaces( domainName, true )
+      when 'possibility'        
+        hash = {
+          "possibility"    => lambda { hash['possibility'].to_yaml },                    
+          "possibility"    => possibility, # possibility defined in setup, currently being generated
+        }
+      when 'possibilities'        
+        hash = {
+          "possibilities"  => lambda { hash['possibilities'].to_yaml },                    
+          "possibilities"  => possibilities,      # possibilities in setup, all in current setup
+        }
+      when 'variables'        
+        hash = {
+          "dump"           => lambda { hash['variables'].to_yaml },                    
+          "variables"      => [], # paramSets,                                       # => TLA state variable
+        }
+      when 'steps'        
+        hash = {
+          "dump"        => lambda { hash['steps'].to_yaml },                    
+          "steps"       => steps.map.with_index { |step,i|
+            {
+              :process => step.getName,
+              :interface_name => step.interfaceReference.getName,
+              :interface_operation => step.interfaceReference.getId,
+              :interface_path => step.interfaceReference.path,
+              # :interface_id => step.interfaceReference.getId,              
+              :_comma => (i< steps.length-1 ? "," : ""),                                         
+              :bindRule => step.bindExact == false ? step.inputs : false,
+              :bindSets  => step.bindExact ?  step.inputs.map.with_index { |input,i| input[:_comma] = i<step.inputs.length-1 ? ',' : ''; input }  : false, 
+            }
+          },
+        }
+      when 'none'
+        {
+        }
+      when 'definitions'
+        hash = {
+          "dump"        => lambda { hash['definitions'].to_yaml },          
+          "definitions" => definitions.tsort.map.with_index { |parameterName,i|
+            # tsort returns array of names, resolve paramSet
+            p = getParamset( parameterName )
+            {  :definition_name => p.getName,
+               :isArray => p.isArray,
+               :_comma => (i< definitions.values.length-1 ? "," : ""),
+               :parameter_definitions => p.parameter_definitions( self )
+            }
+          }
+        }                                                                       # => TLA definitions
+      when 'domains'
+        hash = {
+          "dump"        => lambda { hash['domains'].to_yaml },          
+          "domains"     => domains.values.map do |domain|
+            {
+              :domain_name => domain.domain_name,
+              :domain_values => domain.domain_values,
+            }
+          end,                                      # => TLA domain
+        }
+      else
+        raise "Unknown template '#{domainName}'"
+      end # case
+      
+    end # getTemplateData
+    
+
+    # Extract data model for interfaces 
+    #
+    # @param infrastructureServices [Boolean] choose  'interfaces' or 'infrastructureServices'
+    # @return [Hash] for template rendering composed of interfaces, false if configs
+    #
+    private def templateDataInterfaces( domainName, infrastructureServices )
+      hash = {
+          "dump" => lambda { hash[domainName].to_yaml },
+          domainName => interfaces.values.select { |iface|
+            
+            iface.infrastructureService == infrastructureServices
+            
+          }.map { |iface |
+            {
+              :interface_name => iface.getName,          # e.g._pet_post_
+              :interface_operation => iface.getId,       # e.g /pet(post)
+              :implementation => getImplementationExtension( iface ),
+              :_comma => ',',
+              :parameter_definitions => iface.parameter_definitions( self ),
+              :response_definitions => iface.response && iface.response.parameters.any? ? iface.response.parameter_definitions( self ) : false,
+            }
+          }       # => TLA process & stubs
+      }
+
+      # return 'false' instead of an array if empty
+      hash[domainName] = false unless hash[domainName].any?
+      # fix _comma for the last entry in array
+      fixLastComma( hash[domainName] )
+      return hash
+    end
+
+    private def fixLastComma( arrOfHashes )
+      arrOfHashes.last[:_comma] = "" if arrOfHashes && arrOfHashes.any?
+    end
+      
+
+    private def validateProperties( defintionHash, required, allowed=nil )
+      allowed = required unless allowed
+      missingProps = required - defintionHash.keys
+      raise ModelException.new "Missing properties #{missingProps} in #{defintionHash} - required #{required}" if missingProps.any?
+
+      invalidProps = defintionHash.keys - allowed
+      raise ModelException.new "Unknown properties #{invalidProps} in #{defintionHash}- allowed #{allowed}" if invalidProps.any?
+
+    end
+    
+  end # class
+
+end