fire 0.2.0

data/demo/applique/ae.rb

@@ -0,0 +1 @@
+require 'ae'

data/demo/applique/fire.rb

@@ -0,0 +1 @@
+require 'fire'

data/demo/applique/rules.rb

@@ -0,0 +1,5 @@
+
+When 'iven a @system defined' do |text|
+  @system = Fire::System.new
+  @system.module_eval(text)
+end

data/demo/overview.md

@@ -0,0 +1,14 @@
+= Ousama
+
+TBD.
+
+Given a Rulefile:
+
+    state 'rdocs out-of-date' do
+
+    end
+
+    rule 'rdocs out-of-date' do
+
+    end
+

data/lib/fire.rb

@@ -0,0 +1,3 @@
+require 'fire/cli'
+require 'fire/session'
+

data/lib/fire.yml

@@ -0,0 +1,53 @@
+---
+revision: 2013
+type: ruby
+sources:
+- var
+authors:
+- name: Trans
+  email: transfire@gmail.com
+organizations:
+- name: Rubyworks
+requirements:
+- name: notify
+- groups:
+  - build
+  development: true
+  name: detroit
+- groups:
+  - build
+  development: true
+  name: mast
+conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: http://rubyworks.github.com/fire
+  label: Homepage
+- type: code
+  uri: http://github.com/rubyworks/fire
+  label: Source Code
+- type: bugs
+  uri: http://github.com/rubyworks/fire/issues
+  label: Issue Tracker
+repositories:
+- name: upstream
+  scm: git
+  uri: git://github.com/rubyworks/fire.git
+categories: []
+copyrights:
+- holder: Rubyworks
+  year: '2010'
+  license: BSD-2-Clause
+customs: []
+paths:
+  lib:
+  - lib
+created: '2010-07-05'
+summary: The best build tool, logically!
+title: Fire
+version: 0.2.0
+name: fire
+description: ! "Fire is a continuous integration build tool with a slick set logic
+  \nstate/rules system."
+date: '2013-02-12'

data/lib/fire/cli.rb

@@ -0,0 +1,64 @@
+require 'fire/core_ext'
+require 'fire/session'
+
+module Fire
+
+  # Fire's command line interface.
+  #
+  class CLI
+
+    # Fire her up!
+    def self.run(argv=ARGV)
+      new(argv).run
+    end
+
+    # Fire her up in autorun mode!
+    def self.autorun(argv=ARGV)
+      new(argv).autorun
+    end
+
+    # Initialize new instance of Fire::CLI.
+    def initialize(argv=ARGV)
+      @argv = argv
+    end
+
+    # Returns session instance. [Session]
+    def session
+      @session ||= Session.new(:watch=>@watch)
+    end
+
+    # Fire her up!
+    def run
+      args = cli_parse
+      session.run(args)
+    end
+
+    # Fire her up in autorun mode!
+    def autorun
+      args = cli_parse
+      session.autorun(args)
+    end
+
+    # Parse command line arguments with just the prettiest
+    # little CLI parser there ever was.
+    def cli_parse
+      cli @argv,
+        "-T" => method(:list_tasks),
+        "-w" => method(:watch)
+    end
+
+    # Print out a list of availabe manual triggers.
+    def list_tasks
+      puts "(#{session.root})"
+      puts session.task_sheet
+      exit
+    end
+
+    # Set the watch wait period.
+    def watch(seconds)
+      @watch = seconds 
+    end
+
+  end
+
+end

data/lib/fire/core_ext.rb

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

data/lib/fire/core_ext/boolean.rb

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

data/lib/fire/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

data/lib/fire/core_ext/true_class.rb

@@ -0,0 +1,58 @@
+# We are going to try doing it this way. If i proves a problem
+# we'll make a special class.
+#
+class TrueClass
+  def empty?
+    false
+  end
+
+  def &(other)
+    other
+  end
+
+  def |(other)
+    other
+  end
+end
+
+=begin
+class TrueArray < Array
+
+  def each; end
+
+  def size
+    1  # ?
+  end
+
+  def empty?
+    false
+  end
+
+  def &(other)
+    other.dup
+  end
+
+  def |(other)
+    other.dup
+  end
+
+  ## If this would have worked we would not have had
+  ## to override Array.
+  #def coerce(other)
+  #  return self, other
+  #end
+end
+=end
+
+class Array
+  alias and_without_t :&
+  alias or_without_t :|
+
+  def |(other)
+    TrueClass === other ? dup : or_without_t(other)
+  end
+
+  def &(other)
+    TrueClass === other ? dup : and_without_t(other)
+  end
+end

data/lib/fire/digest.rb

@@ -0,0 +1,112 @@
+require 'digest/sha1'
+require 'fileutils'
+
+module Fire
+
+  #
+  #
+  class Digest
+
+    #
+    DEFAULT_FILE = ".fire/digest"
+
+    #
+    attr :file
+
+    #
+    attr :current
+
+    #
+    attr :saved
+
+    #
+    attr :ignore
+
+    #
+    def initialize(options={})
+      @file   = options[:file]   || DEFAULT_FILE
+      @ignore = options[:ignore] || []
+
+      @current = {}
+      @saved   = {}
+
+      read
+      refresh
+    end
+
+    # Load saved digest.
+    def read
+      return unless File.exist?(file)
+      File.read(file).lines.each do |line|
+        if md = /^(\w+)\s+(.*?)$/.match(line)
+          @saved[md[2]] = md[1]
+        end
+      end
+    end
+
+=begin
+    # Gather current digest for all files.
+    #
+    # Returns nothing.
+    def refresh
+      Dir['**/*'].each do |path|
+        if File.directory?(path)
+          # how to handle directories as a whole?
+        elsif File.exist?(path)
+          id = checksum(path)
+          @current[path] = id
+        end
+      end
+    end
+=end
+
+    # Gather current digest for all files.
+    #
+    # Returns nothing.
+    def refresh
+      list = Dir['**/*']
+      list = list.reject{ |path| ignore.any?{ |ig| /^#{ig}/ =~ path } }
+      list.each do |path|
+        if File.directory?(path)
+          # how to handle directories as a whole?
+        elsif File.exist?(path)
+          id = checksum(path)
+          @current[path] = id
+        end
+      end
+    end
+
+    # Save current digest.
+    def save
+      dir = File.dirname(file)
+      FileUtils.mkdir(dir) unless File.directory?(dir)
+      File.open(file, 'w'){ |f| f << to_s }      
+    end
+
+    # Returns [String] digest file format.
+    def to_s
+      s = ""
+      current.each do |path, id|
+        s << "#{id} #{path}\n"
+      end
+      s
+    end
+
+    # Compute the sha1 identifer for a file.
+    #
+    # file - path to a file
+    #
+    # Returns [String] SHA1 digest string.
+    def checksum(file)
+      sha = ::Digest::SHA1.new
+      File.open(file, 'r') do |fh|
+        fh.each_line do |l|
+          sha << l
+        end
+      end
+      sha.hexdigest
+    end
+
+  end
+
+end

data/lib/fire/dsl.rb

@@ -0,0 +1,34 @@
+module Fire
+
+p "HERE!!!!!!!"
+
+  #
+  module DSL
+
+    def state(name, &condition)
+      Fire.system.state(name, &condition)
+    end
+
+    def rule(logic, &procedure)
+      Fire.system.rule(logic, &procedure)
+    end
+
+    #def file(pattern, &procedure)
+    #  Fire.system.file(pattern, &procedure)
+    #end
+
+    def trip(state)
+      Fire.system.trip(state)
+    end
+
+    def desc(description)
+      Fire.system.desc(description)
+    end
+
+    def task(name_and_logic, &procedure)
+      Fire.system.task(name_and_logic, &procedure)
+    end
+
+  end
+
+end

data/lib/fire/match.rb

@@ -0,0 +1,26 @@
+module Fire
+
+  # Match is a subclass of a string that also stores the 
+  # MatchData then matched against it in a Regexp comparison.
+  #
+  class Match < String
+    # Initialize a new instance of Match.
+    #
+    # string    - The string. [String]
+    # matchdata - The match data. [MatchData]
+    #
+    def intialize(string, matchdata)
+      replace(string)
+      @matchdata = matchdata
+    end
+
+    # The match data that resulted from
+    # a successful Regexp against the string.
+    #
+    # Returns [MatchData]
+    def matchdata
+      @matchdata
+    end
+  end
+
+end