Reblog this post
@param blogName the blog name to reblog onto
@param options options to reblog with (or null)
@return reblogged post
493379
public Post reblog(String blogName, Map<String, ?> options) {
        return client.postReblog(blogName, id, reblog_key, options);
    }
1208422
public function setOptions(BlogOptions $options)
    {
        $options->setBlog($this);

        $this->options = $options;

        return $this;
    }
634898
function createOptions( options ) {
	var object = optionsCache[ options ] = {};
	jQuery.each( options.split( core_rspace ), function( _, flag ) {
		object[ flag ] = true;
	});
	return object;
}
361468
@Override
    public QueryResult<P> execute(StatementOptions options, Object... params) {
        return multi(options).add(params).execute();
    }
1208856
public function postComment(string $authorName, EmailAddress $authorEmail, string $content, IClock $clock): BlogArticleComment
    {
        InvalidOperationException::verify($this->published, 'This blog article is not published');
        InvalidOperationException::verify($this->allowCommenting, 'This blog article does not allow comments');

        $comment = new BlogArticleComment(
            $this,
            $authorName,
            $authorEmail,
            $content,
            $clock
        );

        $this->comments[] = $comment;

        return $comment;
    }
758961
public function serialize(Blog $blog, array $options = [])
    {
        return [
            'id' => $blog->getUuid(),
            'name' => $blog->getResourceNode()->getName(),
            'infos' => $blog->getInfos(),
            'options' => $this->blogOptionsSerializer->serialize($blog, $blog->getOptions()),
        ];
    }
929329
public static Options create(String name) {
		synchronized (SINGLETONS) {
			if (SINGLETONS.containsKey(name)) {
				return SINGLETONS.get(name);
			}

			Options options = new Options();
			List<String> lines = CommanderUtil.execute(name);
			for (String line : lines) {
				if (LOGGER.isDebugEnabled()) {
					LOGGER.debug(line);
				}
				if (!line.startsWith("-")) {
					continue;
				}
				int indexOfDesc = line.indexOf(":");
				String opts[] = line.substring(0, indexOfDesc).trim().split(",");
				String desc = line.substring(indexOfDesc + 1).trim();
				options.addOption(new Option(opts[0].trim().substring(1), opts[1].trim().substring(2), true, desc));
			}
			SINGLETONS.put(name, options);
			for (String opt : NO_VALUE_OPTIONS) {
				Option option = options.getOption(opt);
				if (option != null) {
					option.setArgs(0);
				}
			}
			return options;
		}
	}
270456
public static String getOptionValue(String[] args, String optionName) {
		String opt = "-" + optionName + "=";
		for (String arg : args) {
			if (arg.startsWith(opt))
				return arg.substring(opt.length());
		}
		return null;
	}
29601
public function postComment(int $blogArticleId, string $authorName, EmailAddress $authorEmail, string $comment): BlogArticleComment
    {
        $blogArticle = $this->blogArticleRepo->get($blogArticleId);

        $comment = $blogArticle->postComment($authorName, $authorEmail, $comment, $this->clock);

        $this->blogArticleRepo->save($blogArticle);

        return $comment;
    }
213612
public function newAction(Blog $blog)
    {
        try {
            $article = new Article();
            $article->setBlog($blog);
            $form = $this->createForm(ArticleType::class, $article);

            return new JsonResponse([
                'html' => $this->container->get('templating')->render(
                    'VictoireBlogBundle:Article:new.html.twig',
                    [
                        'form'   => $form->createView(),
                        'blogId' => $blog->getId(),
                    ]
                ),
            ]);
        } catch (NoResultException $e) {
            return new JsonResponse([
                'success' => false,
                'message' => $e->getMessage(),
            ]);
        }
    }
535602
private static void rewriteOptions(String[] args, String option, String new_option) {
        for (int i=0; i<args.length; ++i) {
            if (args[i].equals(option)) {
                args[i] = new_option;
            }
        }
    }
266787
public static function runOnBlog( int $blog_id, callable $callback, ...$args ) {
		switch_to_blog( $blog_id );
		$result = call_user_func_array( $callback, $args );
		switch_to_blog( get_current_blog_id() );

		return $result;
	}
668363
public function deserialize($data, Blog $blog = null, array $options = [])
    {
        if (empty($blog)) {
            $blog = new Blog();
        }

        if (!in_array(Options::REFRESH_UUID, $options)) {
            $this->sipe('id', 'setUuid', $data, $blog);
        }

        $this->sipe('name', 'setName', $data, $blog);
        $this->sipe('infos', 'setInfos', $data, $blog);

        if (isset($data['options'])) {
            $blog->setOptions($this->blogOptionsSerializer->deserialize($data['options'], $blog->getOptions(), $options));
        }

        return $blog;
    }
263162
public function publishComment(Blog $blog, Comment $existingComment)
    {
        $existingComment->publish();
        if (BlogOptions::COMMENT_MODERATION_PRIOR_ONCE === $blog->getOptions()->getCommentModerationMode()
            && null !== $existingComment->getAuthor()) {
            if (0 === count($this->memberRepo->getTrustedMember($blog, $existingComment->getAuthor()))) {
                $this->addTrustedMember($blog, $existingComment->getAuthor());
            }
        }
        $this->om->flush();

        $this->trackingManager->dispatchCommentPublishEvent($existingComment->getPost(), $existingComment);

        return $existingComment;
    }
67735
function Blog(loader, options) {
    this.slugs = {};
    this.ids = {};
    this.posts = [];
    this.length = 0;
    options = options || {};
    if (typeof loader === 'string') {
        loader = new FileSystemLoader(loader, options);
    } else if (Array.isArray(loader)) {
        loader = new ArrayLoader(loader);
    }
    var self = this;
    loader.on('error', function (err) {
        self.emit('error', err);
    });
    loader.on('load', this.onLoad.bind(this));
    loader.on('new_post', this.onNewPost.bind(this));
    loader.on('updated_post', this.onUpdatedPost.bind(this));
    loader.on('removed_post', this.onRemovedPost.bind(this));
}
155013
@Override
  public String getOptStringProperty(final String name) throws OptionsException {
    Object val = getOptProperty(name);

    if (val == null) {
      return null;
    }

    if (!(val instanceof String)) {
      throw new OptionsException("org.bedework.calenv.bad.option.value");
    }

    return (String)val;
  }
415353
public List<Post> tagged(String tag, Map<String, ?> options) {
        if (options == null) {
            options = Collections.emptyMap();
        }
        Map<String, Object> soptions = JumblrClient.safeOptionMap(options);
        soptions.put("api_key", apiKey);
        soptions.put("tag", tag);
        return requestBuilder.get("/tagged", soptions).getTaggedPosts();
    }