How to use com.github.dreamhead.moco.parser.model

  public ProxyContainer toProxyContainer() {
    return builder()
        .withUrl(url)
        .withFrom(from)
        .withTo(to)
        .withFailover(failover)
        .withPlayback(playback)
        .build();
  }
}

public final Builder withUrl(final String url) {
  this.url = TextContainer.builder().withText(url).build();
  return this;
}

@Override
public ContentResource asTemplateResource() {
  if (this.content == null) {
    return null;
  }
  return this.content.asTemplateResource();
}

private TextContainer toLocal(final TextContainer container) {
  String name = NAMES.get(container.getOperation());
  if (name == null) {
    return container;
  }
  return builder().withOperation(name).withText(container.getText()).withProps(container.getProps()).build();
}

private RequestMatcher createSingleTextMatcher(final String name, final TextContainer container) {
  if (container.isRawText()) {
    return createSingleMatcher(name, container.getText());
  }
  if (isExistOperator(container)) {
    return existMatcher(Extractors.extractor(name), container);
  }
  return createRequestMatcherWithResource(container.getOperation(), createResource(name, container.getText()));
}

private Resource asResource(final String name, final FileContainer fileContainer) {
  Optional<Charset> charset = fileContainer.getCharset();
  String text = fileContainer.getName().getText();
  return asResource(name, text(text), charset);
}

public ContentResource asTemplateResource(final String resourceName) {
  ensureTemplate();
  if (hasProperties()) {
    return template(invokeTarget(resourceName, this.text, ContentResource.class), toVariables(this.props));
  }
  return template(invokeTarget(resourceName, this.text, ContentResource.class));
}

public final ResponseHandler asResponseHandler() {
  Failover failover = getFailover();
  if (hasProxyConfig()) {
    return Moco.proxy(getProxyConfig(), failover);
  }
  return Moco.proxy(url.asResource(), failover);
}

private Resource resourceFrom(final String name, final TextContainer container) {
  if (container.isFileContainer()) {
    return fileResource(name, FileContainer.class.cast(container));
  }
  return textResource(name, container);
}

public void bindTo(final HttpServer server) {
  HttpResponseSetting setting = bindToSession(server);
  if (hasEvent()) {
    for (MocoEventTrigger trigger : on.triggers()) {
      setting.on(trigger);
    }
  }
}

public FileContainer build() {
  return new FileContainer(name, toCharset(charset));
}

public final TextContainer build() {
  return new TextContainer(text, operation, asProps(props));
}

  @SuppressWarnings("unchecked")
  public final RestSetting[] getSettings() {
    return toArray(concat(asRestSetting(get), asRestSetting(post),
            asRestSetting(put), asRestSetting(delete),
            asRestSetting(head), asRestSetting(patch), asSubRestSetting(resource)),
        RestSetting.class);
  }
}

private MocoEventAction doCreateAction() {
  if (get != null) {
    return get.createAction();
  }
  if (post != null) {
    return post.createAction();
  }
  throw new IllegalArgumentException("At least one action is expected");
}

private ResponseBase<RestSetting> getRestSettingBuilder() {
  RestSettingBuilder builder = this.startRestSetting();
  if (request != null) {
    return builder.request(request.getRequestMatcher());
  }
  return builder;
}

  @Override
  public ResponseHandler apply(final ResponseSetting setting) {
    return setting.getResponseHandler();
  }
};

public static CookieContainer newContainer(final String text) {
  CookieContainer container = new CookieContainer();
  container.value = text;
  return container;
}

@Override
public ContentResource asResource() {
  if (this.content == null) {
    return null;
  }
  return this.content.asResource();
}

@Override
public String getText() {
  if (this.content == null) {
    return null;
  }
  return this.content.getText();
}

@Override
public String getOperation() {
  if (this.content == null) {
    return null;
  }
  return this.content.getOperation();
}