cf_script 0.0.1.beta.1

data/lib/cf_script/output/parser/attributes.rb

@@ -0,0 +1,44 @@
+module CfScript
+  module Output::Parser::Attributes
+    ATTRIBUTE_REGEXP = /^(?<name>[^:]+):\s+(?<value>.+)$/
+
+    def parse_attribute(line, symbolize_name = false)
+      if line =~ ATTRIBUTE_REGEXP
+        name  = Regexp.last_match[:name].strip
+        value = Regexp.last_match[:value].strip
+
+        CfScript::Attribute.new(
+          symbolize_name ? symbolize(name) : name,
+          Regexp.last_match['value'].strip
+        )
+      end
+    end
+
+    def parse_attribute_list(buffer, symbolize_names = true)
+      attribute_list = CfScript::AttributeList.new
+
+      buffer.each_line do |line|
+        if attribute = parse_attribute(line, symbolize_names)
+          attribute_list << attribute
+        end
+      end
+
+      attribute_list
+    end
+
+    def parse_line_attributes(buffer, regexp)
+      if matched = buffer.match(regexp)
+        attribute_list = CfScript::AttributeList.new
+
+        matched.names.each do |name|
+          attribute_list << CfScript::Attribute.new(
+            symbolize(name),
+            matched[name].strip
+          )
+        end
+
+        attribute_list
+      end
+    end
+  end
+end

data/lib/cf_script/output/parser/section.rb

@@ -0,0 +1,15 @@
+module CfScript
+  module Output::Parser::Section
+    def extract_section(buffer, header)
+      if match = buffer.match(/^#{header}:?\s*\n(.*?)\n\n/m)
+        match[1]
+      end
+    end
+
+    def parse_section_attributes(buffer, header)
+      if section = extract_section(buffer, header)
+        parse_attribute_list(section, false)
+      end
+    end
+  end
+end

data/lib/cf_script/output/parser/table.rb

@@ -0,0 +1,46 @@
+module CfScript
+  module Output::Parser::Table
+    def parse_columns(line)
+      line ? line.split(/\s{2,}/).map(&:strip) : []
+    end
+
+    def parse_row(line, columns)
+      row    = CfScript::AttributeList.new
+      values = line.split(/\s{2,}/, columns.length).map!(&:strip)
+
+      columns.each_with_index do |column, index|
+        # Special case for instance status tables
+        name = index == 0 && column == '' ? 'index' : column
+
+        row << CfScript::Attribute.new(
+          symbolize(name),
+          (values[index] ? values[index].strip : '')
+        )
+      end
+
+      row
+    end
+
+    def parse_rows(lines)
+      rows = []
+
+      if lines.first.strip.empty?
+        lines.shift
+      end
+
+      cols = parse_columns(lines.shift)
+
+      lines.each do |line|
+        rows << parse_row(line, cols)
+      end
+
+      rows
+    end
+
+    def parse_table(buffer, headers)
+      if m = buffer.match(/^#{headers.join('\s+')}/)
+        parse_rows buffer[m.begin(0)..-1].lines
+      end
+    end
+  end
+end

data/lib/cf_script/output/parser.rb

@@ -0,0 +1,15 @@
+CfScript::Output.const_set(:Parser, Module.new)
+
+require 'cf_script/output/parser/attributes'
+require 'cf_script/output/parser/section'
+require 'cf_script/output/parser/table'
+
+module CfScript
+  module Output::Parser
+    include CfScript::Utils
+
+    include CfScript::Output::Parser::Attributes
+    include CfScript::Output::Parser::Section
+    include CfScript::Output::Parser::Table
+  end
+end

data/lib/cf_script/output/tests.rb

@@ -0,0 +1,51 @@
+module CfScript
+  module Output::Tests
+    def matches?(regexp)
+      out.matches?(regexp)
+    end
+
+    def contains?(text)
+      out.contains?(text)
+    end
+
+    def ok?
+      out.last_line_matches? /^OK$/
+    end
+
+    def authenticated?
+      matches? /Authenticating\.\.\.\nOK/m
+    end
+
+    def failed?
+      contains? 'FAILED'
+    end
+
+    def no_api_endpoint?
+      contains? 'No API endpoint set.'
+    end
+
+    def not_logged_in?
+      contains? 'Not logged in'
+    end
+
+    def not_authorized?
+      contains? 'You are not authorized'
+    end
+
+    def credentials_rejected?
+      contains? 'Credentials were rejected'
+    end
+
+    def not_found?(type, name)
+      out.last_line_matches? /#{type} #{name} not found/
+    end
+
+    def is_already?(name, state)
+      out.last_line_matches? /#{name} is already #{state}/
+    end
+
+    def already_exists?(type, name)
+      out.last_line_matches? /#{type} #{name} already exists/
+    end
+  end
+end

data/lib/cf_script/output/utils.rb

@@ -0,0 +1,13 @@
+module CfScript
+  module Output::Utils
+    def dump
+      list = []
+
+      list << 'STATUS:' << status.inspect
+      list << 'STDOUT:' << (stdout.size == 0 ? '<empty>' : stdout)
+      list << 'STDERR:' << (stderr.size == 0 ? '<empty>' : stderr)
+
+      CfScript.stderr.puts list.join("\n")
+    end
+  end
+end

data/lib/cf_script/output.rb

@@ -0,0 +1,62 @@
+CfScript.const_set(:Output, Class.new)
+
+require 'cf_script/output/buffer'
+require 'cf_script/output/parser'
+require 'cf_script/output/tests'
+require 'cf_script/output/utils'
+
+module CfScript
+  class Output
+    attr_reader :command
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :status
+
+    include CfScript::Output::Parser
+    include CfScript::Output::Tests
+    include CfScript::Output::Utils
+
+    def initialize(command, stdout, stderr, status)
+      @command = command
+      @stdout  = stdout
+      @stderr  = stderr
+      @status  = status
+    end
+
+    def good?
+      status.success? && status.exitstatus == 0
+    end
+
+    def out
+      @sane_stdout ||= Buffer.new(stdout)
+    end
+
+    def err
+      @sane_stderr ||= Buffer.new(stderr)
+    end
+
+    def last_line
+      out.last_line
+    end
+
+    def attributes
+      parse_attribute_list(out)
+    end
+
+    def line_attributes(line_regexp)
+      parse_line_attributes(out, line_regexp)
+    end
+
+    def attributes_from(line_start)
+      parse_attribute_list(out.from(line_start))
+    end
+
+    def table(headers)
+      parse_table(out, headers)
+    end
+
+    def section_attributes(header)
+      parse_section_attributes(out, header)
+    end
+  end
+end

data/lib/cf_script/scope/app/env.rb

@@ -0,0 +1,15 @@
+module CfScript::Scope
+  module App::Env
+    def env
+      CfScript::Command.env name
+    end
+
+    def set_env(var_name, var_value)
+      CfScript::Command.set_env name, var_name, var_value
+    end
+
+    def unset_env(var_name)
+      CfScript::Command.unset_env name, var_name
+    end
+  end
+end

data/lib/cf_script/scope/app/routes.rb

@@ -0,0 +1,21 @@
+module CfScript::Scope
+  module App::Routes
+    def has_route?(domain, host = nil)
+      route = [host, domain].compact.join('.')
+
+      urls.split(', ').include?(route)
+    end
+
+    def map_route(domain, host =  nil)
+      CfScript::Command.map_route name, domain, host do |mapped|
+        cf_self; has_route?(domain, host)
+      end
+    end
+
+    def unmap_route(domain, host =  nil)
+      CfScript::Command.unmap_route name, domain, host do |unmapped|
+        cf_self; not has_route?(domain, host)
+      end
+    end
+  end
+end

data/lib/cf_script/scope/app/state.rb

@@ -0,0 +1,33 @@
+module CfScript::Scope
+  module App::State
+    def start
+      CfScript::Command.start name do |app_info|
+        @app_info = app_info if app_info
+      end
+    end
+
+    def stop
+      CfScript::Command.stop name do |stopped|
+        cf_self
+      end
+    end
+
+    def restart
+      CfScript::Command.restart name do |app_info|
+        @app_info = app_info if app_info
+      end
+    end
+
+    def push(options = {})
+      CfScript::Command.push name, options do |app_info|
+        @app_info = app_info if app_info
+      end
+    end
+
+    def restage
+      CfScript::Command.restage name do |app_info|
+        @app_info = app_info if app_info
+      end
+    end
+  end
+end

data/lib/cf_script/scope/app/utils.rb

@@ -0,0 +1,32 @@
+module CfScript::Scope
+  module App::Utils
+    def dump
+      title name
+
+      app_info.instance_variables.each do |var|
+        next if var == :@name or var == :@instance_status
+        detail "#{var.to_s.gsub('@', '')}: #{app_info.instance_variable_get(var)}"
+      end
+
+      if app_info.instance_status
+        title 'Instances', 2
+
+        app_info.instance_status.each do |inst|
+          str = inst.show(:index, :state, :cpu, :memory, :disk, :since)
+
+          detail str, 3
+        end
+      end
+    end
+
+    def show(*attrs)
+      line = []
+
+      attrs.each do |attr|
+        line << "#{attr}: #{self.send(attr)}"
+      end
+
+      info line.join(', ')
+    end
+  end
+end

data/lib/cf_script/scope/app.rb

@@ -0,0 +1,94 @@
+require 'forwardable'
+
+module CfScript::Scope
+  class App < Base
+    extend Forwardable
+
+    attr_reader :name
+    attr_reader :app_info
+   #attr_reader :app_spec
+    attr_reader :current_target
+
+   #include CfScript::Callbacks
+    include CfScript::UI
+    include CfScript::UI::NameTag
+
+    def initialize(name_or_info, current_target)
+      @current_target = current_target
+
+      case name_or_info
+      when String, Symbol
+        @name     = name_or_info
+        @app_info = nil
+       #@app_spec = spec_for(name)
+      when CfScript::AppInfo
+        @name     = name_or_info.name
+        @app_info = name_or_info
+       #@app_spec = spec_for(name)
+      else
+        raise "App accepts a name (String or Symbol) or an AppInfo object, " +
+              "but a #{name_or_info.class.name} was given"
+      end
+
+      cf_self
+    end
+
+    def_delegators :@app_info, :requested_state, :instances, :urls,
+      :usage, :last_uploaded, :stack, :buildpack, :memory, :disk,
+      :state, :started?, :hot?, :stopped?, :cold?
+
+    def current_space
+      current_target.space
+    end
+
+    def tag_color(type = nil)
+      started? ? :active : :inactive
+    end
+
+    def name_tag
+      "#{current_target.space}:#{name}"
+    end
+
+   #def run_callbacks(stage, command)
+   #  return unless app_spec
+
+   #  app_spec.callbacks_for(stage, command).each do |callback|
+   #    self.instance_eval(&callback)
+   #  end
+   #end
+
+   #def callbacks_before(command)
+   #  run_callbacks(:before, command)
+   #end
+
+   #def callbacks_after(command)
+   #  run_callbacks(:after, command)
+   #end
+
+   #def callbacks_around(command, &block)
+   #  run_callbacks(:before, command)
+   #  self.instance_eval(&block)
+   #  run_callbacks(:after, command)
+   #end
+
+    private
+
+    def cf_self
+      CfScript::Command.app name do |app_info|
+        @app_info = app_info if app_info
+      end
+    end
+  end
+end
+
+require 'cf_script/scope/app/state'
+require 'cf_script/scope/app/env'
+require 'cf_script/scope/app/routes'
+require 'cf_script/scope/app/utils'
+
+class CfScript::Scope::App
+  include State
+  include Env
+  include Routes
+  include Utils
+end

data/lib/cf_script/scope/proxy.rb

@@ -0,0 +1,36 @@
+require 'set'
+
+module CfScript
+  class Scope::Proxy
+    BASIC_OBJECT_METHODS = BasicObject.instance_methods.to_set
+    PROXY_OBJECT_METHODS = BASIC_OBJECT_METHODS | Set[
+      :object_id,
+      :instance_variables,
+      :instance_variable_get,
+      :instance_variable_set
+    ]
+
+    PROXY_OBJECT_INSTANCE_VARIABLES = Set[:@__inner__, :@__outer__]
+
+    instance_methods.each do |m|
+      undef_method(m) unless PROXY_OBJECT_METHODS.include?(m)
+    end
+
+    def initialize(inner, outer)
+      @__inner__ = inner
+      @__outer__ = outer
+    end
+
+    def instance_variables
+      super.select { |v| !PROXY_OBJECT_INSTANCE_VARIABLES.include?(v.to_sym) }
+    end
+
+    def method_missing(m, *args, &block)
+      if @__inner__.respond_to?(m.to_sym)
+        @__inner__.__send__(m.to_sym, *args, &block)
+      else
+        @__outer__.__send__(m.to_sym, *args, &block)
+      end
+    end
+  end
+end

data/lib/cf_script/scope/script.rb

@@ -0,0 +1,59 @@
+module CfScript::Scope
+  class Script < Target
+    attr_reader :options
+
+    VALID_OPTIONS = [:api, :org, :username, :password, :space]
+
+    include CfScript::UI
+
+    def initialize(options = {})
+      super()
+
+      @options = options
+    end
+
+    def run(&block)
+      apply_options unless options.empty?
+
+      exec_in(self, nil, &block)
+    end
+
+    def check_options
+      options.keys.each do |key|
+        unless VALID_OPTIONS.include?(key)
+          alert :options, "#{key} is not a valid option for the " +
+                          'cf method. It will be ignored.'
+        end
+      end
+    end
+
+    def apply_options
+      check_options
+
+      # If api is given and there are no username or password, set the api
+      if options[:api] and (options[:username].nil? or options[:password].nil?)
+        unless endpoint = CfScript::Command.api(options[:api])
+          error :cf, "Could not set the API endpoint: #{options[:api]}"
+          raise "Could not set the API endpoint: #{options[:api]}"
+        end
+      end
+
+      # If username and password are given, call login. This also sets the api
+      # and the space if they are given.
+      if options[:username] and options[:password]
+        unless CfScript::Command.login(options[:username], options[:password], options)
+          error :cf, 'Could not login with given credentials'
+          raise 'Could not login with given credentials'
+        end
+      end
+
+      # If a space is given, don't set it if there is a username and password,
+      # login would have already set it.
+      if options[:space] and (options[:username].nil? or options[:password].nil?)
+        # Use target, not CfScript::Command.target, so we can keep track of
+        # the previous and current spaces and reset them on scope exit.
+        target options[:space]
+      end
+    end
+  end
+end

data/lib/cf_script/scope/space.rb

@@ -0,0 +1,9 @@
+module CfScript::Scope
+  class Space < Target
+    def initialize(space_name = nil)
+      super()
+
+      target(space_name) if space_name
+    end
+  end
+end

data/lib/cf_script/scope/target.rb

@@ -0,0 +1,90 @@
+module CfScript::Scope
+  class Target < Base
+    def current_org
+      @current_target ? @current_target.org : ''
+    end
+
+    def current_space
+      @current_target ? @current_target.space : ''
+    end
+
+    def target(*args, &block)
+      unless args.empty?
+        # TODO: check if it's the same org too
+        if args.first.to_s == current_space
+          return @current_target
+        end
+      end
+
+      @current_target = CfScript::Command.run(:target, *args)
+
+      block_given? ? yield(@current_target) : @current_target
+    end
+
+    def space(space_name, &block)
+      space_scope = nil
+
+      if block_given?
+        space_scope = CfScript::Scope::Space.new(space_name)
+
+        exec_in(space_scope, nil, &block)
+      else
+        CfScript::Command.space(space_name)
+      end
+    ensure
+      space_scope.finalize if space_scope
+    end
+
+    def app(name_or_info, &block)
+      if block_given?
+        app = CfScript::Scope::App.new(name_or_info, @current_target)
+
+        exec_in(app, nil, &block)
+      else
+        app_name = name_or_info.respond_to?(:name) ? name_or_info.name : name_or_info
+
+        CfScript::Command.app(app_name)
+      end
+    end
+
+    def apps(options = {}, &block)
+      apps = CfScript::Command.apps
+
+      apps.select!(options) unless options.empty?
+
+      block_given? ? yield(apps) : apps
+    end
+
+    private
+
+    def target_desc(t)
+      desc = ''
+      desc << (t.org.nil? || t.org.empty? ? 'ORG-NOT-SET' : t.org)
+      desc << ':'
+      desc << (t.space.nil? || t.space.empty? ? 'SPACE-NOT-SET' : t.space)
+    end
+
+    def enter_scope
+      if current = target
+        @initial_target = @current_target = current
+      end
+
+      raise "Could not set initial and current targets" unless
+        @initial_target and @current_target
+
+      trace scope_name, "enter_scope: " +
+        "initial: (#{target_desc(@initial_target)}), " +
+        "current: (#{target_desc(@current_target)})"
+    end
+
+    def exit_scope
+      trace scope_name, "exit_scope: " +
+        "initial: (#{target_desc(@initial_target)}), " +
+        "current: (#{target_desc(@current_target)})"
+
+      if @initial_target.org != current_org or @initial_target.space != current_space
+        target(@initial_target)
+      end
+    end
+  end
+end