waz-storage 0.5.81 → 1.0.0

data/lib/waz-storage.rb

@@ -1,3 +1,5 @@
+require 'net/http'
+
 $:.unshift(File.dirname(__FILE__))
 require 'waz/storage/base'
 require 'waz/storage/core_service'
@@ -14,4 +16,16 @@ unless String.method_defined? :start_with?
       self[0, prefix.length] == prefix
     end
   end
+end
+
+# The Merge method is not defined in the RFC 2616 
+# and it's required to Merge entities in Windows Azure
+module Net
+  class HTTP < Protocol
+    class Merge < HTTPRequest
+      METHOD = 'MERGE'
+      REQUEST_HAS_BODY  = true
+      RESPONSE_HAS_BODY = false
+    end
+  end
 end

data/lib/waz-tables.rb

@@ -0,0 +1,20 @@
+require 'time'
+require 'cgi'
+require 'base64'
+require 'rexml/document'
+require 'rexml/xpath'
+require 'restclient'
+require 'hmac-sha2'
+
+$:.unshift(File.dirname(__FILE__))
+require 'waz-storage'
+require 'waz/tables/exceptions'
+require 'waz/tables/table'
+require 'waz/tables/table_array'
+require 'waz/tables/service'
+require 'waz/tables/edm_type_helper'
+
+# extendes the Symbol class to assign a type to an entity field
+class Symbol
+  attr_accessor :edm_type
+end

data/lib/waz/blobs/blob_object.rb

@@ -31,7 +31,7 @@ module WAZ
         # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
         def service_instance
           options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "blob")
-          (@service_instances ||= {})[:account_name] ||= Service.new(options)
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
         end
       end
       

data/lib/waz/blobs/container.rb

@@ -66,7 +66,7 @@ module WAZ
         # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
         def service_instance
           options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "blob")
-          (@service_instances ||= {})[:account_name] ||= Service.new(options)
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
         end        
       end
       

data/lib/waz/queues/message.rb

@@ -29,7 +29,7 @@ module WAZ
         # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
         def service_instance
           options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "queue")
-          (@service_instances ||= {})[:account_name] ||= Service.new(options)
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
         end
       end
       

data/lib/waz/queues/queue.rb

@@ -76,7 +76,7 @@ module WAZ
         # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
         def service_instance
           options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "queue")
-          (@service_instances ||= {})[:account_name] ||= Service.new(options)
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
         end
       end
       

data/lib/waz/storage/core_service.rb

@@ -3,15 +3,17 @@ module WAZ
     # This module is imported by the specific services that use Shared Key authentication profile. On the current implementation
     # this module is imported from WAZ::Queues::Service and WAZ::Blobs::Service.
     module SharedKeyCoreService
-      attr_accessor :account_name, :access_key, :use_ssl, :base_url, :type_of_service
+      attr_accessor :account_name, :access_key, :use_ssl, :base_url, :type_of_service, :use_devenv
       
       # Creates an instance of the implementor service (internally used by the API).
       def initialize(options = {})
         self.account_name = options[:account_name]
         self.access_key = options[:access_key]
+        self.type_of_service = options[:type_of_service]        
         self.use_ssl = options[:use_ssl] or false
-        self.type_of_service = options[:type_of_service]
-        self.base_url = "#{options[:type_of_service] or "blobs"}.#{options[:base_url] or "core.windows.net"}"
+        self.use_devenv = !!options[:use_devenv]
+        self.base_url = "#{options[:type_of_service] or "blobs"}.#{options[:base_url] or "core.windows.net"}" unless self.use_devenv
+        self.base_url ||= (options[:base_url] or "core.windows.net") 
       end
       
       # Generates a request based on Adam Wiggings' rest-client, including all the required headers
@@ -32,7 +34,8 @@ module WAZ
       def generate_request_uri(path = nil, options = {})
         protocol = use_ssl ? "https" : "http"
         query_params = options.keys.sort{ |a, b| a.to_s <=> b.to_s}.map{ |k| "#{k.to_s.gsub(/_/, '')}=#{CGI.escape(options[k].to_s)}"}.join("&") unless options.nil? or options.empty?
-        uri = "#{protocol}://#{account_name}.#{base_url}#{(path or "").start_with?("/") ? "" : "/"}#{(path or "")}"
+        uri = "#{protocol}://#{base_url}/#{account_name}#{(path or "").start_with?("/") ? "" : "/"}#{(path or "")}" if !self.use_devenv.nil? and self.use_devenv
+        uri ||= "#{protocol}://#{account_name}.#{base_url}#{(path or "").start_with?("/") ? "" : "/"}#{(path or "")}" 
         uri << "?#{query_params}" if query_params
         return uri
       end
@@ -101,7 +104,7 @@ module WAZ
       # Generates a Windows Azure Storage call, it internally calls url generation method
       # and the request generation message.
       def execute(verb, path, query = {}, headers = {}, payload = nil)
-        url = generate_request_uri(path, query)
+        url = generate_request_uri(path, query)        
         request = generate_request(verb, url, headers, payload)
         request.execute()
       end

data/lib/waz/storage/validation_rules.rb

@@ -11,6 +11,15 @@ module WAZ
         def valid_name?(name)
           name =~ /^[a-z0-9][a-z0-9\-]{1,}[^-]$/ && name.length < 64
         end
+
+        # Validates that the Table name given matches with the requirements of Windows Azure. 
+        #
+        # -Table names must start with at least one lower / upper character.
+        # -Table names can have character or any digit starting from the second position.
+        # -Table names must be from 3 through 63 characters long.
+        def valid_table_name?(name)
+          name =~ /^([a-z]|[A-Z]){1}([a-z]|[A-Z]|\d){2,62}$/
+        end
       end
     end
   end

data/lib/waz/storage/version.rb

@@ -1,9 +1,9 @@
 module WAZ
   module Storage
     module VERSION #:nodoc:
-      MAJOR    = '0'
-      MINOR    = '5'
-      TINY     = '81' 
+      MAJOR    = '1'
+      MINOR    = '0'
+      TINY     = '0' 
     end
     
     Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY].compact * '.'

data/lib/waz/tables/edm_type_helper.rb

@@ -0,0 +1,45 @@
+module WAZ
+  module Tables
+    class EdmTypeHelper
+      class << self
+        def parse_from(item)
+          return nil if !item.attributes['m:null'].nil? and item.attributes['m:null'] == 'true'
+          case item.attributes['m:type']
+            when 'Edm.Int16', 'Edm.Int32', 'Edm.Int64'
+              item.text.to_i
+            when 'Edm.Single', 'Edm.Double'
+              item.text.to_f
+            when 'Edm.Boolean'
+              item.text == 'true'
+            when 'Edm.DateTime'
+              Time.parse(item.text)
+            when 'Edm.Binary'
+              StringIO.new(Base64.decode64(item.text))
+            else
+              item.text
+          end
+        end
+      
+        def parse_to(item)
+          case item.class.name
+            when 'String'
+              [item, 'Edm.String']
+            when 'Fixnum'
+              [item, 'Edm.Int32']
+            when 'Float'
+              [item, 'Edm.Double']
+            when 'TrueClass', 'FalseClass'          
+              [item, 'Edm.Boolean']
+            when 'Time'
+              [item.iso8601, 'Edm.DateTime']
+            when 'File', 'StringIO'
+              item.pos = 0
+              [Base64.encode64(item.read), 'Edm.Binary']
+            else
+              [item, 'Edm.String']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/waz/tables/exceptions.rb

@@ -0,0 +1,45 @@
+module WAZ
+  module Tables
+    # This exception is raised while trying to create table that already exists.
+    class TableAlreadyExists < WAZ::Storage::StorageException
+      def initialize(name)
+        super("The table #{name} already exists on your account.")
+      end
+    end
+
+    # This exception is raised while trying to delete an unexisting table.    
+    class TableDoesNotExist < WAZ::Storage::StorageException
+      def initialize(name)
+        super("The specified table #{name} does not exist.")
+      end
+    end
+    
+    # This exception is raised when an invalid table name is provided.
+    class InvalidTableName < WAZ::Storage::StorageException
+      def initialize(name)
+        super("The table name #{name} is invalid, it must start with at least one lower/upper characted, must be from 3 through 63 characters long and can have character or any digit starting from the second position")
+      end
+    end
+    
+    # This exception is raised when provided more than the 252 properties allowed by the Rest API.
+    class TooManyProperties < WAZ::Storage::StorageException
+      def initialize(total)
+        super("The entity contains more properties than allowed (252). The entity has #{total} properties.")
+      end
+    end
+
+    # This exception is raised when the specified entity already exists.
+    class EntityAlreadyExists < WAZ::Storage::StorageException
+      def initialize(row_key)
+        super("The specified entity already exists. RowKey: #{row_key}")
+      end
+    end
+    
+    # This exception is raised while trying to delete an unexisting entity.    
+    class EntityDoesNotExist < WAZ::Storage::StorageException
+      def initialize(key)
+        super("The specified entity with #{key} does not exist.")
+      end
+    end
+  end
+end

data/lib/waz/tables/service.rb

@@ -0,0 +1,178 @@
+module WAZ
+  module Tables
+    # This is internally used by the waz-tables part of the gem and it exposes the Windows Azure Blob API REST methods 
+    # implementation. You can use this class to perform an specific operation that isn't provided by the current API.
+    class Service
+      include WAZ::Storage::SharedKeyCoreService
+      
+      DATASERVICES_NAMESPACE = "http://schemas.microsoft.com/ado/2007/08/dataservices"      
+      DATASERVICES_METADATA_NAMESPACE = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
+      
+      # Creates a table on the current Windows Azure Storage account.
+      def create_table(table_name)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+
+        payload = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>" \
+                  "<entry xmlns:d=\"#{DATASERVICES_NAMESPACE}\" xmlns:m=\"#{DATASERVICES_METADATA_NAMESPACE}\" xmlns=\"http://www.w3.org/2005/Atom\">" \
+                  "<title /><updated>#{Time.now.utc.iso8601}</updated><author><name/></author><id/>" \
+                  "<content type=\"application/xml\"><m:properties><d:TableName>#{table_name}</d:TableName></m:properties></content></entry>"
+
+        begin
+          execute :post, 'Tables', {}, default_headers, payload
+          return {:name => table_name, :url => "#{self.base_url}/Tables('#{table_name}"}
+        rescue RestClient::RequestFailed
+          raise WAZ::Tables::TableAlreadyExists, table_name if $!.http_code == 409
+        end
+      end
+      
+      # Delete a table on the current Windows Azure Storage account.
+      def delete_table(table_name)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+        begin
+          execute :delete, "Tables('#{table_name}')", {}, default_headers
+        rescue RestClient::ResourceNotFound
+          raise WAZ::Tables::TableDoesNotExist, table_name if $!.http_code == 404
+        end
+      end
+      
+      # Lists all existing tables on the current storage account.
+      # remove Content-Type if it's not working
+      def list_tables(next_table_name = nil)
+        query = { 'NextTableName' => next_table_name } unless next_table_name.nil?
+        content = execute :get, "Tables", query ||= {}, default_headers
+
+        doc = REXML::Document.new(content)
+        tables = REXML::XPath.each(doc, '/feed/entry').map do |item|
+            { :name => REXML::XPath.first(item.elements['content'], "m:properties/d:TableName", {"m" => DATASERVICES_METADATA_NAMESPACE, "d" => DATASERVICES_NAMESPACE}).text,
+              :url => REXML::XPath.first(item, "id").text }
+        end
+        
+        return tables, content.headers[:x_ms_continuation_nexttablename]
+      end
+      
+      # Retrieves an existing table on the current storage account.
+      # remove Content-Type if it's not working
+      def get_table(table_name)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)        
+        
+        begin
+          content = execute :get, "Tables('#{table_name}')", {}, default_headers
+          doc = REXML::Document.new(content)
+          item = REXML::XPath.first(doc, "entry")
+          return {  :name => REXML::XPath.first(item.elements['content'], "m:properties/d:TableName", {"m" => DATASERVICES_METADATA_NAMESPACE, "d" => DATASERVICES_NAMESPACE}).text,
+                    :url => REXML::XPath.first(item, "id").text }
+        rescue RestClient::ResourceNotFound
+          raise WAZ::Tables::TableDoesNotExist, table_name if $!.http_code == 404
+        end        
+      end
+             
+      # Insert a new entity on the provided table for the current storage account
+      # TODO: catch all api errors as described on Table Service Error Codes on MSDN (http://msdn.microsoft.com/en-us/library/dd179438.aspx)
+      def insert_entity(table_name, entity)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+        raise WAZ::Tables::TooManyProperties, entity.length if entity.length > 252 
+        
+        begin
+          response = execute(:post, table_name, {}, default_headers, generate_payload(table_name, entity))
+          return parse_response(response)          
+        rescue RestClient::RequestFailed          
+          raise WAZ::Tables::EntityAlreadyExists, entity[:row_key] if $!.http_code == 409 and $!.response.body.include?('EntityAlreadyExists')          
+        end     
+      end
+      
+      # Update an existing entity on the current storage account.
+      # TODO: handle specific errors
+      def update_entity(table_name, entity)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+        response = execute(:put, "#{table_name}(PartitionKey='#{entity[:partition_key]}',RowKey='#{entity[:row_key]}')", {}, default_headers.merge({'If-Match' => '*'}) , generate_payload(table_name, entity))
+        return parse_response(response)
+      end
+      
+      # Merge an existing entity on the current storage account.
+      # The Merge Entity operation updates an existing entity by updating the entity's properties. 
+      # This operation does not replace the existing entity, as the Update Entity operation does
+      # TODO: handle specific errors
+      def merge_entity(table_name, entity)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+        response = execute(:merge, "#{table_name}(PartitionKey='#{entity[:partition_key]}',RowKey='#{entity[:row_key]}')", {}, default_headers.merge({'If-Match' => '*'}), generate_payload(table_name, entity))
+        return parse_response(response)
+      end
+      
+      # Delete an existing entity in a table.
+      def delete_entity(table_name, partition_key, row_key)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+        
+        begin
+          execute :delete, "#{table_name}(PartitionKey='#{partition_key}',RowKey='#{row_key}')", {}, default_headers.merge({'If-Match' => '*'})
+        rescue RestClient::ResourceNotFound
+          raise WAZ::Tables::TableDoesNotExist, table_name if $!.http_code == 404 and $!.response.body.include?('TableNotFound')
+          raise WAZ::Tables::EntityDoesNotExist, "(PartitionKey='#{partition_key}',RowKey='#{row_key}')" if $!.http_code == 404
+        end
+      end
+      
+      # Retrieves an existing entity on the current storage account.
+      # TODO: handle specific errors
+      def get_entity(table_name, partition_key, row_key)
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+        response = execute(:get, "#{table_name}(PartitionKey='#{partition_key}',RowKey='#{row_key}')", {}, default_headers)
+        return parse_response(response)
+      end    
+      
+      # Retrieves a set of entities on the current storage account for a given query.
+      # When the :top => n is passed it returns only the first n rows that match with the query
+      # Optional parameters:
+      # * :headers a hash containing the request headers
+      # * :expression the filter query that will be executed against the table (see http://msdn.microsoft.com/en-us/library/dd179421.aspx for more information), 
+      # * :top limits the amount of fields for this query. 
+      # * :continuation_token the hash obtained when you perform a query that has more than 1000 records or exceeds the allowed timeout (see http://msdn.microsoft.com/en-us/library/dd135718.aspx)
+      def query(table_name, options = {})
+        raise WAZ::Tables::InvalidTableName, table_name unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+        query = {'$filter' => (options[:expression] or '') }
+        query.merge!({ '$top' => options[:top] }) unless options[:top].nil?
+        query.merge!(options[:continuation_token]) unless options[:continuation_token].nil?
+        response = execute :get, "#{table_name}()", query, default_headers
+        continuation_token = {'NextPartitionKey' => response.headers[:x_ms_continuation_nextpartitionkey], 'NextRowKey' => response.headers[:x_ms_continuation_nextrowkey]}
+        parse_response(response, continuation_token)
+      end
+
+      private 
+        def generate_payload(table_name, entity)
+          payload = "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>" \
+                     "<entry xmlns:d=\"#{DATASERVICES_NAMESPACE}\" xmlns:m=\"#{DATASERVICES_METADATA_NAMESPACE}\" xmlns=\"http://www.w3.org/2005/Atom\">" \
+                     "<id>#{generate_request_uri "#{table_name}"}(PartitionKey='#{entity[:partition_key]}',RowKey='#{entity[:row_key]}')</id>" \
+                     "<title /><updated>#{Time.now.utc.iso8601}</updated><author><name /></author><link rel=\"edit\" title=\"#{table_name}\" href=\"#{table_name}(PartitionKey='#{entity[:partition_key]}',RowKey='#{entity[:row_key]}')\" />" \
+                     "<content type=\"application/xml\"><m:properties>"
+
+          entity.sort_by { |k| k.to_s }.each do |k,v| 
+            value, type = EdmTypeHelper.parse_to(v)[0].to_s, EdmTypeHelper.parse_to(v)[1].to_s
+            payload << (!v.nil? ? "<d:#{k.to_s} m:type=\"#{k.edm_type || type}\">#{value}</d:#{k.to_s}>" : "<d:#{k.to_s} m:type=\"#{k.edm_type || type}\" m:null=\"true\" />") unless k.eql?(:partition_key) or k.eql?(:row_key) 
+          end  
+
+          payload << "<d:PartitionKey>#{entity[:partition_key]}</d:PartitionKey>" \
+                     "<d:RowKey>#{entity[:row_key]}</d:RowKey>" \
+                     "</m:properties></content></entry>"
+          return payload
+        end
+        
+        def parse_response(response, continuation_token = nil)
+          doc = REXML::Document.new(response)
+          entities = REXML::XPath.each(doc, '//entry').map do |entry|
+            fields = REXML::XPath.each(entry.elements['content'], 'm:properties/*', {"m" => DATASERVICES_METADATA_NAMESPACE}).map do |f|
+              { f.name.gsub(/PartitionKey/i, 'partition_key').gsub(/RowKey/i, 'row_key').to_sym => EdmTypeHelper.parse_from(f) }
+            end
+            Hash[*fields.collect {|h| h.to_a}.flatten]
+          end
+          entities = WAZ::Tables::TableArray.new(entities)          
+          entities.continuation_token = continuation_token
+          return (REXML::XPath.first(doc, '/feed')) ? entities : entities.first
+        end
+        
+        def default_headers
+          { 'Date' => Time.new.httpdate, 
+            'Content-Type' => 'application/atom+xml', 
+            'DataServiceVersion' => '1.0;NetFx', 
+            'MaxDataServiceVersion' => '1.0;NetFx' }
+        end
+    end
+  end
+end

data/lib/waz/tables/table.rb

@@ -0,0 +1,75 @@
+module WAZ
+  module Tables
+    # This class represents a Table on Windows Azure Tables API. These are the methods implemented from Microsoft's API description 
+    # available on MSDN at http://msdn.microsoft.com/en-us/library/dd179423.aspx
+    #
+    #	# list available tables
+    #	tables = WAZ::Tables::Table.list
+    #
+    #	# list more tables
+    #	WAZ::Tables::Table.list(tables.continuation_token)
+    #
+  	# # get a specific table
+  	# my_table = WAZ::Tables::Table.find('my-table')
+  	#    
+    #	# delete table
+    #	my_table.destroy!
+    #
+    #	# create a new table
+    #	WAZ::Tables::Table.create('new-table')
+    #
+    class Table
+      class << self
+        INVALID_TABLE_ERROR_MESSAGE = "must start with at least one lower/upper characted, can have character or any digit starting from the second position, must be from 3 through 63 characters long"
+        
+        # Finds a table by name. It will return nil if no table was found.
+        def find(table_name)
+          raise WAZ::Storage::InvalidParameterValue, {:name => table_name, :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+          begin 
+            WAZ::Tables::Table.new(service_instance.get_table(table_name))
+          rescue WAZ::Tables::TableDoesNotExist
+            return nil
+          end
+        end
+                
+        # Returns an array of the existing tables (WAZ::Tables::Table) on the current 
+        # Windows Azure Storage account.
+        def list(continuation_token = {})
+            table_list, next_table_name = service_instance.list_tables(continuation_token['NextTableName'])
+            tables = TableArray.new(table_list.map { |table| WAZ::Tables::Table.new({ :name => table[:name], :url => table[:url] }) })
+            tables.continuation_token = {'NextTableName' => next_table_name} unless next_table_name.nil?
+            return tables
+        end
+        
+        # Creates a table on the current account.
+        def create(table_name)
+          raise WAZ::Storage::InvalidParameterValue, {:name => table_name, :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(table_name)
+          WAZ::Tables::Table.new(service_instance.create_table(table_name))
+        end
+        
+        # This method is internally used by this class. It's the way we keep a single instance of the 
+        # service that wraps the calls the Windows Azure Tables API. It's initialized with the values
+        # from the default_connection on WAZ::Storage::Base initialized thru establish_connection!
+        def service_instance
+          options = WAZ::Storage::Base.default_connection.merge(:type_of_service => "table")
+          (@service_instances ||= {})[options[:account_name]] ||= Service.new(options)
+        end       
+      end
+
+      attr_accessor :name, :url
+
+      def initialize(options = {})
+        raise WAZ::Storage::InvalidOption, :name unless options.keys.include?(:name) and !options[:name].empty?
+        raise WAZ::Storage::InvalidOption, :url unless options.keys.include?(:url) and !options[:url].empty?        
+        raise WAZ::Storage::InvalidParameterValue, {:name => options[:name], :values => [INVALID_TABLE_ERROR_MESSAGE]} unless WAZ::Storage::ValidationRules.valid_table_name?(options[:name])        
+        self.name = options[:name]
+        self.url = options[:url]        
+      end
+      
+      # Removes the table from the current account.
+      def destroy!
+        self.class.service_instance.delete_table(self.name)
+      end
+    end
+  end
+end

data/lib/waz/tables/table_array.rb

@@ -0,0 +1,11 @@
+module WAZ
+  module Tables
+    class TableArray < Array
+      attr_accessor :continuation_token
+      
+      def initialize(array)
+        super(array)
+      end
+    end
+  end
+end

data/rakefile

@@ -5,10 +5,9 @@ require 'rake/gempackagetask'
 require 'rake/rdoctask'
 require 'lib/waz-storage'
 
-
 namespace :test do
   Spec::Rake::SpecTask.new('run_with_rcov') do |t|
-    t.spec_files = FileList['tests/waz/queues/*.rb', 'tests/waz/blobs/*.rb', 'tests/waz/storage/*.rb']
+    t.spec_files = FileList['tests/waz/queues/*.rb', 'tests/waz/blobs/*.rb', 'tests/waz/tables/*.rb', 'tests/waz/storage/*.rb']
     t.rcov = true
     t.rcov_opts = ['--text-report', '--exclude', "exclude.*/.gem,test,Library,#{ENV['GEM_HOME']}", '--sort', 'coverage' ]
     t.spec_opts = ['-cfn']
@@ -49,4 +48,4 @@ namespace :docs do
   	t.rdoc_files.include('README.rdoc')
   	t.rdoc_files.include('lib/**/*.rb')
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: waz-storage
 version: !ruby/object:Gem::Version 
-  version: 0.5.81
+  version: 1.0.0
 platform: ruby
 authors: 
 - Johnny G. Halife
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-03 00:00:00 -03:00
+date: 2010-02-04 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,9 +55,15 @@ files:
 - lib/waz/storage/exceptions.rb
 - lib/waz/storage/validation_rules.rb
 - lib/waz/storage/version.rb
+- lib/waz/tables/edm_type_helper.rb
+- lib/waz/tables/exceptions.rb
+- lib/waz/tables/service.rb
+- lib/waz/tables/table.rb
+- lib/waz/tables/table_array.rb
 - lib/waz-blobs.rb
 - lib/waz-queues.rb
 - lib/waz-storage.rb
+- lib/waz-tables.rb
 has_rdoc: true
 homepage: http://waz-storage.heroku.com
 licenses: []