version-one 0.0.2

data/lib/version-one/asset_ref.rb

@@ -0,0 +1,51 @@
+require 'libxml'
+
+module VersionOne
+  class AssetRef
+    attr_reader   :href, :id
+
+    def initialize(xml_or_asset)
+      case xml_or_asset
+        when Asset
+          @asset = xml_or_asset
+          @id = @asset.id
+          @href = @asset.href
+        else
+          @href = xml_or_asset.attributes['href']
+          @id = xml_or_asset.attributes['idref']
+      end
+      raise ArgumentError, "Could not get id and href" unless @id && @href
+    end
+
+    def self.for(x)
+      x.is_a?(AssetRef) ? x : AssetRef.new(x)
+    end
+
+    def get(*fields)
+      @asset ||= get_asset(*fields)
+    end
+
+    def inspect
+      "#<AssetRef:#{@href}>"
+    end
+
+    def to_xml
+      xml = XML::Node.new('Asset')
+      xml.attributes['href'] = @href
+      xml.attributes['idref'] = @id
+      xml
+    end
+
+    def method_missing(method, *args, &block)
+      get.send(method, *args, &block)
+    end
+
+    private
+
+    def get_asset(*fields)
+      client = VersionOne::Client.new
+      xml = client.get(href, *fields)
+      Asset.new(xml: xml)
+    end
+  end
+end

data/lib/version-one/client.rb

@@ -0,0 +1,129 @@
+require 'xml/libxml'
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+module VersionOne
+  class Client
+    XML_CONTENT_TYPE = 'text/xml'
+
+    def get(path, *fields)
+      uri = path_uri(path)
+
+      unless fields.empty?
+        fields.concat(Query::REQUIRED_FIELDS)
+        uri.query = "sel=#{fields.join(',')}"
+      end
+
+      get_uri uri
+    end
+
+    def post_xml(path, xml)
+      uri = path_uri(path)
+      xml = xml.root if xml.respond_to?(:root)
+      xml.attributes['href'] = uri.path
+      request :post, uri do |r|
+        r.body = xml.to_s
+        r.content_type = XML_CONTENT_TYPE
+      end
+    end
+
+    def post(path)
+      uri = path_uri(path)
+      request :post, uri do |r|
+        r.body = ''
+        r.content_type = XML_CONTENT_TYPE
+      end
+    end
+
+    def get_uri(uri)
+      request :get, uri
+    end
+
+    def cache_store
+      #Rails.cache
+    end
+
+    def can_cache?
+      @cache && cache_store
+    end
+
+    def self.service_uri
+      @service_uri ||= get_service_uri
+    end
+
+    def service_uri
+      self.class.service_uri
+    end
+
+    private
+
+    def self.get_service_uri
+      raise "VersionOne service_uri must be configured" unless VersionOne.config.service_uri
+      URI.parse(VersionOne.config.service_uri)
+    end
+
+    def path_uri(path)
+      if path =~ /^#{service_uri.path}/i
+        uri = service_uri.dup
+        uri.path = path
+        uri
+      else
+        uri_string = service_uri.to_s + '/' + path.sub(/^\/+/, '')
+        URI.parse(uri_string)
+      end
+    end
+
+    def request(type, uri)
+      xml = nil
+      VersionOne.logger.debug('%s %s' % [type.to_s.upcase, uri.to_s])
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+
+      request_path = uri.path
+      request_path += '?' + uri.query if uri.query
+
+      result = http.start do
+        klass = case type
+                  when :get
+                    Net::HTTP::Get
+                  when :post
+                    Net::HTTP::Post
+                  else
+                    raise ArgumentError, "Unhandled request type: #{type}"
+                end
+        request = klass.new(request_path)
+        request.basic_auth(VersionOne.config.user, VersionOne.config.password)
+        yield request if block_given?
+        response = http.request(request)
+
+        if response.content_type == XML_CONTENT_TYPE
+          #VersionOne.logger.debug response.body
+          xml = XML::Document.string(response.body).root
+        end
+
+        if (response.code.to_i / 100) != 2
+          handle_error(xml, response, request)
+        end
+      end
+
+      xml || true
+    end
+
+    def handle_error(xml, response, request)
+      msg = ''
+      if xml && (xml.name == 'Error')
+        xml.each do |el|
+          msg << el.content
+          msg << "\n"
+        end
+      else
+        msg = response.body
+      end
+      VersionOne.logger.error("%s %s\n%s\n%s" % [response.code.to_s, request.path, response.message, msg])
+      raise "VersionOne Error: #{response.message} (#{request.path}) #{msg}"
+    end
+
+  end
+end

data/lib/version-one/config.rb

@@ -0,0 +1,40 @@
+require 'base64'
+require 'logger'
+
+module VersionOne
+  class Configuration
+    attr_accessor :user, :password, :service_uri
+
+    def load(options={})
+      raise ArgumentError.new("Parameter must be a hash") unless options.is_a?(Hash)
+
+      options.each do |k,v|
+        send(k.to_s + '=', v)
+      end
+    end
+
+    def password_base64=(val)
+      self.password=(Base64.decode64(val))
+    end
+
+  end
+
+  def self.config
+    @@config ||= Configuration.new
+  end
+
+  def self.logger=(l)
+    @@logger = l
+  end
+
+  def self.logger
+    @@logger ||= defined?(Rails) ? Rails.logger : create_logger
+  end
+
+  def self.create_logger
+    l = Logger.new(STDOUT)
+    l.level = Logger::INFO
+    l
+  end
+
+end

data/lib/version-one/meta/attribute_definition.rb

@@ -0,0 +1,50 @@
+module VersionOne
+
+  class AttributeDefinition
+
+    def initialize(xml)
+      @xml = xml
+      @original_type = @xml.attributes['attributetype']
+    end
+
+    def name
+      @name ||= @xml.attributes['name']
+    end
+
+    def type
+      @type ||= @original_type.downcase.to_sym
+    end
+
+    def multivalue?
+      bool('ismultivalue')
+    end
+
+    def readonly?
+      bool('isreadonly')
+    end
+
+    def required?
+      bool('isrequired')
+    end
+
+    def relation?
+      self.type == :relation
+    end
+
+    def attribute?
+      !relation?
+    end
+
+    def inspect
+      '#<AttributeDefinition:%s:%s>' % [self.name, @original_type]
+    end
+
+    private
+
+    def bool(name)
+      @xml.attributes[name] == 'True'
+    end
+
+  end
+
+end

data/lib/version-one/meta.rb

@@ -0,0 +1,74 @@
+require 'libxml'
+require 'version-one/meta/attribute_definition'
+
+module VersionOne
+  class Meta
+
+    attr_reader :name
+    attr_reader :attributes
+
+    def initialize(xml)
+      parse_xml(xml)
+    end
+
+    def self.get(asset_type, client=nil)
+      xml = get_cached(asset_type)
+
+      unless xml
+        client ||= VersionOne::Client.new
+        xml = client.get('/meta.v1/' + asset_type)
+        set_cached(asset_type, xml)
+      end
+
+      new(xml)
+    end
+
+    def self.cache
+      @@cache ||= nil
+    end
+
+    def self.cache=(c)
+      @@cache = c
+    end
+
+    def [](name)
+      @named_attributes[name]
+    end
+
+    def inspect
+      '#<Meta:%s>' % [self.name]
+    end
+
+    private
+
+    def parse_xml(xml)
+      @name = xml.attributes['name']
+      @attributes = []
+      @named_attributes = {}
+
+      xml.each do |child|
+        next unless child.element? && (child.name == 'AttributeDefinition')
+        a = AttributeDefinition.new(child)
+        next if a.name == 'ID'
+        @attributes << a
+        @named_attributes[a.name] = a
+      end
+
+    end
+
+    def self.get_cached(asset_type)
+      if cache
+        xml = XML::Document.string(cache.read("VersionOne/Meta/#{asset_type}")).root rescue nil
+        VersionOne.logger.debug("Loaded #{asset_type} meta from cache") if xml
+        xml
+      else
+        nil
+      end
+    end
+
+    def self.set_cached(asset_type, meta)
+      cache.write("VersionOne/Meta/#{asset_type}", meta.to_s) if cache
+    end
+
+  end
+end

data/lib/version-one/query.rb

@@ -0,0 +1,261 @@
+module VersionOne
+
+  class Query
+    REQUIRED_FIELDS = %w{AssetType}.freeze
+
+    def initialize(_asset_type, _client=nil)
+      @asset_type = _asset_type
+      @select = []
+      @filter = []
+      @order = []
+      @cache = nil
+      @asof = nil
+      @limit = nil
+      @offset = nil
+      @client = VersionOne::Client.new
+    end
+
+    def dup(&block)
+      q = Query.new(@asset_type)
+
+      [:@select, :@filter, :@order, :@asof, :@limit, :@offset, :@cache, :@client].each do |sym|
+        val = instance_variable_get(sym)
+        unless val.nil?
+          val = val.dup if val.is_a? Array
+          q.instance_variable_set(sym,  val)
+        end
+      end
+
+      q.instance_eval &block
+      q
+    end
+
+    def self.primary_work_items
+      Query.new 'PrimaryWorkitem'
+    end
+
+    def self.stories
+      Query.new 'Story'
+    end
+
+    def self.projects
+      Query.new 'Scope'
+    end
+
+    def self.sprints
+      Query.new 'Timebox'
+    end
+
+    def self.issues
+      Query.new 'Issue'
+    end
+
+    def find_by_url(url)
+      xml = nil
+      #xml = cache_store.read(@cache[:key]) if can_cache?
+      xml ||= @client.get(url)
+      #cache_store.write(@cache[:key], xml, @cache[:options]) if can_cache?
+
+      if xml.name == 'Error'
+        msg = 'VersionOne Error: %s (%s)' % [xml.find_first('Message').content, xml.attributes['href']]
+        raise msg
+      else
+        VersionOne::Asset.from_xml(xml)
+      end
+
+    end
+
+    def find(what)
+      url = to_url(what)
+      find_by_url(url)
+    end
+
+    def to_url(what=nil)
+      what = what.id.to_s if what.is_a?(Asset)
+
+      what = case what
+               when NilClass
+                 what
+               when Integer
+                 what.to_s
+               when /^[A-Z]+((?::\d+)+)$/i
+                 $1.gsub(':', '/')
+               else
+                 :bad
+             end
+
+      raise ArgumentError, 'Invalid parameter type' if what == :bad
+
+      url = ['rest-1.v1/Data', @asset_type, what].compact.join('/')
+
+      query = [
+          select_query,
+          filter_query,
+          page_query,
+          order_query,
+          asof_query
+      ].compact.join('&')
+
+      if query && !query.empty?
+        url << '?'
+        url << query
+      end
+
+      url
+    end
+
+    def select(*fields)
+      dup do
+        @select = @select + fields
+      end
+    end
+
+    def where(criteria)
+      criteria = case criteria
+                  when String
+                    [criteria]
+                  when Hash
+                    criteria.map{|k,v| "#{k}='#{v.to_s}'"}
+                  else
+                    raise ArgumentError
+      end
+      dup do
+        @filter.concat criteria
+      end
+    end
+
+    def for_project_and_children(project_id)
+      where("Scope.ParentMeAndUp='Scope:#{project_id}'")
+    end
+
+    def active
+      where("IsInactive='false'")
+    end
+
+    def order(attrib, dir=:asc)
+      raise ArgumentError unless attrib.is_a? String
+      attrib = '-' + attrib if dir == :desc
+      dup { @order << attrib }
+    end
+
+    def offset(index)
+      dup { @offset = index }
+    end
+
+    def limit(size)
+      dup { @limit = size }
+    end
+
+    def asof(date)
+      dup do
+        @asof = date
+      end
+    end
+
+    def first
+      limit(1).all.first
+    end
+
+    def all
+      find(nil)
+    end
+
+    def cache(key, options={})
+      dup do
+        @cache = {
+            :key => key,
+            :options => options
+        }
+      end
+    end
+
+    def to_a
+      all
+    end
+
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    private unless ENV['RAILS_ENV'] == 'test'
+
+    def http_get(uri)
+      xml = nil
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      request_path = uri.path
+      request_path += '?' + uri.query unless uri.query.blank?
+      Rails.logger.debug("Uri path = #{request_path}")
+
+      http.start do
+        request = Net::HTTP::Get.new(request_path)
+        request.basic_auth(VersionOne.user, VersionOne.password)
+        response = http.request(request)
+
+        xml = response.body
+        Rails.logger.debug(xml)
+      end
+
+      xml
+    end
+
+    def cache_store
+      Rails.cache
+    end
+
+    def can_cache?
+      @cache && cache_store
+    end
+
+    def select_query
+      if @select.empty?
+        nil
+      else
+        REQUIRED_FIELDS.each {|f| @select << f unless @select.include?(f) }
+        'sel=' + uri_escape(@select.join(','))
+      end
+    end
+
+    def filter_query
+      if @filter.empty?
+        nil
+      else
+        'where=' + uri_escape(@filter.collect{|s| "(#{s})"}.join(';'))
+      end
+    end
+
+    def page_query
+      if @limit
+        "page=#{@limit},#{@offset || 0}"
+      else
+        nil
+      end
+    end
+
+    def order_query
+      if @order.empty?
+        nil
+      else
+        'sort=' + uri_escape(@order.join(','))
+      end
+    end
+
+    def asof_query
+      if @asof.nil?
+        nil
+      else
+        'asof=' + @asof.xmlschema
+      end
+    end
+
+    def uri_escape(s)
+      @uri_parser ||= URI::Parser.new
+      @uri_parser.escape(s, /[^A-za-z0-9\-()']/)
+    end
+
+  end
+
+end
+