sbuilder-ial 0.0.1

data/lib/fp/compositable.rb

@@ -0,0 +1,185 @@
+module Sbuilder
+  module Fp
+
+    module Compositable
+
+      def initialize( value )
+        # @value = join(value)
+        @value = value
+      end
+      
+      # @attr [Object] value wrapped
+      attr_reader :value
+
+      # @return [Error|nil] 
+      def error
+        return nil unless isError
+        return self if is_a?( Error )
+        value.error
+      end
+
+      def method_missing( m, *args, &block)
+        value.public_send( m, *args, &block)
+      end
+
+      
+      def to_s
+        value.to_s
+      end
+
+      def isError
+        # return @value.isError if  @value.respond_to?( :isError )
+        @value.is_a?( Error ) || is_a?( Error )
+      end
+      
+      def isSuccess
+        !isError
+      end
+
+      # Composition operator. Can bind (with *args) to an instance
+      # method (given as a :symbol), proc, or block.
+      def and_then( proc=nil, *args, &block )
+        
+        # make error pass trough
+        return self if isError
+
+        # 
+        proc = _proc( proc, *args, &block )
+        begin
+          ret = proc.arity == 0 ? proc.call( &block ) : proc.call( value, &block )        
+          ret = self.class.new( ret ) if ret.is_a?( Fixnum ) ||  !ret.singleton_class.include?(Compositable)
+        rescue  FpException => fpError
+          ret = Error( fpError )
+        end
+        
+        ret
+      end
+      alias :>> :and_then
+      
+
+      def or_else( proc=nil, *args, &block )
+
+        # transparent unless error
+        return self unless isError
+
+        proc = _proc( proc, *args, &block )
+        ret = proc.call( value )                
+
+        ret
+        
+      end
+      alias :'__' :or_else                  
+
+      # Pipe to enable side effects
+      def pipe(proc=nil, &block)
+        (proc || block).call(self)
+        self
+      end
+      alias :<< :pipe
+
+
+      def _proc( proc=nil, *args, &block )
+        # referring to an instance method (given as a symbol in 'proc')
+        if proc.is_a? Symbol
+          if respond_to?(proc)
+            proc = method(proc).to_proc
+          elsif value.respond_to?(proc)
+            proc = value.method(proc).to_proc
+          else
+            raise "Unknown method symbol '#{proc}' in #{self}"
+          end
+        end
+        proc = proc || block
+
+        # curry possible *args
+        if  args.count > 0 then
+          proc = proc.curry[*args]
+          if !proc.is_a?( Proc ) then
+            # all parameters in proc bound, wrap it as lambda to
+            # return a fixed value
+            procRet = proc
+            proc = ->() { procRet }
+          end
+        end
+        proc
+      end # _proc
+
+      # ------------------------------------------------------------------
+
+      # lwrap (lambda wrapper) for an instance method
+      #
+      # @Return [lamba] lamba(v)' calling to a instance method 'm'
+      # curried with '*args'
+      
+      def lwrap( m, *args )
+        # find instance method & curry
+        p = method( m ).to_proc
+        p = args.count > 0 ? p.curry[*args] : p
+
+        # create lamba(v) calling to p[v]
+        self.class._lwrap( p, args )
+
+      end
+
+      def Error( o )
+        self.class.Error( o )
+      end
+      
+      def Result( o )
+        Sbuilder::Fp.Result( o )
+      end
+      
+
+      # ------------------------------------------------------------------
+      # class methods
+
+      # Add class methods from module 'ClassMethods'
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def Error( o )
+          # Sbuilder::Fp::Error.new( o )
+          Sbuilder::Fp.Error( o )
+        end
+
+        # lwrap (lambda wrapper) for a class method
+        #
+        # @Return [lamba] lamba(v)' calling a class method 'm' curried
+        # with '*args'
+        def lwrap( m = :new, *args )
+          # find class method & curry 
+          p = method( m ).to_proc
+          p = args.count > 0 ? p.curry[*args] : p
+          # create lamba(v) calling to p[v]
+          _lwrap( p, args )
+        end
+
+
+        # @return [lambda] lamdba(v) for proc 'p' curried with
+        # '*args'. lamba return is wrapped into object instance of
+        # current class, unless the return is already 'Compositable',
+        # short circuits 'Error'
+        def _lwrap( p, *args )
+          
+          ->(v) do
+            if v.is_a?(Error) then
+              # short circuit error
+              v
+            else
+              # ret = p[v]
+              ret = p.arity == 0 ? p.call : p[v]
+              ret = self.new( ret ) unless ret.singleton_class.include? Compositable
+              ret 
+            end
+          end
+        end # self._lwrap
+        
+            
+      end # module ClassMethods
+      
+    end # module Compositable
+  end
+end

data/lib/fp/error.rb

@@ -0,0 +1,19 @@
+module Sbuilder
+  module Fp
+
+    class Error
+
+      include Sbuilder::Fp::Compositable
+      
+    end
+
+    # ------------------------------------------------------------------
+    # Module function allows calling Sbuilder::Fp.Error( wrapped )
+
+    def Error( o )
+      Sbuilder::Fp::Error.new( o )
+    end
+    module_function :Error
+
+  end
+end

data/lib/fp/exception.rb

@@ -0,0 +1,9 @@
+module Sbuilder
+  module Fp
+
+    class FpException < Exception
+    end
+    
+    
+  end
+end

data/lib/fp/result.rb

@@ -0,0 +1,19 @@
+module Sbuilder
+  module Fp
+
+    class Result
+
+      include Sbuilder::Fp::Compositable
+      
+    end
+
+    # ------------------------------------------------------------------
+    # Entry points 
+    def Result( o )
+      return o if o.is_a?( Result ) || o.is_a?( Error )
+      Sbuilder::Fp::Result.new( o )
+    end
+    module_function :Result
+
+  end
+end

data/lib/fp/sequence.rb

@@ -0,0 +1,65 @@
+module Sbuilder
+  module Fp
+
+    class Sequence
+
+      include Sbuilder::Fp::Compositable
+
+      # Composition operator. Can bind (with *args) to an instance
+      # method (given as a :symbol), proc, or block.
+      def and_then( proc=nil, *args, &block )
+        
+        proc = _proc( proc, *args, &block )
+
+        # toggle for any error
+        inError = false
+
+        # ----------
+        # Iterate sequence using lamba
+
+        blockAsProc = ->(v) do 
+          begin
+            mapped_v = proc.arity == 0 ? proc.call( &block ) : proc.call( v, &block )        
+            # Guarantee that sequenced results are wrapped within
+            # 'Compositable'. Use Fixnum check to avoid error "can't
+            # define singleton" for 'immadiate values (i.e. Fixnums)
+            mapped_v = Result(mapped_v) if mapped_v.is_a?( Fixnum ) || !mapped_v.singleton_class.include?( Compositable)
+            inError = inError || mapped_v.isError
+          rescue  FpException => fpError
+            inError = true
+            mapped_v = Error(fpError)
+          end
+          mapped_v
+        end
+        ret =  value.map &blockAsProc
+        
+        ret = inError ? Error( ret ) : Result( ret )
+        ret
+      end
+
+      
+
+      def self.wrap( wrapped )
+        Sequence.new( wrapped )        
+      end
+      
+      def self.from_array( array )
+        array = [ array ] unless array.is_a?( Array )
+        Sequence.new( array.lazy )
+      end
+      
+      
+    end
+
+    # ------------------------------------------------------------------
+    # Entry points 
+    def Sequence( o )
+      o = [ o ] unless  o.is_a?( Array )
+      Sbuilder::Fp::Sequence.wrap( o )
+    end
+    module_function :Sequence
+    
+    
+  end
+end
+

data/lib/ial/build.rb

@@ -0,0 +1,12 @@
+module Sbuilder
+  module Ial
+    module Ial
+      class Build
+
+        
+        
+        
+      end
+    end
+  end
+end

data/lib/ial/exception.rb

@@ -0,0 +1,13 @@
+module Sbuilder
+  module Ial
+    module Ial
+      
+      class IalException < Sbuilder::Fp::FpException; end
+      
+      class PropertyException < IalException; end
+      
+      class UnkwonSexpType < IalException;  end
+      
+    end
+  end
+end

data/lib/model/constants.rb

@@ -0,0 +1,72 @@
+module Sbuilder
+  module Ial
+    module Model
+
+      class Constants
+        
+        # types
+        IAL_LIBRARY     =  :library
+        IAL_DOMAIN      =  :domain
+        IAL_DEFINITION  =  :definition
+        IAL_VARIABLE    = :variable
+        IAL_TRANSACTION = :transaction
+        IAL_MACRO       = :macro
+        IAL_OPERATOR    = :operator
+
+        # Lookup 'type' names to initilize by default
+        LOOKUPS_TO_INIT = [ IAL_LIBRARY, IAL_DOMAIN, IAL_DEFINITION, IAL_VARIABLE, IAL_TRANSACTION, IAL_MACRO, IAL_OPERATOR ]
+
+        # ------------------------------------------------------------------
+        # Expressions
+
+        CONSTANT_EXPRESSION_NIL = :nil
+        CONSTANT_EXPRESSION_EMPTY = :empty
+
+        CONSTANT_EXPRESSIONS = {
+          CONSTANT_EXPRESSION_EMPTY => '{}',
+          CONSTANT_EXPRESSION_NIL => 'Nil',
+        }
+
+        # ------------------------------------------------------------------
+        # Operators
+        
+        OPERATOR_SET_MINUS = :set_minus
+        OPERATOR_SET_UNION = :union
+        OPERATOR_PLUS = :plus
+        OPERATOR_MINUS = :minus
+        OPERATOR_MULT = :mult
+        OPERATOR_DIV = :div
+        OPERATOR_EQUAL = :equal
+
+        # map operator names to TLA implementation
+        IAL_OPERATORS = {
+          OPERATOR_SET_MINUS => '\\',
+          OPERATOR_SET_UNION => '\\union',
+          OPERATOR_PLUS => '+',
+          OPERATOR_MINUS => '-',
+          OPERATOR_MULT => '*',
+          OPERATOR_DIV => '/',
+          OPERATOR_EQUAL => '=',
+        }
+
+        # ------------------------------------------------------------------
+        # Tla templates
+        
+
+        TLA_TEMPLATES = {
+          :set => ->(gen, *args) { gen.gen_set( *args ) },
+          :set_generate => ->(gen, map, variable, set ) { gen.gen_set_map( map, gen.gen_set_iterate( variable, set )) },          
+          :plainname => ->(gen, name ) { gen.gen_plainname( name ) },          
+          :sequence => ->(gen, *args) { gen.gen_sequence( args ) },
+          :record_field => ->(gen, *args) { gen.gen_record_field( *args ) },
+          :IF_expression => ->(gen, condExpr, thenExpr, elseExpr) { gen.gen_IF( condExpr, thenExpr, elseExpr ) },
+          :EXCEPT_expression => ->(gen, variable, *excepts) { gen.gen_EXCEPT( variable, excepts ) },
+          :procedure_call => ->( gen, txName, operationName, params ) { gen.gen_procedure_call( gen.txName2ServiceProcedure( txName, operationName ), params ) },
+          :record_field_definition => ->( gen, name, value ) { gen.gen_record_field_definition( name, value ) },
+          :record => ->( gen, *arrOfFields ) { gen.gen_record_definition( arrOfFields ) },
+        }
+
+      end
+    end
+  end
+end

data/lib/model/model.rb

@@ -0,0 +1,74 @@
+require 'docile'
+
+
+module Sbuilder
+  module Ial
+    module Model
+
+      class Model
+
+        # ------------------------------------------------------------------
+        # Contrcut && configure
+
+        # @param [:Symbol:Array] lookupsToInit lookup types to inialize
+        def initialize( lookupsToInit = [] )
+          @lookups = {}
+          lookupsToInit.each do |type|
+            initLookup( type )
+          end
+        end
+
+        def self.start
+          self.new( Sbuilder::Ial::Model::Constants::LOOKUPS_TO_INIT )
+        end
+
+        # @attr [Hash] lookups
+        attr_reader :lookups
+
+        # has operations
+
+        def []( key )
+          @lookups[key]
+        end
+
+        def keys()
+          @lookups.keys
+        end
+
+        # Creates a lookup hash for 'type'
+        #
+        # @param [:Symbol] type of looupk to create
+        def initLookup( type )
+          raise "Lookup already initiazed for type' #{type}'" unless lookups[type].nil?
+          lookups[type] = {}
+          self
+        end
+
+        # ------------------------------------------------------------------
+        # Use
+
+        # sets lookups[type][ref] = value
+        def define( type, ref, value )
+          raise "Application error: lookups[#{type}] - not initiliazed - should have run 'initLookup( #{type} - known lookups #{lookups.keys.join(',')})'" unless lookups[type].is_a?(Hash)
+          lookups[type][ref] = value
+          self
+        end
+
+        # @return lookups[type][ref]| lookups[type].keys
+        def lookup( type, ref=nil )
+          raise "Should have run 'initLookup( #{type} )'" if lookups[type].nil?
+          return lookups[type].keys if ref.nil?
+          lookups[type][ref]
+        end
+
+        
+        
+      end # class Model
+      
+      
+    end
+  end
+end
+
+
+require_relative 'model_dsl'