aliyun-oss-rails4 0.7.0.1448446959

data/Rakefile

@@ -0,0 +1,334 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'rake/packagetask'
+require 'rubygems/package_task'
+
+require File.dirname(__FILE__) + '/lib/aliyun/oss'
+
+def library_root
+  File.dirname(__FILE__)
+end
+
+task :default => :test
+
+Rake::TestTask.new do |test|
+  test.pattern = 'test/*_test.rb'
+  test.verbose = true
+end
+
+namespace :doc do
+  Rake::RDocTask.new do |rdoc|  
+    rdoc.rdoc_dir = 'doc'  
+    rdoc.title    = "Aliyun::OSS -- Support for Aliyun OSS's REST api"  
+    rdoc.options << '--line-numbers' << '--inline-source'
+    rdoc.rdoc_files.include('README')
+    rdoc.rdoc_files.include('COPYING')
+    rdoc.rdoc_files.include('INSTALL')    
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+  
+  task :rdoc => 'doc:readme'
+  
+  task :refresh => :rerdoc do
+    system 'open doc/index.html'
+  end
+
+  task :readme do
+    require File.dirname(__FILE__) + '/support/rdoc/code_info'
+    RDoc::CodeInfo.parse('lib/**/*.rb')
+    
+    strip_comments = lambda {|comment| comment.gsub(/^# ?/, '')}
+    docs_for       = lambda do |location| 
+      info = RDoc::CodeInfo.for(location)
+      raise RuntimeError, "Couldn't find documentation for `#{location}'" unless info
+      strip_comments[info.comment]
+    end
+    
+    open('README', 'w') do |file|
+      file.write ERB.new(IO.read('README.erb')).result(binding)
+    end
+  end
+  
+  task :deploy => :rerdoc do
+    sh %(scp -r doc marcel@rubyforge.org:/var/www/gforge-projects/aliyun/)
+  end
+end
+
+namespace :dist do  
+  spec = Gem::Specification.new do |s|
+    s.name              = 'aliyun-oss-rails4'
+    s.version           = Gem::Version.new(Aliyun::OSS::Version)
+    s.summary           = "Client library for Aliyun's Open Storage Service's REST API"
+    s.description       = s.summary
+    s.email             = 'langyong135@gmail.com'
+    s.author            = 'mangege'
+    s.has_rdoc          = true
+    s.extra_rdoc_files  = %w(README COPYING INSTALL)
+    s.homepage          = 'https://github.com/TimLang/aliyun-oss-sdk-for-ruby'
+    s.files             = FileList['Rakefile', 'lib/**/*.rb', 'bin/*', 'support/**/*.rb']
+    s.executables       << 'oss'
+    s.test_files        = Dir['test/**/*']
+    
+    s.add_dependency 'xml-simple'
+    s.add_dependency 'builder'
+    s.add_dependency 'mime-types'
+    s.rdoc_options  = ['--title', "Aliyun::OSS -- Support for Aliyun OSS's REST api",
+                       '--main',  'README',
+                       '--line-numbers', '--inline-source']
+  end
+    
+  # Regenerate README before packaging
+  #task :package => 'doc:readme' #TODO 暂时不生成文档
+  task :package
+  Gem::PackageTask.new(spec) do |pkg|
+    pkg.need_tar_gz = true
+    pkg.package_files.include('{lib,script,test,support}/**/*')
+    pkg.package_files.include('README')
+    pkg.package_files.include('COPYING')
+    pkg.package_files.include('INSTALL')
+    pkg.package_files.include('Rakefile')
+  end
+  
+  desc 'Install with gems'
+  task :install => :repackage do
+    sh "gem i pkg/#{spec.name}-#{spec.version}.gem"
+  end
+  
+  desc 'Uninstall gem'
+  task :uninstall do
+    sh "gem uninstall #{spec.name} -x"
+  end
+  
+  desc 'Reinstall gem'
+  task :reinstall => [:uninstall, :install]
+  
+  task :confirm_release do
+    print "Releasing version #{spec.version}. Are you sure you want to proceed? [Yn] "
+    abort if STDIN.getc == ?n
+  end
+  
+  desc 'Tag release'
+  task :tag do
+    sh %(git tag -a '#{spec.version}-release' -m 'Tagging #{spec.version} release')
+    sh 'git push --tags'
+  end
+  
+  desc 'Update changelog to include a release marker'
+  task :add_release_marker_to_changelog do
+    changelog = IO.read('CHANGELOG')
+    changelog.sub!(/^head:/, "#{spec.version}:")
+    
+    open('CHANGELOG', 'w') do |file|
+      file.write "head:\n\n#{changelog}"
+    end
+  end
+  
+  task :commit_changelog do
+    sh %(git commit CHANGELOG -m "Bump changelog version marker for release")
+    sh 'git push'
+  end
+  
+  package_name = lambda {|specification| File.join('pkg', "#{specification.name}-#{specification.version}")}
+  
+  desc 'Push a release to rubyforge'
+  task :release => [:confirm_release, :clean, :add_release_marker_to_changelog, :package, :commit_changelog, :tag] do 
+    require 'rubyforge'
+    package = package_name[spec]
+
+    rubyforge = RubyForge.new.configure
+    rubyforge.login
+    
+    user_config = rubyforge.userconfig
+    user_config['release_changes'] = YAML.load_file('CHANGELOG')[spec.version.to_s].join("\n")
+  
+    version_already_released = lambda do
+      releases = rubyforge.autoconfig['release_ids']
+      releases.has_key?(spec.name) && releases[spec.name][spec.version.to_s]
+    end
+    
+    abort("Release #{spec.version} already exists!") if version_already_released.call
+    
+    begin
+      rubyforge.add_release(spec.rubyforge_project, spec.name, spec.version.to_s, "#{package}.tar.gz", "#{package}.gem")
+      puts "Version #{spec.version} released!"
+    rescue Exception => exception
+      puts 'Release failed!'
+      raise
+    end
+  end
+  
+  desc 'Upload a beta gem'
+  task :push_beta_gem => [:clobber_package, :package] do
+    beta_gem = package_name[spec]
+    #sh %(scp #{beta_gem}.gem  marcel@rubyforge.org:/var/www/gforge-projects/aliyun/beta)
+    sh %(gem push #{beta_gem}.gem)
+  end
+  
+  task :spec do
+    puts spec.to_ruby
+  end
+end
+
+desc 'Check code to test ratio'
+task :stats do 
+  library_files = FileList["#{library_root}/lib/**/*.rb"]
+  test_files    = FileList["#{library_root}/test/**/*_test.rb"]
+  count_code_lines = Proc.new do |lines| 
+    lines.inject(0) do |code_lines, line|
+      next code_lines if [/^\s*$/, /^\s*#/].any? {|non_code_line| non_code_line === line}
+      code_lines + 1
+    end
+  end
+  
+  count_code_lines_for_files = Proc.new do |files|
+    files.inject(0) {|code_lines, file| code_lines + count_code_lines[IO.read(file)]}
+  end
+  
+  library_code_lines = count_code_lines_for_files[library_files]
+  test_code_lines    = count_code_lines_for_files[test_files]
+  ratio = Proc.new { sprintf('%.2f', test_code_lines.to_f / library_code_lines)}
+  
+  puts "Code LOC: #{library_code_lines}    Test LOC: #{test_code_lines}    Code to Test Ratio: 1:#{ratio.call}"
+end
+
+namespace :test do
+  find_file = lambda do |name|
+    file_name = lambda {|path| File.join(path, "#{name}.rb")}
+    root = $:.detect do |path|
+      File.exist?(file_name[path])
+    end
+    file_name[root] if root
+  end
+  
+  TEST_LOADER = find_file['rake/rake_test_loader']
+  multiruby   = lambda do |glob|
+    system 'multiruby', TEST_LOADER, *Dir.glob(glob)
+  end
+    
+  desc 'Check test coverage'
+  task :coverage do
+    system("rcov -x Library -x support --sort coverage #{File.join(library_root, 'test/*_test.rb')}")
+    show_test_coverage_results
+  end
+  
+  Rake::TestTask.new(:remote) do |test|
+    test.pattern = 'test/remote/*_test.rb'
+    test.verbose = true
+  end
+  
+  Rake::TestTask.new(:all) do |test|
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+
+  desc 'Check test coverage of full stack remote tests'
+  task :full_coverage do
+    system("rcov -x Library -x support --sort coverage #{File.join(library_root, 'test/remote/*_test.rb')} #{File.join(library_root, 'test/*_test.rb')}")
+    show_test_coverage_results
+  end
+  
+  desc 'Run local tests against multiple versions of Ruby'
+  task :version_audit do
+    multiruby['test/*_test.rb']
+  end
+  
+  namespace :version_audit do
+    desc 'Run remote tests against multiple versions of Ruby'
+    task :remote do
+      multiruby['test/remote/*_test.rb']
+    end
+    
+    desc 'Run all tests against multiple versions of Ruby'
+    task :all do
+      multiruby['test/**/*_test.rb']
+    end
+  end
+  
+  def show_test_coverage_results
+    system("open #{File.join(library_root, 'coverage/index.html')}") if PLATFORM['darwin']
+  end
+  
+  desc 'Remove coverage products'
+  task :clobber_coverage do
+    rm_r 'coverage' rescue nil
+  end
+end
+
+namespace :todo do
+  class << TODOS = IO.read(File.join(library_root, 'TODO'))
+    def items
+      split("\n").grep(/^\[\s|X\]/)
+    end
+    
+    def completed
+      find_items_matching(/^\[X\]/)
+    end
+    
+    def uncompleted
+      find_items_matching(/^\[\s\]/)
+    end
+        
+    def find_items_matching(regexp)
+      items.grep(regexp).instance_eval do
+        def display
+          puts map {|item| "* #{item.sub(/^\[[^\]]\]\s/, '')}"}
+        end
+        self
+      end
+    end
+  end
+  
+  desc 'Completed todo items'
+  task :completed do
+    TODOS.completed.display
+  end
+  
+  desc 'Incomplete todo items'
+  task :uncompleted do
+    TODOS.uncompleted.display
+  end
+end if File.exists?(File.join(library_root, 'TODO'))
+
+namespace :site do
+  require 'erb'
+  require 'rdoc'
+  
+  readme    = lambda { IO.read('README')[/^== Getting started\n(.*)/m, 1] }
+
+  readme_to_html = lambda do
+    handler = SM::ToHtml.new
+    handler.instance_eval do
+      require 'syntax'
+      require 'syntax/convertors/html'
+      def accept_verbatim(am, fragment) 
+        syntax = Syntax::Convertors::HTML.for_syntax('ruby')
+        @res << %(<div class="ruby">#{syntax.convert(fragment.txt, true)}</div>)
+      end
+    end
+    SM::SimpleMarkup.new.convert(readme.call, handler)
+  end
+  
+  desc 'Regenerate the public website page'
+  task :build => 'doc:readme' do
+    open('site/public/index.html', 'w') do |file|
+      erb_data = {}
+      erb_data[:readme] = readme_to_html.call
+      file.write ERB.new(IO.read('site/index.erb')).result(binding)
+    end
+  end
+  
+  task :refresh => :build do
+    system 'open site/public/index.html'
+  end
+  
+  desc 'Update the live website'
+  task :deploy => :build do
+    site_files = FileList['site/public/*']
+    site_files.delete_if {|file| File.directory?(file)}
+    sh %(scp #{site_files.join ' '} marcel@rubyforge.org:/var/www/gforge-projects/aliyun/)
+  end
+end 
+
+task :clean => ['dist:clobber_package', 'doc:clobber_rdoc', 'test:clobber_coverage']

data/bin/oss

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+oss_lib   = File.dirname(__FILE__) + '/../lib/aliyun/oss'
+setup    = File.dirname(__FILE__) + '/setup'
+irb_name = RUBY_PLATFORM =~ /mswin32/ ? 'irb.bat' : 'irb'
+
+exec "#{irb_name} -r #{oss_lib} -r #{setup} --simple-prompt"

data/bin/setup.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+#!/usr/bin/env ruby
+if ENV['OSS_ACCESS_KEY_ID'] && ENV['OSS_SECRET_ACCESS_KEY']
+  Aliyun::OSS::Base.establish_connection!(
+    :access_key_id     => ENV['OSS_ACCESS_KEY_ID'], 
+    :secret_access_key => ENV['OSS_SECRET_ACCESS_KEY']
+  )
+end
+
+require File.dirname(__FILE__) + '/../test/fixtures'
+include Aliyun::OSS

data/lib/aliyun/oss.rb

@@ -0,0 +1,55 @@
+# -*- encoding : utf-8 -*-
+require 'cgi'
+require 'uri'
+require 'openssl'
+require 'digest/sha1'
+require 'net/https'
+require 'time'
+require 'date'
+require 'open-uri'
+
+$:.unshift(File.dirname(__FILE__))
+require 'oss/extensions'
+require_library_or_gem 'builder' unless defined? Builder
+require_library_or_gem 'mime/types', 'mime-types' unless defined? MIME::Types
+
+require 'oss/base'
+require 'oss/version'
+require 'oss/parsing'
+require 'oss/acl'
+require 'oss/logging'
+require 'oss/service'
+require 'oss/owner'
+require 'oss/bucket'
+require 'oss/object'
+require 'oss/error'
+require 'oss/exceptions'
+require 'oss/connection'
+require 'oss/authentication'
+require 'oss/response'
+
+Aliyun::OSS::Base.class_eval do
+  include Aliyun::OSS::Connection::Management
+end
+
+Aliyun::OSS::Bucket.class_eval do
+  include Aliyun::OSS::Logging::Management
+  include Aliyun::OSS::ACL::Bucket
+end
+
+require_library_or_gem 'xmlsimple', 'xml-simple' unless defined? XmlSimple
+# If libxml is installed, we use the FasterXmlSimple library, that provides most of the functionality of XmlSimple
+# except it uses the xml/libxml library for xml parsing (rather than REXML). If libxml isn't installed, we just fall back on
+# XmlSimple.
+Aliyun::OSS::Parsing.parser =
+  begin
+    require_library_or_gem 'xml/libxml'
+    # Older version of libxml aren't stable (bus error when requesting attributes that don't exist) so we
+    # have to use a version greater than '0.3.8.2'.
+    raise LoadError unless XML::Parser::VERSION > '0.3.8.2'
+    $:.push(File.join(File.dirname(__FILE__), '..', '..', 'support', 'faster-xml-simple', 'lib'))
+    require_library_or_gem 'faster_xml_simple' 
+    FasterXmlSimple
+  rescue LoadError
+    XmlSimple
+  end

data/lib/aliyun/oss/acl.rb

@@ -0,0 +1,132 @@
+# -*- encoding : utf-8 -*-
+module Aliyun
+  module OSS
+    # By default buckets are private. This means that only the owner has access rights to the bucket and its objects. 
+    # Objects in that bucket inherit the permission of the bucket unless otherwise specified. When an object is private, the owner can 
+    # generate a signed url that exposes the object to anyone who has that url. Alternatively, buckets and objects can be given other 
+    # access levels. Several canned access levels are defined:
+    # 
+    # * <tt>:private</tt> - Owner gets FULL_CONTROL. No one else has any access rights. This is the default.
+    # * <tt>:public_read</tt> - Owner gets FULL_CONTROL and the anonymous principal is granted READ access. If this policy is used on an object, it can be read from a browser with no authentication.
+    # * <tt>:public_read_write</tt> - Owner gets FULL_CONTROL, the anonymous principal is granted READ and WRITE access. This is a useful policy to apply to a bucket, if you intend for any anonymous user to PUT objects into the bucket.
+    # 
+    # You can set a canned access level when you create a bucket or an object by using the <tt>:access</tt> option:
+    # 
+    #   OSSObject.store(
+    #     'kiss.jpg', 
+    #     data, 
+    #     'marcel', 
+    #     :access => :public_read
+    #   )
+    # 
+    # Since the image we created is publicly readable, we can access it directly from a browser by going to the corresponding bucket name 
+    # and specifying the object's key without a special authenticated url:
+    # 
+    #  http://oss.aliyuncs.com/marcel/kiss.jpg
+    # 
+    module ACL
+      # The ACL::Policy class lets you inspect and modify access controls for buckets and objects.
+      # A policy is made up of one or more Grants which specify a permission and a Grantee to whom that permission is granted.
+      #
+      # Buckets and objects are given a default access policy which contains one grant permitting the owner of the bucket or object
+      # FULL_CONTROL over its contents. This means they can read the object, write to the object, as well as read and write its
+      # policy.
+      #
+      # The <tt>acl</tt> method for both buckets and objects returns the policy object for that entity:
+      #
+      #   grant = Bucket.acl('some-bucket')
+      #   grant = Bucket.acl('some-bucket', :public_read)
+      #
+      
+      module Bucket
+        def self.included(klass) #:nodoc:
+          klass.extend(ClassMethods)
+        end
+        
+        module ClassMethods
+          # The acl method is the single point of entry for reading and writing access control list policies for a given bucket.
+          #   
+          #   # Fetch the acl for the 'marcel' bucket
+          #   policy = Bucket.acl 'marcel'
+          #
+          #   # Modify the policy ...
+          #   # Bucket.acl 'marcel', :public_read
+          def acl(name = nil, access_level = nil)
+            path = path(name) << '?acl'
+            if access_level
+              put(path, {:access => access_level})
+              acl(name)
+            else
+              respond_with(Policy::Response) do 
+                policy = get(path).policy 
+                policy.has_key?('access_control_list') && policy['access_control_list']['grant'][0]
+              end
+            end
+          end
+        end
+        
+        # The acl method returns and updates the acl for a given bucket.
+        #
+        #   # Fetch a bucket
+        #   bucket = Bucket.find 'marcel'
+        #
+        #   # view
+        #   bucket.acl
+        #
+        #   # write
+        #   bucket.acl(:public_read)
+        def acl(reload = false)
+          expirable_memoize(reload) do
+            self.class.acl(name, reload)
+          end
+        end
+      end
+      
+      class OptionProcessor #:nodoc:
+        attr_reader :options
+        class << self
+          def process!(options)
+            new(options).process!
+          end
+        end
+
+        def initialize(options)
+          options.to_normalized_options!
+          @options      = options
+          @access_level = extract_access_level
+        end
+
+        def process!
+          return unless access_level_specified?
+          validate!
+          options['x-oss-acl'] = access_level
+        end
+
+        private
+          def extract_access_level
+             options.delete('access') || options.delete('x-oss-acl')
+          end
+
+          def validate!
+            raise InvalidAccessControlLevel.new(valid_levels, access_level) unless valid?
+          end
+
+          def valid?
+            valid_levels.include?(access_level)
+          end
+
+          def access_level_specified?
+            !@access_level.nil?
+          end
+
+          def valid_levels
+            %w(private public-read public-read-write)
+          end
+
+          def access_level
+            @normalized_access_level ||= @access_level.to_header
+          end
+      end
+    end
+  end
+end