dam 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jean-Philippe Bougie
+ 
+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.markdown

@@ -0,0 +1,2 @@
+== Dam
+A ruby framework for Activity Streams

data/Rakefile

@@ -0,0 +1,34 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+
+begin
+  require 'jeweler'
+  require 'dam/version'
+ 
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "dam"
+    gemspec.summary = "An activity stream framework for Ruby"
+    gemspec.description = ""
+    gemspec.email = "jp.bougie@gmail.com"
+    gemspec.homepage = "http://github.com/jpbougie/dam"
+    gemspec.authors = ["Jean-Philippe Bougie"]
+    gemspec.version = Dam::Version
+ 
+    gemspec.add_dependency "redis"
+    gemspec.add_dependency "yajl-ruby"
+    gemspec.add_development_dependency "jeweler"
+    gemspec.add_development_dependency "riot"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: "
+  puts "gem install jeweler"
+end

data/lib/dam/activity.rb

@@ -0,0 +1,120 @@
+module Dam
+  
+  private
+  
+  class TypeProxy
+    instance_methods.each { |m| undef_method m unless m =~ /(^__|instance_eval)/ }
+    
+    def initialize(type)
+      @type = type
+    end
+    
+    def method_missing(meth, arg=nil, &block)
+      
+      # the attribute can either be a static value, or a block to be evaluated, not both
+      raise ArgumentError unless (!arg.nil? ^ block_given?)
+      
+      if block_given?
+        @type.add_attribute(:name => meth, :block => block)
+      else
+        @type.add_attribute(:name => meth, :value => arg)
+      end
+      
+    end
+  end
+  
+  class Context
+    attr_reader :params
+    def initialize(params); @params = params; end
+  end
+  
+  public
+  
+  class ActivityType
+    attr_accessor :attributes
+    attr_reader :name
+
+    # Class methods
+    def self.register(type, act)
+      @activity_types ||= {}
+      @activity_types[type] = act
+    
+      act
+    end
+
+    def self.lookup(type)
+      @activity_types ||= {}
+      @activity_types[type]
+    end
+
+    # Instance methods
+    def initialize(name, &block)
+      @attributes = {}
+      @name = name
+      
+      proxy = TypeProxy.new(self)
+      
+      proxy.instance_eval(&block)
+    end
+    
+    def add_attribute(params = {})
+      @attributes[params[:name].to_s] = params[:value] || params[:block]
+      self
+    end
+    
+    def apply(params = {})
+      context = Context.new(params)
+      evaluated_attributes = {}
+      @attributes.each_pair do |attribute, value| 
+        evaluated_attributes[attribute.to_s] = if value.respond_to? :call
+          context.instance_eval(&value)
+        else
+          value
+        end
+      end
+      
+      Activity.new(self.name, evaluated_attributes)
+    end
+  end
+  
+  class Activity
+    
+    def self.[](name)
+      Dam::ActivityType.lookup(name)
+    end
+    
+    attr_accessor :attributes
+    def initialize(type, params = {})
+      @attributes = params
+      @type = type
+    end
+    
+    def ==(other)
+      @type == other.instance_variable_get("@type") && attributes == other.attributes
+    end
+    
+    def post!
+      Dam.push(self)
+    end
+    
+    def self.from_json json
+      attributes = Yajl::Parser.parse(json)
+      type = attributes.delete("_type").to_sym
+      new(type, attributes)
+    end
+    
+    def to_json
+      Yajl::Encoder.encode(self.attributes.merge({:_type => @type}))
+    end
+    
+    private
+    
+    def method_missing(meth, *args, &block)
+      if @attributes.has_key? meth.to_s
+        @attributes[meth.to_s]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/dam/storage.rb

@@ -0,0 +1,40 @@
+require 'redis'
+
+module Dam
+  class Storage
+    def Storage.register(name, engine)
+      @engines ||= {}
+      @engines[name] = engine
+    end
+    
+    def self.database
+      return @database if instance_variable_defined? '@database'
+    end
+    
+    def self.database=(database)
+      @database = database
+    end
+    
+    def self.insert(stream, activity)
+      key = stream.name
+      
+      self.database.push_head("stream:#{key}", activity.to_json)
+      self.database.ltrim("stream:#{key}", 0, (stream.limit || 10) - 1)
+      
+    end
+    
+    def self.get(stream_name)
+      self.database.list_range("stream:#{stream_name}", 0, -1)
+    end
+    
+    def self.head(stream_name)
+      self.database.list_index("stream:#{stream_name}", 0)
+    end
+    
+    private 
+    def Storage.lookup(name)
+      @engines ||= {}
+      @engines[name]
+    end
+  end
+end

data/lib/dam/stream.rb

@@ -0,0 +1,211 @@
+module Dam
+  
+  
+  PLACEHOLDER_PATTERN = %r{:[^:@/-]+}
+  
+  # provides the basis of the DSL to define a stream
+  class StreamDefinition
+    def initialize
+      @filters = []
+      @limit = 10
+    end
+    
+    def limit(amount = nil)
+      amount.nil? ? @amount : @amount = amount
+    end
+    
+    def filters
+      @filters
+    end
+    
+    def accepts(args = {})
+      @filters << args
+    end
+    
+    def params
+      ParamsProxy
+    end
+  end
+  
+  
+  # a class that will allow us to note which param has been used from the placeholders
+  class ParamsProxy
+    attr_reader :key
+    def initialize(key)
+      @key = key
+    end
+    
+    def self.[] key
+      ParamsProxy.new(key)
+    end
+  end
+  
+  # a templated stream is one which contains placeholders, and thus will only be defined through his instances
+  class TemplatedStream
+    attr_reader :name
+    
+    def initialize(name, definition)
+      @name = name
+      @definition = definition
+      
+      extract_placeholders!
+      make_glob_pattern!
+      make_regexp!
+    end
+    
+    def apply(params)
+      if params.is_a? String
+        name = params
+        params = extract_params(name)
+      else
+        name = replace_placeholders(params)
+      end
+      Stream.new(name, @definition, :params => params)
+    end
+    
+    def instances
+      elems = Dam::Storage.database.keys("stream:" + @glob_pattern)
+      elems.each {|elem| streams << apply(elem) }
+    end
+    
+    def matches? what
+      what =~ @regexp
+    end
+    
+    private
+    
+    def replace_placeholders(params)
+      name = @name
+      params.each_pair do |key, value|
+        name = name.gsub(":#{key}", value.to_s)
+      end
+      
+      name
+    end
+    
+    def extract_params(what)
+      Hash[*@placeholders.collect {|pat| pat[1..-1].to_sym}.zip(@regexp.match(what).captures).flatten]
+    end
+    
+    def extract_placeholders!
+      @placeholders = @name.scan(PLACEHOLDER_PATTERN)
+    end
+    
+    def make_glob_pattern!
+      @glob_pattern = @placeholders.inject(@name) do |name, placeholder|
+        name.sub(placeholder, "*")
+      end
+    end
+    
+    def make_regexp!
+      @regexp = Regexp.new(@placeholders.inject(@name) do |name, placeholder|
+        name.sub(placeholder, "([^/:-]+)")
+      end)
+    end
+  end
+  
+  class Stream
+    def Stream.lookup(name)
+      @streams ||= {}
+      if @streams.has_key? name
+        @streams[name]
+      else
+        template = @streams.values.find {|stream| stream.respond_to?(:instances) && stream.matches?(name)  }
+        template.apply(name) if template
+      end
+    end
+    
+    def Stream.[](name)
+      lookup(name)
+    end
+    
+    def Stream.register(name, stream)
+      @streams ||= {}
+      @streams[name] = stream
+      stream
+    end
+    
+    def Stream.has_placeholder? string
+      string =~ PLACEHOLDER_PATTERN
+    end
+    
+    def Stream.all
+      @streams.values.collect {|stream| stream.respond_to?(:instances) ? stream.instances : stream }.flatten
+    end
+    
+    
+    attr_reader :name
+        
+    def initialize(name, definition, params = {})
+      @name = name
+      @definition = definition
+      @params = params.delete(:params)
+    end
+    
+    def limit
+      @definition.limit
+    end
+    
+    def filters
+      @definition.filters
+    end
+    
+    def all
+      Dam::Storage.get(self.name).collect do |json|
+        Activity.from_json json
+      end
+    end
+    
+    def first
+      Activity.from_json(Dam::Storage.head(self.name))
+    end
+
+    def matches? activity
+      filters.any? do |filter|
+        return true if filter == :all
+        
+        filter.any? do |key, value|
+          attr_match(value, activity.attributes[key.to_s])
+        end
+      end
+    end
+    
+    def instantiate!
+      ensure_exists!
+      self
+    end
+    
+    private
+    
+    def ensure_exists!
+      if Dam::Storage.database.keys("stream:#{name}").size == 0
+        Dam::Storage.database.push_head("stream:#{name}", 1)
+        Dam::Storage.database.pop_head("stream:#{name}")
+      end
+    end
+  
+    def attr_match(condition, element)
+      # match a nil element with a nil condition
+      return condition.nil? if element.nil?
+      
+      if condition.respond_to? :each_pair
+        condition.all? do |key, value|
+          (element.respond_to?(key) ? element.send(key) : element[key]) == eval_arg(element)
+        end
+      else
+        condition == eval_arg(element)
+      end
+    end
+    
+    def eval_arg(arg)
+      case arg
+      when ParamsProxy
+        @params[arg.key]
+      when Proc
+        arg.call
+      else
+        arg
+      end
+    end
+  end
+end

data/lib/dam/version.rb

@@ -0,0 +1,3 @@
+module Dam
+  Version = "0.1.0"
+end

data/lib/dam.rb

@@ -0,0 +1,39 @@
+require 'dam/activity'
+require 'dam/storage'
+require 'dam/stream'
+
+require 'yajl'
+
+module Dam
+  
+  def self.push(activity)
+    Dam::Stream.all.select {|stream| stream.matches? activity }.each do |stream|
+      Dam::Storage.insert(stream, activity)
+    end
+  end
+  
+  def self.post(type, params = {})
+    act = Activity.new(Dam::ActivityType.lookup(type.to_sym), params)
+
+    act.submit!
+  end
+  
+  def self.activity(name, &block)
+    act = Dam::ActivityType.new(name, &block)
+    Dam::ActivityType.register(name, act)
+    act
+  end
+  
+  def self.stream(name, &block)
+    definition = StreamDefinition.new
+    definition.instance_eval(&block)
+    
+    stream = if Stream.has_placeholder? name
+      TemplatedStream.new(name, definition)
+    else
+      Stream.new(name, definition)
+    end
+    Dam::Stream.register(name, stream)
+  end
+  
+end

data/test/activity_test.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "a new activity type" do
+  setup do
+    Dam::activity :comment_posted do
+      author "Some Author"
+      action :post
+      
+      comment do
+        {:id => params[:comment]}
+      end
+      
+      project do
+        {:id => params[:project], :some_other_property => true }
+      end
+      published { Date.today }
+      text { "a comment has been posted" }
+    end
+  end
+  
+  topic.kind_of(Dam::ActivityType)
+  
+  asserts("is registered") { topic }.equals(Dam::ActivityType.lookup(:comment_posted))
+  asserts("has a name") { topic.name }.equals(:comment_posted)
+  
+  asserts("has a static author") { topic.attributes["author"] }.equals("Some Author")
+  asserts("has a static action") { topic.attributes["action"] }.equals(:post)
+  
+  asserts("has a comment proc") { topic.attributes["comment"] }.kind_of(Proc)
+  asserts("has a project proc") { topic.attributes["project"] }.kind_of(Proc)
+  
+  asserts("has a published proc") { topic.attributes["published"] }.kind_of(Proc)
+  asserts("has a text proc") { topic.attributes["text"] }.kind_of(Proc)
+  
+  context "can be instantiated" do
+    setup do
+      topic.apply({:comment => "ab3d", :project => "xyz" })
+    end
+    
+    topic.kind_of(Dam::Activity)
+    
+    asserts("the author has been evaluated") { topic.author }.equals("Some Author")
+    asserts("the action has been evaluated") { topic.action }.equals(:post)
+    asserts("the published date has been evaluated") { topic.published }.kind_of(Date)
+    asserts("the comment has been evaluated") { topic.comment }.equals({:id => "ab3d"})
+    asserts("the project has been evaluated") { topic.project }.equals({:id => "xyz", :some_other_property => true})
+    asserts("the text has been evaluated") { topic.text }.equals("a comment has been posted")
+  end
+end
+
+
+context "an activity without params" do
+  setup do
+    Dam.activity :no_params do
+      action :post
+      author "bob"
+      some_param 123
+    end
+  end
+   topic.kind_of(Dam::ActivityType)
+   asserts("can be applied without params") { topic.apply }.kind_of(Dam::Activity)
+end

data/test/stream_test.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+# Define some activities to be used in the tests
+Dam.activity :comment do
+  action "post"
+  author { { "name" => params[:author] } }
+end
+
+Dam.activity :edit do
+  action :edit
+end
+
+
+context "a stream which filters the latest 25 activities" do
+  setup do
+    Dam::stream :all do
+      limit 25
+      accepts :all
+    end
+  end
+  
+  topic.kind_of(Dam::Stream)
+  topic.equals(Dam::Stream[:all])
+  asserts("has one filter") { topic.filters.size }.equals(1)
+  asserts("has a limit of 25") { topic.limit }.equals(25)
+  
+  asserts("accepts an activity") { topic.matches? Dam::Activity[:comment].apply({:author => "test"})}
+end
+
+context "a stream which only accepts edits" do
+  setup do
+    Dam::stream :edit_actions do
+      accepts :action => :edit
+    end
+  end
+  
+  topic.kind_of(Dam::Stream)
+  asserts("rejects a post action") { !topic.matches? Dam::Activity[:comment].apply({:author => "test"})}
+  asserts("accepts an edit") { topic.matches? Dam::Activity[:edit].apply}
+end
+
+context "a stream with a complex object filter" do
+  setup do
+    Dam::stream :only_from_bob do
+      accepts :author => { "name" => "bob" }
+    end
+  end
+  
+  topic.kind_of(Dam::Stream)
+  asserts("accepts a valid activity") { topic.matches? Dam::Activity[:comment].apply({:author => "bob"})}
+  asserts("rejects an activity with a different value") { !topic.matches? Dam::Activity[:comment].apply({:author => "not bob"})}
+  asserts("reject an activity which doesn't have the attribute") { !topic.matches? Dam::Activity[:edit].apply }
+end
+
+context "post an activity" do
+  setup do
+    Dam::Storage.clear!
+    Dam.stream :all do
+      accepts :all
+    end
+    
+    act = Dam::Activity[:comment].apply(:author => "bob")
+    act.post!
+    act
+  end
+  
+  asserts("the stream has one element") { Dam::Stream[:all].all.size }.equals(1)
+  topic.equals(Dam::Stream[:all].first)
+end
+
+context "post multiple activities" do
+  setup do
+    Dam::Storage.clear!
+    Dam.stream :only_2 do
+      accepts :all
+      limit 2
+    end
+    3.times {|i| Dam::Activity[:comment].apply(:author => "bob_#{i}").post! }
+  end
+  
+  asserts("the stream has been limited to 2 elements") { Dam::Stream[:only_2].all.size }.equals(2)
+  asserts("the first one is the last to be entered") { Dam::Stream[:only_2].first.author }.equals({"name" => "bob_2"})
+end
+
+
+context "a parameterized stream" do
+  setup do
+    Dam::Storage.clear!
+    Dam.stream "comments/:author" do
+      accepts :author => { "name" => params[:author] }
+    end
+  end
+  
+  topic.kind_of(Dam::TemplatedStream)
+  asserts("has no actual instances at first") { topic.instances.size }.equals(0)
+  
+  context "with an instance" do
+    setup do
+      Dam::Stream["comments/bob"].instantiate!
+    end
+    
+    topic.kind_of(Dam::Stream)
+    asserts("matches a valid activity") { topic.matches? Dam::Activity[:comment].apply(:author => "bob") }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+
+require 'riot'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'dam'
+
+DATABASE = 15 # change this if you already use database #15 for something else
+
+Dam::Storage.database = Redis.new(:db => DATABASE) # change this to your running redis server
+
+module Dam
+  class Storage
+    def self.clear!
+      @database.keys("*").each {|k| @database.delete k}
+    end
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: dam
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jean-Philippe Bougie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-20 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: riot
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: ""
+email: jp.bougie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/dam.rb
+- lib/dam/activity.rb
+- lib/dam/storage.rb
+- lib/dam/stream.rb
+- lib/dam/version.rb
+- test/activity_test.rb
+- test/stream_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/jpbougie/dam
+licenses: []
+
+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"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An activity stream framework for Ruby
+test_files: 
+- test/activity_test.rb
+- test/stream_test.rb
+- test/test_helper.rb