snarl-snp 0.1.1 → 0.2.0

data/lib/snarl/snp.rb

@@ -1,11 +1,11 @@
 require 'socket'
-
+require 'yaml'
 $LOAD_PATH.unshift(File.dirname(File.expand_path(__FILE__)))
 
 require 'snp/action'
-require 'snp/snp'
+require 'snp/snp_procedure'
+require 'snp/config'
 require 'snp/request'
 require 'snp/response'
 require 'snp/error'
-require 'snp/config'
-# require 'snp/addon'
+require 'snp/snp'

data/lib/snarl/snp/action.rb

@@ -13,9 +13,10 @@ class Snarl
       #
       # Snarl sends back a casual error when +app+ is already registered.
       # It is treated as SNP::SNPError::Casual::SNP_ERROR_ALREADY_REGISTERED.
-      def register(app=nil)
-        @app = app
-        cmds = {:action => 'register', :app => app}
+      def register(app = nil)
+        # when self['app'] == nil/unset and register(nil), SNARL receives SNP_ERROR_BAD_PACKET
+        self['app'] = app if app
+        cmds = {:action => 'register', :app => self['app']}
         request(Request.new(cmds))
       end
       alias :app= :register
@@ -33,8 +34,8 @@ class Snarl
       def add_class(classid, classtitle=nil)
         # TODO: add_class(app=nil, classid, classtitle=nil)
         # type=SNP#?version=1.0#?action=add_class#?class=t returns (107) Bad Packet
-        raise "#{self}#register(appname) required before add_class" unless @app
-        cmds = {:action => 'add_class', :app => @app, :class => classid.to_s, :title => classtitle}
+        raise "registering is required. #{self}#register(appname)  before #add_class" unless self['app']
+        cmds = {:action => 'add_class', :app => self['app'], :class => classid.to_s, :title => classtitle}
         request(Request.new(cmds))
       end
 
@@ -66,7 +67,7 @@ class Snarl
       # Snarl sends back a casual error when +app+ is not registered.
       # It is treated as SNP::SNPError::Casual::SNP_ERROR_NOT_REGISTERED.
       def unregister(app=nil)
-        app = app || @app
+        app = app || self['app']
         raise "#{self}#unregister requires appname." unless app
         cmds = {:action => 'unregister', :app => app}
         request(Request.new(cmds))
@@ -126,11 +127,14 @@ class Snarl
           res[command] =  keyhash_value if keyhash_value
         end
         res[:action]  = 'notification'
-        res[:app]     = @app if (res[:app].nil? && @app) # default notification
-        res[:app]     = nil if res[:app] == :anonymous # from snp.show_message
-        res[:title]   = (@title || DEFAULT_TITLE) unless res[:title]
-        res[:timeout] = (@timeout || DEFAULT_TIMEOUT) unless res[:timeout]
-        res[:icon]    = icon(res[:icon]) if res[:icon]
+        res[:app]     = self['app'] if (res[:app].nil? && self['app']) # default notification
+        res[:title]   = (res[:title] || self['title'] || DEFAULT_TITLE)
+        res[:timeout] = (res[:timeout] || self['timeout'] || DEFAULT_TIMEOUT)
+        if res[:icon] then
+          res[:icon] = icon(res[:icon])
+        elsif self['icon'] then
+          res[:icon] = self['icon']
+        end
         return res
       end
     end

data/lib/snarl/snp/autosnp.rb

@@ -0,0 +1,69 @@
+require 'snp'
+class Snarl
+  class SNP
+    module AutoSNP
+      @host=nil
+      @port=nil
+      @icondir=nil
+      @icon_ok=nil
+      @icon_fail=nil
+      @icon_pending=nil
+      @timeout_ok=nil
+      @timeout_fail=nil
+
+      attr_accessor :host, :port
+      attr_writer :icondir, :icon_ok, :icon_fail, :icon_pending, :timeout_ok, :timeout_fail
+
+      def snp
+        Snarl::SNP.load(<<YAML)
+host : #{host}
+port : #{port}
+app  : Autotest::Snarl
+"class" :
+  - ['green', 'test ok']
+  - ['red', 'test fail']
+  - ['yellow', 'test pending']
+  - ['info', 'system message']
+iconset :
+   green  : #{File.join(icondir, icon_ok)}
+   red    : #{File.join(icondir, icon_fail)}
+   yellow : #{File.join(icondir, icon_pending)}
+YAML
+      end
+
+      # Windows Snarl shortcut's "working folder" (left click property)
+      # %HOME%\Application Data\full phat\snarl\styles
+      def icondir ; @icondir ||= './' ; end
+
+      # %HOME%\Application Data\full phat\snarl\styles\ok.png works fine
+      def icon_ok ; @icon_ok ||= "ok.png" ; end
+      def icon_fail ; @icon_fail ||= "fail.png" ; end
+      def icon_pending ; @icon_pending ||= "pending.png" ; end
+
+      def timeout_ok ; @timeout_ok ||= 5 ; end
+      def timeout_fail ; @timeout_fail ||= 10 ; end
+
+      def timeout(state)
+        case state
+        when :green then timeout_ok.to_i
+        when :red   then timeout_fail.to_i
+        else 5
+        end
+      end
+
+      def classname(state)
+        state.to_s
+      end
+
+      def snarl(title, text, state)
+        snp.notification(
+                         :title   => title,
+                         :text    => text,
+                         :icon    => state.to_s,
+                         :timeout => timeout(state),
+                         :class   => classname(state)
+                         )
+      end
+    end
+  end
+end

data/lib/snarl/snp/config.rb

@@ -1,31 +1,123 @@
-
-# when config file exists, require this config
 class Snarl
   class SNP
     class Config
 
       DEFAULT_HOST = '127.0.0.1'
       DEFAULT_PORT = 9887
-      @host = nil
-      @port = nil
 
-      def self.host
-        @host || ENV['SNARL_HOST'] || DEFAULT_HOST
-      end
-      def self.host=(v)
-        @host = if v then v.to_s else nil end
+      def initialize
+        @config = {}
+        default_config
       end
 
-      def self.port
-        @port || ENV['SNARL_PORT'] || DEFAULT_PORT
-      end
-      def self.port=(v)
-        @port = if v then v.to_i else nil end
+      attr_reader :config # mainly for debug
+
+      def default_config
+        self['host'] = if $SAFE > 0 then DEFAULT_HOST else ENV['SNARL_HOST'] || DEFAULT_HOST end
+        self['port'] = if $SAFE > 0 then DEFAULT_PORT else ENV['SNARL_PORT'] || DEFAULT_PORT end
       end
+      private :default_config
+
+      def []=(k, v) ; Normalize.store(k, v, @config) ; end
+      def [](k) ; @config[k.to_s] ; end
+      def reset ; @config = {} ; end
+      def to_yaml ; @config.to_yaml ; end
+
+      class Normalize
+
+        def self.store(k, v, hash)
+          nkey, nvalue = new(k, v).normalize
+          hash.store(nkey, nvalue) if nkey && nvalue != nil
+        end
+
+        def initialize(k, v)
+          @key, @value = k, v
+        end
+
+        def normalize
+          # NOTE: [xxx, nil] is not set to @config
+          # TODO : [k, v] should be equal to {k ,v}
+          v = @value
+          case @key.to_s
+          when 'host' then
+            ['host', if is_yaml_undef?(v) then nil else v end]
+          when 'port' then
+            # {:port => '9887'} is {'port' => 9887}
+            ['port', if is_yaml_undef?(v) then nil else v.to_i end]
+          when 'app', 'application', 'name', 'register' then
+            ['app', if is_yaml_undef?(v) then nil else v end]
+          when 'class', 'add_class', 'classes' then
+            # {:class => 'cls'} and {'add_class' => {'cls' => nil}} are {'class' => ['cls', nil]}
+            ['class', extract_classes(v)]
+          when 'title' then
+            ['title', if is_yaml_undef?(v) then nil else v end]
+          when 'text', 'body', 'msg' then
+            ['text', if is_yaml_undef?(v) then nil else v end]
+          when 'timeout', 'duration', 'sec' then
+            ['timeout', if is_yaml_undef?(v) then 0 else v.to_i end] # "timeout: nil" is sticky
+          when 'sticky' then
+            ['timeout', if is_yaml_false?(v) then nil else 0 end]
+          when 'icon' then # NOTE: is "this notification icon", not "iconset setting"
+            ['icon', if is_yaml_undef?(v) then nil else v end]
+          when 'notification', 'notify', 'message' then
+            ['notification', if is_yaml_undef?(v) then nil else v end]
+          when 'unregister' then
+            ['unregister', if is_yaml_false?(v) then false else true end]
+          when 'iconset' then
+            ['iconset', if is_yaml_undef?(v) then nil else v end]
+
+          when 'log', 'logger' then # useless on yaml?
+            ['logger', v]
+          when 'logfile' then
+            ['logfile', extract_logfile(v)]
+          when 'loglevel', 'logger.level', 'log_level' then
+            ['loglevel', extract_loglevel(v)]
+
+          when 'config' then
+            ['config', if is_yaml_undef?(v) then nil else v end]
+          when 'yaml' then
+            ['yaml', if is_yaml_undef?(v) then nil else v end]
+
+          else [@key.to_s, v] # or raise?
+          end
+        end
+
+        private
+
+        def is_yaml_undef?(v)
+          v == 'nil' || v == nil || v == ':nil' || v == :nil || v == '' || v == [] || v == {}
+        end
+        def is_yaml_false?(v)
+          is_yaml_undef?(v) || v == false || v == 'false' || v == :false || v == ':false'
+        end
+
+        def extract_classes(v)
+          if v.kind_of?(Array) then
+            res = []
+            v.each do |a|
+              pair = [a].flatten
+              pair.push(nil) if pair.size == 1
+              res << pair
+            end
+            return res
+          elsif v.kind_of?(String)
+            return [[v, nil]]
+          else
+            return nil
+          end
+        end
+
+        def extract_logfile(v)
+          if is_yaml_undef?(v) then nil else {'$stdout' => $stdout, '$stderr' => $stderr}[v.to_s] || v end
+        end
 
-      def self.reset
-        self.host = nil
-        self.port = nil
+        def extract_loglevel(v)
+          if is_yaml_undef?(v) then
+            return 0
+          else
+            return /\d/ =~ v.to_s ? v.to_s.to_i : (%w(DEBUG INFO WARN ERROR FATAL).index(v.to_s.upcase) || 0)
+          end
+        end
       end
     end
   end

data/lib/snarl/snp/error.rb

@@ -16,6 +16,9 @@ class Snarl
       class SNP_OK < Casual ; end
       # (0) OK
 
+      class SNP_ERROR_NOT_RUNNING < Casual ; end
+      # (201) Incoming network notification handling has been disabled by the user.
+
       class SNP_ERROR_NOT_REGISTERED < Casual ; end
       # (202) The application hasn't been registered.
 
@@ -25,11 +28,12 @@ class Snarl
       class SNP_ERROR_CLASS_ALREADY_EXISTS < Casual ; end
       # (204) Class is already registered.
 
-      class Fatal < SNPError ; end
-
-      class SNP_ERROR_FAILED < Fatal ; end
+      # "Do not Disturb" often raises this error...
+      class SNP_ERROR_FAILED < Casual ; end #Fatal ; end
       # (101) An internal error occurred - usually this represents a fault within Snarl itself.
 
+      class Fatal < SNPError ; end
+
       class SNP_ERROR_UNKNOWN_COMMAND < Fatal ; end
       # (102) An unknown action was specified.
 
@@ -39,9 +43,6 @@ class Snarl
       class SNP_ERROR_BAD_PACKET < Fatal ; end
       # (107) The command packet is wrongly formed.
 
-      class SNP_ERROR_NOT_RUNNING < Fatal ; end
-      # (201) Incoming network notification handling has been disabled by the user.
-
       class RUBYSNARL_UNKNOWN_RESPONSE < Fatal ; end
       # (???) Snarl returns unknown return code.
 

data/lib/snarl/snp/request.rb

@@ -23,60 +23,70 @@ class Snarl
       # make SNP request string from command hash and is Request object.
       def initialize(cmd_hash={})
         @commands = {}.update(cmd_hash)
+        normalize unless @commands.empty?
       end
 
       attr_reader :commands
 
       # Adds command key and value to Request
-      def []=(cmdkey, value) ; @commands[cmdkey] = value ; end # TODO: normalize
+      def []=(cmdkey, value)
+        norm_cmdkey = normalize_cmdkey(cmdkey)
+        if norm_cmdkey == 'action' then
+          @commands['action'] = normalize_action_value(value)
+        else
+          @commands[norm_cmdkey] = normalize_value(value)
+        end
+      end
       # Returns command value for command key
-      def [](cmdkey)        ; @commands[cmdkey]     ; end
+      def [](cmdkey) ; @commands[cmdkey] ; end
 
       # Returns Request query string with SNP_TERMINAL_STRING "\r\n"
       def to_str ; query + SNP_TERMINAL_STRING ; end # FIXME: include "\r\n"?
       alias :to_s :to_str
       # Returns Request query string. has no SNP_TERMINAL_STRING "\r\n".
-      def inspect ; query ; end
+      def inspect ; query.inspect ; end
       def action ; @commands['action'] ; end
 
       private
 
-      def order_command_pair
-        action = @commands['action']
+      def align_command_pair
         @commands.to_a.sort_by{|pair| SNP_ACTIONS[action].index(pair[0])}
       end
 
       def query
-        normalize
-        order_command_pair.map{|pair| pair.join('=')}.join(SNP_SEPARATOR)
+        # @commands is already normalized
+        align_command_pair.map{|pair| pair.join('=')}.join(SNP_SEPARATOR)
       end
 
-      # normalize item pairs
+      # normalize command item pairs {cmdkey => value}
       # - symbol keys and upcase KEYS are normalized into downcased string keys.
-      # - query should not have any "\r". use "\n"
-      # - when value is nil, delete the item pair.
+      # - value should not have any "\r". use one "\n" as a newline.
+      # - {'action' => 'add-class' or :add_class} are {'action' => 'add_class'}.
+      # - when value is nil, delete the pair.
       def normalize
-        norm_commands = Hash[*@commands.map{|k, v| [crlf2lf(k).downcase, crlf2lf(v)]}.flatten]
-        action = normalize_action(norm_commands['action'])
-        norm_commands['action'] = action
+        unnormalized_commands = @commands.dup
         @commands = SNP_HEADER.dup
-        available_commands_in(action).each do |cmd|
-          @commands[cmd] = norm_commands[cmd] if norm_commands[cmd]
-        end
+        unnormalized_commands.each{|cmdkey, value| self[cmdkey] = value}
+        available_commands = SNP_ACTIONS[self.action] || [] # or raise
+        @commands.delete_if{|cmdkey, value| !available_commands.include?(cmdkey)}
+        @commands.delete_if{|cmdkey, value| value.nil?} # || value.empty? # TODO: "timeout=" is vaild SNP?
+        @commands
       end
 
-      def normalize_action(action_type)
-        action_type.downcase.gsub(/-/){'_'}.sub(/\Aaddclass\Z/){'add_class'}
+      def normalize_cmdkey(cmdkey)
+        crlf2lf(cmdkey).downcase
       end
-
-      def available_commands_in(action)
-        SNP_ACTIONS[action] || {}
+      def normalize_value(value)
+        crlf2lf(value)
       end
 
       def crlf2lf(s)
         s ? s.to_s.gsub(/\r\n/){"\n"}.gsub(/\r/){"\n"} : s
       end
 
+      def normalize_action_value(value)
+        normalize_value(value).downcase.gsub(/-/){'_'}.sub(/\Aaddclass\Z/){'add_class'}
+      end
     end
   end
 end

data/lib/snarl/snp/response.rb

@@ -31,6 +31,7 @@ class Snarl
       def inspect ; @response.chomp ; end # p response #=> "SNP/1.1/0/OK/456"
 
       def ok? ; code.to_i.zero? ; end
+      def request_str ; request ? request.to_s : nil ; end
     end
   end
 end

data/lib/snarl/snp/snp.rb

@@ -3,6 +3,7 @@ class Snarl # conpat for ruby-snarl
   class SNP
 
     include Action
+    include SNPProcedure
 
     # default "timeout command" value. popup disappers in 10 seconds.
     DEFAULT_TIMEOUT = 10
@@ -11,49 +12,60 @@ class Snarl # conpat for ruby-snarl
     DEFAULT_TITLE = 'Ruby-Snarl'
 
     # Snarl::SNP.new('127.0.0.1', 9887)
-    def initialize(host=nil, port=nil, verbose=false)
-      @host = host
-      @port = port
-      @verbose = verbose
-      @logger = nil
-      @app = nil
-      @timeout = nil
-      @iconset = {}
-      @title = nil
+    def initialize(host=nil, port=nil, verbose=false, &block)
+      @config = Config.new
+      if host && YAML.load(host).kind_of?(Hash) then
+        port.respond_to?(:debug) ? load(host, port, &block) : load(host, nil, &block)
+      else
+        self['host'] = host
+        self['port'] = port
+        self['verbose'] = verbose
+        yield(self) if block_given?
+      end
     end
+    attr_reader :config
+
+    def []=(k, v) ; @config[k] =v ; end
+    def [](k) ; @config[k] ; end
 
     # When you set it true, all unimportant SNP errors raise.
     # Default is false, Snarl::SNP::Error::Casual are disabled.
-    attr_accessor :verbose
-
-    # a value of SNP command "app".
-    attr_reader :app
+    def verbose=(v) ; self['verbose'] = v ; end
+    def verbose ; self['verbose'] ; end
 
-    attr_accessor :title
+#    # a value of SNP command "app".
+#    attr_reader :app
+#
+#    attr_accessor :title
 
-    # a value of SNP command "timeout".
-    attr_accessor :timeout
+#    # a value of SNP command "timeout".
+#    attr_accessor :timeout
 
     # set Logger object. It is used when sending request and getting response.
     def logger=(logger)
-      @logger = (logger.kind_of?(Class) ? logger.new($stdout) : logger)
+      self['logger'] = (logger.kind_of?(Class) ? logger.new($stdout) : logger)
     end
+    def logger ; self['logger'] ; end
 
     # send Snarl::SNP::Request/Hash/String and get Snarl::SNP::Response fron Snarl.
     # When the response "fatal" response, raise errors.
     # When method +verbose+ returns true, "casual" errors also raises.
     def request(req)
       req = Request.new(req) if req.kind_of?(Hash)
-      debug(req)
+      action = if req.kind_of?(Request) then req.action else '(string)' end
+      debug("#{action}: #{req.inspect}")
       begin
-        action = req.kind_of?(Request) ? req.action : '(string)'
         res = get_response(req)
         info("#{action}: #{res.inspect}")
       rescue Error::Casual => ex
         info("#{action}: (ignored) #{ex.message}")
         raise if verbose
+        res = ex.response
       rescue Error::Fatal => ex
-        info("#{action}: #{ex.message}")
+        error("#{action}: #{ex.message}")
+        raise
+      rescue Errno::ECONNREFUSED => ex
+        error("#{ex.message} / #{self['host'].inspect}:#{self['port'].inspect}")
         raise
       end
       return res
@@ -63,25 +75,22 @@ class Snarl # conpat for ruby-snarl
 
     # add_classes('type1', 'type2', 'type3')
     # add_classes(['type1', desc1], ['type2', desc2], ['type3', desc3])
+    # add_classes(*array_of_pairs)
+    # returns [add_class_response1, add_class_response2, add_class_response3]
     def add_classes(*classes)
-      classes.each do |classpair|
-        classpair = [classpair, nil] if classpair.kind_of?(String)
-        add_class(*classpair)
-      end
+      classes.map{|e| e.kind_of?(String) ? [e, nil] : e}.map{|p| add_class(*p)}
     end
 
     # returns icon path if SNP knows. optional.
     def icon(s)
-      if @iconset.has_key?(s) then @iconset[s] else s end
+      if self['iconset'] && self['iconset'].has_key?(s) then self['iconset'][s] else s end
     end
 
     # set icons pair. quite optional.
-    #   snp.iconset(:red => 'red.jpg')
+    #   snp.iconset({:red => 'red.jpg'})
     #   snp.notification('title', 'text', :red) #=> sends "icon=red.jpg"
     #   snp.notification('title', 'text', 'blue') #=> sends "icon=blue"
-    def iconset(icons)
-      @iconset = icons
-    end
+    def iconset(icons) ; self['iconset'] = icons ; end
     alias :icons :iconset
 
     def ping
@@ -106,9 +115,11 @@ class Snarl # conpat for ruby-snarl
       client
     end
 
-    # send message only. app is "anonymous".
-    #   Snarl::SNP.show_message(host, 9887, title, text, tomeout, icon)
-    #   Snarl::SNP.show_message(host, title, text, tomeout, icon)
+    # send message only. app and class is "anonymous".
+    #   Snarl::SNP.show_message(host, 9887, title, text, timeout, icon)
+    #   Snarl::SNP.show_message(host, title, text, timeout, icon)
+    #   Snarl::SNP.show_message(host, title, text)
+    #   Snarl::SNP.show_message(host, text)
     def self.show_message(host, port, title=nil, text=nil, timeout=nil, icon=nil)
       # TODO: (host, title, text, 10)
       if port.kind_of?(String) && icon.nil? then
@@ -124,19 +135,23 @@ class Snarl # conpat for ruby-snarl
 
     private
 
-    def get_response(req)
-      host = @host || Config.host
-      port = @port || Config.port
-      TCPSocket.open(host, port) do |s|
+    def send(req)
+      # normalize just before using # FIXME:
+      TCPSocket.open(self['host'], self['port']) do |s|
         s.write(req)
-        res = Response.new(s.gets)
-        res.request = req
-        res
+        s.gets
       end
     end
 
-    def info(m); @logger.info(m) if @logger; end
-    def debug(m); @logger.debug(m) if @logger; end
+    def get_response(req)
+      res = Response.new(send(req))
+      res.request = req
+      res
+    end
+
+    def error(m); logger.error(m) if logger ; end
+    def info(m);  logger.info(m)  if logger ; end
+    def debug(m); logger.debug(m) if logger ; end
 
   end
 end