place 0.1.0

data/lib/place/time_point.rb

@@ -0,0 +1,55 @@
+module Place
+
+# A TimePoint is a "named milestone"
+class TimePoint < Ohm::Model
+  attribute :tid
+  index :tid
+  attribute :url
+  
+  attribute :name
+  attribute :time
+  attribute :description
+  
+  reference :project, Project
+  
+  collection :workitems, WorkItem, :timepoint
+    
+  class << self; attr_accessor :rules end
+  @rules = {
+    'name'			=> '//time-point/field[@id="name"]',
+	'description'	=> '//time-point/field[@id="description"]',
+	'time'			=> '//time-point/field[@id="time"]'
+  }
+
+  # Collect all timepoints (url) under a given project url
+  def self.collect_all(base_url)
+    Dir.glob(base_url + '/tracker/timepoints/*.xml').each do |filename|
+	  TimePoint.create(
+		:tid		=> File.basename(filename, '.xml'),
+		:url		=> filename,
+		:project	=> Project.find_by_url(base_url)
+	  )
+	  Place.logger.info("collected timepoint at #{filename}")
+	end
+  end
+  
+  # Retrieve a specific timepoint data (name, time, description)
+  def retrieve
+    content = IO.readlines(url).join('')
+	doc = Nokogiri::XML(content)
+	self.class.rules.each_pair do |k,v|
+	  tmp = doc.xpath(v)
+	  self.send("#{k}=", tmp[0].content)  unless tmp[0].nil?		
+	end
+	Place.logger.info("retrieved timepoint #{self.url}")
+    self.save
+  end
+  
+  def self.find_by_tid(tid)
+    return nil  if tid.nil?
+    tps = self.find(:tid => tid.to_s)
+	tps.nil? ? nil : tps[0]
+  end
+end
+
+end

data/lib/place/user.rb

@@ -0,0 +1,79 @@
+module Place
+
+# A User is an account under Polarion
+class User < Ohm::Model
+  attribute :name
+  index :name
+  attribute :url
+  
+  attribute :full_name
+  attribute :description
+  attribute :email
+
+  collection :workrecords, WorkRecord, :user
+  collection :comments, Comment, :author
+
+  set :watches, WorkItem
+  collection :author_of, WorkItem, :author
+  set :assignments, WorkItem
+  
+  collection :participations, Participation, :user
+
+  
+  # Collect all users (name, url) under a given repository url
+  def self.collect_all(base_url)
+    Dir.glob(base_url + '/.polarion/user-management/users/**/user.xml').each do |filename|
+	  User.create(
+		:name	=> File.dirname(filename).split(/\//).last,
+		:url	=> filename
+	  )
+	  Place.logger.info("collected user at #{filename}")
+	end
+  end
+  
+  class << self; attr_accessor :rules end
+  @rules = {
+    'full_name'   => '//user/field[@id="name"]',
+	'description' => '//user/field[@id="description"]',
+	'email'       => '//user/field[@id="email"]'
+  }
+  
+  # Retrieve a specific user data (based on name and url only)
+  def retrieve
+    content = IO.readlines(url).join('')
+    doc = Nokogiri::XML(content)
+	self.class.rules.each_pair do |k,v|
+	  tmp = doc.xpath(v)
+	  self.send("#{k}=", tmp[0].content)  unless tmp[0].nil?		
+	end
+	Place.logger.info("retrieved user at #{self.name}")
+	self.save
+  end
+  
+  def retrieve_watches
+    content = IO.readlines(url).join('')
+	doc = Nokogiri::XML(content)
+    doc.xpath('//user/field[@id="watches"]/list//item').each do |wa|
+	  prj, wid = wa.text.split('$')
+	  if Project.all.map{|p| p.name}.include?(prj)
+	    wi = WorkItem.find_by_wid(wid)
+		unless wi.nil?
+		  wi.watches << User.find_by_name(name)
+		  wi.save
+		  self.watches << wi
+		  self.save
+		end
+	  end
+	end
+	Place.logger.info("retrieved watches for user #{self.name}")
+	self
+  end
+  
+  # Find a user by the given name, returns +nil+ if not present
+  def self.find_by_name(name)
+    users = self.find(:name => name.to_s)
+	  users.nil? ? nil : users[0]
+  end
+end
+
+end

data/lib/place/work_item.rb

@@ -0,0 +1,179 @@
+
+require 'set'
+
+module Place
+
+# Each WorkItem has a work-item id (wid) and an url that refers to its main xml file (workitem.xml) located under its own directory (that terminates with its Polarion ID = our wid).
+class WorkItem < Ohm::Model
+  attribute :wid
+  index :wid
+  
+  attribute :url
+  attribute :type
+  index :type
+  attribute :fields
+  
+  reference :author, User
+  set :assignees, User
+    
+  reference :timepoint, TimePoint
+  reference :project, Project
+  
+  set :watches, User
+  collection :workrecords, WorkRecord, :workitem
+  collection :comments, Comment, :workitem
+  
+  # Collect all workitems (wid and url) under a given project url
+  def self.collect_all(base_url)
+    Dir.glob(base_url + '/tracker/workitems/**/workitem.xml').each do |filename|
+	  wi = WorkItem.create(
+		:wid	=> File.dirname(filename).split(/\//).last,
+		:url	=> filename,
+		:fields => "{}"
+	  )
+	  project_prefix = wi.wid.split(/\-/)[0]
+	  wi.project = Project.find_by_prefix(project_prefix)
+	  Place.logger.info("collected workitem at #{wi.url}")
+	  wi.save	  
+	end
+  end
+
+  # Retrieve a specific workitem (based on wid and url only)
+  def retrieve
+    content = IO.readlines(url).join('')
+	doc = Nokogiri::XML(content)
+	  
+    doc.xpath('//work-item/field').each do |field|
+      self[field.attributes['id'].to_s] = field.content
+    end
+
+    self.type = self[:type]
+	
+	self.author = User.find_by_name(self[:author])
+
+	unless self[:assignee].nil?
+	  self[:assignee].split.each do |name|
+	    u = User.find_by_name(name)
+		unless u.nil?
+	      self.assignees << u
+		  u.assignments << self  
+		end
+	  end
+	end
+
+	self.timepoint = TimePoint.find_by_tid(self['timePoint'])
+	
+	%w(initialEstimate timeSpent remainingEstimate).each do |t|
+	  self[t] = to_hours(self[t])
+	end
+	
+	# links
+    doc.xpath('/work-item/field[@id="linkedWorkItems"]/list/struct').each do |struct|
+	  l = Link.create(
+		:role		=> struct.xpath('item[@id="role"]').text,
+		:suspect	=> struct.xpath('item[@id="suspect"]').text == 'true' ? true : false,
+		:revision	=> struct.xpath('item[@id="revision"]').empty? ? false : true,
+		:from		=> self,
+		:to			=> WorkItem.find_by_wid(struct.xpath('item[@id="workItem"]').text),
+		:from_wid	=> self.wid,
+		:to_wid		=> struct.xpath('item[@id="workItem"]').text
+		)
+	end
+	
+	# comments
+	Dir.glob(File.dirname(url) + '/comment-*.xml').each do |filename|
+	  c = Comment.create(:url => filename)
+	  c.retrieve
+	end
+	
+	# workrecords
+	Dir.glob(File.dirname(url) + '/workrecord-*.xml').each do |filename|
+	  wr = WorkRecord.create(:url => filename)
+	  wr.retrieve
+	end
+	
+	Place.logger.info("retrieved workitem #{self.wid}")	
+	
+	self.save
+  end
+  
+  # Get value from specified field, +nil+ if not present
+  def [](fname)
+    JSON.parse(fields)[fname.to_s]
+  end
+  
+  # Set value for specified field
+  def []=(fname, fvalue)
+    h = JSON.parse(self.fields)
+    h[fname.to_s] = fvalue
+	self.fields = h.to_json
+  end
+  
+  # Returns a workitem by its wid, +nil+ if not present
+  def self.find_by_wid(wid)
+    wis = self.find(:wid => wid)
+	wis.nil? ? nil : wis[0]
+  end
+  
+  # Returns all workitems of the given +type+
+  def self.find_by_type(type)
+    #self.all.select{|wi| wi.type == type.to_s}
+	self.find(:type => type.to_s)
+  end
+  
+  # Returns all links from the current workitems to others, eventually only with a specified role
+  def links_out(role=nil)    
+	if role.nil?
+	  Link.find(:from_wid => self.wid)
+	else
+	  Link.find(:from_wid => self.wid, :role => role.to_s)
+	end
+  end
+  
+  # Returns all links to the current workitems from others, eventually only with a specified role
+  def links_in(role=nil)
+	if role.nil?
+	  Link.find(:to_wid => self.wid)
+	else
+	  Link.find(:to_wid => self.wid, :role => role.to_s)
+	end
+  end
+  
+  # Returns all the fields name for the workitem
+  def field_names
+    JSON.parse(self.fields).keys.sort
+  end
+  
+  # Returns the total sum, for a given +field+, from descendant and workitem itself
+  # Note: descendants = children with parent role 
+  def total_on(field)
+    # return a past computed value if present
+	return self["_total_on_#{field}"]  unless self["_total_on_#{field}"].nil?
+  
+    # computing the total
+	total = self[field].nil? ? 0 : self[field]
+	children.each{|c| total += c.total_on(field) }
+	
+	# saving (momoizing) for future invocations
+	self["_total_on_#{field}"] = total.to_f
+	self.save
+	
+	total.to_f
+  end
+
+  
+  private
+
+  
+  # Returns workitem effective children (linked in with a parent role)
+  def children
+    tmp = [].to_set
+	project.parent_roles.each do |role|
+	  tmp.merge(links_in(role).map{|lnk| lnk.from})  unless links_in(role).empty?
+	end
+    tmp.to_a
+  end
+
+end
+
+end

data/lib/place/work_record.rb

@@ -0,0 +1,51 @@
+module Place
+
+# Each WorkRecord ties a User to a WorkItem, with a +time_spent+, +date+ plus a +type+ and a +comment+
+class WorkRecord < Ohm::Model
+  attribute :url
+  index :url
+
+  attribute :time_spent
+  attribute :date
+  attribute :type
+  attribute :comment
+
+  reference :user, User
+  reference :workitem, WorkItem
+
+  class << self; attr_accessor :rules end
+  @rules = {
+    'time_spent'	=> '//work-record/field[@id="timeSpent"]',
+	'date'			=> '//work-record/field[@id="date"]',
+	'type'			=> '//work-record/field[@id="type"]',
+	'comment'		=> '//work-record/field[@id="comment"]',
+	'user'			=> '//work-record/field[@id="user"]'
+  }
+
+  # Retrieve a specific workrecord data (time_spent, date, user, workitem) + (type, comment)
+  def retrieve
+    content = IO.readlines(url).join('')
+	doc = Nokogiri::XML(content)
+	self.class.rules.each_pair do |k,v|
+	  tmp = doc.xpath(v)
+
+	  case k
+	    when 'time_spent'
+		  self.send("#{k}=", to_hours(tmp[0].content))
+		when 'user'
+		  self.send("#{k}=", User.find_by_name(tmp[0].content))
+		else
+		  self.send("#{k}=", tmp[0].content)  unless tmp[0].nil?		
+	  end
+	end
+	
+	self.workitem = WorkItem.find_by_wid(File.dirname(self.url).split(/\//).last)
+	
+	Place.logger.info("saved workrecord #{self.url}")
+	
+    self.save
+  end
+end
+
+
+end

data/lib/place.rb

@@ -0,0 +1,112 @@
+require 'rubygems'
+
+require 'ohm'
+require 'nokogiri'
+require 'json'
+require 'logger'
+
+
+require File.join(File.dirname(__FILE__), 'place', 'project')
+require File.join(File.dirname(__FILE__), 'place', 'time_point')
+require File.join(File.dirname(__FILE__), 'place', 'user')
+require File.join(File.dirname(__FILE__), 'place', 'work_item')
+require File.join(File.dirname(__FILE__), 'place', 'work_record')
+require File.join(File.dirname(__FILE__), 'place', 'comment')
+require File.join(File.dirname(__FILE__), 'place', 'link')
+require File.join(File.dirname(__FILE__), 'place', 'participation')
+
+
+module Place
+  VERSION = '0.1.0'
+
+  @conf = {}
+  
+  def self.setup(repository_path)
+    @conf['base'] = repository_path
+	Ohm.connect
+  end
+  
+  def self.conf
+    @conf
+  end
+  
+  def self.logger
+    @log
+  end  
+  
+  def self.logger_setup(filename=nil)
+    unless filename.nil?
+      @log = Logger.new(filename)
+    else	  
+      @log = Logger.new(STDERR)
+	end
+	@log.level = Logger::INFO   
+  end
+  
+  # Collect and retrieve all repo information, for each contained project
+  # If a project url is specified, it retrieves only info on this project
+  # BEWARE: each gather flush the whole database!
+  def gather!(project_url=nil)
+    start_time = Time.now.to_i
+	
+    path = @conf['base']  # without ending '.polarion'
+    Ohm.flush
+	
+	Project.collect_all(path)
+    User.collect_all(path)
+	
+	unless project_url.nil?
+	  prj = Project.find_by_url(project_url)
+	  prj.retrieve
+	else
+      Project.all.each{|prj| prj.retrieve}
+	end
+	
+	Ohm.redis.set 'updated_duration', Time.now.to_i - start_time
+  end
+
+  # Write last update timespent for the whole database  
+  def updated!
+    Ohm.redis.set 'updated', Time.now.strftime("%d.%m.%Y %H:%M:%S")
+  end
+  
+  def updated_at
+    Ohm.redis.get 'updated'
+  end
+  
+  def updated?
+    not updated_at.nil?
+  end
+  
+  def updated_duration
+    Ohm.redis.get 'updated_duration'
+  end
+  
+  def reset!
+    Ohm.flush
+  end
+
+  # from duration to number of hours (1d == 8h)
+  def to_hours(duration)
+    return nil if duration.nil?
+	# TODO with a case statement or another regexp?
+    if duration =~ /(\d+)d\s(\d+)h/
+      days, hours = $1.to_f, $2.to_f
+	elsif duration =~ /(\d+)\/(\d+)d/
+	  days = $1.to_f / $2.to_f
+	  hours = 0
+	elsif duration =~ /(\d+)\/(\d+)h/
+	  days = 0
+	  hours = $1.to_f / $2.to_f
+    elsif duration =~ /(\d+)d/
+	  days, hours = $1.to_f, 0
+    elsif duration =~ /(\d+)h/
+	  days, hours =  0, $1.to_f
+    else
+	  days, hours =  0, 0
+    end
+
+    (8*days + hours)
+  end
+
+end

data/place.gemspec

@@ -0,0 +1,19 @@
+
+Gem::Specification.new do |s|
+  s.name              = "place"
+  s.version           = "0.1.0"
+  s.summary           = "Polarion LACE: Polarion items access in Ruby"
+  s.description		  = <<-EOF
+    Extract information from Polarion and turns it into easy manageable ruby objects.
+	
+	Those objects are stored via Redis.
+  EOF
+  s.authors           = ["Carlo Pecchia"]
+  s.email             = ["info@carlopecchia.eu"]
+  s.homepage          = "http://github.com/carlopecchia/place"
+  s.add_dependency('json')
+  s.add_dependency('ohm')
+  s.add_dependency('nokogiri')
+  s.files = ["Changelog", "LICENSE", "README.markdown", "Technical.markdown", "Rakefile", "lib/place.rb", "lib/place/project.rb", "lib/place/link.rb", "lib/place/participation.rb", "lib/place/user.rb", "lib/place/time_point.rb", "lib/place/work_item.rb", "lib/place/work_record.rb", "lib/place/comment.rb", "place.gemspec", "test/test_project.rb", "test/helper.rb", "test/test_workitem.rb", "test/test_time_point.rb", "test/test_place.rb", "test/test_comment.rb", "test/test_user.rb", "examples/sample-1.rb"]
+end
+

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$: << File.join(File.dirname(__FILE__), '../lib')
+require 'ohm'
+require 'place'
+include Place
+
+Place.logger_setup('/dev/null')

data/test/test_comment.rb

@@ -0,0 +1,35 @@
+
+$: << File.join(File.dirname(__FILE__), '.')
+require 'helper.rb'
+
+class CommentTest < Test::Unit::TestCase
+
+  def setup
+	Place.setup(File.expand_path(File.join(File.dirname(__FILE__), 'repo')))
+	Place.gather!
+  end
+
+  def teardown
+    Ohm.flush
+  end
+
+  def test_environment
+	Comment.all.each do |c|
+	  assert_not_nil c.author
+	  assert_not_nil c.workitem
+	  assert_not_nil c.text
+	  assert_not_nil c.created
+	end
+  end
+  
+  def test_find_by_cid
+	assert_not_nil Comment.find_by_cid('P-6#1')
+	assert_nil Comment.find_by_cid('P-6#z00')
+  end
+  
+  def test_parent
+	c = Comment.find_by_cid('P-6#2')
+	assert_not_nil c.parent
+	assert_equal Comment.find_by_cid('P-6#1'), c.parent
+  end
+end

data/test/test_place.rb

@@ -0,0 +1,28 @@
+
+$: << File.join(File.dirname(__FILE__), '.')
+require 'helper.rb'
+
+class PlaceTest < Test::Unit::TestCase
+
+  def teardown
+    Ohm.flush
+  end	
+  
+  def test_gather
+	base = File.expand_path(File.join(File.dirname(__FILE__), 'repo'))
+	Place.setup(base)
+	Place.gather!
+	
+	assert_equal 2, Project.all.size
+  end
+  
+  def test_duration
+	assert_equal  11, to_hours('1d 3h')
+	assert_equal  16, to_hours('2d')
+	assert_equal   3, to_hours('3h')
+	assert_equal 0.5, to_hours('1/2h')
+	assert_equal   4, to_hours('1/2d')
+	assert_equal   0, to_hours('')
+	assert_equal nil, to_hours(nil)
+  end
+end

data/test/test_project.rb

@@ -0,0 +1,100 @@
+
+$: << File.join(File.dirname(__FILE__), '.')
+require 'helper.rb'
+
+class ProjectTest < Test::Unit::TestCase
+
+  def setup
+	@base = File.expand_path(File.join(File.dirname(__FILE__), 'repo'))
+	Place.setup(@base)
+	Place.gather!  
+  end
+
+  def teardown
+    Ohm.flush
+  end
+
+  def test_collecting
+    assert_not_nil @base
+	assert_equal 2, Project.all.size
+  end
+
+  def test_find_by_name
+	p = Project.find_by_name('P')
+	assert_equal 'P', p.name
+	assert_equal 'P', p.prefix
+	assert_not_nil p.description
+	
+	p = Project.find_by_name 'NONE'
+	assert_nil p
+  end
+  
+  def test_find_by_url
+	p = Project.find_by_url(@base + '/P/.polarion')
+	assert_not_nil p
+	
+	b = Project.find_by_url(@base + '/A/B/.polarion')
+	assert_not_nil b
+	
+	n = Project.find_by_url(@base + '/none/.polarion')
+	assert_nil n
+  end
+  
+  def test_find_by_prefix
+	p = Project.find_by_prefix('P')
+	assert_not_nil p
+	
+	p = Project.find_by_prefix('NONE')
+	assert_nil p
+  end
+  
+  def test_workitems
+	p = Project.find_by_name('P')
+	assert_not_nil p
+
+	assert p.workitems.all.size > 0
+
+	wi = p.workitems.all.first
+	assert_not_nil wi
+	assert_equal p, wi.project
+  end
+  
+  def test_roles
+    p = Project.find_by_name('P')
+	assert_not_nil p
+	
+	assert p.roles.size > 0
+	assert p.roles.include?('project_admin')
+	assert !p.roles.include?('foo servant role')
+  end
+  
+  def test_users
+    p = Project.find_by_name('P')
+	assert_not_nil p
+	
+	assert_equal 2, p.users.size
+	assert_equal 1, p.users('project_admin').size
+	
+	u = User.find_by_name 'alice'
+	assert_not_nil u
+	assert_equal u, p.users('project_admin').first
+  end
+  
+  def test_parent_roles
+	p = Project.find_by_name('P')
+	assert_not_nil p
+
+	assert ! p.parent_roles.empty?
+	assert p.parent_roles.include?('parent')
+	assert p.parent_roles.include?('refines')
+	assert ! p.parent_roles.include?('depends')
+
+    # A/B doesn't have a local file for workitem-link-roles	
+	b = Project.find_by_url(@base + '/A/B/.polarion')
+	assert_not_nil b
+	assert ! b.parent_roles.empty?
+	assert b.parent_roles.include?('parent')
+	assert_equal 1, b.parent_roles.size 
+  end
+
+end