iisconfig 0.0.1.pre2 → 0.0.1.pre3

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/lib/erubis/error.rb

@@ -1,23 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-module Erubis
-
-
-  ##
-  ## base error class
-  ##
-  class ErubisError < StandardError
-  end
-
-
-  ##
-  ## raised when method or function is not supported
-  ##
-  class NotSupportedError < ErubisError
-  end
-
-
-end

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/lib/erubis/evaluator.rb

@@ -1,88 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-require 'erubis/error'
-require 'erubis/context'
-
-
-module Erubis
-
-  EMPTY_BINDING = binding()
-
-
-  ##
-  ## evaluate code
-  ##
-  module Evaluator
-
-    def self.supported_properties    # :nodoc:
-      return []
-    end
-
-    attr_accessor :src, :filename
-
-    def init_evaluator(properties)
-      @filename = properties[:filename]
-    end
-
-    def result(*args)
-      raise NotSupportedError.new("evaluation of code except Ruby is not supported.")
-    end
-
-    def evaluate(*args)
-      raise NotSupportedError.new("evaluation of code except Ruby is not supported.")
-    end
-
-  end
-
-
-  ##
-  ## evaluator for Ruby
-  ##
-  module RubyEvaluator
-    include Evaluator
-
-    def self.supported_properties    # :nodoc:
-      list = Evaluator.supported_properties
-      return list
-    end
-
-    ## eval(@src) with binding object
-    def result(_binding_or_hash=TOPLEVEL_BINDING)
-      _arg = _binding_or_hash
-      if _arg.is_a?(Hash)
-        _b = binding()
-        eval _arg.collect{|k,v| "#{k} = _arg[#{k.inspect}]; "}.join, _b
-      elsif _arg.is_a?(Binding)
-        _b = _arg
-      elsif _arg.nil?
-        _b = binding()
-      else
-        raise ArgumentError.new("#{self.class.name}#result(): argument should be Binding or Hash but passed #{_arg.class.name} object.")
-      end
-      return eval(@src, _b, (@filename || '(erubis'))
-    end
-
-    ## invoke context.instance_eval(@src)
-    def evaluate(_context=Context.new)
-      _context = Context.new(_context) if _context.is_a?(Hash)
-      #return _context.instance_eval(@src, @filename || '(erubis)')
-      #@_proc ||= eval("proc { #{@src} }", Erubis::EMPTY_BINDING, @filename || '(erubis)')
-      @_proc ||= eval("proc { #{@src} }", binding(), @filename || '(erubis)')
-      return _context.instance_eval(&@_proc)
-    end
-
-    ## if object is an Class or Module then define instance method to it,
-    ## else define singleton method to it.
-    def def_method(object, method_name, filename=nil)
-      m = object.is_a?(Module) ? :module_eval : :instance_eval
-      object.__send__(m, "def #{method_name}; #{@src}; end", filename || @filename || '(erubis)')
-    end
-
-
-  end
-
-
-end

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/lib/erubis/generator.rb

@@ -1,85 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-require 'erubis/util'
-
-module Erubis
-
-
-  ##
-  ## code generator, called by Converter module
-  ##
-  module Generator
-
-    def self.supported_properties()  # :nodoc:
-      return [
-              [:escapefunc,    nil,    "escape function name"],
-            ]
-    end
-
-    attr_accessor :escapefunc
-
-    def init_generator(properties={})
-      @escapefunc = properties[:escapefunc]
-    end
-
-
-    ## (abstract) escape text string
-    ##
-    ## ex.
-    ##   def escape_text(text)
-    ##     return text.dump
-    ##     # or return "'" + text.gsub(/['\\]/, '\\\\\&') + "'"
-    ##   end
-    def escape_text(text)
-      not_implemented
-    end
-
-    ## return escaped expression code (ex. 'h(...)' or 'htmlspecialchars(...)')
-    def escaped_expr(code)
-      code.strip!
-      return "#{@escapefunc}(#{code})"
-    end
-
-    ## (abstract) add @preamble to src
-    def add_preamble(src)
-      not_implemented
-    end
-
-    ## (abstract) add text string to src
-    def add_text(src, text)
-      not_implemented
-    end
-
-    ## (abstract) add statement code to src
-    def add_stmt(src, code)
-      not_implemented
-    end
-
-    ## (abstract) add expression literal code to src. this is called by add_expr().
-    def add_expr_literal(src, code)
-      not_implemented
-    end
-
-    ## (abstract) add escaped expression code to src. this is called by add_expr().
-    def add_expr_escaped(src, code)
-      not_implemented
-    end
-
-    ## (abstract) add expression code to src for debug. this is called by add_expr().
-    def add_expr_debug(src, code)
-      not_implemented
-    end
-
-    ## (abstract) add @postamble to src
-    def add_postamble(src)
-      not_implemented
-    end
-
-
-  end
-
-
-end

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/lib/erubis/helper.rb

@@ -1,47 +0,0 @@
-##
-## $Release: 2.7.0 $
-## copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-##
-
-
-module Erubis
-
-  ##
-  ## helper for xml
-  ##
-  module XmlHelper
-
-    module_function
-
-    ESCAPE_TABLE = {
-      '&' => '&',
-      '<' => '&lt;',
-      '>' => '&gt;',
-      '"' => '&quot;',
-      "'" => '&#039;',
-    }
-
-    def escape_xml(value)
-      value.to_s.gsub(/[&<>"]/) { |s| ESCAPE_TABLE[s] }   # or /[&<>"']/
-      #value.to_s.gsub(/[&<>"]/) { ESCAPE_TABLE[$&] }
-    end
-
-    def escape_xml2(value)
-      return value.to_s.gsub(/\&/,'&amp;').gsub(/</,'&lt;').gsub(/>/,'&gt;').gsub(/"/,'&quot;')
-    end
-
-    alias h escape_xml
-    alias html_escape escape_xml
-
-    def url_encode(str)
-      return str.gsub(/[^-_.a-zA-Z0-9]+/) { |s|
-        s.unpack('C*').collect { |i| "%%%02X" % i }.join
-      }
-    end
-
-    alias u url_encode
-
-  end
-
-
-end

data/build/bundler/ruby/1.9.1/gems/erubis-2.7.0/lib/erubis/helpers/rails_form_helper.rb

@@ -1,197 +0,0 @@
-###
-### $Release: 2.7.0 $
-### copyright(c) 2006-2011 kuwata-lab.com all rights reserved.
-###
-
-
-module Erubis
-  module Helpers
-    module RailsFormHelper
-    end
-  end
-end
-
-
-module Erubis::Helpers::RailsFormHelper
-
-
-if ActionPack::VERSION::MAJOR == 1   ###  Rails 1.X
-  def pp_template_filename(basename)
-    return "#{RAILS_ROOT}/app/views/#{controller.controller_name}/#{basename}.rhtml"
-  end
-else                                 ###  Rails 2.X
-  def pp_template_filename(basename)
-    fname = "#{RAILS_ROOT}/app/views/#{controller.controller_name}/#{basename}.html.erb"
-    return fname if test(?f, fname)
-    return  "#{RAILS_ROOT}/app/views/#{controller.controller_name}/#{basename}.rhtml"
-  end
-end
-
-  def pp_render_partial(basename)
-    basename = "_#{basename}" unless basename[0] == ?_
-    filename = pp_template_filename(basename)
-    preprocessor = _create_preprocessor(File.read(filename))
-    return preprocessor.evaluate(_preprocessing_context_object())
-  end
-
-  def pp_error_on(object_name, method)
-    s = ''
-    s << "<% _stag, _etag = _pp_error_tags(@#{object_name}.errors.on('#{method}')) %>"
-    s << "<%= _stag %>"
-    s << yield(object_name, method)
-    s << "<%= _etag %>"
-    return s
-  end
-
-  def _pp_error_tags(value)
-    return value ? ['<div class="fieldWithErrors">', '</div>'] : ['', '']
-  end
-
-  def _pp_remove_error_div(s)
-    s.sub!(/\A<div class="fieldWithErrors">(.*)<\/div>\z/, '\1')
-    return s
-  end
-
-  def pp_tag_helper(helper, object_name, method, options={})
-    if object_name.is_a?(ActionView::Helpers::FormHelper)
-      object_name = object_name.object_name
-    end
-    unless options.key?(:value) || options.key?('value')
-      options['value'] = _?("h @#{object_name}.#{method}")
-    end
-    #$stderr.puts "*** debug: pp_tag_helper(): options=#{options.inspect}"
-    return pp_error_on(object_name, method) {
-      s = __send__(helper, object_name, method, options)
-      _pp_remove_error_div(s)
-    }
-  end
-
-  def pp_form_tag(url_for_options={}, options={}, *parameters_for_url, &block)
-    return form_tag(url_for_options, options, *parameters_for_url, &block)
-  end
-
-  #--
-  #def pp_form_for(object_name, *args, &block)
-  #  return form_for(object_name, *args, &block)
-  #end
-  #++
-
-  def pp_text_field(object_name, method, options={})
-    return pp_tag_helper(:text_field, object_name, method, options)
-  end
-
-  def pp_password_field(object_name, method, options={})
-    return pp_tag_helper(:password_field, object_name, method, options)
-  end
-
-  def pp_hidden_field(object_name, method, options={})
-    return pp_tag_helper(:hidden_field, object_name, method, options)
-  end
-
-  def pp_file_field(object_name, method, options={})
-    return pp_tag_helper(:file_field, object_name, method, options)
-  end
-
-  def pp_text_area(object_name, method, options={})
-    return pp_tag_helper(:text_area, object_name, method, options)
-  end
-
-  def pp_check_box(object_name, method, options={}, checked_value="1", unchecked_value="0")
-    s = check_box(object_name, method, options, checked_value, unchecked_value)
-    s.sub!(/\schecked=\"checked\"/, '')
-    s.sub!(/type="checkbox"/, "\\&<%= _pp_check_box_checked?(@#{object_name}.#{method}, #{checked_value.inspect}) ? ' checked=\"checked\"' : '' %>")
-    return pp_error_on(object_name, method) { _pp_remove_error_div(s) }
-  end
-
-  def _pp_check_box_checked?(value, checked_value)
-    return ActionView::Helpers::InstanceTag::check_box_checked?(value, checked_value)
-  end
-
-  def pp_radio_button(object_name, method, tag_value, options={})
-    s = radio_button(object_name, method, tag_value, options)
-    s.sub!(/\schecked=\"checked\"/, '')
-    s.sub!(/type="radio"/, "\\&<%= _pp_radio_button_checked?(@#{object_name}.#{method}, #{tag_value.inspect}) ? ' checked=\"checked\"' : '' %>")
-    return pp_error_on(object_name, method) { _pp_remove_error_div(s) }
-  end
-
-  def _pp_radio_button_checked?(value, tag_value)
-    return ActionView::Helpers::InstanceTag::radio_button_checked?(value, tag_value)
-  end
-
-  def _pp_select(object, method, collection, priority_collection, options={}, html_options={})
-    return pp_error_on(object, method) do
-      s = ""
-      ## start tag
-      s << "<select id=\"#{object}_#{method}\" name=\"#{object}[#{method}]\""
-      for key, val in html_options:
-          s << " #{key}=\"#{val}\""
-      end
-      s << ">\n"
-      ## selected table
-      key = options.key?(:value) ? :value : (options.key?('value') ? 'value' : nil)
-      if    key.nil?                ;  selected = "@#{object}.#{method}"
-      elsif (val=options[key]).nil? ;  selected = nil
-      elsif val =~ /\A<%=(.*)%>\z/  ;  selected = $1
-      else                          ;  selected = val.inspect
-      end
-      s << "<% _table = {#{selected}=>' selected=\"selected\"'} %>\n" if selected
-      ## <option> tags
-      if options[:include_blank] || options['include_blank']
-        s << "<option value=\"\"></option>\n"
-      end
-      unless priority_collection.blank?
-        _pp_select_options(s, priority_collection, selected, 'delete')
-        s << "<option value=\"\">-------------</option>\n"
-      end
-      _pp_select_options(s, collection, selected, '[]')
-      ## end tag
-      s << "</select>"
-      s
-    end
-  end
-
-  def _pp_select_options(s, collection, selected, operator)
-    for item in collection
-      value, text = item.is_a?(Array) ? item : [item, item]
-      if !selected
-        t = ''
-      elsif operator == 'delete'
-        t = "<%= _table.delete(#{value.inspect}) %>"
-      else
-        t = "<%= _table[#{value.inspect}] %>"
-      end
-      s << "<option value=\"#{h value}\"#{t}>#{h text}</option>\n"
-    end
-  end
-
-  def pp_select(object, method, collection, options={}, html_options={})
-    return _pp_select(object, method, collection, nil, options, html_options)
-  end
-
-  def pp_collection_select(object, method, collection, value_method, text_method, options={}, html_options={})
-    collection2 = collection.collect { |e|
-      [e.__send__(value_method), e.__send__(text_method)]
-    }
-    return _pp_select(object, method, collection2, nil, options, html_options)
-  end
-
-  def pp_country_select(object, method, priority_countries=nil, options={}, html_options={})
-    collection = ActionView::Helpers::FormOptionsHelper::COUNTRIES
-    return _pp_select(object, method, collection, priority_countries, options, html_options)
-  end
-
-  def pp_time_zone_select(object, method, priority_zones=nil, options={}, html_options={})
-    model = options[:model] || options['model'] || TimeZone
-    collection = model.all.collect { |e| [e.name, e.to_s] }
-    return _pp_select(object, method, collection, priority_zones, options, html_options)
-  end
-
-  def pp_submit_tag(value="Save changes", options={})
-    return submit_tag(value, options)
-  end
-
-  def pp_image_submit_tag(source, options={})
-    return image_submit_tag(source, options)
-  end
-
-end