Ruote::Reader

# File lib/ruote/reader.rb, line 71
def initialize(context)

  @context = context
end

# File lib/ruote/reader.rb, line 123
def self.read(d)

  unless @reader

    require 'ostruct'
    require 'ruote/svc/treechecker'

    @reader = Ruote::Reader.new(
      OpenStruct.new('treechecker' => Ruote::TreeChecker.new({})))
  end

  @reader.read(d)
end

# File lib/ruote/reader.rb, line 281
def self.remote?(definition)

  u = URI.parse(definition)

  (u.scheme != nil) && ( ! ('A'..'Z').include?(u.scheme))
end

# File lib/ruote/reader.rb, line 238
def self.to_expid_radial(tree)

  lines = to_raw_expid_radial(tree, '0')
  max = lines.collect { |l| l[1].length }.max

  lines.collect { |l|
    "%#{max}s  " % l[1] + "  " * l[0] + l[2] + l[3]
  }.join("\n")
end

# File lib/ruote/reader.rb, line 274
def self.to_json(tree)

  tree.to_json
end

# File lib/ruote/reader.rb, line 219
def self.to_radial(tree, level=0)

  s = '  ' * level + tree[0] + atts_to_radial(tree[1]) + "\n"

  return s if tree[2].empty?

  tree[2].inject(s) { |ss, child| ss << to_radial(child, level + 1); ss }
end

# File lib/ruote/reader.rb, line 260
def self.to_raw_expid_radial(tree, expid='0')

  i = -1

  [
    [ expid.split('_').size - 1, expid, tree[0], atts_to_radial(tree[1]) ]
  ] +
  tree[2].collect { |t|
    i = i + 1; to_raw_expid_radial(t, "#{expid}_#{i}")
  }.flatten(1)
end

# File lib/ruote/reader.rb, line 201
def self.to_ruby(tree, level=0)

  expname = tree[0]
  expname = 'Ruote.process_definition' if level == 0 && expname == 'define'

  s = '  ' * level + expname + atts_to_ruby(tree[1])

  return "#{s}\n" if tree[2].empty?

  s << " do\n"
  tree[2].each { |child| s << to_ruby(child, level + 1) }
  s << "#{'  ' * level}end\n"

  s
end

# File lib/ruote/reader.rb, line 142
def self.to_xml(tree, options={})

  s = StringIO.new
  s.puts('<?xml version="1.0" encoding="UTF-8"?>')

  _to_xml(tree, options[:indent], 0, s)

  s.string
end

# File lib/ruote/reader.rb, line 329
def self.atts_to_radial(atts, &block)

  s = []
  txt, atts = split_atts(atts)

  s << to_ra_string(txt) if txt
  s += atts.collect { |k, v| "#{to_ra_string(k)}: #{to_ra_string(v)}" }

  s = s.join(', ')

  s.length > 0 ? " #{s}" : s
end

# File lib/ruote/reader.rb, line 344
def self.atts_to_ruby(atts, &block)

  s = []
  txt, atts = split_atts(atts)

  s << txt.inspect if txt
  s += atts.collect { |k, v| ":#{k} => #{v.inspect}" }

  s = s.join(', ')

  s.length > 0 ? " #{s}" : s
end

# File lib/ruote/reader.rb, line 318
def self.split_atts(atts)

  atts = atts.to_a.sort_by { |k, v| k }
  txt = atts.find { |k, v| v == nil }
  atts.delete(txt) if txt

  [ txt ? txt.first : nil, atts ]
end

# File lib/ruote/reader.rb, line 299
def self.to_ra_string(o)

  return 'nil' if o == nil

  s = o.to_s

  return s if [ true, false ].include?(o)

  i = o.inspect

  return i if ] true false nil ].include?(s)
  return i if s.match(/[\s:]/)
  return s if i == "\"#{o.to_s}\""

  i
end

# File lib/ruote/reader.rb, line 79
def read(definition)

  return definition if Ruote.is_tree?(definition)

  raise ArgumentError.new(
    "cannot read process definitions of class #{definition.class}"
  ) unless definition.is_a?(String)

  if is_uri?(definition)

    if
      Ruote::Reader.remote?(definition) &&
      @context['remote_definition_allowed'] != true
    then
      raise ArgumentError.new('remote process definitions are not allowed')
    end

    return read(open(definition).read)
  end

  tree = nil
  error = Error.new(definition)

  [
    Ruote::RubyReader, Ruote::RadialReader,
    Ruote::XmlReader, Ruote::JsonReader
  ].each do |reader|

    next if tree
    next unless reader.understands?(definition)

    begin
      tree = reader.read(definition, @context.treechecker)
    rescue => e
      error << [ reader, e ]
    end
  end

  tree || raise(error)
end

# File lib/ruote/reader.rb, line 292
def is_uri?(s)

  return false if s.index("\n")

  ((URI.parse(s); true) rescue false)
end