ergo 0.3.0

data/lib/ergo/book.rb

@@ -0,0 +1,218 @@
+module Ergo
+
+  ##
+  # Ergo rulebook stores defined states and rules.
+  #
+  # TODO: There are some minor namespace issues with this implementation.
+  #       We don't necessarily want a rule block to be able to
+  #       call #rule. However, the scoping is a bit complicated,
+  #       so it's an acceptable niggle for now.
+  #
+  class Book < Module
+
+    # Instantiate new system.
+    #
+    # Arguments
+    #    system - The system to which this book belongs. [System]
+    #    name   - Name of the book.
+    #
+    # Yields the script defining the books rules.
+    def initialize(system, name, &block)
+      extend ShellUtils
+      extend system
+      extend self
+
+      @scripts = []
+      @rules   = []
+      @states  = {}
+
+      @name    = name.to_s
+      @ignore  = system.ignore
+      @session = system.session
+
+      clear_rule_options
+
+      module_eval(&block) if block
+    end
+
+    # Book name
+    attr :name
+
+    # Current session.
+    attr :session
+
+    # Rule scripts.
+    attr :scripts
+
+    # Array of defined states.
+    attr :states
+
+    # Array of defined rules.
+    attr :rules
+
+    # Import from another file, or glob of files, relative to project root.
+    #
+    # TODO: Should importing be relative the importing file?
+    #
+    # Returns nothing.
+    def import(*globs)
+      globs.each do |glob|
+        #if File.relative?(glob)
+        #  dir = Dir.pwd  #session.root #File.dirname(caller[0])
+        #  glob = File.join(dir, glob)
+        #end
+        Dir[glob].each do |file|
+          next unless File.file?(file)  # add warning
+          next if @scripts.include?(file)
+          @scripts << file
+          module_eval(File.read(file), file)
+        end
+      end
+    end
+
+    # Add paths to be ignored in file rules.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def ignore(*globs)
+      @ignore.concat(globs) unless globs.empty?
+      @ignore
+    end
+
+    # Replace globs in ignore list.
+    #
+    # globs - List of file globs. [Array<String>]
+    #
+    # Returns [Array<String>]
+    def ignore!(*globs)
+      @ignore.replace(globs)
+      @ignore
+    end
+
+    # Define a named state. States define conditions that are used to trigger
+    # rules. Named states are kept in a hash table to ensure that only one state
+    # is ever defined for a given name. Calling state again with the same name
+    # as a previously defined state will redefine the condition of that state.
+    #
+    # Examples
+    #   state :no_rdocs? do
+    #     files = Dir.glob('lib/**/*.rb')
+    #     FileUtils.uptodate?('doc', files) ? files : false
+    #   end
+    #
+    # Returns nil if state name is given. [nil]
+    # Returns State in no name is given. [State]
+    def state(name=nil, &condition)
+      if name
+        if condition
+          @states[name.to_sym] = condition
+          define_method(name) do |*args|
+            state = @states[name.to_sym]
+            State.new{ states[name.to_sym].call(*args) }
+          end
+        else
+          raise ArgumentError
+        end
+      else
+        State.new{ condition.call(*args) }
+      end
+    end
+
+    # Define a file state.
+    #
+    # Returns [FileState]
+    def file(pattern)
+      FileState.new(pattern)
+    end
+
+    # Define an environment state.
+    #
+    # Examples
+    #   env('PATH'=>/foo/)
+    #
+    # Returns [State]
+    def env(name_to_pattern)
+      State.new do
+        name_to_pattern.any? do |name, re|
+          re === ENV[name.to_s]  # or `all?` instead?
+        end
+      end
+    end
+
+    # Define a rule. Rules are procedures that are tiggered 
+    # by logical states.
+    #
+    # Examples
+    #   rule no_rdocs do |files|
+    #     sh "rdoc --output doc/rdoc " + files.join(" ")
+    #   end
+    #
+    # Returns [Rule]
+    def rule(state, &procedure)
+      case state
+      when String, Regexp
+        state = file(state)
+      when Symbol
+        # TODO: Is this really the best idea?
+        #@states[state.to_sym]
+      end
+      rule = Rule.new(state, get_rule_options, &procedure)
+      @rules << rule
+      clear_rule_options
+      rule
+    end
+
+    # Check a name state.
+    #
+    # Returns [Array,Boolean]
+    def state?(name, *args)
+      @states[name.to_sym].call(*args)
+    end
+
+    # Set rule description. The next rule defined will get the most
+    # recently defined description attached to it.
+    #
+    # Returns [String]
+    def desc(description)
+      @_desc = description
+    end
+
+    # Bookmark the rule.
+    #
+    # Returns nothing.
+    def mark(*names)
+      @_mark.concat(names)
+    end
+    alias :bookmark :mark
+
+    #
+    #
+    def private(*methods)
+      @_priv = true
+      super(*methods)   # TODO: why doesn't this work as expected?
+    end
+
+    # Issue notification.
+    #
+    # Returns nothing.
+    def notify(message, options={})
+      title = options.delete(:title) || 'Fire Notification'
+      Notify.notify(title, message.to_s, options)
+    end
+
+  private
+
+    def get_rule_options     
+      { :desc=>@_desc, :mark=>@_mark, :private=>@_priv }
+    end
+
+    def clear_rule_options
+      @_mark = [name].compact
+      @_desc = nil
+      @_priv = false
+    end
+
+  end
+
+end

data/lib/ergo/cli.rb

@@ -0,0 +1,185 @@
+module Ergo
+
+  ##
+  # Fire's command line interface.
+  #
+  class CLI
+
+    # Fire her up!
+    def self.fire!(argv=ARGV)
+      new(argv).fire!
+    end
+
+    # Initialize new instance of Ergo::CLI.
+    # If `argv` is not provided than ARGV is uses.
+    #
+    # argv - Command line argument. [Array<String>]
+    #
+    # Returns nothing.
+    def initialize(argv=nil)
+      begin
+        require 'dotopts'
+      rescue LoadError
+      end
+
+      @argv = Array(argv || ARGV)
+
+      @script = nil
+      @watch  = nil
+      @fresh  = false
+    end
+
+    # Returns runner instance. [Runner]
+    def runner
+      @runner ||= (
+        Runner.new(
+          :script => @script,
+          :fresh  => @fresh,
+          :watch  => @watch
+        )  
+      )
+    end
+
+    # Execute command.
+    #
+    # command - Which command to execute.
+    #
+    # Returns nothing.
+    def fire!(argv=ARGV)
+      $DEBUG = argv.include?('--debug') || $DEBUG
+      return fire if $DEBUG
+      begin
+        fire
+      rescue => err
+        puts "ergo: error #{err}"
+      end
+    end
+
+    # Fire her up!
+    def fire
+      args = cli_parse
+
+      ensure_options(args)
+
+      #if args.first == 'init' && !runner.root?
+      #  init_project(*args)
+      #end
+
+      case @command
+      when :list
+        print_rules(*args)
+      else
+        runner.run(*args)
+      end
+    end
+
+    # Parse command line arguments with just the prettiest
+    # little CLI parser there ever was.
+    def cli_parse
+      @command = nil
+
+      cli @argv,
+        "-R --rules"  => lambda{ @command = :list },
+        "-a --auto"   => method(:watch=),
+        "-f --fresh"  => method(:fresh!),
+        "-s --script" => method(:script=),
+        "   --debug"  => method(:debug!)
+    end
+
+    #
+    def ensure_options(args)
+      erropts = args.select{ |a| a.start_with?('-') }
+      unless erropts.empty?
+        raise "unsupported options #{erropts.join(' ')}" 
+      end
+    end
+
+    # Shall we make a fresh start of it, and remove all digests?
+    #
+    # Returns [Boolean]
+    def fresh?
+      @fresh
+    end
+
+    # Set fresh flag to true.
+    #
+    # Returns [Boolean]
+    def fresh! 
+      @fresh = true
+    end
+
+    # Shall we make a fresh start of it, and remove all digests?
+    #
+    # Returns [Boolean]
+    def debug?
+      @debug
+    end
+
+    # Set debug flag to true.
+    #
+    # Returns [Boolean]
+    def debug! 
+      @debug = true
+    end
+  
+    # Set the "watch" period --the rate at which
+    # autofiring of occurs.
+    #
+    # Returns [Fixnum[
+    def watch=(seconds)
+      @watch = seconds.to_i
+    end
+
+    # Use alternate ergo script.
+    #
+    # Returns [Array]
+    def script=(script)
+      @script = script.to_s
+    end
+
+    #
+    #
+    # Returns nothing.
+    def init_project(*args)
+      FileUtils.mkdir_p('.ergo')
+    end
+
+    # Print out a list of availabe manual triggers.
+    #
+    # Returns nothing.
+    def print_rules(*names)
+      names = nil if names.empty?
+
+      list = []
+      runner.rules.each do |rule|
+        if Book === rule
+          rule.rules.each do |r|
+            next unless names.any?{ |n| r.mark?(n) } if names
+            list << r.to_a
+          end
+        else         
+          next unless names.any?{ |n| rule.mark?(n) } if names
+          list << rule.to_a
+        end
+      end
+
+      list.reject!{ |desc, marks, prv| desc.to_s == "" }
+
+      puts "(#{runner.root})"
+
+      i = 1
+      list.each do |desc, marks, prv|
+        if marks.empty?
+          puts "%4d. %s%s" % [i, desc, prv ? '*' : '']
+        else
+          puts "%4d. %s%s (%s)" % [i, desc, prv ? '*' : '', marks.join(' ')]
+        end
+        i += 1
+      end
+
+      exit
+    end
+
+  end
+
+end

data/lib/ergo/core_ext.rb

@@ -0,0 +1,4 @@
+#require 'facets/cli'
+require 'ergo/core_ext/cli'
+require 'ergo/core_ext/boolean'
+require 'ergo/core_ext/true_class'

data/lib/ergo/core_ext/boolean.rb

@@ -0,0 +1,10 @@
+module Boolean
+end
+
+class TrueClass
+  include Boolean
+end
+
+class FalseClass
+  include Boolean
+end

data/lib/ergo/core_ext/cli.rb

@@ -0,0 +1,56 @@
+module Kernel
+  private
+  #
+  # CLI is based on Clap library
+  # Copyright (c) 2010 Michel Martens
+  #
+  def cli(*args)
+    opts = (Hash === args.last ? args.pop : nil)
+    argv = args.first || ARGV.dup
+    args = []
+
+    #raise ArgumentError unless opts
+
+    # Split option aliases.
+    opts = opts.inject({}) do |h,(k,v)|
+      k.to_s.split(/\s+/).each{|o| h[o]=v}; h
+    end
+
+    # Convert single dash flags into multiple flags.
+    argv = argv.inject([]) do |a, v|
+      if v[0,1] == '-' && v[1,1] != '-'
+        a.concat(v[1..-1].chars.map{|c| "-#{c}"})
+      else
+        a << v
+      end
+      a
+    end
+
+    while argv.any?
+      item = argv.shift
+      flag = opts[item]
+
+      if flag
+        # Work around lambda semantics in 1.8.7.
+        arity = [flag.arity, 0].max
+
+        # Raise if there are not enough parameters
+        # available for the flag.
+        if argv.size < arity
+          raise ArgumentError
+        end
+
+        # Call the lambda with N items from argv,
+        # where N is the lambda's arity.
+        flag.call(*argv.shift(arity))
+      else
+
+        # Collect the items that don't correspond to
+        # flags.
+        args << item
+      end
+    end
+
+    args
+  end
+end