version-one 0.0.2

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea/
+spec/v1config.yml

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+1.9.2-p484

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in version-one.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'rspec-mocks'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dan Drew
+
+MIT License
+
+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,29 @@
+# Version::One::Gem
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'version-one-gem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install version-one-gem
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/version-one-gem/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/version-one/asset.rb

@@ -0,0 +1,434 @@
+require 'xml/libxml'
+require 'version-one/asset_ref'
+
+module VersionOne
+  class Asset
+
+    ASSET_TYPE_MAP = {
+        date:     Time,
+        text:     String,
+        numeric:  Float,
+        rank:     Integer
+    }.freeze
+
+    attr_reader   :type,
+                  :href,
+                  :meta,
+                  :attributes
+
+    def initialize(options={})
+      raise ArgumentError unless options.is_a?(Hash)
+      xml = options.delete(:xml)
+      @type = options.delete(:type)
+      @initialized = false
+      @href = nil
+
+      if xml
+        xml = xml.root if xml.is_a?(XML::Document)
+        @id = normalized_id(xml.attributes['id'])
+        @href = normalized_href(xml.attributes['href'])
+        unless @type
+          @type = xml.find_first('Attribute[@name="AssetType"]')
+          @type = @type.content
+        end
+      else
+        @id = normalized_id(options[:id]) if options[:id]
+      end
+
+      class_name = self.class.name.split('::').last
+      if class_name != 'Asset'
+        @type ||= class_name
+        raise ArgumentError, "Incompatible class #{class_name} for asset type #{@type}" unless @type == class_name
+      end
+
+      case @type
+        when String, Symbol
+          @type = @type.to_s
+        when NilClass
+          raise ArgumentError, 'No asset type specified' unless @type
+        else
+          raise ArgumentError, "Invalid asset type argument: #{@type.inspect}"
+      end
+
+      @meta = options[:meta]
+      @meta ||= options[:meta_cache][@type] if options.key?(:meta_cache)
+      @meta ||= Meta.get(@type)
+
+      @attributes = {}
+      @changed_attributes = {}
+      @setters = {}
+
+      @meta.attributes.each do |a|
+        simple_type = ASSET_TYPE_MAP[a.type]
+        if simple_type
+          add_simple_attribute(a, simple_type)
+        elsif a.type == :relation
+          add_relation_attribute(a)
+        else
+          add_simple_attribute(a, String)
+        end
+      end
+
+      if xml
+        xml.each {|el| init_attribute_value(el) }
+        @changed_attributes.clear
+      else
+        options.each do |name,val|
+          send("#{name}=", val)
+        end
+      end
+
+      @initialized = true
+
+      self
+    end
+
+    def id
+      @id
+    end
+
+    def ref
+      AssertRef.for(self)
+    end
+
+    def inspect
+      "<Asset:#{@id || @type || '???'}>"
+    end
+
+    def save(options={})
+      save!(options) rescue false
+    end
+
+    def save!(options={})
+      xml = change_xml
+      client = options[:client] || VersionOne::Client.new
+      response_xml = client.post_xml(save_url, xml)
+      @href ||= normalized_href(response_xml.attributes['href'])
+      @id ||= normalized_id(response_xml.attributes['id'])
+      @changed_attributes.clear
+      self
+    end
+
+    def delete!(options={})
+      exec('Delete', options) unless new_record?
+    end
+
+    def delete(options={})
+      delete! rescue false
+    end
+
+    def new_record?
+      @href.nil?
+    end
+
+    def add_comment(msg)
+      raise 'Cannot comment on an unsaved asset' if new_record?
+
+      conversation = VersionOne::Asset.new(type: 'Conversation')
+      conversation.save!
+
+      expression = VersionOne::Asset.new(type: 'Expression')
+      expression.content = msg
+      expression.belongs_to = conversation
+      expression.mentions = [self]
+      expression.save!
+    rescue
+      conversation.delete if conversation
+      raise
+    end
+
+    def exec(op_name, options={})
+      client = options[:client] || VersionOne::Client.new
+      client.post(href + "?op=#{op_name}")
+    end
+
+    def get_history(fields=nil)
+      path = href.sub(/\/[Dd]ata\//, '/Hist/')
+      client = VersionOne::Client.new
+      Asset.from_xml(client.get(path, fields))
+    end
+
+    def self.from_xml(xml)
+      meta = nil
+      case xml.name
+        when 'Asset'
+          Asset.new(xml: xml)
+        when 'Assets', 'History'
+          xml.find('Asset').map do |el|
+            a = Asset.new(xml: el, meta: meta)
+            meta ||= a.meta
+            a
+          end
+        else
+          raise "XML element #{xml.name} cannot be converted to an asset"
+      end
+    end
+
+    def self.get(id_or_href, *fields)
+      client = VersionOne::Client.new
+      if id_or_href =~ /^[A-Za-z]+:\d+$/
+        xml = client.get "/rest.v1/Data/#{id_or_href.sub(':', '/')}", *fields
+      else
+        xml = client.get id_or_href, *fields
+      end
+      Asset.from_xml(xml)
+    end
+
+    def reload(*fields)
+      Asset.get(self.href, *fields)
+    end
+
+    private
+
+    def init_attribute_value(el)
+      attr_name = el.attributes['name']
+
+      children = el.children
+      child_count = children.size
+      first = children[0]
+
+      if true #child_count > 0
+
+        case el.name
+          when 'Attribute'
+            val = case
+                    when child_count == 0
+                      nil
+                    when first.name == 'Value'
+                      children.map(&:content)
+                    else
+                      el.content
+                    end
+
+            #DEBUG puts "Setting #{attr_name} to #{val.inspect}"
+
+            if @setters[attr_name]
+              send(@setters[attr_name], val)
+            else
+              add_simple_attribute(attr_name, String, readonly: true)
+              @attributes[attr_name] = val
+            end
+
+          when 'Relation'
+            val = children.map{|v| (v.name == 'Asset') ? AssetRef.new(v) : nil}.compact
+            unless @setters[attr_name]
+              add_relation_attribute(attr_name, readonly: true)
+            end
+            send(@setters[attr_name], val)
+            @attributes[attr_name].unchanged! if @attributes[attr_name].respond_to?(:unchanged!)
+
+          else
+            # Ignore
+        end
+
+      end
+    end
+
+    def add_generic_attribute(attr_name, options={})
+      if attr_name.is_a?(VersionOne::AttributeDefinition)
+        a = attr_name
+        attr_name = a.name
+        options = {
+            readonly: a.readonly?,
+            multivalue: a.multivalue?
+        }
+      end
+
+      clean_name = attr_name.gsub('.', '_')
+      ruby_name = clean_name.gsub(/([a-z])([A-Z])/){|m|
+        $1 + '_' + $2
+      }.downcase
+      readonly = !!options[:readonly]
+
+      set_script = %{
+        def #{ruby_name}=(val)
+          raise "Can't set read-only property" if #{readonly.to_s} && @initialized
+          #{yield(attr_name, options)}
+          @attributes['#{attr_name}'] = val
+          @changed_attributes['#{attr_name}'] = true
+          val
+        end
+        }
+
+      get_script = %{
+def #{ruby_name}
+  @attributes['#{attr_name}']
+end
+
+def #{ruby_name}?
+  !!#{ruby_name}
+end
+
+def #{ruby_name}_definition
+  @meta.attributes['#{attr_name}']
+end
+}
+
+      instance_eval(get_script)
+      instance_eval(set_script)
+      @setters[attr_name] = "#{ruby_name}="
+    end
+
+    def add_simple_attribute(attr_name, native_type, options={})
+
+      add_generic_attribute(attr_name, options) do |attr_name, options|
+        convert = "convert_to_#{native_type}"
+        if options[:multivalue]
+          setter = %{
+          val = case val
+            when NilClass
+              val
+            when Array
+              val.map{|v| #{convert}('#{attr_name}',v) }
+            else
+              [#{convert}('#{attr_name}',val)]
+          end
+        }
+        else
+          setter = %{
+          val = case val
+            when NilClass
+              val
+            else
+              #{convert}('#{attr_name}',val)
+          end
+        }
+        end
+
+        setter
+      end
+
+    end
+
+    def add_relation_attribute(a, opts={})
+      add_generic_attribute(a, opts) do |attr_name, options|
+        script = %{
+          val = case val
+              when NilClass
+                val
+        }
+        if options[:multivalue]
+          script << %{
+            when Asset, AssetRef, Array
+              rel = @attributes['#{attr_name}'] || RelationMultiValue.new
+              rel.set(val)
+            else
+              raise ArgumentError, "Invalid argument type: %s" % [val.class.name]
+            end
+          }
+        else
+          script << %{
+            when Array
+              raise ArgumentError.new("Too many values for single value attribute") if val.size > 1
+              val[0]
+            when Asset, AssetRef
+              val
+            else
+              raise ArgumentError, "Invalid argument type: %s" % [val.class.name]
+            end
+            val = AssetRef.for(val) if val
+          }
+        end
+        script
+      end
+    end
+
+    def convert_to_Integer(name, val)
+      val.to_i
+    end
+
+    def convert_to_String(name, val)
+      val.to_s
+    end
+
+    def convert_to_Time(name, val)
+      VersionOne.s_to_time(val, utc: !!(name.match(/utc$/i)))
+    end
+
+    def save_url
+      if @href
+        @href
+      else
+        "rest-1.v1/Data/#{@type}"
+      end
+    end
+
+    def change_xml
+      asset = XML::Node.new('Asset')
+
+      @changed_attributes.each_key do |a|
+        attr_def = meta[a]
+        child = nil
+        val = @attributes[a]
+
+        if attr_def.relation?
+          child = XML::Node.new('Relation')
+          case
+            when val.nil?
+            when attr_def.multivalue?
+              val.added.each do |v|
+                v = v.to_xml
+                v.attributes['act'] = 'add'
+                child << v
+              end
+              val.removed.each do |v|
+                v = v.to_xml
+                v.attributes['act'] = 'remove'
+                child << v
+              end
+            else
+              child << val.to_xml
+          end
+        else
+          child = XML::Node.new('Attribute')
+          case
+            when val.nil?
+              #noop
+            when attr_def.multivalue?
+              val.each do |v|
+                child << XML::Node.new('Value', v.to_s)
+              end
+            else
+              child.content = val.to_s
+          end
+        end
+
+        child.attributes['name'] = a
+        child.attributes['act'] = 'set'  unless (attr_def.relation? && attr_def.multivalue?)
+        asset << child
+      end
+
+      asset
+    end
+
+    # Remove the moment from the href if any
+    def normalized_href(s)
+      if s =~ /(\/.+\/[A-Z][a-zA-Z]+\/\d{4,6})(\/\d{4,6})?$/
+        $1
+      else
+        raise ArgumentError, "Invalid href '#{s}'"
+      end
+    end
+
+    # Remove the moment from the ID if any
+    def normalized_id(s)
+      if s =~ /^([A-Z][a-zA-Z]+:\d{4,6})(:\d{4,6})?$/
+        $1
+      else
+        raise ArgumentError, "Invalid ID '#{s}'"
+      end
+    end
+
+  end
+
+  #
+  # ASSET TYPE CLASSES
+  #
+  class Scope       < Asset; end
+  class Expression  < Asset; end
+  class Story       < Asset; end
+  class Defect      < Asset; end
+  class Conversation < Asset; end
+  class Task        < Asset; end
+  class Test        < Asset; end
+end