Class: Erubis::Main

Class | Erubis::Main
In: | erubis/main.rb
Parent: | Object

main class of command

ex.

      Main.main(ARGV)

### Methods

execute main new

### Public Class methods

main(argv=ARGV)

[Source]

    # File erubis/main.rb, line 39
        def self.main(argv=ARGV)
          status = 0
          begin
            Main.new.execute(ARGV)
          rescue CommandOptionError => ex
            $stderr.puts ex.message
            status = 1
          end
          exit(status)
        end

new()

[Source]

    # File erubis/main.rb, line 50
        def initialize
          @single_options = "hvxztTSbeBXNUC"
          @arg_options    = "pcrfKIlaE" #C
          @option_names   = {
            'h' => :help,
            'v' => :version,
            'x' => :source,
            'z' => :syntax,
            'T' => :unexpand,
            't' => :untabify,      # obsolete
            'S' => :intern,
            'b' => :bodyonly,
            'B' => :binding,
            'p' => :pattern,
            'c' => :context,
            #'C' => :class,
            'e' => :escape,
            'r' => :requires,
            'f' => :datafiles,
            'K' => :kanji,
            'I' => :includes,
            'l' => :lang,
            'a' => :action,
            'E' => :enhancers,
            'X' => :notext,
            'N' => :linenum,
            'U' => :unique,
            'C' => :compact,
          }
          assert unless @single_options.length + @arg_options.length == @option_names.length
          (@single_options + @arg_options).each_byte do |ch|
            assert unless @option_names.key?(ch.chr)
          end
        end

### Public Instance methods

execute(argv=ARGV)

[Source]

    # File erubis/main.rb, line 86
        def execute(argv=ARGV)
          ## parse command-line options
          options, properties = parse_argv(argv, @single_options, @arg_options)
          filenames = argv
          options['h'] = true if properties[:help]
          opts = Object.new
          arr = @option_names.collect {|ch, name| "def #{name}; @#{name}; end\n" }
          opts.instance_eval arr.join
          options.each do |ch, val|
            name = @option_names[ch]
            opts.instance_variable_set("@#{name}", val)
          end

          ## help, version, enhancer list
          if opts.help || opts.version
            puts version()         if opts.version
            puts usage()           if opts.help
            puts show_properties() if opts.help
            puts show_enhancers()  if opts.help
            return
          end

          ## include path
          opts.includes.split(/,/).each do |path|
            $: << path
          end if opts.includes

          ## require library
          opts.requires.split(/,/).each do |library|
            require library
          end if opts.requires

          ## action
          action = opts.action
          action ||= 'syntax'  if opts.syntax
          action ||= 'convert' if opts.source || opts.notext

          ## lang
          lang = opts.lang || 'ruby'
          action ||= 'convert' if opts.lang

          ## class name of Eruby
          #classname = opts.class
          classname = nil
          klass = get_classobj(classname, lang, properties[:pi])

          ## kanji code
          $KCODE = opts.kanji if opts.kanji

          ## read context values from yaml file
          datafiles = opts.datafiles
          context = load_datafiles(datafiles, opts)

          ## parse context data
          if opts.context
            context = parse_context_data(opts.context, opts)
          end

          ## properties for engine
          properties[:escape]   = true         if opts.escape && !properties.key?(:escape)
          properties[:pattern]  = opts.pattern if opts.pattern
          #properties[:trim]     = false        if opts.notrim
          properties[:preamble] = properties[:postamble] = false if opts.bodyonly
          properties[:pi]       = nil          if properties[:pi] == true

          ## create engine and extend enhancers
          engine = klass.new(nil, properties)
          enhancers = get_enhancers(opts.enhancers)
          #enhancers.push(Erubis::EscapeEnhancer) if opts.escape
          enhancers.each do |enhancer|
            engine.extend(enhancer)
            engine.bipattern = properties[:bipattern] if enhancer == Erubis::BiPatternEnhancer
          end

          ## no-text
          engine.extend(Erubis::NoTextEnhancer) if opts.notext

          ## convert and execute
          val = nil
          msg = "Syntax OK\n"
          if filenames && !filenames.empty?
            filenames.each do |filename|
              File.file?(filename)  or
                raise CommandOptionError.new("#{filename}: file not found.")
              engine.filename = filename
              engine.convert!(File.read(filename))
              val = do_action(action, engine, context, filename, opts)
              msg = nil if val
            end
          else
            engine.filename = filename = '(stdin)'
            engine.convert!($stdin.read())
            val = do_action(action, engine, context, filename, opts)
            msg = nil if val
          end
          print msg if action == 'syntax' && msg

        end

[Validate]