rango 0.1.pre → 0.1.0

data/vendor/erubis/lib/erubis/helpers/rails_helper.rb

@@ -1,325 +0,0 @@
-###
-### $Rev: 112 $
-### $Release: 2.6.2 $
-### copyright(c) 2006-2008 kuwata-lab.com all rights reserved.
-###
-
-
-require 'erubis'
-require 'erubis/preprocessing'
-
-
-module Erubis
-
-  class Eruby
-    include ErboutEnhancer      # will generate '_erbout = _buf = ""; '
-  end
-
-  class FastEruby
-    include ErboutEnhancer      # will generate '_erbout = _buf = ""; '
-  end
-
-  module Helpers
-
-    ##
-    ## helper module for Ruby on Rails
-    ##
-    ## howto:
-    ##
-    ## 1. add the folliwng code in your 'config/environment.rb'
-    ##
-    ##      require 'erubis/helpers/rails_helper'
-    ##      #Erubis::Helpers::RailsHelper.engine_class = Erubis::Eruby # or Erubis::FastEruby
-    ##      #Erubis::Helpers::RailsHelper.init_properties = {}
-    ##      #Erubis::Helpers::RailsHelper.show_src = false       # set true for debugging
-    ##      #Erubis::Helpers::RailsHelper.preprocessing = true   # set true to enable preprocessing
-    ##
-    ## 2. restart web server.
-    ##
-    ## if Erubis::Helper::Rails.show_src is true, Erubis prints converted Ruby code
-    ## into log file ('log/development.log' or so). if false, it doesn't.
-    ## if nil, Erubis prints converted Ruby code if ENV['RAILS_ENV'] == 'development'.
-    ##
-    module RailsHelper
-
-      #cattr_accessor :init_properties
-      @@engine_class = ::Erubis::Eruby
-      #@@engine_class = ::Erubis::FastEruby
-      def self.engine_class
-        @@engine_class
-      end
-      def self.engine_class=(klass)
-        @@engine_class = klass
-      end
-
-      #cattr_accessor :init_properties
-      @@init_properties = {}
-      def self.init_properties
-        @@init_properties
-      end
-      def self.init_properties=(hash)
-        @@init_properties = hash
-      end
-
-      #cattr_accessor :show_src
-      @@show_src = nil
-      def self.show_src
-        @@show_src
-      end
-      def self.show_src=(flag)
-        @@show_src = flag
-      end
-
-      #cattr_accessor :preprocessing
-      @@preprocessing = false
-      def self.preprocessing
-        @@preprocessing
-      end
-      def self.preprocessing=(flag)
-        @@preprocessing = flag
-      end
-
-
-      ## define class for backward-compatibility
-      class PreprocessingEruby < Erubis::PreprocessingEruby   # :nodoc:
-      end
-
-
-      module TemplateConverter
-        ## covert eRuby string into ruby code
-        def _convert_template(template)    # :nodoc:
-          #src = ::Erubis::Eruby.new(template).src
-          klass      = ::Erubis::Helpers::RailsHelper.engine_class
-          properties = ::Erubis::Helpers::RailsHelper.init_properties
-          show_src   = ::Erubis::Helpers::RailsHelper.show_src
-          show_src = ENV['RAILS_ENV'] == 'development' if show_src.nil?
-          ## preprocessing
-          if ::Erubis::Helpers::RailsHelper.preprocessing
-            preprocessor = _create_preprocessor(template)
-            template = preprocessor.evaluate(_preprocessing_context_object())
-            logger.info "** Erubis: preprocessed==<<'END'\n#{template}END\n" if show_src
-          end
-          ## convert into ruby code
-          src = klass.new(template, properties).src
-          #src.insert(0, '_erbout = ')
-          logger.info "** Erubis: src==<<'END'\n#{src}END\n" if show_src
-          return src
-        end
-        def _create_preprocessor(template)
-          return PreprocessingEruby.new(template, :escape=>true)
-        end
-        def _preprocessing_context_object
-          return self
-        end
-      end
-
-    end
-
-  end
-
-end
-
-
-class ActionView::Base   # :nodoc:
-  include ::Erubis::Helpers::RailsHelper::TemplateConverter
-  include ::Erubis::PreprocessingHelper
-  private
-  # convert template into ruby code
-  def convert_template_into_ruby_code(template)
-    #ERB.new(template, nil, @@erb_trim_mode).src
-    return _convert_template(template)
-  end
-end
-
-
-require 'action_pack/version'
-
-
-if ActionPack::VERSION::MAJOR >= 2             ### Rails 2.X
-
-
-  if ActionPack::VERSION::MINOR >=1            ### Rails 2.1 or higher
-
-    module ActionView
-      module TemplateHandlers # :nodoc:
-        class ErubisHandler < TemplateHandler
-          include Compilable
-          include Erubis::Helpers::RailsHelper::TemplateConverter
-          include Erubis::PreprocessingHelper
-          #
-          def compile(template)
-            return _convert_template(template.source)   # template.is_a?(ActionView::Template)
-          end
-          def logger  #:nodoc:
-            return @view.controller.logger
-          end
-          def _preprocessing_context_object  #:nodoc:
-            return @view.controller.instance_variable_get('@template')
-          end
-          #
-          def cache_fragment(block, name = {}, options = nil) #:nodoc:
-            @view.fragment_for(block, name, options) do
-              #eval(ActionView::Base.erb_variable, block.binding)
-              eval('_buf', block.binding)
-            end
-          end
-        end
-      end
-      handler_klass = TemplateHandlers::ErubisHandler
-      Template.register_default_template_handler :erb, handler_klass
-      Template.register_template_handler :rhtml, handler_klass
-    end
-
-  elsif ActionPack::VERSION::TINY >= 2         ### Rails 2.0.X (X >= 2)
-
-    module ActionView
-      module TemplateHandlers # :nodoc:
-        class ErubisHandler < TemplateHandler
-          include Erubis::Helpers::RailsHelper::TemplateConverter
-          include Erubis::PreprocessingHelper
-          def compile(template)
-            return _convert_template(template)     # template.is_a?(String)
-          end
-          def logger  #:nodoc:
-            return @view.controller.logger
-          end
-          def _preprocessing_context_object  #:nodoc:
-            return @view.controller.instance_variable_get('@template')
-          end
-        end
-      end
-      Base.class_eval do
-        handler_klass = TemplateHandlers::ErubisHandler
-        register_default_template_handler :erb, handler_klass
-        register_template_handler :rhtml, handler_klass
-      end
-    end
-
-  else                                         ### Rails 2.0.0 or 2.0.1
-
-    class ActionView::Base   # :nodoc:
-      private
-      # Method to create the source code for a given template.
-      def create_template_source(extension, template, render_symbol, locals)
-        if template_requires_setup?(extension)
-          body = case extension.to_sym
-            when :rxml, :builder
-              content_type_handler = (controller.respond_to?(:response) ? "controller.response" : "controller")
-              "#{content_type_handler}.content_type ||= Mime::XML\n" +
-              "xml = Builder::XmlMarkup.new(:indent => 2)\n" +
-              template +
-              "\nxml.target!\n"
-            when :rjs
-              "controller.response.content_type ||= Mime::JS\n" +
-              "update_page do |page|\n#{template}\nend"
-          end
-        else
-          #body = ERB.new(template, nil, @@erb_trim_mode).src
-          body = convert_template_into_ruby_code(template)
-        end
-        #
-        @@template_args[render_symbol] ||= {}
-        locals_keys = @@template_args[render_symbol].keys | locals
-        @@template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h }
-        #
-        locals_code = ""
-        locals_keys.each do |key|
-          locals_code << "#{key} = local_assigns[:#{key}]\n"
-        end
-        #
-        "def #{render_symbol}(local_assigns)\n#{locals_code}#{body}\nend"
-      end
-    end
-
-  end #if
-
-
-else                                           ###  Rails 1.X
-
-
-  if ActionPack::VERSION::MINOR > 12           ###  Rails 1.2
-
-    class ActionView::Base   # :nodoc:
-      private
-      # Create source code for given template
-      def create_template_source(extension, template, render_symbol, locals)
-        if template_requires_setup?(extension)
-          body = case extension.to_sym
-            when :rxml
-              "controller.response.content_type ||= 'application/xml'\n" +
-              "xml = Builder::XmlMarkup.new(:indent => 2)\n" +
-              template
-            when :rjs
-              "controller.response.content_type ||= 'text/javascript'\n" +
-              "update_page do |page|\n#{template}\nend"
-          end
-        else
-          #body = ERB.new(template, nil, @@erb_trim_mode).src
-          body = convert_template_into_ruby_code(template)
-        end
-        #
-        @@template_args[render_symbol] ||= {}
-        locals_keys = @@template_args[render_symbol].keys | locals
-        @@template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h }
-        #
-        locals_code = ""
-        locals_keys.each do |key|
-          locals_code << "#{key} = local_assigns[:#{key}]\n"
-        end
-        #
-        "def #{render_symbol}(local_assigns)\n#{locals_code}#{body}\nend"
-      end
-    end
-
-  else                                         ###  Rails 1.1
-
-    class ActionView::Base   # :nodoc:
-      private
-      # Create source code for given template
-      def create_template_source(extension, template, render_symbol, locals)
-        if template_requires_setup?(extension)
-          body = case extension.to_sym
-            when :rxml
-              "xml = Builder::XmlMarkup.new(:indent => 2)\n" +
-              "@controller.headers['Content-Type'] ||= 'application/xml'\n" +
-              template
-            when :rjs
-              "@controller.headers['Content-Type'] ||= 'text/javascript'\n" +
-              "update_page do |page|\n#{template}\nend"
-          end
-        else
-          #body = ERB.new(template, nil, @@erb_trim_mode).src
-          body = convert_template_into_ruby_code(template)
-        end
-        #
-        @@template_args[render_symbol] ||= {}
-        locals_keys = @@template_args[render_symbol].keys | locals
-        @@template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h }
-        #
-        locals_code = ""
-        locals_keys.each do |key|
-          locals_code << "#{key} = local_assigns[:#{key}] if local_assigns.has_key?(:#{key})\n"
-        end
-        #
-        "def #{render_symbol}(local_assigns)\n#{locals_code}#{body}\nend"
-      end
-    end
-
-  end #if
-
-  ## make h() method faster (only for Rails 1.X)
-  module ERB::Util  # :nodoc:
-    ESCAPE_TABLE = { '&'=>'&amp;', '<'=>'&lt;', '>'=>'&gt;', '"'=>'&quot;', "'"=>'&#039;', }
-    def h(value)
-      value.to_s.gsub(/[&<>"]/) {|s| ESCAPE_TABLE[s] }
-    end
-    module_function :h
-  end
-
-end   ###
-
-
-## finish
-ac = ActionController::Base.new
-ac.logger.info "** Erubis #{::Erubis::VERSION}"
-#$stdout.puts "** Erubis #{::Erubis::VERSION}"

data/vendor/erubis/lib/erubis/local-setting.rb

@@ -1,10 +0,0 @@
-##
-## $Rev: 77 $
-## $Release: 2.6.2 $
-## copyright(c) 2006-2008 kuwata-lab.com all rights reserved.
-##
-
-##
-## you can add site-local settings here.
-## this files is required by erubis.rb
-##

data/vendor/erubis/lib/erubis/main.rb

@@ -1,491 +0,0 @@
-###
-### $Rev: 116 $
-### $Release: 2.6.2 $
-### copyright(c) 2006-2008 kuwata-lab.com all rights reserved.
-###
-
-require 'yaml'
-require 'erubis'
-require 'erubis/tiny'
-require 'erubis/engine/enhanced'
-require 'erubis/engine/optimized'
-require 'erubis/engine/eruby'
-require 'erubis/engine/ephp'
-require 'erubis/engine/ec'
-require 'erubis/engine/ejava'
-require 'erubis/engine/escheme'
-require 'erubis/engine/eperl'
-require 'erubis/engine/ejavascript'
-
-
-module Erubis
-
-
-  Ejs = Ejavascript
-  EscapedEjs = EscapedEjavascript
-
-
-  class CommandOptionError < ErubisError
-  end
-
-
-  ##
-  ## main class of command
-  ##
-  ## ex.
-  ##   Main.main(ARGV)
-  ##
-  class Main
-
-    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
-
-    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
-
-
-    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|
-          test(?f, 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
-
-    private
-
-    def do_action(action, engine, context, filename, opts)
-      case action
-      when 'convert'
-        s = manipulate_src(engine.src, opts)
-      when nil, 'exec', 'execute'
-        s = opts.binding ? engine.result(context.to_hash) : engine.evaluate(context)
-      when 'syntax'
-        s = check_syntax(filename, engine.src)
-      else
-        raise "*** internal error"
-      end
-      print s if s
-      return s
-    end
-
-    def manipulate_src(source, opts)
-      flag_linenum   = opts.linenum
-      flag_unique    = opts.unique
-      flag_compact   = opts.compact
-      if flag_linenum
-        n = 0
-        source.gsub!(/^/) { n += 1; "%5d:  " % n }
-        source.gsub!(/^ *\d+:\s+?\n/, '')      if flag_compact
-        source.gsub!(/(^ *\d+:\s+?\n)+/, "\n") if flag_unique
-      else
-        source.gsub!(/^\s*?\n/, '')      if flag_compact
-        source.gsub!(/(^\s*?\n)+/, "\n") if flag_unique
-      end
-      return source
-    end
-
-    def usage(command=nil)
-      command ||= File.basename($0)
-      buf = []
-      buf << "erubis - embedded program converter for multi-language"
-      buf << "Usage: #{command} [..options..] [file ...]"
-      buf << "  -h, --help    : help"
-      buf << "  -v            : version"
-      buf << "  -x            : show converted code"
-      buf << "  -X            : show converted code, only ruby code and no text part"
-      buf << "  -N            : numbering: add line numbers            (for '-x/-X')"
-      buf << "  -U            : unique: compress empty lines to a line (for '-x/-X')"
-      buf << "  -C            : compact: remove empty lines            (for '-x/-X')"
-      buf << "  -b            : body only: no preamble nor postamble   (for '-x/-X')"
-      buf << "  -z            : syntax checking"
-      buf << "  -e            : escape (equal to '--E Escape')"
-      buf << "  -p pattern    : embedded pattern (default '<% %>')"
-      buf << "  -l lang       : convert but no execute (ruby/php/c/java/scheme/perl/js)"
-      buf << "  -E e1,e2,...  : enhancer names (Escape, PercentLine, BiPattern, ...)"
-      buf << "  -I path       : library include path"
-      buf << "  -K kanji      : kanji code (euc/sjis/utf8) (default none)"
-      buf << "  -c context    : context data string (yaml inline style or ruby code)"
-      buf << "  -f datafile   : context data file ('*.yaml', '*.yml', or '*.rb')"
-      #buf << "  -t            : expand tab characters in YAML file"
-      buf << "  -T            : don't expand tab characters in YAML file"
-      buf << "  -S            : convert mapping key from string to symbol in YAML file"
-      buf << "  -B            : invoke 'result(binding)' instead of 'evaluate(context)'"
-      buf << "  --pi=name     : parse '<?name ... ?>' instead of '<% ... %>'"
-      #'
-      #  -T            : don't trim spaces around '<% %>'
-      #  -c class      : class name (XmlEruby/PercentLineEruby/...) (default Eruby)
-      #  -r library    : require library
-      #  -a            : action (convert/execute)
-      return buf.join("\n")
-    end
-
-    def collect_supported_properties(erubis_klass)
-      list = []
-      erubis_klass.ancestors.each do |klass|
-        if klass.respond_to?(:supported_properties)
-          list.concat(klass.supported_properties)
-        end
-      end
-      return list
-    end
-
-    def show_properties
-      s = "supported properties:\n"
-      basic_props = collect_supported_properties(Erubis::Basic::Engine)
-      pi_props    = collect_supported_properties(Erubis::PI::Engine)
-      list = []
-      common_props = basic_props & pi_props
-      list << ['(common)', common_props]
-      list << ['(basic)',  basic_props - common_props]
-      list << ['(pi)',     pi_props    - common_props]
-      %w[ruby php c java scheme perl javascript].each do |lang|
-        klass = Erubis.const_get("E#{lang}")
-        list << [lang, collect_supported_properties(klass) - basic_props]
-      end
-      list.each do |lang, props|
-        s << "  * #{lang}\n"
-        props.each do |name, default_val, desc|
-          s << ("     --%-23s : %s\n" % ["#{name}=#{default_val.inspect}", desc])
-        end
-      end
-      s << "\n"
-      return s
-    end
-
-    def show_enhancers
-      s = "enhancers:\n"
-      list = []
-      ObjectSpace.each_object(Module) do |m| list << m end
-      list.sort_by { |m| m.name.to_s }.each do |m|
-        next unless m.name =~ /\AErubis::(.*)Enhancer\z/
-        name = $1
-        desc = m.desc
-        s << ("  %-13s : %s\n" % [name, desc])
-      end
-      return s
-    end
-
-    def version
-      return Erubis::VERSION
-    end
-
-    def parse_argv(argv, arg_none='', arg_required='', arg_optional='')
-      options = {}
-      context = {}
-      while argv[0] && argv[0][0] == ?-
-        optstr = argv.shift
-        optstr = optstr[1, optstr.length-1]
-        #
-        if optstr[0] == ?-    # context
-          unless optstr =~ /\A\-([-\w]+)(?:=(.*))?/
-            raise CommandOptionError.new("-#{optstr}: invalid context value.")
-          end
-          name = $1;  value = $2
-          name  = name.gsub(/-/, '_').intern
-          #value = value.nil? ? true : YAML.load(value)   # error, why?
-          value = value.nil? ? true : YAML.load("---\n#{value}\n")
-          context[name] = value
-          #
-        else                  # options
-          while optstr && !optstr.empty?
-            optchar = optstr[0].chr
-            optstr[0,1] = ""
-            if arg_none.include?(optchar)
-              options[optchar] = true
-            elsif arg_required.include?(optchar)
-              arg = optstr.empty? ? argv.shift : optstr
-              unless arg
-                mesg = "-#{optchar.chr}: #{@option_args[optchar]} required."
-                raise CommandOptionError.new(mesg)
-              end
-              options[optchar] = arg
-              optstr = nil
-            elsif arg_optional.include?(optchar)
-              arg = optstr.empty? ? true : optstr
-              options[optchar] = arg
-              optstr = nil
-            else
-              raise CommandOptionError.new("-#{optchar.chr}: unknown option.")
-            end
-          end
-        end
-        #
-      end  # end of while
-
-      return options, context
-    end
-
-
-    def untabify(str, width=8)
-      list = str.split(/\t/)
-      last = list.pop
-      sb = ''
-      list.each do |s|
-        column = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
-        n = width - (column % width)
-        sb << s << (' ' * n)
-      end
-      sb << last
-      return sb
-    end
-    #--
-    #def untabify(str, width=8)
-    #  sb = ''
-    #  str.scan(/(.*?)\t/m) do |s, |
-    #    len = (n = s.rindex(?\n)) ? s.length - n - 1 : s.length
-    #    sb << s << (" " * (width - len % width))
-    #  end
-    #  return $' ? (sb << $') : str
-    #end
-    #++
-
-
-    def get_classobj(classname, lang, pi)
-      classname ||= "E#{lang}"
-      base_module = pi ? Erubis::PI : Erubis
-      begin
-        klass = base_module.const_get(classname)
-      rescue NameError
-        klass = nil
-      end
-      unless klass
-        if lang
-          msg = "-l #{lang}: invalid language name (class #{base_module.name}::#{classname} not found)."
-        else
-          msg = "-c #{classname}: invalid class name."
-        end
-        raise CommandOptionError.new(msg)
-      end
-      return klass
-    end
-
-    def get_enhancers(enhancer_names)
-      return [] unless enhancer_names
-      enhancers = []
-      shortname = nil
-      begin
-        enhancer_names.split(/,/).each do |shortname|
-          enhancers << Erubis.const_get("#{shortname}Enhancer")
-        end
-      rescue NameError
-        raise CommandOptionError.new("#{shortname}: no such Enhancer (try '-E' to show all enhancers).")
-      end
-      return enhancers
-    end
-
-    def load_datafiles(filenames, opts)
-      context = Erubis::Context.new
-      return context unless filenames
-      filenames.split(/,/).each do |filename|
-        filename.strip!
-        test(?f, filename) or raise CommandOptionError.new("#{filename}: file not found.")
-        if filename =~ /\.ya?ml$/
-          if opts.unexpand
-            ydoc = YAML.load_file(filename)
-          else
-            ydoc = YAML.load(untabify(File.read(filename)))
-          end
-          ydoc.is_a?(Hash) or raise CommandOptionError.new("#{filename}: root object is not a mapping.")
-          intern_hash_keys(ydoc) if opts.intern
-          context.update(ydoc)
-        elsif filename =~ /\.rb$/
-          str = File.read(filename)
-          context2 = Erubis::Context.new
-          _instance_eval(context2, str)
-          context.update(context2)
-        else
-          CommandOptionError.new("#{filename}: '*.yaml', '*.yml', or '*.rb' required.")
-        end
-      end
-      return context
-    end
-
-    def _instance_eval(_context, _str)
-      _context.instance_eval(_str)
-    end
-
-    def parse_context_data(context_str, opts)
-      if context_str[0] == ?{
-        require 'yaml'
-        ydoc = YAML.load(context_str)
-        unless ydoc.is_a?(Hash)
-          raise CommandOptionError.new("-c: root object is not a mapping.")
-        end
-        intern_hash_keys(ydoc) if opts.intern
-        return ydoc
-      else
-        context = Erubis::Context.new
-        context.instance_eval(context_str, '-c')
-        return context
-      end
-    end
-
-    def intern_hash_keys(obj, done={})
-      return if done.key?(obj.__id__)
-      case obj
-      when Hash
-        done[obj.__id__] = obj
-        obj.keys.each do |key|
-          obj[key.intern] = obj.delete(key) if key.is_a?(String)
-        end
-        obj.values.each do |val|
-          intern_hash_keys(val, done) if val.is_a?(Hash) || val.is_a?(Array)
-        end
-      when Array
-        done[obj.__id__] = obj
-        obj.each do |val|
-          intern_hash_keys(val, done) if val.is_a?(Hash) || val.is_a?(Array)
-        end
-      end
-    end
-
-    def check_syntax(filename, src)
-      require 'open3'
-      command = (ENV['_'] || 'ruby') + ' -wc'   # ENV['_'] stores command name
-      stdin, stdout, stderr = Open3.popen3(command)
-      stdin.write(src)
-      stdin.close
-      result = stdout.read()
-      stdout.close()
-      errmsg = stderr.read()
-      stderr.close()
-      return nil unless errmsg && !errmsg.empty?
-      errmsg =~ /\A-:(\d+): /
-      linenum, message = $1, $'
-      return "#{filename}:#{linenum}: #{message}"
-    end
-
-  end
-
-end