sds-rest 0.1.1

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-10-23
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,30 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+config/hoe.rb
+config/requirements.rb
+lib/sds-activeresource.rb
+lib/sds-rest.rb
+lib/sds-rest/version.rb
+script/console
+script/destroy
+script/generate
+script/txt2html
+setup.rb
+spec/authority_spec.rb
+spec/blob_spec.rb
+spec/container_spec.rb
+spec/entity_spec.rb
+spec/sdsactiveresource_spec.rb
+spec/sdsconnection_spec.rb
+spec/spec_helper.rb
+tasks/deployment.rake
+tasks/environment.rake
+tasks/website.rake
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.html.erb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on sds-rest, see http://sdsrest.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,62 @@
+= sds-rest
+
+* FIX (url)
+
+== DESCRIPTION:
+
+A ruby library for accessing the SDS REST interface.
+
+== FEATURES/PROBLEMS:
+
+SDSRest Library
+Active Resource Adapter
+
+== SYNOPSIS:
+
+
+
+== REQUIREMENTS:
+
+gem install uuidtools
+
+== INSTALL:
+
+If you are new to ruby follow these instructions:
+
+1) Install Ruby with the One-Click Installer - http://rubyforge.org/frs/download.php/29263/ruby186-26.exe
+2) Install Ruby Gems - http://rubyforge.org/frs/download.php/38647/rubygems-1.2.0.zip
+3) Install Rails - cmd line => gem install rails --include-dependencies
+4) Install UUIDTools - cmd line => gem install uuidtools
+
+== LICENSE:
+
+Copyright (c) 2008 Microsoft
+
+This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.
+1. Definitions
+
+The terms “reproduce,” “reproduction,” “derivative works,” and “distribution” have the same meaning here as under U.S. copyright law.
+
+A “contribution” is the original software, or any additions or changes to the software.
+
+A “contributor” is any person that distributes its contribution under this license.
+
+“Licensed patents” are a contributor’s patent claims that read directly on its contribution.
+2. Grant of Rights
+
+(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+
+(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.
+3. Conditions and Limitations
+
+(A) No Trademark License- This license does not grant you rights to use any contributors’ name, logo, or trademarks.
+
+(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically.
+
+(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.
+
+(D) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license.
+
+(E) The software is licensed “as-is.” You bear the risk of using it. The contributors give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement.
+
+See FAQ.html for answers to frequently asked questions about this license.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'config/requirements'
+require 'config/hoe' # setup Hoe + all gem configuration
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }

data/config/hoe.rb

@@ -0,0 +1,77 @@
+require 'sds-rest/version'
+
+AUTHOR = 'James Avery'  # can also be an array of Authors
+EMAIL = "javery@infozerk.com"
+DESCRIPTION = "description of gem"
+GEM_NAME = 'sds-rest' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'sdsrest' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+#  ['activesupport', '>= 1.3.1']
+]    # An array of rubygem dependencies [name, version]
+EXTRA_DEV_DEPENDENCIES = [
+#  ['rspec', '>= 1.1.5']
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = SDSRest::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'sds-rest documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description    = DESCRIPTION
+  p.summary        = DESCRIPTION
+  p.url            = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs     = ["spec/**/*_spec.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes        = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.extra_deps     = EXTRA_DEPENDENCIES
+  p.extra_dev_deps = EXTRA_DEV_DEPENDENCIES
+
+    p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/sds-activeresource.rb

@@ -0,0 +1,183 @@
+require 'rubygems'
+require 'activesupport'
+require 'activeresource'
+require 'rexml/document'
+require 'uri'
+require 'sds-rest'
+
+module SDSActiveResource
+  
+  class Base < ActiveResource::Base
+
+    def self.connection(refresh = false)
+        @connection = SDSConnection.new(super.site, super.format) if refresh || @connection.nil?
+        @connection.user = user
+        @connection.password = password
+        @connection
+    end
+    
+    #we don't want to create XML, we want to pass the attributes directly to the SDS service where the XML can be created
+    def to_xml(options={})
+      newattributes = {}
+      newattributes.merge! attributes
+      newattributes["entityname"] = self.class.element_name
+      newattributes
+    end
+
+    def self.query(query)
+      instantiate_collection(@connection.query(collection_path(), query))
+    end
+  end
+  
+  class SDSConnection < ActiveResource::Connection
+    
+    def service
+      @service = SDSRest::Service.new :username => user, :password => password, :authority => get_authority(site), :url => get_url(site) if @service.nil?
+      @service
+    end
+    
+    def query(path, query)
+      container = get_container(path)
+      query.gsub!(/AND/i, "%26%26 ")
+      response = service.query(container, query)
+      entity = REXML::Document.new(response.body)
+      entities = []
+      
+      entity.root().elements.each { |element| 
+        options = {}      
+        element.elements.each { |element2|       
+          options[element2.name] = parse_value(element.attributes["xsi:type"], element2.text)
+        }
+        entities.push(options)
+        }
+
+      entities
+    end
+    
+    def post(path, body = '', headers = {})
+      container = get_container(path)
+      response = service.create_entity(container, body["entityname"], body["Id"], body)
+      response['location'] = "test/" + body["Id"].to_s
+      response
+    end   
+    
+    def delete(path, body = '', headers = {})
+      container = get_container(path)
+      id = get_id(path)
+      service.delete_entity(container, id)
+    end    
+        
+    def put(path, body = '', headers = {})
+      container = get_container(path)  
+      response = service.update_entity(container, body["name"], body["Id"], nil, body)
+      response['location'] = "test/" + body["Id"].to_s
+      response
+    end
+        
+    def get(path, headers = {})
+      container = get_container(path)
+      entityname = get_entity(path)
+      id = get_id(path)
+      if(id.nil?)
+        query = 'from e in entities where e.Kind == "' + entityname.singularize + '" select e'
+        response = service.query(container, query)
+        entity = REXML::Document.new(response.body)
+        entities = []
+        
+        entity.root().elements.each { |element| 
+          options = {}      
+          element.elements.each { |element2|       
+            options[element2.name] = parse_value(element2.attributes["xsi:type"], element2.text)
+          }
+          entities.push(options)
+          }
+
+        entities        
+      else
+        
+      response = service.get_entity(container, id)
+          
+      entity = REXML::Document.new(response.body)
+     
+      options = {}      
+      entity.root().elements.each { |element|      
+          options[element.name] = parse_value(element.attributes["xsi:type"], element.text)
+      }
+      options['id'] = id
+      options
+      
+      end
+    end
+        
+    def get_authority(path)
+     splitpath = URI::split(path.to_s)
+     splitpath[2].split('.')[0]
+    end
+    
+    def get_url(path)
+      splitpath = URI::split(path.to_s)
+      host = splitpath[2]
+      host[get_authority(path) + "."] = ""
+      host
+    end
+    
+    def get_params(path)
+      puts path
+      if(path.include? "?")
+        params = path.split('?')[1]  
+        params || ""
+      end
+    end
+      
+    def get_container(path)
+      container = path.to_s.split('/')[1]
+      
+      if(container.nil?)
+        raise "no container found"
+      end
+      container
+    end
+    
+    def get_entity(path)
+      path.delete! '.xml'
+      entity = path.split('/')[2]
+      
+      if(entity.include? "?")
+        entity = entity.split('?')[0]  
+      end
+      
+      if(entity.nil?)
+        raise "no entity found"
+      end
+      entity
+    end
+    
+    def parse_value(type, value)
+      if(type == "x:decimal")
+        if(value.include?("."))
+          Float(value)
+        else
+          Integer(value)
+        end
+      elsif(type == "x:boolean")
+        Boolean(value)
+      elsif(type == "x:dateTime")
+        DateTime.parse(value)
+      else
+        value
+      end    
+    end
+    
+    def get_id(path)
+      path.delete! '.xml'
+      path.to_s.split('/')[3]
+    end
+    
+    def Boolean(string)
+        return true if string == true || string =~ /^true$/i
+        return false if string == false || string.nil? || string =~ /^false$/i
+        raise ArgumentError.new("invalid value for Boolean: \"#{string}\"")
+    end
+  
+  end
+end

data/lib/sds-rest.rb

@@ -0,0 +1,255 @@
+require 'net/http'
+require 'rexml/document'
+require 'yaml'
+
+module SDSRest
+  
+   ssds_config = "#{RAILS_ROOT}/config/ssds.yml"
+
+   if File.exist?(ssds_config)
+     SSDSCONFIG = YAML.load_file(ssds_config)[RAILS_ENV] 
+     ENV['username'] = SSDSCONFIG['username']
+     ENV['password'] = SSDSCONFIG['password']
+     ENV['url'] = SSDSCONFIG['url']
+     ENV['authority'] = SSDSCONFIG['authority']
+   end
+  
+  
+  class Service
+   
+   def initialize(options={})
+     @username = options[:username] || ENV['username']
+     @password = options[:password] || ENV['password']
+     @url = options[:url] || ENV['url']
+     @authority = options[:authority] || ENV['authority']
+   end
+   
+   def authority=(value)
+     @authority = value
+   end
+   
+   def create_authority(authority)   
+     request_xml = REXML::Document.new()
+     request_xml.add_element('s:Authority')
+     request_xml.root().add_attribute('xmlns:s', 'http://schemas.microsoft.com/sitka/2008/03/')
+     request_xml.root().add_element("s:Id")
+     request_xml.root().elements["s:Id"].text = authority
+     req = create_post(request_xml)
+     execute_request req
+   end
+   
+   def get_authority(authority)
+     @authority = authority
+     get(get_request_url)
+   end
+   
+   def create_container(container)
+     request_xml = REXML::Document.new()
+     request_xml.add_element('s:Container')
+     request_xml.root().add_attribute('xmlns:s', 'http://schemas.microsoft.com/sitka/2008/03/')
+     request_xml.root().add_element("s:Id")
+     request_xml.root().elements["s:Id"].text = container
+     req = create_post(request_xml)
+     execute_request req     
+   end
+   
+   def delete_container(container)
+     delete(get_request_url(container))
+   end
+   
+   def get_container(container)
+     get(get_request_url(container))
+   end
+   
+   def create_entity(container, entity, id, options={})
+     request_xml = REXML::Document.new()
+     request_xml.add_element(entity)
+     request_xml.root().add_attribute('xmlns:s', 'http://schemas.microsoft.com/sitka/2008/03/')
+     request_xml.root().add_attribute('xmlns:x', 'http://www.w3.org/2001/XMLSchema')
+     request_xml.root().add_attribute('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance' ) 
+     request_xml.root().add_element('s:Id')
+     request_xml.root().elements['s:Id'].text = id
+     
+     options.each { |key, value|
+       request_xml.root().add_element(key.to_s)
+       request_xml.root().elements[key.to_s].add_attribute('xsi:type', infer_type(value))
+       request_xml.root().elements[key.to_s].text = value
+     }
+     req = create_post(request_xml, container)
+     execute_request req
+   end
+
+   # passing in a version number means that SSDS will only delete the entity if the version
+   # number equals the current version number. 
+   def delete_entity(container, id, version = nil)
+     url = get_request_url(container, id)
+     delete(url, version)
+   end
+   
+   # passing in a version number means that SSDS will only delete the entity if the version
+   # number equals the current version number. 
+   def get_entity(container, id, version = nil)
+     url = get_request_url(container, id)
+     get(url, version)
+   end
+   
+   # passing in a version number means that SSDS will only delete the entity if the version
+   # number equals the current version number. 
+   def update_entity(container, entity, id, version = nil, options={})
+     results = get_entity container, id
+     entity = REXML::Document.new(results.body)
+     
+     options.each { |key, value|
+        if(entity.root().elements[key.to_s].nil?)
+          entity.root().add_element(key.to_s)
+          entity.root().elements[key.to_s].add_attribute('xsi:type', infer_type(value))
+        end
+        
+        entity.root().elements[key.to_s].text = value
+      }
+     url = get_request_url(container, id)
+     put(url, entity, version)
+   end
+   
+   #sends a query using the SSDS query syntax
+   # 
+   # examples:
+   #   from c in entities select c - selects all entities
+   #   from c in entities where c.Kind = 'Car' select c - select all entities of type 'Car'
+   #   from c in entities where c["Make"] = 'Toyota' - select all entities with property Make that equals Toyota
+   def query(container, query)
+     url = get_request_url(container) + "?q=" + URI.escape(query)
+     get(url)
+   end
+   
+   def create_blob(container, blob, id)
+     url = get_request_url(container)
+     req = Net::HTTP::Post.new(url)       
+     req.content_type = 'text'
+     req.content_length = blob.to_s.size.to_s
+     req['slug'] = id
+     req.basic_auth @username, @password
+     req.body = blob.to_s
+     execute_request(req)     
+   end
+   
+   def update_blob(container, blob, id)
+      url = get_request_url(container, id)
+      req = Net::HTTP::Put.new(url)       
+      req.content_type = 'text'
+      req.content_length = blob.to_s.size.to_s
+      req['slug'] = id
+      req.basic_auth @username, @password
+      req.body = blob.to_s
+      execute_request(req)     
+    end
+    
+    def delete_blob(container, id)
+        delete(get_request_url(container, id))   
+      end
+    
+    def get_blob(container, id)
+      get(get_request_url(container, id))
+    end
+    
+    def infer_type(value)
+      if(value.is_a?(Integer) || value.is_a?(Float))
+        'x:decimal'
+      elsif(value.is_a?(true.class) || value.is_a?(false.class))
+        'x:boolean'
+      elsif(value.is_a?(DateTime))
+        'x:dateTime'
+      else
+        'x:string' 
+      end
+    end
+   
+   
+    private
+      #execute a request
+      def execute_request(req)
+        Net::HTTP.new(get_url).start {|http|
+          response = http.request(req)
+        }
+      end  
+      
+      #gets the base url to send the request to
+      def get_url
+        url = @url
+        if(!@authority.nil?)
+          url = @authority + "." + @url
+        end
+
+        url
+      end
+      
+      #sends an HTTP delete request to SSDS
+      def delete(url, version = nil)
+        req = Net::HTTP::Delete.new(url)
+        req.content_type = 'application/x-ssds+xml'
+        
+        if(!version.nil?)
+          req['if-match'] = version;
+        end
+        
+        req.basic_auth @username, @password
+        execute_request(req)
+      end
+      
+      #sends an HTTP get request to SSDS
+      def get(url, version = nil)
+        req = Net::HTTP::Get.new(url)
+        req.content_type = 'application/x-ssds+xml'
+        
+        if(!version.nil?)
+          req['if-none-match'] = version;
+        end
+        
+        req.basic_auth @username, @password
+        execute_request(req)
+      end
+      
+      #sends an HTTP put request to SSDS
+      def put(url, xml, version = nil)
+        req = Net::HTTP::Put.new(url)
+        req.content_type = 'application/x-ssds+xml'
+        
+        if(!version.nil?)
+          req['if-match'] = version;
+        end
+        
+        req.content_length = xml.to_s.size.to_s
+        req.basic_auth @username, @password
+        req.body = xml.to_s
+        execute_request(req)
+      end
+
+      #determines the correct URL to use for a SSDS request
+      def get_request_url(container = nil, id = nil)
+        url = '/v1/'
+        
+        #add the container to the url
+        if(!container.nil?)
+          url = url + container
+        end
+        
+        #add the id to the end of the url if it is present
+        if(!id.nil?)
+          url = url + "/" + id.to_s
+        end
+        
+        url
+      end
+    
+      def create_post(xml, container=nil)
+        url = get_request_url(container)
+        req = Net::HTTP::Post.new(url)       
+        req.content_type = 'application/x-ssds+xml'
+        req.content_length = xml.to_s.size.to_s
+        req.basic_auth @username, @password
+        req.body = xml.to_s
+        req
+      end
+      
+  end
+end