grimen-shelly 0.1.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jonas Grimfelt
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,109 @@
+h1. SHELLY
+
+_Remotely stored shell scripts executable locally._
+
+h2. The Problem
+
+There are plenty of tools out there that makes it more or less straightforward to run scripts on a remote machine. What's funny though is that many people tend to spend more time on trying to get libraries to work on the local machine, because this is the place where the development and testing takes place. The reason for this is that compiling 3rd party libraries can be a real pain when it comes to different hardware architecture, OSs, OS versions, etc. No, package managers (such as port, apt-get, etc.) is not solving this all the way - sometimes not at all. What I usually do to in such cases is to find and copy-paste shell script "setup recipes" from docs/forums/blogs that - well, usually - works for a specific setup. This is not very scalable though, and actually a waste in many senses:
+
+*Key reasons:*
+
+* Old-school sharing => Setup recipes that works are spread thorough blogs/forums mostly, there's no single resource if you not having your own repository and cloning the scripts manually.
+* No versioning => Same 'ol scripts might stop being "the way of doing it" because of library changes
+* New machine => Same solution probably not works now, i.e. back to finding new setup recipes
+* Conventions?
+
+h2. A Solution: Shelly
+
+Shelly solves this by letting you run scripts - on your local machine - from a remote server like local shell commands almost. You don't need to get paid storage for this; Shelly can load scripts from code hosts solutions like GitHub, Gist, Pastie, etc., which is usually used for purposes of sharing code/snippets with each other anyway.
+
+*Key concepts:*
+
+* Run remotely stored setup scripts/recipes on local machine directly - without downloading/copying stuff manually.
+* No new DSL, just a command that runs a shell script resource (Note: No Windows scripting support).
+* Easy to share setup recipes (shell scripts) - shell script platform?
+* Easy on the eye and memory; easy to learn how to use and remember how to access a script.
+* Out-of-the-box supported script sources: GitHub repos, Gist, Pastie, Pastebin, Raw/URL.
+* Local script aliases for personalization - optional though.
+
+h2. Installation
+
+<pre>$ sudo gem install grimen-shelly</pre>
+
+h2. Dependencies&nbsp;
+
+<pre>$ sudo gem install activesupport</pre>
+<pre>$ sudo gem install octopi</pre>
+
+h2. Basic Usage
+
+Run *GitHub* script source:
+
+<pre>$ shelly run github:grimen/my_shell_scripts/install_geoip-city.sh</pre>
+
+Run *Gist* script source:
+
+<pre>$ shelly run gist:112090</pre>
+
+Run *Pastie* script source:
+
+<pre>$ shelly run pastie:478898</pre>
+
+Run *Pastebin* script source:
+
+<pre>$ shelly run pastebin:23233</pre>
+
+Run *custom* script source:
+
+<pre>$ shelly run http://somedomain.com/my_scripts/quack.sh</pre>
+
+Example Output:
+
+<pre>$ shelly run pastie:478898
+=============================================================================
+[shelly]: Script source type: PASTIE
+[shelly]: Script source URL: http://pastie.org/478898.txt
+[shelly]: Fetching script...DONE
+[shelly]: Executing script...
+============================================================== SCRIPT =======
+Quack, quack!
+Quack, quack!
+=============================================================================
+[shelly]: Cleaning up...DONE
+[shelly]: END</pre>
+
+h2. Advanced Usage
+
+h3. Repositories
+
+Add repository:
+
+<pre>$ shelly add repo github:grimen/my_shell_scripts</pre>
+
+Note: The files within this repo is now accessible. Example-file: @install_geoip-city.sh@
+
+Run:
+
+<pre>$ shelly run install_geoip-city.sh</pre>
+
+h3. Aliases
+
+Add alias:
+
+<pre>$ shelly add alias quack:gist/112090</pre>
+
+Run:
+
+<pre>$ shelly run quack</pre>
+
+h2. NOTE: Security Implications
+
+There are obvious security implications with running shell scripts from remote locations, but the same applies to scripts downloaded manually - which is why Shelly got born in the first place. As long as you know what you doing, security should not be a big issue really. You'll need root access (sudo) to run a script no matter if it's required by the script or not.
+
+h2. Bugs & Features
+
+Shelly is in a sort of conceptual stage, so a lot of improvements can be made. If you got any suggestions, issues, or find any vicious bugs, just file an issue or notify me.
+
+h2. License
+
+Copyright (c) 2009 Jonas Grimfelt, released under the MIT-license.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+NAME = "shelly"
+SUMMARY = %Q{Remotely stored shell scripts runned locally - shell scripts á la rubygems sort of.}
+HOMEPAGE = "http://github.com/grimen/#{NAME}/tree/master"
+AUTHOR = "Jonas Grimfelt"
+EMAIL = "grimen@gmail.com"
+SUPPORT_FILES = %w(README.textile TODO.textile)
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = NAME
+    gem.summary = SUMMARY
+    gem.description = SUMMARY
+    gem.homepage = HOMEPAGE
+    gem.author = AUTHOR
+    gem.email = EMAIL
+    
+    gem.require_paths = %w{lib}
+    gem.files = %w(MIT-LICENSE Rakefile) + SUPPORT_FILES + Dir.glob(File.join('{bin,config,lib,test}', '**', '*'))
+    gem.executables = %w(shelly)
+    gem.extra_rdoc_files = SUPPORT_FILES
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo NAME install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc %Q{Run unit tests for "#{NAME}".}
+task :default => :test
+
+desc %Q{Run unit tests for "#{NAME}".}
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+desc %Q{Generate documentation for "#{NAME}".}
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = NAME
+  rdoc.options << '--line-numbers' << '--inline-source' << '--charset=UTF-8'
+  rdoc.rdoc_files.include(SUPPORT_FILES)
+  rdoc.rdoc_files.include(File.join('lib', '**', '*.rb'))
+end

data/TODO.textile

@@ -0,0 +1,10 @@
+h1. TODO
+
+h2. Next
+
+* Feature: shelly help
+* Enhance: Make the shell script execution output more *stable*, i.e. not being printed out in wrong order
+* Enhance: Arguments handling; make use of existing lib for nicer args-parsing?
+* Feature: Write boring tests
+* Other: Comment the code where needed - for everyone's best
+* ____________?

data/bin/shelly

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'shelly'))
+
+Shelly.run(ARGV)

data/config/shelly.yml

@@ -0,0 +1,6 @@
+--- 
+repos: 
+  github: 
+  - grimen/my_shell_scripts
+aliases: 
+  quack: gist:112090

data/lib/shelly.rb

@@ -0,0 +1,169 @@
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'shelly', '**', '*.rb'))].uniq.each do |file|
+  require file
+end
+
+require 'net/http'
+require 'uri'
+
+module Shelly
+  
+  VALID_SCRIPT_SOURCES = [:github, :gist, :pastie, :pastebin, :raw].freeze
+  VALID_COMMANDS = {
+      :run => [],
+      :create => [:config],
+      :add => [:repo, :alias],
+      :remove => [:repo, :alias],
+      :list => [:repos, :aliases],
+      :help => []
+    }.freeze
+    
+  def run(args)
+    (args ||= []).collect! { |arg| arg.strip }
+    
+    unless Shelly.internet_connection?
+      puts "[shelly]: You are not connected to the Internet."
+    else
+      unless args.empty?
+        if Shelly.valid_command?(args[0], args[1])
+          case args[0].to_sym
+          when :run then Shelly.run!(args[1])
+          when :create then Shelly.create!(args[1])
+          when :add then Shelly.add!(args[1], args[2])
+          when :remove then Shelly.remove!(args[1], args[2])
+          when :list then Shelly.list(args[1])
+          when :help then Shelly.help(args[1])
+          end
+        else
+          puts "[shelly]: FAIL: '#{args[1]}' is not a valid command for '#{args[0]}'. Try 'help' for help."
+        end
+      else
+        puts "[shelly]: FAIL: No valid command."
+      end
+    end
+    
+  end
+  
+  def run!(what)
+    if what
+      begin
+        if Shelly::Store::Alias.include?(what)
+          # Alias, e.g. "shelly run hello_world"
+          what = Shelly::Store::Alias.value(what)
+        elsif Shelly::Store::Repo.include?(what)
+          # File from repo, e.g. "shelly run hello_world"
+          what = Shelly::Store::Repo.value(what)
+        end
+        
+        if what.include?(':')
+          # Explicit script source, e.g. "shelly run pastie:1234"
+          whats = what.split(':')
+          script_source = whats.shift.to_sym
+          script_id = whats.join('/')
+          
+          if valid_script_source?(script_source)
+            case script_source
+            when :github then Shelly::ScriptSource::Scm::Github.new(script_id).run!
+            when :gist then Shelly::ScriptSource::Plain::Gist.new(script_id).run!
+            when :pastie then Shelly::ScriptSource::Plain::Pastie.new(script_id).run!
+            when :pastebin then Shelly::ScriptSource::Plain::Pastebin.new(script_id).run!
+            when :raw then Shelly::ScriptSource::Plain::Raw.new(script_id).run!
+            end
+          else
+            Shelly::ScriptSource::Plain::Raw.new(script_id).run!
+          end
+        else
+          puts "[shelly]: FAIL: No valid script source."
+        end
+      rescue StandardError => e
+        puts "#{e}"
+      end
+    else
+      puts "[shelly]: Invalid args for RUN."
+    end
+  end
+  
+  def create!(what)
+    if what
+      case what.to_sym
+      when :config then Shelly::Store::Base.create_root_config!
+      end
+    else
+      puts "[shelly]: Invalid args for CREATE."
+    end
+  end
+  
+  def add!(to, what)
+    if to
+      case to.to_sym
+      when :repo then Shelly::Store::Repo.add(what)
+      when :alias then Shelly::Store::Alias.add(what)
+      end
+    else
+      puts "[shelly]: Invalid args for ADD."
+    end
+  end
+  
+  def remove!(from, what)
+    if from
+      case from.to_sym
+      when :repo then Shelly::Store::Repo.remove(what)
+      when :alias then Shelly::Store::Alias.remove(what)
+      end
+    else
+      puts "[shelly]: Invalid args for REMOVE."
+    end
+  end
+  
+  def list(from)
+    case (from ||= :all).to_sym
+    when :repos then puts Shelly::Store::Repo.list
+    when :aliases then puts Shelly::Store::Alias.list
+    else puts Shelly::Store::Base.list
+    end
+  end
+  
+  # TODO: Implement help instructions
+  def help(from)
+    puts "[shelly]: No help available."
+  end
+  
+  extend self
+  
+  def internet_connection?
+    uri = URI('http://google.com')
+    begin 
+      http = Net::HTTP.new(uri.host, uri.port) 
+      http.open_timeout = 5
+      http.start
+      http.finish
+      true
+    rescue
+      false
+    end
+  end
+  
+  def valid_alias?(arg)
+    Shelly::Store::Alias.include?(arg)
+  end
+  
+  def valid_repo?(arg)
+    Shelly::Store::Repo.include?(arg)
+  end
+  
+  def valid_repo_file?(arg)
+    Shelly::Store::Repo.include_file?(arg)
+  end
+  
+  def valid_script_source?(arg)
+    VALID_SCRIPT_SOURCES.include?(arg.to_sym)
+  end
+  
+  def valid_command?(*args)
+    if args[1]
+      VALID_COMMANDS[args[0].to_sym].empty? || VALID_COMMANDS[args[0].to_sym].include?(args[1].to_sym)
+    else
+      VALID_COMMANDS.keys.include?(args[0].to_sym)
+    end
+  end
+  
+end

data/lib/shelly/script_source/base.rb

@@ -0,0 +1,62 @@
+module Shelly
+  module ScriptSource
+    class Base
+      
+      DEFAULT_SCRIPT_DIRECTORY = '/tmp'.freeze # could not get this to work
+      DEFAULT_SCRIPT_EXTENSION = ''.freeze
+      
+      attr_accessor :script_file_name, :script_file_path, :fetch_url
+      
+      def initialize(script_identifier)
+        self.fetch_url = self.script_url(script_identifier)
+        self.script_file_name = self.script_name(script_identifier)
+        self.script_file_path = self.script_path(self.script_file_name)
+      end
+      
+      def run!
+        begin
+          puts "============================================================================="
+          puts "[shelly]: Script source type: #{self.script_source.upcase}"
+          puts "[shelly]: Script source URL: #{self.fetch_url}"
+          
+          print "[shelly]: Fetching script..."
+          Shelly::ShellScript.store!(self.fetch_url, self.script_file_path, 'script')
+          print "DONE\n"
+          
+          puts "[shelly]: Executing script..."
+          puts "============================================================== SCRIPT ======="
+          Shelly::ShellScript.execute!(self.script_file_path)
+          puts "============================================================================="
+          
+          print "[shelly]: Cleaning up..."
+          Shelly::ShellScript.delete!(self.script_file_path)
+          print "DONE\n"
+          
+          puts "[shelly]: END\n"
+          
+        rescue StandardError => m
+          puts "[shelly]: Error: #{m}"
+        end
+      end
+      
+      protected
+      
+      def script_source
+        self.class.to_s.split('::').last.downcase
+      end
+      
+      def script_name(id)
+        "#{self.script_source}_#{id}"
+      end
+      
+      def script_path(script_name)
+        File.expand_path(File.join(DEFAULT_SCRIPT_DIRECTORY, "#{self.script_file_name}#{DEFAULT_SCRIPT_EXTENSION}"))
+      end
+      
+      def script_url
+        raise "[shelly]: ** Error: Should implement 'script_url'."
+      end
+      
+    end
+  end
+end

data/lib/shelly/script_source/plain/base.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'base'))
+
+module Shelly
+  module ScriptSource
+    module Plain
+      class Base < Shelly::ScriptSource::Base
+        
+        protected
+        
+        def is_url(url)
+          url =~ /#{SCRIPT_SOURCE_BASE_URL}/
+        end
+        
+      end
+    end
+  end
+end

data/lib/shelly/script_source/plain/gist.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'base'))
+
+module Shelly
+  module ScriptSource
+    module Plain
+      class Gist < Shelly::ScriptSource::Plain::Base
+        
+        SCRIPT_SOURCE_BASE_URL = 'gist.github.com'.freeze
+        
+        protected
+        
+        def script_url(gist_id)
+          "http://#{SCRIPT_SOURCE_BASE_URL}/#{gist_id}.txt"
+        end
+        
+      end
+    end
+  end
+end

data/lib/shelly/script_source/plain/pastebin.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'base'))
+
+module Shelly
+  module ScriptSource
+    module Plain
+      class Pastebin < Shelly::ScriptSource::Plain::Base
+        
+        SCRIPT_SOURCE_BASE_URL = 'pastebin.com'.freeze
+        
+        protected
+        
+        def script_url(pastebin_id)
+          "http://#{SCRIPT_SOURCE_BASE_URL}/pastebin.php?dl=#{pastebin_id}"
+        end
+        
+      end
+    end
+  end
+end

data/lib/shelly/script_source/plain/pastie.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'base'))
+
+module Shelly
+  module ScriptSource
+    module Plain
+      class Pastie < Shelly::ScriptSource::Plain::Base
+        
+        SCRIPT_SOURCE_BASE_URL = 'pastie.org'.freeze
+        
+        protected
+        
+        def script_url(pastie_id)
+          "http://#{SCRIPT_SOURCE_BASE_URL}/#{pastie_id}.txt"
+        end
+        
+      end
+    end
+  end
+end

data/lib/shelly/script_source/plain/raw.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'base'))
+
+require 'uri'
+
+module Shelly
+  module ScriptSource
+    module Plain
+      class Raw < Shelly::ScriptSource::Plain::Base
+        
+        SCRIPT_SOURCE_BASE_URL = '.'.freeze
+        
+        protected
+        
+        def script_url(url)
+          URI.encode("#{url}")
+        end
+        
+      end
+    end
+  end
+end

data/lib/shelly/script_source/scm/base.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'base'))
+
+module Shelly
+  module ScriptSource
+    module Scm
+      class Base < Shelly::ScriptSource::Base
+        
+      end
+    end
+  end
+end

data/lib/shelly/script_source/scm/github.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'base'))
+
+require 'rubygems'
+
+gem 'octopi', '0.0.9'
+require 'octopi'
+
+module Shelly
+  module ScriptSource
+    module Scm
+      class Github < Shelly::ScriptSource::Scm::Base
+        
+        include Octopi
+        
+        SCRIPT_SOURCE_BASE_URL = 'http://github.com'.freeze
+        
+        def initialize(script_identifier)
+          user_id, repo_name, file_name, commit_sha = id_parts = script_identifier.split('/')
+          raise "Invalid script source: '#{script_identifier}'." unless id_parts.size >= 2
+          
+          self.fetch_url = self.script_url(user_id, repo_name, file_name, commit_sha)
+          self.script_file_name = self.script_name(file_name)
+          self.script_file_path = self.script_path(self.script_file_name)
+        end
+        
+        def self.files(user_id, repo_name, commit_id = nil)
+          commit_id ||= Repository.find(user_id, repo_name).commits.first.id
+          repo_files = FileObject.find(user_id, repo_name, commit_id).collect { |f| f.name }
+        end
+        
+        protected
+        
+        def script_url(user_id, repo_name, file_name, commit_id = nil)
+          commit_id ||= Repository.find(user_id, repo_name).commits.first.id
+          "#{SCRIPT_SOURCE_BASE_URL}/#{user_id}/#{repo_name}/raw/#{commit_id}/#{file_name}"
+        end
+        
+      end
+    end
+  end
+end

data/lib/shelly/shell_script.rb

@@ -0,0 +1,83 @@
+module Shelly
+  module ShellScript
+    
+    def store!(source_url, destination_path, type)
+      `sudo curl "#{source_url}" --silent -o #{destination_path}`
+      raise "The specified #{type} could not be found." unless File.exist?(destination_path)
+    end
+    
+    def make_executable!(script_path)
+      `sudo chmod 777 #{script_path}` if File.exist?(script_path)
+    end
+    
+    def execute!(script_path)
+      if self.valid?(script_path)
+        self.make_executable!(script_path)
+        self.ensure_format!(script_path)
+        self.execute_with_output!(script_path, false)
+      else
+        puts "Invalid script source."
+      end
+    end
+    
+    def execute_with_output!(script_path, advanced = false)
+      if advanced
+        # Runs the script with output directly, but causes paths to be wrong. =/
+        File.open(script_path, 'r') do |file|
+          begin
+            while line = file.gets
+              # Print shell script instruction
+              # print line
+              # Run everyting except empty lines and comments + print out result.
+              print `#{line.strip}` unless line =~ /^(\#|\n)/
+            end
+          rescue StandardError => e
+            puts "Error: #{e}"
+          ensure
+            file.close
+          end
+        end
+      else
+        puts `sudo #{script_path}`
+      end
+    end
+    
+    def delete!(script_path)
+      `sudo rm #{script_path}` if File.exist?(script_path)
+    end
+    
+    def valid?(script_path)
+      result = false
+      File.open(script_path, 'r') do |file|
+        begin
+          script = file.read
+          # Contains a shebang? I.e. is it a valid script?
+          result = (script =~ /^\#\!\//)
+        rescue StandardError => e
+          puts "Error: #{e}"
+        ensure
+          file.close
+        end
+      end
+      result
+    end
+    
+    def ensure_format!(script_path)
+      File.open(script_path, 'r+') do |file|
+        begin
+          script = file.read
+          # Remove invalid new-line returns
+          script.gsub!(/\r/, '')
+          file.write(script)
+        rescue StandardError => e
+          puts "Error: #{e}"
+        ensure
+          file.close
+        end
+      end
+    end
+    
+    extend self
+    
+  end
+end

data/lib/shelly/store/alias.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'base'))
+
+module Shelly
+  module Store
+    class Alias < Shelly::Store::Base
+      
+      CONFIG_KEY = 'aliases'.freeze
+      
+      class << self
+        
+        def add(what)
+          whats = what.split(':')
+          config = self.load_config
+          config[CONFIG_KEY] ||= {}
+          config[CONFIG_KEY].merge!(whats.shift => whats.join(':'))
+          self.store_config(config)
+        end
+        
+        def remove(what)
+          whats = what.split(':')
+          config = self.load_config
+          config[CONFIG_KEY].delete(whats.shift)
+          config[CONFIG_KEY] = nil if config[CONFIG_KEY] == {}
+          self.store_config(config)
+        end
+        
+        def list
+          self.config.to_yaml
+        end
+        
+        def include?(key)
+          config = load_config
+          config[CONFIG_KEY].keys.include?(key) rescue false
+        end
+        
+        def value(key)
+          "#{config[CONFIG_KEY][key.to_s]}"
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/shelly/store/base.rb

@@ -0,0 +1,43 @@
+require 'yaml'
+
+module Shelly
+  module Store
+    class Base
+      
+      DEFAULT_CONFIG_FILE_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'shelly.yml')).freeze
+      CUSTOM_CONFIG_FILE_PATH = File.expand_path(File.join('~', '.shelly')).freeze
+      
+      class << self
+        
+        def config
+          load_config
+        end
+        
+        def create_root_config!
+          `sudo cp #{self::DEFAULT_CONFIG_FILE_PATH} #{self::CUSTOM_CONFIG_FILE_PATH}`
+          `sudo chmod 664 #{self::CUSTOM_CONFIG_FILE_PATH}`
+        end
+        
+        def config_file_path
+          File.exist?(self::CUSTOM_CONFIG_FILE_PATH) ? self::CUSTOM_CONFIG_FILE_PATH : self::DEFAULT_CONFIG_FILE_PATH
+        end
+        
+        def load_config
+          config_hash = YAML.load_file(self.config_file_path) || Hash.new
+        end
+        
+        def store_config(config_hash)
+          File.open(config_file_path, 'w') do |file|
+            YAML.dump(config_hash, file)
+          end
+        end
+        
+        def list
+          load_config.to_yaml rescue ''
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/shelly/store/repo.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'base'))
+
+require 'activesupport'
+
+module Shelly
+  module Store
+    class Repo < Shelly::Store::Base
+      
+      CONFIG_KEY = 'repos'.freeze
+      
+      class << self
+        
+        def add(what)
+          whats = what.split(':')
+          config = self.load_config
+          config[CONFIG_KEY] ||= {}
+          config[CONFIG_KEY][whats[0].to_s] ||= []
+          config[CONFIG_KEY][whats[0].to_s] << whats[1]
+          self.store_config(config)
+        end
+        
+        def remove(what)
+          whats = what.split(':')
+          config = self.load_config
+          config[CONFIG_KEY][whats[0].to_s].delete(whats[1].to_s) if config[CONFIG_KEY][whats[0].to_s]
+          config[CONFIG_KEY][whats[0].to_s] = nil if config[CONFIG_KEY][whats[0].to_s] == []
+          self.store_config(config)
+        end
+        
+        def list
+          self.load_config[CONFIG_KEY].to_yaml
+        end
+        
+        def include?(file_name)
+          files(file_name).present? rescue false
+        end
+        
+        def files(match_file_name = nil)
+          @repo = nil
+          @file_names = []
+          config = load_config
+          config[CONFIG_KEY].each do |host, repos|
+            scm_class = "Shelly::ScriptSource::Scm::#{host.classify}".constantize
+            repos.each do |repo|
+              files = scm_class.files(*repo.split('/'))
+              @file_names << files
+              @repo = "#{host}:#{repo}/#{match_file_name}" if files.include?(match_file_name)
+            end
+          end
+          @file_names = @file_names.flatten.compact
+          @repo
+        end
+        
+        def value(file_name)
+          files(file_name)
+        end
+        
+      end
+      
+    end
+  end
+end

data/test/shelly_test.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+require 'shelly'
+
+class ShellyTest < Test::Unit::TestCase
+  
+  context "script source" do
+    should "should be able to fetch: gist" do
+      
+    end
+    
+    should "should be able to fetch: pastebin" do
+      
+    end
+    
+    should "should be able to fetch: pastie" do
+      
+    end
+    
+    should "should be able to fetch: raw" do
+      
+    end
+  end
+  
+  context "store" do
+    # should "create config file in user root upon request" do
+    #   `rm #{Shelly::Store::Base::CUSTOM_CONFIG_FILE_PATH}`
+    #   Shelly.create!(:config)
+    #   
+    #   assert File.exist?(Shelly::Store::Base::CUSTOM_CONFIG_FILE_PATH)
+    # end
+    
+    should "initialize config" do
+      assert Shelly::Store::Base.load_config
+    end
+    
+    should "be able to add alias to config" do
+      Shelly.add(:alias, 'foo:http://pastie.org/12345')
+      
+      assert_equal Shelly::Store::Base.config['aliases']['foo'], 'http://pastie.org/12345'
+    end
+    
+    should "be able to remove alias from config" do
+      Shelly.add(:alias, 'foo:http://pastie.org/12345')
+      Shelly.remove(:alias, 'foo')
+      
+      assert !Shelly::Store::Base.config['aliases'].keys.include?('foo')
+    end
+    
+    should "be able to add repo to config" do
+      Shelly.add(:repo, 'github/grimen/shelly')
+      
+      #flunk 'Not done testing yet.'
+      
+      #assert false
+    end
+    
+    should "be able to remove repo from config" do
+      Shelly.remove(:repo, 'github/grimen/shelly')
+      
+      #assert false
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: grimen-shelly
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jonas Grimfelt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-19 00:00:00 -07:00
+default_executable: shelly
+dependencies: []
+
+description: "Remotely stored shell scripts runned locally - shell scripts \xC3\xA1 la rubygems sort of."
+email: grimen@gmail.com
+executables: 
+- shelly
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+- TODO.textile
+files: 
+- MIT-LICENSE
+- README.textile
+- Rakefile
+- TODO.textile
+- bin/shelly
+- config/shelly.yml
+- lib/shelly.rb
+- lib/shelly/script_source/base.rb
+- lib/shelly/script_source/plain/base.rb
+- lib/shelly/script_source/plain/gist.rb
+- lib/shelly/script_source/plain/pastebin.rb
+- lib/shelly/script_source/plain/pastie.rb
+- lib/shelly/script_source/plain/raw.rb
+- lib/shelly/script_source/scm/base.rb
+- lib/shelly/script_source/scm/github.rb
+- lib/shelly/shell_script.rb
+- lib/shelly/store/alias.rb
+- lib/shelly/store/base.rb
+- lib/shelly/store/repo.rb
+- test/shelly_test.rb
+has_rdoc: false
+homepage: http://github.com/grimen/shelly/tree/master
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: "Remotely stored shell scripts runned locally - shell scripts \xC3\xA1 la rubygems sort of."
+test_files: 
+- test/shelly_test.rb