polling 0.0.7 → 0.1.1

data/README.md

@@ -14,10 +14,10 @@ Or install it yourself as:
 
 ## Usage
 
-It starts at per minute 0 second. 
+New Interface
 
-    time = [0,10,20,30,40,50]
-    Polling::run(time,debug=true) do
+    require 'polling'
+    Polling.start 10 do
       puts "test"
       sleep 2
     end
@@ -40,6 +40,64 @@ result
     sleep 7.998055934906006seconds (until 2012-11-16 19:49:00 +0900)
     test
     sleep 7.998072147369385seconds (until 2012-11-16 19:49:10 +0900)
+
+set offset
+
+    require 'polling'
+    Polling.setting offset: 30
+    Polling.start 5 do
+      puts "exec sleep 2"
+      sleep 2
+    end
+
+result
+
+    start: 2013-03-24 23:38:25 +0900                                 
+    sleep 4.086651802062988seconds (until 2013-03-24 23:38:30 +0900) 
+    2013-03-24 23:38:30 +0900                                        
+    exec sleep 2                                                     
+    sleep 2.9990789890289307seconds (until 2013-03-24 23:38:35 +0900)
+    2013-03-24 23:38:35 +0900                                        
+    exec sleep 2                                                     
+    sleep 2.9979379177093506seconds (until 2013-03-24 23:38:40 +0900)
+    2013-03-24 23:38:40 +0900                                        
+    exec sleep 2                                                     
+    sleep 2.9986801147460938seconds (until 2013-03-24 23:38:45 +0900)
+    2013-03-24 23:38:45 +0900                                        
+    exec sleep 2                                                     
+    sleep 2.998732089996338seconds (until 2013-03-24 23:38:50 +0900) 
+
+debug
+
+    require 'polling'
+    Polling.setting offset: 5, debug: true
+    Polling.start 5 do
+      puts "test"
+      sleep 2
+    end
+
+or
+
+    require 'polling'
+    Polling.start 5,true do
+      puts "test"
+      sleep 2
+    end
+
+Time which can be set up 
+
+- 1 or other integer
+- "5s" or like string type [s|m|h|d]
+- [0,10,20,30,40,50] array class
+
+Support legacy interface.
+It starts at per minute 0 second. 
+
+    time = [0,10,20,30,40,50]
+    Polling::run(time,debug=true) do
+      puts "test"
+      sleep 2
+    end
     
 The multiple of 60 is set up. 
 

data/lib/polling/engine.rb

@@ -0,0 +1,71 @@
+#encoding: utf-8
+module Polling
+  class Engine
+    attr_accessor :target, :offset
+    def initialize
+      @target = @offset = 0
+      @init_time = 60
+    end
+
+    def increment! interval
+      @init_time = interval if interval > 60
+      @target += interval
+    end
+
+    def substitution! interval
+      @init_time = interval if interval > 60
+      @target = interval
+    end
+
+    def stime opts={}
+      opts = {target: @target, init_time: @init_time}.merge opts
+
+      case
+      when target(opts[:target]) < opts[:init_time]
+        stime = make_sleep(opts[:target],now_sec_to_f)
+        stime += opts[:init_time] if opts[:target].eql? 0
+      when target(opts[:target]) >= opts[:init_time]
+        decrement!
+        stime = make_sleep(opts[:target],now_sec_to_f) + opts[:init_time]
+      end
+
+      stime += @offset
+      stime -= opts[:init_time] if stime > opts[:init_time]
+
+      if stime < 0
+        stime = opts[:init_time] - stime.abs
+      end
+
+      debug debug: opts[:debug], stime: stime
+      stime
+    rescue => ex
+      $stderr.puts ex.to_s
+      return opts[:init_time]
+    end
+
+    private
+
+    def target target=@target, offset=@offset
+      target + offset
+    end
+
+    def now_sec_to_f init_time=@init_time
+      Time.now.to_f % init_time
+    end
+
+    def make_sleep target=@target, now
+      target - now
+    end
+
+    def decrement! init_time=@init_time
+      @target -= init_time
+    end
+
+    def debug opts={}
+      if opts[:debug]
+        until_time = Time.at(Time.now.to_f + opts[:stime])
+        $stdout.print "sleep #{opts[:stime]}seconds (until #{until_time})\n"
+      end
+    end
+  end
+end

data/lib/polling/sleep.rb

@@ -1,7 +1,6 @@
 module Polling
   module Sleep
-    module_function
-    def exec(stime)
+    def self.exec stime
       stime > 0 ? (sleep stime) : false
     end
   end

data/lib/polling/utils.rb

@@ -0,0 +1,21 @@
+module Polling
+  class Utils
+    class << self
+      def convert(value)
+        case value
+        when /(\d+)s/
+          value = $1.to_i
+        when /(\d+)m/
+          value = $1.to_i*60
+        when /(\d+)h/
+          value = $1.to_i*60*60
+        when /(\d+)d/
+          value = $1.to_i*60*60*24
+        when String
+          value = value.to_i
+        end
+        return value
+      end
+    end
+  end
+end

data/lib/polling/validate.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__),"utils")
+module Polling
+  module Validate
+    def self.value value
+      case value
+      when Array
+        if value.size.eql? 1
+          value = value[0]
+          if value.class == String
+            value = Utils.convert value
+          end
+        elsif value.size > 1
+          if value[0].class == String
+            value = value.map {|i| i.to_i}
+          end
+        end
+      when String
+        value = Utils.convert value
+      end
+      value
+    end
+  end
+end

data/lib/polling/version.rb

@@ -1,3 +1,3 @@
 module Polling
-  VERSION = "0.0.7"
+  VERSION = "0.1.1"
 end

data/lib/polling.rb

@@ -1,23 +1,55 @@
-require 'polling/version'
-require 'polling/confirm'
+require 'polling/engine'
 require 'polling/sleep'
-require 'polling/target'
+require 'polling/validate'
+require 'polling/utils'
 
 module Polling
-  module_function
-  def run(arr, debug=false)
-    arr = Confirm::check_arr(arr)
-    args = {:start => false, :debug => debug}
-    Sleep::exec Target::interval(0,args)
-    args[:start] = true
-    loop do 
-      arr.each do |time|
-        time = Confirm::check_value(time)
-        time = 0 if args[:start] && time >= 60
-        Sleep::exec Target::interval(time,args)
-        args[:start] = false
-        yield
+  class << self
+    def setting opts={}
+      set_instance_variables opts
+    end
+
+    def run interval=@interval, debug=false
+      @offset ||= 0
+      @debug ||= debug
+      e = Engine.new
+      e.offset = @offset
+
+      exec = lambda do |time|
+        yield if block_given?
+        e.target = e.increment! time
+        Sleep.exec e.stime(:debug=>@debug)
+      end
+
+      exec_arr = lambda do |time_arr|
+        time_arr.each do |time|
+          e.target = e.substitution! time
+          Sleep.exec e.stime(:debug=>@debug)
+          yield if block_given?
+        end
+      end
+
+      interval = Validate.value interval
+
+      case interval
+      when Array
+        loop { exec_arr.call interval }
+      else
+        Sleep.exec e.stime(:debug=>@debug)
+        loop { exec.call interval }
+      end
+    rescue => ex
+      $stderr.puts ex.message
+    end
+
+    private
+
+    def set_instance_variables variables
+      variables.each do |key,var|
+        instance_variable_set "@#{key}", var
       end
     end
+
+    alias start run
   end
 end

data/test/helper.rb

@@ -4,3 +4,4 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'test/unit'
 require 'mocha/setup'
 require 'polling'
+require 'time'

data/test/run.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+
+class Polling::Test < Test::Unit::TestCase
+  def test_run
+    puts "start: #{Time.now}"
+    Polling.setting offset: 5, debug: true
+    #Polling::run [0,10,20,30,40,50] do
+    Polling::run 10 do
+      puts Time.now
+      puts "exec sleep 2"
+      sleep 2
+    end
+  end
+end

data/test/test_engine.rb

@@ -0,0 +1,103 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+
+class Polling::Engine::Test < Test::Unit::TestCase
+  def setup
+    @e = Polling::Engine.new
+  end
+
+  def test_engine_initialize
+    assert_equal 0, @e.offset
+    assert_equal 5, @e.target = 5
+  end
+
+  def test_increment!
+    @e.target = 0
+    assert_equal 10, @e.increment!(10)
+    @e.target = 60
+    assert_equal 130, @e.increment!(70)
+  end
+
+  def test_substitution!
+    @e.target = 0
+    assert_equal 10, @e.substitution!(10)
+    @e.target = 60
+    assert_equal 70, @e.substitution!(70)
+  end
+
+  def test_stime
+    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:00")
+    assert_equal 60, @e.stime(target: 0)
+
+    arr = [1,5,10,20,30,40,50,58,60,120,300,500]
+    arr.each do |time|
+      assert_equal time, @e.stime(target: time)
+    end
+
+    assert_equal 10, @e.stime(target: @e.substitution!(10))
+    assert_equal 20, @e.stime(target: @e.substitution!(20))
+    assert_equal 30, @e.stime(target: @e.substitution!(30))
+
+    @e.target = 10
+    assert_equal 20, @e.stime(target: @e.increment!(10))
+    assert_equal 40, @e.stime(target: @e.increment!(20))
+    assert_equal 70, @e.stime(target: @e.increment!(30))
+
+    Time.stubs(:now).returns(Time.parse "2012/12/31 23:50:20")
+    arr = [30,40,50,60,70,80,90,60,120,300,500]
+    arr.each do |time|
+      assert_equal time - 20, @e.stime(target: time)
+    end
+
+    Time.stubs(:now).returns(Time.parse "2012/12/31 23:59:50")
+    @e.target = 0
+    assert_equal 10, @e.stime(target: 0)
+    @e.target = 60
+    assert_equal 70, @e.stime(target: @e.increment!(60))
+    @e.target = 120
+    assert_equal 130, @e.stime(target: @e.increment!(120))
+    @e.target = 600
+    assert_equal 610, @e.stime(target: @e.increment!(300))
+  end
+
+  def test_target
+    assert_equal 0, @e.__send__(:target, 0, 0)
+    assert_equal 10, @e.__send__(:target, 10, 0)
+    assert_equal 5, @e.__send__(:target, 0, 5)
+    assert_equal 15, @e.__send__(:target, 10, 5)
+  end
+
+  def test_now_sec_to_f
+    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:00")
+    assert_equal 0, @e.__send__(:now_sec_to_f, 60)
+    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:30")
+    assert_equal 30, @e.__send__(:now_sec_to_f, 60)
+    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:33")
+    assert_equal 33, @e.__send__(:now_sec_to_f, 60)
+    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:30")
+    assert_equal 30, @e.__send__(:now_sec_to_f, 120)
+  end
+
+  def test_make_sleep
+    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:30")
+    assert_equal -20, @e.__send__(:make_sleep, 10, @e.__send__(:now_sec_to_f,60))
+    assert_equal -10, @e.__send__(:make_sleep, 20, @e.__send__(:now_sec_to_f,60))
+    assert_equal 0, @e.__send__(:make_sleep, 30, @e.__send__(:now_sec_to_f,60))
+    assert_equal 10, @e.__send__(:make_sleep, 40, @e.__send__(:now_sec_to_f,60))
+    assert_equal 90, @e.__send__(:make_sleep, 120, @e.__send__(:now_sec_to_f,60))
+  end
+
+  def test_decrement!
+    @e.target = 70
+    assert_equal 10, @e.__send__(:decrement!, 60)
+    assert_equal -110, @e.__send__(:decrement!, 120)
+  end
+
+  def test_debug
+    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:30")
+    opts = {
+      debug: true,
+      stime: 40
+    }
+    assert_nil @e.__send__(:debug, opts)
+  end
+end

data/test/test_main.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+
+class Polling::Test < Test::Unit::TestCase
+  def test_setting
+    hash = {:offset=>0}
+    assert_equal hash, Polling.setting(offset:0)
+    hash = {:offset=>30,:debug=>true}
+    assert_equal hash, Polling.setting(offset:30,debug:true)
+  end
+end

data/test/test_sleep.rb

@@ -1,9 +1,9 @@
 require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
 
-class PollingTest < Test::Unit::TestCase
-  def test_sleep
-    assert_equal false, Polling::Sleep::exec(-1)
-    assert_equal false, Polling::Sleep::exec(0)
-    #assert_equal 5, Polling::Sleep::exec(5)
+class Polling::Sleep::Test < Test::Unit::TestCase
+  def test_sleep_exec
+    assert_equal false, Polling::Sleep.exec(-1)
+    assert_equal false, Polling::Sleep.exec(0)
+    assert_equal 1, Polling::Sleep.exec(1)
   end
 end

data/test/test_utils.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+
+class Polling::Utils::Test < Test::Unit::TestCase
+  def test_utils_convert
+    assert_equal 0, Polling::Utils.convert(0)
+    assert_equal 60, Polling::Utils.convert(60)
+
+    assert_equal 0, Polling::Utils.convert("0")
+    assert_equal 60, Polling::Utils.convert("60")
+    assert_equal 120, Polling::Utils.convert("120")
+
+    assert_equal 0, Polling::Utils.convert("0s")
+    assert_equal 10, Polling::Utils.convert("10s")
+    assert_equal 60, Polling::Utils.convert("60s")
+    assert_equal 60, Polling::Utils.convert("1m")
+    assert_equal 300, Polling::Utils.convert("5m")
+    assert_equal 1800, Polling::Utils.convert("30m")
+    assert_equal 3600, Polling::Utils.convert("1h")
+    assert_equal 18000, Polling::Utils.convert("5h")
+    assert_equal 86400, Polling::Utils.convert("1d")
+    assert_equal 432000, Polling::Utils.convert("5d")
+
+    assert_equal [0], Polling::Utils.convert([0])
+    assert_equal [60], Polling::Utils.convert([60])
+    assert_equal [0,10,20,30,40,50], Polling::Utils.convert([0,10,20,30,40,50])
+  end
+end

data/test/test_validate.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
+
+class Polling::Validate::Test < Test::Unit::TestCase
+  def test_validate_value
+    assert_equal 0, Polling::Validate.value(0)
+    assert_equal 60, Polling::Validate.value(60)
+
+    assert_equal 0, Polling::Validate.value("0")
+    assert_equal 60, Polling::Validate.value("60")
+    assert_equal 120, Polling::Validate.value("120")
+
+    assert_equal 0, Polling::Validate.value("0s")
+    assert_equal 10, Polling::Validate.value("10s")
+    assert_equal 60, Polling::Validate.value("60s")
+    assert_equal 60, Polling::Validate.value("1m")
+    assert_equal 300, Polling::Validate.value("5m")
+    assert_equal 1800, Polling::Validate.value("30m")
+    assert_equal 3600, Polling::Validate.value("1h")
+    assert_equal 18000, Polling::Validate.value("5h")
+    assert_equal 86400, Polling::Validate.value("1d")
+    assert_equal 432000, Polling::Validate.value("5d")
+
+    assert_equal 0, Polling::Validate.value([0])
+    assert_equal 60, Polling::Validate.value([60])
+    assert_equal [0,10,20,30,40,50], Polling::Validate.value([0,10,20,30,40,50])
+    assert_equal [0,10,20,30,40,50], Polling::Validate.value(["0","10","20","30","40","50"])
+    assert_equal [5,15,25,35,45,55], Polling::Validate.value(["5","15","25","35","45","55"])
+
+    assert_equal 0, Polling::Validate.value(["0"])
+    assert_equal 60, Polling::Validate.value(["60"])
+    assert_equal 10, Polling::Validate.value(["10s"])
+    assert_equal 60, Polling::Validate.value(["60s"])
+    assert_equal 60, Polling::Validate.value(["1m"])
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polling
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2013-03-26 00:00:00.000000000 Z
 dependencies: []
 description: polling
 email:
@@ -24,16 +24,19 @@ files:
 - README.md
 - Rakefile
 - lib/polling.rb
-- lib/polling/confirm.rb
+- lib/polling/engine.rb
 - lib/polling/sleep.rb
-- lib/polling/target.rb
+- lib/polling/utils.rb
+- lib/polling/validate.rb
 - lib/polling/version.rb
 - polling.gemspec
 - test/helper.rb
-- test/test_confirm.rb
-- test/test_run.rb
+- test/run.rb
+- test/test_engine.rb
+- test/test_main.rb
 - test/test_sleep.rb
-- test/test_target.rb
+- test/test_utils.rb
+- test/test_validate.rb
 homepage: https://github.com/hiro-su/polling
 licenses: []
 post_install_message: 
@@ -60,7 +63,9 @@ specification_version: 3
 summary: polling
 test_files:
 - test/helper.rb
-- test/test_confirm.rb
-- test/test_run.rb
+- test/run.rb
+- test/test_engine.rb
+- test/test_main.rb
 - test/test_sleep.rb
-- test/test_target.rb
+- test/test_utils.rb
+- test/test_validate.rb

data/lib/polling/confirm.rb

@@ -1,51 +0,0 @@
-module Polling
-  module Confirm
-    module_function
-    def check_value(value)
-      value = value.to_i
-      raise TypeError, "Please set a value that is multiple of 60." if (value % 60 != 0) && value > 60
-      return value
-    end
-
-    def check_arr(arr)
-      if arr.count == 1
-        time = convert(arr[0])
-        #arr = time < 60 ? create_arr(time) : [time]
-        arr = create_arr(time)
-        raise TypeError, "Please set a value that is divisible by 60." if (60 % time != 0) && time < 60
-      end
-      return arr
-    end
-
-    def convert(value)
-      case value
-      when /(\d+)s/
-        value = $1.to_i
-      when /(\d+)m/
-        value = $1.to_i*60
-      when /(\d+)h/
-        value = $1.to_i*60*60
-      when /(\d+)d/
-        value = $1.to_i*60*60*24
-      when String
-        value = value.to_i
-      end
-      return value
-    end
-
-    def create_arr(time)
-      arr = Array.new
-      if time < 60
-        arr << 0 if time != 0
-        result = time
-        while time < 60
-          arr << time
-          time += result
-        end
-      else
-        arr << time
-      end
-      return arr
-    end
-  end
-end

data/lib/polling/target.rb

@@ -1,27 +0,0 @@
-require 'time'
-
-module Polling
-  module Target
-    module_function
-
-    def interval(interval,*args)
-      init = 60
-      now_to_f = Time.now.to_f
-      stime = interval - (now_to_f % init)
-
-      args.each do |arg|
-        @start = arg[:start]
-        @debug = arg[:debug]
-      end
-
-      if !@start && stime < 0
-        stime = init - stime.abs
-      end
-
-      ### debug
-      print "sleep #{stime}seconds (until #{Time.at(now_to_f + stime)})\n" if @debug && stime > 0
-      return stime
-    end
-
-  end
-end

data/test/test_confirm.rb

@@ -1,34 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
-
-class PollingTest < Test::Unit::TestCase
-  def test_check_value
-    assert_equal 0, Polling::Confirm::check_value(0)
-    assert_equal 0, Polling::Confirm::check_value("0")
-    assert_equal 60, Polling::Confirm::check_value(60)
-    assert_equal 5, Polling::Confirm::check_value("5")
-  end
-
-  def test_convert
-    assert_equal 5, Polling::Confirm::convert(5)
-    assert_equal 5, Polling::Confirm::convert("5")
-    assert_equal 5, Polling::Confirm::convert("5s")
-    assert_equal 300, Polling::Confirm::convert("5m")
-    assert_equal 18000, Polling::Confirm::convert("5h")
-  end
-
-  def test_check_arr
-    assert_equal ["0","10","20","30","40","50"], Polling::Confirm::check_arr(["0","10","20","30","40","50"])
-    assert_equal [0,10,20,30,40,50], Polling::Confirm::check_arr([0,10,20,30,40,50])
-    assert_equal [0,10,20,30,40,50], Polling::Confirm::check_arr(["10s"])
-    assert_equal [60], Polling::Confirm::check_arr(["1m"])
-    assert_equal [120], Polling::Confirm::check_arr(["2m"])
-    assert_equal [1800], Polling::Confirm::check_arr(["30m"])
-    assert_equal [0,10,20,30,40,50], Polling::Confirm::check_arr(["10"])
-    assert_equal [0,10,20,30,40,50], Polling::Confirm::check_arr([10])
-    assert_equal [0,30], Polling::Confirm::check_arr([30])
-    assert_equal [60], Polling::Confirm::check_arr([60])
-    assert_equal [60], Polling::Confirm::check_arr(["60"])
-    assert_equal [60], Polling::Confirm::check_arr(["60s"])
-    assert_equal [120], Polling::Confirm::check_arr(["120s"])
-  end
-end

data/test/test_run.rb

@@ -1,15 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
-
-class PollingTest < Test::Unit::TestCase
-  #def test_run
-  #  puts "start: #{Time.now}"
-  #  #arr = [5,15,25,35,45,55]
-  #  #arr = ["0","10","20","30","40","50"]
-  #  #arr = ["10s"]
-  #  arr = ["3m"]
-  #  Polling::run(arr,true) do
-  #    puts Time.now
-  #    sleep 2
-  #  end
-  #end
-end

data/test/test_target.rb

@@ -1,31 +0,0 @@
-require File.expand_path(File.dirname(__FILE__)) + "/helper.rb"
-require 'time'
-
-class PollingTest < Test::Unit::TestCase
-
-  def test_target_time
-    Time.stubs(:now).returns(Time.parse "2012/12/31 23:59:59")
-    assert_equal 1, Polling::Target::interval(0)
-    assert_equal 6, Polling::Target::interval(5)
-    assert_equal 0, Polling::Target::interval(59)
-    assert_equal 1, Polling::Target::interval(60)
-    assert_equal 2, Polling::Target::interval(61)
-
-    arr = [0,1,5,10,20,30,40,50,58]
-    arr.each do |time|
-      assert_equal time+1, Polling::Target::interval(time)
-    end
-
-    debug = {:debug => true}
-    
-    Time.stubs(:now).returns(Time.parse "2012/01/01 00:00:00")
-    assert_equal 180, Polling::Target::interval(180,debug)
-    assert_equal 300, Polling::Target::interval(300,debug)
-    assert_equal 300, Polling::Target::interval(300,debug)
-    assert_equal 3600, Polling::Target::interval(3600,debug)
-    
-    Time.stubs(:now).returns(Time.parse "2012/11/19 10:16:00")
-    assert_equal 300, Polling::Target::interval(300,debug)
-  end
-  
-end