tane 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tane.gemspec
+gemspec
+
+group :development, :test do
+  gem "rspec"
+  gem "awesome_print"
+end
+
+group :test do
+  gem 'cover_me', '>= 1.0.0.rc6'
+  gem 'ci_reporter'
+end

data/README.md

@@ -0,0 +1,22 @@
+# Tane
+
+Copy-paste the following to create a new Bushido rails application.
+
+    gem install tane
+    tane create
+
+## What is tane?
+
+Tane is a Bushido Developers best friend and a development tool. It
+helps you generate new Bushido capable apps. It also enables existing
+Ruby on Rails Apps to be Bushido friendly.
+
+## How To Create A New App
+
+Install the tane gem and run the `tane create` command to create a new
+app.
+
+The create command will then make a new directory using that passed
+name. If you don't pass a name, it will ask you for one.  The create
+command will use the directory specified to generate a new rails 3 app
+based on a Bushido app template.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+# Import the Tane rake tasks
+import 'tasks/tane.rake'
+
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+if ENV["RAILS_ENV"] != "production"
+  require 'ci/reporter/rake/rspec'
+end

data/bin/tane

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+
+
+args = ARGV.dup
+ARGV.clear
+
+require 'tane'
+options = Tane::Parser.parse(args)
+
+command = args.shift.strip rescue 'help'
+command = 'help' if command == ''
+
+klass = Tane::Commands.const_get command.capitalize
+klass.fire(options, args)

data/lib/tane.rb

@@ -0,0 +1,64 @@
+require "ostruct"
+require "optparse"
+require "awesome_print"
+require "highline"
+
+require "tane/version"
+require "tane/helpers"
+require "tane/parser"
+
+# Load all the available commands
+$commands = []
+
+Dir.glob(File.dirname(__FILE__) + "/tane/commands/*.rb").each do |command|
+  $commands << command.split("/").last.split('.rb').first
+end
+
+# Mark the commands for autoload (load-on-demand)
+module Tane
+  module Commands
+    $commands.each do |command|
+      autoload command.capitalize.to_sym, "tane/commands/#{command}"
+    end
+
+    class << self
+      def command_list_and_help
+        command_list  = "\n"
+        command_list += "The commands I know are:"
+
+        ($commands - ["app", "base"]).each do |command|
+          command_list += "\n  #{command}"
+        end
+
+        command_list += "\n\n"
+        command_list += "For help on any of these commands do"
+        command_list += "\n\t"
+        command_list += "tane help command_name"
+        command_list += "\n\n"
+      end
+
+      def const_missing(name)
+        puts "Unsupported command #{name.downcase}."
+        puts command_list_and_help
+        exit 1
+      end
+    end
+
+  end
+end
+
+$helpers = []
+
+Dir.glob(File.dirname(__FILE__) + "/tane/helpers/*.rb").each do |helper|
+  $helpers << helper.split("/").last.split('_helper.rb').first
+end
+
+# Mark the commands for autoload (load-on-demand)
+module Tane
+  module Helpers
+    $helpers.each do |helper|
+      autoload helper.capitalize.to_sym, "tane/helpers/#{helper}_helper"
+    end
+  end
+end
+

data/lib/tane/commands/app.rb

@@ -0,0 +1,5 @@
+class Tane::Commands::App < Tane::Commands::Base
+  # Parent class for all commands that need to interact with an app
+  class << self
+  end
+end

data/lib/tane/commands/base.rb

@@ -0,0 +1,15 @@
+module Tane
+  module Commands
+    class Base
+      include Tane::Helpers
+
+      class << self
+        def fire(opts, args)
+          @opts = opts
+
+          process(args)
+        end
+      end
+    end
+  end
+end

data/lib/tane/commands/claim.rb

@@ -0,0 +1,26 @@
+class Tane::Commands::Claim < Tane::Commands::Base
+
+  class << self
+    def process(args)
+      email = args.first
+      ido_id = args[1]
+      event = {'category' => 'app', 'event' => 'claimed',
+        'data' => {'time' => Time.now, 'ido_id' => ido_id, 'email' => email}}
+      
+      post(data_url, event)
+    end
+    
+    def help_text
+      <<-EOL
+Usage:
+
+    tane claim email ido_id
+
+Notifies the app of an App.claimed event to the locally running app when the email and ido_id are passed.
+
+    tane claim john@example.com 6h284ah92jcj9m2sv21f
+EOL
+    end
+  end
+
+end

data/lib/tane/commands/create.rb

@@ -0,0 +1,46 @@
+class Tane::Commands::Create < Tane::Commands::Base
+
+  class << self
+    def process(args)
+      authenticate_user
+      app_name = args[0] ||= term.ask("Please enter a name for your new app:     ") { |app_name| app_name }
+      template_url = ENV['KIMONO_URL'] || "https://raw.github.com/Bushido/kimono/master/kimono.rb"
+
+      print "Creating a new Bushido rails app in #{ app_name } ... "
+
+      system("rails new #{app_name} -m #{ template_url } > tane.log")
+
+      Dir.chdir("./#{app_name}")do
+        system("bundle exec tane init > ../tane.log")
+      end
+
+      success_messages = ["Let the hacking commence!",
+                          "Hacks and glory await!",
+                          "Hack and be merry!",
+                          "Your hacking starts... NOW!",
+                          "May the source be with you!",
+                          "Take this demi-REPL, dear friend, and may it serve you well.",
+                          "Lemonodor-fame is but a hack away!",
+                          "Go forth to #{ app_name }, and hack for all you're worth - for all mankind!"]
+
+      success_message = success_messages[ rand(success_messages.length) ]
+
+      FileUtils.mv("./tane.log", "./#{ app_name }/log/tane.log")
+      puts "Finished successfully!"
+      puts "Your app is now in ./#{ app_name } . #{ success_message }"
+    end
+
+    def help_text
+      <<-EOL
+Usage:
+
+    tane claim email ido_id
+
+Notifies the app of an App.claimed event to the locally running app when the email and ido_id are passed.
+
+    tane claim john@example.com 6h284ah92jcj9m2sv21f
+EOL
+    end
+  end
+
+end

data/lib/tane/commands/email.rb

@@ -0,0 +1,50 @@
+class Tane::Commands::Email < Tane::Commands::Base
+  class << self
+    def process(args)
+      if args.count == 0
+        list_email_templates
+      else
+        send_email(args.first)
+      end
+    end
+
+    def list_email_templates
+      email_templates = Dir["#{email_templates_path}/*.yml"]
+      "#{email_templates.count} email templates found for this app:"
+      email_templates.each { |template| term.say template }
+    end
+    
+    def send_email(email_name)
+      email = render_email(email_name)
+
+      if email.nil?
+        term.say "Couldn't find any email with the title '#{email_name}', are you sure there is a .bushido/emails/#{email_name}.yml? "
+        term.say "Here are the email templates for this app..."
+        list_email_templates
+
+        exit 1
+      end
+
+      post(mail_url, email)
+    end
+
+    def render_email(name)
+      YAML.load(ERB.new(File.read( email_template_file_path(name) )).result)
+    end
+
+    def help_text
+      <<-EOL
+Usage:
+
+    tane email [email_template_name]
+   
+Simulates an incoming email event in the app running locally, using the template provided. Details on how to create a template are discussed later in this document.
+
+To list email templates defined for the application, run
+
+    tane email
+EOL
+    end
+
+  end
+end

data/lib/tane/commands/event.rb

@@ -0,0 +1,21 @@
+class Tane::Commands::Event < Tane::Commands::Base
+
+  class << self
+    def process(args)
+      event = {'category' => args.first, 'event' => args[1], 'data' => eval(args[2])}
+      puts event
+      post(data_url, event)
+    end
+
+    def help_text
+      <<-EOL
+Usage:
+
+    tane event event_category event_name data_hash
+    
+Notifies the local app of an event. The event category, event name are to be passed along with the data. The data is in the form of a ruby hash with the keys as strings (not symbols!). The following is an example.
+EOL
+    end
+  end
+
+end

data/lib/tane/commands/exec.rb

@@ -0,0 +1,37 @@
+class Tane::Commands::Exec < Tane::Commands::Base
+
+  class << self
+    def process(args)
+      authenticate_user
+      bushido_envs.each_pair do |key, value|
+        ENV[key] = value
+      end
+      
+      command = args.join(' ')
+      
+      if command.empty?
+        term.say("please enter a command for tane exec to run. example:")
+        term.say("\t tane exec rails s")
+        
+        exit 1
+      end
+      
+      exec command
+    end
+
+    def help_text
+      <<-EOL
+Usage:
+
+    tane exec any_command
+    
+Executes any command specified in a simulated Bushido environment. The following example shows you how to run rails applications.
+
+    tane exec rails s
+
+This is how you should be running Bushido rails applications locally. All the configuration required for `tane exec` is obtained from `.bushido` directory in the current directory. This can only be used if `tane init` has been run in the current directory.
+EOL
+    end
+  end
+
+end

data/lib/tane/commands/help.rb

@@ -0,0 +1,33 @@
+class Tane::Commands::Help < Tane::Commands::Base
+
+  class << self
+    def process(args)
+      if args.count == 0
+        puts opts.help_text
+        return
+      end
+      help_for_command args.first.capitalize if args.count != 0
+    end
+    
+    def help_for_command(command)
+      klass = Tane::Commands.const_get(command)
+      Tane::Commands.const_missing(command) if not klass.respond_to? :help_text
+      term.say "\n#{klass.help_text}\n"
+    end
+
+    def help_text
+      <<-EOL
+Usage:
+
+    tane help [command]
+
+Displays the help message with the list commands tane supports. For details about usage about each each command use `tane help name`, where _name_ is the name of the command you need information about. For example
+
+    tane help support
+  
+displays the information about the support command.
+EOL
+    end
+  end
+
+end

data/lib/tane/commands/init.rb

@@ -0,0 +1,25 @@
+class Tane::Commands::Init < Tane::Commands::Base
+
+  class << self
+    def process(args)
+      authenticate_user
+      if in_rails_dir?
+        Tane::Helpers::Init.initialize_app
+      else
+        term.say("You have to be in the local rails app's root directory when running `tane init`")
+        exit 1
+      end
+    end
+
+    def help_text
+      <<-EOL
+Usage:
+
+    tane init
+    
+Creates a `.bushido` directory within the directory of the rails application. That holds all the config that enables you to run applications and commands in a Bushido environment. It also deploys a development application on Bushido that allows your local application to use resources on the Bushido platform.
+EOL
+    end
+  end
+
+end

data/lib/tane/commands/login.rb

@@ -0,0 +1,91 @@
+require 'tane/commands/app'
+
+class Tane::Commands::Login < Tane::Commands::Base
+  class << self
+    def process(args)
+      email, password = warn_if_credentials_and_prompt
+      
+      auth_token = verify_or_signup(email, password)
+      
+      term.say "Done!"
+      term.say "Saving credentials"
+      save_credentials(email, auth_token)
+    end
+    
+    
+    def warn_if_credentials_and_prompt
+      warn_if_credentials
+      
+      term.say "Let's log you in:"
+      email, password = prompt_for_credentials
+    end
+    
+    
+    def verify_or_signup(email, password)
+      term.say "contacting bushido, please wait..."
+      auth_token, errors = Tane::Helpers::Bushido.verify_credentials(email, password)
+      
+      return auth_token if not auth_token.nil?
+
+      if auth_token.nil?
+        term.say("Invalid username, or password, sorry! Don't worry though, we'll get you through this!")
+
+        # returns auth_token on success
+        return signup_and_notify(email, password) if term.agree("would you like to try signing up with those credentials?")
+          
+        display_help_messages_and_exit
+      end
+    end
+    
+    
+    def signup_and_notify(email, password)
+      term.say "Trying to sign up with those credentials..."
+      auth_token, errors = Tane::Helpers::Bushido.signup(email, password)
+
+      display_errors_and_exit(errors) if auth_token.nil?
+      
+      term.say "Ok, you're signed up as #{email}!"
+      return auth_token
+    end
+
+    
+    def display_errors_and_exit(errors)
+      term.say "Couldn't signup - "
+
+      errors.each do |field|
+        term.say "\n"
+        field.last.each do |error|
+          term.say "  #{field.first} #{error} \n"
+        end
+      end
+      exit
+    end
+
+
+    def display_help_messages_and_exit
+      messages = [
+        "Please try one of the following:",
+        "\t1. Log in again with different credentials",
+        "\t2. Send us a help message from the command line via `tane support 'Hey guys, having trouble logging in with tane...'`",
+        "\t3. Contact us by email at support@gobushido.com if you're having trouble!",
+        "Seriously, isn't it cool to be able to send a support message straight from the cli? It's like you're the fonz"]
+
+      messages.each do |message|
+        term.say message
+      end
+      
+      exit
+    end
+
+    def help_text
+      <<-EOL
+Usage:
+
+    tane login
+    
+Logs you into the Bushido and stores the credentials in `~/.bushido/credentials.yml` file. It only stores your email and an authentication token. Your password is not stored. This is required if you want to run local applications in a Bushido environment. It prompts you to signup if you do not have a Bushido account.
+EOL
+    end
+    
+  end
+end