loom-core 0.0.1

data/lib/loom/logger.rb

@@ -0,0 +1,141 @@
+require 'logger'
+
+module Loom
+  class Logger
+    COLOR_MAP = {
+      :d => :green,
+      :i => :blue,
+      :w => :yellow,
+      :e => :red,
+      :f => :pink
+    }
+
+    class << self
+      def configure(config)
+        device = configure_device config.log_device
+
+        logger = ::Logger.new device
+        class << logger
+          include LoggerDebugLevels
+        end
+        raise "missing logger debug methods" unless logger.respond_to? :debug1
+
+        logger.level = case config.log_level
+                       when Symbol, String
+                         ::Logger.const_get config.log_level.to_s.upcase
+                       when Integer
+                         # Negative numbers can be used for detailed debug levels
+                         config.log_level
+                       end
+
+        colorize = config.log_colorize && device.tty?
+        logger.formatter = default_formatter colorize
+
+        if config.log_colorize && !device.tty?
+          logger.warn "disabled log colorization for non-tty"
+        end
+
+        logger
+      end
+
+      private
+      def configure_device(device_value)
+        case device_value
+        when :stderr, 'stderr'
+          STDERR
+        when :stdout, 'stdout'
+          STDOUT
+        when :devnull, 'devnull'
+          File.new '/dev/null', 'a'
+        when Integer
+          IO.new device_value, 'a'
+        when String
+          File.new device_value, 'a'
+        when StringIO
+          device_value
+        else
+          raise ConfigError, "log_device => #{device_value}"
+        end
+      end
+
+      def default_formatter(colorize)
+        lambda do |severity, datetime, progname, msg|
+          s_key = severity[0].downcase.to_sym
+          if colorize && COLOR_MAP[s_key]
+            severity = Styleizer.apply severity, COLOR_MAP[s_key]
+            progname = Styleizer.apply progname, :bold, :dark_gray
+          end
+
+          if progname
+            "[%s] (%s): %s\n" % [severity, progname, msg]
+          else
+            "[%s] %s\n" % [severity, msg]
+          end
+        end
+      end
+    end
+
+    module LoggerDebugLevels
+      NUM_DEBUG_LEVELS = 6
+
+      ##
+      # Adds methods debug1, debug2, ... debug6 for more detailed
+      # debug levels. Set a negative index +logger.level+ to enable
+      # lower levels, e.g. logger.level = -6 for debug6 messages.
+      (1..NUM_DEBUG_LEVELS).to_a.each do |debug_level|
+        debug_method_name = "debug#{debug_level}"
+
+        define_method debug_method_name do |*args, &block|
+          severity = debug_level * -1
+          return if severity < self.level
+
+          debug_at_level severity, *args, &block
+        end
+      end
+
+      def format_severity(severity)
+        if severity < ::Logger::DEBUG
+          return "D" + severity.abs.to_s
+        else
+          super(severity)[0]
+        end
+      end
+
+      private
+      def debug_at_level(severity, progname=nil, &block)
+        raise 'block required for super debug loggers' unless block_given?
+        raise 'progname required for super debug loggers' unless progname
+
+        add severity, nil, progname, &block
+      end
+    end
+
+    class Styleizer
+      class << self
+
+        STYLE_CODES = {
+          :bold => 1,
+          :red => 31,
+          :green => 32,
+          :yellow => 33,
+          :blue => 34,
+          :pink => 35,
+          :light_blue => 36,
+          :light_gray => 37,
+          :dark_gray => 90
+        }
+
+        def apply(str, *styles)
+          return str unless str
+          styles.reduce(str) { |str, style| styleize STYLE_CODES[style], str }
+        end
+
+        private
+        def styleize(color_code, str)
+          "\e[#{color_code}m#{str}\e[0m"
+        end
+      end
+    end
+
+  end
+end

data/lib/loom/method_signature.rb

@@ -0,0 +1,174 @@
+module Loom
+
+  # Used to analyze the arguments of a method.
+  class MethodSignature
+
+    module ParamType
+      REQ = :req
+      OPT = :opt
+      REST = :rest
+      KEYREQ = :keyreq
+      KEY = :key
+      KEYREST = :keyrest
+      BLOCK = :block
+    end
+
+    # @param proc_or_method [#parameters] A {Proc} or {Method}
+    def initialize(proc_or_method)
+      @parameter_list = proc_or_method.parameters
+      @req_args = find_by_type ParamType::REQ
+      @opt_args = find_by_type ParamType::OPT
+      @rest_args = find_by_type ParamType::REST
+      @keyreq_args = find_by_type ParamType::KEYREQ
+      @key_args = find_by_type ParamType::KEY
+      @keyrest_args = find_by_type ParamType::KEYREST
+      @block_args = find_by_type ParamType::BLOCK
+    end
+
+    attr_reader :req_args, :opt_args, :rest_args, :keyreq_args, :key_args,
+                :keyrest_args, :block_args
+
+    def find_by_type(type)
+      @parameter_list.find_all { |tuple| tuple.first == type }
+    end
+
+    # Defines has_xyz_args? methods for each {ParamType}.
+    def method_missing(name, *args)
+      match_data = name.to_s.match /^has_([^?]+)_args\?$/
+      if match_data
+        method = "%s_args" % [match_data[1]]
+        !self.send(method.to_sym).empty?
+      else
+        super name, *args
+      end
+    end
+
+    class MatchSpec
+
+      class Builder
+        def initialize
+          @map = {
+            :req_args => 0,
+            :opt_args => 0,
+            :has_rest_args => false,
+            :keyreq_args => 0,
+            :key_args => 0,
+            :has_keyrest_args => false,
+            :has_block => false
+          }
+        end
+
+        def method_missing(name, value, *args)
+          @map[name.to_sym] = value
+          self
+        end
+
+        def build
+          MatchSpec.new(@map || {})
+        end
+      end
+
+      class << self
+        def builder
+          Builder.new
+        end
+      end
+
+      # @param req_args [Fixnum] Number of required args, nil for any.
+      # @param opt_args [Fixnum] Number of optional args, nil for any.
+      # @param has_rest_args [Boolean] Whether a *args is defined, nil
+      #     for any. If +has_rest_args+ is true then any number of req or opt
+      #     args will satisfy this match.
+      # @param keyreq_args [Fixnum] Number of required keyward args, nil
+      #     for any.
+      # @param key_args [Fixnum] Number of optional keyward args, nil
+      #     for any.
+      # @param has_keyrest_args [Boolean] Whether a **opts is defined,
+      #     nil for any. If +has_keyrest_args+ is true, then any number of
+      #     keyreq or key args will satisfy this match for name named opts.
+      # @param has_block [Boolean] Whether a block is defined, nil for any.
+      def initialize(
+            req_args: nil,
+            opt_args: nil,
+            has_rest_args: nil,
+            keyreq_args: nil,
+            key_args: nil,
+            has_keyrest_args: nil,
+            has_block: nil)
+        @req_args = req_args
+        @opt_args = opt_args
+        @has_rest_args = has_rest_args
+        @keyreq_args = keyreq_args
+        @key_args = key_args
+        @has_keyrest_args = has_keyrest_args
+        @has_block = has_block
+      end
+
+      # @return [Boolean]
+      def match?(method)
+        method_sig = MethodSignature.new method
+
+        # *args definition matches any call.
+        return true if @has_rest_args
+
+        check_ordered_args(method_sig) &&
+          check_keyword_args(method_sig) &&
+          check_block_args(method_sig)
+      end
+
+      private
+      def check_ordered_args(method_sig)
+        rest = check_rest(method_sig)
+        if rest && method_sig.has_rest_args?
+          Loom.log.debug1(self) { "returning from failed addon look"}
+          return true
+        end
+
+        return rest &&
+               check_req_args(method_sig) &&
+               check_opt_args(method_sig);
+      end
+
+      def check_rest(method_sig)
+        @has_rest_args.nil? || method_sig.has_rest_args? == @has_rest_args
+      end
+
+      def check_req_args(method_sig)
+        @req_args.nil? || @req_args == method_sig.req_args.size
+      end
+
+      def check_opt_args(method_sig)
+        @opt_args.nil? || @opt_args == method_sig.opt_args.size
+      end
+
+      def check_keyword_args(method_sig)
+        return true if @has_keyrest_args
+
+        return check_keyrest(method_sig) &&
+               check_keyreq_args(method_sig) &&
+               check_key_args(method_sig);
+      end
+
+      def check_keyrest(method_sig)
+        @has_keyrest_args.nil? || method_sig.has_keyrest_args? == @has_keyrest_args
+      end
+
+      def check_keyreq_args(method_sig)
+        @keyreq_args.nil? ||
+          @keyreq_args == method_sig.keyreq_args.size ||
+          method_sig.has_keyrest_args?
+      end
+
+      def check_key_args(method_sig)
+        @key_args.nil? ||
+          @key_args == method_sig.key_args.size ||
+          method_sig.has_keyrest_args?
+      end
+
+      def check_block_args(method_sig)
+        return true if @has_block.nil?
+        return method_sig.has_block_args? == @has_block
+      end
+    end
+  end
+end

data/lib/loom/mods.rb

@@ -0,0 +1,4 @@
+module Loom::Mods
+end
+
+require 'loom/mods/all'

data/lib/loom/mods/action_proxy.rb

@@ -0,0 +1,105 @@
+# TODO: The method names in this file are atrocious and confusing, need to
+# rethink these names and simplify this class.
+module Loom::Mods
+  class ActionProxy
+
+    def initialize(mod, shell_api)
+      @mod = mod
+      @shell_api = shell_api
+      @nested_action_proxies = {}
+    end
+
+    def proxy_for_namespace(ns=nil)
+      ns.nil? ? self : @nested_action_proxies[ns]
+    end
+
+    private
+
+    class << self
+      def new_action_map
+        ActionMap.new
+      end
+
+      def subclass_for_action_map(action_map)
+        sub_class = Class.new ActionProxy
+        sub_class.install_action_map action_map
+        sub_class
+      end
+
+      def install_action_map(action_map)
+        install_root_actions action_map
+        install_namespace_action_proxies action_map
+      end
+
+      def install_root_actions(action_map)
+        action_map.action_tuples.each do |tuple|
+          public_action_name = tuple[0]
+          # TODO: What I've done here w/ bound_action_name (remapping methods
+          # from a given name to a flattened namespace on the Mod object) is
+          # very very strange. Just storing/binding/calling a Proc would be more
+          # idiomatic.
+          bound_action_name = tuple[1]
+
+          define_method public_action_name do |*args, &block|
+            # TODO: Effectively this is the API for all mods, but it's burried
+            # here in the middle of nowhere. Add documentation - or make it
+            # easier to read.
+            Loom.log.debug2(self) do
+              "proxy to mod #{@mod} => #{public_action_name}: #{args} #{block}"
+            end
+
+            @mod.send bound_action_name, *args, &block
+          end
+          Loom.log.debug2 self do
+            "defined action proxy action: #{public_action_name} => #{bound_action_name}"
+          end
+        end
+      end
+
+      ##
+      # This gets a bit tricky
+      def install_namespace_action_proxies(action_map)
+        action_map.ns_actionmaps.each do |ns, ns_action_map|
+          @nested_action_proxy_klasses ||= {}
+          @nested_action_proxy_klasses[self.hash] ||= {}
+          @nested_action_proxy_klasses[self.hash][ns] ||=
+            ActionProxy.subclass_for_action_map ns_action_map
+          action_proxy_klass = @nested_action_proxy_klasses[self.hash][ns]
+
+          define_method ns do
+            @nested_action_proxies[ns] ||= action_proxy_klass.new @mod
+          end
+          Loom.log.debug2 self do
+            "defined action proxy ns: #{ns}"
+          end
+        end
+      end
+
+    end
+
+    class ActionMap
+
+      attr_reader :action_tuples, :ns_actionmaps
+
+      def initialize
+        @action_tuples = []
+        @ns_actionmaps = {}
+      end
+
+      def add_action(action_name, bound_method_name, namespace=nil)
+        if namespace.nil?
+          tuple = [action_name, bound_method_name]
+          @action_tuples << tuple unless namespace 
+        else
+          # Adds an action name to a nested ActionMap
+          add_namespace(namespace).add_action action_name, bound_method_name
+        end
+      end
+
+      private
+      def add_namespace(ns)
+        @ns_actionmaps[ns] ||= ActionMap.new
+      end
+    end
+  end
+end

data/lib/loom/mods/all.rb

@@ -0,0 +1,3 @@
+require_relative "mod_loader"
+require_relative "action_proxy"
+require_relative "module"

data/lib/loom/mods/mod_loader.rb

@@ -0,0 +1,80 @@
+module Loom::Mods
+
+  AliasRegisteredError = Class.new Loom::LoomError
+  AnonymousModLoadError = Class.new Loom::LoomError
+  ModDefinedError = Class.new Loom:: LoomError
+  ModNotRegisteredError = Class.new Loom::LoomError
+
+  class ModLoader
+    def initialize(loom_config)
+      @loom_config = loom_config
+    end
+
+    def verify_shell_cmds(shell, mod_klass)
+      Loom.log.debug2(self) { "verifying cmds for mod => #{mod_klass}" }
+      mod_klass.required_commands.each do |cmd|
+        begin
+          shell.verify_which cmd
+        rescue Loom::Shell::VerifyError
+          Loom.log.error "unable to use mod #{mod_klass}, missing required command => #{cmd}"
+          raise $!
+        end
+      end
+    end
+
+    class << self
+
+      def register_mod(klass, name, **opts)
+        name = name.to_sym
+        raise AnonymousModLoadError, 'cannot load anonymous mods' unless name
+        raise ModDefinedError, name if instance_methods.include? name
+
+        define_mod_factory name, klass
+        Loom.log.debug1(self) { "registered mod => #{klass} as #{name}" }
+
+        opts.each do |k,v|
+          case k
+          when :alias
+            [v].flatten.each { |v| alias_module klass, v }
+          else
+            raise "unknown option #{k}"
+          end
+        end
+      end
+
+      # TODO: add some documentation here, this is the entrypoint for all mod
+      # factories and returning the ActionProxy or running a ModBlock. This is
+      # just as hidden as ActionProxy+install_root_actions+
+      def define_mod_factory(name, mod_klass)
+        raise ModDefinedError, name if instance_methods.include? name
+        registered_mods[mod_klass.name] = [name]
+
+        define_method name do |shell, *args, &pattern_block|
+          Loom.log.debug3(self) do
+            "handling mod call => #{mod_klass}##{name} #{args} #{pattern_block}"
+          end
+          verify_shell_cmds shell, mod_klass
+
+          mod = mod_klass.new shell, @loom_config
+          mod.execute *args, &pattern_block
+        end
+      end
+
+      def registered_mods
+        @registered_mods ||= {}
+      end
+
+      private
+      def alias_module(klass, alias_name)
+        raise ModNotRegisteredError, klass unless registered_mods[klass.name]
+        raise AliasRegisteredError, alias_name if instance_methods.include? alias_name
+
+        original_method = registered_mods[klass.name].first
+        registered_mods[klass.name] << alias_name
+
+        alias_method alias_name.to_sym, original_method
+        Loom.log.debug1(self) { "mod aliased => #{original_method} as #{alias_name}" }
+      end
+    end
+  end
+end