file_scheduler 0.0.2

data/lib/file_scheduler/scheduling.rb

@@ -0,0 +1,59 @@
+module FileScheduler
+  class Scheduling
+
+    attr_accessor :root, :time, :log
+
+    def initialize(root, time)
+      @root = root
+      @time = time
+    end
+
+    def log
+      @log ||= FileScheduler::Log.new
+    end
+
+    def schedulable?(content)
+      schedulable_by_time?(content) and 
+        schedulable_by_repeat?(content)
+    end
+
+    def schedulable_by_time?(content)
+      content.time_constraints.nil? or
+        content.time_constraints.matches?(time)
+    end
+
+    def schedulable_by_repeat?(content)
+      content.repeat_constraints.nil? or
+        log.distance(content).nil? or
+        log.distance(content) >= content.repeat_constraints
+    end
+
+    def schedulable_contents
+      @schedulable_contents ||= root.contents.select do |content|
+        schedulable? content
+      end
+    end
+
+    def forced_contents
+      schedulable_contents.select &:forced_started_time?
+    end
+
+    def forced_next
+      forced_contents.first
+    end
+
+    def schedulable_next
+      schedulable_contents.shuffle.first
+    end
+
+    def next_without_log
+      forced_next or schedulable_next
+    end
+
+    def next_with_log
+      log.log(next_without_log)
+    end
+    alias_method :next, :next_with_log
+
+  end
+end

data/lib/file_scheduler/time_chain.rb

@@ -0,0 +1,19 @@
+module FileScheduler
+  class TimeChain
+
+    attr_reader :parts
+
+    def initialize(*parts)
+      @parts = parts.flatten
+    end
+
+    def ==(other)
+      other.respond_to?(:parts) and parts == other.parts
+    end
+
+    def to_s
+      parts.join('/')
+    end
+
+  end
+end

data/lib/file_scheduler/time_interval.rb

@@ -0,0 +1,38 @@
+require 'set'
+
+module FileScheduler
+  class TimeInterval
+
+    attr_reader :from, :to
+    
+    def initialize(from, to)
+      @from, @to = from, to
+    end
+
+    def include?(time)
+      if from > to
+        not time.between?(to, from)
+      else
+        time.between?(from, to)
+      end
+    end
+
+    alias_method :matches?, :include?
+
+    def ==(other)
+      [:from, :to].all? do |attribute|
+        other.respond_to?(attribute) and send(attribute) == other.send(attribute)
+      end
+    end
+
+    def to_s
+      "#{from}-#{to}"
+    end
+
+    def inspect
+      to_s
+    end
+
+  end
+
+end

data/lib/file_scheduler/time_mark.rb

@@ -0,0 +1,66 @@
+class Time
+  alias_method :minute, :min
+  alias_method :week_day, :wday
+
+  alias_method :compare_to_without_time_mark_support, :<=>
+
+  def <=>(other)
+    if FileScheduler::TimeMark === other
+      -(other <=> self)
+    else
+      compare_to_without_time_mark_support other
+    end
+  end
+end
+
+module FileScheduler
+  class TimeMark
+
+    attr_reader :attributes
+    
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
+
+    def matches?(time)
+      attributes.all? do |attribute, value|
+        time.send(attribute) == value
+      end
+    end
+
+    def [](attribute)
+      attributes[attribute]
+    end
+
+    [:year, :month, :day, :hour, :minute, :week_day].each do |attribute|
+      define_method(attribute) do
+        attributes[attribute]
+      end
+    end
+
+    def <=>(time)
+      [:year, :month, :day, :week_day, :hour, :minute].each do |attribute|
+        value = attributes[attribute]
+        if value
+          comparaison = value <=> time.send(attribute)
+          return comparaison unless comparaison == 0
+        end
+      end
+
+      0
+    end
+
+    include Comparable
+
+    def to_s
+      [:year, :month, :day, :week_day, :hour, :minute].collect do |attribute|
+        value = attributes[attribute]
+        if value
+          suffix = attribute == :month ? "M" : attribute.to_s.chars.first
+          "#{value}#{suffix}"
+        end
+      end.join
+    end
+
+  end
+end

data/lib/file_scheduler/time_parser.rb

@@ -0,0 +1,37 @@
+module FileScheduler
+  class TimeParser
+
+    @@time_mark_fields =
+      [["y", 4], ["M", 2], ["d", 2], ["w", 1], ["h", 2], ["m", 2]]
+
+    def self.time_mark_format
+      @@time_mark_fields.collect do |field|
+        "(\\d{#{field[1]}}#{field[0]})?"
+      end.join
+    end
+
+    def parse(string)
+      parsed_fields = string.scan(/^T?#{self.class.time_mark_format}(-#{self.class.time_mark_format})?/).first.map do |field|
+        field.to_i if field
+      end
+
+      from = time_mark(parsed_fields.first(6))
+      to = time_mark(parsed_fields.last(6))
+
+      if to
+        TimeInterval.new from, to
+      else
+        from
+      end
+    end
+
+    def time_mark(parsed_fields)
+      unless parsed_fields.all?(&:nil?)
+        attributes = Hash[ [[:year, :month, :day, :week_day, :hour, :minute], parsed_fields].transpose ]
+        attributes.delete_if { |k,v| v.nil? }
+        TimeMark.new attributes
+      end
+    end
+
+  end
+end

data/lib/file_scheduler/url.rb

@@ -0,0 +1,56 @@
+module FileScheduler
+  class URL
+    include FileScheduler::Content
+
+    attr_accessor :path, :url
+
+    def initialize(attributes = {})
+      if String === attributes
+        attributes = { :path => attributes }
+      end
+
+      attributes.each { |k,v| send "#{k}=", v }
+    end
+
+    def ==(other)
+      other.respond_to?(:path) and path == other.path
+    end
+
+    def hidden?
+      path_parts.any? do |part|
+        part.start_with?("_")
+      end
+    end
+
+    def path_parts
+      @path_parts ||= path.split("/")
+    end
+
+    def name
+      @path_parts.last
+    end
+
+    def time_constraints
+      part_constraints = path_parts.collect do |part|
+        parser.parse(part)
+      end.compact
+
+      if part_constraints.size > 1
+        FileScheduler::TimeChain.new part_constraints
+      else
+        part_constraints.first
+      end
+    end
+    
+    def to_s
+      (url and url.to_s) or path 
+    end
+
+    def attributes
+      @attributes ||= path_parts.inject({}) do |attributes, part|
+        attributes.merge attributes_parser.parse(part)
+      end
+    end
+
+  end
+end

data/lib/file_scheduler/version.rb

@@ -0,0 +1,3 @@
+module FileScheduler
+  VERSION = "0.0.2"
+end

data/spec/lib/file_scheduler/attributes_parser_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe FileScheduler::AttributesParser do
+
+  it "should be empty without {}" do
+    subject.parse("dummy").should be_empty
+  end
+
+  it "should be empty when {} is empty" do
+    subject.parse("dummy{}").should be_empty
+  end
+
+  it "should use {...} at the end of name" do
+    subject.parse("dummy{key=value}").should == { :key => "value" }
+  end
+
+  it "should use {...} before file extension" do
+    subject.parse("dummy{key=value}.wav").should == { :key => "value" }
+  end
+
+  it "should not use {...} before a simple dot" do
+    subject.parse("dummy{key=value}.otherpart.wav").should be_empty
+  end
+
+  it "should support several attributes" do
+    subject.parse("dummy{key1=value1,key2=value2}").should == { :key1 => "value1", :key2 => "value2" }
+  end
+
+  it "should strip spaces" do
+    subject.parse("dummy{ key1 = value1 , key2 = value2 }").should == { :key1 => "value1", :key2 => "value2" }
+  end
+
+end

data/spec/lib/file_scheduler/base_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe FileScheduler::Base do
+
+  before(:each) do
+    subject.root = mock(:contents => mock)
+  end
+
+  let(:content) { mock }
+
+  describe "#contents" do
+
+    it "should return root contents" do
+      subject.contents.should == subject.root.contents
+    end
+    
+  end
+
+  describe "scheduling" do
+
+    let(:time) { Time.now }
+    
+    it "should return a Scheduling with specified time" do
+      subject.scheduling(time).time.should == time
+    end
+
+    it "should return a Scheduling with the same root" do
+      subject.scheduling.root.should == subject.root
+    end
+
+    it "should return a Scheduling with the same log" do
+      subject.scheduling.log.should == subject.log
+    end
+
+  end
+
+  describe "next" do
+
+    let(:next_content) { content }
+    
+    before(:each) do
+      subject.stub :scheduling => mock(:next => content)
+    end
+    
+    it "should return the next content choosed by scheduling" do
+      subject.next.should == next_content
+    end
+
+    it "should invoke after_next with selected content" do
+      subject.should_receive(:after_next).with(next_content)
+      subject.next
+    end
+
+  end
+
+  describe "forced_next" do
+
+    let(:forced_content) { content }
+    
+    before(:each) do
+      subject.stub :scheduling => mock(:forced_next => content)
+    end
+    
+    it "should return the forced content choosed by scheduling" do
+      subject.forced_next.should == forced_content
+    end
+
+    it "should invoke after_next with selected content" do
+      subject.should_receive(:after_next).with(forced_content)
+      subject.forced_next
+    end
+
+  end
+
+end

data/spec/lib/file_scheduler/content_shared_examples.rb

@@ -0,0 +1,12 @@
+shared_examples "a content" do
+
+  describe "#repeat_constraints" do
+    
+    it "should return the number defined by 'repeat' attribute" do
+      subject.stub :attributes => { :repeat => "5" }
+      subject.repeat_constraints.should == 5
+    end
+
+  end
+
+end

data/spec/lib/file_scheduler/file_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe FileScheduler::File do
+
+  subject { file "dummy" }
+
+  def file(file, parent = nil)
+    FileScheduler::File.new file, parent
+  end
+
+  describe "#name" do
+    
+    it "should use path basename" do
+      file("/path/to/basename").name.should == "basename"
+    end
+
+  end
+
+  describe "#local_time_constraints" do
+    
+    it "should parse the time specifications in the name" do
+      file("/path/to/12h30m-dummy",mock).local_time_constraints.should == FileScheduler::TimeMark.new(:hour => 12, :minute => 30)
+    end
+
+    it "should be nil when parent isn't defined (root directory)" do
+      file("/path/to/12h30m-dummy").local_time_constraints.should be_nil
+    end
+
+  end
+
+  describe "#time_constraints" do
+
+    it "should concat with parent constraints" do
+      parent = mock(:time_constraints => FileScheduler::TimeMark.new(:week_day => 1))
+      file("/path/1w/12h30m-dummy", parent).time_constraints.should == FileScheduler::TimeChain.new(parent.time_constraints, FileScheduler::TimeMark.new(:hour => 12, :minute => 30))
+    end
+
+  end
+
+  describe "file_system_children" do
+    
+    it "should return pathnames of files and directories present under file" do
+      Dir.mktmpdir do |base|
+        base = Pathname.new(base)
+
+        file = base.touch "file"
+        directory = base.mkpath "directory"
+
+        file(base).file_system_children.should include(file, directory)
+      end
+    end
+
+  end
+
+  describe "children" do
+    
+    it "should return children created from files and directories present under path" do
+      Dir.mktmpdir do |base|
+        base = Pathname.new(base)
+
+        file = base.touch "file"
+        directory = base.mkpath "directory"
+
+        parent = file(base)
+        parent.children.should include(file(file, parent))
+        parent.children.should include(file(directory, parent))
+      end
+    end
+
+    it "should ignore files prefixed with underscore" do
+      Dir.mktmpdir do |base|
+        base = Pathname.new(base)
+
+        file = base.touch "_ignored_file"
+        directory = base.mkpath "_ignored_directory"
+        
+        file(base).children.should be_empty
+      end
+    end
+
+  end
+
+  describe "local_attributes" do
+    
+    it "should use attributes found in name" do
+      file("dummy{key=value}.wav").local_attributes.should == { :key => "value" }
+    end
+
+  end
+
+  describe "#attributes" do
+
+    it "should merge parent attributes with local attributes" do
+      parent = mock(:attributes => {:key1 => "parent_value1", :key2 => "value2"})
+      file("dummy{key1=value1}.wav",parent).attributes.should == { :key1 => "value1", :key2 => "value2" }
+    end
+    
+  end
+
+  require File.expand_path("../content_shared_examples", __FILE__)
+
+  it_behaves_like "a content"
+
+end