grabass 0.1.0 → 0.2.0

data/bin/grabass

@@ -1,61 +1,46 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
-require 'grabass'
+require_relative '../lib/grabass'
 
-ABOUT = '''
-  Grabass
-    Grab static assets and put them somewhere.
-    http://github.com/brian-c/grabass
-
-  Use it like this:
-    grabass assets.json
-    # That JSON looks like this:
-      [{"http://some.remote/file.js": "./lib/file.js"}]
-
-    grabass http://some.remote/file.js ./lib/file.js
-    grabass http://some.remote/archive.zip ./lib/archive/
-'''
+commands = ['install', 'help']
+command = ARGV.shift if commands.include? ARGV[0]
+command ||= commands[0]
 
 options = {}
+options[:force]   = (ARGV.delete '--force')    || (ARGV.delete '-f')
+options[:quiet]   = (ARGV.delete '--quiet')    || (ARGV.delete '-q')
+options[:help]    = (ARGV.delete '--help')     || (ARGV.delete '-h')
+options[:version] = (ARGV.delete '--version')  || (ARGV.delete '-v')
 
-optparse = OptionParser.new do |args|
-  options[:force] = false
-  args.on '-f', '--force', 'Replace existing files' do
-    options[:force] = true
-  end
-  options[:quiet] = false
-  args.on '-q', '--quiet', 'Don\'t log anything' do
-    options[:quiet] = true
-  end
-end
+manifest = ARGV.shift if not ARGV[0].nil? and File.exists? ARGV[0]
+manifest = Grabass::AssetManifest.new manifest || 'assets.json'
 
-optparse.parse!
+destinations = ARGV
 
-started = Time.now
+unless options[:quiet]
+  started = Time.now
+end
 
-if ARGV.length == 0
-  puts ABOUT
-elsif ARGV.length == 1
-  if File.exists? ARGV[0]
-    manifest = Grabass::AssetManifest.new ARGV[0]
-    results = manifest.grab options
+case command
+when 'help'
+  puts 'Help!'
+when 'install'
+  if destinations.length == 0
+    # Grab entire manifest
+    results = manifest.install options
   else
-    puts "Asset manifest \"#{ARGV[0]}\" not found."
+    # Grab the given destinations
+    puts 'TODO: Install specific destinations from the command line'
     exit
   end
-elsif ARGV.length == 2
-  asset = Grabass::Asset.new ARGV[0], {'*' => ARGV[1]}
-  results = asset.fetch options
-elsif ARGV.length == 3
-  asset = Grabass::Asset.new ARGV[0], {ARGV[1] => ARGV[2]}
-  results = asset.fetch options
 end
 
-finished = Time.now
-time = '%.2f' % (finished - started)
-pass = results[:pass]
-total = pass + results[:fail]
+unless options[:quiet] or results.nil?
+  time = '%.2f' % (Time.now - started)
 
-puts "Grabass took in #{time} seconds. #{pass}/#{total} successful."
-puts ''
+  pass = results[:pass]
+  total = pass + results[:fail]
+
+  puts "Grabass took in #{time} seconds. #{pass}/#{total} successful."
+  puts ''
+end

data/lib/grabass.rb

@@ -14,130 +14,178 @@ class Grabass
     "#{text}\n#{char * 72}"
   end
 
-  class Asset
-    attr_accessor :source, :selections, :type
-
-    def initialize(source, selections = [])
-      @source = source
-      @selections = selections # [{'pattern': 'destination'}]
+  class Source
+    def initialize(location)
+      @location = location
 
-      if source.end_with? '.git' or Dir.exists? File.join @source, '.git'
+      if @location.end_with? '.git' or Dir.exists? File.join @location, '.git'
         @type = :git
-      elsif @source.start_with? '/', '.', '~'
+      elsif @location.start_with? '/', '.', '~'
         @type = :local
       else
         @type = :remote
       end
     end
 
-    def grab(destination_root, options = {})
-      puts Grabass::underline @source unless options[:quite]
-      fetch options # Get the files into the temp_dir
-
-      results = {:pass => 0, :fail => 0}
-
-      @selections.each do |selection|
-        pattern, destination = selection.to_a[0]
-        absolute_destination = File.absolute_path destination, destination_root
-
-        # TODO: Do this check before fetching things.
-        if File.exists? absolute_destination and not options[:force]
-          puts Grabass::indent "#{destination} already exists. Use --force to replace.", '!'
-          results[:fail] += 1
-        else
-          if File.exists? absolute_destination
-            puts Grabass::indent "Replacing existing #{destination}", '!' unless options[:quiet]
-            FileUtils.remove_entry absolute_destination, true
-          end
-
-          Dir.chdir temp_dir
-          selected_files = Dir.glob(pattern)
-
-          if selected_files.length == 1
-            FileUtils.makedirs File.dirname absolute_destination
-           `mv #{selected_files[0]} #{absolute_destination}`
-          else
-            FileUtils.makedirs absolute_destination
-            FileUtils.move selected_files, absolute_destination
-          end
-
-          results[:pass] += 1
-        end
-      end
-
-      puts '' unless options[:quiet] # Blank line between assets
-      results
+    def clean_up
+      FileUtils.rm_rf temp_dir
     end
 
     def fetch(options = {})
-      `rm -rf #{temp_dir}`
+      clean_up
+      FileUtils.mkdir_p temp_dir
 
-      if @type == :local
-      elsif @type == :remote
+      case @type
+      when :local
+        copy_local options
+      when :remote
         download_remote options
-        if is_zipped?
-          unzip
-        end
-      elsif @type == :git
-        clone_git_repo
+        unzip options if is_zipped?
+      when :git
+        clone_git_repo options
       end
 
-      Dir.chdir temp_dir
-      Dir['*']
+      temp_dir
     end
 
-    def copy_local
+    def copy_local(options = {})
+      # TODO
     end
 
     def download_remote(options = {})
-      puts Grabass::indent "Downloading #{@source}" unless options[:quiet]
-      `curl --silent --location #{@source} --output #{temp_file}`
+      puts "Downloading #{@location}" unless options[:quiet]
+      wd =  FileUtils.pwd
+      FileUtils.cd temp_dir
+      `curl --silent --location #{@location} --remote-name --remote-header-name`
+      FileUtils.cd wd
     end
 
     def is_zipped?
-      `file --brief --mime-type #{temp_file}`.include? 'zip'
+      `file --mime-type --brief #{Dir[File.join temp_dir, '*']}`.include? 'zip'
     end
 
-    def unzip(options ={})
-      puts Grabass::indent "Unzipping..." unless options[:quiet]
-      `unzip #{temp_file} -d #{temp_dir}`
-      FileUtils.remove temp_file
+    def unzip(options = {})
+      puts "Unzipping..." unless options[:quiet]
+
+      download = Dir[File.join temp_dir, '*'][0]
+      `unzip #{download} -d #{temp_dir}`
+      FileUtils.rm download
 
       # If the zip file expanded into a single directory (they usually do),
       # bring its contents up into temp_dir
       # since that's the root from which we'll make our selections
 
-      Dir.chdir temp_dir
-      if Dir['*'].length == 1
-        single_unzipped_thing = Dir['*'][0]
+      temp_dir_contents = Dir[File.join temp_dir, '*']
+      if temp_dir_contents.length == 1
+        single_unzipped_thing = temp_dir_contents[0]
+
         if File.directory? single_unzipped_thing
-          `mv #{File.join temp_dir, single_unzipped_thing, '*'} #{temp_dir}`
-          FileUtils.remove_dir single_unzipped_thing
+          FileUtils.mv Dir[File.join single_unzipped_thing, '*'], temp_dir
+          FileUtils.rm_r single_unzipped_thing
         end
-      else
-        puts Grabass::indent "Zip archive contained loose contents", '>' unless options[:quiet]
       end
     end
 
-    def clone_git_repo
-      puts Grabass::indent "Temporarily cloning #{@source}" unless options[:quiet]
-      `git clone --quiet #{@source} #{temp_dir}`
+    def clone_git_repo(options = {})
+      puts Grabass::indent "Temporarily cloning #{@location}" unless options[:quiet]
+      `git clone --quiet #{@location} #{temp_dir}`
     end
 
-    private
-
     def short_name
-      @source.gsub(/\W/, '')
+      @location.gsub(/\W/, '')
     end
 
     def temp_dir
-      holding = File.join Grabass::temp_dir, short_name
-      FileUtils.makedirs holding
-      holding
+      File.join Grabass::temp_dir, short_name
+    end
+  end
+
+  class Selection
+    def initialize(glob, destination)
+      @glob, @destination = glob, destination
+    end
+
+    def make_from(source_dir, options)
+      selection = Dir[File.join source_dir, @glob]
+
+      if selection.length == 0
+        puts "No files selected with glob \"#{@glob}\"" unless options[:quiet]
+        return false
+      elsif selection.length == 1
+        puts "Moving \"#{File.basename selection[0]}\" to #{@destination}" unless options[:quiet]
+
+        if File.exists? @destination
+          if options[:force]
+            if File.directory?(selection[0]) == File.directory?(@destination)
+              puts "Removing existing \"#{@destination}\"..." unless options[:quiet]
+              FileUtils.rm_rf @destination
+            end
+          else
+            puts "#{@destination} already exists. Use --force to replace." unless options[:quiet]
+            return false
+          end
+        end
+
+        FileUtils.mkdir_p File.dirname @destination
+        FileUtils.mv selection[0], @destination
+      else
+        puts "Moving #{selection.length} \"#{@glob}\" to #{@destination}" unless options[:quiet]
+
+        failures = 0
+        selection.each do |file|
+          destination_file = File.join @destination, file.sub(source_dir, '')
+          if File.exists? destination_file
+            if options[:force]
+              if File.directory?(file) == File.directory?(destination_file)
+                puts "Removing \"#{destination_file}\"..." unless options[:quiet]
+                FileUtils.rm_rf destination_file
+              end
+            else
+              puts "#{destination_file} already exists. Use --force to replace." unless options[:quiet]
+              failures += 1
+            end
+          end
+        end
+
+        return false if failures > 0
+
+        FileUtils.mkdir_p @destination
+        FileUtils.mv selection, @destination
+      end
+
+      true
     end
+  end
+
+  class Asset
+    def initialize(source, selections)
+      @source = Source.new(source)
 
-    def temp_file
-      File.join temp_dir, short_name
+      @selections = []
+      selections.each do |selection|
+        selection.each do |glob, destination|
+          @selections << Selection.new(glob, destination)
+        end
+      end
+    end
+
+    def install(options = {})
+      results = {:pass => 0, :fail => 0}
+
+      source_dir = @source.fetch
+
+      @selections.each do |selection|
+        success = selection.make_from source_dir, options
+
+        if success
+          results[:pass] += 1
+        else
+          results[:fail] += 1
+        end
+      end
+
+      puts '' unless options[:quiet] # Blank line between assets
+      results
     end
   end
 
@@ -147,26 +195,28 @@ class Grabass
     end
 
     def display(options)
-      puts Grabass::underline @content unless options[:quiet]
+      puts @content unless options[:quiet]
     end
   end
 
   class AssetManifest
     def initialize(filename)
       @filename = filename
-      @root = File.absolute_path File.dirname filename
+      root = File.dirname File.absolute_path filename
 
-      records = JSON.parse File.read @filename
-      @records = records.map do |record|
-        if record.is_a? String
-          Comment.new record
+      @assets = JSON.parse(File.read @filename).map do |item|
+        if item.is_a? String
+          Comment.new item
         else
-          source, selections = record.to_a[0]
+          source, selections = item.to_a[0]
 
-          if selections.is_a? String
-            selections = [{'*' => selections}]
-          elsif selections.is_a? Hash
-            selections = [selections]
+          selections = {'*' => selections} if selections.is_a? String
+          selections = [selections] if selections.is_a? Hash
+
+          selections.map! do |selection|
+            selection.each do |glob, destination|
+              selection[glob] = File.absolute_path destination, root
+            end
           end
 
           Asset.new source, selections
@@ -174,20 +224,16 @@ class Grabass
       end
     end
 
-    def grab(options = {})
-      results = {:pass => 0, :fail => 0}
+    def install(options = {})
+      puts "Installing assets from #{@filename}", '' unless options[:quiet]
 
-      unless options[:quiet]
-        puts ''
-        puts Grabass::underline "Fetching assets from #{@filename}", '='
-        puts ''
-      end
+      results = {:pass => 0, :fail => 0}
 
-      @records.each do |record|
-        if record.is_a? Comment
-          record.display options
-        elsif record.is_a? Asset
-          asset_results = record.grab @root, options
+      @assets.each do |asset|
+        if asset.is_a? Comment
+          asset.display options
+        elsif asset.is_a? Asset
+          asset_results = asset.install options
           results[:pass] += asset_results[:pass]
           results[:fail] += asset_results[:fail]
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: grabass
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-11 00:00:00.000000000 Z
+date: 2012-03-26 00:00:00.000000000 Z
 dependencies: []
 description: Grab static assets and put them somewhere
 email: brian.carstensen@gmail.com