sbuilder-ial 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: adc5f01a4ed93c98bd2b23bdd27c918d4afae217
+  data.tar.gz: d33fea2b83e302205afbdc53c5f3dc68cd50f1fc
+SHA512:
+  metadata.gz: 721d8942e0cd0802840f415e5b1137eca3de78949d3d332391429eccd0a37d0c1a294048ded007a09e977937f7819be0d9256d4d855eaf0d90e706ebbad06569
+  data.tar.gz: bc3102e19c1f065fe7486e5098871df145f23415e2f67fcb74e68dfff968fe713a1496c507fe5be5967480f6ee74d65ce8fe5e91694817f568d2c984b310032b

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/action/exception.rb

@@ -0,0 +1,13 @@
+module Sbuilder
+  module Ial
+    module Action
+
+      # not to to intercepted in Sbuilder::Fp
+      class ActionException < Exception; end
+
+      # intercepted in Sbuilder::Fp      
+      class ActionError < Sbuilder::Fp::FpException; end      
+      
+    end
+  end
+end

data/lib/action/extender.rb

@@ -0,0 +1,30 @@
+module Sbuilder
+  module Ial
+    module Action
+
+      # not catched in 'Fp'
+      class ExtenderException < ActionException; end
+      # catched in 'Fp'
+      class ExtenderError < ActionError; end      
+
+      class Extender
+
+        # start in application mode
+        def self.start
+          extender = Extender.new
+          extender
+        end
+
+        def defineDomain( domainDefinition ) 
+          warn "#{__method__}: Not implemented domainDefinition=#{domainDefinition}"
+        end
+        
+        def defineSnippet( metatype, appName, snippetBody, specName ) 
+          warn "#{__method__}: Not implemented snippetBody =#{snippetBody}"
+        end
+        
+      end # class
+      
+    end
+  end
+end

data/lib/action/file_path.rb

@@ -0,0 +1,35 @@
+##
+# A compositable wrapping a string pointing to a file, with a method
+# 'readlines' to slurp file content to an array.
+
+module Sbuilder
+  module Ial
+    module Action
+
+      class FilePath
+
+        def self.from_string( str )
+          File.exist?( str ) ?  new( str ) : new( Error( "Error: trying to access a non existing file #{str}" ))
+        end
+
+        # @return [String:Array] lines
+        def readlines( filename = nil )
+          filename = value if filename.nil?
+          File.readlines( filename )
+        end
+
+
+        # # @return [String|Error] content of file name wrapped OR error
+        # def to_s
+        #   return Error(value) if isError
+        #   File.open( value, 'rb' ).read
+        # end
+
+        include Sbuilder::Fp::Compositable 
+        
+      end
+
+      
+    end
+  end
+end

data/lib/action/model_builder.rb

@@ -0,0 +1,74 @@
+module Sbuilder
+  module Ial
+    module Action
+      class ModelBuilder
+
+        # # @attr [Sbuilder::Ial::Action::Validator] validator
+        # attr_accessor :validator
+
+        def self.start
+          parser = ModelBuilder.new( Sbuilder::Ial::Model::Model.start )
+          # parser.validator = Sbuilder::Ial::Action::Validator.start
+          parser
+        end
+
+
+        # ------------------------------------------------------------------
+        # parseSexps && parseSexp
+
+        # Wrap result of 'validator.updateVo' to Result/Error
+        # compositable
+        def updateVo( vo )
+          Sbuilder::Fp.Result(vo)
+          # begin
+          #   updatedVoret = validator.updateVo( getModel, vo )
+          #   ret = Sbuilder::Fp.Result( updatedVoret )
+          # rescue PropertyError => err
+          #   ret = Sbuilder::Fp.Error( err )
+          # end
+          # ret
+        end
+
+
+        # Currently no-operation
+        def validateVo( vo )
+          Sbuilder::Fp.Result(vo)
+          # begin
+          #   validationResult = validator.validateVo( getModel, vo )
+          #   ret = validationResult ? Result( vo ) : Error( vo )
+          # rescue PropertyError => err
+          #   ret = Sbuilder::Fp.Error( err )
+          # end
+          # ret
+        end
+
+        # ------------------------------------------------------------------
+        # defineVo && defineVos
+
+        def defineVo( vo )
+          return if vo.nil?
+          value.define( vo.type, vo.name, vo )
+          vo
+          # self
+        end
+        def defineVos( vos )
+          defined = vos.map {  |vo|  defineVo( vo ) }
+          # Sbuilder::Fp.Result( value )
+        end
+
+        # @return [Result(Sbuilder::Ial::Model::Model)] model being build using 'defineVo'
+        def getModelBuilt
+          Sbuilder::Fp.Result( getModel )
+        end
+
+        def getModel
+          value
+        end
+
+        include Sbuilder::Fp::Compositable 
+
+
+      end
+    end
+  end
+end

data/lib/action/render/exception.rb

@@ -0,0 +1,12 @@
+module Sbuilder
+  module Ial
+    module Action
+      module Render
+
+        class MustacheException < Exception; end
+        class TlaElementException < Exception; end        
+
+      end
+    end
+  end
+end

data/lib/action/render/producer.rb

@@ -0,0 +1,193 @@
+module Sbuilder
+  module Ial
+    module Action
+      module Render
+
+        class Producer
+
+          extend Forwardable                      # for easy delegation
+
+          def_delegators :tla,
+                         :partials,               # @attr [Hash]
+                         # tla code rendering
+                         :gen_empty_set,
+                         :gen_set,
+                         :gen_sequence,                         
+                         :gen_list,                     
+                         :gen_nilElement,
+                         :gen_op_set_minus,
+                         :gen_operator,
+                         :gen_macro_call,                     
+                         :gen_operator_call,
+                         :gen_expression2,
+                         :gen_identifier,
+                         :gen_service_name,                     
+                         :gen_state_variable,
+                         :gen_record_definition,
+                         :gen_name_op_operand,
+                         # names
+                         :gen_specname,
+                         :gen_interface_input_variable_name,
+                         :gen_interface_abort_label,
+                         :gen_interface_fail_label,
+                         :gen_interface_end_label,
+                         :gen_plainname,
+                         # 
+                         :gen_constant,
+                         :gen_str,
+                         :gen_parenthesis,
+                         # :gen_service_entry,
+                         :gen_service_procedure,
+                         :gen_free_text,
+                         :gen_debug_msg,
+                         :gen_print,
+                         :gen_assert,
+                         :gen_commented,
+                         :gen_traced_stmt,
+                         :gen_labeled_stmt, # add label to stmt
+                         :gen_label,     # skip which is followed by label
+                         :gen_label_it,  # wrapts stmt to require label after
+                         :gen_goto,
+                         :gen_either,                                          
+                         :gen_skip,
+                         # :gen_check_resume,
+                         :gen_assign,
+                         :gen_record_field_definition,
+                         :gen_record_named_field,
+                         :gen_record_field,
+                         :gen_stmts,
+                         :gen_operator_dummy,
+                         :gen_construct_contract,
+                         :gen_new_record,
+                         :gen_procedure_call,
+                         :gen_if,
+                         :gen_not,                     
+                         :gen_IF,
+                         :gen_TRUE,
+                         :gen_FALSE,                                          
+                         :gen_EXCEPT,
+                         :gen_and,
+                         :gen_bin_op,
+                         :gen_unary_op,
+                         :gen_set_iterate,
+                         :gen_set_map,                     
+                         :gen_macro,
+                         :gen_serviceProcedureLabelStatements
+          
+          
+          
+
+          # @attr [TlaElementGenerator] tla
+          attr_reader :tla
+
+          # @attr [Hash] validMetatypes metatype->String 
+          attr_accessor :validMetatypes
+
+          # @attr [String:Array] metatypeKeys
+          # @option metatypeKeys [0] app
+          # @option metatypeKeys [1] tx_function          
+          attr_accessor :metatypeKeys
+
+
+          METATYPE_ETH = 'ial'          
+          # METATYPE_TX_ENTRY = 'ial-tx-entry'
+          # METATYPE_TX_EXIT = 'ial-tx-exit'
+          METATYPE_TX_FUNC = 'ial-tx-func'                    
+
+          METATYPES = {
+            METATYPE_ETH => { :name => "Intermediate API Language ethereum implementation", :prefix => 'ial' },
+            METATYPE_TX_FUNC => { :name => "Intermediate API Language transaction function", :prefix => 'ial_tx_func' },
+            # METATYPE_TX_ENTRY => { :name => "Intermediate API Language transaction entry", :prefix => 'ial_tx_enter', :framework => Sbuilder::FacadeConstants::META_MODEL_SERVICE_IMPLEMENTATION },
+            # METATYPE_TX_EXIT => { :name => "Intermediate API Language transaction exit", :prefix => 'ial_tx_exit', :framework => Sbuilder::FacadeConstants::META_MODEL_SERVICE_COMPLETION },                      
+            
+          }
+
+
+          # ------------------------------------------------------------------
+          # @!group Construct & configure
+
+          def initialize( options = {}, metatypes=nil )
+            tla = Sbuilder::Ial::Action::Render::TlaElementGenerator.start
+            setTla( tla  )
+            self.metatypeKeys = [ METATYPE_ETH, METATYPE_TX_FUNC ]
+            initMetatypes( metatypes )
+          end
+
+          # @param [TlaElementGenerator] tla element generator
+          def setTla( tla ) 
+            @tla = tla
+          end
+
+          # @param [Hash] metatypes key-value to init
+          private def initMetatypes( metatypes )
+            return if metatypes.nil?
+            self.metatypeKeys = [ metatypes, "#{metatypes}_func"]
+            self.validMetatypes = {
+              metatypeKeys[0] => { :name => "Intermediate API Language ethereum implementation for #{metatypes}", :prefix=> metatypeKeys[0] },
+              metatypeKeys[1] => { :name => "Intermediate API Language ethereum implementation for #{metatypes}", :prefix=> metatypeKeys[1] },              
+            }
+          end
+
+          # @!endgroup
+
+          # ------------------------------------------------------------------
+          # @!group Metatypes
+          
+          # Return non-frameworked metatypes (to be loaded to
+          # sbuilder-framework)
+          #
+          # @return [Hash] metatypes
+          # @option metatypes [String|Symbol] key
+          # @option metatypes [Symbol] :name
+          # @option metatypes [Symbol] :prefix optional          
+          def rule_metatypes
+            # metatypes = getMetatypes
+            # metatypes.keys.inject( {}) { |memo,k| memo[k] = metatypes[k] if metatypes[k][:framework].nil?; memo }
+            getMetatypes
+          end
+
+          # @return [Hash] validMetatypes i.e. all metatypes used when
+          # producing ethereum code
+          private def getMetatypes
+            return validMetatypes unless validMetatypes.nil?
+            METATYPES 
+          end
+
+          # Pass +metatype+ trough, and ensure it exists +metatypes+
+          def setMetatype( metatype )
+            raise TlaElementException, 
+                  <<-EOS unless (getMetatypes && getMetatypes.key?( metatype ))
+                  Unknown metatype '#{metatype}' type '#{metatype.class}'
+
+                  valid metatypes =: #{getMetatypes ? getMetatypes.keys.join(',') : 'non metatypes found - use setValidMetatypes to define metatypes '}
+
+                  EOS
+            # map to :framework metatype - if possible
+            getMetatypes[metatype][:framework].nil? ? metatype : getMetatypes[metatype][:framework]
+          end
+
+          def metaTxFunc
+            # METATYPE_TX_FUNC
+            metatypeKeys[1]
+          end
+          def metaTxEntry
+            Sbuilder::FacadeConstants::META_MODEL_SERVICE_IMPLEMENTATION 
+            # METATYPE_TX_ENTRY
+          end
+          def metaTxExit
+            Sbuilder::FacadeConstants::META_MODEL_SERVICE_COMPLETION
+            # METATYPE_TX_EXIT
+          end
+          def metaApp
+            # METATYPE_ETH
+            metatypeKeys[0]
+          end
+          
+          # @!endgroup
+          
+        end
+
+      end
+    end
+  end
+end