tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/setup_loader_pref.rb

@@ -0,0 +1,56 @@
+module Sbuilder
+
+
+  # Abstaract base class
+  class SetupLoaderPref < SetupLoader
+
+    # ------------------------------------------------------------------
+    # Validation
+
+
+    # ------------------------------------------------------------------
+    # mix logger
+    
+    PROGNAME = nil                    # progname for logger default class name
+    include Sbuilder::Utils::MyLogger # mix logger
+
+
+    # ------------------------------------------------------------------
+    # @!group Construct & configure
+
+
+    def initialize( options = {} )
+      @logger = getLogger( nil, options )
+      @logger.info( "#{__method__} initialized options=#{options}" )
+
+      super( options )
+    end
+
+
+    # @!endgroup        
+
+    # ------------------------------------------------------------------
+    # @!group Abstract methods from parent class
+
+    ##
+    # Pass 'extensionDef' for 'controller' use to #updatetSetup of
+    # setup 'setupName'
+    #
+    # @param [Hash:Array] extensionDef configuration defining loading
+    def doLoad( extensionDefs )
+      Utils::Validate.validateProperties( extensionDefs, Constants::VALIDATION[:SetupLoaderPref][:required], Constants::VALIDATION[:SetupLoaderPref][:allowed] )
+      controller.updateSetup(  setupName, extensionDefs )
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement load
+
+
+    # @!endgroup
+
+
+  end # class
+  
+end # module

data/lib/sbuilder/snippet_loader_simple.rb

@@ -0,0 +1,125 @@
+module Sbuilder
+
+  class SnippetLoaderSimple < Sbuilder::SnippetLoaderPlugin
+
+    # PROPS_REQUIRED = %w( metatype appName   )
+    # PROPS_ALLOWED = %w( name file  )
+
+    # REQUIRED_CONFIG_PROPS = %w( src_dir )
+    # ALLOWED_CONFIG_PROPS =  %w()             # = required
+
+    extend Forwardable                       # for easy delegation
+
+    extend SingleForwardable                 # for of class methods
+    
+    def_delegator Sbuilder::SnippetLoaderPlugin, :validateProperties
+
+    @@src_dir = "./src"                      # default directory where files are read
+
+    # ------------------------------------------------------------------
+    # @!group Constructor and configuration
+
+    def initialize( options = {} )
+      super( options )
+    end
+    
+    # Class method to configure class 'SnippetLoaderPlugin'
+    #
+    # @param configuration [Hash] properties to configure
+    #
+    def self.configure( configuration )
+      return if configuration.nil?
+      Sbuilder::Utils::Validate.validateProperties(
+        configuration,
+        Constants::VALIDATION[:snippet_loader_plugin][:class_config_required],
+        Constants::VALIDATION[:snippet_loader_plugin][:class_config_allowed] )
+      @@src_dir = configuration['src_dir']
+    end
+
+
+    # base class should implement 'doConfigure'
+    def doConfigure( configuration )
+
+      if configuration.nil?
+        logger.warn "#{__method__}: no cofiguration for #{self.class}"
+        return
+      end
+      Sbuilder::Utils::Validate.validateProperties(
+        configuration,
+        Constants::VALIDATION[:snippet_loader_plugin][:object_config_required],
+        Constants::VALIDATION[:snippet_loader_plugin][:object_config_allowed] )
+
+      # hash with metatypes as keys
+      configuration['metatypes'] && configuration['metatypes'].each do |metatype,desc|
+        registerMetatype( metatype, desc )
+      end
+
+    end
+    
+
+    # @!endgroup
+    
+    # ------------------------------------------------------------------
+    # @!group Register snippets to sbuilder
+
+    # Override abstract method in parent class for the implementation.
+    #
+    # @param [Hash:Array] snippetDefitions given in sbuilder.yaml
+    # 
+    def doRegisterSnippets( snippetDefitions )
+      logger.info "#{__method__}, loading snippetDefitions=#{snippetDefitions}"
+      
+      snippetDefitions && snippetDefitions.each do  |snippetDefition|
+
+        # gets actually delegated
+        # Sbuilder::Utils::Validate.validateProperties( snippetDefition, PROPS_REQUIRED, PROPS_ALLOWED )
+        Utils::Validate.validateProperties( snippetDefition, Constants::VALIDATION[:snippet_loader_plugin][:required], Constants::VALIDATION[:snippet_loader_plugin][:allowed] )
+        # 0 allowed, max one allowed from url/file
+        Utils::Validate.oneOf( snippetDefition, Constants::VALIDATION[:snippet_loader_plugin][:one_of_file_or_url], 0, 1 )
+
+        # read content of snippetDefition['file'] into a [String}
+        snippetBody = readFile( src_path( snippetDefition ) ) if snippetDefition['file'] || snippetDefition['url']
+
+        # pass 'snippetBody' together with metatypes to facade
+        snippetFacade.handOver( snippetDefition['metatype'], snippetDefition['appName'], snippetBody, snippetDefition['name'], )
+        
+      end
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Simple plugin implementation
+
+    # Read file pointed by 'location'
+    #
+    # @param [String] location to read
+    # 
+    # @return [String] lines in file in 'location'
+    def readFile( location )
+      @logger.info "#{__method__}: location=#{location}"
+      line = Sbuilder::Utils::NetIo.read_lines( location )
+    end
+
+    # @param [Hash] snippetDefition configuration for location
+    # @option snippetDefition [String] url read from url (=e.g. path)
+    # @option snippetDefition [String] file read from file in src -repository
+    # 
+    # @return [String] path to file to read 'url' or +src_dir+ + +file+
+    def src_path( snippetDefition )
+      return snippetDefition['url'] if snippetDefition['url']
+      return File.join( src_dir, snippetDefition['file'])
+    end
+
+    # @return [String] path to directory, where src files are
+    def src_dir
+      @@src_dir || "."
+    end
+                  
+
+    # @!endgroup    
+    
+    
+  end
+  
+end

data/lib/sbuilder/spec/api_loader.rb

@@ -0,0 +1,34 @@
+require 'sbuilder'
+
+
+RSpec.shared_examples_for "api_loader_plugin: signature" do
+
+  describe "Interface of API Loader Plugin" do
+
+    it "#load" do
+      expect( loader ).to respond_to( :load )
+    end
+    
+    it "#load" do
+      expect( loader.class ).to respond_to( :configure )
+    end
+    
+
+    describe "parent class/mixer" do
+
+      it "#setFacade" do
+        expect( loader ).to respond_to( :setFacade )
+      end
+
+      it "#facade" do
+        expect( loader ).to respond_to( :facade )
+      end
+      
+    end
+
+    
+
+  end
+    
+
+end

data/lib/sbuilder/spec/api_loader_facade.rb

@@ -8,40 +8,176 @@ require 'sbuilder'
 # implements methods :load :setFacade
 #
 
-RSpec.shared_examples_for "api_loader_facade: signatures" do
+RSpec.shared_examples_for "api_loader_facade: signature" do
 
-  let( :factory ) { Sbuilder::Factory.getFactory }
-  let( :facade ) { Sbuilder::ApiLoader.new( factory ) }
+  describe "interface" do
 
-  before :each do
-    loader.setFacade( facade )
-  end
-  # ------------------------------------------------------------------
-  # Interfaces
+    describe "configure before use" do
+
+      it "#setController" do
+        expect( facade ).to respond_to( :setController )
+      end
+
+      it "#setFactory" do
+        expect( facade ).to respond_to( :setFactory )
+      end
+
+      it "#configureInfrastructureService" do
+        expect( facade ).to respond_to( :configureInfrastructureService )
+      end
+
+      it "#infrastructureServices" do
+        expect( facade ).to respond_to( :infrastructureServices )
+      end
+
+      it "#configureInterfaceService" do
+        expect( facade ).to respond_to( :configureInterfaceService )
+      end
+
+      it "#interfaceService" do
+        expect( facade ).to respond_to( :interfaceServices )
+      end
+      
+
+      it "#configureNamespace" do
+        expect( facade ).to respond_to( :configureNamespace )
+      end
 
-  describe "interfaces" do
+      it "#setInterfaceCacheFilePath" do
+        expect( facade ).to respond_to( :setInterfaceCacheFilePath )
+      end
+
+
+    end
+
+    describe "data read & cache" do
+
+      it "#read_cached" do
+        expect( facade ).to respond_to( :read_cached )
+      end
+
+      describe "cache" do
+
+        it "#getCacheDir" do
+          expect( facade ).to respond_to( :getCacheDir )
+        end
+        
+        it "#doCache?" do
+          expect( facade ).to respond_to( :doCache? )
+        end
+
+        it "#get_cached" do
+          expect( facade ).to respond_to( :get_cached )
+        end
+        it "#cache_line" do
+          expect( facade ).to respond_to( :cache_line )
+        end
+        
+      end
+      
+    end
 
-    describe "loader" do
+    describe "access framework context" do
 
-      it ".configure static method " do
-        expect( loader.class ).to respond_to( :configure )
+      it "#baseMetatypes" do
+        expect( facade ).to respond_to( :baseMetatypes )
       end
       
       
-      it "#load" do
-        expect( loader ).to respond_to( :load )
+    end
+
+    
+    describe "domains" do
+
+      it "#defineDomain" do
+        expect( facade ).to respond_to( :defineDomain )
       end
       
-      it "#setFacade" do
-        expect( loader ).to respond_to( :setFacade )
+    end
+    
+    
+    describe "create model objects" do
+
+      it "#newDefinition" do
+        expect( facade ).to respond_to( :newDefinition )
+      end
+      it "#newFunctionDefinition" do
+        expect( facade ).to respond_to( :newFunctionDefinition )
+      end
+
+      it "#newInterface" do
+        expect( facade ).to respond_to( :newInterface )
+      end
+
+      it "#newParameter" do
+        expect( facade ).to respond_to( :newParameter )
+      end
+
+      it "#newParameterReference" do
+        expect( facade ).to respond_to( :newParameterReference )
+      end
+
+      it "#addParameter" do
+        expect( facade ).to respond_to( :addParameter )
+      end
+
+      it "#addResponseParameter" do
+        expect( facade ).to respond_to( :addResponseParameter )
       end
 
     end
 
+    describe "build model" do
 
+      it "#modelDefinition" do
+        expect( facade ).to respond_to( :modelDefinition )
+      end
+      
+      it "#modelInterface" do
+        expect( facade ).to respond_to( :modelInterface )
+      end
+      
+      
+    end
+
+    
     
   end
   
+
+  # let( :factory ) { Sbuilder::Factory.getFactory }
+  # let( :facade ) { Sbuilder::ApiLoaderFacade.new( factory ) }
+
+  # before :each do
+  #   loader.setFacade( facade )
+  # end
+  
+  # # ------------------------------------------------------------------
+  # # Interfaces
+
+  # describe "interfaces" do
+
+  #   describe "loader" do
+
+  #     it ".configure static method " do
+  #       expect( loader.class ).to respond_to( :configure )
+  #     end
+      
+      
+  #     it "#load" do
+  #       expect( loader ).to respond_to( :load )
+  #     end
+      
+  #     it "#setFacade" do
+  #       expect( loader ).to respond_to( :setFacade )
+  #     end
+
+  #   end
+
+
+    
+  # end
+  
 end
 
 
@@ -65,7 +201,7 @@ end
 RSpec.shared_examples_for "api_loader_facade: uses ':read_cached' to access api definition" do
 
   let( :factory )    { Sbuilder::Factory.getFactory }
-  let( :facade )     { Sbuilder::ApiLoader.new( factory ) }
+  let( :facade )     { Sbuilder::ApiLoaderFacade.new( factory ) }
 
   before :each do
     loader.setFacade( facade )
@@ -117,7 +253,7 @@ RSpec.shared_examples_for "api_loader_facade: contract to load one definition" d
 
 
   let( :factory ) { Sbuilder::Factory.getFactory }
-  let( :facade ) { Sbuilder::ApiLoader.new( factory ) }
+  let( :facade ) { Sbuilder::ApiLoaderFacade.new( factory ) }
 
   before :each do
     loader.setFacade( facade )
@@ -129,6 +265,7 @@ RSpec.shared_examples_for "api_loader_facade: contract to load one definition" d
     parameter = instance_double( Sbuilder::Parameter )
     expect( facade ).to receive( :newDefinition ).ordered.and_return( definition )
     expect( definition ).to receive( :addParameter ).with( parameter )
+    allow( definition ).to receive( :isArray ).and_return( false )
     expect( facade ).to receive( :newParameter ).ordered.and_return( parameter )
     expect( facade ).to receive( :modelDefinition ).ordered
     load
@@ -162,7 +299,7 @@ RSpec.shared_examples_for "api_loader_facade: contract to load one interface" do
 
 
   let( :factory ) { Sbuilder::Factory.getFactory }
-  let( :facade ) { Sbuilder::ApiLoader.new( factory ) }
+  let( :facade ) { Sbuilder::ApiLoaderFacade.new( factory ) }
 
   before :each do
     loader.setFacade( facade )
@@ -225,23 +362,23 @@ end
 #
 #
 
-RSpec.shared_examples_for "api_loader_facade: loader calls #createLogger on #setFacade" do
+# RSpec.shared_examples_for "api_loader_facade: loader calls #createLogger on #setFacade" do
 
-  let( :factory ) { Sbuilder::Factory.getFactory }
-  let( :facade ) { Sbuilder::ApiLoader.new( factory ) }
+#   let( :factory ) { Sbuilder::Factory.getFactory }
+#   let( :facade ) { Sbuilder::ApiLoaderFacade.new( factory ) }
   
 
-  it "#createLogger" do
-    expect( facade ).to receive( :createLogger ).and_call_original
-    loader.setFacade( facade )
-  end
+#   it "#createLogger" do
+#     expect( facade ).to receive( :createLogger ).and_call_original
+#     loader.setFacade( facade )
+#   end
 
-  describe "facade#createLogger" do
+#   describe "facade#createLogger" do
 
-    it "#returns Logger" do
-      expect( facade.createLogger( "name" )).to be_a( Logger )
-    end
-  end
+#     it "#returns Logger" do
+#       expect( facade.createLogger( "name" )).to be_a( Logger )
+#     end
+#   end
   
-end
+# end