strobe 0.0.1 → 0.0.2

data/bin/strobe

@@ -1,14 +1,4 @@
 #!/usr/bin/env ruby
+require 'strobe'
 
-require "strobe"
-
-begin
-  Strobe::CLI.start
-rescue Strobe::Error => e
-  Strobe.ui.error e.message
-  Strobe.ui.error e.backtrace.join("\n") if ENV["STROBE_DEBUG"]
-  exit e.status_code
-rescue Interrupt
-  Strobe.ui.error "\nQuitting..."
-  exit 1
-end
+Strobe::CLI.start

data/lib/strobe.rb

@@ -1,100 +1,47 @@
-require "pathname"
-require "yaml"
-
-class Strobe
-  class << self
-
-    # this isn't currently needed, but why start with globals when you could
-    # just as easily start with a singleton instance, which may be helpful
-    # later
-    def main
-      @main ||= new
-    end
-
-    def ui
-      main.ui
-    end
-
-    def ui=(ui)
-      main.ui = ui
-    end
-
-    def root
-      main.root
-    end
-
-    def app_root
-      main.app_root
-    end
-
-    def account
-      main.account
-    end
-
-    def settings
-      main.settings
-    end
-
-    def config_dir
-      main.config_dir
-    end
-
-    def local_config_dir
-      main.local_config_dir
-    end
-  end
-
-  attr_writer :ui
-
-  def ui
-    @ui ||= UI::Basic.new
+require 'base64'
+require 'active_model'
+require 'active_support/concern'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+
+module Strobe
+  autoload :Association, 'strobe/association'
+  autoload :CLI,         'strobe/cli'
+  autoload :Collection,  'strobe/collection'
+  autoload :Connection,  'strobe/connection'
+  autoload :Validations, 'strobe/validations'
+
+  module Resource
+    autoload :Base,       'strobe/resource/base'
+    autoload :Collection, 'strobe/resource/collection'
+    autoload :Singleton,  'strobe/resource/singleton'
   end
 
-  def root
-    sproutcore = "#{app_root}/tmp/build"
-    File.directory?(sproutcore) ? sproutcore : app_root
+  # Resources
+  module Resources
+    autoload :Account,     'strobe/resources/account'
+    autoload :Application, 'strobe/resources/application'
+    autoload :Me,          'strobe/resources/me'
+    autoload :Signup,      'strobe/resources/signup'
+    autoload :Team,        'strobe/resources/team'
+    autoload :User,        'strobe/resources/user'
   end
 
-  def app_root
-    @app_root ||= Pathname.new(Dir.pwd)
-  end
+  # Errors
+  class StrobeError           < StandardError ; end
+  class UnauthenticatedError  < StrobeError   ; end
+  class ResourceNotFoundError < StrobeError   ; end
 
-  def config_dir
-    @config_dir ||= begin
-      dir = Pathname.new(File.join(Strobe.user_home, ".strobe"))
-      FileUtils.mkdir_p(dir) unless dir.exist?
-      dir
-    end
+  def self.connection
+    @connection
   end
 
-  def local_config_dir
-    @local_config_dir ||= begin
-      dir = Pathname.new(File.join(app_root, ".strobe"))
-      FileUtils.mkdir_p(dir) unless dir.exist?
-      dir
-    end
+  def self.connection=(connection)
+    @connection = connection
   end
 
-  def settings
-    @settings ||= Settings.new
-  end
-
-  autoload :Account,  "strobe/account"
-  autoload :CLI,      "strobe/cli"
-  autoload :Deploy,   "strobe/deploy"
-  autoload :Error,    "strobe/errors"
-  autoload :HTTP,     "strobe/http"
-  autoload :Server,   "strobe/server"
-  autoload :Settings, "strobe/settings"
-  autoload :UI,       "strobe/ui"
-  autoload :User,     "strobe/user"
-  autoload :Version,  "strobe/version"
-
-  # ERRORS
-  autoload :AccountError,     "strobe/errors"
-  autoload :ApplicationError, "strobe/errors"
-
-private
   # sadly, copied from Rubygems
   def self.user_home
     unless RUBY_VERSION > '1.9' then

data/lib/strobe/association.rb

@@ -0,0 +1,86 @@
+module Strobe
+  class Association
+    attr_reader :source, :name, :cardinality, :options
+
+    def initialize(source, cardinality, name, options)
+      @source      = source
+      @cardinality = cardinality
+      @name        = name.to_sym
+      @options     = options
+    end
+
+    def target_name
+      'Strobe::Resources::' + name.to_s.classify
+    end
+
+    def target
+      @target ||= target_name.constantize
+    end
+
+    def collection?
+      cardinality == :n
+    end
+
+    def autoload?
+      !options.key?(:autoload) || options[:autoload]
+    end
+
+    def include?
+      options[:include]
+    end
+
+    def reader
+      ruby = []
+      ruby <<   "def #{name}"
+
+      if autoload? && collection?
+
+        ruby << "  @__#{name} ||= Strobe::Collection.new( "                  \
+                "    #{target_name}, '#{source.singular_resource_name}_id' " \
+                "    => self[:id] ) if self[:id]"
+
+      elsif autoload?
+
+        ruby << " return @__#{name} if @__#{name}"
+        ruby << " return nil unless self[:#{name}_id]"
+        ruby << " @__#{name} = #{target_name}.get( self[:#{name}_id] )"
+
+      end
+
+      ruby <<   "  @__#{name}"
+
+      ruby <<   "end"
+      ruby.join("\n")
+    end
+
+    def writer
+      ruby = []
+      ruby <<   "def #{name}=(val)"
+
+      if collection?
+
+        ruby << "  raise NotImplementedError"
+
+      else
+
+        ruby << "  if val"
+        ruby << "    if val.is_a?(Hash)"
+        ruby << "      val = #{target_name}.new(val)"
+        ruby << "    elsif !val.is_a?(#{target_name})"
+        ruby << "      raise 'fail'"
+        ruby << "    end"
+
+        ruby << "    self[:#{name}_id] = val[:id]" if autoload?
+        ruby << "    @__#{name} = val"
+        ruby << "  else"
+        ruby << "    self[:#{name}_id] = nil" if autoload?
+        ruby << "    @__#{name} = nil"
+        ruby << "  end"
+
+      end
+
+      ruby <<   "end"
+      ruby.join("\n")
+    end
+  end
+end

data/lib/strobe/cli.rb

@@ -1,78 +1,64 @@
-require "thor"
+require 'thor'
+require 'pathname'
+require 'fileutils'
 
-class Strobe
+module Strobe
   class CLI < Thor
-    check_unknown_options!
+    autoload :Action,   'strobe/cli/action'
+    autoload :Settings, 'strobe/cli/settings'
 
-    class_option "no-color", :type => :boolean, :banner => "Disable colorization in output"
-    class_option "path",     :type => :string,  :banner => "The path to your application"
+    def self.start(*)
+      super
+    rescue Strobe::StrobeError => e
+      raise if $STROBE_BACKTRACE
+      abort "[ERROR] #{e.message}"
+    end
+
+    class_option "backtrace", :type => :boolean, :banner => "Show a backtrace in case of an exception"
 
     def initialize(*)
       super
 
-      opts = {"path" => Strobe.root}.merge(options)
-      self.options = Thor::CoreExt::HashWithIndifferentAccess.new(opts)
-
-      use_shell = options["no-color"] ? Thor::Shell::Basic.new : shell
-      Strobe.ui = UI::Shell.new(use_shell)
+      $STROBE_BACKTRACE = true if options[:backtrace]
+      _settings.connect!
     end
 
-    desc "signup", "sign up for a new Strobe account"
+    # Load the CLI actions
+    require "strobe/cli/actions"
+
+    desc "signup", "signup for a new Strobe account"
     def signup
-      Account.signup
+      _run :signup
+    end
+
+    desc "login", "register this computer with an existing Strobe account"
+    def login
+      _run :login
     end
 
     desc "deploy", "deploy your application to Strobe"
+    method_option "path", :type => :string, :banner => "The path to the application"
     def deploy
-      Deploy.new(options[:path]).deploy
-    end
+      path   = options[:path] || Dir.pwd
+      config = Settings.new(Pathname.new(path).join(".strobe/config"))
 
-    desc "preview", "preview your application locally"
-    def preview
-      Server.new(options[:path]).start
+      _run :deploy, :config => config, :path => path
     end
 
-    def help(command)
-      case command
-      when "gemfile" then command = "gemfile.5"
-      when nil       then command = "bundle"
-      else command = "bundle-#{cli}"
-      end
-
-      root = File.expand_path("../man", __FILE__)
-
-      if manpages.include?(command)
-        if have_groff?
-          groff   = "groff -Wall -mtty-char -mandoc -Tascii"
-          pager   = ENV['MANPAGER'] || ENV['PAGER'] || 'more'
+  private
 
-          Kernel.exec "#{groff} #{root}/#{command} | #{pager}"
-        else
-          puts File.read("#{root}/#{command}.txt")
-        end
-      else
-        super
-      end
+    def _init_application
+      path = options[:path]
+      dir  = Pathname.new(path).join(".strobe")
+      FileUtils.mkdir_p dir
     end
 
-  private
-    def manpages
-      man_root = File.expand_path("../man", __FILE__)
-      return [] unless File.directory?(man_root)
-
-      man_pages = []
-      Dir["#{man_root}/*"].each do |file|
-        base = File.basename(file)
-        next if base.include?(".")
-        man_pages << base
-      end
-      man_pages
+    def _run(name, opts = {})
+      Action.run name, _settings, opts
     end
 
-    def have_groff?
-      `which groff 2>#{NULL}`
-      $? == 0
+    def _settings
+      @settings ||= Settings.new
     end
   end
 end
-

data/lib/strobe/cli/action.rb

@@ -0,0 +1,131 @@
+require 'highline'
+
+module Strobe
+  class CLI::Action
+    def self.run(action, settings, options = {})
+      success = false
+      klass   = action.to_s.classify + 'Action'
+      klass   = CLI::Actions.const_get(klass)
+
+      until success == true
+        action = klass.new(settings, options)
+        action.steps
+        success = !action.restart
+      end
+    end
+
+    include Resources
+
+    attr_reader :actions, :settings, :restart, :options
+
+    def initialize(settings, options)
+      @settings = settings
+      @options  = options
+      @highline = HighLine.new
+      @resource = nil
+
+      # State
+      @in_group = false
+      @restart  = false
+    end
+
+    def resource(resource = nil)
+      @resource = resource if resource
+      @resource
+    end
+
+    def say(what)
+      puts what
+    end
+
+    def agree(msg, *args)
+      @highline.agree(msg, *args) do |q|
+        next unless STDIN.tty? # For testing
+        q.readline = true
+      end
+    end
+
+    def ask(key, options = {})
+      input key, options do |msg|
+        resp = @highline.ask msg do |q|
+          next unless STDIN.tty? # For testing
+          q.readline = true
+        end
+      end
+    end
+
+    def password(key, options = {})
+      input key, options do |msg|
+        @highline.ask msg do |q|
+          next unless STDIN.tty? # For testing
+          q.echo = '*'
+        end
+      end
+    end
+
+    def choose
+      @highline.choose do |menu|
+        yield menu
+      end
+    end
+
+    def group(options = {}, &blk)
+      case
+      when key = options[:validate]
+        validation_group(key, &blk)
+      else
+        yield if block_given?
+      end
+    end
+
+    def save(opts = {})
+      if resource.save
+        yield
+      else
+        display_errors
+        if opts[:on_error] == :restart
+          @restart = true
+        end
+      end
+    end
+
+    def run(action, opts = {})
+      CLI::Action.run(action, settings, opts)
+    end
+
+  private
+
+    def input(key, options)
+      into = options[:into] || key
+
+      validation_group into do
+        msg = (key.to_s.humanize + ': ').ljust(25)
+        resource[into] = yield msg
+      end
+    end
+
+    def validation_group(resource_key)
+      return yield if @in_group
+
+      begin
+        @in_group = true
+        while true
+          yield
+
+          break if resource.valid_attribute?(resource_key)
+
+          display_errors
+        end
+      ensure
+        @in_group = false
+      end
+    end
+
+    def display_errors
+      resource.errors.each do |k, msg|
+        key = k.to_s.split('.').last
+        say "[ERROR] #{key.humanize} #{msg}"
+      end
+    end
+  end
+end