fun_with_files 0.0.4 → 0.0.5

data/Gemfile

@@ -13,4 +13,5 @@ group :development do
   gem "jeweler", "~> 1.8.4"
 end
 
+gem "xdg"
 gem "debugger"

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/files/directory_builder.rb

@@ -0,0 +1,179 @@
+module FunWith
+  module Files
+    
+    # Describes a domain-specific language for creating and populating a
+    # directory of files.
+    class DirectoryBuilder
+      attr_accessor :current_path, :current_file
+      
+      def initialize( path )
+        @paths = []
+        @current_path = path.fwf_filepath
+        make_path
+      end
+      
+      def self.create( path, &block )
+        builder = self.new( path )
+        yield builder if block_given?
+        builder
+      end
+
+      def dir( *args, &block )
+        descend( *args ) do
+          yield if block_given?
+        end
+      end
+      
+      # Beware: if block is given, the temp directory will be
+      #
+      def self.tmpdir( &block )
+        if block_given?
+          FilePath.tmpdir do |dir|
+            self.create( dir ) do |builder|
+              yield builder
+            end
+          end
+        else
+          self.create( FilePath.tmpdir )
+        end
+      end
+      
+      # Copies the given source file into a file in the current_path.
+      # If a dest_name is given, the new file will be given that name.
+      def copy( src_filepath, dst_name = nil )
+        dst_filepath = dst_name ? @current_path.join( dst_name ) : @current_path
+        FileUtils.copy( src_filepath, dst_filepath )
+      end
+      
+      def file( name = nil, content = nil, &block )
+        # if name && content
+        #   begin
+        #     f = open_file( name )
+        #     f << content
+        #   ensure
+        #     close_file
+        #   end
+        if name
+          open_file( name )
+          @current_file << content if content
+          if block_given?
+            begin
+              yield @current_file
+            ensure
+              close_file
+            end
+          end
+        else
+          @current_file
+        end
+      end
+      
+      def current_file
+        @current_file ? FunWith::Files::FilePath.new( @current_file.path ) : nil
+      end
+      
+      # if file not given, the result is appended to the current file.
+      def download( url, file = nil )
+        if file
+          if file.fwf_filepath.relative?
+            file = FunWith::Files::FilePath.new( @current_path, file )
+          end
+            
+          File.open( file, "w" ) do |f|
+            download_to_target( url, f )
+          end
+        elsif @current_file
+          download_to_target( url, @current_file )
+        else
+          puts "No current file to append #{url} to."
+        end
+      end
+
+      protected
+      def make_path
+        FileUtils.mkdir_p( @current_path ) unless @current_path.exist?
+      end
+
+      def descend( *args, &block )
+        if @current_path.directory?
+          close_file
+  	      @paths << @current_path
+          @current_path = @paths.last.join( *args )
+          make_path
+  	      yield
+          @current_path = @paths.pop
+          close_file
+        else
+          raise "Cannot descend."
+        end
+      end 
+      
+      def open_file( name )
+        close_file
+        @current_file = File.open( @current_path.join( name ), "w" )
+      end
+      
+      def close_file
+        if @current_file
+          @current_file.flush
+          @current_file.close
+        end
+        
+        @current_file = nil
+      end
+      
+      def download_to_target( url, file )
+        Downloader.new.download( url, file )
+      end
+    end
+  end
+end
+
+
+# sample code
+# 
+# DirBuilder.create( '~/project' ) do |b|         # starts by creating directory.  If parent 
+#                                                 # directories don't exist, they will soon.
+#                                                 # if you use DirBuilder.tmp('~/project'), a tempdir
+#                                                 # is created, and its contents relocated to ~/project when the
+#                                                 # block terminates.
+#   b.dir("images") do                      # creates subdirectory "images"
+#     for img in src_dir.entries.select{|img| img.extension == ".png"}
+#     b.copy( src_dir.join( img.filename ) )         # copies a bunch of files from another directory
+#   end    # rises back to the initial '~/project directory
+# 
+#   b.copy( src_dir.join( "rorshach.xml" ) )
+#   b.download( "dest.bash", "http://get.rvm.io" )            # downloads file directly beneath '~/project'
+#                                                             # maybe someday, though
+# 
+#   b.dir("text", "scenes") do   # creates ~/project/text/scenes subdir
+#     b.file( "adventure_time.txt" ) do |f|
+#       f << "Fill this in later"
+#     end
+# 
+#     # calling .file without feeding it a block leaves it open for writing,
+#     # until either the enclosing block terminates or .file is called
+#     # again with a string argument.
+#     b.file( "another_brick.txt" )           
+#     b.file << "Hey, you!"
+#     b.file << "Yes, you!"
+#     b.file.push "Stand still, laddie!"
+#     
+#     b.template(templates_dir.join("blue_template.txt")) do |t|
+#       t.var(:fname, "John")
+#       t.var(:lname, "Macey")
+#       t.var(:state, "Ohio")
+#       t.vars(graduated: "2003")
+#       t.vars(quot: "That wasn't my duck.", photo: "john.png", css: "font-family: arial")
+#     end
+# 
+#     b.copy( [src_dir.join("abba.txt"), "baab.txt"] )  # contents of abba.txt copied into baab.txt
+#   
+#     
+#     b.file( ".lockfile" )   # creates an empty file
+#   end
+# 
+#   b.
+# end
+#   
+  

data/lib/files/downloader.rb

@@ -0,0 +1,62 @@
+require 'open-uri'            # needed by Utils::Downloader
+require 'net/http'
+require 'timeout'
+
+
+module FunWith
+  module Files
+    class Downloader
+      # stolen from:
+      # http://stackoverflow.com/questions/2263540/how-do-i-download-a-binary-file-over-http-using-ruby
+      def download( url, io )
+        @uri = URI.parse( url )
+        @io  = io
+
+        open( url ) do |f|
+          @io << f.read
+        end
+
+        # @io << Net::HTTP.get( @uri )
+
+        # Net::HTTP.start( @uri.host, @uri.port ) do |http| 
+        #   http.request_get( @uri.path ) do |request| 
+        #     request.read_body do |seg|
+        #       puts "==============================  #{seg} ============================="
+        #       io << seg
+        #       #hack -- adjust to suit:
+        #       sleep 0.005 
+        #     end
+        #   end
+        # end
+      rescue Exception => e
+        handle_network_errors( e )
+      end
+
+      def handle_network_errors( e )
+        raise e
+      rescue URI::InvalidURIError => e
+        puts "Tried to get #{@uri.path} but failed with URI::InvalidURIError."
+      rescue OpenURI::HTTPError => e
+        STDERR.write( "Couldn't fetch podcast info from #{@uri.path}\n" )
+        STDERR.write( "#{e}\n\n" )
+      rescue SocketError => e
+        STDERR.write( "Problem connecting to server (Socket error) when downloading #{@uri.path}." )
+        STDERR.write( "#{e}\n\n" )
+      rescue URI::InvalidURIError => e
+        STDERR.write( "URI::InvalidURIError for #{@uri.path}." )
+        STDERR.write( "#{e}\n\n" )
+        # this may be too broad a filter
+        # TODO: retry?
+      rescue SystemCallError => e
+        STDERR.write( "Problem connecting to server (System call error) when downloading #{@uri.path}" )
+        STDERR.write( "#{e}\n\n" )
+      rescue OpenSSL::SSL::SSLError => e
+        STDERR.write( "OpenSSL::SSL::SSLError while downloading #{@uri.path}" )
+        STDERR.write( "#{e}\n\n" )
+      rescue Timeout::Error
+        STDERR.write( "Timeout error connecting to #{@uri.path}" )
+        STDERR.write( "#{e}\n\n" )
+      end
+    end
+  end
+end

data/lib/files/file_orderer.rb

@@ -0,0 +1,44 @@
+module FunWith
+  module Files
+    # FileOrderer holds a set of strings/regexes, then reorders a set of files (FunWith::Files::FilePaths, actually)
+    # by matching the filenames against one regex after another.  Allows you to say,
+    # "I want the title page, the foreward, then all the chapters, then all the appendixes, then the afterword."
+    # Ex:  FileOrderer( ["title_page", "forward", "chapter-.*", "afterword", "appendix.*" ).reorder( pages )
+    # Only compares the basename minus extension.  Files should come from the same directory.  cover.extension always comes first.
+    class FileOrderer
+      def initialize( matchers )
+        @matchers = matchers.map do |m| 
+          case m
+          when Regexp
+            m
+          when String
+            /^#{m}$/
+          end
+        end
+        
+        @matchers.unshift( /^cover$/ )
+        @matchers.push( /^.*$/ )
+      end
+      
+      def reorder( files )
+        files = files.map(&:fwf_filepath)
+        
+        ordered_files = @matchers.inject( [] ) do |collector, matcher|
+          matched_files = files.select do |f| 
+            name = f.basename_no_ext.to_s
+            matcher.match( name )
+          end
+          
+          matched_files.sort_by! do |filename|
+            filename.basename_no_ext.to_s
+          end
+          
+          collector += matched_files.sort
+          files -= matched_files
+          
+          collector
+        end
+      end
+    end
+  end
+end

data/lib/files/file_path.rb

@@ -14,6 +14,11 @@ module FunWith
         self.cwd( *args )
       end
       
+      # If block given, temporary directory is deleted at the end of the block, and the
+      # value given by the block is returned.
+      # 
+      # If no block given, the path to the temp directory is returned as a FilePath.
+      # Don't forget to delete it when you're done.
       def self.tmpdir( &block )
         if block_given?
           Dir.mktmpdir do |d|
@@ -28,6 +33,10 @@ module FunWith
         Dir.home.fwf_filepath.join( *args )
       end
 
+      def self.template( src, dest, vars = {} )
+        raise "require 'fun_with_templates' to use this method"
+      end
+
       def join( *args, &block )
         if block_given?
           yield self.class.new( super(*args) )
@@ -38,6 +47,8 @@ module FunWith
 
       alias :exists? :exist?
       
+      # If called on a file instead of a directory,
+      # has the same effect as path.dirname
       def up
         self.class.new( self.join("..") ).expand
       end
@@ -169,6 +180,7 @@ module FunWith
         end
       end
       
+      # Returns a [list] of the lines in the file matching the given file
       def grep( regex )
         return [] unless self.file?
         matching = []
@@ -207,23 +219,21 @@ module FunWith
       
       # base, ext =  @path.basename_and_ext
       def basename_and_ext
-        [basename_no_ext, ext]
+        [self.basename_no_ext, self.ext]
       end
       
-      # Basically Pathname.relative_path_from, but you can pass in strings
-      def relative_path_from( dir )
-        dir = super( Pathname.new( dir ) )
-        self.class.new( dir )
+      def dirname_and_basename
+        [self.dirname, self.basename]
       end
       
-      # gsub acts on the filepath, not the file contents
-      def gsub( *args )
-        self.to_s.gsub(*args).fwf_filepath
+      def dirname_and_basename_and_ext
+        [self.dirname, self.basename_no_ext, self.ext]
       end
       
-      def gsub!( *args )
-        new_path = self.to_s.gsub(*args)
-        self.instance_variable_set(:@path, new_path)
+      # Basically Pathname.relative_path_from, but you can pass in strings
+      def relative_path_from( dir )
+        dir = super( Pathname.new( dir ) )
+        self.class.new( dir )
       end
     
       def fwf_filepath
@@ -339,10 +349,7 @@ module FunWith
           FileUtils.rmtree( self )
         end
       end
-      
-      def =~( rval )
-        self.to_s =~ rval
-      end
+
       
       def load
         if self.directory?
@@ -360,6 +367,32 @@ module FunWith
           require self.expand.gsub( /\.rb$/, '' )
         end
       end
+      
+      def root?
+        self == self.up
+      end
+      
+      def descend( &block )
+        path = self.clone
+        
+        if path.root?
+          yield path
+        else
+          self.up.descend( &block )
+          yield self
+        end
+      end
+      
+      def ascend( &block )
+        path = self.clone
+        
+        if path.root?
+          yield path
+        else
+          yield self
+          self.up.ascend( &block )
+        end
+      end
     end
   end
 end

data/lib/files/string_behavior.rb

@@ -0,0 +1,24 @@
+# Allow FilePaths to participate in some of the String-based mischief.
+
+module FunWith
+  module Files
+    module StringBehavior
+      def =~( rval )
+        @path =~ rval
+      end
+      
+      def match( *args )
+        @path.match( *args )
+      end
+      
+      # gsub acts on the filepath, not the file contents
+      def gsub( *args )
+        @path.gsub(*args).fwf_filepath
+      end
+      
+      def gsub!( *args )
+        @path = @path.gsub(*args)
+      end
+    end
+  end
+end

data/lib/files/xdg_extensions.rb

@@ -0,0 +1,7 @@
+module XDG
+  class BaseDir
+    def fwf_filepath( *args )
+      FunWith::Files::FilePath.new( self.to_s, *args )
+    end
+  end
+end

data/lib/fun_with_files.rb

@@ -1,10 +1,22 @@
 require 'pathname'  #stdlib
 require 'tmpdir'
-require "debugger"
+require 'debugger'
 
-for file in %w(file_path root_path remote_path string_extensions pathname_extensions)
+for file in %w(directory_builder
+               downloader
+               file_orderer
+               file_path 
+               root_path 
+               remote_path 
+               string_extensions 
+               string_behavior 
+               pathname_extensions 
+               xdg_extensions)
+               
   require_relative File.join("files", file)
 end
 
 FunWith::Files::RootPath.rootify( FunWith::Files, __FILE__.fwf_filepath.dirname.up )
 FunWith::Files::VERSION = FunWith::Files.root("VERSION").read
+
+FunWith::Files::FilePath.send( :include, FunWith::Files::StringBehavior )

data/test/helper.rb

@@ -20,4 +20,12 @@ class Test::Unit::TestCase
 end
 
 class FunWith::Files::TestCase < Test::Unit::TestCase
+  include FunWith::Files
+  
+  def tmpdir( &block )
+    FunWith::Files::FilePath.tmpdir do |d|
+      @tmpdir = d
+      yield
+    end
+  end
 end

data/test/test_descent.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+class TestDescent < FunWith::Files::TestCase
+  should "descend and ascend" do
+    root = FunWith::Files.root
+    
+    ascent = []
+    descent = []
+    
+    FunWith::Files.root.ascend do |path|
+      ascent << path
+    end
+    
+    FunWith::Files.root.descend do |path|
+      descent << path
+    end
+
+    assert_equal ascent, descent.reverse
+    assert_equal ascent[1], ascent[0].up
+  end
+end

data/test/test_directory_builder.rb

@@ -0,0 +1,136 @@
+require 'helper'
+
+class TestDirectoryBuilder < FunWith::Files::TestCase
+  context "tearing my hair out because shoulda seems borked" do
+    should "stop blaming shoulda for my problems" do
+      assert true
+    end
+  
+    should "realize that assert statements need to be inside should blocks" do
+      assert "Okay, okay.  I get it.  Now lay off me."
+    end
+  
+    should "figure out why the hell [].is_a?(Array) returns false" do
+      assert_kind_of Array, []
+      assert [].is_a?(Array)
+    end
+  end
+  
+  context "In a temporary directory" do
+    should "create a temporary directory" do
+      DirectoryBuilder.tmpdir do |b|
+        assert_equal DirectoryBuilder, b.class    # 
+        assert b.current_path.exist?
+      end
+    end
+  
+    should "write data to a new file" do
+      DirectoryBuilder.tmpdir do |b|
+        assert_equal DirectoryBuilder, b.class
+        assert b.current_path
+        assert b.current_path.exist?
+        b.file("widdershins.txt") do |f|
+          f << "Hello World"
+          f.flush
+        
+          assert b.current_file.exist?
+          assert_equal 11, b.current_file.size
+        end
+      end
+    end
+  
+    should "copy files from elsewhere into the directory" do
+      DirectoryBuilder.tmpdir do |b|
+        assert_equal DirectoryBuilder, b.class
+        src = FunWith::Files.root.join("Gemfile")
+        assert src.exist?
+      
+        b.copy( FunWith::Files.root.join("Gemfile") )
+          
+        gemfile = b.current_path.join("Gemfile")
+        assert gemfile.exist?
+        assert !gemfile.zero?
+        assert_equal 1, gemfile.grep( /jeweler/ ).length
+      end
+    end
+  
+    should "copy files from elsewhere, renaming the file in the destination" do
+      DirectoryBuilder.tmpdir do |b|
+        assert_equal DirectoryBuilder, b.class
+        assert !b.current_path.join("helpers.rb").exist?
+        b.copy( FunWith::Files.root("lib", "fun_with_files.rb"), "fwf.rb" )
+        assert b.current_path.join("fwf.rb").exist?
+      end
+    end
+    
+    should "download random crap from all over the Internet" do
+      DirectoryBuilder.tmpdir do |b|
+        gist_url = "http://bannedsorcery.com/downloads/testfile.txt"
+        gist_text = "This is a file\n==============\n\n**silent**: But _bold_! [Link](http://slashdot.org)\n"
+        b.download( gist_url, "gist.txt" )
+        
+        b.file( "gist.txt.2" ) do
+          b.download( gist_url )
+        end
+        
+        assert b.current_file.nil?
+        assert b.current_path.join("gist.txt").exist?
+        assert b.current_path.join("gist.txt.2").exist?
+        assert_equal gist_text, b.current_path.join("gist.txt").read
+      end
+    end
+  
+    should "exercise all manner of features to create a complex directory" do
+      DirectoryBuilder.tmpdir do |b|
+        assert_equal DirectoryBuilder, b.class
+        root = FunWith::Files.root
+        gemfile = root.join("Gemfile")
+        b.copy( gemfile )
+        assert gemfile.exist?
+        assert_equal gemfile.size, b.current_path.join("Gemfile").size
+        
+        b.dir( "earth" ) do
+          b.dir( "air") do
+            b.dir( "fire" ) do
+              b.dir( "water" ) do
+                b.file( "hello.txt" )
+                b.file << "H"
+                b.file << "e"
+                b.file << "l"
+                b.file << "l"
+                b.file << "o"
+              end
+              
+              assert b.current_file.nil?
+            end
+          end
+        end
+        
+        assert "Hello", b.current_path.join("earth", "air", "fire", "water", "hello.txt").read
+        
+        b.dir( "fire", "water", "earth", "air" ) do
+          assert b.current_path.exist?
+          b.copy( FunWith::Files.root.join("Gemfile"), "Gemfile.example" )
+          b.copy( FunWith::Files.root.join("Gemfile.lock"), "Gemfile.lock.example" )
+          b.copy( FunWith::Files.root.join("Rakefile"), "Rakefile" )
+          
+          for file in %W(Gemfile.example Gemfile.lock.example Rakefile)
+            assert b.current_path.join(file).exist?, "#{file} should exist"
+          end
+        end
+        
+        directory = ["air", "earth", "water", "fire"]
+        b.dir( *directory ) do
+          b.file( "slipstream.txt", "file contents" )
+        end
+        
+        assert b.current_path.join(*directory).exist?
+        slip = b.current_path.join(*directory).join("slipstream.txt")
+        assert slip.exist?
+        assert_equal false, slip.empty?
+        assert_equal "file contents", b.current_path.join(*directory).join( "slipstream.txt" ).read
+        
+      end
+    end
+  end
+end

data/test/test_file_path.rb

@@ -1,7 +1,5 @@
 require 'helper'
 
-include FunWith::Files
-
 class TestFilePath < FunWith::Files::TestCase
   context "testing basics" do
     setup do

data/test/test_globbing.rb

@@ -1,7 +1,5 @@
 require 'helper'
 
-include FunWith::Files
-
 class TestGlobbing < FunWith::Files::TestCase
   should "glob some ruby files from the test/loadable_dir directory" do
     assert FunWith::Files.respond_to?(:root)

data/test/test_loading.rb

@@ -1,7 +1,5 @@
 require 'helper'
 
-include FunWith::Files
-
 class TestLoading < FunWith::Files::TestCase
   should "require a file" do
     assert !defined?( LoadedOrRequiredModule::Loaded1 ), "LoadedOrRequiredModule::Loaded1 shouldn't be defined yet."

data/test/test_root_path.rb

@@ -1,7 +1,5 @@
 require 'helper'
 
-include FunWith::Files
-
 class TestRootPath < FunWith::Files::TestCase
   should "add a root to a module" do
     mod = Module.new

data/test/test_touching.rb

@@ -1,7 +1,5 @@
 require 'helper'
 
-include FunWith::Files
-
 class TestTouching < FunWith::Files::TestCase
   context "inside a tmpdir" do
     setup do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fun_with_files
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-13 00:00:00.000000000 Z
+date: 2014-02-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: xdg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: debugger
   requirement: !ruby/object:Gem::Requirement
@@ -105,11 +121,16 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.rdoc
 files:
+- ./lib/files/directory_builder.rb
+- ./lib/files/downloader.rb
+- ./lib/files/file_orderer.rb
 - ./lib/files/file_path.rb
 - ./lib/files/pathname_extensions.rb
 - ./lib/files/remote_path.rb
 - ./lib/files/root_path.rb
+- ./lib/files/string_behavior.rb
 - ./lib/files/string_extensions.rb
+- ./lib/files/xdg_extensions.rb
 - ./lib/fun_with_files.rb
 - ./test/data/empty.txt
 - ./test/data/grep1.txt
@@ -119,6 +140,8 @@ files:
 - ./test/loadable_dir/dir2/file2.rb
 - ./test/loadable_dir/dir3/file3.rb
 - ./test/loadable_dir/dir4/file4.rb
+- ./test/test_descent.rb
+- ./test/test_directory_builder.rb
 - ./test/test_file_path.rb
 - ./test/test_globbing.rb
 - ./test/test_loading.rb
@@ -144,7 +167,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -676116548205951635
+      hash: -363617118462161826
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: