herpes 0.0.1a1 → 0.0.1

data/bin/herpes

@@ -0,0 +1,17 @@
+#! /usr/bin/env ruby
+require 'herpes'
+
+if ARGV.first == '-v' or ARGV.first == '--version'
+	puts Herpes.version
+	exit
+end
+
+fail 'no configuration file passed' if ARGV.empty?
+
+herpes = Herpes.load(*ARGV)
+
+trap 'INT' do
+	herpes.stop!
+end
+
+herpes.start!

data/examples/generator.rb

@@ -0,0 +1,11 @@
+every 5.seconds do
+	dispatch {
+		time Time.now
+		
+		comment time.to_i.to_s[-2].to_i.odd? ? 'O_O' : '^_^'
+	}
+end
+
+on :anything do |event|
+	puts "It is #{event.time} #{event.comment}"
+end

data/examples/rss.rb

@@ -1,26 +1,68 @@
+require 'herpes/rss'
+require 'herpes/email'
+
+state '~/.herpes'
+
 # load the RSS module
 use :rss do
+	check_every 2.minutes
+
 	# register sankaku with the following tags for the generated events
 	tag :anime, :manga, :japan, :nsfw do
 		register 'http://www.sankakucomplex.com/feed/'
 	end
 
-	# register incomaemeglio in the blog group
+	# register incomaemeglio in the blog group and give it a name
+	# also register github's blog in the blog group
 	group :blog do
-		register 'http://feeds.feedburner.com/incomaemeglio'
+		register 'http://feeds.feedburner.com/incomaemeglio', :smeriglia
+		register 'https://github.com/blog.atom'
 	end
 end
 
-on -> e { e.tags.include?(:nsfw) } do |event|
-	with :email do
-		from 'rss-nsfw@events'
-		to   'meh@paranoici.org'
-	end.send(event)
-end
+# only events coming from the RSS module
+from :rss do
+	# define some common helper methods on every event
+	before do |event|
+		require 'nokogiri'
+
+		[event.channel.title, event.title, event.description].each {|obj|
+			class << obj
+				def strip_html
+					Nokogiri::HTML(self).search('//text()').text
+				end
+			end
+		}
+
+		class << event
+			def render
+				"#{title.strip_html} (#{link})\n\n#{description.strip_html}"
+			end
+		end
+	end
 
-on :anything_else do |event|
-	with :email do
-		from 'rss@events'
-		to   'meh@paranoici.org'
-	end.send(event)
+	# for events that have the nsfw tag
+	on -> e { e.tags.include?(:nsfw) } do |event|
+		with :email do
+			from    "#{event.channel.title.strip_html} <rss-nsfw@herpes>"
+			to      'herpes'
+			subject event.title.strip_html
+
+			via :procmail
+
+			send event.render
+		end
+	end
+
+	on :anything_else do |event|
+		with :email do
+			from    "#{event.channel.title.strip_html} <rss@herpes>"
+			to      'herpes'
+			subject event.title.strip_html
+
+			via :procmail
+
+			send event.render
+		end
+	end
 end

data/herpes.gemspec

@@ -13,4 +13,6 @@ Gem::Specification.new {|s|
 	s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
 	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
 	s.require_paths = ['lib']
+
+  s.add_dependency 'actionpool'
 }

data/lib/herpes/email.rb

@@ -0,0 +1,55 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'pony'
+
+Herpes::Notifier.define :email, :mail do
+	@options = %w(from to cc bcc sender subject headers charset text_part_charset message_id via via_options attachments)
+
+	plain_accessor *@options
+
+	from 'herpes'
+
+	@attachments = {}
+
+	def via (name, options = {})
+		if name == :procmail
+			procmail = `which procmail`.chomp
+			procmail = procmail.empty? ? '/usr/bin/procmail' : procmail
+
+			via :sendmail, location: "#{options[:location] || procmail} -f - #"
+		else
+			@via         = name
+			@via_options = options
+		end
+	end
+
+	def attachment (name, path)
+		@attachments[name] = File.read(File.expand_path(path))
+	end
+
+	def to_hash
+		result = {}
+
+		@options.each {|name|
+			result[name.to_sym] = instance_variable_get("@#{name}") if instance_variable_get("@#{name}")
+		}
+
+		result
+	end
+
+	def send (data)
+		if !data.is_a?(Hash)
+			data = { :text => data.to_s }
+		end
+
+		Pony.mail(to_hash.merge(body: data[:text], html_body: data[:html]))
+	end
+end

data/lib/herpes/event.rb

@@ -0,0 +1,45 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+class Herpes
+
+class Event
+	def initialize (&block)
+		@data = {}
+		
+		instance_eval &block
+	end
+
+	def method_missing (id, *args)
+		id = id.to_s.sub(/[=?]$/, '').to_sym
+
+		if args.length == 0
+			@data[id]
+		else
+			if respond_to? "#{id}="
+				send "#{id}=", *args
+			else
+				value = (args.length > 1) ? args : args.first
+
+				if value.nil?
+					@data.delete(id)
+				else
+					@data[id] = value
+				end
+			end
+		end
+	end
+
+	def to_hash
+		@data.dup
+	end
+end
+
+end

data/lib/herpes/extensions.rb

@@ -0,0 +1,95 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'forwardable'
+
+class Numeric
+	def seconds
+		self
+	end; alias second seconds
+
+	def minutes
+		self * 60
+	end; alias minute minutes
+
+	def hours
+		self * 60.minutes
+	end; alias hour hours
+
+	def days
+		self * 24.hours
+	end; alias day days
+end
+
+class Object
+	def plain_accessor (*names)
+		names.each {|name|
+			define_singleton_method name do |*args|
+				if args.empty?
+					instance_variable_get "@#{name}"
+				else
+					value = (args.length > 1) ? args : args.first
+
+					if value.nil?
+						remove_instance_variable "@#{name}"
+					else
+						instance_variable_set "@#{name}", value
+					end
+				end
+			end
+
+			define_singleton_method "#{name}?" do
+				instance_variable_get "@#{name}"
+			end
+
+			define_singleton_method "#{name}!" do
+				instance_variable_set "@#{name}", true
+			end
+
+			define_singleton_method "no_#{name}!" do
+				instance_variable_set "@#{name}", false
+			end
+
+		}
+	end
+end
+
+class Module
+	def plain_accessor (*names)
+		names.each {|name|
+			define_method name do |*args|
+				if args.empty?
+					instance_variable_get "@#{name}"
+				else
+					value = (args.length > 1) ? args : args.first
+
+					if value.nil?
+						remove_instance_variable "@#{name}"
+					else
+						instance_variable_set "@#{name}", value
+					end
+				end
+			end
+
+			define_method "#{name}?" do
+				instance_variable_get "@#{name}"
+			end
+
+			define_method "#{name}!" do
+				instance_variable_set "@#{name}", true
+			end
+
+			define_method "no_#{name}!" do
+				instance_variable_set "@#{name}", false
+			end
+
+		}
+	end
+end

data/lib/herpes/module.rb

@@ -0,0 +1,129 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+class Herpes
+
+class Module
+	def self.all
+		@modules ||= []
+	end
+
+	def self.[] (name)
+		return name if name.is_a?(Module)
+
+		Module.all.find { |mod| mod =~ name }
+	end
+
+	def self.define (name, *aliases, &block)
+		Module.all << new(name, *aliases, &block)
+	end
+
+	extend Forwardable
+
+	attr_reader    :name, :aliases, :owner
+	def_delegators :owner, :state, :workers
+
+	def initialize (name, *aliases, &block)
+		@name    = name
+		@aliases = aliases
+
+		instance_eval &block
+	end
+
+	def =~ (other)
+		return true if self == other
+
+		name.to_s.downcase == other.to_s.downcase || aliases.any? { |a| a.to_s.downcase == other.to_s.downcase }
+	end
+
+	def default (&block)
+		block ? @default : @default = block
+	end
+
+	def with (&block)
+		block = default unless block
+
+		if !block
+			raise ArgumentError, 'no block passed and a default is not present'
+		end
+
+		clone.tap { |o| o.instance_eval &block }
+	end
+
+	def use (*)
+		raise NotImplementedError, 'you have to use a specialized module'
+	end
+
+	def inspect
+		"#<#{self.class.name}(#{name}#{" [#{aliases.join ', '}]" unless aliases.empty?})>"
+	end
+end
+
+class Generator < Module
+	plain_accessor :check_every
+
+	def initialize (*)
+		super
+	end
+
+	def use (owner, &block)
+		with(&block).tap {|o|
+			o.instance_eval {
+				@owner = owner
+
+				owned if respond_to? :owned
+
+				if respond_to? :check
+					@owner.every(check_every, &method(:check))
+				end
+			}
+		}
+	end
+
+	def dispatch (event = nil, &block)
+		if block && !event
+			event = Event.new(&block)
+		end
+
+		raise ArgumentError, 'you did not pass an Event' unless event.is_a?(Event)
+
+		event.generated_by self
+
+		owner.dispatch(event)
+	end
+end
+
+class Notifier < Module
+	def initialize (*)
+		@matchers = []
+
+		super
+	end
+
+	def on (*args, &block)
+		@matchers << Struct.new(:arguments, :block).new(args, block)
+	end
+
+	def use (owner, &block)
+		with(&block).tap {|o|
+			o.instance_eval {
+				@owner = owner
+
+				owned if respond_to? :owned
+
+				@matchers.each {|matcher|
+					@owner.on *matcher.arguments, &matcher.block
+				}
+			}
+		}
+	end
+end
+
+end

data/lib/herpes/rss.rb

@@ -0,0 +1,88 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'rss'
+require 'open-uri'
+
+Herpes::Generator.define :rss do
+	plain_accessor :digest
+
+	check_every 5.minutes
+
+	@tags = []
+	@rss  = []
+
+	def tag (*tags, &block)
+		@tags.push tags
+		instance_eval &block
+		@tags.pop
+	end
+
+	def group (group, &block)
+		@group, tmp = group, @group
+		instance_eval &block
+		@group = tmp
+	end
+
+	def register (url, name = nil)
+		@rss << Struct.new(:url, :name, :tags, :group).new(url, name, @tags.flatten, @group)
+	end
+
+	def check
+		digest = [] if digest?
+
+		@rss.each {|r|
+			(state[:rss] ||= {})[r.url] ||= []
+
+			RSS::Parser.parse(open(r.url).read, false).tap {|p|
+				p.items.each {|item|
+					next if state[:rss][r.url].member? [item.date, item.title]
+
+					event = Herpes::Event.new {
+						tags  r.tags
+						group r.group
+						name  r.name
+
+						channel p.channel.dup
+
+						title       item.title.dup
+						link        item.link.dup
+						description item.description.dup
+						date        item.date
+					}
+
+					if digest
+						digest.push(event)
+					else
+						dispatch(event)
+					end
+
+					state[:rss][r.url].push [item.date, item.title]
+				}
+
+				state[:rss][r.url].reject! {|(date, title)|
+					p.items.none? {|item|
+						item.date == date && item.title == title
+					}
+				}
+			}
+		}
+
+		if digest
+			dispatch Herpes::Event.new {
+				events digest
+
+				def to_a
+					events
+				end
+			}
+		end
+	end
+end

data/lib/herpes/version.rb

@@ -8,8 +8,8 @@
 #  0. You just DO WHAT THE FUCK YOU WANT TO.
 #++
 
-module Herpes
+class Herpes
 	def self.version
-		'0.0.1a1'
+		'0.0.1'
 	end
 end

data/lib/herpes/workers.rb

@@ -0,0 +1,26 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'actionpool'
+
+class Workers
+	extend Forwardable
+
+	def_delegators :@pool, :max, :max=, :min, :min=
+
+	def initialize (range = 2 .. 4)
+		@pool = ActionPool::Pool.new(:min_threads => range.begin, :max_threads => range.end)
+	end
+
+	def do (*args, &block)
+		@pool.process(*args, &block)
+	end
+end
+

data/lib/herpes.rb

@@ -0,0 +1,247 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+require 'herpes/version'
+require 'herpes/extensions'
+require 'herpes/workers'
+require 'herpes/event'
+require 'herpes/module'
+
+class Herpes
+	class Callback
+		attr_reader :time, :block, :last
+
+		def initialize (time, one_shot = false, &block)
+			raise ArgumentError, 'no block has been passed' unless block
+
+			@time     = time
+			@one_shot = one_shot
+			@block    = block
+
+			if !one_shot?
+				@last = Time.now - time
+			else
+				called!
+			end
+		end
+
+		def one_shot?
+			@one_shot
+		end
+
+		def next_in
+			time - (Time.now - last)
+		end
+
+		def gonna_call!
+			@calling = :gonna
+		end
+
+		def gonna_call?
+			@calling == :gonna
+		end
+
+		def calling!
+			@calling = :gonna
+		end
+
+		def called!
+			@last    = Time.now
+			@calling = false
+		end
+
+		def calling?
+			@calling == true
+		end
+
+		def call (*args, &block)
+			return if calling?
+
+			calling!
+			@block.call(*args, &block)
+			called!
+		end
+	end
+
+	def self.load (*path)
+		new.load(*path)
+	end
+
+	attr_reader :workers, :modules
+
+	def initialize
+		@modules = []
+		@workers = Workers.new
+		@pipes   = IO.pipe
+
+		@before   = Hash.new { |h, k| h[k] = [] }
+		@matchers = Hash.new { |h, k| h[k] = [] }
+		@after    = Hash.new { |h, k| h[k] = [] }
+
+		@callbacks = []
+	end
+
+	def state (path = nil)
+		if path && path != @path
+			@path  = File.expand_path(path)
+			@state = Marshal.load(File.read(@path)) rescue nil
+		else
+			@state ||= {}
+		end
+	end
+
+	def save
+		return unless @state && @path
+
+		dump = Marshal.dump(@state)
+
+		File.open(@path, 'wb') { |f| f.write(dump) }
+	end
+
+	def load (*paths)
+		paths.each {|path|
+			instance_eval File.read(path), path, 1
+		}
+
+		self
+	end
+
+	def with (name, &block)
+		raise ArgumentError, "#{name} not found" unless Module[name]
+
+		Module[name].with(&block)
+	end
+
+	def use (name, &block)
+		raise ArgumentError, "#{name} not found" unless Module[name]
+
+		@modules << Module[name].use(self, &block)
+	end
+
+	def from (name, &block)
+		return unless block
+
+		@current, tmp = name, @current
+		result = instance_eval &block
+		@current = tmp
+		result
+	end
+
+	def before (&block)
+		@before[@current] = block
+	end
+
+	def on (matcher, &block)
+		return unless block
+
+		@matchers[@current] << Struct.new(:matcher, :block).new(matcher, block)
+	end
+
+	def after (&block)
+		@after[@current] = block
+	end
+
+	def dispatch (event = nil, &block)
+		if block && !event
+			event = Event.new(&block)
+		end
+
+		raise ArgumentError, 'you did not pass an Event' unless event.is_a?(Event)
+
+		@before.each {|name, block|
+			next unless name.nil? || (event.generated_by && event.generated_by =~ name)
+
+			block.call(event)
+		}
+
+		@matchers.each {|name, matchers|
+			next unless name.nil? || (event.generated_by && event.generated_by =~ name)
+
+			dispatched = false
+
+			matchers.each {|m|
+				begin
+					dispatched = true
+
+					m.block.call(event)
+				end if
+					(m.matcher == :anything) ||
+					(m.matcher == :anything_else && !dispatched) ||
+					(m.matcher.respond_to?(:call) && m.matcher.call(event))
+			}
+		}
+
+		@after.each {|name, block|
+			next unless name.nil? || (event.generated_by && event.generated_by =~ name)
+
+			block.call(event)
+		}
+	end
+
+	def every (time, &block)
+		@callbacks << Callback.new(time, &block)
+		wake_up
+	end
+
+	def after (time, &block)
+		@callbacks << Callback.new(time, true, &block)
+		wake_up
+	end
+
+	def until_next
+		next_in = @callbacks.min_by(&:next_in).next_in
+
+		next_in > 0 ? next_in : 0
+	rescue
+		10
+	end
+
+	def sleep (time)
+		@pipes.first.read_nonblock 1337 rescue nil
+
+		IO.select([@pipes.first], nil, nil, time)
+	end
+
+	def wake_up
+		@pipes.last.write 'x'
+	end
+
+	def running?; !!@running; end
+	def stopped?; !@running;  end
+
+	def start!
+		@running = true
+
+		while running?
+			sleep until_next
+
+			@callbacks.select {|callback|
+				callback.next_in <= 0
+			}.uniq.each {|callback|
+				@callbacks.delete(callback) if callback.one_shot?
+
+				next if callback.gonna_call?
+
+				callback.gonna_call!
+
+				workers.do {
+					callback.call
+				}
+			}
+		end
+
+		save
+	end
+
+	def stop!
+		@running = false;
+		wake_up
+	end
+end

metadata

@@ -1,26 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: herpes
 version: !ruby/object:Gem::Version
-  version: 0.0.1a1
-  prerelease: 5
+  version: 0.0.1
+  prerelease: 
 platform: ruby
 authors:
 - meh.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-21 00:00:00.000000000 Z
-dependencies: []
+date: 2011-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpool
+  requirement: &10434500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *10434500
 description: 
 email: meh@paranoici.org
-executables: []
+executables:
+- herpes
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- bin/herpes
+- examples/generator.rb
 - examples/rss.rb
 - herpes.gemspec
+- lib/herpes.rb
+- lib/herpes/email.rb
+- lib/herpes/event.rb
+- lib/herpes/extensions.rb
+- lib/herpes/module.rb
+- lib/herpes/rss.rb
 - lib/herpes/version.rb
+- lib/herpes/workers.rb
 homepage: http://github.com/meh/herpes
 licenses: []
 post_install_message: 
@@ -36,9 +57,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10