tmp 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 483eb950ab983710d8486dda03faa403671d3b68
-  data.tar.gz: a8028f1d1e5c48228216b3492376fdb209a54b55
+  metadata.gz: b63871da5854ee49651dc7047a3b727bb6f0bb35
+  data.tar.gz: 20264ee3627c2290530ac350b7c1b85e810ddb88
 SHA512:
-  metadata.gz: 453c5af9abca249cc6a9a6045b980a1dc5a4ca7637ebdd614ef7718903c6e37838be55322215d180fa139d3a015f1f96e259c923f8d34146e5506ec6230fe2dd
-  data.tar.gz: 8585bdb016f1ec0e4a5e572e96a22cc732e5079701154f13ae775a57ca085d89948c2e3630618904eda9e67d43a4a7bb51f7f44d3178a8cf7f94fe58616c8384
+  metadata.gz: ec4c05025a24207e28dd220ca8984d34079268b3eb31445476e020a0fb41a2f99f3e7d14c8b14af8de2b2899f3d09273737e872f30f4d440e4c0c080343a16c1
+  data.tar.gz: a23973ca4932fbd7f7e0d792da7b2c1dac40f180bea277bef4c33675afbedecdd15c1cad6ba45e637566ab6e0a9436cba55bf8f1e64b8118207f9ac2ce172c30

data/.gitignore

@@ -7,9 +7,6 @@
 /InstalledFiles
 /pkg/
 /spec/reports/
-/test/tmp/
-/test/version_tmp/
-/tmp/
 
 ## Specific to RubyMotion:
 .dat*

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tmp (4.0.0.alpha)
+    tmp (4.0.0)
 
 GEM
   remote: http://rubygems.org/

data/VERSION

@@ -1 +1 @@
-4.0.0
+4.1.0

data/lib/tmp/deprecated/core.rb

@@ -0,0 +1,186 @@
+#encoding: UTF-8
+module TMP
+
+  module CORE
+
+    def project_name name_string= nil
+
+      unless name_string.nil?
+
+        unless name_string.class <= String
+          raise ArgumentError,"invalid name string"
+        end
+
+        @project_name = name_string
+
+      end
+
+      @project_name || Dir.pwd.split(File::Separator).last.to_s
+
+    end
+
+    alias :project_folder :project_name
+
+    def tmpdir
+      ::Dir.tmpdir
+    end
+
+    def default_folder_path
+      File.join( tmpdir , project_name )
+    end
+
+    @folder_path= nil
+    def tmp_folder_path path_string= nil
+
+      $stderr.puts('warning this is deprecated, will be removed in the further releases!(tmp gem)')
+
+      unless path_string.nil?
+
+        unless path_string.class <= String
+          raise ArgumentError,"invalid path class, must be string like"
+        end
+
+        @folder_path = File.absolute_path(path_string)
+
+      end
+
+      @folder_path || default_folder_path
+
+    end
+
+    alias :folder_path :tmp_folder_path
+
+    def tmp_folder_init
+
+      begin
+
+        Dir.mkdir tmp_folder_path
+        return true
+
+      rescue Errno::EEXIST
+        return false
+      end
+
+    end
+
+    alias :folder_init :tmp_folder_init
+
+    def write variable_name, data_object
+
+      $stderr.puts('warning this is deprecated, will be removed in the further releases!(tmp gem)')
+
+      tmp_folder_init
+
+      File.open( File.join(tmp_folder_path,variable_name.to_s) ,"w") do |file|
+        return file.write ::Marshal.dump(data_object)
+      end
+
+    end
+
+    def block variable_name, *args, &block_obj
+
+      $stderr.puts('warning this is deprecated, will be removed in the further releases!(tmp gem)')
+
+      tmp_folder_init
+
+      options = args.select{|e|(e.class <= ::Hash)}.reduce({},:merge!)
+      args.select!{|e|!(e.class <= ::Hash)}
+
+      options[:file_extension] ||= options[:extension] || options[:ext]
+      file_name = variable_name.to_s
+      options[:file_mod] ||= options[:mod] || args[0].class <= ::String ? args[0] : nil
+
+      unless options[:file_extension].nil?
+
+        while options[:file_extension][0] == '.'
+          options[:file_extension][0]= ''
+        end
+
+        file_name += ".#{options[:file_extension]}"
+
+      end
+
+      if File.exist?(File.join( tmp_folder_path, file_name ))
+        options[:file_mod] ||= "r+"
+      else
+        options[:file_mod] ||= "w+"
+      end
+
+      begin
+        return File.open( File.join( tmp_folder_path, file_name ), options[:file_mod], &block_obj )
+      rescue Errno::ENOENT
+        var_file= File.new( File.join( tmp_folder_path, file_name ), options[:file_mod])
+        block_obj.call(var_file) unless block_obj.nil?
+        var_file.close
+      end
+
+    end
+
+    def read variable_name
+
+      $stderr.puts('warning this is deprecated, will be removed in the further releases!(tmp gem)')
+
+      unless File.exist?(File.join( tmp_folder_path,variable_name.to_s))
+        return nil
+      end
+
+      File.open( File.join( tmp_folder_path,variable_name.to_s ) ,"r+") do |file|
+
+        var= file.read
+        begin
+          return ::Marshal.load var
+        rescue
+          return var
+        end
+
+      end
+
+    end
+
+    def path variable_name,*args
+
+      $stderr.puts('warning this is deprecated, will be removed in the further releases!(tmp gem)')
+
+      options = args.select{|e|(e.class <= ::Hash)}.reduce({},:merge!)
+      args.select!{|e|!(e.class <= ::Hash)}
+
+      variable_name = variable_name.to_s
+      options[:file_extension] ||= options[:extension] || options[:ext]
+      unless options[:file_extension].nil?
+        while options[:file_extension][0] == '.'
+          options[:file_extension][0]= ''
+        end
+        variable_name += ".#{options[:file_extension]}"
+      end
+
+      tmp_folder_init
+      path_to_file= File.join( tmp_folder_path, variable_name )
+      unless File.exist?(path_to_file)
+        File.open( path_to_file ,"w") {|f| f.write(""); f.close }
+      end
+      return path_to_file
+
+    end
+
+    def purge_files
+
+      Dir.glob( File.join( tmp_folder_path,'**','*' ) ).map do |file_path|
+
+        begin
+          File.delete file_path
+        rescue Errno::ENOENT => ex
+          ex
+        end
+
+      end
+
+    end
+
+    alias :purge! :purge_files
+    alias :purge  :purge_files
+
+  end
+
+  extend CORE
+
+end

data/lib/tmp/deprecated/dci.rb

@@ -0,0 +1,3 @@
+module TMP::DCI
+  require 'tmp/dci/syntax_sugar'
+end

data/lib/tmp/deprecated/dsl.rb

@@ -0,0 +1,62 @@
+#encoding: UTF-8
+module TMP
+
+  module DSLCore
+
+    def target_obj obj=nil
+
+      @target_obj= obj unless obj.nil?
+      @target_obj || ::TMP
+
+    end
+
+    def method_missing( method, *args, &block )
+
+      if method.to_s.reverse[0] == '='
+
+        target_obj.__send__ :write, method.to_s.reverse.sub('=','').reverse, args.first
+        return args.first
+
+      else
+
+        unless block.nil?
+
+          return target_obj.__send__ :block, method, *args, &block
+
+        else
+
+          if method =~ /^\w+__path__$/
+            return target_obj.__send__ :path, method.to_s.sub!( /__path__$/,"" ),*args
+          else
+            return target_obj.__send__ :read, method
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+  module DSL
+
+    extend ObjectExt
+    extend DSLCore
+    privatize
+
+  end
+
+  module SyntaxSugar
+
+    def __tmp__
+      ::TMP::DSL
+    end
+
+    alias :__TMP__  :__tmp__
+
+  end
+
+end
+
+Object.__send__ :include, ::TMP::SyntaxSugar

data/lib/tmp/deprecated/init.rb

@@ -0,0 +1,49 @@
+#encoding: UTF-8
+module TMP
+
+  class InstanceCore
+
+    include CORE
+
+    def initialize path_string
+
+      unless path_string.class <= String
+        raise ArgumentError, "path must be a string like type"
+      end
+
+      folder_path path_string
+
+    end
+
+  end
+
+  class InstanceDSL
+
+    extend ObjectExt
+    include DSLCore
+
+    def initialize path_string
+      target_obj InstanceCore.new( path_string )
+    end
+
+    privatize t: 'instance'
+
+    public
+
+
+    def tmp_class_instance_object
+      target_obj
+    end
+
+  end
+
+  class << self
+
+    def new *args
+      InstanceDSL.new *args
+    end
+    alias :init :new
+
+  end
+
+end

data/lib/tmp/deprecated/sup.rb

@@ -0,0 +1,92 @@
+#encoding: UTF-8
+module TMP
+
+  module ObjectExt
+
+    def privatize opts= {}
+
+      unless opts.class <= Hash
+        raise ArgumentError,"invalid input for options"
+      end
+
+      %W[ e ex exc ].each do |str_sym|
+        opts[:exclude] ||= opts[str_sym.to_sym]
+      end
+
+      %W[ i in inc only methods ].each do |str_sym|
+        opts[:include] ||= opts[str_sym.to_sym]
+      end
+
+      %W[ t target ].each do |str_sym|
+        opts[:target] ||= opts[str_sym.to_sym]
+      end
+
+      opts[:target] ||= 's'
+      opts[:target]= opts[:target].to_s.downcase
+
+      unless opts[:target][0] == "s" || opts[:target][0] == "i"
+        %W[ singleton instance ].include?(opts[:target].to_s)
+        raise ArgumentError, [
+            "invalid options for target, you should use the following: ",
+            "\n\tsingleton for targeting the singleton class what is de",
+            "fault\n\tinstance for targeting the object instance methods."
+        ].join
+      end
+
+      opts[:exclude] ||= []
+
+      if opts[:target][0] == 'i' && self.class <= Module
+        opts[:include] ||= self.instance_methods.map{|e| e.to_s }
+      else
+        opts[:target]= 's'
+        opts[:include] ||= self.methods.map{|e| e.to_s }
+
+      end
+
+      [:include,:exclude].each do |array_name|
+
+        unless opts[array_name].class <= Array
+          opts[array_name]= [ opts[array_name] ]
+        end
+
+        opts[array_name].map!{ |element| ( element.class == String ? element : element.to_s ) }
+
+      end
+
+      opts[:exclude].push('__send__').push('object_id')
+
+      if opts[:target][0] == 's'
+
+        self.instance_eval do
+
+          opts[:include].each do |sym|
+
+            unless opts[:exclude].include?(sym)
+              (class << self; self; end).__send__ :private, sym
+            end
+
+          end
+        end
+
+      elsif opts[:target][0] == 'i'
+
+        opts[:include].each do |sym|
+
+          unless opts[:exclude].include?(sym)
+            self.__send__ :private, sym
+          end
+
+        end
+
+      else
+        STDERR.puts "invalid target definition"
+
+      end
+
+
+    end
+
+  end
+
+
+end

data/lib/tmp/instance.rb

@@ -0,0 +1,60 @@
+class TMP::Instance
+
+  attr_reader :tmpdir
+
+  def initialize(tmp_folder=nil)
+    @tmpdir = tmp_folder || get_system_tmpdir
+  end
+
+  def []=(file_name, dump_object)
+    open(file_name, 'w+') do |file|
+      file.write(Marshal.dump(dump_object))
+    end
+  end
+
+  def [](file_name)
+    open(file_name, 'r') do |f|
+      begin
+        Marshal.load(f.read)
+      rescue ArgumentError => ex
+        ex.message.to_s.include?('marshal') ? nil : raise(ex)
+      end
+    end
+  end
+
+  def open(file_name, *args)
+
+    file_path = path_for(file_name)
+
+    File.open(file_path, *args) do |f|
+      begin
+        f.flock(File::LOCK_EX)
+        yield(f)
+      ensure
+        f.flock(File::LOCK_UN)
+      end
+    end
+
+  rescue Errno::ENOENT
+    File.open(file_path, 'a') {}
+    retry
+  end
+
+  def path_for(file_name)
+    File.join(tmpdir, file_name)
+  end
+
+  protected
+
+  def get_system_tmpdir
+
+    require 'tmpdir'
+    require 'securerandom'
+    tmp_dir_to_use = File.join(Dir.tmpdir,SecureRandom.uuid.to_s)
+    Dir.mkdir(tmp_dir_to_use) unless File.exist?(tmp_dir_to_use)
+
+    return tmp_dir_to_use
+
+  end
+
+end

data/spec/tmp/instance_spec.rb

@@ -0,0 +1,157 @@
+require_relative '../spec_helper'
+describe TMP::Instance do
+
+  let(:tmp_folder_path){'/tmp/folder/path'}
+  subject{ self.described_class.new(tmp_folder_path)}
+
+  before{ allow(Dir).to receive(:mkdir).and_return(true) }
+
+  describe '#initialize' do
+
+    context 'when tmp folder path not given' do
+
+      subject{ self.described_class.new }
+      it 'should initialize, and set the default tmp folder by the system' do
+
+        require 'securerandom'
+        require 'tmpdir'
+
+        expect(SecureRandom).to receive(:uuid).and_return('uuid')
+        expect(subject.instance_variable_get(:@tmpdir)).to eq File.join(Dir.tmpdir,'uuid')
+
+      end
+
+    end
+
+    context 'when folder path passed to the initialization' do
+
+      it 'should return the path that passed on initialization' do
+        expect(subject.instance_variable_get(:@tmpdir)).to eq tmp_folder_path
+      end
+
+    end
+
+  end
+
+  describe '#tmpdir' do
+
+    it 'should return the @tmpdir content' do
+      expect( subject.tmpdir ).to eq subject.instance_variable_get(:@tmpdir)
+    end
+
+  end
+
+  describe 'File Accessors' do
+
+    let(:file_mock){double('file mock')}
+    let(:sample_object){{name: 'test',content: 'Sample Object'}}
+
+    describe '#[]=' do
+
+      context 'when block not given' do
+
+        it 'should marshal dump to a temp file by the given name' do
+
+          expect( subject ).to receive(:open).with( sample_object[:name], 'w+' ).and_yield(file_mock)
+          expect( file_mock ).to receive(:write).with(Marshal.dump(sample_object[:content]))
+          expect( subject[sample_object[:name]]= sample_object[:content] ).to eq sample_object[:content]
+
+        end
+
+      end
+
+    end
+
+    describe '#[]' do
+
+      context 'when valid marshal data in the file' do
+
+        it 'should read a tmp file content by unserialize and returning object' do
+
+          expect( subject ).to receive(:open).with(sample_object[:name],'r').and_yield(file_mock)
+          expect( file_mock ).to receive(:read).and_return(Marshal.dump(sample_object[:content]))
+          expect( subject[sample_object[:name]] ).to eq sample_object[:content]
+
+        end
+
+      end
+
+      context 'when marshal data too short' do
+
+        it 'should return a nil' do
+
+          expect( subject ).to receive(:open).with(sample_object[:name],'r').and_yield(file_mock)
+          expect( file_mock ).to receive(:read).and_return('')
+          expect( subject[sample_object[:name]] ).to eq nil
+
+        end
+
+      end
+
+    end
+
+    describe '#open' do
+
+      let(:file_open_mode){'r+'}
+
+      before do
+        allow(file_mock).to receive(:flock)
+      end
+
+      context 'when file exist' do
+        it 'should send lock signal thought the os for the file for a given block' do
+
+          expect(File).to receive(:open).with(File.join(tmp_folder_path,sample_object[:name]),file_open_mode).and_yield(file_mock)
+
+          expect(file_mock).to receive(:flock).with(File::LOCK_EX)
+          expect(file_mock).to receive(:flock).with(File::LOCK_UN)
+
+          block_ran = false
+          subject.open( sample_object[:name], file_open_mode ) do |f|
+            expect(f).to eq file_mock
+            block_ran = true
+          end
+
+          expect(block_ran).to be_truthy
+
+        end
+      end
+
+      context 'when file not exist' do
+
+        it 'should rescue ENOENT exception, create an empty file and retry' do
+
+          expect(File).to receive(:open).with(File.join(tmp_folder_path,sample_object[:name]),file_open_mode).once.and_raise(Errno::ENOENT)
+          expect(File).to receive(:open).with(File.join(tmp_folder_path,sample_object[:name]),'a')
+
+          expect(File).to receive(:open).with(File.join(tmp_folder_path,sample_object[:name]),file_open_mode).and_yield(file_mock)
+
+          expect(file_mock).to receive(:flock).with(File::LOCK_EX)
+          expect(file_mock).to receive(:flock).with(File::LOCK_UN)
+
+          block_ran = false
+          subject.open( sample_object[:name], file_open_mode ) do |f|
+            expect(f).to eq file_mock
+            block_ran = true
+          end
+
+          expect(block_ran).to be_truthy
+
+        end
+
+
+      end
+
+    end
+
+    describe '#path_for' do
+
+      it 'should return a full path for a given name that is located in the current tmp directory' do
+        expect(subject.path_for(sample_object[:name])).to  eq File.join(tmp_folder_path,sample_object[:name])
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tmp
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-10 00:00:00.000000000 Z
+date: 2015-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -75,15 +75,16 @@ files:
 - Rakefile
 - VERSION
 - bin/console
-- examples/blocks.rb
-- examples/config_exmpl.rb
-- examples/instance.rb
-- examples/path.rb
-- examples/sugar_use.rb
-- examples/test.rb
 - files.rb
 - lib/tmp.rb
+- lib/tmp/deprecated/core.rb
+- lib/tmp/deprecated/dci.rb
+- lib/tmp/deprecated/dsl.rb
+- lib/tmp/deprecated/init.rb
+- lib/tmp/deprecated/sup.rb
+- lib/tmp/instance.rb
 - spec/spec_helper.rb
+- spec/tmp/instance_spec.rb
 - tmp.gemspec
 homepage: https://github.com/adamluzsi/tmp
 licenses:
@@ -111,3 +112,4 @@ specification_version: 4
 summary: DSL for temporally files read/write in the object oriented way (system tmp)
 test_files:
 - spec/spec_helper.rb
+- spec/tmp/instance_spec.rb

data/examples/blocks.rb

@@ -1,50 +0,0 @@
-require 'tmp'
-
-TMP.purge!
-# using blocks is simply as this
-__tmp__.some_file_name "w+" do |file|
-  file.write Random.rand(1000...9999)
-end
-
-__tmp__.some_file_name do |file|
-  puts file.readline #> some random number
-end
-
-# reopen the new file is also simple
-__tmp__.some_file_name do |file|
-
-  while line = file.gets
-    #> some random number same as above
-    puts line
-  end
-
-end
-
-# you can set the file mod if you like, by default it's based on file e
-__tmp__.some_file_name "w+" do |file|
-
-  puts file.readlines.inspect #> [] empty array because the file got w+ command
-
-  file.write "Hello world!"
-
-end
-
-__tmp__.some_file_name do |file|
-  puts file.gets.inspect #> "Hello world!"
-end
-
-puts __tmp__.some_file_name__path__
-
-puts __tmp__.some_file_name.inspect #> it's a string from the file we made
-
-
-TMP.purge!.inspect
-
-#> file_with_extension.rb
-__tmp__.file_with_extension ext: 'rb' do |file|
-  file.write "hello world!"
-end
-
-__tmp__.file_with_extension ext: 'rb' do |file|
-  puts file.read
-end

data/examples/config_exmpl.rb

@@ -1,23 +0,0 @@
-require 'tmp'
-
-TMP.folder_path File.expand_path(File.join(File.dirname(__FILE__),'tmp_folder'))
-
-# except the default folder path, everything is opt able
-puts "","default tmp folder:",
-     TMP.default_folder_path,"",
-
-     "new tmp folder for use:",
-     TMP.folder_path,"",
-
-     "the project name what is used:",
-     TMP.project_name,""
-
-# you can trigger the tmp folder generating by the following
-TMP.folder_init #> || tmp_folder_init
-
-# or you can use syntax sugar!
-__tmp__.hello = { hello: 'world'}
-
-# defined variable
-puts __tmp__.hello #> { hello: 'world'}
-

data/examples/instance.rb

@@ -1,30 +0,0 @@
-require 'tmp'
-
-
-tmp_instance= TMP.new( File.expand_path(File.join(File.dirname(__FILE__),'tmp_folder')) )
-
-# use the same as the TMP::DSL aka tmp method
-
-# let's set a string for this one
-tmp_instance.test= "hello"
-
-# get the string what we just set now
-tmp_instance.test #> "hello"
-
-# you can get the tmp class instance obj like this:
-tmp_instance.tmp_class_instance_object #> return the tmp_instance
-
-# return the tmp folder path
-tmp_instance.tmp_class_instance_object.folder_path
-
-# Remember this instance use different folder thant the main TMP::DSL
-__tmp__.test.inspect  #> nil, because it was never used before
-                  #> the tmp method is same like invoke the TMP::DSL module
-
-tmp_instance.test_file do |file|
-  file.write "hello world!"
-end
-
-tmp_instance.test_file do |file|
-  file.read
-end

data/examples/path.rb

@@ -1,7 +0,0 @@
-require 'tmp'
-
-puts __tmp__.random #> nil or empty string because never used or just fresh inited file
-puts __tmp__.random__path__ #> path to random named file,
-                            # if not exist, make an empty one
-
-puts __tmp__.random__path__ ext: 'rb' #> path to random named file,

data/examples/sugar_use.rb

@@ -1,18 +0,0 @@
-require 'tmp'
-
-TMP.write :test2, {hello: 'world'}
-puts TMP.read(:test2)
-
-#or you can use syntax sugar!
-__tmp__.hello= { hello: 'world'}
-
-# defined variable
-puts __tmp__.hello #> { hello: 'world'}
-
-# undefined variable
-puts __tmp__.sup #> nil
-
-TMP.purge!
-
-# call after tmp is purged
-puts __tmp__.hello #> nil

data/examples/test.rb

@@ -1,6 +0,0 @@
-require 'tmp'
-require 'securerandom'
-
-tmp= TMP.new File.join TMP.tmpdir,SecureRandom.uuid
-$stdout.reopen tmp.test__path__
-puts "hello world"