neutrino 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 700370ce37aa38dfdc9d9868a86fb7ad8de577de
+  data.tar.gz: 9363cc836ecbd7b1c83f297b7e5c25fb241e1963
+SHA512:
+  metadata.gz: 409091534ed84f578e427ec66fe31083fd49d732fac50d30738729b097643a2abaef5d453a2f1c0dd2fb0f0118261b44e480deaaa22ad5d9a274581c058fbf27
+  data.tar.gz: afb8ac3876e407def5e7aadeb63e98d1cbb3a0ffbb804bbd6fde2138248e15dd9ca9650b5a65712916d24ad17b63fa0ad2eff2bcbc8e6cff1d5ff4668a8dbf3f

data/.env.sample

@@ -0,0 +1,3 @@
+AWS_BUCKET_NAME='BUCKET_NAME'
+AWS_ACCESS_KEY_ID='ACCESS_KEY_ID'
+AWS_SECRET_ACCESS_KEY='SECRET_ACCESS_KEY'

data/.gitignore

@@ -0,0 +1,13 @@
+*.gem
+*.rbc
+.bundle
+.config
+Gemfile.lock
+doc/
+pkg
+rdoc
+tmp
+bin/*
+TODO
+vendor/*
+.env

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,20 @@
+---
+language: ruby
+rvm:
+- 1.9.3
+- 2.0.0
+script: bundle exec rspec spec
+env:
+  global:
+  - secure: |-
+      PpbHqVauGo2B31JKgZ7YTBfwflDuHYOr88QuROMJO7VdBaJidB5+51jjUIrI
+      2Z8edxKvwL6Wj4Y9JttY3Q2Rmv//2QE74PxCHv4ofds6SPsYLmgZvIi1C156
+      143j05sNhGZaBgHhNe/jVz+VWx39jP6hfhX/UzqdKS1O/GcU0Hc=
+  - secure: |-
+      Ip+U3IefxnOkZXGDl5iVatTCV3JTeopnPZbs+eG/o9jCu2OTF//ttG5F5PIF
+      yn9ffVXLw7Sw1CxR5/G436AKCr/EjZgC3mhnKtW+grOofbig1p3lAMQf1nGB
+      qqZtBJ/WL1AZpasr4ab8Gj5wGlpVsVIhpzic3WylhQbH+157+zg=
+  - secure: |-
+      KuVQfT2Zp/QNXhB7rT4YS0irpZjpd6okDtg0PgqXebwruc+nnSWvuxYTi4Tf
+      OfoUs4p4ObFJo0tHGtPfKd1S1fMMQq8bEnMdAd9an4LT+eWoAKc5X6DP0MaO
+      UWcTtriA66sQBOkWwNdnkPcPq4UFHzU75mn6dD0tAGUDR8HitF4=

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.0.1
+
+* Placeholder release. Such a spiffy name!

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Parker Selbert
+
+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,183 @@
+# Neutrino
+
+[![Build Status](https://travis-ci.org/sorentwo/neutrino.png?branch=master)](https://travis-ci.org/sorentwo/neutrino)
+[![Code Climate](https://codeclimate.com/github/sorentwo/neutrino.png)](https://codeclimate.com/github/sorentwo/neutrino)
+
+Neutrino is a ruby uploader library that embraces the spirit of CarrierWave,
+but rejects many of the implementation details and magic. Neutrino's aim is to
+work regardless of framework and with any persistence, storage, or processor.
+
+## Disclaimer
+
+Neutrino is under active development and is by no means stable. Classes and
+methods documented in this README are not necessarily implemented yet. When a
+gem is distributed and/or the version is at least `0.1.0` the gem can be
+considered in beta.
+
+## Configuration
+
+Neutrino must be configured to handle persistence, storage, or processing.
+Engine configuration uses classes rather than symbols so that any component may
+be substituted for a custom library without the need to modify or extend any of
+Neutrino's internal classes.
+
+```ruby
+# Note that neutrino does not load any engines without an explicit require, you
+# must include any engine you need for configuration.
+
+require 'neutrino/storage/aws'
+
+Neutrino.configure do |config|
+  config.storage = Neutrino::Storage::AWS
+
+  config.storage.configure do |storage|
+    storage.bucket            = 'bucket.name'
+    storage.acl               = :public_read
+    storage.access_key_id     = 'access key id'
+    storage.secret_access_key = 'secret access key'
+  end
+end
+```
+
+# Mounting
+
+An uploader can be mounted on any ruby object automatically, or it can be
+handled manually.
+
+Automatic mounting, identical to CarrierWave syntax. Mounting will only define
+a reader and writer, it does not automatically eval in callbacks, validation,
+or any additional methods.
+
+```ruby
+class User
+  include Neutrino::Mixins::Mountable
+
+  mount_uploader :avatar, AvatarUploader
+end
+```
+
+Uploaders can also be mounted 'manually' simply by composing them into a class.
+This is all that the automatic mounter is doing, but allows you to add custom
+behavior to the method.
+
+```ruby
+class User
+  def avatar
+    avatar_uploader.stored
+  end
+
+  def avatar=(new_avatar)
+    avatar_uploader.stored=(new_avatar)
+  end
+
+  def avatar_uploader
+    AvatarUploader.new(self, mounted_on: :avatar)
+  end
+end
+```
+
+# Persistence
+
+Having a mounted uploader is nice and all, but you need persistence to retreive
+the asset later. As with mounting there are a couple of ways that you can
+implement persistence.
+
+```ruby
+Neutrino.configure do |config|
+  config.auto_persist = true
+end
+```
+
+The built in ActiveRecord engine will define lifecylce callbacks to handle
+storing, tempfile cleanup, and destruction. You would manually define the
+callbacks like this:
+
+```ruby
+class User < ActiveRecord::Base
+  before_validation -> user { user.avatar_uploader.validate }
+  before_save       -> user { user.avatar_uploader.store }
+  after_save        -> user { user.avatar_uploader.cleanup }
+  before_destroy    -> user { user.avatar_uploader.destroy }
+end
+```
+
+## Processing
+
+More often than not processing refers to image processing, though it can be any
+post upload asset processing. Asset processing requires defining a processor
+pipeline, and is performed by a set of `process` directives, each applied in
+sequence.
+
+```ruby
+class AvatarUploader
+  include Neutrino::Uploader, Neutrino::Processors::Nano
+
+  def process!
+    resize!  '120x120'
+    convert! 'jpg'
+  end
+end
+```
+
+## Versions
+
+Defining multiple versions of an asset is simple and modeled directly off of
+CarrierWave's style.
+
+```ruby
+class AvatarUploader
+  include Neutrino::Uploader, Neutrino::Processors::Nano
+
+  def process!
+    resize!  '100x100'
+    convert! 'jpg'
+  end
+
+  version(:thumb) do |thumb|
+    resize!  '100x100'
+    convert! 'jpg'
+  end
+end
+```
+
+## Testing
+
+Performing asset processing during testing is unnecessary and slow. It is
+recommended that you disable global processing in your testing config.
+
+```ruby
+Neutrino.configure do |config|
+  config.processing = false
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'neutrino', '~> 0.1.0'
+```
+
+## Contributing
+
+Feature specs are dependent on at least one external service (AWS) and the
+specs won't run unless some environment variables are configured. Please copy
+the `.env.sample` file and fill in real credentials to ensure integration specs
+are working properly.
+
+```bash
+cp .env.sample .env
+```
+
+Travis builds are configured to use secure environment variables so that AWS
+integration specs will operate. Those variables are *not* available for pull
+requests, so all pull requests will fail to pass CI. If and when I get any real
+pull requests I'll implement some feature detection to prevent blanekt CI
+failures.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/neutrino.rb

@@ -0,0 +1,33 @@
+require 'neutrino/storage/null'
+require 'neutrino/uploader'
+require 'neutrino/version'
+
+module Neutrino
+  class << self
+    attr_writer :persistence, :processor, :storage
+
+    def configure(&block)
+      yield self
+    end
+
+    def reset!
+      configure do |config|
+        config.persistence = nil
+        config.processor   = nil
+        config.storage     = nil
+      end
+    end
+
+    def persistence
+      @persistence
+    end
+
+    def processor
+      @processor
+    end
+
+    def storage
+      @storage ||= Neutrino::Storage::Null
+    end
+  end
+end

data/lib/neutrino/processing/nano.rb

@@ -0,0 +1,41 @@
+require 'shellwords'
+
+module Neutrino
+  module Processing
+    module Nano
+      attr_accessor :cached
+
+      def convert!(format)
+        pathname = converted_pathname(format)
+
+        manipulate!('-format', format)
+
+        if pathname != File.expand_path(cached.path)
+          File.delete(cached)
+
+          self.cached = File.open(pathname)
+        end
+      end
+
+      def resize!(dimensions)
+        manipulate!('-resize', dimensions)
+      end
+
+      def manipulate!(*arguments)
+        pid = Kernel.spawn(build_command(arguments))
+
+        Process.wait(pid)
+      end
+
+      private
+
+      def build_command(arguments)
+        Shellwords.join(['mogrify'] + arguments + [cached.path])
+      end
+
+      def converted_pathname(format)
+        File.expand_path(cached.path.sub(/(\.\w*)?$/, ".#{format}"))
+      end
+    end
+  end
+end

data/lib/neutrino/storage/aws.rb

@@ -0,0 +1,62 @@
+require 'aws/s3'
+
+module Neutrino
+  module Storage
+    class AWS
+      class << self
+        attr_accessor :acl, :bucket, :access_key_id, :secret_access_key
+
+        def configure(&block)
+          yield self
+        end
+      end
+
+      attr_reader :uploader
+
+      def initialize(uploader)
+        @uploader = uploader
+      end
+
+      def store(new_file)
+        file.write(
+          acl:          self.class.acl,
+          content_type: 'application/octet-stream',
+          file:         new_file.path
+        )
+
+        true
+      end
+
+      def delete
+        file.delete
+      end
+
+      def exists?
+        file.exists?
+      end
+
+      def url
+        file.public_url.to_s
+      end
+
+      private
+
+      def bucket
+        @bucket ||= connection.buckets[self.class.bucket]
+      end
+
+      def connection
+        @connection ||= ::AWS::S3.new(credentials)
+      end
+
+      def credentials
+        { access_key_id:     self.class.access_key_id,
+          secret_access_key: self.class.secret_access_key }
+      end
+
+      def file
+        @file ||= bucket.objects[uploader.store_path]
+      end
+    end
+  end
+end

data/lib/neutrino/storage/null.rb

@@ -0,0 +1,15 @@
+module Neutrino
+  module Storage
+    class Null
+      attr_reader :uploader
+
+      def initialize(uploader)
+        @uploader = uploader
+      end
+
+      def delete;          nil;  end
+      def store(new_file); true; end
+      def url;             nil;  end
+    end
+  end
+end

data/lib/neutrino/uploader.rb

@@ -0,0 +1,31 @@
+require 'neutrino'
+require 'forwardable'
+
+module Neutrino
+  module Uploader
+    extend Forwardable
+
+    attr_writer :storage
+    attr_reader :cached
+
+    delegate [:delete, :exists?, :store, :url] => :storage
+
+    def storage
+      @storage ||= Neutrino.storage.new(self)
+    end
+
+    def store_dir
+    end
+
+    def filename
+    end
+
+    def store_path(for_file = filename)
+      File.join([store_dir, for_file].compact)
+    end
+
+    def cache(file)
+      @cached = file
+    end
+  end
+end

data/lib/neutrino/version.rb

@@ -0,0 +1,3 @@
+module Neutrino
+  VERSION = "0.0.1"
+end

data/neutrino.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'neutrino/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'neutrino'
+  spec.version       = Neutrino::VERSION
+  spec.authors       = ['Parker Selbert']
+  spec.email         = ['parker@sorentwo.com']
+  spec.homepage      = 'https://github.com/sorentwo/neutrino'
+  spec.license       = 'MIT'
+  spec.description   = %(An uploader library that embraces modularity and rejects magick)
+  spec.summary       = %(
+    Neutrino is a ruby uploader library that embraces the spirit of
+    CarrierWave, but rejects many of the implementation details and magic.
+    Neutrino's aim is to work regardless of framework and with any persistence,
+    storage, or processor.
+  )
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake',    '~> 10.0.2'
+  spec.add_development_dependency 'rspec',   '~> 2.13.0'
+  spec.add_development_dependency 'aws-sdk', '~> 1.8.5'
+end

data/spec/features/deleting_files_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class BasicUploader
+  include Neutrino::Uploader
+
+  def store_dir; 'uploads';       end
+  def filename;  'text_file.txt'; end
+end
+
+describe 'Deleting Files' do
+  let(:text_file) { File.open('spec/fixtures/text_file.txt', 'r') }
+
+  subject(:uploader) { BasicUploader.new }
+
+  context 'Using null storage', storage: :null do
+    it 'does not delete a file' do
+      expect(uploader.delete).to be_nil
+    end
+  end
+
+  context 'Using AWS storage', storage: :aws do
+    it 'deletes the file from the stored location' do
+      uploader.store(text_file)
+      uploader.delete
+
+      expect(uploader.exists?).to be_false
+    end
+  end
+end

data/spec/features/processing_files_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'neutrino/processing/nano'
+
+class BasicUploader
+  include Neutrino::Uploader, Neutrino::Processing::Nano
+
+  def store_dir; 'uploads';   end
+  def filename;  'image.png'; end
+
+  def process!
+    resize!  '100x100'
+    convert! 'jpg'
+  end
+end
+
+describe 'Processing Files', processing: :image do
+  it 'applies processing directives to the file before storage' do
+    uploader = BasicUploader.new
+    image    = File.open('spec/fixtures/image.png')
+
+    uploader.cache(image)
+    uploader.process!
+
+    expect(File.extname(uploader.cached)).to eq('.jpg')
+  end
+end

data/spec/features/storing_files_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+class BasicUploader
+  include Neutrino::Uploader
+
+  def store_dir; 'uploads';       end
+  def filename;  'text_file.txt'; end
+end
+
+describe 'Storing Files' do
+  let(:text_file) { File.open('spec/fixtures/text_file.txt', 'r') }
+
+  subject(:uploader) { BasicUploader.new }
+
+  context 'Using null storage', storage: :null do
+    it 'does not store a file' do
+      expect(uploader.store(text_file)).to be_true
+    end
+  end
+
+  context 'Using AWS storage', storage: :aws do
+    it 'uploads the file to the configured s3 bucket' do
+      expect(uploader.store(text_file)).to be_true
+
+      expect(uploader.url).to eq("https://#{ENV.fetch('AWS_BUCKET_NAME')}.s3.amazonaws.com/uploads/text_file.txt")
+    end
+  end
+end

data/spec/fixtures/text_file.txt

@@ -0,0 +1 @@
+Text File

data/spec/neutrino/processing/nano_spec.rb

@@ -0,0 +1,40 @@
+require 'neutrino/processing/nano'
+
+describe Neutrino::Processing::Nano, processing: :image do
+  let(:file) { File.open('spec/fixtures/image.png') }
+
+  subject(:processor) do
+    Object.new.tap do |object|
+      object.extend(Neutrino::Processing::Nano)
+      object.cached = file
+    end
+  end
+
+  describe '#convert!' do
+    it 'converts the file to the new format' do
+      processor.convert!('jpg')
+
+      expect(File.extname(processor.cached)).to eq('.jpg')
+    end
+
+    it 'cleans up the original file' do
+      processor.convert!('jpg')
+
+      expect(File.exists?(file.path)).to be_false
+    end
+
+    it 'does not delete the original file if the format has not changed' do
+      processor.convert!('png')
+
+      expect(File.exists?(file.path)).to be_true
+    end
+  end
+
+  describe '#resize!' do
+    it 'resizes the image using the exact dimensions' do
+      processor.resize!('100x100')
+
+      expect(`identify #{file.path}`.split(' ')[2]).to eq('100x100')
+    end
+  end
+end

data/spec/neutrino/uploader_spec.rb

@@ -0,0 +1,34 @@
+require 'neutrino'
+require 'neutrino/uploader'
+
+describe Neutrino::Uploader do
+  let(:uploader) do
+    Object.new.tap do |object|
+      object.extend(Neutrino::Uploader)
+    end
+  end
+
+  describe '#storage' do
+    it 'defaults to the null storage engine' do
+      expect(uploader.storage).to be_instance_of(Neutrino.storage)
+    end
+  end
+
+  describe '#storage=' do
+    it 'overrides the configured storage engine' do
+      engine = double(:storage)
+      uploader.storage = engine
+
+      expect(uploader.storage).to eq(engine)
+    end
+  end
+
+  describe '#cache' do
+    it 'holds a reference to the provided file' do
+      file = double(:file)
+
+      uploader.cache(file)
+      expect(uploader.cached).to eq(file)
+    end
+  end
+end

data/spec/neutrino_spec.rb

@@ -0,0 +1,25 @@
+require 'neutrino'
+
+describe Neutrino do
+  describe '.configure' do
+    let(:custom_module) { double(:custom_module) }
+
+    it 'overrides the default engines' do
+      Neutrino.configure do |config|
+        config.persistence = custom_module
+        config.processor   = custom_module
+        config.storage     = custom_module
+      end
+
+      expect(Neutrino.persistence).to be(custom_module)
+      expect(Neutrino.processor).to be(custom_module)
+      expect(Neutrino.storage).to be(custom_module)
+    end
+  end
+
+  describe '.storage' do
+    it 'defaults to the null storage engine' do
+      expect(Neutrino.storage).to be(Neutrino::Storage::Null)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+require 'neutrino'
+require 'fileutils'
+
+def source_environment_file!
+  return unless File.exists?('.env')
+
+  File.readlines('.env').each do |line|
+    values = line.split('=')
+    ENV[values.first] = values.last.chomp
+  end
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus
+  config.order = 'random'
+  config.run_all_when_everything_filtered = true
+
+  config.before do
+    Neutrino.reset!
+  end
+
+  config.before(storage: :null) do
+    require 'neutrino/storage/null'
+
+    Neutrino.configure do |config|
+      config.storage = Neutrino::Storage::Null
+    end
+  end
+
+  config.before(storage: :aws) do
+    require 'neutrino/storage/aws'
+
+    Neutrino.configure do |config|
+      config.storage = Neutrino::Storage::AWS
+
+      config.storage.configure do |storage|
+        storage.acl               = :public_read
+        storage.bucket            = ENV.fetch('AWS_BUCKET_NAME')
+        storage.access_key_id     = ENV.fetch('AWS_ACCESS_KEY_ID')
+        storage.secret_access_key = ENV.fetch('AWS_SECRET_ACCESS_KEY')
+      end
+    end
+  end
+
+  config.before(processing: :image) do
+    FileUtils.cp('spec/fixtures/image.png', 'spec/fixtures/backup.png')
+  end
+
+  config.after(processing: :image) do
+    jpeg_path = 'spec/fixtures/image.jpg'
+
+    FileUtils.rm(jpeg_path) if File.exists?(jpeg_path)
+    FileUtils.mv('spec/fixtures/backup.png', 'spec/fixtures/image.png')
+  end
+
+  source_environment_file!
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: neutrino
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Parker Selbert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.5
+description: An uploader library that embraces modularity and rejects magick
+email:
+- parker@sorentwo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .env.sample
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/neutrino.rb
+- lib/neutrino/processing/nano.rb
+- lib/neutrino/storage/aws.rb
+- lib/neutrino/storage/null.rb
+- lib/neutrino/uploader.rb
+- lib/neutrino/version.rb
+- neutrino.gemspec
+- spec/features/deleting_files_spec.rb
+- spec/features/processing_files_spec.rb
+- spec/features/storing_files_spec.rb
+- spec/fixtures/image.png
+- spec/fixtures/text_file.txt
+- spec/neutrino/processing/nano_spec.rb
+- spec/neutrino/uploader_spec.rb
+- spec/neutrino_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sorentwo/neutrino
+licenses:
+- MIT
+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.0
+signing_key: 
+specification_version: 4
+summary: Neutrino is a ruby uploader library that embraces the spirit of CarrierWave,
+  but rejects many of the implementation details and magic. Neutrino's aim is to work
+  regardless of framework and with any persistence, storage, or processor.
+test_files:
+- spec/features/deleting_files_spec.rb
+- spec/features/processing_files_spec.rb
+- spec/features/storing_files_spec.rb
+- spec/fixtures/image.png
+- spec/fixtures/text_file.txt
+- spec/neutrino/processing/nano_spec.rb
+- spec/neutrino/uploader_spec.rb
+- spec/neutrino_spec.rb
+- spec/spec_helper.rb