RubyGems - bahuvrihi-tap - Versions diffs - 0.10.2 → 0.10.3 - Mend

bahuvrihi-tap 0.10.2 → 0.10.3

Files changed (22) hide show

data/cgi/run.rb +36 -0
data/cmd/run.rb +4 -3
data/cmd/server.rb +36 -0
data/lib/tap/app.rb +1 -1
data/lib/tap/constants.rb +1 -1
data/lib/tap/env.rb +8 -2
data/lib/tap/exe.rb +1 -57
data/lib/tap/support/declarations.rb +73 -51
data/lib/tap/support/executable.rb +81 -2
data/lib/tap/support/gems/rack.rb +151 -0
data/lib/tap/support/parsers/base.rb +81 -0
data/lib/tap/support/parsers/command_line.rb +90 -0
data/lib/tap/support/parsers/server.rb +83 -0
data/lib/tap/task.rb +327 -7
data/lib/tap/workflow.rb +9 -48
data/template/404.erb +12 -0
data/template/index.erb +41 -0
data/vendor/url_encoded_pair_parser.rb +93 -0
metadata +10 -4
data/lib/tap/support/command_line/parser.rb +0 -121
data/lib/tap/support/framework.rb +0 -83
data/lib/tap/support/framework_class.rb +0 -182

data/lib/tap/workflow.rb CHANGED Viewed

@@ -76,43 +76,17 @@ module Tap
   #   app.run
   #   app.results(w1.exit_points, w2.exit_points))    # => [8, -8]
   #
-  class Workflow
-    include Support::Framework
-    class << self
-      protected
-      def define(name, klass=Tap::Task, &block)
-        instance_var = "@#{name}".to_sym
-        define_method(name) do |*args|
-          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)" if args.length > 1
-          instance_name = args[0] || name
-          instance_variable_set(instance_var, {}) unless instance_variable_defined?(instance_var)
-          instance_variable_get(instance_var)[instance_name] ||= task(instance_name, klass, &block)
-        end
-        define_method("#{name}=") do |input|
-          input = {name => input} unless input.kind_of?(Hash)
-          instance_variable_set(instance_var, input)
-        end
-      end
-    end
+  class Workflow < Task
     # The entry point for self.
     attr_accessor :entry_point
     # The exit point for self.
     attr_accessor :exit_point
-    # The task block provided during initialization.
-    attr_reader :task_block
     # Creates a new Task with the specified attributes.
     def initialize(config={}, name=nil, app=App.instance, &task_block)
-      super(config, name, app)
-      @task_block = (task_block == nil ? default_task_block : task_block)
+      super
       initialize_workflow
     end
@@ -157,32 +131,22 @@ module Tap
     # the number of inputs required by all the entry points;
     # if the entry points have different input requirements, they
     # have to be enqued separately.
-    def enq(*inputs)
+    def unbatched_enq(*inputs)
       entry_points.each do |task|
         app.enq(task, *inputs)
       end
     end
-    batch_function :enq
     # Sets the on_complete_block for all exit points for self and
     # self.batch. Use unbatched_on_complete to set the on_complete_block
     # for just self.exit_points.
-    def on_complete(override=false, &block)
+    def unbatched_on_complete(override=false, &block)
       exit_points.each do |task|
         task.on_complete(override, &block)
       end
       self
     end
-    batch_function(:on_complete) {}
-    def task(name, klass=Tap::Task, &block)
-      configs = config[name] || {}
-      raise ArgumentError, "config '#{name}' is not a hash" unless configs.kind_of?(Hash)
-      klass.new(configs, name, &block)
-    end
     # The workflow definition method.  By default workflow
     # simply calls the task_block.  In subclasses, workflow
     # should be overridden to provide the workflow definition.
@@ -190,11 +154,8 @@ module Tap
       task_block.call(self) if task_block
     end
-    protected
-    # Hook to set a default task block.  By default, nil.
-    def default_task_block
-      nil
+    def process(*inputs)
+      enq(*inputs)
     end
   end
 end

data/template/404.erb ADDED Viewed

@@ -0,0 +1,12 @@
+<html>
+<body>
+<p>
+# 404 error<br/>
+# Could not handle request:
+</p>
+<code><pre>
+<%= cgi.to_yaml %>
+<%= rack.to_yaml %>
+</pre></code>
+</body>
+</html>

data/template/index.erb ADDED Viewed

@@ -0,0 +1,41 @@
+<html>
+<head>
+	<title>Tap::Manifest</title>
+</head>
+<body>
+	<h1><a href="<%= Tap::WEBSITE %>">Tap (<ins>T</ins>ask <ins>Ap</ins>plication) <%= Tap::VERSION %> </a></h1>
+<% server.manifest(:envs, true).minimize.each do |(env_key, env)|
+	 cgi_manifest = env.manifest(:cgis, true).minimize
+	 task_manifest = env.manifest(:tasks, true).minimize
+	 next if cgi_manifest.empty? && task_manifest.empty? %>
+	<h2><%= env_key %></h2>
+	<% unless cgi_manifest.empty? %>
+	<ul>
+		<% cgi_manifest.each do |(cgi_key, path)|
+			lazydoc = Tap::Support::Lazydoc[path]
+			lazydoc.resolve
+			summary = lazydoc.default_attributes['summary']
+			%>
+		<li><a href="<%= cgi_key %>"><%= cgi_key %></a>: <%= summary %></li>
+		<% end %>
+	</ul>
+	<% end %>
+	<% unless task_manifest.empty? %>
+	<ul>
+		<% task_manifest.each do |(task_key, const)|
+			lazydoc = Tap::Support::Lazydoc[const.require_path]
+			lazydoc.resolve
+			summary = lazydoc[const.name]['manifest'].subject
+			%>
+		<li><a href="run?task=<%= task_key %>"><%= const.name %></a> <%= summary %></li>
+		<% end %>
+	</ul>
+	<% end %>
+<% end %>
+	<a href="index?refresh=true">Refresh</a>
+</body>
+</html>

data/vendor/url_encoded_pair_parser.rb ADDED Viewed

@@ -0,0 +1,93 @@
+require 'strscan'
+class UrlEncodedPairParser < StringScanner #:nodoc:
+  attr_reader :top, :parent, :result
+  def initialize(pairs = [])
+    super('')
+    @result = {}
+    pairs.each { |key, value| parse(key, value) }
+  end
+  KEY_REGEXP = %r{([^\[\]=&]+)}
+  BRACKETED_KEY_REGEXP = %r{\[([^\[\]=&]+)\]}
+  # Parse the query string
+  def parse(key, value)
+    self.string = key
+    @top, @parent = result, nil
+    # First scan the bare key
+    key = scan(KEY_REGEXP) or return
+    key = post_key_check(key)
+    # Then scan as many nestings as present
+    until eos?
+      r = scan(BRACKETED_KEY_REGEXP) or return
+      key = self[1]
+      key = post_key_check(key)
+    end
+    bind(key, value)
+  end
+  private
+  # After we see a key, we must look ahead to determine our next action. Cases:
+  #
+  # [] follows the key. Then the value must be an array.
+  # = follows the key. (A value comes next)
+  # & or the end of string follows the key. Then the key is a flag.
+  # otherwise, a hash follows the key.
+  def post_key_check(key)
+    if scan(/\[\]/) # a[b][] indicates that b is an array
+      container(key, Array)
+      nil
+    elsif check(/\[[^\]]/) # a[b] indicates that a is a hash
+      container(key, Hash)
+      nil
+    else # End of key? We do nothing.
+      key
+    end
+  end
+  # Add a container to the stack.
+  def container(key, klass)
+    type_conflict! klass, top[key] if top.is_a?(Hash) && top.key?(key) && ! top[key].is_a?(klass)
+    value = bind(key, klass.new)
+    type_conflict! klass, value unless value.is_a?(klass)
+    push(value)
+  end
+  # Push a value onto the 'stack', which is actually only the top 2 items.
+  def push(value)
+    @parent, @top = @top, value
+  end
+  # Bind a key (which may be nil for items in an array) to the provided value.
+  def bind(key, value)
+    if top.is_a? Array
+      if key
+        if top[-1].is_a?(Hash) && ! top[-1].key?(key)
+          top[-1][key] = value
+        else
+          top << {key => value}#.with_indifferent_access
+          push top.last
+        end
+      else
+        top << value
+      end
+    elsif top.is_a? Hash
+      key = CGI.unescape(key)
+      parent << (@top = {}) if top.key?(key) && parent.is_a?(Array)
+      return top[key] ||= value
+    else
+      raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
+    end
+    return value
+  end
+  def type_conflict!(klass, value)
+    raise TypeError, "Conflicting types for parameter containers. Expected an instance of #{klass} but found an instance of #{value.class}. This can be caused by colliding Array and Hash parameters like qs[]=value&qs[key]=value."
+  end
+end

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bahuvrihi-tap
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.3
 platform: ruby
 authors:
 - Simon Chiang
@@ -30,11 +30,13 @@ files:
 - README
 - MIT-LICENSE
 - History
+- cgi/run.rb
 - cmd/console.rb
 - cmd/destroy.rb
 - cmd/generate.rb
 - cmd/manifest.rb
 - cmd/run.rb
+- cmd/server.rb
 - doc/Tutorial
 - doc/Class Reference
 - doc/Command Reference
@@ -85,7 +87,6 @@ files:
 - lib/tap/support/batchable_class.rb
 - lib/tap/support/class_configuration.rb
 - lib/tap/support/command_line.rb
-- lib/tap/support/command_line/parser.rb
 - lib/tap/support/comment.rb
 - lib/tap/support/configurable.rb
 - lib/tap/support/configurable_class.rb
@@ -95,14 +96,16 @@ files:
 - lib/tap/support/declarations.rb
 - lib/tap/support/executable.rb
 - lib/tap/support/executable_queue.rb
-- lib/tap/support/framework.rb
-- lib/tap/support/framework_class.rb
 - lib/tap/support/gems/rake.rb
+- lib/tap/support/gems/rack.rb
 - lib/tap/support/gems.rb
 - lib/tap/support/instance_configuration.rb
 - lib/tap/support/lazy_attributes.rb
 - lib/tap/support/lazydoc.rb
 - lib/tap/support/manifest.rb
+- lib/tap/support/parsers/base.rb
+- lib/tap/support/parsers/command_line.rb
+- lib/tap/support/parsers/server.rb
 - lib/tap/support/run_error.rb
 - lib/tap/support/shell_utils.rb
 - lib/tap/support/tdoc.rb
@@ -127,6 +130,9 @@ files:
 - lib/tap/test.rb
 - lib/tap/workflow.rb
 - lib/tap.rb
+- template/404.erb
+- template/index.erb
+- vendor/url_encoded_pair_parser.rb
 has_rdoc: true
 homepage: http://tap.rubyforge.org
 post_install_message:

data/lib/tap/support/command_line/parser.rb DELETED Viewed

@@ -1,121 +0,0 @@
-module Tap
-  module Support
-    module CommandLine
-      class Parser
-        class << self
-          def parse_sequence(str, count=0)
-             seq = []
-             seq << count if str[0] == ?:
-             str.split(/:+/).each do |n|
-               seq << n.to_i unless n.empty?
-             end
-             seq << count + 1 if str[-1] == ?:
-             seq
-          end
-          def bracket_regexp(l, r)
-            /\A--(\d*)#{Regexp.escape(l)}([\d,]*)#{Regexp.escape(r)}\z/
-          end
-          def parse_bracket(lead, str, count=0)
-             bracket = []
-             str.split(/,+/).each do |n|
-               bracket << n.to_i unless n.empty?
-             end
-             [lead.empty? ? count : lead.to_i, bracket]
-          end
-          # Parses the input string as YAML, if the string matches the YAML document
-          # specifier (ie it begins with "---\s*\n").  Otherwise returns the string.
-          #
-          #   str = {'key' => 'value'}.to_yaml       # => "--- \nkey: value\n"
-          #   Tap::Script.parse_yaml(str)            # => {'key' => 'value'}
-          #   Tap::Script.parse_yaml("str")          # => "str"
-          def parse_yaml(str)
-            str =~ /\A---\s*\n/ ? YAML.load(str) : str
-          end
-          def shift_arg(argv)
-            index = nil
-            argv.each_with_index do |arg, i|
-              if arg !~ /\A-/
-                index = i
-                break
-              end
-            end
-            index == nil ? nil : argv.delete_at(index)
-          end
-        end
-        ROUND = /\A--(\+(\d+)|\+*)\z/
-        SEQUENCE = /\A--(\d*(:\d*)+)\z/
-        FORK = bracket_regexp("[", "]")
-        MERGE = bracket_regexp("{", "}")
-        SYNC_MERGE = bracket_regexp("(", ")")
-        INVALID =  /\A--(\z|[^A-Za-z])/
-        attr_reader :rounds
-        attr_reader :sequences
-        attr_reader :forks
-        attr_reader :merges
-        attr_reader :sync_merges
-        def initialize(argv)
-          @sequences = []
-          @forks = []
-          @merges = []
-          @sync_merges = []
-          current = []
-          current_round = []
-          count = 0
-          @rounds = [current_round]
-          argv.each do |arg|
-            unless arg =~ INVALID
-              current << arg
-              next
-            end
-            # for peformance split to match
-            # most arguments just once.
-            current_round << current unless current.empty?
-            current = []
-            case arg
-            when ROUND
-              current_round = (@rounds[$2 ? $2.to_i : $1.length] ||= [])
-            when SEQUENCE
-              @sequences << Parser.parse_sequence($1, count)
-            when FORK
-              @forks << Parser.parse_bracket($1, $2, count)
-            when MERGE
-              @merges << Parser.parse_bracket($1, $2, count)
-            when SYNC_MERGE
-              @sync_merges << Parser.parse_bracket($1, $2, count)
-            else
-              raise ArgumentError, "invalid argument: #{arg}"
-            end
-            count += 1
-          end
-          current_round << current unless current.empty?
-          @rounds.delete_if {|round| round.nil? || round.empty? }
-        end
-        def targets
-          targets = []
-          sequences.each {|sequence| targets.concat(sequence[1..-1]) }
-          forks.each {|fork| targets.concat(fork[1]) }
-          targets.concat merges.collect {|target, sources| target }
-          targets.concat sync_merges.collect {|target, sources| target }
-          targets.uniq.sort
-        end
-      end
-    end
-  end
-end

data/lib/tap/support/framework.rb DELETED Viewed

@@ -1,83 +0,0 @@
-require 'tap/support/batchable'
-require 'tap/support/executable'
-require 'tap/support/framework_class'
-module Tap
-  module Support
-    # Framework encapsulates the basic framework functionality (batching,
-    # configuration, documentation, etc) used by Task and Workflow. Note
-    # that Framework does NOT encapsulate the functionality needed to
-    # make a class useful in workflows, such as enq and on_complete.
-    module Framework
-      include Batchable
-      include Configurable
-      def self.included(mod)
-        mod.extend Support::BatchableClass
-        mod.extend Support::ConfigurableClass
-        mod.extend Support::FrameworkClass
-        mod.lazy_attr :manifest
-        mod.lazy_attr :args
-      end
-      # The application used to load config_file templates
-      # (and hence, to initialize batched objects).
-      attr_reader :app
-      # The name of self.
-      #--
-      # Currently names may be any object.  Audit makes use of name
-      # via to_s, as does app when figuring configuration filepaths.
-      attr_accessor :name
-      # Initializes a new instance and associated batch objects.  Batch
-      # objects will be initialized for each configuration template
-      # specified by app.each_config_template(config_file) where
-      # config_file = app.config_filepath(name).
-      def initialize(config={}, name=nil, app=App.instance)
-        super()
-        @app = app
-        @name = name || self.class.default_name
-        case config
-        when InstanceConfiguration
-          @config = config
-          config.bind(self)
-        else
-          initialize_config(config)
-        end
-      end
-      # Creates a new batched object and adds the object to batch. The batched object
-      # will be a duplicate of the current object but with a new name and/or
-      # configurations.
-      def initialize_batch_obj(overrides={}, name=nil)
-        obj = super().reconfigure(overrides)
-        obj.name = name if name
-        obj
-      end
-      # Logs the inputs to the application logger (via app.log)
-      def log(action, msg="", level=Logger::INFO)
-        # TODO - add a task identifier?
-        app.log(action, msg, level)
-      end
-      # Raises a TerminateError if app.state == State::TERMINATE.
-      # check_terminate may be called at any time to provide a
-      # breakpoint in long-running processes.
-      def check_terminate
-        if app.state == App::State::TERMINATE
-          raise App::TerminateError.new
-        end
-      end
-      # Returns self.name
-      def to_s
-        name.to_s
-      end
-    end
-  end
-end