xpflow 0.1b

data/bin/xpflow

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# Runs xpflow script
+
+require('pathname')
+
+def realpath(x)
+    Pathname.new(x).realpath.to_s
+end
+
+# code that magically switches ruby interpreter
+if ENV.key?("__RUBY__")
+    __ruby__ = ENV["__RUBY__"]
+    __here__ = realpath(__FILE__)
+    ENV.delete("__RUBY__")  # avoid infinite loop
+    begin
+        exec(__ruby__, __here__, *ARGV)
+    rescue Errno::ENOENT => e
+        puts "Could not launch with custom Ruby (#{e})."
+    end
+    exit 1
+end
+
+def get_lib_dir
+    f = __FILE__
+    f = File.readlink(f) if File.symlink?(f)
+    p = Pathname.new(File.dirname(f))
+    lib = File.join(p.realpath, '..', 'lib')
+    return Pathname.new(lib).realpath.to_s
+end
+
+$:.unshift(get_lib_dir)
+
+#XSTART
+require 'xpflow'
+#XEND
+
+def usage
+    puts "XPFlow (running on Ruby #{RUBY_VERSION})"
+    puts
+    puts "Usage:"
+    puts "    xpflow <cmd> <workflow> [OPTIONS]"
+    puts
+    puts "Standard commands:"
+    puts "    xpflow run <workflow> - run a workflow"
+    puts
+end
+
+def use(*args)
+    
+    # TODO: this should be more sophisticated
+    # for now it's so so
+
+    args.each do |lib|
+        require "xpflow/exts/#{lib.to_s}_use"
+    end
+end
+
+if true
+
+    $original_argv = ARGV.clone
+
+    begin
+        $cmdline_options = XPFlow::Options.new(ARGV.dup)
+        $variables = $cmdline_options.vars
+        $engine.init_from_options($cmdline_options)
+    rescue XPFlow::CmdlineError => e
+        if e.ignore?
+            exit 0
+        else
+            Kernel.puts "Error while parsing cmdline: #{e}"
+            exit 1
+        end
+    end
+
+    $cmdline_options.includes.each do |filename|
+        filename = realpath(filename)
+        require(filename)
+    end
+
+    ok = nil
+    begin
+        XPFlow::TerminalThread.start_thread
+        _, ok = $cmdline_options.dispatch($engine)
+    rescue => e
+        Kernel.puts "Error while running : #{e}."
+        if $cmdline_options.verbose?
+            Kernel.puts "Backtrace:"
+            e.backtrace.each do |line|
+                Kernel.puts("    " + line)
+            end
+        end
+        ok = false
+    end
+    exit(ok ? 0 : 1)
+end

data/lib/colorado.rb

@@ -0,0 +1,198 @@
+
+# This simple library allows you to use
+# colors with strings
+
+module Colorado
+
+    COLORS = {
+        :red => 31,
+        :green => 32,
+        :yellow => 33,
+        :blue => 34,
+        :violet => 35,
+        :magenta => 36,
+        :white => 37,
+        :normal => 0
+    }
+
+    KEYS = COLORS.keys + COLORS.keys.map { |c| "#{c}!" }
+
+    module StringMix
+        
+        Colorado::KEYS.each do |color|
+            define_method(color) do
+                return Colorado::Str.new(self, color)
+            end
+        end
+
+    end
+
+    module BaseMix
+        
+        Colorado::KEYS.each do |color|
+            define_method(color) do
+                return self.plain.send(:color)
+            end
+        end
+
+    end
+
+    class Color
+
+        attr_reader :bold
+        attr_reader :color
+
+        def initialize(c)
+            @color = (c.is_a?(Color) ? c.color : c)
+            @bold = @color.to_s.end_with?('!')
+            @index = @color.to_s.chomp('!').to_sym
+        end
+
+        def code
+            return COLORS[@index]
+        end
+
+        def prefix
+            return '' if @index == :normal
+            return (@bold ? "\e[#{code};1m" : "\e[#{code}m")
+        end
+
+        def suffix
+            return '' if @index == :normal
+            return "\e[0m"
+        end
+
+        def to_s
+            return @color.to_s
+        end
+
+        def normal?
+            return @index == :normal
+        end
+
+    end
+
+    class Base
+
+        include BaseMix
+
+        attr_reader :color
+
+        def initialize(color)
+            @color = Color.new(color)
+        end
+
+        def +(s)
+            s = Str.new(s) if s.is_a?(String)
+            return Group.new(self.parts + s.parts)    
+        end
+
+    end
+
+    class Str < Base
+
+        def initialize(s, color = :normal)
+            super(color)
+            raise "Already colorized: #{s}" if Colorado.colorized(s)
+            @s = s.to_s
+        end
+
+        def inspect
+            "<'#{@s}' in #{@color}>"
+        end
+
+        def plain
+            return @s
+        end
+
+        def parts
+            return [ self ]
+        end
+
+        def to_s
+            return "#{color.prefix}#{@s}#{color.suffix}"
+        end
+    end
+
+    class Group < Base
+
+        def initialize(array)
+            super(:normal)
+            @array = array
+        end
+
+        def exec(method)
+            return @array.map { |it| it.send(method) }
+        end
+
+        def parts
+            return exec(:parts).reduce(:+)
+        end
+
+        def plain
+            return exec(:plain).reduce(:+)
+        end
+
+        def inspect
+            return parts.inspect
+        end
+
+        def to_s
+            return exec(:to_s).reduce(:+)
+        end
+
+    end
+
+    def self.substitute(fmt, array)
+        parts = fmt.split(/%(.)/)
+        strings = []
+        idx = 0
+        parts.each_index do |i| 
+            s = parts[i]
+            if i.even? # normal string
+                next if s == ''
+                strings.push(Str.new(s))
+            else
+                if s == 's'
+                    strings.push(fix(array[idx]))
+                    idx += 1
+                elsif s == '%'
+                    strings.push(fix('%'))
+                else
+                    raise "Error!"
+                end
+            end
+        end
+        return Group.new(strings)
+    end
+
+    def self.fix(x)
+        return x if x.is_a?(Base)
+        return Str.new(x.to_s)
+    end
+
+    def self.colorized(s)
+        return (!s.is_a?(Base) && s.to_s.include?("\e"))
+    end
+
+end
+
+class String
+
+    include Colorado::StringMix
+
+    alias old_addition :+
+    alias old_modulo :%
+
+    def +(x)
+        return Colorado::Str.new(self) + x if x.is_a?(Colorado::Base)
+        return old_addition(x)
+    end
+
+    def %(x)
+        return Colorado.substitute(self, [x]) if x.is_a?(Colorado::Base)
+        return Colorado.substitute(self, x) if (x.is_a?(Array) && x.any? { |el| el.is_a?(Colorado::Base) } )
+        return old_modulo(x)
+    end
+
+end

data/lib/json/add/core.rb

@@ -0,0 +1,243 @@
+# This file contains implementations of ruby core's custom objects for
+# serialisation/deserialisation.
+
+unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
+  require 'json'
+end
+require 'date'
+
+# Symbol serialization/deserialization
+class Symbol
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    {
+      JSON.create_id => self.class.name,
+      's'            => to_s,
+    }
+  end
+
+  # Stores class name (Symbol) with String representation of Symbol as a JSON string.
+  def to_json(*a)
+    as_json.to_json(*a)
+  end
+  
+  # Deserializes JSON string by converting the <tt>string</tt> value stored in the object to a Symbol
+  def self.json_create(o)
+    o['s'].to_sym
+  end
+end
+
+# Time serialization/deserialization
+class Time
+
+  # Deserializes JSON string by converting time since epoch to Time
+  def self.json_create(object)
+    if usec = object.delete('u') # used to be tv_usec -> tv_nsec
+      object['n'] = usec * 1000
+    end
+    if respond_to?(:tv_nsec)
+      at(*object.values_at('s', 'n'))
+    else
+      at(object['s'], object['n'] / 1000)
+    end
+  end
+
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    {
+      JSON.create_id => self.class.name,
+      's'            => tv_sec,
+      'n'            => respond_to?(:tv_nsec) ? tv_nsec : tv_usec * 1000
+    }
+  end
+  
+  # Stores class name (Time) with number of seconds since epoch and number of
+  # microseconds for Time as JSON string
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+end
+
+# Date serialization/deserialization
+class Date
+  
+  # Deserializes JSON string by converting Julian year <tt>y</tt>, month
+  # <tt>m</tt>, day <tt>d</tt> and Day of Calendar Reform <tt>sg</tt> to Date.
+  def self.json_create(object)
+    civil(*object.values_at('y', 'm', 'd', 'sg'))
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    {
+      JSON.create_id => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'sg' => start,
+    }  
+  end
+
+  # Stores class name (Date) with Julian year <tt>y</tt>, month <tt>m</tt>, day
+  # <tt>d</tt> and Day of Calendar Reform <tt>sg</tt> as JSON string
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+end
+
+# DateTime serialization/deserialization
+class DateTime
+
+  # Deserializes JSON string by converting year <tt>y</tt>, month <tt>m</tt>,
+  # day <tt>d</tt>, hour <tt>H</tt>, minute <tt>M</tt>, second <tt>S</tt>,
+  # offset <tt>of</tt> and Day of Calendar Reform <tt>sg</tt> to DateTime.
+  def self.json_create(object)
+    args = object.values_at('y', 'm', 'd', 'H', 'M', 'S')
+    of_a, of_b = object['of'].split('/')
+    if of_b and of_b != '0'
+      args << Rational(of_a.to_i, of_b.to_i)
+    else
+      args << of_a
+    end
+    args << object['sg']
+    civil(*args)
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    {
+      JSON.create_id => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'H' => hour,
+      'M' => min,
+      'S' => sec,
+      'of' => offset.to_s,
+      'sg' => start,
+    } 
+  end
+
+  # Stores class name (DateTime) with Julian year <tt>y</tt>, month <tt>m</tt>,
+  # day <tt>d</tt>, hour <tt>H</tt>, minute <tt>M</tt>, second <tt>S</tt>,
+  # offset <tt>of</tt> and Day of Calendar Reform <tt>sg</tt> as JSON string
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+end
+
+# Range serialization/deserialization
+class Range
+  
+  # Deserializes JSON string by constructing new Range object with arguments
+  # <tt>a</tt> serialized by <tt>to_json</tt>.
+  def self.json_create(object)
+    new(*object['a'])
+  end
+
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    {
+      JSON.create_id  => self.class.name,
+      'a'             => [ first, last, exclude_end? ]
+    }
+  end
+
+  # Stores class name (Range) with JSON array of arguments <tt>a</tt> which
+  # include <tt>first</tt> (integer), <tt>last</tt> (integer), and
+  # <tt>exclude_end?</tt> (boolean) as JSON string.
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+end
+
+# Struct serialization/deserialization
+class Struct
+  
+  # Deserializes JSON string by constructing new Struct object with values
+  # <tt>v</tt> serialized by <tt>to_json</tt>.
+  def self.json_create(object)
+    new(*object['v'])
+  end
+
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    klass = self.class.name
+    klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
+    {
+      JSON.create_id => klass,
+      'v'            => values,
+    }
+  end
+
+  # Stores class name (Struct) with Struct values <tt>v</tt> as a JSON string.
+  # Only named structs are supported.
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+end
+
+# Exception serialization/deserialization
+class Exception
+
+  # Deserializes JSON string by constructing new Exception object with message
+  # <tt>m</tt> and backtrace <tt>b</tt> serialized with <tt>to_json</tt>
+  def self.json_create(object)
+    result = new(object['m'])
+    result.set_backtrace object['b']
+    result
+  end
+
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    {
+      JSON.create_id => self.class.name,
+      'm'            => message,
+      'b'            => backtrace,
+    }
+  end
+
+  # Stores class name (Exception) with message <tt>m</tt> and backtrace array
+  # <tt>b</tt> as JSON string
+  def to_json(*args)
+    as_json.to_json(*args)
+  end
+end
+
+# Regexp serialization/deserialization
+class Regexp
+
+  # Deserializes JSON string by constructing new Regexp object with source
+  # <tt>s</tt> (Regexp or String) and options <tt>o</tt> serialized by
+  # <tt>to_json</tt>
+  def self.json_create(object)
+    new(object['s'], object['o'])
+  end
+
+  # Returns a hash, that will be turned into a JSON object and represent this
+  # object.
+  def as_json(*)
+    {
+      JSON.create_id => self.class.name,
+      'o' => options,
+      's' => source,
+    }
+  end
+
+  # Stores class name (Regexp) with options <tt>o</tt> and source <tt>s</tt>
+  # (Regexp or String) as JSON string
+  def to_json(*)
+    as_json.to_json
+  end
+end

data/lib/json/add/rails.rb

@@ -0,0 +1,8 @@
+# This file used to implementations of rails custom objects for
+# serialisation/deserialisation and is obsoleted now.
+
+unless defined?(::JSON::JSON_LOADED) and ::JSON::JSON_LOADED
+  require 'json'
+end
+
+$DEBUG and warn "required json/add/rails which is obsolete now!"