rivendell-import 0.0.1

data/lib/rivendell/import/cart.rb

@@ -0,0 +1,67 @@
+module Rivendell::Import
+  class Cart
+
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+
+    def attributes
+      %w{number group}.inject({}) do |map, attribute|
+        value = send attribute
+        map[attribute] = value if value
+        map
+      end
+    end
+
+    def attributes=(attributes)
+      attributes.each { |k,v| send "#{k}=", v }
+    end
+
+    delegate :blank?, :to => :attributes
+
+    attr_accessor :number, :group
+    attr_reader :task
+
+    def initialize(task = nil)
+      @task = task
+    end
+
+    def xport
+      task.xport
+    end
+
+    def create
+      unless number
+        raise "Can't create Cart, Group isn't defined" unless group.present?
+        self.number = xport.add_cart(:group => group).number
+      end
+    end
+
+    def update
+      # xport.edit_cart # to define title, etc ...
+    end
+    
+    def cut
+      @cut ||= Cut.new(self)
+    end
+
+    def import(file)
+      raise "File #{file.path} not found" unless file.exists?
+
+      cut.create
+      xport.import number, cut.number, file.path
+      cut.update
+    end
+
+    def find_by_title(string, options = {})
+      if remote_cart = carts_cache.find_by_title(string, options)
+        self.number = remote_cart.number
+      end
+    end
+
+    def carts_cache
+      @carts_cache ||= Rivendell::Import::CartsCache.new(xport)
+    end
+
+  end
+end
+  

data/lib/rivendell/import/carts_cache.rb

@@ -0,0 +1,58 @@
+module Rivendell::Import
+  class CartsCache
+
+    attr_accessor :xport
+
+    def initialize(xport)
+      @xport = xport
+    end
+
+    def find_all_by_title(string, options = {})
+      normalizer = options.delete(:normalizer) || Proc.new { |id| id }
+
+      string = normalizer.call(string)
+      carts(options).select do |cart|
+        normalizer.call(cart.title) == string
+      end
+    end
+    
+    def default_normalizer
+      Proc.new do |string|
+        string.downcase.gsub(/[^a-z0-9]/," ").gsub(/[ ]+/," ")
+      end
+    end
+
+    def find_by_title(string, options = {})
+      matching_carts = find_all_by_title(string, options)
+
+      if matching_carts.blank?
+        matching_carts = find_all_by_title(string, options.merge(:normalizer => default_normalizer))
+      end
+
+      matching_carts.first if matching_carts.one?
+    end
+
+    def cache
+      clear if purged_at < time_to_live.ago
+      @cache ||= {}
+    end
+
+    def clear
+      @cache = nil
+    end
+
+    @@time_to_live = 600
+    cattr_accessor :time_to_live
+
+    attr_accessor :purged_at
+
+    def purged_at
+      @purged_at ||= Time.now
+    end
+
+    def carts(options = {})
+      cache[options.to_s] ||= xport.list_carts(options)
+    end
+
+  end
+end

data/lib/rivendell/import/cli.rb

@@ -0,0 +1,90 @@
+require 'trollop'
+require 'logger'
+
+module Rivendell::Import
+  class CLI
+
+    attr_reader :arguments
+    attr_accessor :options_count
+
+    def initialize(arguments = [])
+      @arguments = arguments
+    end
+
+    def config_file
+      @config_file ||= options[:config]
+    end
+
+    def listen_mode?
+      options[:listen]
+    end
+
+    def dry_run?
+      options[:dry_run]
+    end
+
+    def debug?
+      options[:debug]
+    end
+
+    def database
+      options[:database]
+    end
+
+    def parser
+      @parser ||= Trollop::Parser.new do
+        opt :config, "Configuration file", :type => String
+        opt :listen, "Wait for files in given directory"
+        opt :dry_run, "Just create tasks without executing them"
+        opt :debug, "Enable debug messages (in stderr)"
+        opt :database, "The database file used to store tasks", :type => String
+      end
+    end
+
+    def options
+      @options ||= Trollop::with_standard_exception_handling(parser) do
+        raise Trollop::HelpNeeded if ARGV.empty? # show help screen
+        parser.parse arguments
+      end
+    end
+    alias_method :parse, :options
+
+    def parsed_parser
+      parse
+      parser
+    end
+
+    def import
+      @import ||= Rivendell::Import::Base.new
+    end
+
+    def paths
+      parsed_parser.leftovers
+    end
+
+    def run
+      Rivendell::Import.logger = Logger.new($stderr) if debug?
+
+      if database
+        Rivendell::Import.establish_connection database
+      else
+        Rivendell::Import.establish_connection
+      end
+
+      if config_file
+        load config_file 
+        import.to_prepare = Rivendell::Import.config.to_prepare
+      end
+
+      if listen_mode?
+        listen_options = {}
+        listen_options[:dry_run] = true if dry_run?
+
+        import.listen paths.first, listen_options
+      else
+        import.process paths
+        import.tasks.run unless dry_run?
+      end
+    end
+  end
+end

data/lib/rivendell/import/config.rb

@@ -0,0 +1,13 @@
+module Rivendell::Import
+  class Config
+
+    def to_prepare(&block)
+      if block_given?
+        @prepare = block
+      else
+        @prepare
+      end
+    end
+
+  end
+end

data/lib/rivendell/import/context.rb

@@ -0,0 +1,28 @@
+module Rivendell::Import
+  class Context
+
+    attr_reader :task
+
+    def initialize(task)
+      @task = task
+    end
+
+    delegate :file, :cart, :logger, :to => :task
+
+    def with(expression)
+      yield if file.match expression
+    end
+
+    def notify(target, options = {})
+      Rivendell::Import::Notifier::Base.notify(target, options).tap do |notifier|
+        logger.debug "Will notify with #{notifier.inspect}"
+        task.notifiers << notifier
+      end
+    end
+
+    def run(&block)
+      instance_exec file, &block if block_given?
+    end
+
+  end
+end

data/lib/rivendell/import/cut.rb

@@ -0,0 +1,33 @@
+module Rivendell::Import
+  class Cut
+
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+
+    attr_reader :cart
+
+    attr_accessor :number
+
+    def initialize(cart)
+      @cart = cart
+    end
+
+    def attributes
+      {}
+    end
+
+    def xport
+      cart.xport
+    end
+
+    def create
+      # xport.delete_cuts # if clean cuts is required
+      self.number = xport.add_cut(cart.number).number unless number
+    end
+
+    def update
+      # xport.edit_cut # to define attributes
+    end
+
+  end
+end

data/lib/rivendell/import/file.rb

@@ -0,0 +1,57 @@
+module Rivendell::Import
+  class File
+
+    attr_reader :name, :path
+
+    def initialize(name, attributes = {})
+      if attributes[:base_directory]
+        @path = name
+        @name = self.class.relative_filename(name, attributes[:base_directory])
+      elsif attributes[:path]
+        @name = name
+        @path = attributes[:path]
+      else
+        @name = @path = name
+      end
+    end
+
+    def self.relative_filename(path, base_directory)
+      ::File.expand_path(path).gsub(%r{^#{::File.expand_path(base_directory)}/},"")
+    end
+
+    def to_s
+      name
+    end
+
+    def basename
+      ::File.basename(name, ".#{extension}")
+    end
+
+    def extension
+      ::File.extname(name).gsub(/^\./,'')
+    end
+
+    def ==(other)
+      other and path == other.path
+    end
+
+    def match(expression)
+      name.match(expression).tap do |result|
+        verb = result ? "match" : "doesn't match"
+        Rivendell::Import.logger.debug "File #{verb} '#{expression}'"
+        !!result
+      end
+    end
+
+    def in(directory, &block)
+      if match %r{^#{directory}/}
+        yield 
+      end
+    end
+
+    def exists?
+      ::File.exists? path
+    end
+
+  end
+end

data/lib/rivendell/import/notification.rb

@@ -0,0 +1,16 @@
+module Rivendell::Import
+  class Notification < ActiveRecord::Base
+
+    belongs_to :task
+    belongs_to :notifier, :class_name => "Rivendell::Import::Notifier::Base"
+
+    def sent?
+      sent_at.present?
+    end
+
+    def self.pending
+      where :sent_at => nil
+    end
+
+  end
+end

data/lib/rivendell/import/notifier/base.rb

@@ -0,0 +1,89 @@
+require 'mail'
+require 'erb'
+
+module Rivendell::Import::Notifier
+  class Base < ActiveRecord::Base
+
+    # self.abstract_class = true
+    self.table_name = "notifiers"
+
+    def parameters
+      {}
+    end
+
+    has_many :notifications, :foreign_key => "notifier_id" do
+      def to_sent
+        pending.joins(:task).where("tasks.status" => %w{completed failed})
+      end
+      def waiting_for_more_than(delay)
+        joins(:task).where("tasks.updated_at < ?", Time.now - delay)
+      end
+    end
+
+    has_many :tasks, :through => :notifications
+
+    def delay
+      tasks.pending.empty? ? 0 : 60
+    end
+
+    def notify
+      to_sent_notifications = notifications.to_sent.includes(:task)
+
+      if delay > 0
+        to_sent_notifications = to_sent_notifications.waiting_for_more_than(delay)
+      end
+
+      if to_sent_notifications.present?
+        logger.debug "Notify #{to_sent_notifications.size} tasks with #{self.inspect}"
+        notify! to_sent_notifications.map(&:task)
+        to_sent_notifications.update_all(:sent_at => Time.now)
+      end
+    end
+
+    def logger
+      Rivendell::Import.logger
+    end
+
+    def parameters=(parameters)
+      parameters.each { |k,v| send "#{k}=", v }
+    end
+    
+    def raw_parameters
+      read_attribute :parameters
+    end
+
+    def read_parameters
+      self.parameters = ActiveSupport::JSON.decode(raw_parameters) if raw_parameters.present?
+    end
+
+    after_initialize :read_parameters
+
+    def write_parameters
+      if parameters.present?
+        write_attribute :parameters, parameters.to_json
+        write_attribute :key, parameters.hash
+      else
+        write_attribute :parameters, nil
+        write_attribute :key, nil
+      end
+    end
+
+    before_save :write_parameters
+
+    def self.notify(target, options = {})
+      new_notifier = case options.delete(:by)
+                     when :email
+                       Mail.new options.merge(:to => target)
+                     end
+
+      key = new_notifier.parameters.hash
+      if existing_notifier = where(:type => new_notifier.type, :key => key).first
+        existing_notifier
+      else
+        new_notifier.save!
+        new_notifier
+      end
+    end
+    
+  end
+end