fire 0.2.0

data/lib/fire/shellutils.rb

@@ -0,0 +1,77 @@
+module Fire
+
+  # TODO: Borrow code from Detroit for ShellUtils and beef her up!
+
+  # File system utility methods.
+  #
+  module ShellUtils
+    # Shell out via system call.
+    #
+    # Arguments
+    #   args - Argument vector. [Array]
+    #
+    # Returns success of shell invocation.
+    def sh(*args)
+      puts args.join(' ')
+      system(*args)
+    end
+
+    def directory?(path)
+      File.directory?(path)
+    end
+
+    #
+    # Synchronize a destination directory with a source directory.
+    #
+    # TODO: Augment FileUtils instead.
+    # TODO: Not every action needs to be verbose.
+    #
+    def sync(src, dst, options={})
+      src_files = Dir[File.join(src, '**', '*')].map{ |f| f.sub(src+'/', '') }
+      dst_files = Dir[File.join(dst, '**', '*')].map{ |f| f.sub(dst+'/', '') }
+
+      removal = dst_files - src_files
+
+      rm_dirs, rm_files = [], []
+      removal.each do |f|
+        path = File.join(dst, f)
+        if File.directory?(path)
+          rm_dirs << path
+        else
+          rm_files << path
+        end
+      end
+
+      rm_files.each { |f| rm(f) }
+      rm_dirs.each  { |d| rmdir(d) }
+
+      src_files.each do |f|
+        src_path = File.join(src, f)
+        dst_path = File.join(dst, f)
+        if File.directory?(src_path)
+          mkdir_p(dst_path)
+        else
+          parent = File.dirname(dst_path) 
+          mkdir_p(parent) unless File.directory?(parent)
+          install(src_path, dst_path)
+        end
+      end
+    end
+
+    #
+    # If FileUtils responds to a missing method, then call it.
+    #
+    def method_missing(s, *a, &b)
+      if FileUtils.respond_to?(s)
+        if $DRYRUN
+          FileUtils::DryRun.__send__(s, *a, &b)
+        else
+          FileUtils::Verbose.__send__(s, *a, &b)
+        end
+      else
+        super(s, *a, &b)
+      end
+    end
+  end
+
+end

data/lib/fire/state.rb

@@ -0,0 +1,91 @@
+module Fire
+  require 'fire/match'
+
+  # Fire's logic system is a *set logic* system. That means an empty set, `[]`
+  # is treated as `false` and a non-empty set is `true`.
+  #
+  # Fire handles complex logic by building-up lazy logic constructs. It's logical
+  # operators are defined using single charcter symbols, e.g. `&` and `|`.
+  #
+  class State
+    def initialize(&procedure)
+      @procedure = procedure
+    end
+
+    def call
+      set @procedure.call
+    end
+
+    # set or
+    def |(other)
+      State.new{ set(self.call) | set(other.call) }
+    end
+
+    # set and
+    def &(other)
+      State.new{ set(self.call) & set(other.call) }
+    end
+
+  private
+
+    #
+    def set(value)
+      case value
+      when Array
+        value.compact
+      when Boolean
+        value ? true : []
+      else
+        [value]
+      end
+    end
+
+  end
+
+  # File state.
+  #
+  class FileState < State
+    # Initialize new instance of Autologic.
+    #
+    # pattern - File glob or regular expression. [String,Regexp]
+    # digest  - 
+    # ignore  -
+    #
+    def initialize(pattern, digest, ignore)
+      @pattern = pattern
+      @digest  = digest
+      @ignore  = ignore
+    end
+
+    # File glob or regular expression.
+    attr :pattern
+
+    # TODO: it would be nice if we could pass the regexp match too the procedure too
+
+    # Process logic.
+    def call
+      result = []
+      case pattern
+      when Regexp
+        @digest.current.keys.each do |fname|
+          if md = pattern.match(fname)
+            if @digest.current[fname] != @digest.saved[fname]
+              result << Match.new(fname, md)
+            end
+          end
+        end
+      else
+        # TODO: if fnmatch? worked like glob then we'd follow the same code as for regexp
+        list = Dir[pattern].reject{ |path| @ignore.any?{ |ig| /^#{ig}/ =~ path } }
+        list.each do |fname|
+          if @digest.current[fname] != @digest.saved[fname]
+            result << fname
+          end
+        end
+      end
+      result
+    end
+
+  end
+
+end

data/lib/fire/system.rb

@@ -0,0 +1,244 @@
+require 'ostruct'
+require 'notify'
+
+require 'fire/shellutils'
+require 'fire/rule'
+require 'fire/state'
+require 'fire/task'
+require 'fire/digest'
+#require 'fire/rulefile'
+
+module Fire
+
+  #
+  # Master system instance.
+  #
+  def self.system
+    @system ||= System.new
+  end
+
+  # System stores states and rules.
+  class System < Module
+
+    # TODO: there are some namespace issues to deal with here.
+    #       we don't necessarily want a rule block to be able to call #rule.
+
+    # Instantiate new system.
+    #
+    def initialize(options={})
+      extend self
+      extend ShellUtils
+
+      @ignore  = Array(options[:ignore] || [])
+      @files   = Array(options[:files]  || [])
+
+      @rules   = []
+      @states  = {}
+      @tasks   = {}
+
+      @digest  = Digest.new
+      @session = OpenStruct.new
+
+      @files.each do |file|
+        module_eval(File.read(file), file)
+      end
+    end
+
+    # Current session.
+    attr :session
+
+    # Array of defined states.
+    attr :states
+
+    # Array of defined rules.
+    attr :rules
+
+    # Mapping of defined tasks.
+    attr :tasks
+
+    # File digest.
+    attr :digest
+
+    # Import from another file, or glob of files, relative to project root.
+    #
+    # @todo Should importing be relative the importing file?
+    # @return 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)
+          #instance_eval(File.read(file), file)
+          module_eval(File.read(file), file)
+        end
+      end
+    end
+
+    # Add paths to be ignored in file rules.
+    def ignore(*globs)
+      @ignore.concat(globs.flatten)
+      @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.
+    #
+    # @example
+    #   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, digest, ignore)
+    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
+    #
+    def rule(state, &procedure)
+      state, todo = parse_arrow(state)
+
+      case state
+      when String, Regexp
+        file_rule(state, :todo=>todo, &procedure)
+      when Symbol
+        # TODO: Is this really the best idea?
+        #@states[state.to_sym]
+      else
+        @rules << Rule.new(state, :todo=>todo, &procedure)
+      end
+    end
+
+    #
+    # Check a name state.
+    #
+    def state?(name, *args)
+      @states[name.to_sym].call(*args)
+    end
+
+    #
+    # Run a task.
+    #
+    def run(task_name) #, *args)
+      tasks[task_name.to_sym].invoke #call(*args)
+    end
+
+    # Set task description. The next task defined will get the most
+    # recently defined description attached to it.
+    def desc(description)
+      @_desc = description
+    end
+
+    # Define a command line task. A task is special type of rule that
+    # is triggered when the command line tool is invoked with
+    # the name of the task.
+    #
+    # Tasks are an isolated set of rules and suppress the activation of
+    # all other rules not specifically given as prerequisites.
+    #
+    #   task :rdoc do
+    #     trip no_rdocs
+    #   end
+    #
+    # Returns [Task]
+    def task(name_and_state, &procedure)
+      name, todo = parse_arrow(name_and_state)
+      task = Task.new(name, :todo=>todo, :desc=>@_desc, &procedure)
+      @tasks[name.to_sym] = task
+      @_desc = nil
+      task
+    end
+
+    #
+    # Issue notification.
+    #
+    def notify(message, options={})
+      title = options.delete(:title) || 'Fire Notification'
+      Notify.notify(title, message.to_s, options)
+    end
+
+  private
+
+    # Split a hash argument into it's key and value pair.
+    # The hash is expected to have only one entry. If the argument
+    # is not a hash then returns the argument and an empty array.
+    # 
+    # Raises an [ArgumetError] if the hash has more than one entry.
+    #
+    # Returns key and value. [Array]
+    def parse_arrow(argument)
+      case argument
+      when Hash
+        raise ArgumentError if argument.size > 1
+        head, tail = *argument.to_a.first
+        return head, Array(tail)
+      else
+        return argument, []
+      end
+    end
+
+    # TODO: pass `self` to FileState instead of digest and igonre ?
+
+    # Define a file rule. A file rule is a rule with a specific state
+    # based on changes in files.
+    #
+    # @example
+    #   file_rule 'test/**/case_*.rb' do |files|
+    #     sh "ruby-test " + files.join(" ")
+    #   end
+    #
+    # Returns nothing.
+    def file_rule(pattern, options={}, &procedure)
+      state = FileState.new(pattern, digest, ignore)
+      @rules << Rule.new(state, options, &procedure)
+    end
+
+  end
+
+end

data/lib/fire/task.rb

@@ -0,0 +1,71 @@
+module Fire
+
+  # The Task class encapsulates command-line dependent rules.
+  #
+  class Task
+    #
+    def initialize(name, options={}, &procedure)
+      @name        = name
+      @description = options[:desc]
+      @requisite   = options[:todo] || []
+      @procedure   = procedure
+
+      #@_reducing = nil
+    end
+
+    # The tasks name.
+    attr :name
+
+    # Task description. This is need for a task to
+    # available via the command line.
+    attr :description
+
+    #
+    attr :requisite
+
+    #
+    alias :todo :requisite
+
+    # Run the task.
+    def invoke(&prepare)
+      prepare.call
+      call
+    end
+
+    # Alias for #invoke.
+    alias :apply :invoke
+
+    #def to_s
+    #  @description.to_s
+    #end
+
+  protected
+
+    #
+    def call
+      @procedure.call
+    end
+
+=begin
+    # Reduce task list.
+    #
+    # Returns [Array<Task>]
+    def reduce
+      return [] if @_reducing
+      list = []
+      begin
+        @_reducing = true
+        @requisite.each do |r|
+          list << @system.tasks[r.to_sym].reduce
+        end
+        list << self
+      ensure
+        @_reducing = false
+      end
+      list.flatten.uniq
+    end
+=end
+
+  end
+
+end