clacks 1.0.4

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTYyNjIzMjk1NzcxNjcxMDAwYWExMDAzYzJhZGJlMjBjOTZlM2YyNg==
+  data.tar.gz: !binary |-
+    N2NmMjk0Yjk3OWEwZWMxZmIyMGNiMTRjZDM1ZTA1MTFiN2NmNmRiOA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NTFlMzIyYjMzMWU4OTY1MGY3ODU3NmFjZDQxNmU2MGRjYjRlMTNkY2ZmNDg5
+    MGE1Y2RiY2JlM2NhOTMxN2ZiNWQyZjBkYzNmNDZmNzhhNzliZjIyMmI5MDhk
+    ZTg4NzA1NjYwMzVkMTc1MTRiZmIxNWYyMjgyZThkMmQwOTU1MDk=
+  data.tar.gz: !binary |-
+    OTJiMjBjYzliODA0Y2QzZWU5NWFhZTU2N2ZjODc4ODEyYTY1ZWMwODZiNTk1
+    M2YxODZkOWFkMWVhMmYxMDEyY2ZhNDM3NmU5NjBhZjZkNWYzODNiZTU2ZDMy
+    YjQ4Mjg2MDNkYTcxN2U5NTliYzMzYTQ4M2I3NGYzNzUxZDYyOWY=

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 ITRP (http://developer.itrp.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,104 @@
+# Clacks 
+
+[![Build Status](https://secure.travis-ci.org/itrp/clacks.png)](http://travis-ci.org/itrp/clacks?branch=master)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/itrp/clacks)
+[![Gem Version](https://fury-badge.herokuapp.com/rb/clacks.png)](http://badge.fury.io/rb/clacks)
+
+"The clacks is a system of shutter semaphore towers which occupies roughly the same cultural space as telegraphy in nineteenth century Europe." ^[[1]](http://en.wikipedia.org/wiki/Technology_of_the_Discworld#The_clacks)
+
+Clacks is an easy way to process incoming emails in ruby. It uses the POP3 or IMAP protocol. If the IMAP protocol is used and the IMAP server advertises the [IDLE](http://tools.ietf.org/rfc/rfc2177.txt) capability it will use that. Which means that emails are pushed to your email processor instead of having to poll for it at regular intervals, which in turn means emails arrive near real-time at your systems.
+
+Clacks can be used standalone and/or within a Rails environment.
+
+
+Installation and Usage
+----------------------
+
+If you use Rails, add this to your Gemfile:
+
+    gem 'clacks', :require => nil
+
+Then create a configuration file, using ruby syntax, such as:
+
+``` ruby
+# -*- encoding: binary -*-
+# Configuration of clacks
+# See Clacks::Configurator for documentation on options
+#
+# Put this in: <RAILS_ROOT>/config/clacks.rb
+#
+
+poll_interval 30
+pid "tmp/pids/clacks.pid"
+stdout_path 'log/clacks.log'
+stderr_path 'log/clacks.log'
+
+imap({
+  :address    => "imap.googlemail.com",
+  :port       => 993,
+  :user_name  => '<user_name>'
+  :password   => '<password>'
+  :enable_ssl => true,
+})
+
+find_options({
+  :mailbox => 'INBOX',
+  :archivebox => '[Gmail]/All Mail',
+  :delete_after_find => true
+})
+
+on_mail do |mail|
+  Clacks.logger.info "Got new mail from #{mail.from.first}, subject: #{mail.subject}"
+
+  to = mail.to.first
+  if to =~ /^task-(\d+)@example.com/
+    Task.find($1).add_note(mail)
+  elsif to =~ /^(\w+)@example.com/
+    Account.find_by_name($1).tickets.create_from_mail!(mail)
+  else
+    # Prevent deletion of this mail after all
+    mail.skip_deletion
+  end
+end
+```
+
+See [Clacks::Configurator](https://github.com/itrp/clacks/tree/master/lib/clacks/configurator.rb) for documentation on all options.
+
+Start clacks:
+
+```
+/project/my_rails_app$ clacks --help
+/project/my_rails_app$ clacks
+```
+
+Clacks can run as a daemon:
+
+```
+/project/my_rails_app$ clacks -D
+```
+
+Once it's running as a daemon process you can control it via sending signals. See the available signals below.
+
+See the [contrib](https://github.com/itrp/clacks/tree/master/contrib/) directory for handy init.d, logrotate and monit scripts.
+
+
+Signals
+-------
+
+* INT/TERM - quick shutdown, kills the process immediately.
+
+* QUIT - graceful shutdown, waits for the worker process to finish processing an email.
+
+* USR1 - reopen logs
+
+
+Author
+----------
+
+ITRP, mathijs.sterk@itrp.com, [developer.itrp.com](http://developer.itrp.com)
+
+
+Copyright
+-----------
+
+Copyright (c) 2013 ITRP. See MIT-LICENSE for details.

data/bin/clacks

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'clacks'))
+Clacks::Command.new(ARGV).exec

data/clacks.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "clacks/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{clacks}
+  s.version = Clacks::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["ITRP"]
+  s.email = %q{mathijs.sterk@itrp.com}
+  s.homepage = %q{http://github.com/itrp/clacks}
+  s.summary = %q{Clacks system for receiving emails}
+  s.description = %q{Clacks system for receiving emails to be processed in ruby}
+  s.date = Time.now.utc.strftime("%Y-%m-%d")
+  s.files = Dir.glob("lib/**/*") + [
+     "MIT-LICENSE",
+     "README.md",
+     "Gemfile",
+     "clacks.gemspec"
+  ]
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.add_dependency('mail')
+  s.add_development_dependency "rake"
+  # s.add_development_dependency "rcov"
+  s.add_development_dependency "rspec"
+end
+

data/lib/clacks/command.rb

@@ -0,0 +1,171 @@
+# -*- encoding: binary -*-
+module Clacks
+  class Command
+    require 'optparse'
+
+    PROC_NAME = ::File.basename($0.dup)
+    PROC_ARGV = ARGV.map { |a| a.dup }
+
+    def initialize(args)
+      @options = { :config_file => "config/clacks.rb" }
+
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: #{PROC_NAME} [options]"
+
+        if Clacks.rails_env?
+          opts.separator "Rails options:"
+          opts.on("-E", "--env RAILS_ENV", "use RAILS_ENV for defaults (default: development)") do |e|
+            ENV['RAILS_ENV'] = e
+          end
+        end
+
+        opts.separator "Ruby options:"
+
+        opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") do
+          $DEBUG = true
+        end
+
+        opts.on("-w", "--warn", "turn warnings on for your script") do
+          $-w = true
+        end
+
+        opts.separator "Clacks options:"
+
+        opts.on("-c", "--config-file FILE", "Clacks-specific config file (default: #{@options[:config_file]})") do |f|
+          @options[:config_file] = f
+        end
+
+        opts.on("-D", "--daemonize", "run daemonized in the background") do |d|
+          @options[:daemonize] = !!d
+        end
+
+        opts.on("-P", "--pid FILE", "file to store PID (default: clacks.pid)") { |f|
+          @options[:pid] = f
+        }
+
+        opts.separator "Common options:"
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts.to_s.gsub(/^.*DEPRECATED.*$/s, '')
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Show version") do
+          puts "#{PROC_NAME} v#{Clacks::VERSION}"
+          exit
+        end
+      end
+      @args = opts.parse!(args)
+    end
+
+    def exec
+      daemonize if @options[:daemonize]
+
+      Clacks.require_rails if Clacks.rails_env?
+
+      Clacks.config = config = Clacks::Configurator.new(@options[:config_file])
+      unless config[:pop3] || config[:imap]
+        $stderr.puts "Either a POP3 or an IMAP server must be configured"
+        exit!(1)
+      end
+
+      reopen_io($stdout, config[:stdout_path])
+      reopen_io($stderr, config[:stderr_path])
+
+      unless config[:pid]
+        config.pid(@options[:pid] || (defined?(Rails) && Rails.version =~ /^2/ ? 'tmp/pids/clacks.pid' : 'clacks.pid'))
+      end
+      pid = config[:pid]
+      if wpid = running?(pid)
+        $stderr.puts "#{Clacks::Command::PROC_NAME} already running with pid: #{wpid} (or stale #{pid})"
+        exit!(1)
+      end
+      write_pid(pid)
+
+      proc_name('master')
+
+      setup_signal_handling
+
+      @service = Clacks::Service.new
+      @service.run
+    end
+
+    private
+
+    # See Stevens's "Advanced Programming in the UNIX Environment" chapter 13
+    def daemonize(safe = true)
+      $stdin.reopen '/dev/null'
+
+      # Fork and have the parent exit.
+      # This makes the shell or boot script think the command is done.
+      # Also, the child process is guaranteed not to be a process group
+      # leader (a prerequisite for setsid next)
+      exit if fork
+
+      # Call setsid to create a new session. This does three things:
+      # - The process becomes a session leader of a new session
+      # - The process becomes the process group leader of a new process group
+      # - The process has no controlling terminal
+      Process.setsid
+
+      # Fork again and have the parent exit.
+      # This guarantes that the daemon is not a session leader nor can
+      # it acquire a controlling terminal (under SVR4)
+      exit if fork
+
+      unless safe
+        ::Dir.chdir('/')
+        ::File.umask(0000)
+      end
+
+      cfg_defaults = Clacks::Configurator::DEFAULTS
+      cfg_defaults[:stdout_path] ||= "/dev/null"
+      cfg_defaults[:stderr_path] ||= "/dev/null"
+    end
+
+    # Redirect file descriptors inherited from the parent.
+    def reopen_io(io, path)
+      io.reopen(::File.open(path, "ab")) if path
+      io.sync = true
+    end
+
+    # Read the working pid from the pid file.
+    def running?(path)
+      wpid = ::File.read(path).to_i
+      return if wpid <= 0
+      Process.kill(0, wpid)
+      wpid
+    rescue Errno::EPERM, Errno::ESRCH, Errno::ENOENT
+      # noop
+    end
+
+    # Write the pid.
+    def write_pid(pid)
+      ::File.open(pid, 'w') { |f| f.write("#{Process.pid}") }
+      at_exit { ::File.delete(pid) if ::File.exist?(pid) rescue nil }
+    end
+
+    def proc_name(tag)
+      $0 = [ Clacks::Command::PROC_NAME, tag, Clacks::Command::PROC_ARGV ].join(' ')
+    end
+
+    def setup_signal_handling
+      stop_signal = (Signal.list.keys & ['QUIT', 'INT']).first
+      Signal.trap(stop_signal) do
+        Clacks.logger.info 'QUIT signal received. Shutting down gracefully.'
+        @service.stop if @service
+      end unless stop_signal.nil?
+
+      Signal.trap('USR1') do
+        Clacks.logger.info 'USR1 signal received. Rotating logs.'
+        rotate_logs
+      end if Signal.list['USR1']
+    end
+
+    def rotate_logs
+      reopen_io($stdout, Clacks.config[:stdout_path])
+      reopen_io($stderr, Clacks.config[:stderr_path])
+    end
+
+  end
+end

data/lib/clacks/configurator.rb

@@ -0,0 +1,95 @@
+# -*- encoding: binary -*-
+module Clacks
+  class Configurator
+    require 'logger'
+    attr_accessor :map, :config_file
+
+    DEFAULTS = {
+      :poll_interval => 60,
+      :logger => Logger.new($stderr),
+      :on_mail => lambda { |mail|
+        Clacks.logger.info("Mail from #{mail.from.first}, subject: #{mail.subject}")
+      }
+    }
+
+    def initialize(config_file = nil)
+      self.map = Hash.new
+      map.merge!(DEFAULTS)
+      self.config_file = config_file
+      instance_eval(File.read(config_file), config_file) if config_file
+    end
+
+    def [](key) # :nodoc:
+      map[key]
+    end
+
+    def poll_interval(value)
+      map[:poll_interval] = value.to_i
+    end
+
+    def pid(path)
+      set_path(:pid, path)
+    end
+
+    # Sets the Logger-like object.
+    # The default Logger will log its output to Rails.logger if
+    # you're running within a rails environment, otherwise it will
+    # output to the path specified by +stdout_path+.
+    def logger(obj)
+      %w(debug info warn error fatal level).each do |m|
+        next if obj.respond_to?(m)
+        raise ArgumentError, "logger #{obj} does not respond to method #{m}"
+      end
+      map[:logger] = obj
+    end
+
+    # If you're running Clacks daemonized, then you must specify a path
+    # to prevent error messages from going to /dev/null.
+    def stdout_path(path)
+      set_path(:stdout_path, path)
+    end
+
+    # If you're running Clacks daemonized, then you must specify a path
+    # to prevent error messages from going to /dev/null.
+    def stderr_path(path)
+      set_path(:stderr_path, path)
+    end
+
+    def pop3(hash)
+      set_hash(:pop3, hash)
+    end
+
+    def imap(hash)
+      set_hash(:imap, hash)
+    end
+
+    def find_options(hash)
+      set_hash(:find_options, hash)
+    end
+
+    def on_mail(*args, &block)
+      set_hook(:on_mail, block_given? ? block : args[0])
+    end
+
+    private
+
+      def set_path(var, path) #:nodoc:
+        raise ArgumentError unless path.nil? || path.is_a?(String)
+        map[var] = path ? ::File.expand_path(path) : nil
+      end
+
+      def set_hash(var, hash) #:nodoc:
+        raise ArgumentError unless hash.is_a?(Hash)
+        map[var] = hash
+      end
+
+      def set_hook(var, proc) #:nodoc:
+        raise ArgumentError unless proc.is_a?(Proc)
+        unless proc.arity == 1
+          raise ArgumentError, "#{var}=#{proc.inspect} has invalid arity: #{proc.arity} (need 1)"
+        end
+        map[var] = proc
+      end
+
+  end
+end

data/lib/clacks/service.rb

@@ -0,0 +1,223 @@
+# -*- encoding: binary -*-
+module Clacks
+  class Service
+    require 'mail'
+
+    # In practice timeouts occur when there is no activity keeping an IMAP connection open.
+    # Timeouts occuring are:
+    #   IMAP server timeout: typically after 30 minutes with no activity.
+    #   NAT Gateway timeout: typically after 15 minutes with an idle connection.
+    # The solution to this is for the IMAP client to issue a NOOP (No Operation) command
+    # at intervals, typically every 15 minutes.
+    IMAP_NOOP_SLEEP = 15 * 60   # 15 minutes
+
+    def run
+      Clacks.logger.info "Clacks v#{Clacks::VERSION} started"
+      if Clacks.config[:pop3]
+        run_pop3
+      elsif Clacks.config[:imap]
+        run_imap
+      else
+        raise "Either a POP3 or an IMAP server must be configured"
+      end
+    end
+
+    def stop
+      $STOPPING = true
+      exit unless finding?
+    end
+
+    private
+
+    def run_pop3
+      config = Clacks.config[:pop3]
+      Clacks.logger.info("Clacks POP3 polling #{config[:user_name]}@#{config[:address]}")
+      # TODO: if $DEBUG
+      processor = Mail::IMAP.new(config)
+      poll(processor)
+    end
+
+    def run_imap
+      config = Clacks.config[:imap]
+      options = Clacks.config[:find_options]
+      processor = Mail::IMAP.new(config)
+      require 'clacks/stdlib_extensions/ruby_1_8' if RUBY_VERSION.to_f < 1.9
+      Net::IMAP.debug = $DEBUG
+      imap_validate_options(options)
+      if imap_idle_support?(processor)
+        Clacks.logger.info("Clacks IMAP idling #{config[:user_name]}@#{config[:address]}")
+        imap_idling(processor)
+      else
+        Clacks.logger.info("Clacks IMAP polling #{config[:user_name]}@#{config[:address]}")
+        poll(processor)
+      end
+    end
+
+    # Follows mostly the defaults from the Mail gem
+    def imap_validate_options(options)
+      options ||= {}
+      options[:mailbox] ||= 'INBOX'
+      options[:count]   ||= 5
+      options[:order]   ||= :asc
+      options[:what]    ||= :first
+      options[:keys]    ||= 'ALL'
+      options[:delete_after_find] ||= false
+      options[:mailbox] = Net::IMAP.encode_utf7(options[:mailbox])
+      if options[:archivebox]
+        options[:archivebox] = Net::IMAP.encode_utf7(options[:archivebox])
+      end
+      options
+    end
+
+    def imap_idle_support?(processor)
+      processor.connection { |imap| imap.capability.include?("IDLE") }
+    end
+
+    def imap_idling(processor)
+      imap_nooper
+      loop do
+        begin
+          processor.connection do |imap|
+            @imap = imap
+            # select the mailbox to process
+            imap.select(Clacks.config[:find_options][:mailbox])
+            loop {
+              break if stopping?
+              finding { imap_find(imap) }
+              # http://tools.ietf.org/rfc/rfc2177.txt
+              imap.idle do |r|
+                if r.instance_of?(Net::IMAP::UntaggedResponse) && r.name == 'EXISTS'
+                  imap.idle_done unless r.data == 0
+                elsif r.instance_of?(Net::IMAP::ContinuationRequest)
+                  Clacks.logger.info(r.data.text)
+                end
+              end
+            }
+          end
+        rescue Net::IMAP::BadResponseError => e
+          unless e.message == 'Could not parse command'
+            Clacks.logger.error("#{e.message} (#{e.class})\n#{(e.backtrace || []).join("\n")}")
+          end
+          # reconnect in next loop
+        rescue Net::IMAP::Error, IOError => e
+          # OK: reconnect in next loop
+        rescue => e
+          Clacks.logger.error("#{e.message} (#{e.class})\n#{(e.backtrace || []).join("\n")}")
+          sleep(5) unless stopping?
+        end
+        break if stopping?
+      end
+    end
+
+    def imap_nooper
+      @imap_nooper = Thread.new do
+        loop do
+          begin
+            sleep IMAP_NOOP_SLEEP
+            @imap.idle_done
+            @imap.noop
+          rescue
+            # noop
+          end
+        end
+      end
+    end
+
+    # Keep processing emails until nothing is found anymore,
+    # or until a QUIT signal is received to stop the process.
+    def imap_find(imap)
+      options = Clacks.config[:find_options]
+      begin
+        break if stopping?
+        uids = imap.uid_search(options[:keys] || 'ALL')
+        uids.reverse! if options[:what].to_sym == :last
+        uids = uids.first(options[:count]) if options[:count].is_a?(Integer)
+        uids.reverse! if (options[:what].to_sym == :last && options[:order].to_sym == :asc) ||
+                         (options[:what].to_sym != :last && options[:order].to_sym == :desc)
+        processed = 0
+        uids.each do |uid|
+          break if stopping?
+          source = imap.uid_fetch(uid, ['RFC822']).first.attr['RFC822']
+          break if stopping?
+          mail = Mail.new(source)
+          mail.mark_for_delete = true if options[:delete_after_find]
+          begin
+            Clacks.config[:on_mail].call(mail)
+          rescue Exception => e
+            Clacks.logger.debug(e.message)
+            Clacks.logger.debug(e.backtrace)
+          end
+          begin
+            imap.uid_copy(uid, options[:archivebox]) if options[:archivebox]
+            if options[:delete_after_find] && mail.is_marked_for_delete?
+              imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED])
+            end
+          rescue Exception => e
+            Clacks.logger.error(e.message)
+          end
+          processed += 1
+        end
+        imap.expunge if options[:delete_after_find]
+      end while uids.any? && processed == uids.length
+    end
+
+    def poll(processor)
+      polling_msg = if polling?
+        "Clacks polling every #{poll_interval} seconds."
+      else
+        "Clacks polling for messages once."
+      end
+      Clacks.logger.info(polling_msg)
+
+      find_options = Clacks.config[:find_options]
+      on_mail = Clacks.config[:on_mail]
+      loop do
+        break if stopping?
+        finding {
+          processor.find(find_options) do |mail|
+            if stopping?
+              mail.skip_deletion
+            else
+              begin
+                on_mail.call(mail)
+              rescue Exception => e
+                Clacks.logger.debug(e.message)
+                Clacks.logger.debug(e.backtrace)
+              end
+            end
+          end
+        }
+        break if stopping? || !polling?
+        sleep(poll_interval)
+      end
+    end
+
+    def poll_interval
+      Clacks.config[:poll_interval]
+    end
+
+    def polling?
+      poll_interval > 0
+    end
+
+    def finding(&block)
+      @finding = true
+      yield
+    ensure
+      @finding = false
+    end
+
+    def finding?
+      @finding
+    end
+
+    def stopping?
+      $STOPPING
+    end
+
+    at_exit {
+      Clacks.logger.info("Clacks stopped.") if $STOPPING
+    }
+
+  end
+end

data/lib/clacks/stdlib_extensions/ruby_1_8.rb

@@ -0,0 +1,41 @@
+# -*- encoding: binary -*-
+# Backport from ruby 1.9.3 source to ruby 1.8.7
+class Net::IMAP
+  def idle(&response_handler)
+    raise LocalJumpError, "no block given" unless response_handler
+
+    response = nil
+
+    synchronize do
+      tag = Thread.current[:net_imap_tag] = generate_tag
+      put_string("#{tag} IDLE#{CRLF}")
+
+      begin
+        add_response_handler(response_handler)
+        @idle_done_cond = new_cond
+        @idle_done_cond.wait
+        @idle_done_cond = nil
+        if @receiver_thread_terminating
+          raise Net::IMAP::Error, "connection closed"
+        end
+      ensure
+        unless @receiver_thread_terminating
+          remove_response_handler(response_handler)
+          put_string("DONE#{CRLF}")
+          response = get_tagged_response(tag)  #, "IDLE")
+        end
+      end
+    end
+
+    return response
+  end
+
+  def idle_done
+    synchronize do
+      if @idle_done_cond.nil?
+        raise Net::IMAP::Error, "not during IDLE"
+      end
+      @idle_done_cond.signal
+    end
+  end
+end

data/lib/clacks/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding: binary -*-
+module Clacks
+  VERSION = '1.0.4'
+end

data/lib/clacks.rb

@@ -0,0 +1,30 @@
+# -*- encoding: binary -*-
+module Clacks
+  require 'clacks/version'
+  require 'clacks/configurator'
+  require 'clacks/command'
+  require 'clacks/service'
+
+  def self.config=(config)
+    @config = config
+  end
+
+  def self.config
+    @config ||= Clacks::Configurator.new
+  end
+
+  def self.logger
+    @logger ||= Clacks.config[:logger]
+  end
+
+  RAILS_CONFIG_ENV = 'config/environment.rb'
+  def self.rails_env?
+    @rails_env ||= defined?(Rails) || File.readable?(RAILS_CONFIG_ENV)
+  end
+
+  def self.require_rails
+    ENV['RAILS_ENV'] ||= 'development'
+    require "#{Dir.pwd}/#{RAILS_CONFIG_ENV}" unless defined?(Rails)
+  end
+end
+

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: clacks
+version: !ruby/object:Gem::Version
+  version: !binary |-
+    MS4wLjQ=
+platform: ruby
+authors:
+- ITRP
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Clacks system for receiving emails to be processed in ruby
+email: mathijs.sterk@itrp.com
+executables:
+- clacks
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/clacks/service.rb
+- lib/clacks/version.rb
+- lib/clacks/stdlib_extensions/ruby_1_8.rb
+- lib/clacks/configurator.rb
+- lib/clacks/command.rb
+- lib/clacks.rb
+- MIT-LICENSE
+- README.md
+- Gemfile
+- clacks.gemspec
+- bin/clacks
+homepage: http://github.com/itrp/clacks
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Clacks system for receiving emails
+test_files: []