xlogin 0.13.10 → 0.14.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 719819143a56b26ad14b31cbe6e61ed9d4df208c36dc9c060709bce170974d43
-  data.tar.gz: e0d20e9e5cd5967cacb28a8d92bd0f342bd5ecf47e591e9b7b3fb6257e6d5690
+  metadata.gz: cdbb386674deee491268f35a9d5ca46c721391068d693a68d9a3e289e0168f97
+  data.tar.gz: b6afba886c65c3744253d58e0d8eccda3c265cf168159d95f3504408962127ce
 SHA512:
-  metadata.gz: ce9b1a9bd127b38edd212875887773264019eb25a137eb4f84793b284671915246b2055d5e36c85a0d65d9350910262e642940f5f71d78400e6dffa8addaf4a8
-  data.tar.gz: d57ea13b2a0fd0aee2e332cf941e4cf596253297695932944dda3a310932e50be72a9fd0ea099adce2c9784ac55da91c92c781d5b74d3238f418334796eb23f4
+  metadata.gz: edf8a747bff259718090617554b0d0868a3a3f321c287b328be882ac4dc68f9cbd2943755e55a1772525647bbfc485e849ac56495bed49a92b3a76cfb5bb4d1d
+  data.tar.gz: 5d699b1d3982c7cf1a7bd4cd19ef174acf27885ac5e38fc4f10f746efd99b8e1e3deea523f52b901f9d4cdb80440aae5dd532abde1d41aa09c7548e07198a838

data/lib/xlogin.rb

@@ -22,7 +22,7 @@ module Xlogin
 
   class << self
     def list(*patterns)
-      factory.list_inventory(*patterns)
+      factory.list_hostinfo(*patterns)
     end
 
     def find(*patterns)
@@ -34,7 +34,7 @@ module Xlogin
                 when Hash   then factory.build(**args.merge(**opts))
                 when String then factory.build_from_hostname(args, **opts)
                 else
-                  raise SessionError.new("Invalid argument: '#{args}'")
+                  raise Xlogin::Error.new("Invalid argument: '#{args}'")
                 end
 
       return session unless block
@@ -59,16 +59,16 @@ module Xlogin
     end
 
     def generate_templates(dir)
-      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      FileUtils.mkdir_p(dir)
       builtin_templates = Dir.glob(File.join(File.dirname(__FILE__), 'xlogin', 'templates', '*.rb'))
-      builtin_templates.each { |file| FileUtils.cp(file, DEFAULT_TEMPLATE_DIR) }
+      builtin_templates.each{ |file| FileUtils.cp(file, DEFAULT_TEMPLATE_DIR) }
     end
 
-    private
     def factory
       @factory ||= Xlogin::Factory.instance
     end
 
+    private
     def set(opts = {})
       @settings ||= {}
       opts.each do |key, val|

data/lib/xlogin/cli.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'optparse'
 require 'parallel'
 require 'stringio'
@@ -7,30 +5,32 @@ require 'stringio'
 module Xlogin
   class CLI
 
-    DEFAULT_INVENTORY_FILE = File.join(ENV['HOME'], '.xloginrc')
-    DEFAULT_TEMPLATE_DIR   = File.join(ENV['HOME'], '.xlogin.d')
+    DEFAULT_INVENTORY = File.join(ENV['HOME'], '.xloginrc')
+    DEFAULT_TEMPLATE  = File.join(ENV['HOME'], '.xlogin.d')
 
     def self.run(args = ARGV)
       Xlogin::CLI.new.run(args)
     end
 
     def list(config)
-      puts Xlogin.list(*config[:pattern]).map { |e| e[:name] }.sort.uniq
+      puts Xlogin.list(*config[:patterns]).map{ |e| e[:name] }.sort.uniq
     end
 
     def tty(config)
-      info = Xlogin.list(*config[:pattern]).shift
+      info = Xlogin.find(*config[:patterns])
       puts "Trying #{info[:name]}...", "Escape character is '^]'."
-      session, _ = exec(config.merge(pattern: info[:name], jobs: 1))
+
+      session, _ = exec(config.merge(patterns: info[:name], jobs: 1))
       session.interact!
     end
 
     def exec(config)
-      Signal.trap(:INT) { exit 0 }
+      Signal.trap(:INT){ exit 1 }
 
       jobs  = config[:jobs] || 1
-      hosts = Xlogin.list(*config[:pattern])
-      width = hosts.map { |e| e[:name].length }.max
+      hosts = Xlogin.list(*config[:patterns])
+      width = hosts.map{ |e| e[:name].length }.max
+      raise "No host found: `#{config[:patterns].join(', ')}`" if hosts.empty?
 
       Parallel.map(hosts, in_threads: jobs) do |info|
         buffer  = StringIO.new
@@ -40,17 +40,17 @@ module Xlogin
         begin
           loggers  = []
           loggers << ((jobs > 1)? buffer : $stdout)
-          loggers << File.expand_path(File.join(config[:"log-dir"], "#{info[:name]}.log"), ENV['PWD']) if config[:"log-dir"]
+          loggers << File.expand_path(File.join(config[:logdir], "#{info[:name]}.log"), ENV['PWD']) if config[:logdir]
 
           session = Xlogin.get(info.merge(log: loggers))
-          session.enable(info[:enable]) if info[:enable] && Xlogin.settings.enable?
+          session.enable(session.config.enable) if session.config.enable && Xlogin.settings.enable?
 
-          command_lines = ['', *config[:exec].to_s.split(';').map(&:strip)]
-          command_lines.each { |line| session.cmd(line) }
+          command_lines = config[:command].flat_map { |e| e.to_s.split(';').map(&:strip) }
+          command_lines.each{ |line| session.cmd(line) }
 
-          buffer.string.lines.each { |line| print prefix + line.gsub("\r", '') } if jobs > 1
+          buffer.string.lines.each{ |line| print prefix + line.gsub(/^.*\r/, '') } if jobs > 1
         rescue => e
-          buffer.string.lines.each { |line| print prefix + line.gsub("\r", '') } if jobs > 1
+          buffer.string.lines.each{ |line| print prefix + line.gsub(/^.*\r/, '') } if jobs > 1
           raise e
         end
 
@@ -60,34 +60,38 @@ module Xlogin
 
     def run(args)
       config = Hash.new
-      config[:env]       = {}
+      config[:env]       = []
+      config[:inventory] = []
+      config[:template]  = []
+      config[:command]   = []
       config[:runner]    = self.method(:tty)
-      config[:inventory] = DEFAULT_INVENTORY_FILE
-      config[:template]  = DEFAULT_TEMPLATE_DIR
 
       parser = OptionParser.new
       parser.banner  = "#{File.basename($0)} HOST_PATTERN [Options]"
       parser.version = Xlogin::VERSION
 
-      parser.on('-i PATH', '--inventory', String, 'The PATH to the inventory file.')
-      parser.on('-t PATH', '--template',  String, 'The PATH to the template file or directory.')
-      parser.on('-L PATH', '--log-dir',   String, 'The PATH to the log directory.') { |v| v || '.' }
+      parser.on('-i PATH', '--inventory', String, 'The PATH to the inventory file.')            { |v| config[:inventory] << v }
+      parser.on('-t PATH', '--template',  String, 'The PATH to the template file or directory.'){ |v| config[:template]  << v }
+      parser.on('-L PATH', '--log-dir',   String, 'The PATH to the log directory.')             { |v| config[:logdir]     = v }
 
-      parser.on('-l',         '--list',   TrueClass, 'List the inventory.')        { |v| config[:runner] = self.method(:list) }
-      parser.on('-e COMMAND', '--exec',   String,    'Execute commands and quit.') { |v| config[:runner] = self.method(:exec); v }
+      parser.on('-l',         '--list',   TrueClass, 'List the inventory.')       { |v| config[:runner] = self.method(:list) }
+      parser.on('-e COMMAND', '--exec',   String,    'Execute commands and quit.'){ |v| config[:runner] = self.method(:exec); config[:command] << v }
 
-      parser.on('-E KEY=VAL', '--env',    /(\w+=\w+)+/, 'Environment variables.')
-      parser.on('-j NUM',     '--jobs',   Integer,      'The NUM of jobs to execute in parallel.')
+      parser.on('-E KEY=VAL', '--env',    /(\w+=\w+)+/, 'Environment variables.')                 { |v| config[:env] << v }
+      parser.on('-j NUM',     '--jobs',   Integer,      'The NUM of jobs to execute in parallel.'){ |v| config[:jobs] = v }
 
-      config[:pattern] = parser.parse!(args, into: config)
+      config[:patterns]  = parser.parse!(args)
+      config[:inventory] << DEFAULT_INVENTORY if config[:inventory].empty?
+      config[:template]  << DEFAULT_TEMPLATE  if config[:template].empty?
 
       Xlogin.configure do
-        set      Hash[config[:env].map{ |v| v.split('=') }]
-        source   File.expand_path(config[:inventory], ENV['PWD'])
-        template File.expand_path(config[:template],  ENV['PWD'])
+        set Hash[config[:env].map{ |v| v.split('=') }]
+
+        source   *config[:inventory].map{ |e| File.expand_path(e, ENV['PWD']) }
+        template *config[:template].map { |e| File.expand_path(e, ENV['PWD']) }
       end
-      raise "No host found: `#{args.join(', ')}`" if Xlogin.list(*config[:pattern]).empty?
 
+      raise Xlogin::Error.new("Invalid host pattern: '#{config[:patterns].join(' ')}'") if Xlogin.list(*config[:patterns]).empty?
       config[:runner].call(config)
     rescue => e
       $stderr.puts e, '', parser

data/lib/xlogin/factory.rb

@@ -1,5 +1,7 @@
 require 'addressable/uri'
+require 'net/ssh/gateway'
 require 'singleton'
+require 'thread'
 require 'xlogin/session_pool'
 require 'xlogin/template'
 
@@ -9,30 +11,32 @@ module Xlogin
     include Singleton
 
     def initialize
-      @inventory    = Hash.new
-      @templates    = Hash.new
+      @inventory = Hash.new
+      @templates = Hash.new
+      @gateways  = Hash.new
+      @mutex     = Mutex.new
     end
 
-    def set_inventory(name, **opts)
-      @inventory[name] = (get_inventory(name) || {name: name}).merge(opts)
+    def set_hostinfo(name, **opts)
+      @inventory[name] = (get_hostinfo(name) || {name: name}).merge(opts)
     end
 
-    def get_inventory(name)
+    def get_hostinfo(name)
       @inventory[name]
     end
 
-    def list_inventory(*patterns)
+    def list_hostinfo(*patterns)
       return @inventory.values if patterns.empty?
 
-      values1 = patterns.map do |pattern|
+      values1 = patterns.compact.map do |pattern|
         values2 = pattern.split(',').map do |entry|
           key, val = entry.to_s.split(':')
           key, val = 'name', key if val.nil?
-          @inventory.values.select { |e| File.fnmatch(val, e[key.to_sym]) }
+          @inventory.values.select{ |e| File.fnmatch(val, e[key.to_sym]) }
         end
-        values2.reduce(&:&)
+        values2.reduce(&:&) || []
       end
-      values1.reduce(&:|)
+      values1.reduce(&:|) || []
     end
 
     def set_template(name, text = nil, &block)
@@ -50,6 +54,35 @@ module Xlogin
       @templates.keys
     end
 
+    def open_tunnel(tunnel, host, port)
+      @mutex.synchronize do
+        unless @gateways[tunnel]
+          gateway_uri = Addressable::URI.parse(tunnel)
+          case gateway_uri.scheme
+          when 'ssh'
+            username, password = *gateway_uri.userinfo.split(':')
+            @gateways[tunnel] = Net::SSH::Gateway.new(
+              gateway_uri.host,
+              username,
+              password: password,
+              port: gateway_uri.port || 22
+            )
+          end
+        end
+
+        gateway = @gateways[tunnel]
+        return host, port unless gateway
+        return '127.0.0.1', gateway.open(host, port)
+      end
+    end
+
+    def close_tunnel(tunnel, port)
+      @mutex.synchronize do
+        gateway = @gateways[tunnel]
+        gateway.close(port) if gateway
+      end
+    end
+
     def build(type:, **opts)
       template = get_template(type)
       raise Xlogin::Error.new("Template not found: '#{type}'") unless template
@@ -62,31 +95,25 @@ module Xlogin
     end
 
     def build_from_hostname(args, **opts)
-      hostinfo = get_inventory(args)
+      hostinfo = get_hostinfo(args)
       raise Xlogin::Error.new("Host not found: '#{args}'") unless hostinfo
 
-      build(hostinfo.merge(name: args, **opts))
+      build(**hostinfo.merge(**opts))
     end
 
     def method_missing(method_name, *args, **opts, &block)
-      super unless args.size == 2 && %r{^\S+://\S+} =~ args[1]
+      super unless args.size == 2 && Addressable::URI::URIREGEX =~ args[1]
 
-      type = method_name.to_s.downcase
       name = args[0]
       uri  = args[1]
-      set_inventory(name, type: type, uri: uri, **opts)
+      type = method_name.to_s.downcase
+      set_hostinfo(name.to_s, type: type, uri: uri, **opts)
     end
 
     private
     def uri(**opts)
       return Addressable::URI.parse(opts[:uri].strip) if opts.key?(:uri)
-
-      scheme   = opts[:scheme].strip
-      address  = opts.values_at(:host, :port).compact.map(&:strip).join(':')
-      userinfo = opts[:userinfo].strip
-      userinfo ||= opts.values_at(:username, :password).compact.map(&:strip).join(':')
-
-      Addressable::URI.parse("#{scheme}://" + [userinfo, address].compact.join('@'))
+      Addressable::URI.new(**opts)
     rescue
       raise Xlogin::Error.new("Invalid target - '#{opts}'")
     end

data/lib/xlogin/rake_task.rb

@@ -1,7 +1,6 @@
 require 'time'
 require 'rake'
 require 'rake/tasklib'
-require 'ostruct'
 require 'stringio'
 require 'colorize'
 
@@ -13,11 +12,11 @@ module Xlogin
 
       def generate(*patterns, **opts, &block)
         description = Rake.application.last_description
-        hostnames   = Xlogin.list(*patterns).map { |e| e[:name] }
+        hostnames   = Xlogin.list(*patterns).map{ |e| e[:name] }
 
         task 'all' => hostnames unless opts[:all] == false
         hostnames.each do |hostname|
-          desc "#{description} @#{hostname}" if opts[:all] == false
+          desc "#{description} with #{hostname}"
           RakeTask.new(hostname, &block)
         end
       end
@@ -32,8 +31,8 @@ module Xlogin
     end
 
     attr_reader   :name
-    attr_accessor :lock
     attr_accessor :log
+    attr_accessor :lock
     attr_accessor :timeout
     attr_accessor :silent
     attr_accessor :fail_on_error
@@ -49,8 +48,8 @@ module Xlogin
       define
     end
 
-    def name_with_scope
-      [*Rake.application.current_scope.to_a.reverse, name].join(':')
+    def name_with_scope(separator = ':')
+      [*Rake.application.current_scope.to_a.reverse, name].join(separator)
     end
 
     def run(&block)
@@ -78,47 +77,41 @@ module Xlogin
     end
 
     def run_task
-      buffer = StringIO.new
-
-      logger = log ? [log] : []
-      logger.push buffer
-      logger.push $stdout if !silent && !Rake.application.options.always_multitask
+      buffer  = StringIO.new
+      loggers = []
+      loggers << log     if log
+      loggers << $stdout if !silent && !Rake.application.options.always_multitask
+      loggers << buffer
 
-      session = Xlogin.get(name, log: logger, timeout: timeout)
+      session = Xlogin.get(name, log: loggers, timeout: timeout)
 
       @runner.call(session)
-      $stdout.print format_log(buffer.string) if !silent && Rake.application.options.always_multitask
+      $stdout.print log_text(buffer.string) if !silent && Rake.application.options.always_multitask
 
       return true
     rescue => e
       RakeTask.shutdown! if fail_on_error
 
-      buffer.puts("\n[ERROR] #{e}".colorize(color: :white, background: :red))
-      $stderr.print "\n" + format_log(buffer.string.chomp).colorize(color: :light_red)
-      $stderr.print "\n"
+      session.comment(e.to_s, prefix: "[ERROR]", chomp: true, color: :white, background: :red)
+      $stderr.print log_text(buffer.string + "\n").colorize(color: :light_red) if Rake.application.options.always_multitask
 
       return false
     ensure
       session.close rescue nil
     end
 
-    def format_log(text)
-      text.lines.map do |line|
-        "#{Time.now.iso8601} - #{name}\t|#{line.gsub(/^\s*[\r]+/, '')}"
-      end.join
+    def log_text(text)
+      text.lines.map{ |line| "#{Time.now.iso8601} - #{name}\t|#{line.gsub(/^.*\r/, '')}" }.join
     end
 
   end
 
   module SessionModule
-    def msg(text, prefix: "[INFO]", chomp: false, **color)
-      default_color = { color: :green }
 
-      log("\n")
-      log(Time.now.iso8601.colorize(**color) + ' ') if !Rake.application.options.always_multitask
-
-      log("#{prefix} #{text}".colorize(**default_color.merge(color)))
+    def comment(line, prefix: "[INFO]", chomp: false, **color)
+      write_log("#{prefix} #{line}".colorize({color: :light_white}.merge(**color)))
       cmd('') unless chomp
     end
+
   end
 end

data/lib/xlogin/session.rb

@@ -1,14 +1,11 @@
-require 'addressable/uri'
-require 'delegate'
 require 'fileutils'
-require 'net/ssh/gateway'
-require 'ostruct'
 require 'stringio'
 require 'thread'
 
 module Xlogin
   module SessionModule
 
+    attr_reader   :config
     attr_accessor :name
 
     def initialize(template, uri, **opts)
@@ -21,16 +18,14 @@ module Xlogin
                 end
 
       @name     = opts[:name] || @host
-      @config   = OpenStruct.new(opts)
+      @tunnel   = opts[:tunnel] || opts[:via]
+      @config   = ReadOnlyStruct.new(opts)
       @template = template
-      @username, @password = uri.userinfo.to_s.split(':')
+      @loggers  = [@config.log].flatten.uniq.reduce({}){ |a, e| a.merge(e => build_log(e)) }
+      @host, @port = Xlogin.factory.open_tunnel(@tunnel, @host, @port) if @tunnel
 
-      forward = @config.forward || @config.via
-      ssh_tunnel(forward) if forward
       max_retry = @config.retry || 1
-
-      @mutex   = Mutex.new
-      @loggers = [@config.log].flatten.uniq.reduce({}) { |a, e| a.merge(e => build_logger(e)) }
+      username, password = uri.userinfo.to_s.split(':')
 
       begin
         args = Hash.new
@@ -42,8 +37,8 @@ module Xlogin
         else
           args['Host'    ] = @host
           args['Port'    ] = @port
-          args['Username'] = @username
-          args['Password'] = @password
+          args['Username'] = username
+          args['Password'] = password
         end
 
         super(args)
@@ -63,47 +58,54 @@ module Xlogin
     end
 
     def prompt_pattern
-      Regexp.union(*@template.prompt.map(&:first))
+      Regexp.union(*@template.prompts.map(&:first))
     end
 
     def duplicate(type: @template.name, **args)
       template = Xlogin::Factory.instance.get_template(type)
+      raise Xlogin::Error.new("Template not found: '#{type}'") unless template
+
       template.build(@uri, **@config.to_h.merge(args))
     end
 
-    def puts(*args, &block)
-      args = args.flat_map { |arg| instance_exec(arg, &@template.interrupt!) }.compact if @template.interrupt!
-      args.empty? ? super('', &block) : super(*args, &block)
+    def puts(string = '', &block)
+      super(string, &block)
     end
 
-    def waitfor(*args, &block)
-      args = [prompt_pattern] if args.empty?
-      @mutex.synchronize { _waitfor(*args, &block) }
+    def print(string = '', &block)
+      string = instance_exec(string, &@template.interrupt!) if @template.interrupt!
+      super(string, &block)
     end
 
-    def close
-      logout if respond_to?(:logout)
-      @mutex.synchronize do
-        @loggers.each do |_, logger|
-          next if logger.nil? || [$stdout, $stderr].include?(logger)
-          logger.close
-        end
+    def waitfor(*args, &block)
+      return waitfor(prompt_pattern) if args.empty?
 
-        if @gateway
-          @gateway.close(@port)
-          @gateway.shutdown!
-        end
+      line = super(*args) do |recv|
+        write_log(recv)
+        block.call(recv) if block
+      end
 
-        super
+      _, process = @template.prompts.find{ |r, p| r =~ line && p }
+      if process
+        instance_eval(&process)
+        line += waitfor(*args, &block)
       end
+
+      return line
     end
 
-    def log(text)
-      @loggers.each { |_, logger| logger.syswrite(text) if logger }
+    def close
+      @loggers.each do |_, logger|
+        next if [$stdout, $stderr, nil].include?(logger)
+        logger.close
+      end
+
+      Xlogin.factory.close_tunnel(@tunnel, @port) if @tunnel
+      super
     end
 
     def enable_log(log = $stdout)
-      @loggers.update(log => build_logger(log))
+      @loggers.update(log => build_log(log))
       if block_given?
         yield
         disable_log(log)
@@ -119,40 +121,11 @@ module Xlogin
     end
 
     private
-    def _waitfor(*args, &block)
-      __waitfor = method(:waitfor).super_method
-      line = __waitfor.call(*args) do |recv|
-        log(recv)
-        block.call(recv) if block
-      end
-
-      _, process = @template.prompt.find { |r, p| r =~ line && p }
-      if process
-        instance_eval(&process)
-        line += _waitfor(*args, &block)
-      end
-
-      return line
-    end
-
-    def ssh_tunnel(gateway)
-      gateway_uri = Addressable::URI.parse(gateway)
-      case gateway_uri.scheme
-      when 'ssh'
-        username, password = *gateway_uri.userinfo.split(':')
-        @gateway = Net::SSH::Gateway.new(
-          gateway_uri.host,
-          username,
-          password: password,
-          port: gateway_uri.port || 22
-        )
-
-        @port = @gateway.open(@host, @port)
-        @host = '127.0.0.1'
-      end
+    def write_log(text)
+      @loggers.each{ |_, logger| logger.syswrite(text) if logger }
     end
 
-    def build_logger(log)
+    def build_log(log)
       case log
       when String
         FileUtils.mkdir_p(File.dirname(log))

data/lib/xlogin/session_pool.rb

@@ -22,23 +22,23 @@ module Xlogin
     end
 
     def size=(val)
-      @mutex.synchronize { @size = val }
+      @mutex.synchronize{ @size = val }
     end
 
     def idle=(val)
-      @mutex.synchronize { @idle = val }
+      @mutex.synchronize{ @idle = val }
     end
 
     def with
       session = deq
-      Thread.handle_interrupt(Exception => :immediate) { yield session }
+      Thread.handle_interrupt(Exception => :immediate){ yield session }
     ensure
       enq session
     end
 
     def close
-      while @queue.empty?
-        session, _, _ = @queue.deq
+      until @queue.empty?
+        session, _ = @queue.deq
         destroy(session)
       end
     end
@@ -58,10 +58,10 @@ module Xlogin
       end
 
       begin
-        raise IOError if session.sock.closed?
+        raise IOError if session&.sock&.closed?
       rescue IOError, EOFError, Errno::ECONNABORTED, Errno::ECONNREFUSED, Errno::ECONNRESET
         destroy(session)
-        session = deq
+        return deq
       end
 
       session

data/lib/xlogin/spec.rb

@@ -2,7 +2,7 @@ module Xlogin
   class ExpectationError < StandardError
 
     def initialize(expect, actual)
-      super("Expected to match #{expect}")
+      super(expect)
       @actual = actual
     end
 
@@ -14,28 +14,22 @@ module Xlogin
 
   class Expectation
 
-    def initialize(session, *args)
-      @session = session
-      @args = args
+    def initialize(result)
+      @result = result
     end
 
     def to_match(regexp)
-      return if match(regexp)
-      raise ExpectationError.new(@expect, @actual)
-    end
+      regexp = Regexp.new(regexp.to_s) unless regexp.kind_of?(Regexp)
+      return if @result =~ regexp
 
-    def not_to_match(regexp)
-      return unless match(regexp)
-      raise ExpectationError.new(@expect, @actual)
+      raise ExpectationError.new("Expected to match #{regexp}", @result)
     end
 
-    private
-    def match(regexp)
-      regexp  = Regexp.new(regexp.to_s) unless regexp.kind_of?(Regexp)
-      @expect = regexp.inspect
+    def not_to_match(regexp)
+      regexp = Regexp.new(regexp.to_s) unless regexp.kind_of?(Regexp)
+      return if @result !~ regexp
 
-      @actual ||= @session.cmd(*@args)
-      @actual =~ regexp
+      raise ExpectationError.new("Expected not to match #{regexp}", @result)
     end
 
   end
@@ -43,9 +37,8 @@ module Xlogin
   module SessionModule
 
     def expect(*args)
-      Expectation.new(self, *args)
+      Expectation.new(cmd(*args))
     end
-    alias_method :exp, :expect
 
   end
 end

data/lib/xlogin/telnet.rb

@@ -38,7 +38,7 @@ module Xlogin
             @sock.syswrite(bs)
           when @sock
             begin
-              log(fh.readpartial(1024))
+              write_log(fh.readpartial(1024))
             rescue Errno::EAGAIN
               retry
             end
@@ -47,7 +47,7 @@ module Xlogin
       end
     rescue EOFError, Errno::ECONNRESET
       $stdout.puts "\r\n", "Conneciton closed.", "\r\n"
-      self.close
+      close
     ensure
       $stdin.cooked!
     end

data/lib/xlogin/template.rb

@@ -8,54 +8,44 @@ module Xlogin
     DEFAULT_PROMPT   = /[$%#>] ?\z/n
     RESERVED_METHODS = %i( login logout enable disable )
 
-    attr_reader :name, :scopes, :methods
+    attr_reader :name, :methods
 
     def initialize(name)
       @name    = name
-      @scopes  = Hash.new
-      @timeout = DEFAULT_TIMEOUT
       @prompts = Array.new
       @methods = Hash.new
+      @timeout = DEFAULT_TIMEOUT
       @interrupt = nil
     end
 
-    def timeout(val = nil)
-      @timeout = val.to_i if val
-      @timeout
+    def prompt(expect, &block)
+      @prompts << [Regexp.new(expect.to_s), block]
     end
 
-    def prompt(expect = nil, &block)
-      return [[DEFAULT_PROMPT, nil]] if expect.nil? && @prompts.empty?
-      @prompts << [Regexp.new(expect.to_s), block] if expect
+    def prompts
+      @prompts << [DEFAULT_PROMPT, nil] if @prompts.empty?
       @prompts
     end
 
-    def scope(name = nil, &block)
-      @scopes[name] = block
+    def bind(name, &block)
+      @methods[name] = block
     end
 
-    def bind(name = nil, &block)
-      @methods[name] = block
+    def timeout(val = nil)
+      @timeout = val.to_i if val
+      @timeout
     end
 
     def interrupt!(&block)
-      return @interrupt unless block
-      @interrupt = block
+      @interrupt = block if block
+      @interrupt
     end
 
     def build(uri, **opts)
       klass = Class.new(Xlogin.const_get(uri.scheme.capitalize))
       klass.class_exec(self) do |template|
-        scopes = [*opts[:scope]].compact
-        scopes.each { |scope| template.instance_eval(&template.scopes[scope]) }
-
         template.methods.each do |name, block|
-          case name.to_s
-          when 'enable'
-            define_method(name) { |args = nil| instance_exec(args || opts[:enable], &block) }
-          else
-            define_method(name, &block)
-          end
+          define_method(name, &block)
         end
       end
 
@@ -64,7 +54,7 @@ module Xlogin
 
     def method_missing(name, *, &block)
       super unless RESERVED_METHODS.include?(name)
-      bind(name) { |*args| instance_exec(*args, &block) }
+      bind(name){ |*args| instance_exec(*args, &block) }
     end
 
   end

data/lib/xlogin/version.rb

@@ -1,3 +1,3 @@
 module Xlogin
-	VERSION = "0.13.10"
+	VERSION = "0.14.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xlogin
 version: !ruby/object:Gem::Version
-  version: 0.13.10
+  version: 0.14.4
 platform: ruby
 authors:
 - haccht
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-20 00:00:00.000000000 Z
+date: 2020-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-telnet