snarl-snp 0.1.1 → 0.2.0

data/lib/snarl/snp/snp_procedure.rb

@@ -0,0 +1,105 @@
+require 'yaml' # some users don't use rubygems
+class Snarl
+  class SNP
+    module SNPProcedure
+      def is_app_available? ; self['app'] && !self['app'].empty? ; end
+      def auto_register
+        if is_app_available? then
+          register(self['app'])
+        end
+      end
+
+      def is_class_available? ; self['class'] && !self['class'].empty? ; end
+      def auto_add_class
+        if is_app_available? && is_class_available? then
+          add_classes(*self['class'])
+        end
+      end
+
+      def is_notification_available? ; self['notification'] && !self['notification'].empty? ; end
+      def auto_notification
+        _notify_arg_is_array = is_notification_available? && self['notification'].kind_of?(Array)
+        _notify_arg_is_arraied_notify_hashes = is_notification_available? && self['notification'].first.kind_of?(Hash)
+
+        if is_notification_available? then
+          if _notify_arg_is_array then
+            if _notify_arg_is_arraied_notify_hashes then
+              # [{notify_hash1}, {notify_hash2}, ...]
+              self['notification'].map{|h| notification(h)}
+            else
+              # [title, text, timeout, icon, class]
+              notification(*self['notification'])
+            end
+          else
+            # {notify_hash}
+            notification(self['notification'])
+          end
+        else # config has no 'notification' key
+          # build notify arg from config
+          h = {}
+          h[:app] = self['app'] if self['app']
+          h[:title] = self['title'] if self['title']
+          h[:text] = self['text'] if self['text']
+          h[:timeout] = self['timeout'] if self['timeout']
+          h[:icon] = self['icon'] if self['icon']
+          h[:class] = self['class'][0][0] if is_class_available? # snp['class'] == [['clsnam', 'clstit']]
+          notification(h) if (h.has_key?(:text)||h.has_key?(:title))
+        end
+      end
+
+      private :is_app_available?, :is_class_available?, :is_notification_available?
+
+      def auto_unregister
+        if self['unregister'] && is_app_available? then
+          unregister(self['app'])
+        end
+      end
+
+      def autoexecute_with_config!
+        [auto_register,
+         auto_add_class,
+         auto_notification]
+      end
+
+      def apply_yaml(yamldata)
+        YAML.load(yamldata).each do |k ,v|
+          self[k] = v
+        end
+      end
+
+      def set_logger(arg_logger)
+        # TODO: support for another Logger
+        if arg_logger then
+          require 'logger' # FIXME: oh twice?
+          arg_logger = Logger.new(arg_logger) unless arg_logger.respond_to?(:warn)
+          self.logger = arg_logger
+        elsif self['logfile'] then
+          require 'logger' # FIXME: oh ...
+          logger = Logger.new(self['logfile'])
+          logger.level = self['loglevel'] if self['loglevel']
+          self.logger = logger
+        else
+          # do nothing
+        end
+      end
+
+      def load(yamldata, logger = nil, &block)
+        apply_yaml(yamldata)
+        # apply/overwrite user Logger object
+        # yaml cannot make 'raw' Logger object
+        set_logger(logger)
+        begin
+          autoexecute_with_config!
+          block.call(self) if block_given?
+        ensure
+          auto_unregister
+        end
+        self
+      end
+    end
+
+    def self.load(*args, &block)
+      self.new.load(*args, &block)
+    end
+  end
+end

data/snarl-snp.gemspec

@@ -5,42 +5,49 @@
 
 Gem::Specification.new do |s|
   s.name = %q{snarl-snp}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["kitamomonga"]
-  s.date = %q{2010-04-23}
-  s.description = %q{Snarl Network Protocol Client. Snarl is the notification program for Windows. You can send notification messages to Snarl with SNP over LAN.}
+  s.date = %q{2010-05-20}
+  s.default_executable = %q{snarl_snp}
+  s.description = %q{Snarl Network Protocol Client. Snarl is the notification program for Windows. You can send notification messages to Snarl with SNP on LAN.}
   s.email = %q{ezookojo@gmail.com}
+  s.executables = ["snarl_snp"]
   s.extra_rdoc_files = [
-    "README.rdoc",
-     "README.rdoc.ja"
+    "README.rdoc"
   ]
   s.files = [
-    "GUIDE.rdoc.ja",
-     "MIT-LICENSE",
+    "MIT-LICENSE",
      "README.rdoc",
-     "README.rdoc.ja",
      "Rakefile",
      "VERSION",
+     "YAML.rdoc",
+     "bin/snarl_snp",
+     "doc-ja/GUIDE.rdoc.ja",
+     "doc-ja/README.rdoc.ja",
+     "doc-ja/YAML.rdoc.ja",
      "exsample/ping.rb",
      "exsample/winamp_nowplaying.rb",
      "exsample/yahoo_weather.rb",
      "lib/snarl/autotest.rb",
      "lib/snarl/snp.rb",
      "lib/snarl/snp/action.rb",
+     "lib/snarl/snp/autosnp.rb",
      "lib/snarl/snp/config.rb",
      "lib/snarl/snp/error.rb",
      "lib/snarl/snp/request.rb",
      "lib/snarl/snp/response.rb",
      "lib/snarl/snp/snp.rb",
+     "lib/snarl/snp/snp_procedure.rb",
      "snarl-snp.gemspec",
-     "spec/exsample/data/weather_yahoo_co_jp.html",
-     "spec/exsample/yahoo_weather_spec.rb",
+     "spec/bin/snarl_snp_spec.rb",
      "spec/snp/action_spec.rb",
      "spec/snp/config_spec.rb",
+     "spec/snp/real_connection_spec.rb",
      "spec/snp/request_spec.rb",
      "spec/snp/response_sprc.rb",
+     "spec/snp/snp_procedure_spec.rb",
      "spec/snp/snp_spec.rb",
      "spec/spec_helper.rb"
   ]
@@ -48,12 +55,14 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Snarl Network Protocol Client. You can notify to Snarl over LAN.}
+  s.summary = %q{Snarl Network Protocol Client. You can notify to Snarl on LAN.}
   s.test_files = [
-    "spec/exsample/yahoo_weather_spec.rb",
+    "spec/bin/snarl_snp_spec.rb",
      "spec/spec_helper.rb",
      "spec/snp/config_spec.rb",
      "spec/snp/response_sprc.rb",
+     "spec/snp/snp_procedure_spec.rb",
+     "spec/snp/real_connection_spec.rb",
      "spec/snp/request_spec.rb",
      "spec/snp/snp_spec.rb",
      "spec/snp/action_spec.rb"
@@ -65,14 +74,11 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
-      s.add_development_dependency(%q<webmock>, [">= 0"])
     else
       s.add_dependency(%q<rspec>, [">= 1.2.9"])
-      s.add_dependency(%q<webmock>, [">= 0"])
     end
   else
     s.add_dependency(%q<rspec>, [">= 1.2.9"])
-    s.add_dependency(%q<webmock>, [">= 0"])
   end
 end
 

data/spec/bin/snarl_snp_spec.rb

@@ -0,0 +1,91 @@
+# -*- coding:utf-8 -*-
+require 'tempfile'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+if defined?(TEST_SNARL_SNP_BIN_SPEC) then
+  class SNPBin
+    remove_const :"BINCMD_OPTION"
+  end
+else
+  TEST_SNARL_SNP_BIN_SPEC=true
+end
+load File.expand_path(File.dirname(__FILE__) + '/../../bin/snarl_snp')
+
+describe "SNPBin" do
+
+  before :all do
+    @argv_bak = ARGV.dup
+  end
+  after :all do
+    ARGV.replace(@argv_bak)
+  end
+
+  describe "initialize" do
+    before do
+      @snpbin = SNPBin.new
+    end
+    it "initialize data" do
+      @snpbin.argv_option.should eql({})
+      @snpbin.config.should eql({})
+    end
+  end
+
+  describe "parse_argv" do
+    SNPBin::BINCMD_OPTION.each do |optname, opthash|
+      before do
+        ARGV.clear
+        @snpbin = SNPBin.new
+      end
+      # opthash[:opt] == ['-a app', '--app=app']
+      arg = opthash[:opt][0].split(/\s+|=/) # ['-a', 'app']
+      value = if arg[1] then "'#{arg[1]}'" else true end # ''app''
+      instance_eval(<<EOS)
+      it "when ARGV[1] = '#{opthash[:opt][0]}', set {'#{optname}' => #{value}} to @argv_option" do
+        ARGV.replace([__FILE__] + arg)
+        @snpbin.parse_argv
+        @snpbin.argv_option.should eql({'#{optname}' => #{value}})
+      end
+EOS
+    end
+  end
+
+  describe "merge_yaml_from_argvopt" do
+    before do
+      @yamlfile = Tempfile.new('snarlsnpbinsnarlsnpspecrb')
+      File.open(@yamlfile.path, 'w'){|f| f.write("data : yaml!")}
+      @snpbin = SNPBin.new
+      @snpbin.argv_option.update({'yaml' => @yamlfile.path})
+    end
+    after do
+      @yamlfile.close
+    end
+
+    it "do nothing when @argv_option has no 'yaml' key" do
+      @snpbin.argv_option.delete('yaml')
+      lambda{@snpbin.merge_yaml_from_argvopt}.should_not change(@snpbin, :config)
+    end
+
+    it "picks and deletes {'yaml' => yamlpath} from @argv_option and update @config by yamlpath-yaml" do
+      # FIXME: rewrite with change matcher
+      @snpbin.config.should be_empty
+      @snpbin.merge_yaml_from_argvopt
+      @snpbin.config.should eql({'data' => 'yaml!'})
+      @snpbin.argv_option.should_not have_key('yaml')
+    end
+  end
+
+  describe "#merge_all_argvopt_to_config" do
+    before do
+      @snpbin = SNPBin.new
+      @data = {'key' => 'value'}
+    end
+    it "copys @argv_option to @config" do
+      @snpbin.instance_variable_set(:@argv_option, @data)
+      @snpbin.merge_all_argvopt_to_config
+      @snpbin.config.should eql(@data)
+    end
+  end
+
+  # tests for SNPBin#exec_snplib and #run are in ../snp/real_connection_spec.rb
+
+end

data/spec/snp/action_spec.rb

@@ -1,4 +1,3 @@
-# -*- coding:utf-8 -*-
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "SNP" do
@@ -8,120 +7,114 @@ describe "SNP" do
     @port = 9887
     @app = Snarl::SNP::DEFAULT_TITLE
     @class = '1'
-    Snarl::SNP::Config.reset
+  end
+
+  def snp_open(&block)
+    snp = Snarl::SNP.new(@host, @port)
+    snp.stub!(:send).and_return('SNP/1.1/0/OK/1234/')
+    block.call(snp)
   end
 
   describe "#register" do
-    it "everything goes well" do
-      lambda{
-        Snarl::SNP.open(@host, @port) do |snp|
-          snp.register(@app)
-          snp.unregister(@app)
-        end
-      }.should_not raise_error
-    end
-    it "twice raises error on verbose" do
-      Snarl::SNP.open(@host, @port) do |snp|
-        snp.verbose = true
-        snp.register(@app)
-        lambda{snp.register(@app)}.should raise_error(Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED)
-        snp.unregister(@app)
-      end
-      Snarl::SNP.open(@host, @port) do |snp|
-        snp.register(@app)
-        lambda{snp.register(@app)}.should_not raise_error(Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED)
-        snp.unregister(@app)
+    it "makes valid SNP command string" do
+      expected = "type=SNP#?version=1.0#?action=register#?app=#{@app}\r\n"
+      snp_open do |snp|
+        snp.register(@app).request_str.should eql(expected)
       end
     end
   end
 
   describe "#unregister" do
-    # it "everything goes well" is done in #register
-    it "unregister before register raises error on verbose" do
-      Snarl::SNP.open(@host, @port) do |snp|
-        snp.verbose = true
-        lambda{snp.unregister(@app)}.should raise_error(Snarl::SNP::Error::SNP_ERROR_NOT_REGISTERED)
+    it "makes valid SNP command string" do
+      expected = "type=SNP#?version=1.0#?action=unregister#?app=#{@app}\r\n"
+      snp_open do |snp|
+        snp.unregister(@app).request_str.should eql(expected)
       end
-      Snarl::SNP.open(@host, @port) do |snp|
-        lambda{snp.unregister(@app)}.should_not raise_error(Snarl::SNP::Error::SNP_ERROR_NOT_REGISTERED)
+    end
+    it "raises error when snp has no @app yet" do
+      snp_open do |snp|
+        lambda{snp.unregister}.should raise_error(RuntimeError)
       end
     end
   end
 
   describe "#add_class" do
-    it "everything goes well" do
-      lambda{
-        Snarl::SNP.open(@host, @port) do |snp|
+    describe "makes valid SNP command string" do
+      it "snp.add_class(clsname) has class=clsname" do
+        expected = "type=SNP#?version=1.0#?action=add_class#?app=#{@app}#?class=#{@class}\r\n"
+        snp_open do |snp|
           snp.register(@app)
-          snp.add_class(@class)
-          snp.unregister(@app)
+          snp.add_class(@class).request_str.should eql(expected)
+        end
+      end
+      it "snp.add_class(clsname, clstitle) has class=clsname#?title=clstitle" do
+        clstitle = 'classtitle'
+        expected = "type=SNP#?version=1.0#?action=add_class#?app=#{@app}#?class=#{@class}#?title=#{clstitle}\r\n"
+        snp_open do |snp|
+          snp.register(@app)
+          snp.add_class(@class, clstitle).request_str.should eql(expected)
         end
-      }.should_not raise_error
-    end
-    it "add same class raises error on verbose" do
-      Snarl::SNP.open(@host, @port) do |snp|
-        snp.verbose = true
-        snp.register(@app)
-        snp.add_class(@class)
-        lambda{snp.add_class(@class)}.should raise_error(Snarl::SNP::Error::SNP_ERROR_CLASS_ALREADY_EXISTS)
-        snp.unregister(@app)
       end
-      Snarl::SNP.open(@host, @port) do |snp|
-        snp.register(@app)
-        snp.add_class(@class)
-        lambda{snp.add_class(@app)}.should_not raise_error(Snarl::SNP::Error::SNP_ERROR_CLASS_ALREADY_EXISTS)
-        snp.unregister(@app)
+    end
+    it "raises error when snp has no @app yet" do
+      clstitle = 'classtitle'
+      snp_open do |snp|
+        lambda{snp.add_class(@class, clstitle)}.should raise_error(RuntimeError)
       end
     end
   end
 
   describe "#notification" do
-    it "sends title, text, icon, timeout, class" do
-      Snarl::SNP.open(@host) do |snp|
-        snp.register(@app)
-        snp.add_class(@class)
-        res = snp.notification('tit', 'tex(4 no icon popups)', 'ico', 9, 'cls')
+    describe "makes valid SNP command string" do
+      it "sends title, text, icon, timeout, class" do
         expected = "type=SNP#?version=1.0#?action=notification#?app=Ruby-Snarl#?class=cls#?title=tit#?text=tex(4 no icon popups)#?timeout=9#?icon=ico\r\n"
-        res.request.to_s.should eql(expected)
+        snp_open do |snp|
+          snp.register(@app)
+          snp.add_class(@class)
+          res = snp.notification('tit', 'tex(4 no icon popups)', 'ico', 9, 'cls')
+          res.request_str.should eql(expected)
+        end
       end
-    end
-    it "sends keyword-hash, keys=[:title, :text, :icon, :timeout, :class]" do
-      Snarl::SNP.open(@host) do |snp|
-        snp.register(@app)
-        snp.add_class(@class)
-        res = snp.notification(:title => 'tit', :text => 'tex', :icon => 'ico', :timeout => 9, :class => 'cls')
+      it "sends keyword-hash, keys=[:title, :text, :icon, :timeout, :class]" do
         expected = "type=SNP#?version=1.0#?action=notification#?app=Ruby-Snarl#?class=cls#?title=tit#?text=tex#?timeout=9#?icon=ico\r\n"
-        res.request.to_s.should eql(expected)
+        snp_open do |snp|
+          snp.register(@app)
+          snp.add_class(@class)
+          res = snp.notification(:title => 'tit', :text => 'tex', :icon => 'ico', :timeout => 9, :class => 'cls')
+          res.request_str.should eql(expected)
+        end
       end
-    end
-   it "sends 'anonymous' message if not registered yet" do
-      Snarl::SNP.open(@host) do |snp|
-        res = snp.notification('tit', 'tex', 'ico', 9)
+      it "sends 'anonymous' message if not registered yet" do
         expected = "type=SNP#?version=1.0#?action=notification#?title=tit#?text=tex#?timeout=9#?icon=ico\r\n"
-        res.request.to_s.should eql(expected)
+        snp_open do |snp|
+          res = snp.notification('tit', 'tex', 'ico', 9)
+          res.request_str.should eql(expected)
+        end
       end
-    end
-    it "sends 'anonymous' message if keyhash has {:app => nil} pair" do
-      Snarl::SNP.open(@host) do |snp|
-        res = snp.notification(:app => nil, :title => 'tit', :text => 'tex', :icon => 'ico', :timeout => 9)
+      it "sends 'anonymous' message if keyhash has {:app => nil} pair" do
         expected = "type=SNP#?version=1.0#?action=notification#?title=tit#?text=tex#?timeout=9#?icon=ico\r\n"
-        res.request.to_s.should eql(expected)
+        snp_open do |snp|
+          res = snp.notification(:app => nil, :title => 'tit', :text => 'tex', :icon => 'ico', :timeout => 9)
+          res.request_str.should eql(expected)
+        end
       end
     end
   end
 
   describe "#hello" do
-    it "returns Snarl release identifier" do
-      Snarl::SNP.open(@host) do |snp|
-        snp.hello.infomation.should match(/\ASnarl /)
+    it "makes valid SNP command string" do
+      expected = "type=SNP#?version=1.0#?action=hello\r\n"
+      snp_open do |snp|
+        snp.hello.request_str.should eql(expected)
       end
     end
   end
 
   describe "#version" do
-    it "returns Snarl (inner) version" do
-      Snarl::SNP.open(@host) do |snp|
-        snp.version.infomation.should match(/[\d\.]+/)
+    it "makes valid SNP command string" do
+      expected = "type=SNP#?version=1.0#?action=version\r\n"
+      snp_open do |snp|
+        snp.version.request_str.should eql(expected)
       end
     end
   end
@@ -141,10 +134,10 @@ describe "SNP" do
       expected = {:action => 'notification', :title => @default_title, :text => "text", :timeout => @default_timeout}
       normalize_notification_params(params).should eql(expected)
     end
-    it "['text'] returns {:title => snp.title, :text => 'text', :timeout => DEFAULT_TIMEOUT}, when snp.title is set" do
+    it "['text'] returns {:title => snp.title, :text => 'text', :timeout => DEFAULT_TIMEOUT}, when snp['title'] is set" do
       params = ['text']
       snp = Snarl::SNP.new
-      snp.title = 'snp.title'
+      snp['title'] = 'snp.title'
       expected = {:action => 'notification', :title => 'snp.title', :text => "text", :timeout => @default_timeout}
       snp.__send__(:normalize_notification_params, params).should eql(expected)
     end
@@ -153,10 +146,10 @@ describe "SNP" do
       expected = {:action => 'notification', :title => @default_title, :text => "text", :timeout => 9}
       normalize_notification_params(params).should eql(expected)
     end
-    it "['text', 9] returns {:title => snp.title, :text => 'text', :timeout => 9}, when snp.title is set" do
+    it "['text', 9] returns {:title => snp.title, :text => 'text', :timeout => 9}, when snp['title'] is set" do
       params = ['text', 9]
       snp = Snarl::SNP.new
-      snp.title = 'snp.title'
+      snp['title'] = 'snp.title'
       expected = {:action => 'notification', :title => 'snp.title', :text => "text", :timeout => 9}
       snp.__send__(:normalize_notification_params, params).should eql(expected)
     end
@@ -180,19 +173,89 @@ describe "SNP" do
     end
     it "when already registered, app is @app" do
       params = [{:text => 'text'}]
+      app = 'app'
       snp = Snarl::SNP.new
-      snp.instance_variable_set(:@app, 'app')
-      expected = {:action => 'notification', :app => 'app', :title => @default_title, :text => "text", :timeout => @default_timeout}
+      snp['app'] = app
+      expected = {:action => 'notification', :app => app, :title => @default_title, :text => "text", :timeout => @default_timeout}
       snp.__send__(:normalize_notification_params, params).should eql(expected)
     end
-    it "if @app is :anonymous, app is nil" do
+    it "if @app is nil, app is unset" do
       params = [{:text => 'text'}]
       snp = Snarl::SNP.new
-      snp.instance_variable_set(:@app, :anonymous)
-      expected = {:action => 'notification', :app => nil, :title => @default_title, :text => "text", :timeout => @default_timeout}
+      snp['app'] = nil
+      expected = {:action => 'notification', :title => @default_title, :text => "text", :timeout => @default_timeout}
       snp.__send__(:normalize_notification_params, params).should eql(expected)
     end
+    it "title == param['title'] || snp['title'] || 'Ruby-Snarl'" do
+      param_title = 'param_title'
+      snp_title = 'snp_title'
+
+      params = [{:title => param_title}]
+      Snarl::SNP.new do |snp|
+        snp['title'] = snp_title
+        snp.__send__(:normalize_notification_params, params)[:title].should eql(param_title)
+      end
+
+      params = [{}]
+      Snarl::SNP.new do |snp|
+        snp['title'] = snp_title
+        snp.__send__(:normalize_notification_params, params)[:title].should eql(snp_title)
+      end
+
+      params = [{}]
+      Snarl::SNP.new do |snp|
+        snp.__send__(:normalize_notification_params, params)[:title].should eql(Snarl::SNP::DEFAULT_TITLE)
+      end
+    end
+    it "timeout == param['timeout'] || snp['timeout'] || 10" do
+      param_timeout = 11
+      snp_timeout = 12
+
+      params = [{:timeout => param_timeout}]
+      Snarl::SNP.new do |snp|
+        snp['timeout'] = snp_timeout
+        snp.__send__(:normalize_notification_params, params)[:timeout].should eql(param_timeout)
+      end
+
+      params = [{}]
+      Snarl::SNP.new do |snp|
+        snp['timeout'] = snp_timeout
+        snp.__send__(:normalize_notification_params, params)[:timeout].should eql(snp_timeout)
+      end
+
+      params = [{}]
+      Snarl::SNP.new do |snp|
+        snp.__send__(:normalize_notification_params, params)[:timeout].should eql(Snarl::SNP::DEFAULT_TIMEOUT)
+      end
+    end
+    it "icon == iconset(param['icon']) || param['icon'] || snp['icon'] || #unset" do
+      set_icon = ':set_icon'
+      param_icon = 'param_icon'
+      snp_icon = 'snp_icon'
+
+      params = [{:icon => :set_icon}]
+      Snarl::SNP.new do |snp|
+        snp['iconset'] = {:set_icon => set_icon}
+        snp['icon'] = snp_icon
+        snp.__send__(:normalize_notification_params, params)[:icon].should eql(set_icon)
+      end
+
+      params = [{:icon => param_icon}]
+      Snarl::SNP.new do |snp|
+        snp['icon'] = snp_icon
+        snp.__send__(:normalize_notification_params, params)[:icon].should eql(param_icon)
+      end
+
+      params = [{}]
+      Snarl::SNP.new do |snp|
+        snp['icon'] = snp_icon
+        snp.__send__(:normalize_notification_params, params)[:icon].should eql(snp_icon)
+      end
 
+      params = [{}]
+      Snarl::SNP.new do |snp|
+        snp.__send__(:normalize_notification_params, params).should_not have_key(:icon)
+      end
+    end
   end
 end
-