glima 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5f7b67ff62c0d7d8ec231492f2c8231e5f83dbd
-  data.tar.gz: 16537a6a41967c56c017cc0fe541344c6d787cb6
+  metadata.gz: 27d1459f172ac0f758a2ee88cd5d99cb7f8b2daa
+  data.tar.gz: 933620cec4309b6ef67a6d845e3bd3adc6089b84
 SHA512:
-  metadata.gz: '089186482f1ac400e4a999523640c38e18ce5632676ba65e83a14968b25170beefde1073d1fbe6150c806454f2df609d17a4777dbf3dcfea1918e092260ab017'
-  data.tar.gz: 43e2325cbafdac0b0e243a1742191c77eadb76def1369ab364e42485e3d41ca010ad28bfc21fb27c41152660c4fcf4fa26cbd3280c98da3011228583cc1e5047
+  metadata.gz: f28c39166d7ba2f1ec4002140e2bb4a7120be0561334b38da9d63ab7ec02490abb2172f96b5646d03c3d23d458c02765d0cd76240ce674b01556e46a21a9e85f
+  data.tar.gz: 42c56a60f7cb35173827f1a91b50738cdddaed7db81bb796916bdf8cc5ff4335aeed1bff54b9458b257650301d4f5ee86e4623fa6a790777901bb9cac8cfc8d7

data/examples/config_example.yml

@@ -4,5 +4,5 @@ GENERAL:
   CLIENT_ID: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com"
   CLIENT_SECRET: "yyyyyyyyyyyyyyyyyyyyyyyy"
   TOKEN_STORE: "/Users/nom/.config/glima/token_store.yml"
-  CONTEXT_STORE: "/Users/nom/.config/glima/context.yml"
+  CONTEXT_STORE_PATH: "/Users/nom/.config/glima/context.yml"
   DEFAULT_USER: "????????@gmail.com"

data/exe/glima

@@ -23,19 +23,21 @@ if File.exists?(gemfile + ".lock")
 end
 
 require "rubygems"
+require "clian"
 require "glima"
 require "cgi"
 require "logger"
 
 Encoding.default_external="UTF-8"
 
-class GlimaCLI < Glima::Cli
+class GlimaCLI < Clian::Cli
   package_name 'GLIMA'
 
   ################################################################
   # global option
 
   class_option :profile,    :desc => "Set profiler flag", :type => :boolean
+  class_option :user,       :desc => "Set Gmail/IMAP account"
 
   ################################################################
   # register frequently used options
@@ -44,6 +46,20 @@ class GlimaCLI < Glima::Cli
   named_option :dry_run,    :desc => "Perform a trial run with no changes made", :type => :boolean
   named_option :query,      :desc => "Filter messages by QUERY"
 
+  ################################################################
+  # Command: auth
+  ################################################################
+  desc "auth", "Authenticate interactively"
+
+  def auth
+    conf = config.general
+    authorizer = Clian::Authorizer.new(conf.client_id,
+                                       conf.client_secret,
+                                       Google::Apis::GmailV1::AUTH_SCOPE,
+                                       conf.token_store_path)
+    authorizer.auth_interactively(@user)
+  end
+
   ################################################################
   # Command: dezip
   ################################################################
@@ -76,6 +92,18 @@ class GlimaCLI < Glima::Cli
     Glima::Command::Guess.new(message_id)
   end
 
+  ################################################################
+  # Command: init
+  ################################################################
+  desc "init", "Create new config file"
+
+  expand_option :config
+
+  def init
+    config_file = options[:config] || DEFAULT_CONFIG_PATH
+    Glima::Command::Init.new(config_file)
+  end
+
   ################################################################
   # Command: label
   ################################################################
@@ -218,18 +246,6 @@ class GlimaCLI < Glima::Cli
                              del_dst_labels: parse_label_names(options[:del_dst_labels]))
   end
 
-  ################################################################
-  # add some hooks to Thor
-
-  no_commands do
-    def invoke_command(command, *args)
-      setup_global_options unless command.name == "init"
-      result = super
-      teardown
-      result
-    end
-  end
-
   ################################################################
   # private
 
@@ -249,19 +265,19 @@ class GlimaCLI < Glima::Cli
     end
   end
 
-  attr_reader :builder, :config, :client, :context
+  attr_reader :builder, :config, :user, :context
 
-  def setup_global_options
+  def setup_global_options(command, *args)
     exit_on_error do
-      @config = Glima::Config.create_from_file(options[:config] || CONFIG_PATH)
+      @config = Glima::Config.create_from_file(options[:config] || DEFAULT_CONFIG_PATH) unless command.name == "init"
       @datastore = Glima::DataStore.new(File.expand_path("~/Mail"))
-      @client = Glima::GmailClient.new(config.general, @datastore)
-      @context = Glima::Context.new(File.expand_path(CONFIG_HOME))
+      @user   = options[:user] || config.general.default_user
+      @context = Glima::Context.new(File.expand_path(DEFAULT_CONFIG_HOME))
 
       logger = ::Logger.new($stderr)
       logger.formatter = proc {|severity, datetime, progname, msg| "#{msg}\n"}
 
-      Glima::Command.client = client
+      Glima::Command.client = client unless command.name == "auth"
       Glima::Command.logger = logger
       # Glima::GmailClient.logger = logger
 
@@ -276,6 +292,15 @@ class GlimaCLI < Glima::Cli
       end
     end
   end
+
+  def client
+    begin
+      @client ||= Glima::GmailClient.new(config.general, @user, @datastore)
+    rescue Glima::GmailClient::AuthorizationError
+      STDERR.print "Authorization Error: try ``glima auth'' command.\n"
+      exit(1)
+    end
+  end
 end
 
 def teardown

data/glima.gemspec

@@ -27,9 +27,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.3.0"
 
   spec.add_runtime_dependency "thor", ">= 0.19.1"
-  spec.add_runtime_dependency "google-api-client", ">0.9"
-  spec.add_runtime_dependency "googleauth"
-  spec.add_runtime_dependency "launchy"
+  spec.add_runtime_dependency "clian", ">= 0.3.0"
   spec.add_runtime_dependency "mail"
   spec.add_runtime_dependency "rubyzip"
 

data/lib/glima.rb

@@ -4,7 +4,6 @@ module Glima
 
   dir = File.dirname(__FILE__) + "/glima"
 
-  autoload :Cli,                  "#{dir}/cli.rb"
   autoload :Command,              "#{dir}/command.rb"
   autoload :Config,               "#{dir}/config.rb"
   autoload :Context,              "#{dir}/context.rb"

data/lib/glima/command.rb

@@ -21,6 +21,7 @@ module Glima
     autoload :Guess,       "#{dir}/guess.rb"
     autoload :Label,       "#{dir}/label.rb"
     autoload :Labels,      "#{dir}/labels.rb"
+    autoload :Init,        "#{dir}/init.rb"
     # autoload :Open,        "#{dir}/open.rb"
     autoload :Profile,     "#{dir}/profile.rb"
     autoload :Push,        "#{dir}/push.rb"

data/lib/glima/command/init.rb

@@ -0,0 +1,99 @@
+module Glima
+  module Command
+    class Init
+      TEMPLATE_DIR = File.expand_path("../../templates", __FILE__)
+
+      def initialize(config_file)
+        @shell = Thor.new
+        @status = {green: 0, yellow: 0, red: 0}
+        config = {}
+
+        config_dir = File.dirname(config_file)
+
+        if File.exists?(File.expand_path(config_file))
+          say_status "exist", "Ignore #{config_file}", :red
+          return
+        end
+
+        say "Creating #{config_file} ..."
+        say "Get your CLIENT_ID/CLIENT_SECRET at https://console.developers.google.com", :green
+        say "Googling 'Creating a Google API Console project and client ID' would help."
+
+        config[:client_id] = @shell.ask "CLIENT_ID:"
+        config[:client_secret] = @shell.ask "CLIENT_SECRET:"
+        config[:default_user] = @shell.ask "Gmail address:"
+        config[:token_store_path] = File.expand_path("token_store.yml", config_dir)
+
+        # mkdir
+        unless Dir.exist?(File.expand_path(config_dir))
+          say "Making config directory #{config_dir} ..."
+          mkdir_p(File.expand_path(config_dir))
+        end
+
+        # make config file from tamplate
+        say "Copying file(s) into #{config_file} ..."
+        src = File.expand_path("config.yml.erb", TEMPLATE_DIR)
+        dst = File.expand_path(config_file)
+        expand_template(src, dst, config)
+
+        say_status_report
+      end
+
+      private
+
+      def say(message, color = nil)
+        @shell.say(message, color)
+      end
+
+      def say_status(status, message, log_status = nil)
+        @status[log_status] += 1
+        @shell.say_status(status, message, log_status)
+      end
+
+      def say_status_report
+        if (errors = @status[:red]) > 0
+          say "#{errors} error(s) were occurred.", :red
+        else
+          say "done."
+        end
+      end
+
+      def expand_template(template_path, dest_path, config)
+        require "erb"
+        template = ERB.new(File.open(template_path).read, nil, "-")
+
+        if File.exists?(dest_path)
+          say_status "exist", "Ignore #{dest_path}", :yellow
+          return
+        end
+
+        begin
+          mkdir_p(File.expand_path("..", dest_path))
+          File.open(dest_path, "w", 0600) do |file|
+            file.write(template.result(binding))
+          end
+          say_status "ok", "copy #{dest_path}", :green
+        rescue StandardError => e
+          say_status "failed", "#{e.message.split(' @').first} #{dest_path}", :red
+        end
+      end
+
+      def mkdir_p(path)
+        path = File.expand_path(path)
+
+        if File.directory?(path)
+          say_status "exist", "Ignore #{path}", :yellow
+          return
+        end
+
+        begin
+          FileUtils.mkdir_p(path)
+          say_status "create", "#{path}", :green
+        rescue StandardError => e
+          say_status "failed", "#{e.message.split(' @').first} #{path}", :red
+        end
+      end
+
+    end # class Init
+  end # module Command
+end # module Glima

data/lib/glima/config.rb

@@ -1,205 +1,16 @@
-require 'yaml'
-require 'pp'
-
 module Glima
-  class Config
-    # Syntax table manipulation
-    class Syntax
-      def initialize(syntax_config)
-        @syntax_config = syntax_config
-      end
-
-      def keyword_symbols
-        @syntax_config.keys
-      end
-
-      def keywords
-        keyword_symbols.map {|sym| sym.to_s.upcase }
-      end
-
-      def keyword?(word)
-        if word.is_a?(Symbol)
-          keyword_symbols.member?(word)
-        else
-          # String
-          keywords.member?(word)
-        end
-      end
-
-      def instance_variable_name(word)
-        return nil unless keyword?(word)
-        return '@' + as_symbol(word).to_s
-      end
-
-      def item_class(word)
-        return nil unless keyword?(word)
-        @syntax_config[as_symbol(word)]
-      end
-
-      private
-      def as_symbol(word)
-        word.to_s.downcase.sub(/^@+/, "").to_sym
-      end
-    end # class Syntax
-
-    # Parse Key-Value object in YAML
-    class Base
-      # attr_accessor :name
-
-      def self.create_from_yaml_file(yaml_file)
-        yaml_string = File.open(File.expand_path(yaml_file)).read
-        return create_from_yaml_string(yaml_string, yaml_file)
-      end
-
-      def self.create_from_yaml_string(yaml_string, filename = nil)
-        hash = YAML.load(yaml_string, filename) || {}
-        return new(hash)
-      end
-
-      def self.define_syntax(config)
-        @syntax = Syntax.new(config)
-        @syntax.keyword_symbols.each do |sym|
-          attr_accessor sym # XXX: attr_reader is enough?
-        end
-      end
-
-      def self.syntax
-        return @syntax
-      end
-
-      def initialize(hash = {})
-        @original_hash = hash
-        (hash || {}).each do |key, val|
-          raise Glima::ConfigurationError, "config syntax error (#{key})" unless syntax.keyword?(key)
-          var = syntax.instance_variable_name(key)
-          obj = create_subnode(key, val)
-          instance_variable_set(var, obj)
-        end
-      end
-
-      attr_reader :original_hash
-
-      def get_value(dot_separated_string = nil)
-        if dot_separated_string.to_s == ""
-          return original_hash
-        end
-
-        key, subkey = dot_separated_string.to_s.upcase.split(".", 2)
-        subnode = get_subnode(key)
-
-        if subnode.respond_to?(:get_value)
-          return subnode.get_value(subkey)
-        else
-          return subnode.to_s
-        end
-      end
+  class Config < Clian::Config::Toplevel
 
-      def to_yaml
-        return self.to_hash.to_yaml
-      end
-
-      def to_hash
-        hash = {}
-        syntax.keywords.each do |key|
-          var = syntax.instance_variable_name(key)
-          obj = instance_variable_get(var)
-          obj = obj.respond_to?(:to_hash) ? obj.to_hash : obj.to_s
-          hash[key] = obj
-        end
-        return hash
-      end
-
-      private
-      def syntax
-        self.class.syntax
-      end
-
-      def get_subnode(key)
-        raise Glima::ConfigurationError, "Invalid key: #{key}" unless syntax.keyword?(key)
-        return instance_variable_get(syntax.instance_variable_name(key))
-      end
-
-      def create_subnode(keyword, value)
-        item_class = syntax.item_class(keyword)
-        if item_class.is_a?(Array)
-          return List.new(item_class.first, value)
-        elsif item_class == String
-          return value.to_s
-        else
-          return item_class.new(value)
-        end
-      end
-
-    end # class Base
-
-    # Parse Array object in YAML
-    class List < Base
-      include Enumerable
-
-      def initialize(item_class, array = [])
-        @original_hash = array
-        @configs = []
-        (array || []).each do |value|
-          item = item_class.new(value)
-          @configs << item
-        end
-      end
-
-      def [](key)
-        @configs.find {|c| c.name == key}
-      end
-
-      alias_method :get_subnode, :[]
-
-      def <<(conf)
-        @configs << conf
-      end
-
-      def to_hash # XXX: actually, it returns a Array
-        return @configs.map {|c| c.respond_to?(:to_hash) ? c.to_hash : c.to_s}
-      end
-
-      def each
-        @configs.each do |conf|
-          yield conf
-        end
-      end
-    end # List
-
-    ## concrete config classes
-
-    class General < Base
+    class General < Clian::Config::Element
       define_syntax :client_id => String,
                     :client_secret => String,
-                    :token_store => String,
+                    :token_store_path => String,
                     :context_store => String,
                     :zip_passwords_file => String,
                     :default_user => String
     end # class General
 
-    # Top-Level Config
-    class Top < Base
-      define_syntax :general => General
-    end # class Top
-
-    def self.create_from_file(file_name)
-      unless File.exists?(File.expand_path(file_name))
-        raise Glima::ConfigurationError, "config file '#{file_name}' not found"
-      end
-      begin
-        return Top.create_from_yaml_file(file_name)
-      rescue Psych::SyntaxError => e
-        raise Glima::ConfigurationError, e.message
-      end
-    end
-
-    def self.create_from_string(string)
-      begin
-        return Top.create_from_yaml_string(string)
-      rescue Psych::SyntaxError => e
-        raise Glima::ConfigurationError, e.message
-      end
-    end
+    define_syntax :general => General
 
-  end # class Config
-end # module Glima
+  end # Config
+end # Glima

data/lib/glima/gmail_client.rb

@@ -8,41 +8,9 @@ require 'forwardable'
 Google::Apis::RequestOptions.default.retries = 5
 
 module Glima
-  class Authorizer
-    def initialize(client_id, client_secret, scope, token_store_path)
-      @authorizer = Google::Auth::UserAuthorizer.new(
-        Google::Auth::ClientId.new(client_id, client_secret),
-        scope,
-        Google::Auth::Stores::FileTokenStore.new(file: token_store_path)
-      )
-    end
-
-    def credentials(user_id)
-      @authorizer.get_credentials(user_id)
-    end
-
-    def auth_interactively(user_id)
-      shell   = Thor.new.shell
-      oob_uri = "urn:ietf:wg:oauth:2.0:oob"
-
-      url = @authorizer.get_authorization_url(base_url: oob_uri)
-      begin
-        Launchy.open(url)
-      rescue
-        puts "Open URL in your browser:\n #{url}"
-      end
-
-      code = shell.ask "Enter the resulting code:"
-
-      @authorizer.get_and_store_credentials_from_code(
-        user_id:  user_id,
-        code:     code,
-        base_url: oob_uri
-      )
-    end
-  end # Authorizer
-
   class GmailClient
+    class AuthorizationError < StandardError ; end
+
     def self.logger
       Google::Apis.logger
     end
@@ -124,19 +92,21 @@ module Glima
       }.map(&:addr).map(&:ip_address).length > 0
     end
 
-    def initialize(config, datastore)
-      authorizer = Authorizer.new(config.client_id,
+    def initialize(config, user, datastore)
+      authorizer = Clian::Authorizer.new(config.client_id,
                                   config.client_secret,
                                   Google::Apis::GmailV1::AUTH_SCOPE,
-                                  config.token_store)
+                                  config.token_store_path)
+
+      unless credentials = authorizer.credentials(user)
+        raise AuthorizationError.new
+      end
 
-      credentials = authorizer.credentials(config.default_user) ||
-                    authorizer.auth_interactively(config.default_user)
       @datastore = datastore
       @client = Google::Apis::GmailV1::GmailService.new
       @client.client_options.application_name = 'glima'
       @client.authorization = credentials
-      @client.authorization.username = config.default_user # for IMAP
+      @client.authorization.username = user # for IMAP
 
       return @client
     end

data/lib/glima/templates/config.yml.erb

@@ -0,0 +1,7 @@
+################################################################
+GENERAL:
+################################################################
+  CLIENT_ID: "<%= config[:client_id] %>"
+  CLIENT_SECRET: "<%= config[:client_secret] %>"
+  TOKEN_STORE_PATH: "<%= config[:token_store_path] %>"
+  DEFAULT_USER: "<%= config[:default_user] %>"

data/lib/glima/version.rb

@@ -1,3 +1,3 @@
 module Glima
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glima
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Yoshinari Nomura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-18 00:00:00.000000000 Z
+date: 2017-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -25,47 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.19.1
 - !ruby/object:Gem::Dependency
-  name: google-api-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: googleauth
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: launchy
+  name: clian
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: mail
   requirement: !ruby/object:Gem::Requirement
@@ -157,11 +129,11 @@ files:
 - exe/glima
 - glima.gemspec
 - lib/glima.rb
-- lib/glima/cli.rb
 - lib/glima/command.rb
 - lib/glima/command/base.rb
 - lib/glima/command/dezip.rb
 - lib/glima/command/guess.rb
+- lib/glima/command/init.rb
 - lib/glima/command/label.rb
 - lib/glima/command/labels.rb
 - lib/glima/command/profile.rb
@@ -182,6 +154,7 @@ files:
 - lib/glima/resource/label.rb
 - lib/glima/resource/mail.rb
 - lib/glima/resource/message.rb
+- lib/glima/templates/config.yml.erb
 - lib/glima/version.rb
 - lib/glima/zip.rb
 - spec/glima_spec.rb

data/lib/glima/cli.rb

@@ -1,151 +0,0 @@
-require "thor"
-
-module Glima
-  class Cli < Thor
-    ################################################################
-    # config files
-
-    CONFIG_HOME = File.join((ENV["XDG_CONFIG_HOME"] || "~/.config"), basename)
-    CONFIG_FILE = "config.yml"
-    CONFIG_PATH = File.join(CONFIG_HOME, CONFIG_FILE)
-
-    def self.config_home ; CONFIG_HOME; end
-    def self.config_path ; CONFIG_PATH; end
-
-    ################################################################
-    # register preset options
-
-    def self.named_option(name, options)
-      @named_options ||= {}
-      @named_options[name] = options
-    end
-
-    def self.expand_option(*names)
-      expand_named_option(:method, *names)
-    end
-
-    def self.expand_class_option(*names)
-      expand_named_option(:class, *names)
-    end
-
-    def self.expand_named_option(type, *names)
-      names.each do |name|
-        options = @named_options[name]
-        if type == :class
-          class_option name, options
-        else
-          method_option name, options
-        end
-      end
-    end
-    private_class_method :expand_named_option
-
-    named_option :debug,   :desc => "Set debug flag", :type => :boolean
-    named_option :profile, :desc => "Set profiler flag", :type => :boolean
-    named_option :config,  :desc => "Set config path (default: #{CONFIG_PATH})", :banner => "FILE"
-    named_option :dry_run, :desc => "Perform a trial run with no changes made", :type => :boolean
-
-    ################################################################
-    # command name mappings
-
-    map ["--version", "-v"] => :version
-
-    map ["--help", "-h"] => :help
-
-    default_command :help
-
-    ################################################################
-    # Command: help
-    ################################################################
-
-    desc "help [COMMAND]", "Describe available commands or one specific command"
-
-    def help(command = nil)
-      super(command)
-    end
-
-    ################################################################
-    # Command: version
-    ################################################################
-    desc "version", "Show version"
-
-    def version
-      puts Glima::VERSION
-    end
-
-    ################################################################
-    # Command: completions
-    ################################################################
-    check_unknown_options! :except => :completions
-
-    desc "completions [COMMAND]", "List available commands or options for COMMAND", :hide => true
-
-    long_desc <<-LONGDESC
-      List available commands or options for COMMAND
-      This is supposed to be a zsh compsys helper"
-    LONGDESC
-
-    def completions(*command)
-      help = self.class.commands
-      global_options = self.class.class_options
-      Glima::Command::Completions.new(help, global_options, command, config)
-    end
-
-    ################################################################
-    # add some hooks to Thor
-
-    no_commands do
-      def invoke_command(command, *args)
-        setup_global_options unless command.name == "init"
-        result = super
-        teardown
-        result
-      end
-    end
-
-    ################################################################
-    # private
-
-    private
-
-    def exit_on_error(&block)
-      begin
-        yield if block_given?
-      rescue Glima::ConfigurationError => e
-        STDERR.print "ERROR: #{e.message}.\n"
-        exit 1
-      end
-    end
-
-    attr_reader :builder, :config, :client, :context, :datastore
-
-    def setup_global_options
-      exit_on_error do
-        if options[:profile]
-          require 'profiler'
-          Profiler__.start_profile
-        end
-        if options[:debug]
-          require "pp"
-          $GLIMA_DEBUG = true
-          $GLIMA_DEBUG_FOR_DEVELOPER = true if ENV["GLIMA_DEBUG_FOR_DEVELOPER"]
-        end
-      end
-    end
-
-    def load_plugins
-      config_path = options[:config] || CONFIG_PATH
-      plugin_dir  = File.dirname(config_path)
-
-      Dir.glob(File.expand_path("plugins/*.rb", plugin_dir)) do |rb|
-        require rb
-      end
-    end
-
-    def teardown
-      if options[:profile]
-        Profiler__.print_profile($stdout)
-      end
-    end
-  end
-end