fog-local 0.3.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0e0b4af75c75344097e40217e3f1ec9e84c3043d
-  data.tar.gz: 7d9e80f6f2e4ccc7f33d2fa2f5e51b700d4dfe0d
+SHA256:
+  metadata.gz: 5059e832e9d246d3d6248701810c868c1a7b4bc77b4446ccefa888f511c894f3
+  data.tar.gz: 8c5968aae7995ca18bac5d9caa7c8b384b9146e8e888206fec8fcafbfc76dd00
 SHA512:
-  metadata.gz: 4f32c1dc249f2bc2a88b9f631b9c65a39cf2752f2ab721a1424d9a683e77be4e9d30f7b43236fe55d27a6b92a4797d5d8911ff2728f3b5a1d0bb6af9537a5c78
-  data.tar.gz: 63f0bf2753a1d7ad7ee77cad0179768d6906bdbef7d6cc71b881aa3bb82a38eaf3c157f6aef373162cbc64e9c9b71e88e855109cf2ef357886ab80e9c47eabe3
+  metadata.gz: 8d8aaf3d6c71a320f62fbd5477459bf288a96ce0adbb2bc4137543ba612f58ee4bcdb1cbc31c43345eb08154f1f84b6fb54384579eeb195b5ce343b9e5a0a2c0
+  data.tar.gz: 1df8b44a820c6434bfc2ffaea43388ec38968cf5aabc81304b3a4bb45db7e540bdc8479760f8eba86e2cbfda255adc5ba4583219244f931ba46e6442cd108968

data/.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "bundler"
+    directory: "/"
+    schedule:
+      interval: "daily"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"

data/.github/workflows/ruby.yml

@@ -0,0 +1,34 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.5', '2.6', '2.7', '3.0', 'head']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      run: bundle exec rake

data/.github/workflows/stale.yml

@@ -0,0 +1,23 @@
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: "30 1 * * *"
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/stale@v3
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        days-before-stale: 60
+        days-before-close: 7
+        exempt-issue-labels: 'pinned,security'
+        exempt-pr-labels: 'pinned,security'
+        stale-issue-message: 'This issue has been marked inactive and will be closed if no further activity occurs.'
+        stale-pr-message: 'This pr has been marked inactive and will be closed if no further activity occurs.'
+        stale-issue-label: 'no-issue-activity'
+        stale-pr-label: 'no-pr-activity'

data/CONTRIBUTORS.md

@@ -16,3 +16,4 @@
 * James Herdman <james.herdman@me.com>
 * Adam Tanner <adam@adamtanner.org>
 * Mark Yen <marky@activestate.com>
+* Kevin Deisz <kevin.deisz@gmail.com>

data/README.md

@@ -22,27 +22,22 @@ Or install it yourself as:
 
 ## Usage
 
-Initialise a `Fog::Storage` object using local provider
+Initialise a `Fog::Local::Storage` object:
 
 ```ruby
-
-storage = Fog::Storage.new({
-  :local_root => '~/fog',
-  :provider   => 'Local'
-})
-
+storage = Fog::Local::Storage.new(local_root: '~/fog')
 ```
 
 This can then be used like any other [Fog storage](http://fog.io/storage/).
 
 ```ruby
-directory = storage.directories.create(:key => 'data')
-directory.files.create(:body => 'Hello World!', :key  => 'hello_world.txt')
+directory = storage.directories.create(key: 'data')
+directory.files.create(body: 'Hello World!', key: 'hello_world.txt')
 ```
 
 ## Contributing
 
-1. Fork it ( https://github.com/fog/fog-local/fork )
+1. Fork it ( https://github.com/fog/fog-local/fork)
 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`)

data/fog-local.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency 'bundler', '~> 1.7'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'shindo',  '~> 0.3'
 
-  spec.add_dependency 'fog-core',  '~> 1.27'
+  spec.add_dependency 'fog-core',  '>= 1.27', '< 3.0'
 end

data/lib/fog/bin/local.rb

@@ -3,7 +3,7 @@ class Local < Fog::Bin
     def class_for(key)
       case key
       when :storage
-        Fog::Storage::Local
+        Fog::Local::Storage
       else
         raise ArgumentError, "Unsupported #{self} service: #{key}"
       end
@@ -14,7 +14,7 @@ class Local < Fog::Bin
         hash[key] = case key
         when :storage
           Fog::Logger.warning("Local[:storage] is not recommended, use Storage[:local] for portability")
-          Fog::Storage.new(:provider => 'Local')
+          Fog::Local::Storage.new
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"
         end

data/lib/fog/local.rb

@@ -1,16 +1,16 @@
 require 'fog/core'
 require 'fileutils'
 require 'tempfile'
-require File.expand_path('../local/version', __FILE__)
 
-module Fog
-  module Storage
-    autoload :Local, File.expand_path('../storage/local', __FILE__)
-  end
+require 'fog/local/version'
 
+module Fog
   module Local
-    extend Fog::Provider
+    extend Provider
 
-    service(:storage, 'Storage')
+    autoload :Storage, 'fog/local/storage'
+    service :storage, :Storage
   end
 end
+
+Fog::Storage::Local = Fog::Local::Storage # legacy compat

data/lib/fog/{storage/local → local}/models/directories.rb

@@ -1,8 +1,8 @@
 module Fog
-  module Storage
-    class Local
+  module Local
+    class Storage
       class Directories < Fog::Collection
-        model Fog::Storage::Local::Directory
+        model Directory
 
         def all
           data = if ::File.directory?(service.local_root)
@@ -18,11 +18,13 @@ module Fog
         end
 
         def get(key, options = {})
-          if ::File.directory?(service.path_to(key))
-            new(:key => key)
-          else
-            nil
-          end
+          create_directory(key, options) if ::File.directory?(service.path_to(key))
+        end
+
+        private
+
+        def create_directory(key, options)
+          options[:path] ? new(key: key + options[:path]) : new(key: key)
         end
       end
     end

data/lib/fog/{storage/local → local}/models/directory.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Storage
-    class Local
+  module Local
+    class Storage
       class Directory < Fog::Model
         identity  :key
 
@@ -16,12 +16,7 @@ module Fog
         end
 
         def files
-          @files ||= begin
-            Fog::Storage::Local::Files.new(
-              :directory    => self,
-              :service   => service
-            )
-          end
+          @files ||= Files.new(directory: self, service: service)
         end
 
         def public=(new_public)

data/lib/fog/{storage/local → local}/models/file.rb

@@ -1,6 +1,6 @@
 module Fog
-  module Storage
-    class Local
+  module Local
+    class Storage
       class File < Fog::Model
         identity  :key,             :aliases => 'Key'
 
@@ -54,14 +54,7 @@ module Fog
             if dir_path == service.path_to(directory.key)
               break
             end
-            pwd = Dir.pwd
-            if ::File.directory?(dir_path)
-              Dir.chdir(dir_path)
-              if Dir.glob('*').empty?
-                Dir.rmdir(dir_path)
-              end
-              Dir.chdir(pwd)
-            end
+            rm_if_empty_dir(dir_path)
           end
           true
         end
@@ -74,8 +67,8 @@ module Fog
           requires :directory, :key
 
           if service.endpoint
-            escaped_directory = URI.escape(directory.key)
-            escaped_key = URI.escape(key)
+            escaped_directory = uri_escape(directory.key)
+            escaped_key = uri_escape(key)
 
             ::File.join(service.endpoint, escaped_directory, escaped_key)
           else
@@ -113,6 +106,12 @@ module Fog
           @directory = new_directory
         end
 
+        def uri_escape(string)
+          string.b.gsub(/([^a-zA-Z0-9_.\-~]+)/) do |m|
+            '%' + m.unpack('H2' * m.bytesize).join('%').upcase
+          end
+        end
+
         def path
           service.path_to(::File.join(directory.key, key))
         end
@@ -125,6 +124,22 @@ module Fog
             IO.copy_stream(input_io, file)
           end
         end
+
+        def rm_if_empty_dir(dir_path)
+          if ::File.directory?(dir_path)
+            Dir.rmdir(dir_path) if dir_empty?(dir_path)
+          end
+        end
+
+        def dir_empty?(dir_path)
+          # NOTE: There’s Dir.empty?, but it is only available on Ruby 2.4+
+
+          # NOTE: `entries` will be empty on Windows, and contain . and .. on
+          # unix-like systems (macOS, Linux, BSD, …)
+
+          entries = Dir.entries(dir_path)
+          entries.empty? || entries.all? { |e| ['.', '..'].include?(e) }
+        end
       end
     end
   end

data/lib/fog/{storage/local → local}/models/files.rb

@@ -1,10 +1,10 @@
 module Fog
-  module Storage
-    class Local
+  module Local
+    class Storage
       class Files < Fog::Collection
         attribute :directory
 
-        model Fog::Storage::Local::File
+        model File
 
         def all
           requires :directory
@@ -71,6 +71,10 @@ module Fog
           super({ :directory => directory }.merge!(attributes))
         end
 
+        def is_truncated
+          false
+        end
+
         private
 
         def file_path(key)

data/lib/fog/local/storage.rb

@@ -1 +1,98 @@
-# This file was intentionally left blank
+module Fog
+  module Local
+    class Storage < Fog::Service
+      autoload :Directories, 'fog/local/models/directories'
+      autoload :Directory, 'fog/local/models/directory'
+      autoload :File, 'fog/local/models/file'
+      autoload :Files, 'fog/local/models/files'
+
+      requires :local_root
+      recognizes :endpoint, :scheme, :host, :port, :path
+
+      model_path 'fog/local/models'
+      collection  :directories
+      model       :directory
+      model       :file
+      collection  :files
+
+      require 'uri'
+
+      class Mock
+        attr_reader :endpoint
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+
+          @local_root = ::File.expand_path(options[:local_root])
+
+          @endpoint = options[:endpoint] || build_endpoint_from_options(options)
+        end
+
+        def data
+          self.class.data[@local_root]
+        end
+
+        def local_root
+          @local_root
+        end
+
+        def path_to(partial)
+          ::File.join(@local_root, partial)
+        end
+
+        def reset_data
+          self.class.data.delete(@local_root)
+        end
+
+        private
+        def build_endpoint_from_options(options)
+          return unless options[:host]
+
+          URI::Generic.build(options).to_s
+        end
+      end
+
+      class Real
+        attr_reader :endpoint
+
+        def initialize(options={})
+          @local_root = ::File.expand_path(options[:local_root])
+
+          @endpoint = options[:endpoint] || build_endpoint_from_options(options)
+        end
+
+        def local_root
+          @local_root
+        end
+
+        def path_to(partial)
+          ::File.join(@local_root, partial)
+        end
+
+        def copy_object(source_directory_name, source_object_name, target_directory_name, target_object_name, options={})
+          source_path = path_to(::File.join(source_directory_name, source_object_name))
+          target_path = path_to(::File.join(target_directory_name, target_object_name))
+          ::FileUtils.mkdir_p(::File.dirname(target_path))
+          ::FileUtils.copy_file(source_path, target_path)
+        end
+
+        private
+        def build_endpoint_from_options(options)
+          return unless options[:host]
+
+          URI::Generic.build(options).to_s
+        end
+      end
+    end
+  end
+end

data/lib/fog/local/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Local
-    VERSION = '0.3.1'
+    VERSION = '0.7.0'
   end
 end

data/tests/helper.rb

@@ -5,7 +5,8 @@ rescue LoadError => e
   $stderr.puts "not recording test coverage: #{e.inspect}"
 end
 
-require File.expand_path('../../lib/fog/local', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'fog/local'
 
 Bundler.require(:test)
 require 'tmpdir'

data/tests/helpers/succeeds_helper.rb

@@ -1,8 +1,8 @@
 module Shindo
   class Tests
-    def succeeds
+    def succeeds(&block)
       test('succeeds') do
-        !!instance_eval(&Proc.new)
+        !!instance_eval(&block)
       end
     end
   end

data/tests/local/models/directories_tests.rb

@@ -3,7 +3,7 @@ Shindo.tests('Storage[:local] | directories', ["local"]) do
   pending if Fog.mocking?
 
   @options = { :local_root => Dir.mktmpdir('fog-tests') }
-  @collection = Fog::Storage::Local.new(@options).directories
+  @collection = Fog::Local::Storage.new(@options).directories
 
   collection_tests(@collection, {:key => "fogdirtests"}, true)
 

data/tests/local/models/directory_tests.rb

@@ -12,7 +12,7 @@ Shindo.tests('Storage[:local] | directory', ["local"]) do
 
   tests('save') do
     returns('directory') do
-      connection = Fog::Storage::Local.new(@options)
+      connection = Fog::Local::Storage.new(@options)
       connection.directories.create(:key => 'directory')
       connection.directories.create(:key => 'directory').key
     end

data/tests/local/models/file_tests.rb

@@ -15,7 +15,7 @@ Shindo.tests('Storage[:local] | file', ["local"]) do
       returns('http://example.com/files/directory/file.txt') do
         @options[:endpoint] = 'http://example.com/files'
 
-        connection = Fog::Storage::Local.new(@options)
+        connection = Fog::Local::Storage.new(@options)
         directory = connection.directories.new(:key => 'directory')
         file = directory.files.new(:key => 'file.txt')
 
@@ -26,7 +26,7 @@ Shindo.tests('Storage[:local] | file', ["local"]) do
       returns(nil) do
         @options[:endpoint] = nil
 
-        connection = Fog::Storage::Local.new(@options)
+        connection = Fog::Local::Storage.new(@options)
         directory = connection.directories.new(:key => 'directory')
         file = directory.files.new(:key => 'file.txt')
 
@@ -37,7 +37,7 @@ Shindo.tests('Storage[:local] | file', ["local"]) do
       returns('http://example.com/files/my%20directory/my%20file.txt') do
         @options[:endpoint] = 'http://example.com/files'
 
-        connection = Fog::Storage::Local.new(@options)
+        connection = Fog::Local::Storage.new(@options)
         directory = connection.directories.new(:key => 'my directory')
         file = directory.files.new(:key => 'my file.txt')
 
@@ -48,7 +48,7 @@ Shindo.tests('Storage[:local] | file', ["local"]) do
   tests('#save') do
     tests('creates non-existent subdirs') do
       returns(true) do
-        connection = Fog::Storage::Local.new(@options)
+        connection = Fog::Local::Storage.new(@options)
         directory = connection.directories.new(:key => 'path1')
         file = directory.files.new(:key => 'path2/file.rb', :body => "my contents")
         file.save
@@ -57,7 +57,7 @@ Shindo.tests('Storage[:local] | file', ["local"]) do
     end
 
     tests('with tempfile').returns('tempfile') do
-      connection = Fog::Storage::Local.new(@options)
+      connection = Fog::Local::Storage.new(@options)
       directory = connection.directories.create(:key => 'directory')
 
       tempfile = Tempfile.new(['file', '.txt'])
@@ -76,4 +76,69 @@ Shindo.tests('Storage[:local] | file', ["local"]) do
       directory.files.get('tempfile.txt').body
     end
   end
+
+  tests('#destroy') do
+    # - removes dir if it contains no files
+    # - keeps dir if it contains non-hidden files
+    # - keeps dir if it contains hidden files
+    # - stays in the same directory
+
+    tests('removes enclosing dir if it is empty') do
+      returns(false) do
+        connection = Fog::Local::Storage.new(@options)
+        directory = connection.directories.new(:key => 'path1')
+
+        file = directory.files.new(:key => 'path2/file.rb', :body => "my contents")
+        file.save
+        file.destroy
+
+        File.exists?(@options[:local_root] + "/path1/path2")
+      end
+    end
+
+    tests('keeps enclosing dir if it is not empty') do
+      returns(true) do
+        connection = Fog::Local::Storage.new(@options)
+        directory = connection.directories.new(:key => 'path1')
+
+        file = directory.files.new(:key => 'path2/file.rb', :body => "my contents")
+        file.save
+
+        file = directory.files.new(:key => 'path2/file2.rb', :body => "my contents")
+        file.save
+        file.destroy
+
+        File.exists?(@options[:local_root] + "/path1/path2")
+      end
+    end
+
+    tests('keeps enclosing dir if contains only hidden files') do
+      returns(true) do
+        connection = Fog::Local::Storage.new(@options)
+        directory = connection.directories.new(:key => 'path1')
+
+        file = directory.files.new(:key => 'path2/.file.rb', :body => "my contents")
+        file.save
+
+        file = directory.files.new(:key => 'path2/.file2.rb', :body => "my contents")
+        file.save
+        file.destroy
+
+        File.exists?(@options[:local_root] + "/path1/path2")
+      end
+    end
+
+    tests('it stays in the same directory') do
+      returns(Dir.pwd) do
+        connection = Fog::Local::Storage.new(@options)
+        directory = connection.directories.new(:key => 'path1')
+
+        file = directory.files.new(:key => 'path2/file2.rb', :body => "my contents")
+        file.save
+        file.destroy
+
+        Dir.pwd
+      end
+    end
+  end
 end

data/tests/local/models/files_tests.rb

@@ -0,0 +1,21 @@
+Shindo.tests('Storage[:local] | files', ["local"]) do
+
+  pending if Fog.mocking?
+
+  before do
+    @options = { :local_root => Dir.mktmpdir('fog-tests') }
+  end
+
+  after do
+    FileUtils.remove_entry_secure(@options[:local_root]) if File.directory?(@options[:local_root])
+  end
+
+  tests("#is_truncated") do
+    returns(false) do
+      connection = Fog::Local::Storage.new(@options)
+      directory = connection.directories.create(:key => 'directory')
+      collection = directory.files
+      collection.is_truncated
+    end
+  end
+end

data/tests/local/storage_tests.rb

@@ -13,7 +13,7 @@ Shindo.tests('Local | storage') do
   tests('#endpoint') do
     tests('when no endpoint is provided').
       returns(nil) do
-        Fog::Storage::Local.new(@options).endpoint
+        Fog::Local::Storage.new(@options).endpoint
       end
 
     tests('when no host is provided').
@@ -22,14 +22,14 @@ Shindo.tests('Local | storage') do
         @options[:path] = '/files'
         @options[:port] = 80
 
-        Fog::Storage::Local.new(@options).endpoint
+        Fog::Local::Storage.new(@options).endpoint
       end
 
     tests('when endpoint is provided').
       returns('http://example.com/files') do
         @options[:endpoint] = 'http://example.com/files'
 
-        Fog::Storage::Local.new(@options).endpoint
+        Fog::Local::Storage.new(@options).endpoint
       end
 
     tests('when at least host option is provided').
@@ -38,7 +38,7 @@ Shindo.tests('Local | storage') do
         @options[:host] = 'example.com'
         @options[:path] = '/files'
 
-        Fog::Storage::Local.new(@options).endpoint
+        Fog::Local::Storage.new(@options).endpoint
       end
   end
 end

metadata

@@ -1,44 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: fog-local
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Wesley Beary
 - Ville Lautanala
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-10-24 00:00:00.000000000 Z
+date: 2021-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: shindo
   requirement: !ruby/object:Gem::Requirement
@@ -57,16 +57,22 @@ dependencies:
   name: fog-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.27'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.27'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: |-
   This library can be used as a module for `fog` or as standalone provider
                          to use local filesystem storage.
@@ -77,10 +83,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
+- ".github/workflows/ruby.yml"
+- ".github/workflows/stale.yml"
 - ".gitignore"
 - ".ruby-gemset"
-- ".ruby-version"
-- ".travis.yml"
 - CONTRIBUTING.md
 - CONTRIBUTORS.md
 - Gemfile
@@ -90,31 +97,28 @@ files:
 - fog-local.gemspec
 - lib/fog/bin/local.rb
 - lib/fog/local.rb
+- lib/fog/local/models/directories.rb
+- lib/fog/local/models/directory.rb
+- lib/fog/local/models/file.rb
+- lib/fog/local/models/files.rb
 - lib/fog/local/storage.rb
 - lib/fog/local/version.rb
-- lib/fog/storage/local.rb
-- lib/fog/storage/local/models/directories.rb
-- lib/fog/storage/local/models/directory.rb
-- lib/fog/storage/local/models/file.rb
-- lib/fog/storage/local/models/files.rb
 - tests/helper.rb
 - tests/helpers/collection_helper.rb
-- tests/helpers/formats_helper.rb
-- tests/helpers/formats_helper_tests.rb
 - tests/helpers/mock_helper.rb
 - tests/helpers/model_helper.rb
-- tests/helpers/schema_validator_tests.rb
 - tests/helpers/succeeds_helper.rb
 - tests/local/models/directories_tests.rb
 - tests/local/models/directory_tests.rb
 - tests/local/models/file_tests.rb
+- tests/local/models/files_tests.rb
 - tests/local/storage_tests.rb
 - tests/watchr.rb
 homepage: https://github.com/fog/fog-local
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -129,9 +133,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Module for the 'fog' gem to support local filesystem storage.
 test_files: []

data/.ruby-version

@@ -1 +0,0 @@
-2.2.0

data/.travis.yml

@@ -1,14 +0,0 @@
-language: ruby
-sudo: false
-script: bundle exec rake test
-rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.10
-  - 2.2.5
-  - 2.3.1
-  - jruby-19mode
-  - jruby-9.0.5.0
-env:
-  - FOG_MOCK=true
-  - FOG_MOCK=false

data/lib/fog/storage/local.rb

@@ -1,98 +0,0 @@
-module Fog
-  module Storage
-    class Local < Fog::Service
-      autoload :Directories, ::File.expand_path('../local/models/directories', __FILE__)
-      autoload :Directory, ::File.expand_path('../local/models/directory', __FILE__)
-      autoload :File, ::File.expand_path('../local/models/file', __FILE__)
-      autoload :Files, ::File.expand_path('../local/models/files', __FILE__)
-
-      requires :local_root
-      recognizes :endpoint, :scheme, :host, :port, :path
-
-      model_path 'fog/storage/local/models'
-      collection  :directories
-      model       :directory
-      model       :file
-      collection  :files
-
-      require 'uri'
-
-      class Mock
-        attr_reader :endpoint
-
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          Fog::Mock.not_implemented
-
-          @local_root = ::File.expand_path(options[:local_root])
-
-          @endpoint = options[:endpoint] || build_endpoint_from_options(options)
-        end
-
-        def data
-          self.class.data[@local_root]
-        end
-
-        def local_root
-          @local_root
-        end
-
-        def path_to(partial)
-          ::File.join(@local_root, partial)
-        end
-
-        def reset_data
-          self.class.data.delete(@local_root)
-        end
-
-        private
-        def build_endpoint_from_options(options)
-          return unless options[:host]
-
-          URI::Generic.build(options).to_s
-        end
-      end
-
-      class Real
-        attr_reader :endpoint
-
-        def initialize(options={})
-          @local_root = ::File.expand_path(options[:local_root])
-
-          @endpoint = options[:endpoint] || build_endpoint_from_options(options)
-        end
-
-        def local_root
-          @local_root
-        end
-
-        def path_to(partial)
-          ::File.join(@local_root, partial)
-        end
-
-        def copy_object(source_directory_name, source_object_name, target_directory_name, target_object_name, options={})
-          source_path = path_to(::File.join(source_directory_name, source_object_name))
-          target_path = path_to(::File.join(target_directory_name, target_object_name))
-          ::FileUtils.mkdir_p(::File.dirname(target_path))
-          ::FileUtils.copy_file(source_path, target_path)
-        end
-
-        private
-        def build_endpoint_from_options(options)
-          return unless options[:host]
-
-          URI::Generic.build(options).to_s
-        end
-      end
-    end
-  end
-end

data/tests/helpers/formats_helper.rb

@@ -1,98 +0,0 @@
-require "fog/schema/data_validator"
-
-# format related hackery
-# allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
-# allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String)
-module Fog
-  module Boolean; end
-  module Nullable
-    module Boolean; end
-    module Integer; end
-    module String; end
-    module Time; end
-    module Float; end
-    module Hash; end
-    module Array; end
-  end
-end
-[FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)}
-[FalseClass, TrueClass, NilClass, Fog::Boolean].each {|klass| klass.send(:include, Fog::Nullable::Boolean)}
-[NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)}
-[NilClass, Time].each {|klass| klass.send(:include, Fog::Nullable::Time)}
-[Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)}
-[Float, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Float)}
-[Hash, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Hash)}
-[Array, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Array)}
-
-module Shindo
-  class Tests
-    # Generates a Shindo test that compares a hash schema to the result
-    # of the passed in block returning true if they match.
-    #
-    # The schema that is passed in is a Hash or Array of hashes that
-    # have Classes in place of values. When checking the schema the
-    # value should match the Class.
-    #
-    # Strict mode will fail if the data has additional keys. Setting
-    # +strict+ to +false+ will allow additional keys to appear.
-    #
-    # @param [Hash] schema A Hash schema
-    # @param [Hash] options Options to change validation rules
-    # @option options [Boolean] :allow_extra_keys
-    #     If +true+ does not fail when keys are in the data that are
-    #     not specified in the schema. This allows new values to
-    #     appear in API output without breaking the check.
-    # @option options [Boolean] :allow_optional_rules
-    #     If +true+ does not fail if extra keys are in the schema
-    #     that do not match the data. Not recommended!
-    # @yield Data to check with schema
-    #
-    # @example Using in a test
-    #     Shindo.tests("comparing welcome data against schema") do
-    #       data = {:welcome => "Hello" }
-    #       data_matches_schema(:welcome => String) { data }
-    #     end
-    #
-    #     comparing welcome data against schema
-    #     + data matches schema
-    #
-    # @example Example schema
-    #     {
-    #       "id" => String,
-    #       "ram" => Integer,
-    #       "disks" => [
-    #         {
-    #           "size" => Float
-    #         }
-    #       ],
-    #       "dns_name" => Fog::Nullable::String,
-    #       "active" => Fog::Boolean,
-    #       "created" => DateTime
-    #     }
-    #
-    # @return [Boolean]
-    def data_matches_schema(schema, options = {})
-      test('data matches schema') do
-        validator = Fog::Schema::DataValidator.new
-        valid = validator.validate(yield, schema, options)
-        @message = validator.message unless valid
-        valid
-      end
-    end
-
-    # @deprecated #formats is deprecated. Use #data_matches_schema instead
-    def formats(format, strict = true)
-      test('has proper format') do
-        if strict
-          options = {:allow_extra_keys => false, :allow_optional_rules => true}
-        else
-          options = {:allow_extra_keys => true, :allow_optional_rules => true}
-        end
-        validator = Fog::Schema::DataValidator.new
-        valid = validator.validate(yield, format, options)
-        @message = validator.message unless valid
-        valid
-      end
-    end
-  end
-end

data/tests/helpers/formats_helper_tests.rb

@@ -1,110 +0,0 @@
-Shindo.tests('test_helper', 'meta') do
-
-  tests('comparing welcome data against schema') do
-    data = {:welcome => "Hello" }
-    data_matches_schema(:welcome => String) { data }
-  end
-
-  tests('#data_matches_schema') do
-    tests('when value matches schema expectation') do
-      data_matches_schema({"key" => String}) { {"key" => "Value"} }
-    end
-
-    tests('when values within an array all match schema expectation') do
-      data_matches_schema({"key" => [Integer]}) { {"key" => [1, 2]} }
-    end
-
-    tests('when nested values match schema expectation') do
-      data_matches_schema({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} }
-    end
-
-    tests('when collection of values all match schema expectation') do
-      data_matches_schema([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] }
-    end
-
-    tests('when collection is empty although schema covers optional members') do
-      data_matches_schema([{"key" => String}], {:allow_optional_rules => true}) { [] }
-    end
-
-    tests('when additional keys are passed and not strict') do
-      data_matches_schema({"key" => String}, {:allow_extra_keys => true}) { {"key" => "Value", :extra => "Bonus"} }
-    end
-
-    tests('when value is nil and schema expects NilClass') do
-      data_matches_schema({"key" => NilClass}) { {"key" => nil} }
-    end
-
-    tests('when value and schema match as hashes') do
-      data_matches_schema({}) { {} }
-    end
-
-    tests('when value and schema match as arrays') do
-      data_matches_schema([]) { [] }
-    end
-
-    tests('when value is a Time') do
-      data_matches_schema({"time" => Time}) { {"time" => Time.now} }
-    end
-
-    tests('when key is missing but value should be NilClass (#1477)') do
-      data_matches_schema({"key" => NilClass}, {:allow_optional_rules => true}) { {} }
-    end
-
-    tests('when key is missing but value is nullable (#1477)') do
-      data_matches_schema({"key" => Fog::Nullable::String}, {:allow_optional_rules => true}) { {} }
-    end
-  end
-
-  tests('#formats backwards compatible changes') do
-
-    tests('when value matches schema expectation') do
-      formats({"key" => String}) { {"key" => "Value"} }
-    end
-
-    tests('when values within an array all match schema expectation') do
-      formats({"key" => [Integer]}) { {"key" => [1, 2]} }
-    end
-
-    tests('when nested values match schema expectation') do
-      formats({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} }
-    end
-
-    tests('when collection of values all match schema expectation') do
-      formats([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] }
-    end
-
-    tests('when collection is empty although schema covers optional members') do
-      formats([{"key" => String}]) { [] }
-    end
-
-    tests('when additional keys are passed and not strict') do
-      formats({"key" => String}, false) { {"key" => "Value", :extra => "Bonus"} }
-    end
-
-    tests('when value is nil and schema expects NilClass') do
-      formats({"key" => NilClass}) { {"key" => nil} }
-    end
-
-    tests('when value and schema match as hashes') do
-      formats({}) { {} }
-    end
-
-    tests('when value and schema match as arrays') do
-      formats([]) { [] }
-    end
-
-    tests('when value is a Time') do
-      formats({"time" => Time}) { {"time" => Time.now} }
-    end
-
-    tests('when key is missing but value should be NilClass (#1477)') do
-      formats({"key" => NilClass}) { {} }
-    end
-
-    tests('when key is missing but value is nullable (#1477)') do
-      formats({"key" => Fog::Nullable::String}) { {} }
-    end
-
-  end
-
-end

data/tests/helpers/schema_validator_tests.rb

@@ -1,107 +0,0 @@
-Shindo.tests('Fog::Schema::DataValidator', 'meta') do
-
-  validator = Fog::Schema::DataValidator.new
-
-  tests('#validate') do
-
-    tests('returns true') do
-
-      returns(true, 'when value matches schema expectation') do
-        validator.validate({"key" => "Value"}, {"key" => String})
-      end
-
-      returns(true, 'when values within an array all match schema expectation') do
-        validator.validate({"key" => [1, 2]}, {"key" => [Integer]})
-      end
-
-      returns(true, 'when nested values match schema expectation') do
-        validator.validate({"key" => {:nested_key => "Value"}}, {"key" => {:nested_key => String}})
-      end
-
-      returns(true, 'when collection of values all match schema expectation') do
-        validator.validate([{"key" => "Value"}, {"key" => "Value"}], [{"key" => String}])
-      end
-
-      returns(true, 'when collection is empty although schema covers optional members') do
-        validator.validate([], [{"key" => String}])
-      end
-
-      returns(true, 'when additional keys are passed and not strict') do
-        validator.validate({"key" => "Value", :extra => "Bonus"}, {"key" => String}, {:allow_extra_keys => true})
-      end
-
-      returns(true, 'when value is nil and schema expects NilClass') do
-        validator.validate({"key" => nil}, {"key" => NilClass})
-      end
-
-      returns(true, 'when value and schema match as hashes') do
-        validator.validate({}, {})
-      end
-
-      returns(true, 'when value and schema match as arrays') do
-        validator.validate([], [])
-      end
-
-      returns(true, 'when value is a Time') do
-        validator.validate({"time" => Time.now}, {"time" => Time})
-      end
-
-      returns(true, 'when key is missing but value should be NilClass (#1477)') do
-        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => true})
-      end
-
-      returns(true, 'when key is missing but value is nullable (#1477)') do
-        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => true})
-      end
-
-    end
-
-    tests('returns false') do
-
-      returns(false, 'when value does not match schema expectation') do
-        validator.validate({"key" => nil}, {"key" => String})
-      end
-
-      returns(false, 'when key formats do not match') do
-        validator.validate({"key" => "Value"}, {:key => String})
-      end
-
-      returns(false, 'when additional keys are passed and strict') do
-        validator.validate({"key" => "Missing"}, {})
-      end
-
-      returns(false, 'when some keys do not appear') do
-        validator.validate({}, {"key" => String})
-      end
-
-      returns(false, 'when collection contains a member that does not match schema') do
-        validator.validate([{"key" => "Value"}, {"key" => 5}], [{"key" => String}])
-      end
-
-      returns(false, 'when collection has multiple schema patterns') do
-        validator.validate([{"key" => "Value"}], [{"key" => Integer}, {"key" => String}])
-      end
-
-      returns(false, 'when hash and array are compared') do
-        validator.validate({}, [])
-      end
-
-      returns(false, 'when array and hash are compared') do
-        validator.validate([], {})
-      end
-
-      returns(false, 'when a hash is expected but another data type is found') do
-        validator.validate({"key" => {:nested_key => []}}, {"key" => {:nested_key => {}}})
-      end
-
-      returns(false, 'when key is missing but value should be NilClass (#1477)') do
-        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => false})
-      end
-
-      returns(false, 'when key is missing but value is nullable (#1477)') do
-        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => false})
-      end
-
-    end
-  end
-end