xlogin 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbc5c0255a1328038a84dc96b4e99c1b252c998ece79c03f7e23d22b7c5eba2d
-  data.tar.gz: a605c1f6a0bb730e3aab19c13401c902416aee1e985a34a4d3132c014bc36f43
+  metadata.gz: cda6f2be936220ffb49b9d586d0e8ebcd248194bb0d16b7bc595ab3209da42da
+  data.tar.gz: 484a16a9c5f1e3eaa9d65f85de52e634ffb29a6b4e66f5461385c1f29c115ae6
 SHA512:
-  metadata.gz: c077a17025b8131927de93b9602bc1d8957f4545b38bf2ec58c95d460faf3320d55770c8efc65cce4796eeb11fa5d3e4d3bcd7acbd9b35b44e7beffc1da55b5e
-  data.tar.gz: 665cb8e5a6ebde87623135a31ca21d5f2e25408e31e4fc12560fa4ce6095459a686a32317c1a0dabb4eace83224b828999be069a5c84f225fa4dad9dc174a44b
+  metadata.gz: 0562b0ad712a00b3b2dd8d36b43c3fc15f1435492f9c025e374c52a1a92495575667476dfe1e679a57a6f396b5eba0bad2341d56c0a36454e70ff7737c656ac8
+  data.tar.gz: 716231e8c898ebb0d10b85a58c422f9815361e9c4303c803f2ca40c80fd83e957cd135b3f2db920ec12468e04e42d25f3c5b0213120e149451a62535b218b71b

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,21 +34,19 @@ 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
       begin block.call(session) ensure session.close end
     end
-    alias_method :create, :get
 
-    def get_pool(args, **opts, &block)
+    def pool(args, **opts, &block)
       pool = factory.build_pool(args, **opts)
 
       return pool unless block
       begin block.call(pool) ensure pool.close end
     end
-    alias_method :create_pool, :get_pool
 
     def configure(&block)
       instance_eval(&block)
@@ -59,7 +57,7 @@ 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) }
     end

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])
+      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(session.config.enable) if session.config.enable && Xlogin.settings.enable?
 
-          command_lines = ['', *config[:exec].to_s.split(';').map(&:strip)]
+          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('-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,4 +1,5 @@
 require 'addressable/uri'
+require 'net/ssh/gateway'
 require 'singleton'
 require 'thread'
 require 'xlogin/session_pool'
@@ -12,30 +13,30 @@ module Xlogin
     def initialize
       @inventory = Hash.new
       @templates = Hash.new
-      @gateways  = Hash.new
+      @tunnels   = 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]) }
         end
-        values2.reduce(&:&)
+        values2.reduce(&:&) || []
       end
-      values1.reduce(&:|)
+      values1.reduce(&:|) || []
     end
 
     def set_template(name, text = nil, &block)
@@ -53,32 +54,40 @@ module Xlogin
       @templates.keys
     end
 
-    def open_tunnel(tunnel, host, port)
+    def open_tunnel(name, host, port)
       @mutex.synchronize do
-        unless @gateways[tunnel]
-          gateway_uri = Addressable::URI.parse(tunnel)
-          case gateway_uri.scheme
+        unless @tunnels[name]
+          uri = Addressable::URI.parse(name)
+          case uri.scheme
           when 'ssh'
-            username, password = *gateway_uri.userinfo.split(':')
-            @gateways[tunnel] = Net::SSH::Gateway.new(
-              gateway_uri.host,
+            username, password = *uri.userinfo.split(':')
+            gateway = Net::SSH::Gateway.new(
+              uri.host,
               username,
               password: password,
-              port: gateway_uri.port || 22
+              port: uri.port || 22
             )
+
+             @tunnels[name] = Struct.new('Tunnel', :gateway, :ports).new(gateway, [])
           end
         end
 
-        gateway = @gateways[tunnel]
-        return host, port unless gateway
-        return '127.0.0.1', gateway.open(host, port)
+        if tunnel = @tunnels[name]
+          port = tunnel.gateway.open(host, port)
+          host = '127.0.0.1'
+          tunnel.ports << port
+        end
+        return host, port
       end
     end
 
-    def close_tunnel(tunnel, port)
+    def close_tunnel(name, port)
       @mutex.synchronize do
-        gateway = @gateways[tunnel]
-        gateway.close(port) if gateway
+        if tunnel = @tunnels[name]
+          tunnel.ports.delete(port)
+          tunnel.gateway.close(port)
+          tunnel.gateway.shutdown! if tunnel.ports.empty?
+        end
       end
     end
 
@@ -94,31 +103,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'
 
@@ -17,7 +16,7 @@ module Xlogin
 
         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) if session
+      $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 log_message(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,8 +1,4 @@
-require 'addressable/uri'
-require 'delegate'
 require 'fileutils'
-require 'net/ssh/gateway'
-require 'ostruct'
 require 'stringio'
 require 'thread'
 
@@ -25,13 +21,11 @@ module Xlogin
       @tunnel   = opts[:tunnel] || opts[:via]
       @config   = ReadOnlyStruct.new(opts)
       @template = template
-      @username, @password = uri.userinfo.to_s.split(':')
-
-      max_retry = @config.retry || 1
+      @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
 
-      @mutex   = Mutex.new
-      @loggers = [@config.log].flatten.uniq.reduce({}){ |a, e| a.merge(e => build_logger(e)) }
+      max_retry = @config.retry || 1
+      username, password = uri.userinfo.to_s.split(':')
 
       begin
         args = Hash.new
@@ -43,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)
@@ -64,43 +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?
 
-        Xlogin.factory.close_tunnel(@tunnel, @port) if @tunnel
-        super
+      line = super(*args) do |recv|
+        write_log(recv)
+        block.call(recv) if block
       end
+
+      _, 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)
@@ -116,23 +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
+    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

@@ -13,20 +13,12 @@ module Xlogin
       @args = args
       @opts = opts
 
-      @size = DEFAULT_POOL_SIZE
-      @idle = DEFAULT_POOL_IDLE
+      @size = @opts.delete(:pool_size) || DEFAULT_POOL_SIZE
+      @idle = @opts.delete(:pool_idle) || DEFAULT_POOL_IDLE
 
       @mutex = Mutex.new
       @queue = Queue.new
-      @created  = 0
-    end
-
-    def size=(val)
-      @mutex.synchronize{ @size = val }
-    end
-
-    def idle=(val)
-      @mutex.synchronize{ @idle = val }
+      @count = 0
     end
 
     def with
@@ -37,7 +29,7 @@ module Xlogin
     end
 
     def close
-      while @queue.empty?
+      until @queue.empty?
         session, _, _ = @queue.deq
         destroy(session)
       end
@@ -45,37 +37,40 @@ module Xlogin
 
     def deq
       @mutex.synchronize do
-        if @queue.empty? && @created < @size
-          @created += 1
+        if @queue.empty? && @count < @size
+          @count += 1
           return Xlogin.get(@args, **@opts)
         end
       end
 
-      session, last_used = @queue.deq
+      session, last_used, watch_dog = @queue.deq
+
+      watch_dog.kill
       if Time.now - last_used > @idle
         destroy(session)
         return deq
       end
 
       begin
-        raise IOError if session.sock.closed?
+        raise IOError if session&.sock&.closed?
+        return session
       rescue IOError, EOFError, Errno::ECONNABORTED, Errno::ECONNREFUSED, Errno::ECONNRESET
         destroy(session)
-        session = deq
+        return deq
       end
-
-      session
     end
 
     def enq(session)
       last_used = Time.now
-      @queue.enq [session, last_used]
+      watch_dog = Thread.new(session){ |s| sleep(@idle * 1.5) && s.close rescue nil }
+      @queue.enq [session, last_used, watch_dog]
     end
 
+    private
     def destroy(session)
       @mutex.synchronize do
         session.close rescue nil
-        @created -= 1
+        @count -= 1
       end
     end
 

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
 

data/lib/xlogin/version.rb

@@ -1,3 +1,3 @@
 module Xlogin
-	VERSION = "0.14.1"
+	VERSION = "0.15.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xlogin
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0
 platform: ruby
 authors:
 - haccht
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-27 00:00:00.000000000 Z
+date: 2020-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-telnet