tla-sbuilder 0.1.0

data/lib/sbuilder/resolver_loader.rb

@@ -0,0 +1,79 @@
+
+module Sbuilder
+
+  class ResolverLoader
+
+    attr_reader :factory                      # to create stuff
+    attr_accessor :controller                 # get sets when load starts
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ResolverLoader"                 # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+
+    # ------------------------------------------------------------------
+    # constructore
+    
+    def initialize( factory, options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      @factory = factory
+    end
+
+    # ------------------------------------------------------------------
+    # load mapper from 'filePath'
+    def load( filePath, controller )
+      @controller = controller
+      begin
+        mappers = doLoad( filePath )
+      rescue Exception => ee
+        msg = "Error #{ee} when loading '#{filePath}', caused by #{ee.backtrace.join("\n")} \n\n"
+        @logger.error( "#{__method__} #{msg}" )
+        raise LoaderException.new( msg )
+      end
+      return mappers
+    end
+
+    # create new mapper object
+    def createResolver
+      factory.createResolver
+    end
+
+
+    # create new rule object
+    def createResolverRule
+      factory.createResolverRule
+    end
+
+    # domain encountered during load phase
+    def domainEncountered( domain )
+      controller.domainEncountered( domain )
+    end
+
+    # doLoad infoms super class for a new mapper, delegate to controller
+    def mapperCreated( mapper )
+      controller.mapperCreated( mapper )
+    end
+
+    # return mapper with name in controller - error if not found
+    def findResolver( name )
+      mapper = @controller.findResolver( name )
+      raise "Resolver #{name} not found" if mapper.nil?
+      return mapper
+    end
+    
+
+    # ------------------------------------------------------------------
+    # sub-class should implement the doload method
+    def doLoad( filePath )
+      msg = "Sub class should implement doLoad -method"
+      @logger.error( "#{__method__} #{msg}" )        
+      raise NoMethodError.new( msg  )
+    end
+
+
+  end # class ResolverLoader
+
+
+end # module

data/lib/sbuilder/resolver_loader_yaml.rb

@@ -0,0 +1,103 @@
+module Sbuilder
+
+  class ResolverLoader_YAML < ResolverLoader
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ResolverLoaderYAML"             # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constructore
+
+    def initialize( factory, options = {} )
+      super( factory, options )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+    end
+
+    # ------------------------------------------------------------------
+    # build phase
+
+    def doLoad( yamlPath )
+      @logger.info( "#{__method__} yamlPath=#{yamlPath}" )
+      if !yamlPath then
+        msg = "yamlPath empty"
+        @logger.info( "#{__method__} #{msg}" )
+        raise msg
+      end
+      # get lines from net or from a file
+      yaml_lines = Sbuilder::Utils::NetIo.read_lines( yamlPath )
+      yaml = YAML.load( yaml_lines )
+      mappers = yaml2mapper( yaml )
+      @logger.info( "#{__method__} loaded =#{mappers.length} mappers" )      
+      return mappers
+    end
+
+    # iterate yaml && create mapper && config
+    private def yaml2mapper( yamlArray )
+      mappers = []
+      yamlArray && yamlArray.each do |mapperDef|
+
+        # create mapper & configure it
+        mapper = factory.createResolver( Sbuilder::Constants::MAPPER_YAML )
+        matcher = mapperDef['Matcher']
+        mapper.setMatch( matcher )
+        mapper.setName( mapperDef['Name'] )
+        
+        # inform paraent class that created
+        mapperCreated( mapper )
+        @logger.info( "#{__method__} matcher #{matcher} for #{mapperDef['Name']}" )
+        mappers << mapper
+
+        # validate mapperDef
+        # raise "mapper definition #{mapperDef} should define property 'Rules'" unless mapperDef['Rules']
+        
+        mapperDef['Rules'] && mapperDef['Rules'].each do |ruleDef|
+          
+          if ruleDef['Matcher'] then
+            
+            # rule implementation
+            yaml2mapperMatchRule( mapper, ruleDef )
+          elsif ruleDef['Ref'] then
+
+            # include existing rules
+            yaml2mapperRefRule( mapper, ruleDef )
+          else
+            raise "Unknown mapper rule #{ruleDef} in #{mapperDef['Name']} - should define 'Matcher' or 'Ref' properties"
+          end
+        end
+      end
+      mappers
+    end
+
+    # create match mapper rule && config && add to mapprt
+    private def yaml2mapperMatchRule( mapper, ruleDef )
+      rule = factory.createResolverRule( Sbuilder::Constants::MAPPER_RULE_MATCH  )
+      domainName = ruleDef['Domain']
+      domainEncountered( domainName )
+      rule.config( ruleDef['Matcher'], domainName )
+      mapper.add_rule( rule )
+    end
+
+    # create reference mapper rule && config && add to mapprt
+    private def yaml2mapperRefRule( mapper, ruleDef )
+      # Create rule
+      rule = factory.createResolverRule( Sbuilder::Constants::MAPPER_RULE_REF  )
+
+      # Validate context
+      raise "Expect ruleDef #{ruleDef} to define 'Ref' in mapper #{mapper.name}" unless ruleDef['Ref']
+      name = ruleDef['Ref']
+      referencedResolver = findResolver( name = ruleDef['Ref'] )
+
+      # configure
+      rule.setRef(  referencedResolver );
+      
+      # Finally add to list
+      mapper.add_rule( rule )
+    end
+  end
+
+
+end
+

data/lib/sbuilder/resolver_rule.rb

@@ -0,0 +1,36 @@
+
+module Sbuilder
+
+  class ResolverRule
+
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ResolverRule"                   # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize(  options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+    end
+
+    # ------------------------------------------------------------------
+    # resolve domain
+    
+    # return true if domain resolved
+    def applyRule( parameter, model )
+      doApplyRule( parameter, model )
+    end
+
+    def doApplyRule( parameter, model )
+      msg = "Sub class should implement doApplyRule -method"
+      @logger.error( "#{__method__} #{msg}" )        
+      raise NoMethodError.new( msg  )
+    end
+
+    
+  end
+  
+end

data/lib/sbuilder/resolver_rule_match.rb

@@ -0,0 +1,55 @@
+module Sbuilder
+
+  class ResolverRuleMatch < ResolverRule
+
+    attr_reader :matchRule                    # string or regexp
+    attr_reader :domain
+
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ResolverRuleMatch"              # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize(  options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      super( options )
+    end
+
+    # set properties when loading
+    def config( matchRule, domain )
+      @matchRule = matchRule
+      @domain = domain
+    end
+
+    # ------------------------------------------------------------------
+    # resolve domain
+    def match( parameter )
+      matchRule.is_a?( String ) ? parameter.name == matchRule  : (parameter.name =~ matchRule) != nil
+    end
+
+    # return true if domain resolved
+    def doApplyRule( parameter, model )
+      @logger.debug( "#{__method__} matchRule=#{matchRule}, matchRule.class=#{matchRule.class} on parameter.getName=#{parameter.getName}" )
+      
+      # no need to resolve domain  - Paramter_Ref?
+      return true unless parameter.respond_to?( :domain )
+
+      # its already read
+      return true if parameter.domain
+      if  match(  parameter ) then
+        @logger.info( "#{__method__} setDomain '#{domain}' on parameter '#{parameter.getName}' based on rule '#{matchRule}'" )
+        # 
+        parameter.setDomain( domain )
+        parameter.resolveDomain( model )
+        return true
+      end
+      return false
+    end
+
+
+
+  end
+end

data/lib/sbuilder/resolver_rule_ref.rb

@@ -0,0 +1,37 @@
+module Sbuilder
+
+  class ResolverRuleRef < ResolverRule
+
+
+    attr_reader :ref                         # reference to mapper
+    # ------------------------------------------------------------------
+    # mixer
+    PROGNAME = "ResolverRuleRef"                # progname for logger
+    include Sbuilder::Utils::MyLogger         # mix logger
+
+    # ------------------------------------------------------------------
+    # constrcutore
+    def initialize(  options = {} )
+      @logger = getLogger( PROGNAME, options )
+      @logger.info( "#{__method__} initialized" )
+      super( options )
+    end
+
+    # ------------------------------------------------------------------
+    # config
+    def setRef( mapperRef )
+      @ref = mapperRef
+      self
+    end
+
+    # ------------------------------------------------------------------
+    # resovele phase
+
+    def doApplyRule( parameter, model )
+      # delegate to mapper being refencence
+      ref.applyRule( parameter, model )
+    end
+
+  end # class
+end # module
+

data/lib/utils/hash_inject.rb

@@ -0,0 +1,12 @@
+# https://www.ruby-forum.com/topic/82661
+class Hash
+  alias :__fetch :[]
+
+  def traverse(*path)
+    path.inject(self) { |obj, item| obj.__fetch(item) || break }
+  end
+
+  def [](*args)
+    (args.length > 1) ? traverse(*args) : __fetch(*args)
+  end
+end

data/lib/utils/logger.rb

@@ -0,0 +1,80 @@
+require 'logger'
+
+# see http://hawkins.io/2013/08/using-the-ruby-logger/
+
+module Sbuilder
+  
+  module Utils
+    
+    module MyLogger
+
+      # no logging done
+
+      class NullLoger < Logger
+        def initialize(*args)
+        end
+
+        def add(*args, &block)
+        end
+
+        def debug?
+          false
+        end
+      end
+
+      @@logfile = nil                          # absolute path to log file
+      LOGFILE="sbuilder.log"
+
+      def logfile( options ) 
+        return @@logfile if @@logfile
+        @@logfile = options[:logfile] || File.join( Dir.getwd, LOGFILE )
+      end
+
+      def getLogger( progname, options={} ) 
+
+        level = get_level( options )
+
+        if level.nil? 
+
+          return NullLoger.new 
+
+        else
+          
+          logger = Logger.new( logfile(options) )
+          logger.level=level
+          logger.progname = progname
+          return logger
+
+        end 
+
+      end # getLogger
+
+      # ------------------------------------------------------------------
+      private
+
+      def get_level( options ) 
+
+        # puts  "#{__method__}: options=#{options}" 
+
+        level_name = options && options[:log] ? options[:log] : ENV['LOG_LEVEL']
+
+        level = case  level_name
+                when 'warn', 'WARN'
+                  Logger::WARN
+                when 'info', 'INFO'
+                  Logger::INFO
+                when 'debug', 'DEBUG'
+                  Logger::DEBUG
+                when 'error', 'ERROR'
+                  Logger::ERROR
+                else
+                  nil
+                end
+
+        return level
+      end
+
+    end
+
+  end 
+end

data/lib/utils/netio.rb

@@ -0,0 +1,58 @@
+require 'uri'
+require 'net/http'
+require 'open-uri'
+
+module Sbuilder
+  
+  module Utils
+    
+    class NetIo
+
+      class << self
+        
+        def uri_exist?( uri )
+          if uri =~ URI::regexp
+            url = URI.parse( uri )
+            Net::HTTP.start(url.host, url.port) { |http|
+              return http.head(url.request_uri).code == "200"
+            }
+          else
+            return File.exist?( uri )
+          end
+        end
+
+        # if  'cacheFile' return line in 'cacheFile else read from 'uri' &&  write to 'cacheFile'
+        def read_lines_cached( uri, cacheFile = nil  )
+          
+          # 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?
+
+          # 
+          return lines
+          
+        end
+
+        def read_lines( uri  )
+          begin
+            open( uri ).read
+          rescue => e
+            msg = "Error #{e}, when reading from uri '#{uri}'"
+            raise msg
+          end
+        end
+
+        # write lines in cache file
+        def cache_lines( cacheFile, lines  )
+          File.open( cacheFile, "w" ) { |f| f.write( lines ) }
+        end
+
+
+      end
+      
+    end
+  end
+end