dotum 0.0.0

data/lib/dotum/abstract_rules/options_base.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+class Dotum::AbstractRules::OptionsBase < Dotum::AbstractRules::Base
+
+  def self.exec(context, *args, &block)
+    options = option_defaults.merge(expand_shorthand(*args))
+    options.merge! eval_options_block(&block) if block
+
+    if errors = validate_options(options)
+      raise "Validation errors: #{errors.inspect}"
+    end
+
+    if respond_to? :expand_options
+      expand_options(context, options).map { |rule_options|
+        new(context, rule_options).exec
+      }
+    else
+      new(context, options).exec
+    end
+  end
+
+  def initialize(context, options)
+    super(context)
+
+    options.each do |option, value|
+      filter = self.class.option_configs[option][:filter]
+      value = instance_exec(value, &filter) if filter && !value.nil?
+
+      instance_variable_set(:"@#{option}", value)
+    end
+  end
+
+end

data/lib/dotum/autoload_convention.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+# Autoload Convention
+# ===================
+# We adhere to a strict convention for the constants in this library:
+#
+# `Camel::Caps::BasedConstants` map to their underscore variants of
+# `camel/caps/based_constants`.
+#
+# Each autoloadable parent module/class only needs to to `extend` the
+# `AutoloadConvention` to bootstrap this behavior.
+module Dotum
+  module AutoloadConvention
+
+    # `autoload` is dead, and we don't want to deal with its removal in 2.0,
+    # so here's a thread-unsafe poor man's solution.
+    def const_missing(sym)
+      full_sym   = "#{name}::#{sym}"
+      path_parts = full_sym.split("::").map { |part|
+        part.gsub! /([^A-Z])([A-Z]+)/,       "\\1_\\2" # OneTwo -> One_Two
+        part.gsub! /([A-Z]+)([A-Z][^A-Z]+)/, "\\1_\\2" # ABCOne -> ABC_One
+
+        part.downcase
+      }
+
+      require File.join(path_parts)
+
+      # Make sure that we don't get stuck in an endless loop.  `const_get` calls
+      # into `const_missing`, so we can't use that.
+      eval "defined?(#{full_sym}) ? #{full_sym} : super"
+    end
+
+  end
+end

data/lib/dotum/cli.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+class Dotum::CLI
+
+  def self.exec(args)
+    new(args).exec!
+  end
+
+  def initialize(args)
+    @args = args
+
+    @state_dir  = Dotum::Util::Path.new("~/.dotum")
+    @target_dir = Dotum::Util::Path.new("~")
+    @package_dir = Dotum::Util::Path.new("~/.dotum/local")
+  end
+
+  def exec!
+    context = Dotum::Context.new(
+      # :no_remote  => true,
+      :state_dir  => @state_dir,
+      :target_dir => @target_dir,
+      :logger     => Dotum::Logger.new
+    )
+
+    unless @package_dir.directory?
+      puts
+      puts "#{@package_dir.pretty} doesn't exist!  Creating for now..."
+      @package_dir.mkpath!
+    end
+
+    Dotum::Rules::UseRepo.exec(context, @package_dir)
+    print "\n\n"
+  end
+
+end

data/lib/dotum/context.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+class Dotum::Context
+
+  def initialize(attributes={})
+    set_attributes(attributes)
+  end
+
+  attr_reader :package_dir
+  attr_reader :target_dir
+  attr_reader :state_dir
+
+  attr_reader :logger
+  attr_reader :depth
+
+  def no_remote?
+    @no_remote
+  end
+
+  def attributes
+    result = {}
+    instance_variables.each do |var_name|
+      result[var_name[1..-1].to_sym] = instance_variable_get(var_name)
+    end
+
+    result
+  end
+
+  def fork(new_attributes={})
+    self.class.new(attributes.merge(new_attributes || {}))
+  end
+
+  def child(new_attributes={})
+    new_attributes ||= {}
+    new_attributes[:depth] = (@depth || 0) + 1
+
+    fork(new_attributes)
+  end
+
+private
+
+  def set_attributes(attributes)
+    attributes.each_pair do |key, value|
+      case key
+      when :package_dir then @package_dir = Dotum::Util::Path.new(value)
+      when :target_dir then @target_dir = Dotum::Util::Path.new(value)
+      when :state_dir  then @state_dir  = Dotum::Util::Path.new(value)
+      when :logger     then @logger     = value
+      when :no_remote  then @no_remote  = value
+      when :depth      then @depth      = value
+      end
+    end
+  end
+
+end

data/lib/dotum/externs/json.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+begin
+  require "json"
+rescue LoadError
+  # Fall back to the embedded pure-Ruby JSON implementation.
+  $LOAD_PATH.unshift(Dotum::EXTERN_PATH.join("json", "lib").to_s)
+  require "json"
+end

data/lib/dotum/logger.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+class Dotum::Logger
+  include Dotum::Util::ANSIColors
+
+  INDENT = "  "
+
+  def start_rule(rule)
+    @last_rule       = rule
+    @last_rule_start = Time.now
+
+    print "\n"
+    print rule_line(rule)
+  end
+
+  def finish_rule(rule, status, reason)
+    message = "#{rule_line(rule)} - #{status.inspect} - #{reason.inspect}"
+    if @last_rule == rule
+      delta = (Time.now - @last_rule_start) * 1000.0
+      message += " (%.2fms)" % delta
+
+      print "\r"
+    else
+      print "\n\n"
+    end
+
+    print message
+  end
+
+private
+
+  def rule_line(rule)
+    indent  = INDENT * rule.context.depth
+    action  = rule.class.pretty
+    subject = rule.pretty_subject
+
+    action  = c_cyan(action)
+    subject = colorize_subject(subject)
+
+    "#{indent}#{action}: #{subject}"
+  end
+
+  SUBJECT_MATCHER = /^(.*?)( \(.+\))?$/
+  def colorize_subject(subject)
+    match = SUBJECT_MATCHER.match(subject)
+
+    "#{c_magenta(match[1])}#{match[2]}"
+  end
+
+end

data/lib/dotum/options_context.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require "set"
+
+class Dotum::OptionsContext < Hash
+
+  def initialize(option_configs)
+    @known_options = Set.new(option_configs.keys)
+  end
+
+  def method_missing(sym, *args)
+    super if args.size != 1
+
+    unless @known_options.include? sym
+      raise ArgumentError, "Unknown option '#{sym}'"
+    end
+
+    self[sym] = args[0]
+  end
+
+end

data/lib/dotum/rule_dsl.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require "rbconfig"
+
+module Dotum::RuleDSL
+
+  def success!(reason=nil)
+    throw :finish_rule, [:success, reason]
+  end
+
+  def failure!(reason=nil)
+    throw :finish_rule, [:failure, reason]
+  end
+
+  def skip!(reason=nil)
+    throw :finish_rule, [:skip, reason]
+  end
+
+  def platform?(name)
+    os = RbConfig::CONFIG["host_os"].downcase
+
+    case name
+    when /os\s?x/i     then /mac|darwin/      === os
+    when /win(dows)?/i then /mswin|win|mingw/ === os
+    when /linux/i      then /linux|cygwin/    === os
+    when /bsd/i        then /bsd/             === os
+    when /solaris/i    then /solaris|sunos/   === os
+    else
+      if name.is_a? Regexp
+        name === os
+      else
+        Regexp.new(name, "i") === os
+      end
+    end
+  end
+
+  def available?(command)
+    # TODO: Windows friendly.
+    `which "#{command}"`
+    $?.success?
+  end
+
+  def package_dir
+    context.package_dir
+  end
+
+  def target_dir
+    context.target_dir
+  end
+
+  def state_dir
+    context.state_dir
+  end
+
+  def method_missing(sym, *args, &block)
+    rule_class_name = sym.to_s.split("_").map(&:capitalize).join.to_sym
+
+    begin
+      rule_class = Dotum::Rules.const_get(rule_class_name)
+    rescue LoadError
+      raise NoMethodError, "Unknown rule #{sym}.  Tried to load Dotum::Rules::#{rule_class_name}: #{$!.message}"
+    end
+
+    Dotum::RuleDSL.module_eval <<-end_eval, __FILE__, __LINE__
+      def #{sym}(*args, &block)
+        Dotum::Rules::#{rule_class_name}.exec(context, *args, &block)
+      end
+    end_eval
+
+    send(sym, *args, &block)
+  end
+
+end

data/lib/dotum/rule_options_dsl.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module Dotum::RuleOptionsDSL
+
+  OptionConfig = Struct.new(:filter, :validator, :default)
+
+
+  # DSL
+  # ---
+
+  def shorthand(*args)
+    @shorthand_config ||= args
+  end
+
+  def required(option, &block)
+    (@option_configs ||= {})[option] = OptionConfig.new(
+      block,
+      proc { |v| "Option '#{option}' is required." if v.nil? }
+    )
+  end
+
+  def optional(option, default=nil, &block)
+    (@option_configs ||= {})[option] = OptionConfig.new(block, nil, default)
+  end
+
+  def standard(option)
+    option_module_name = option.to_s.split("_").map(&:capitalize).join.to_sym
+
+    begin
+      option_module = Dotum::StandardOptions.const_get(option_module_name)
+    rescue LoadError
+      raise "Unknown standard option '#{option}'.  Tried to load Dotum::StandardOptions::#{option_module_name}: #{$!.message}"
+    end
+
+    module_configs = option_module.instance_variable_get(:@option_configs)
+    unless module_configs && module_configs[option]
+      raise "Dotum::StandardOptions::#{option_module_name} is misconfigured; expected it to define the option '#{option}'"
+    end
+
+    include option_module
+  end
+
+  def register_preprocessor(sym)
+    @preprocessors ||= []
+    @preprocessors.push(sym)
+  end
+
+
+  # Configuration Management
+  # ------------------------
+
+  def option_configs
+    @memoized_option_configs ||= ancestors.reverse_each.reduce({}) { |result, ancestor|
+      result.merge(ancestor.instance_variable_get(:@option_configs) || {})
+    }
+  end
+
+  def option_defaults
+    @memoized_option_defaults ||= {}.tap do |defaults|
+      option_configs.each do |option, config|
+        defaults[option] = config[:default] unless config[:default].nil?
+      end
+    end
+  end
+
+  def preprocessor_methods
+    @memoized_preprocessor_methods ||= ancestors.map { |ancestor|
+      ancestor.instance_variable_get(:@preprocessors)
+    }.compact.flatten
+  end
+
+  def shorthand_config
+    return @shorthand_config if defined? @shorthand_config
+    return superclass.shorthand_config if superclass.respond_to? :shorthand_config
+
+    []
+  end
+
+  def expand_shorthand(*args)
+    result = {}
+    shorthand_config.zip(args).each do |config, value|
+      case config
+      when Symbol then result[config] = value
+      when Hash
+        if value.is_a? Hash
+          result[config.keys.first]   = value.keys.first
+          result[config.values.first] = value.values.first
+        else
+          result[config.keys.first] = value
+        end
+      end
+    end
+
+    result
+  end
+
+  def eval_options_block(&block)
+    options = Dotum::OptionsContext.new(option_configs)
+    options.instance_eval(&block)
+
+    options
+  end
+
+  def validate_options(options)
+    errors = []
+    option_configs.each do |option, config|
+      next unless validator = config[:validator]
+      next unless error = validator.call(options[option])
+
+      errors.push(error)
+    end
+
+    errors.size > 0 ? errors : nil
+  end
+
+end

data/lib/dotum/rule_runner.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+class Dotum::RuleRunner
+  include Dotum::RuleDSL
+
+  def self.eval(context, *args, &block)
+    new(context).instance_eval(*args, &block)
+  end
+
+  def initialize(context)
+    @context = context
+  end
+
+  attr_reader :context
+
+end