raws 0.0.7

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Jun Kikuchi
+
+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 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.rdoc

@@ -0,0 +1,108 @@
+= RAWS
+
+RAWS is a Ruby library for Amazon Web Service (AWS).
+
+== SQS (Amazon Simple Queue Service)
+
+  require 'rubygems'
+  require 'raws'
+  
+  RAWS.aws_access_key_id = _AWS_ACCESS_KEY_ID_
+  RAWS.aws_secret_access_key = _AWS_SECRET_ACCESS_KEY_
+  
+  RAWS::SQS.create_queue('test_queue')
+  sleep 60
+  
+  RAWS::SQS['test_queue'].send('hello1')
+  RAWS::SQS['test_queue'].send('hello2')
+  RAWS::SQS['test_queue'].send('hello3')
+  
+  RAWS::SQS['test_queue'].receive(:limit => 10).each do |msg|
+    p msg.body
+    msg.delete
+  end
+  
+  RAWS::SQS['test_queue'].delete_queue
+
+== SDB (Amazon SimpleDB)
+
+プリミティブな使い方
+
+  require 'rubygems'
+  require 'raws'
+  
+  RAWS.aws_access_key_id = _AWS_ACCESS_KEY_ID_
+  RAWS.aws_secret_access_key = _AWS_SECRET_ACCESS_KEY_
+  
+  RAWS::SDB.create_domain('test_domain')
+  sleep 60
+  
+  RAWS::SDB['test_domain'].put('1', 'a' => '10')
+  RAWS::SDB['test_domain'].put('2', 'b' => '10')
+  RAWS::SDB['test_domain'].put('3', 'c' => '10')
+  
+  p RAWS::SDB['test_domain'].get('1')
+  p RAWS::SDB['test_domain'].get('2')
+  p RAWS::SDB['test_domain'].get('3')
+  
+  RAWS::SDB['test_domain'].all.each do |a|
+    key, data = a
+    p [key, data]
+  end
+
+  RAWS::SDB['test_domain'].all.filter('a = ?', 10).each do |a|
+    key, data = a
+    p [key, data]
+  end
+  
+  RAWS::SDB['test_domain'].delete('1')
+  RAWS::SDB['test_domain'].delete('2')
+  RAWS::SDB['test_domain'].delete('3')
+  
+  RAWS::SDB['test_domain'].delete_domain
+
+クラスとして使う場合
+
+  require 'rubygems'
+  require 'raws'
+  
+  RAWS.aws_access_key_id = _AWS_ACCESS_KEY_ID_
+  RAWS.aws_secret_access_key = _AWS_SECRET_ACCESS_KEY_
+  
+  class Foo
+    include RAWS::SDB::Model
+    self.domain_name = 'test_domain'
+
+    sdb_accessor 'a', 'b'
+  end
+  
+  Foo.create_domain
+  sleep 60
+  
+  foo1 = Foo.new('a' => '10', 'b' => '100', 'c' => ['1000a', '1000b'])
+  foo1.save
+  
+  foo2 = Foo.new
+  foo2['a'] = '20'
+  foo2['b'] = ['200a', '200b']
+  foo2['c'] = '2000'
+  foo2.save
+  
+  foo3 = Foo.new
+  foo3.a = ['30a', '30b']
+  foo3.b = '300'
+  foo3['c'] = '3000'
+  foo3.save
+  
+  Foo.all.each do |a|
+    p [a.a, a['b'], a['c']]
+  end
+  
+  Foo.all.filter('a = ?', '10').each do |a|
+    p [a.a, a.b, a['c']]
+    a.delete
+  end
+  
+  Foo.delete_domain
+
+== S3 (Amazon Simple Storage Service)

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+NAME = 'raws'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = NAME
+    s.platform = Gem::Platform::RUBY
+    s.summary = NAME
+    s.description = NAME
+    s.author = "Jun Kikuchi"
+    s.email = "kikuchi@bonnou.com"
+    s.homepage = "http://github.com/JunKikuchi/raws"
+    s.files = %w(
+      COPYING CHANGELOG README.rdoc Rakefile VERSION
+    ) + Dir.glob("{bin,doc,lib}/**/*")
+    s.require_path = "lib"
+    s.has_rdoc = true
+    s.add_dependency('pauldix-typhoeus', '>=0.1.2')
+    s.add_dependency('nokogiri', '>=1.3.3')
+    s.add_dependency('uuidtools', '>=2.0.0')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  #t.spec_opts = ['-c --format specdoc']
+  t.spec_opts = ['-c']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.7

data/lib/raws/s3/adapter.rb

@@ -0,0 +1,123 @@
+require 'digest/md5'
+
+class RAWS::S3::Adapter
+  module Adapter20060301
+    URI_PARAMS = {
+      :scheme => 'https',
+      :host   => 's3.amazonaws.com',
+      :path   => '/',
+      :query  => {}
+    }
+
+    def build_uri(params={})
+      "#{params[:scheme]}://#{
+        if params[:bucket]
+          "#{params[:bucket]}.#{params[:host]}"
+        else
+          params[:host]
+        end
+      }#{params[:path]}#{
+        if params[:query].empty?
+          ''
+        else
+          '?' << a[:query].map do |key, val|
+            val ? "#{RAWS.escape(key)}=#{RAWS.escape(val)}" : RAWS.escape(key)
+          end.sort.join(';')
+        end
+      }"
+    end
+
+    def sign(http_verb, content, type, date, path)
+      "#{RAWS.aws_access_key_id}:#{
+        [
+          ::OpenSSL::HMAC.digest(
+            ::OpenSSL::Digest::SHA1.new,
+            RAWS.aws_secret_access_key,
+            [
+              http_verb,
+              content ? Digest::MD5.hexdigest(content) : '',
+              type,
+              date,
+              path
+            ].join("\n")
+          )
+        ].pack('m').strip
+      }"
+    end
+
+    def fetch(http_verb, _uri={}, options={}, content=nil, type='')
+      date = Time.now.httpdate
+      uri = URI_PARAMS.merge(_uri)
+      r = RAWS.__send__(
+        http_verb.downcase.to_sym,
+        build_uri(uri),
+        :headers => {
+          'Date' => date,
+          'Authorization' => "AWS #{
+            sign(http_verb, content, type, date, uri[:path])
+          }"
+        }
+      )
+      data = RAWS.parse(Nokogiri::XML.parse(r.body), options)
+      if 200 <= r.code && r.code <= 299
+        data
+      else
+        raise RAWS::Error.new(r, data)
+      end
+    end
+
+    def get_service
+      fetch('GET', {}, :multiple => 'Bucket')
+    end
+
+    def put_bucket(bucket_name)
+      fetch('PUT', :path => "/#{bucket_name}")
+    end
+
+    def put_request_payment(bucket_name)
+      fetch(
+        'PUT',
+        {
+          :bucket => bucket_name,
+          :query  => {'requestPayment' => nil}
+        }
+      )
+    end
+
+    def get_bucket(bucket_name, params={})
+      fetch(
+        'GET',
+        {
+          :bucket => bucket_name,
+          :query  => params
+        }
+      )
+    end
+
+    def get_request_payment(bucket_name)
+      fetch(
+        'GET',
+        {
+          :bucket => bucket_name,
+          :query  => {'requestPayment' => nil}
+        }
+      )
+    end
+
+    def get_bucket_location(bucket_name)
+      fetch(
+        'GET',
+        {
+          :bucket => bucket_name,
+          :query  => {'location' => nil}
+        }
+      )
+    end
+
+    def delete_bucket(bucket_name)
+      fetch('DELETE', :path => "/#{bucket_name}")
+    end
+  end
+
+  extend Adapter20060301
+end

data/lib/raws/s3.rb

@@ -0,0 +1,21 @@
+class RAWS::S3
+  autoload :Adapter, 'raws/s3/adapter'
+
+  class << self
+    def create_bucket(bucket_name)
+    end
+
+    def delete_bucket(bucket_name)
+    end
+
+    def list
+      Adapter.get_service
+    end
+
+    def each(&block)
+    end
+
+    def [](bucket_name)
+    end
+  end
+end

data/lib/raws/sdb/adapter.rb

@@ -0,0 +1,139 @@
+class RAWS::SDB::Adapter
+  module Adapter20090415
+    URI = 'https://sdb.amazonaws.com/'
+    PARAMS = {'Version' => '2009-04-15'}
+    KEYWORDS = %w'or and not from where select like null is order by asc desc in between intersection limit every'
+    REXP_NAME = /^[a-zA-Z_$]/
+
+    def create_domain(domain_name)
+      params = {
+        'Action'     => 'CreateDomain',
+        'DomainName' => domain_name
+      }
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params))
+    end
+
+    def delete_domain(domain_name)
+      params = {
+        'Action'     => 'DeleteDomain',
+        'DomainName' => domain_name
+      }
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params))
+    end
+
+    def domain_metadata(domain_name)
+      params = {
+        'Action'     => 'DomainMetadata',
+        'DomainName' => domain_name
+      }
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params))
+    end
+
+    def list_domains(next_token=nil, max_num=nil, &block)
+      params = {'Action' => 'ListDomains'}
+      params['NextToken']          = next_token if next_token
+      params['MaxNumberOfDomains'] = max_num    if max_num
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params), :multiple => %w'DomainName')
+    end
+
+    def get_attributes(domain_name, item_name, *attrs)
+      params = {
+        'Action'     => 'GetAttributes',
+        'DomainName' => domain_name,
+        'ItemName'   => item_name
+      }
+
+      i = 0
+      attrs.each do |name|
+        params["AttributeName.#{i}"] = name
+        i += 1
+      end
+
+      RAWS.fetch(
+        'GET',
+        URI,
+        PARAMS.merge(params),
+        :multiple => %w'Attribute',
+        :unpack   => %w'Attribute'
+      )
+    end
+
+    def put_attributes(domain_name, item_name, attrs={}, *replaces)
+      params = {
+        'Action'     => 'PutAttributes',
+        'DomainName' => domain_name,
+        'ItemName'   => item_name
+      }
+      params.merge!(RAWS.pack_attrs(attrs, replaces))
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params))
+    end
+
+    def batch_put_attributes(domain_name, items={}, replaces={})
+      params = {
+        'Action'     => 'BatchPutAttributes',
+        'DomainName' => domain_name
+      }
+      
+      i = 0
+      items.each do |key, attrs|
+        params["Item.#{i}.ItemName"] = key
+        params.merge!(RAWS.pack_attrs(attrs, replaces[key], "Item.#{i}."))
+        i += 1
+      end
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params))
+    end
+
+    def delete_attributes(domain_name, item_name, attrs={})
+      params = {
+        'Action'     => 'DeleteAttributes',
+        'DomainName' => domain_name,
+        'ItemName'   => item_name
+      }
+      params.merge!(RAWS.pack_attrs(attrs))
+
+      RAWS.fetch('GET', URI, PARAMS.merge(params))
+    end
+
+    def quote(val)
+      if !REXP_NAME.match(val) || KEYWORDS.include?(val)
+        "'#{val}'"
+      else
+        val
+      end
+    end
+
+    def query_expr(expr, *params)
+      expr.gsub(/(\\)?(\?)/) do
+        if $1
+          "?"
+        else
+          "'#{params.shift.to_s.gsub(/(['])/, '\1\1')}'"
+        end
+      end
+    end
+
+    def select(expr, expr_params=[], next_token=nil)
+      params = {
+        'Action'           => 'Select',
+        'SelectExpression' => query_expr(expr, *expr_params)
+      }
+      params['NextToken'] = next_token if next_token
+
+      RAWS.fetch(
+        'GET',
+        URI,
+        PARAMS.merge(params),
+        :multiple => %w'Item Attribute',
+        :unpack   => %w'Attribute'
+      )
+    end
+  end
+
+  extend Adapter20090415
+end

data/lib/raws/sdb/model.rb

@@ -0,0 +1,121 @@
+require 'uuidtools'
+
+module RAWS::SDB::Model
+  class Select < RAWS::SDB::Select
+    def initialize(model)
+      super()
+      @model = model
+    end
+
+    def attr_filter(val)
+      @model.new(val.last, val.first)
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :domain_name
+
+    def create_domain
+      RAWS::SDB[domain_name].create_domain
+    end
+
+    def delete_domain
+      RAWS::SDB[domain_name].delete_domain
+    end
+
+    def select(&block)
+      Select.new(self).from(domain_name, &block)
+    end
+    alias :all :select
+
+    def find(id)
+      if attrs = RAWS::SDB[domain_name].get(id)
+        self.new(attrs, id)
+      end
+    end
+
+    def generate_id
+      UUIDTools::UUID.random_create
+    end
+
+    def sdb_reader(*names)
+      names.each do |name|
+        module_eval %Q{
+          def #{name}
+            self['#{name}']
+          end
+        }
+      end
+    end
+
+    def sdb_writer(*names)
+      names.each do |name|
+        module_eval %Q{
+          def #{name}=(val)
+            self['#{name}'] = val
+          end
+        }
+      end
+    end
+
+    def sdb_accessor(*names)
+      sdb_reader(*names)
+      sdb_writer(*names)
+    end
+  end
+  
+  module InstanceMethods
+    attr_reader :id, :values
+
+    def initialize(values={}, id=nil)
+      @id, @values = id, values
+      after_initialize
+    end
+
+    def [](key)
+      values[key]
+    end
+
+    def []=(key, val)
+      values[key] = val
+    end
+
+    def delete
+      before_delete
+      RAWS::SDB[self.class.domain_name].delete(id) if id
+      after_delete
+    end
+
+    def save
+      before_save
+      if id
+        before_update
+        RAWS::SDB[self.class.domain_name].put(id, values)
+        after_update
+      else
+        before_insert
+        @id = self.class.generate_id
+        RAWS::SDB[self.class.domain_name].put(id, values)
+        after_insert
+      end
+      after_save
+    end
+
+    def after_initialize; end
+    def before_delete; end
+    def after_delete; end
+    def before_save; end
+    def after_save; end
+    def before_update; end
+    def after_update; end
+    def before_insert; end
+    def after_insert; end
+  end
+
+  def self.included(mod)
+    mod.class_eval do
+      include InstanceMethods
+      extend ClassMethods
+    end
+  end
+end

data/lib/raws/sdb/select.rb

@@ -0,0 +1,78 @@
+class RAWS::SDB::Select
+  RESERVED_KEYWORD = %w'or and not from where select like null is order by asc desc in between intersection limit every'
+
+  def initialize
+    @output_list = '*'
+    @domain      = nil
+    @condition   = nil
+    @values      = nil
+    @sort        = nil
+    @limit       = nil
+  end
+
+  def attr_filter(val)
+    val
+  end
+
+  def each(&block)
+    RAWS::SDB.select(*to_sql) do |val|
+      block.call(attr_filter(val))
+    end
+  end
+  alias :fetch :each
+
+  def get
+    ret = nil
+
+    _limit = @limit
+    limit(1)
+    each do |val|
+      ret = val
+    end
+    @limit = _limit
+
+    ret
+  end
+
+  def columns(*val)
+    @output_list = val.join(',')
+    self
+  end
+
+  def from(val)
+    @domain = val
+    self
+  end
+
+  def where(condition, *values)
+    @condition = condition
+    @values    = values
+    self
+  end
+  alias :filter :where
+
+  def order(val)
+    @sort = val
+    self
+  end
+
+  def limit(val)
+    @limit = val
+    self
+  end
+
+  def to_sql
+    s = [
+      'select',
+      @output_list,
+      'from',
+      ::RAWS::SDB::Adapter.quote(@domain)
+    ]
+
+    s.push('where',    @condition) if @condition
+    s.push('order by', @sort     ) if @sort
+    s.push('limit',    @limit    ) if @limit
+
+    [s.join(' '), @values]
+  end
+end