radiant-ray-extension 3.0.0.alpha → 3.0.0.pre

data/lib/ray/cli.rb

@@ -3,264 +3,217 @@ require "ray"
 
 module Ray
 
-  # This is the CLI for Ray.
-  # If you're trying to figure out how to use the Ray CLI
-  # refer to the [User Manual](http://goo.gl/5UtP8) instead.
+  # Ray's command line interface.
+  # See the [User Manual](http://johnmuhl.github.com/radiant-ray-extension/)
+  # for complete command line usage.
   class CLI < Thor
 
     include Thor::Actions
     include Thor::Shell
 
-    no_tasks do
-      def self.man task
-        %Q{
-          See also
-          http://johnmuhl.github.com/radiant-ray-extension##{task.to_s}
-        }
-      end
-    end
-
-    map "-v" => "version"
-
     default_task :help
 
-    desc "version", "Display your current version of Ray"
+    desc "version", "Current version of Ray"
     def version
-      say "Friendly extension management for Radiant CMS"
-      say "Version: #{Ray::VERSION}"
+      say Ray::VERSION
     end
 
-    desc "search [QUERY]", "Search for extensions"
-    long_desc %Q{
-      By default, search will check the local cache before making any network
-      requests. If no matches are found in the cache GitHub and Rubygems are
-      searched. If an extension is found on both GitHub and RubyGems the
-      information from RubyGems is used. Use the --github and --rubygems flags
-      to restrict your search or the --live flag to bypass the local cache.
-
-      #{man :search}
-    }
-    method_option :github,
-                  :aliases  => "-g",
-                  :desc     => "Only search GitHub",
-                  :type     => :boolean
-    method_option :rubygems,
-                  :aliases  => "-r",
-                  :desc     => "Only search RubyGems",
-                  :type     => :boolean
-    method_option :live,
-                  :aliases  => "-l",
-                  :desc     => "Bypass local cache",
-                  :type     => :boolean
-    def search query
+    desc "search [QUERY]", "Search for extensions by name or keyword"
+    method_option :github, :desc => "Restrict search to GitHub",
+                  :aliases => "-g", :type => :boolean
+    method_option :rubygems, :desc => "Restrict search to RubyGems",
+                  :aliases => "-r", :type => :boolean
+    method_option :live, :desc => "Bypass local cache",
+                  :aliases => "-l", :type => :boolean
+    # Search for extensions
+    # @example
+    #   ray search blog
+    #   ray search blog --live
+    #   ray search blog --github
+    #   ray search blog --rubygems
+    def search query = nil
       search = case
-      when options["github"]
-        Ray::GitHub.new query
       when options["rubygems"]
-        Ray::RubyGems.new query
+        Ray::Search::RubyGems.new query
+      when options["github"]
+        Ray::Search::GitHub.new query
       when options["live"]
-        Ray::GitHub.new(query).merge Ray::RubyGems.new(query)
-      else
-        if Ray::Cache.new(query).results.empty?
-          Ray::GitHub.new(query).merge Ray::RubyGems.new(query)
-        else
-          Ray::Cache.new query
-        end
+        Ray::Search.new query, :live
+      when options.empty?
+        Ray::Search.new query
       end
-
       search.cache
       say search.output
     end
 
-    desc "install [EXTENSIONS]", "Install extensions"
-    long_desc %Q{
-      #{man :install}
-    }
-    method_option :gem,
-                  :aliases  => "-r",
-                  :banner   => "URL",
-                  :desc     => "Install from RubyGem"
-    method_option :git,
-                  :aliases  => "-g",
-                  :banner   => "URL",
-                  :desc     => "Install from Git repository"
-    method_option :zip,
-                  :aliases  => "-z",
-                  :banner   => "URL",
-                  :desc     => "Install from zip archive"
+    desc "install [EXTENSION]", "Install extensions"
+    method_option :git, :desc => "Install extension from Git repository",
+                  :aliases => "-g"
+    method_option :rubygem, :desc => "Install extension from RubyGems",
+                  :aliases => "-r"
+    method_option :zip, :desc => "Install extension from zip archive",
+                  :aliases => "-z"
+    # Install extensions
+    # @example
+    #   ray install reorder-children
+    #   ray install reorder-children --git
+    #   ray install reorder-children --rubygem
+    #   ray install reorder-children --zip
     def install *extensions
-      if extensions.empty?
-        say "You didn't list any extensions to install", :red
-        say "Try: ray help install"
-        exit 1
-      end
-
       case
-      when options["gem"]                                                       # --gem
-        if options["gem"] == "gem"                                              # no uri was passed to --gem
+      when options["zip"]
+        if extensions.size > 1 && options["zip"] != "zip"
+          say "You can only list one extension at a time", :red
+          exit 1
+        end
+        if options["zip"] == "zip"
           extensions.each do |extension|
-            search = Ray::Cache.new extension                                   # first we search the cache
-            if search.results.empty?                                            # when there are no cache hits
-              search = Ray::RubyGems.new extension                              # then search rubygems
-            else                                                                # when there are cache hits
-              results = {}
-              search.results.select do |name, info|                             # filter out non-gem extensions
-                info[:uri] =~ /rubygems/
-              end.map do |extension|
-                results[extension.first] = extension.last                       # rebuild the results hash
-              end
-              if results.empty?
-                search = Ray::RubyGems.new extension
-              else
-                search.results = results                                        # reset the results hash
-              end
+            search = Ray::Search.new extension.to_extension_name
+            search.cache
+            if search.results.size == 1
+              extension = search.results.first.last
+            else
+              extension = search.multiple_choice
             end
-            if search.results.size == 1                                         # when there is just one match
-              extension = Ray::Gem.new search.results.first.last                # that's our extension
-            else                                                                # when there is more than one match
-              extension = Ray::Gem.new search.multiple_choice                   # make the user pick
-            end
-            extension.install                                                   # install the extension
-            say "#{extension.name} => Installed!", :green
-          end
-        else                                                                    # a uri was passed to --gem
-          extension = Ray::Gem.new({                                            # instantiate with minimal info
-            :name => extensions.first,                                          # nothing works without a name
-            :uri  => options["gem"]                                             # uri should be a git repo
-          })
-          say "#{extension.name} => Adding to Gemfile..."
-          name = "radiant-#{extension.name}-extension"
-          File.open Ray::GEMFILE, "a" do |gemfile|
-            gemfile.puts "gem \"#{name}\", :git => \"#{extension.uri}\""        # add it to the gemfile
+            zip = Ray::Extension::Zip.new extension[:name], extension[:uri]
+            say "#{extension[:name]} => Downloading...", :yellow
+            zip.download
+            say "#{extension[:name]} => Extracting...", :yellow
+            zip.extract
+            say "#{extension[:name]} => Running tasks...", :yellow
+            zip.install
+            say "#{extension[:name]} => Installation complete.", :green
           end
-          extension.bundle                                                      # we don't use install here
-          extension.copy_tasks                                                  # because add_gem only works
-          extension.run_tasks                                                   # with released gem extensions
-          say "#{extension.name} => Installed!", :green
+        else
+          name = extensions.first.to_extension_name
+          zip = Ray::Extension::Zip.new name, options["zip"]
+          say "#{name} => Downloading...", :yellow
+          zip.download
+          say "#{name} => Extracting...", :yellow
+          zip.extract
+          say "#{name} => Running tasks...", :yellow
+          zip.install
+          say "#{name} => Installation complete.", :green
         end
       when options["git"]
+        if extensions.size > 1 && options["git"] != "git"
+          say "You can only list one extension at a time", :red
+          exit 1
+        end
         if options["git"] == "git"
           extensions.each do |extension|
-            search = Ray::Cache.new extension                                   # first we search the cache
-            if search.results.empty?                                            # when there are no cache hits
-              search = Ray::GitHub.new extension                                # then search github
-            else                                                                # when there are cache hits
-              results = {}
-              search.results.select do |name, info|                             # filter out non-git extensions
-                info[:uri] =~ /github/
-              end.map do |extension|
-                results[extension.first] = extension.last                       # rebuild the results hash
-              end
-              if results.empty?
-                search = Ray::GitHub.new extension
-              else
-                search.results = results                                        # reset the results hash
-              end
+            search = Ray::Search::GitHub.new extension.to_extension_name
+            search.cache
+            if search.results.size == 1
+              extension = search.results.first.last
+            else
+              extension = search.multiple_choice
             end
-            if search.results.size == 1                                         # when there is just one match
-              extension = Ray::Git.new search.results.first.last                # that's our extension
-            else                                                                # when there is more than one match
-              extension = Ray::Git.new search.multiple_choice                   # make the user pick
-            end
-            extension.install                                                   # install the extension
-            say "#{extension.name} => Installed!", :green
+            git = Ray::Extension::Git.new extension[:name], extension[:repository]
+            say "#{extension[:name]} => Cloning...", :yellow
+            git.clone
+            say "#{extension[:name]} => Running tasks...", :yellow
+            git.install
+            say "#{extension[:name]} => Installation complete.", :green
           end
         else
-          extension = Ray::Git.new({                                            # instantiate with minimal info
-            :name => extensions.first,                                          # nothing works without a name
-            :uri  => options["git"]                                             # uri should be a git repo
-          })
-          extension.install                                                     # install the extension
-          say "#{extension.name} => Installed!s", :green
+          name = extensions.first.to_extension_name
+          git = Ray::Extension::Git.new name, options["git"]
+          say "#{name} => Cloning...", :yellow
+          git.clone
+          say "#{name} => Running tasks...", :yellow
+          git.install
+          say "#{name} => Installation complete.", :green
         end
-      when options["zip"]
-        if options["zip"] == "zip"
+      when options["rubygem"]
+        if extensions.size > 1 && options["rubygem"] != "rubygem"
+          say "You can only list one extension at a time", :red
+          exit 1
+        end
+        if options["rubygem"] == "rubygem"
           extensions.each do |extension|
-            search = Ray::Cache.new extension                                   # first we search the cache
-            if search.results.empty?                                            # when there are no cache hits
-              search = Ray::GitHub.new extension                                # then search github
-            else                                                                # when there are cache hits
-              results = {}
-              search.results.select do |name, info|                             # filter out non-git extensions
-                info[:uri] =~ /github/
-              end.map do |extension|
-                results[extension.first] = extension.last                       # rebuild the results hash
-              end
-              if results.empty?
-                search = Ray::GitHub.new extension
-              else
-                search.results = results                                        # reset the results hash
-              end
+            search = Ray::Search::RubyGems.new extension.to_extension_name
+            search.cache
+            if search.results.size == 1
+              extension = search.results.first.last
+            else
+              extension = search.multiple_choice
             end
-            if search.results.size == 1                                         # when there is just one match
-              extension = Ray::Zip.new search.results.first.last                # that's our extension
-            else                                                                # when there is more than one match
-              extension = Ray::Zip.new search.multiple_choice                   # make the user pick
-            end
-            extension.uri += "/zipball/master"                                  # github uses awkward naming
-            extension.install                                                   # install the extension
-            say "#{extension.name} => Installed!", :green
+            rubygem = Ray::Extension::RubyGem.new extension[:name], extension[:repository]
+            say "#{extension[:name]} => Bundling...", :yellow
+            rubygem.bundle
+            say "#{extension[:name]} => Running tasks...", :yellow
+            rubygem.install
+            say "#{extension[:name]} => Installation complete.", :green
           end
         else
-          extension = Ray::Zip.new({                                            # instantiate with minimal info
-            :name => extensions.first,                                          # nothing works without a name
-            :uri  => options["zip"]                                             # uri should be a zip archive
-          })
-          extension.install                                                     # install the extension
-          say "#{extension.name} => Installed!", :green
+          # not sure what to do here, probably nothing
         end
       else
-        p options
-      end
-    end
-
-    desc "cache", "Inspect and clear the cache"
-    method_option :clear, :desc => "Clear local cache", :type => :boolean
-    def cache
-      if options["clear"]
-        Ray::Cache.clear
-      else
-        say File.read Ray::CACHE
+        extensions.each do |extension|
+          search = Ray::Search.new extension.to_extension_name
+          search.cache
+          if search.results.size == 1
+            extension = search.results.first.last
+          else
+            extension = search.multiple_choice
+          end
+          if extension[:version] == "latest"
+            git = Ray::Extension::Git.new extension[:name], extension[:repository]
+            say "#{extension[:name]} => Cloning...", :yellow
+            git.clone
+            say "#{extension[:name]} => Running tasks...", :yellow
+            git.install
+            say "#{extension[:name]} => Installation complete.", :green
+          else
+            rubygem = Ray::Extension::RubyGem.new extension[:name], extension[:repository]
+            say "#{extension[:name]} => Bundling...", :yellow
+            rubygem.bundle
+            say "#{extension[:name]} => Running tasks...", :yellow
+            rubygem.install
+            say "#{extension[:name]} => Installation complete.", :green
+          end
+        end
       end
     end
 
-    desc "disable [EXTENSIONS]", "Disable extensions"
+    desc "disable [EXTENSION]", "Disable extensions"
     def disable *extensions
       extensions.each do |x|
         extension = x.to_extension_name
-        if File.exist? "#{Ray::EXT_DIR}/#{extension}"
-          Ray::Git.new({ :name => extension }).disable
+        if File.exist? "#{EXT_DIR}/#{extension}"
+          Ray::Extension.new(extension).disable
           say "#{extension} => Disabled.", :green
         elsif `bundle exec gem list`.include? "radiant-#{extension}-extension"
-          Ray::Gem.new({ :name => extension }).disable
+          Ray::Extension::RubyGem.new(extension).disable
           say "#{extension} => Disabled.", :green
         end
       end
     end
 
-    desc "enable [EXTENSIONS]", "Enable extensions"
+    desc "enable [EXTENSION]", "Enable extensions"
     def enable *extensions
       extensions.each do |x|
         extension = x.to_extension_name
-        if File.exist? "#{Ray::EXT_DIR}/.disabled/#{extension}"
-          Ray::Git.new({ :name => extension }).enable
+        if File.exist? "#{EXT_DIR}/.disabled/#{extension}"
+          Ray::Extension.new(extension).enable
           say "#{extension} => Enabled.", :green
         elsif `gem list`.include? "radiant-#{extension}-extension"
-          Ray::Gem.new({ :name => extension }).enable
+          Ray::Extension::RubyGem.new(extension).enable
           say "#{extension} => Enabled.", :green
         end
       end
     end
 
-    desc "uninstall [EXTENSIONS]", "Uninstall extensions"
+    desc "uninstall [EXTENSION]", "Uninstall extensions"
     def uninstall *extensions
       extensions.each do |x|
         extension = x.to_extension_name
-        if File.exist? "#{Ray::EXT_DIR}/#{extension}"
-          Ray::Git.new({ :name => extension }).uninstall
+        if File.exist? "#{EXT_DIR}/#{extension}"
+          Ray::Extension.new(extension).uninstall
           say "#{extension} => Uninstalled.", :green
         elsif `bundle exec gem list`.include? "radiant-#{extension}-extension"
-          Ray::Gem.new({ :name => extension }).uninstall
+          Ray::Extension::RubyGem.new(extension).uninstall
           say "#{extension} => Uninstalled.", :green
         end
       end

data/lib/ray/constants.rb

@@ -1,17 +1,12 @@
 # Friendly extension management for Radiant CMS
 module Ray
 
-  VERSION   = "3.0.0.alpha"
-
-  RAY       = File.expand_path "~/.ray"
-  CACHE     = "#{RAY}/cache.yml"
-
-  ROOT      = File.expand_path Dir.pwd
-  GEMFILE   = "#{ROOT}/Gemfile"
-  EXT_DIR   = "#{ROOT}/vendor/extensions"
-  TMP_DIR   = "#{ROOT}/tmp/ray"
-  RG_V1_API = "http://rubygems.org/api/v1"
-  GH_V2_API = "http://github.com/api/v2/json"
-  GH_V3_API = "https://api.github.com"
+  VERSION = "3.0.0.pre" # current version
+  RAY     = File.expand_path "~/.ray" # global settings directory
+  TMP     = File.expand_path "#{Dir.pwd}/tmp/ray" # tmp directory
+  ROOT    = Dir.pwd # current directory usually Rails.root
+  CACHE   = File.expand_path "#{RAY}/cache.yml" # global cache file
+  EXT_DIR = File.expand_path "#{Dir.pwd}/vendor/extensions" # install location for "classic" extensions
+  GEMFILE = File.expand_path "#{Dir.pwd}/Gemfile" # project Gemfile
 
 end