tla-sbuilder 0.1.0 → 0.2.1

data/lib/sbuilder/param_set_step.rb

@@ -16,7 +16,7 @@ module Sbuilder
     def initialize( options = {} )
       super( options )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
 
       # default - use rule
       @bindExact = false

data/lib/sbuilder/parameter.rb

@@ -16,7 +16,7 @@ module Sbuilder
     # constrcutore
     def initialize( options = {} )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
       # default is not an arrays
       @isArray = false
     end

data/lib/sbuilder/parameter_container.rb

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

data/lib/sbuilder/parameter_dom.rb

@@ -17,7 +17,7 @@ module Sbuilder
     def initialize( options = {} )
       super( options )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
     end
 
     def self.create( name, domain )

data/lib/sbuilder/parameter_ref.rb

@@ -15,7 +15,7 @@ module Sbuilder
     def initialize( options = {} )
       super( options )
       @logger = getLogger( PROGNAME, options )
-      @logger.info( "#{__method__} initialized" )
+      @logger.debug( "#{__method__} initialized" )
     end
 
     def self.create( name, paramSetName )
@@ -56,7 +56,7 @@ module Sbuilder
     def do_parameter_definition( model )
       {
         # :name => name,
-        :type => reference,
+        :type => getResolvedReference(model).getName,  # reference,
         :namespace => Constants::TYPE_NAMESPACE_REF,   # in TLA code prefix with 't_'
         :composite_parameters => getResolvedReference(model).parameter_definitions( model ),
       }

data/lib/sbuilder/resolver_rule.rb

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

data/lib/sbuilder/resolver_rule_match.rb

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

data/lib/sbuilder/resolver_rule_ref.rb

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

data/lib/sbuilder/spec/README

@@ -0,0 +1,5 @@
+Spec libraries distributed within Gem.
+
+Allown extension points to verify their contract with sbuilder core
+
+

data/lib/sbuilder/spec/api_loader_facade.rb

@@ -0,0 +1,247 @@
+require 'sbuilder'
+
+
+# ------------------------------------------------------------------
+# "api_loader_facade: signatures": Facade implements methods
+# :newDefinition, :newInterface, :newParameter,
+# :newParameterReference, :modelDefinition, :modelInterface. Loader
+# implements methods :load :setFacade
+#
+
+RSpec.shared_examples_for "api_loader_facade: signatures" do
+
+  let( :factory ) { Sbuilder::Factory.getFactory }
+  let( :facade ) { Sbuilder::ApiLoader.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
+
+
+# ------------------------------------------------------------------
+# uses ':read_cached' to access api definition: Loader calls
+# 'read_cached' to receive one string containing api definition.
+# Facade may cache the api definition, if ':cached' property is set
+#
+# Example:
+#
+#  it_behaves_like "api_loader_facade: uses ':read_cached' to access api definition" do
+#    let( :loader ) { described_class.new }
+#    let( :load_data )   {
+#       one_definition
+#    }
+#  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 ) }
+
+  before :each do
+    loader.setFacade( facade )
+  end
+
+  it "#read_cached called" do
+    uri = double( "uri" )
+    empty_yaml  = ""
+    expect( facade ).to receive( :read_cached ).with( uri ).and_return( load_data )
+    # expect( Sbuilder::Utils::NetIo ).to receive( :cache_lines ).with( cacheFile, load_data )
+
+    # after using read_cached --> create model
+    allow( facade ).to receive( :newDefinition ).and_call_original
+    allow( facade ).to receive( :newParameter ).and_call_original
+    allow( facade ).to receive( :newParameterReference ).and_call_original
+    allow( facade ).to receive( :modelDefinition )
+    allow( facade ).to receive( :modelInterface )
+    
+    loader.load( uri ) 
+  end
+
+end
+  
+
+# ------------------------------------------------------------------
+# contract to load one definition: loader calls facade methods
+# 'newDefinition', 'newParameter', 'modelDefinition' in correct order,
+# when loading one interface parameter definition.
+#
+# Example:
+#
+#  it_behaves_like "api_loader_facade: contract to load one definition" do
+#
+#    let( :loader ) {   described_class.new  }
+#    
+#    let( :load )   {
+#      expect( loader ).to receive( :readLines ).and_return( one_definition )
+#      loader.load(  nil )
+#    }
+#  end
+#
+# Notice:
+# - 'loader.load' calls 'loader.readLines', which is stubbed in example block
+# - 'loader.readLine' returns 'one_definition' to create one definition with
+#    one parameter
+#
+
+RSpec.shared_examples_for "api_loader_facade: contract to load one definition" do
+
+
+  let( :factory ) { Sbuilder::Factory.getFactory }
+  let( :facade ) { Sbuilder::ApiLoader.new( factory ) }
+
+  before :each do
+    loader.setFacade( facade )
+  end
+
+  
+  it "#newDefinition, #newParameter, #modelDefinition ordered" do
+    definition = instance_double( Sbuilder::ParamSetDef )
+    parameter = instance_double( Sbuilder::Parameter )
+    expect( facade ).to receive( :newDefinition ).ordered.and_return( definition )
+    expect( definition ).to receive( :addParameter ).with( parameter )
+    expect( facade ).to receive( :newParameter ).ordered.and_return( parameter )
+    expect( facade ).to receive( :modelDefinition ).ordered
+    load
+  end
+
+  
+end
+
+# ------------------------------------------------------------------
+# contract to load one interface: loader calls facade methods
+# 'newInterface', 'newParameter', 'modelInterface' in correct order,
+# when loading one interface definition.
+#
+# Example:
+#
+# it_behaves_like "api_loader_facade: contract to load one interface" do
+#   let( :loader ) {   described_class.new   }
+#   let( :load )   {
+#     expect( loader ).to receive( :readLines ).and_return( one_interface ) 
+#     loader.load(  nil )   }
+# end
+#
+# Notice:
+# - 'loader.load' calls 'loader.readLines', which is stubbed in example block
+# - 'loader.readLine' returns 'one_inteface', which defines one interface with
+#    one interface parameter
+#
+
+
+RSpec.shared_examples_for "api_loader_facade: contract to load one interface" do |parameters=1,references=0|
+
+
+  let( :factory ) { Sbuilder::Factory.getFactory }
+  let( :facade ) { Sbuilder::ApiLoader.new( factory ) }
+
+  before :each do
+    loader.setFacade( facade )
+  end
+  
+  # ------------------------------------------------------------------
+  # builds interface correctly
+
+  describe "creates interface" do
+    
+    it "#newInterface, #newParameter, #modelInterface ordered" do
+      expect( facade ).to receive( :newInterface ).ordered.and_call_original
+      expect( facade ).to receive( :newParameter ).exactly( parameters ).times.and_call_original
+      expect( facade ).to receive( :newParameterReference ).exactly( references ).times.and_call_original            
+      expect( facade ).to receive( :modelInterface ).ordered
+      load
+    end
+    
+  end
+
+  describe "facade#newInterface" do
+    
+    let ( :newInterface ) { facade.newInterface( "path", "op" ) }
+    
+    it "#returns Sbuilder::ParamSet" do
+      expect( newInterface ).to be_a( Sbuilder::ParamSet )
+    end
+
+    it "#returns Sbuilder::ParamSet_If" do
+      expect( newInterface ).to be_a( Sbuilder::ParamSet_If )
+    end
+
+    context "response" do
+
+      let ( :response ) { newInterface.respons }
+
+      it "#response returns Sbuilder::ParamSet" do
+        expect( newInterface ).to be_a( Sbuilder::ParamSet )
+      end
+    
+      it "#response returns Sbuilder::ParamSet_If" do
+        expect( newInterface ).to be_a( Sbuilder::ParamSet_If )
+      end
+
+    end
+    
+  end
+
+end
+
+# ------------------------------------------------------------------
+# Loader method #setFacade  calls facade#createLogger to get an Ruby
+# logger objects
+#
+# Example:
+# 
+# it_behaves_like "api_loader_facade: loader calls #createLogger on #setFacade" do
+#   let( :loader ) {   described_class.new  }    
+# end
+#
+#
+
+RSpec.shared_examples_for "api_loader_facade: loader calls #createLogger on #setFacade" do
+
+  let( :factory ) { Sbuilder::Factory.getFactory }
+  let( :facade ) { Sbuilder::ApiLoader.new( factory ) }
+  
+
+  it "#createLogger" do
+    expect( facade ).to receive( :createLogger ).and_call_original
+    loader.setFacade( facade )
+  end
+
+  describe "facade#createLogger" do
+
+    it "#returns Logger" do
+      expect( facade.createLogger( "name" )).to be_a( Logger )
+    end
+  end
+  
+end
+  

data/lib/utils/cache_lines.rb

@@ -0,0 +1,21 @@
+module Sbuilder
+  
+  module Utils
+
+    module CacheLines
+
+      # write lines in cache file
+      def self.cache_write( cacheFile, data  )
+        File.open( cacheFile, "w" ) { |f| f.write( data ) }
+      end
+
+      # Return content of cache file
+      # 
+      # @return [String] cached Strinng, nil if not cached
+      def self.cache_read( cacheFile )
+        return File.read( cacheFile ) if !cacheFile.nil? && File.exist?( cacheFile )
+      end
+      
+    end
+  end
+end

data/lib/utils/netio.rb

@@ -21,22 +21,18 @@ module Sbuilder
           end
         end
 
-        # if  'cacheFile' return line in 'cacheFile else read from 'uri' &&  write to 'cacheFile'
-        def read_lines_cached( uri, cacheFile = nil  )
+        # read line from uri
+        # @return [String] read from url
+        def read_lines( uri  )
           
-          # cached
-          return File.read( cacheFile ) if !cacheFile.nil? && File.exist?( cacheFile )
-
           # network access && create cache
-          lines = read_lines( uri )
-          cache_lines( cacheFile, lines ) unless cacheFile.nil?
+          lines = do_read_lines( uri )
 
-          # 
           return lines
           
         end
 
-        def read_lines( uri  )
+        def do_read_lines( uri  )
           begin
             open( uri ).read
           rescue => e
@@ -45,10 +41,6 @@ module Sbuilder
           end
         end
 
-        # write lines in cache file
-        def cache_lines( cacheFile, lines  )
-          File.open( cacheFile, "w" ) { |f| f.write( lines ) }
-        end
 
 
       end

data/mustache/cfg/macro_run.mustache

@@ -4,3 +4,4 @@ CONSTANT ProcessRunning <- RunProcessRunning
 CONSTANT ProcessParameter <- RunProcessParameter
 CONSTANT ProcessesToRun <- RunProcessesToRun
 CONSTANT TickNext <- RunTickNext
+CONSTANT InTransaction <- RunInTransaction

data/mustache/interface_processes.mustache

@@ -25,8 +25,15 @@ fair process ({{>name_process.mustache}}="{{interface_operation}}") {
 	    {{^PREFERENCES.debug-output}}\* {{/PREFERENCES.debug-output}}print <<"   - input=>", _input >>;	    
 	    (* print <<"   - {{>name_interface_type.mustache}}=>", {{>name_interface_type.mustache}} >>; *)
 	    {{/implementation}}
-	    (* Valid input type? *)
-	    assert(  _input \in {{>name_interface_type.mustache}} );
+	    {{#parameter_definitions.length}}
+	    (* Valid input type? - _input must match type of API request *)	    
+	    assert(  _input \in {{>name_interface_type.mustache}} );{{/parameter_definitions.length}}{{!
+
+	       else : no parmaeter
+
+	    }}{{^parameter_definitions.length}}
+	    (* Valid input type? - API configuration did not define any parameters - must have Nil for _input.dummy: *)
+	     assert(  _input.dummy = Nil );{{/parameter_definitions.length}}	    
 	    {{#implementation}}{{implementation}}( _input );{{/implementation}}
 	 }; \* with _input
 	 (* enable next process - after current process *)

data/mustache/interface_stubs_dummy.mustache

@@ -4,6 +4,12 @@ Interfaces generated  {{META.desc}}
  - template  {{META.template}}
 ******************************************************************)
 
+(* Allow  'interface-extension.implementation' without specification code snippet *)
+macro dummy( dummy_input ) {
+      print << "Dummy macro called should replace with actual macro" >>;
+}
+
+
 (* Create a dummy procedure with input variable so that pcal creates
    constant defaultInitValue (which is assigned a value in setup.tla)
 *)
@@ -11,3 +17,4 @@ Interfaces generated  {{META.desc}}
 procedure dummy( dummy_input ) {
 	dummy_start:  skip;
 }
+

data/mustache/interface_types.mustache

@@ -19,9 +19,9 @@ Interface input types: {{META.desc}}
 
      Empty parameter definition (passes swagger schema validation).
      
-     ouput 'dummy : Nil'
-     
-}}{{^parameter_definitions.length}}dummy: Nil{{/parameter_definitions.length}}
+     ouput 'dummy : {Nil}'
+
+}}{{^parameter_definitions.length}}dummy: {Nil}{{/parameter_definitions.length}}
 ] \* operation '{{interface_operation}}' --> process '{{>name_process.mustache}}'
 
 {{/interfaces}}