blobsterix_carrierwave 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ea3e909ae2f9f7de7dede8bee31dcdffb2d2ad1
+  data.tar.gz: 10456d10772b34e0200757b561ad3348e7c7fa21
+SHA512:
+  metadata.gz: 93dedde583457804200e53ffc0fe0777ae34d7a3486bb9ce010d9b096acbfa579b9e16a7c8949005c6c1bd9cad87da3c1ef43f8029ddacec778c17f5aaf4b315
+  data.tar.gz: 9496905c70773e445d2965eb38b36ee7a1a6abfa794b418a0648ddd96b26c54a004711b302b891b552c611fe81fb9b43d7ae14e3d0b48c0985244eaaff6dbb63

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-gemset
+.ruby-version
+.rbenv-gemsets

data/CHANGELOG.txt

@@ -0,0 +1,9 @@
+= 0.0.6
+ * just version bump
+= 0.0.5
+ * adding resize_max
+ * renaming scale to resize
+= 0.0.4
+ * fixing scale options
+= 0.0.3
+ * first rc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in blobsterix_carrierwave.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 dsudmann
+
+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,93 @@
+# BlobsterixCarrierwave
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'blobsterix_carrierwave'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install blobsterix_carrierwave
+
+## Usage
+
+Setup:
+  # Configuration to setup carrierwave. This is needed for everything to work
+  CarrierWave.configure do |config|
+    config.fog_credentials = {
+      :provider               => 'AWS',                        # required
+      :aws_access_key_id      => 'xxx',                        # required
+      :aws_secret_access_key  => 'yyy',                        # required
+      :region                 => 'eu-west-1',                  # optional, defaults to 'us-east-1'
+      :host                   => 'blob.localhost.local',      # this hast to have 3 levels so the s3 libs can split them, won't ever be used
+      :connection_options     => {:proxy => "http://#{Pjpp.config.blobsterix_upload_host_port}" }, #need a proxy as the s3 interface uses hostnames
+                                                                                                   #won't mess with dynamic DNS, THIS IS THE REAL upload host
+      :endpoint               => "http://blob.localhost.local" # same as host, won't ever be used
+    }
+    config.fog_directory  = 'pjpp'                     # required, can be overridden in each uploader
+    config.fog_public     = true                                   # optional, defaults to true, and actually not used here anymore.
+    config.fog_attributes = {'Cache-Control'=>'max-age=315576000'}  # optional, defaults to {}
+    config.delete_tmp_file_after_storage = true
+    config.remove_previously_stored_files_after_update = true
+    config.asset_host = proc do |uploader|
+      BlobsterixAdhocTransforms::Generator.new(:host => Pjpp.config.blobsterix_host_port, :uploader => uploader, :trafos => uploader.remote_processors)
+    end
+  end
+
+  # Simple uploader. Image is scaled to fit hight restriction, converted to png and stripped of all commentary data during upload
+  # Now during download it offers three version. One without any transformation which will allow blobsterix to decide what is the best content type.
+  # In case of images Chrome user would get webp images. The raw version restricts blobsterix to deliver the image in the same format it is saved on the server.
+  # And in case of the crazy version it will rotate the image and then convert to best format again since its not locked.
+  # The usage of the uploader is like the normal carrierwave.
+  class CompanyLogoUploader < BlobsterixUploader
+
+    process :resize => ["", "300"]
+    process :strip
+    process :set_format => "png"
+
+    def store_dir
+      "company_logos"
+    end
+
+    def bucket
+      "jobapp"
+    end
+
+    version :raw do
+      process :set_format => "raw"
+    end
+
+    version :crazy do
+      process :rotate => 25
+    end
+    
+    def name_on_server
+      "#{model.id}_#{Time.new.to_i}"
+    end
+  end
+
+  # Since the transformations are done on the fly and not in the application during upload, the uploader also allows custom transforms that do not have to be hardcoded.
+  # instead of:
+
+    company_logo.raw.url
+
+  # you can do
+
+    company_logo.custom.resize(200).rotate(25).url
+
+  # this will generate the url and blobsterix will generate the image on the fly.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/blobsterix_uploader

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require "fileutils"
+puts "Blobsterix upload generator"
+if ARGV.length == 0
+  puts "Usage: "
+  puts "\tblobsterix_uploader uploader_name"
+  exit
+end
+
+
+template = File.read(File.join(File.dirname(__FILE__), "../config/uploader_template.rb"))
+template = template.gsub("$UploaderName", ARGV[0].capitalize)
+
+if !File.exist?(File.join(Dir.pwd, "app/uploaders/#{ARGV[0].downcase}_uploader.rb"))
+  FileUtils.mkdir_p(File.join(Dir.pwd, "app/uploaders"))
+  File.open(File.join(Dir.pwd, "app/uploaders/#{ARGV[0].downcase}_uploader.rb"), "w+") {|f|
+    f.write(template)
+  }
+  puts "Generated new uploader"
+else
+  puts "Uploader already exists"
+end

data/blobsterix_carrierwave.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/blobsterix_carrierwave/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Daniel Sudmann"]
+  gem.email         = ["suddani@googlemail.com"]
+  gem.description   = "This gem is used to create a carrierwave binding to a blobsterix server"
+  gem.summary       = "This gem is used to create a carrierwave binding to a blobsterix server"
+  gem.homepage      = "http://experteer.com"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "blobsterix_carrierwave"
+  gem.require_paths = ["lib"]
+  gem.version       = BlobsterixCarrierwave::VERSION
+
+  gem.add_dependency "carrierwave", "~> 0.9.0"
+  gem.add_dependency "fog"        , "~> 1.3.1"
+end

data/config/uploader_template.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+class $UploaderNameUploader < BlobsterixUploader
+
+  # When setting a global process it is applied when 
+  # uploaded to a blobsterix server
+  #process :resize => ["", "300"]
+
+  # This sets a directory inside a bucket
+  # only used for cosmetic reasons
+  #def store_dir
+  #  "some_dir"
+  #end
+
+  # This function overrides the bucket set
+  # in the carrierwave fog config
+  # only use if this uploader should use a different bucket
+  #def bucket
+  #  "jobapp"
+  #end
+
+  # Versions work the same as in normal carrierwave
+  # with the difference that versions are generated
+  # on the server when requested and are not generated
+  # when uploading
+  #version :raw do
+  #  process :resize => 100
+  #  process :rotate => 25
+  #  process :set_format => "raw"
+  #end
+  
+  # This function is used to set the name of the file
+  # on the server to something else than the actual upload
+  # filename. So only use it when that behaviour is desired.
+  # Example: It can be used to generate timestamped names
+  #          to invalidate the client cache
+  #def name_on_server
+  #  "#{model.id}_#{Time.new.to_i}"
+  #end
+end

data/lib/blobsterix_carrierwave/blobsterix_adhoc_transforms.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module BlobsterixAdhocTransforms
+  extend BlobsterixTransforms
+    class Generator
+      def initialize(options={})
+        # host
+        # bucket
+        # path
+        # trafos <- array with transform methods and 
+        # uploader <- BlobsterixCarrierWaveUploader
+        @options = options || {}
+        @chain=[]
+
+        #init the trafos
+        (@options[:trafos] || []).each{|t|
+          c.send(t[0], t[1])
+        }
+      end
+
+      def clear_trafo
+        @chain = []
+        self
+      end
+
+      def set_path(path)
+        @options[:path] = path
+        self
+      end
+
+      def url(path=nil)
+        @options[:path] = path if path
+        "#{asset_host}#{encoded_path}"
+      end
+
+      def url_s3(path=nil, use_subdomain=true)
+        @options[:path] = path if path
+
+        "#{s3_host(use_subdomain)}#{encoded_path}"
+      end
+
+      def transform(encrypt=true)
+        trafo = @chain.map{|trafo|
+          "#{trafo[:method]}_#{trafo[:args]}"
+        }.join(",")
+        encrypt ? BlobsterixCarrierwave.encrypt_trafo(trafo, self) : trafo
+      end
+
+      def has_transform?
+        !@chain.empty?
+      end
+
+      def method_missing(method, *args)
+        if BlobsterixAdhocTransforms.respond_to?(method)
+          @chain << BlobsterixAdhocTransforms.send(method, *args)
+        else
+          #shit!
+        end
+        self
+      end
+
+      def uploader
+        @options[:uploader]
+      end
+
+      private
+        def version
+          @options[:version] || 1        
+        end
+        def encoded_path
+          @options[:path] || ""
+        end
+        def s3_host(use_subdomain)
+          if (use_subdomain)
+            "http://#{bucket}.#{@options[:host]}/"
+          else
+            "http://#{@options[:host]}/#{bucket}/"
+          end
+        end
+        def asset_host
+
+          host = @options[:host] || ""
+          if host.respond_to? :call and @options.has_key?(:uploader)
+            host.call(self)
+          else
+            trafo = transform
+            if trafo.length > 0
+              "http://#{host}/blob/v#{version}/#{trafo}.#{bucket}/"
+            else
+              "http://#{host}/blob/v#{version}/#{bucket}/"
+            end
+          end
+
+          #"http://localhost:9000/blob/v1/#{trafo}.#{uploader.fog_directory}/"
+        end
+        def bucket()
+          if @options.has_key?(:uploader)
+            @options[:uploader].fog_directory
+          else
+            @options[:bucket] || "main"
+          end
+        end
+    end
+  end

data/lib/blobsterix_carrierwave/blobsterix_carrierwave.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+module Blobsterix
+  module CarrierWave
+    #crazy version stuff not needed anymore
+    def recreate_versions!
+      # Do nothing
+      # puts "Recreate versions"
+    end
+
+    def cache_versions!(new_file=nil)
+      # Do nothing
+      # puts "Cache versions"
+    end
+
+    def store_versions!(new_file=nil)
+      # Do nothing
+      # puts "Store versions"
+    end
+
+    def remove_versions!(new_file=nil)
+      # Do nothing
+      # puts "Remove versions"
+    end
+
+    def retrieve_versions_from_cache!(new_file=nil)
+      # Do nothing
+      # puts "retrieve_versions_from_cache: #{version_name}"
+    end
+
+    def retrieve_versions_from_store!(new_file=nil)
+      # Do nothing
+      # puts "retrieve_versions_from_store: #{new_file.inspect}, #{version_name}"
+      super(new_file)
+    end
+
+    def process!(new_file=nil)
+      # Do nothing
+      # puts "Doing process for #{new_file.inspect} on #{self.inspect}"
+    end
+
+    def remote_process!(encrypt=true)
+      if enable_processing
+        #Deactivate conditional stuff
+        # self.class.processors.each do |method, args, condition|
+        #   if(condition)
+        #     next if !(condition.respond_to?(:call) ? condition.call(self, :args => args, :method => method, :file => new_file) : self.send(condition, new_file))
+        #   end
+        #   puts "Do: #{method} with #{args.inspect}"
+        #   trafos.send(method, *args)
+        # end
+        BlobsterixAdhocTransforms::Generator.new(:trafos => self.class.processors.map{|method, args, condition|[method, args]}).transform(encrypt)
+      else
+        ""
+      end
+    end
+
+    def remote_processors()
+      # puts "Version: #{version_name}"
+      if enable_processing and version_name
+        current_processor = self.class
+        remote_processor_array = []
+        until current_processor.parent == Object
+          remote_processor_array+=current_processor.processors.map{|method, args, condition|[method, args]}
+          current_processor = current_processor.parent
+        end
+        remote_processor_array
+      else
+        []
+      end
+    end
+
+    private
+      #much important, very nice, wow
+      def full_filename(for_file)
+        #[remote_process!, for_file].join(".")
+        for_file
+      end
+
+    #url call somehow broken so just call it directly
+    # def url(options = {})
+    #   file.url(options)
+    # end
+  end
+end

data/lib/blobsterix_carrierwave/blobsterix_storage.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+module CarrierWave
+  module Storage
+    class BlobsterixStore < Fog
+      # From Abstract
+      # attr_reader :uploader
+
+      # def initialize(uploader)
+      #    @uploader = uploader
+      #    puts "Init BlobsterixStore"
+      # end
+
+      # def identifier
+      #   uploader.filename
+      # end
+
+      #################
+      # Abstract provides stubs we must implement.
+      #
+      # Create and save a file instance to your engine.
+      def store!(file)
+        # puts "Called store: #{file.inspect} with #{uploader.processors}"
+        f = File.new(uploader, self, uploader.store_path)
+        f.store(file)
+        f
+      end
+
+      # Load and return a file instance from your engine.
+      def retrieve!(identifier)
+        # puts "Called retrieve: #{identifier.class}:#{identifier}"
+        File.new(uploader, self, uploader.store_path(identifier))
+      end
+
+      # Subclass or duck-type CarrierWave::SanitizedFile ; responsible for storing the file to your engine.
+      class File < Fog::File
+        def initialize(uploader, base, path)
+          @uploader, @base, @path = uploader, base, path
+        end
+
+        def url(options = {})
+          # puts "Get file url: #{options}, #{@uploader.version_name}"
+          u = super(options)
+          # puts "Url is now: #{u}"
+          u
+        end
+
+        def store(new_file)
+          fog_file = new_file.to_file
+          @content_type ||= new_file.content_type
+          @file = directory.files.new({
+            :body         => fog_file ? fog_file : new_file.read,
+            :content_type => @content_type,
+            :key          => path,
+            :public       => @uploader.fog_public,
+            :collection => directory.files,
+            :connection => directory.files.connection
+          }.merge(@uploader.fog_attributes))
+          @file.metadata={"x-amz-meta-trafo" => @uploader.remote_process!(false)}
+          @file.save()
+          fog_file.close if fog_file && !fog_file.closed?
+          true
+        end
+
+        def public_url
+          @uploader.asset_host.url(encode_path(path))
+        end
+
+        def read
+          super()
+        end
+        def size
+          super()
+        end
+        def delete
+          super()
+        end
+        def exists?
+          url = BlobsterixAdhocTransforms::Generator.new(:host => @uploader.fog_credentials[:connection_options][:proxy].gsub("http://",""), :uploader => @uploader, :path => @path).url_s3(nil, false)
+          # puts "Check url: #{url}"
+          uri = URI(url)
+          return_code = 404
+          Net::HTTP.start(uri.host, uri.port) do |http|
+            response = http.get uri.path # Net::HTTPResponse object
+            response.code
+          end == "200"
+        end
+        # Others... ?
+        def process
+        end
+
+      end # File
+
+    end # MyEngine
+  end # Storage
+end # CarrierWave

data/lib/blobsterix_carrierwave/blobsterix_transforms.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module BlobsterixTransforms
+  def resize(args)
+     args=[args].flatten
+     width=args[0]
+     height=args[1]
+     {
+      :method => "resize",
+      :args => "#{width}x#{height}"
+     }
+  end
+  def resizemax(args)
+     args=[args].flatten
+     width=args[0]
+     height=args[1]
+     {
+      :method => "resizemax",
+      :args => "#{width}x#{height}"
+     }
+  end
+  def rotate(angle)
+    {
+      :method => "rotate",
+      :args => "#{angle}"
+    }
+  end
+  def raw_image(e)
+    {
+      :method => "raw",
+      :args => ""
+    }
+  end
+  def set_format(format, option = "")
+    {
+      :method => format,
+      :args => option
+    }
+  end
+  def strip(e)
+    {
+      :method => "strip",
+      :args => ""
+    }
+  end
+end

data/lib/blobsterix_carrierwave/blobsterix_uploader.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+class BlobsterixUploader < CarrierWave::Uploader::Base
+
+  include CarrierWave::MimeTypes
+  include Blobsterix::CarrierWave
+
+  #storage :file
+  storage CarrierWave::Storage::BlobsterixStore
+
+  include BlobsterixTransforms
+
+  after :store, :done_store
+  before :store, :before_store
+
+  def before_store obj
+    #puts "Start with storing"
+  end
+  def done_store obj
+    #puts "Done with storing"
+  end
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    #puts "Would say: uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+    "images"
+    #"uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  def fog_directory
+    bucket || super()
+  end
+
+  def bucket
+    nil
+  end
+
+  def custom
+    asset_host.set_path(path).clear_trafo
+  end
+
+  def filename
+    if original_filename.present? and respond_to?(:name_on_server)
+      name_on_server
+    else
+      super()
+    end
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url
+  #   # For Rails 3.1+ asset pipeline compatibility:
+  #   # ActionController::Base.helpers.asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+  #
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  #process :resize => ["", "300"]
+  #process :rotate => 45
+  #
+
+
+
+  # Create different versions of your uploaded files:
+  # version :thumb do
+  #   process :resize => [50, "50!"]
+  # end
+
+  # version :face do
+  #   process :resize => [10, 10]
+  # end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_white_list
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+
+end

data/lib/blobsterix_carrierwave/version.rb

@@ -0,0 +1,4 @@
+module BlobsterixCarrierwave
+  VERSION = "0.0.7"
+end
+

data/lib/blobsterix_carrierwave.rb

@@ -0,0 +1,22 @@
+require "blobsterix_carrierwave/version"
+
+require "carrierwave"
+require "fog"
+
+require "blobsterix_carrierwave/blobsterix_carrierwave"
+require "blobsterix_carrierwave/blobsterix_storage"
+require "blobsterix_carrierwave/blobsterix_transforms"
+require "blobsterix_carrierwave/blobsterix_adhoc_transforms"
+require "blobsterix_carrierwave/blobsterix_uploader"
+
+module BlobsterixCarrierwave
+  # Your code goes here...
+  def self.encrypt_trafo(trafo_string=nil, generator=nil)
+    @encrypt_trafo||=lambda{|t_string, generator| t_string}
+    trafo_string ? @encrypt_trafo.call(trafo_string, generator) : @encrypt_trafo
+  end
+
+  def self.encrypt_trafo=(obj)
+    @encrypt_trafo=obj
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: blobsterix_carrierwave
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+platform: ruby
+authors:
+- Daniel Sudmann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: carrierwave
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description: This gem is used to create a carrierwave binding to a blobsterix server
+email:
+- suddani@googlemail.com
+executables:
+- blobsterix_uploader
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.txt
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/blobsterix_uploader
+- blobsterix_carrierwave.gemspec
+- config/uploader_template.rb
+- lib/blobsterix_carrierwave.rb
+- lib/blobsterix_carrierwave/blobsterix_adhoc_transforms.rb
+- lib/blobsterix_carrierwave/blobsterix_carrierwave.rb
+- lib/blobsterix_carrierwave/blobsterix_storage.rb
+- lib/blobsterix_carrierwave/blobsterix_transforms.rb
+- lib/blobsterix_carrierwave/blobsterix_uploader.rb
+- lib/blobsterix_carrierwave/version.rb
+homepage: http://experteer.com
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: This gem is used to create a carrierwave binding to a blobsterix server
+test_files: []
+has_rdoc: