fog-local 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e0b4af75c75344097e40217e3f1ec9e84c3043d
-  data.tar.gz: 7d9e80f6f2e4ccc7f33d2fa2f5e51b700d4dfe0d
+  metadata.gz: 2f8d4c17d2d000539b8dad9be95d8495556d6868
+  data.tar.gz: 22616d1b9f12d284cdd10e396ce87596c14082e1
 SHA512:
-  metadata.gz: 4f32c1dc249f2bc2a88b9f631b9c65a39cf2752f2ab721a1424d9a683e77be4e9d30f7b43236fe55d27a6b92a4797d5d8911ff2728f3b5a1d0bb6af9537a5c78
-  data.tar.gz: 63f0bf2753a1d7ad7ee77cad0179768d6906bdbef7d6cc71b881aa3bb82a38eaf3c157f6aef373162cbc64e9c9b71e88e855109cf2ef357886ab80e9c47eabe3
+  metadata.gz: e18eadc38367b13c82ce00b4fac8b8619d877417f8f976f9a2ff755eb33bf30e15c27f2327ba408532ed73acf700aa2dda6012de7cf0dfd9fee8b025f2b52f1c
+  data.tar.gz: f89a42302dc3b2806d9e0f773f62a6bd64219d3df4e728ed7fc451590734e4bd8a31b9e9c8f9d671b0ea0c903093138c43db4e5f363f70db51642e705fbe83ec

data/.travis.yml

@@ -5,10 +5,11 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.10
-  - 2.2.5
-  - 2.3.1
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
   - jruby-19mode
-  - jruby-9.0.5.0
+  - jruby-9.1.7.0
 env:
   - FOG_MOCK=true
   - FOG_MOCK=false

data/lib/fog/local/version.rb

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

data/lib/fog/storage/local/models/directories.rb

@@ -18,11 +18,12 @@ 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fog-local
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Wesley Beary
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-24 00:00:00.000000000 Z
+date: 2017-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,11 +99,8 @@ files:
 - 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
@@ -130,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Module for the 'fog' gem to support local filesystem storage.

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