text:
package org.folio.marccat.integration;

import com.fasterxml.jackson.databind.node.ObjectNode;
import org.folio.marccat.config.Global;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Profile;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;

import java.util.Objects;

import static java.util.Arrays.stream;
import static java.util.stream.Collectors.joining;
import static org.folio.marccat.util.F.safe;
import static org.springframework.web.util.UriComponentsBuilder.fromUriString;

/**
 * Mod MARCcat configuration subsystem facade.
 *
 * @author cchiama
 * @since 1.0
 */
@Component
@Profile({"!test"})
public class RemoteConfiguration implements Configuration {

  private static final String BASE_CQUERY = "module==MARCCAT and configName == ";
  private static final int LIMIT = 100;
  private final RestTemplate client;

  @Value("${configuration.endpoint}")
  private String endpoint;

  /**
   * Builds a new configuration with the given http client.
   *
   * @param client the HTTP / REST client.
   */
  public RemoteConfiguration(final RestTemplate client) {
    this.client = client;
  }

  @Override
  public ObjectNode attributes(final String tenant, final boolean withDatasource, final String... configurationSets) {
    final HttpHeaders headers = new HttpHeaders();
    headers.add(Global.OKAPI_TENANT_HEADER_NAME, tenant);

    return client.exchange(
      fromUriString(endpoint)
        .queryParam(cQuery(withDatasource, safe(configurationSets)))
        .build()
        .toUri(),
      HttpMethod.GET,
      new HttpEntity<>("parameters", headers),
      ObjectNode.class)
      .getBody();
  }

  /**
   * Returns the selection criteria that will be used by the current service for gathering the required configuration.
   *
   * @param configurationsSets the configuration groups.
   * @return the selection criteria that will be used by the current service for gathering the required configuration.
   */
  private String cQuery(boolean withDatasource, final String... configurationsSets) {
    final String[] values = safe(configurationsSets);
    return (values.length == 0 && withDatasource)
      ? BASE_CQUERY + "datasource"
      : BASE_CQUERY +
      stream(values)
        .filter(Objects::nonNull)
        .collect(joining(
          " or ",
          values.length != 0
            ? withDatasource ? "(datasource or " : "("
            : "",
          ")&limit=" + LIMIT));
  }
}


text:
package org.kie.uberfire.social.activities.client.gravatar;

import com.google.gwt.user.client.ui.Image;

public class GravatarImage extends Image {

    public GravatarImage( final String email,
                          final int size ) {
        setUrl( GravatarUrlBuilder.get().build( email, size ) );
    }

}

redpajama_set_name: RedPajamaGithub


text:
window.enclosingAnchorTag = null;
window.selectedNode = null;

window.saveCallback =  function(err, success, cb) {
  var saveUIUpdateDelay = 300;
  setTimeout(function(){
    if (err) {
      return Session.set('saveState', 'failed');
    }
    if (!success) {
      return Session.set('saveState', 'failed');
    }
    Session.set('saveState', 'saved');
  }, saveUIUpdateDelay);
  if(cb){
    cb(err, success);
  }
  if (err){
    throw(err);
  }
};

window.refreshContentDep = new Tracker.Dependency();

var scrollToRelativePosition = function(offset) {
  var selectedNarrative = $('.vertical-narrative-section.selected');
  if (selectedNarrative){
    $('body,html').animate({
      scrollTop: $('.vertical-narrative-section.selected').position().top + offset
    }, 200, 'easeInCubic');
  }
};

Template.stream_search.events({
  'mouseenter .horizontal-narrative-section' () {
    document.body.style.overflow = 'hidden';
  },
  'mouseleave .horizontal-narrative-section' (){
    document.body.style.overflow='auto';
  }
});

Template.stream_search.onDestroyed(function(){
  document.body.style.overflow='auto';
});

Template.add_context.helpers({
  listMode (){
    return emptyContextBlockOfCurrentMediaDataType().searchList;
  },
  searchListTemplate (){
    return emptyContextBlockOfCurrentMediaDataType().searchListTemplate;
  },
  searchSoloTemplate (){
    return emptyContextBlockOfCurrentMediaDataType().searchSoloTemplate;
  }
});

Template.content_icons.helpers(contextHelpers);

Template.content_icons.helpers({
  disableAllButStream (){
    // return bool to determine if first creation step
    return _.contains(['find_stream'], this.creationStep);
  }
});

Template.content_icons.events(_.object(_.map(contextTypes, function(type){
    return 'click .' + type + '-button'
  })
  , _.map(contextTypes, function(type) {
    return function() {
      Session.set('mediaDataType', type);
    };
  }))
);

Template.content_icons.events({
  'click button' () {
    clearCurrentContext(); // clear current context whenever click on a context button
  }
});

Template.add_context.events({
  'mouseenter .search-results-container' () {
    document.body.style.overflow = 'hidden';
  },
  'mouseleave .search-results-container' (){
    document.body.style.overflow='auto';
  }
});

Template.add_context.onDestroyed(function(){
  document.body.style.overflow='auto';
});

window.addStream = function(stream, template) {
  Session.set('query', null); // clear query so it doesn't seem like you're editing this card next time open the new card menu
  Session.set('saveState', 'saving');
  template.focusResult.set(null);

  Meteor.call('addStreamToStream', Session.get("streamShortId"), stream, function(err, streamId){
    saveCallback(err, streamId);
  });
};

window.addContext = function(contextBlock) { // add or suggest
  var user;

  /* require login
  if (user = Meteor.user()) {
    contextBlock.authorId = user._id;
    contextBlock.rank = 0; // places above existing ranked context
    if(mainPlayer.getElapsedTime()){
      if(Session.get('videoMarkerTouched')){
        var videoMarkerArray = Session.get('userVideoMarker').split(':').reverse();
        contextBlock.videoMarker = moment.duration({hours: videoMarkerArray[2], minutes: videoMarkerArray[1], seconds: videoMarkerArray[0]}).asSeconds();
      } else {
        contextBlock.videoMarker = mainPlayer.getElapsedTime();
      }
    }
  } else {
    $('#login-modal').modal('show');
    return;
  }
  */

  //do not req login

  if(user = Meteor.user()){
    contextBlock.authorId = user._id;
  } else {
    contextBlock.authorId = 1;
  }
  contextBlock.rank = 0; // places above existing ranked context
  if(mainPlayer.getElapsedTime()){
    if(Session.get('videoMarkerTouched')){
      var videoMarkerArray = Session.get('userVideoMarker').split(':').reverse();
      contextBlock.videoMarker = moment.duration({hours: videoMarkerArray[2], minutes: videoMarkerArray[1], seconds: videoMarkerArray[0]}).asSeconds();
    } else {
      contextBlock.videoMarker = mainPlayer.getElapsedTime();
    }
  }

  if (Session.get('curateMode')) {
    Session.set('saveState', 'saving');

    Meteor.setTimeout(function () { // scroll to top and focus annotation box
      $('.context-browser>.context-area').scrollTop(0);
      $('.context-section[data-context-id=' + contextBlock._id + '] textarea').focus();
    });

    Meteor.call('addContextToStream', Session.get("streamShortId"), contextBlock, function (err, contextId) {
      saveCallback(err, contextId, function(){
        Session.set('contextMode', 'curate');
        Session.set('mediaDataType', 'selectCard');
      });
    });
  } else { // suggest content
    Meteor.call('suggestContext', Session.get("streamShortId"), contextBlock, function (err, contextId) {
      saveCallback(err, contextId, function(){
        Session.set('contextMode', 'context');
        Session.set('mediaDataType', 'selectCard');
      });
    });
  }
};

Template.link_twitter.events({
  "click button" () {
    if (!Meteor.user()){
      notifyInfo('Please log in to link your twitter account');
      return
    }

    Meteor.linkWithTwitter({
      requestPermissions: ['user']
    }, function (err) {
      if (err) {
        notifyError("Twitter login failed");
        throw(err);
      } else if (!Meteor.user().profile.bio){
        Meteor.call('setBioFromTwitter')
      }
    });
    analytics.track('Click Link Twitter');
  }
});

Template.videoMarkerInput.onCreated(function(){
  Session.set('videoMarkerTouched', false);
  Session.set('userVideoMarker', 0);
});

Template.videoMarkerInput.onDestroyed(function(){
  Session.set('videoMarkerTouched', false);
  Session.set('userVideoMarker', 0);
});

Template.videoMarkerInput.helpers({
  videoMarkerEstimate(){
    if(!Session.get('videoMarkerTouched')){
      return moment.duration(Session.get("currentTimeElapsed"), "seconds").format("h:mm:ss", {trim: false});
    } else {
      return Session.get('userVideoMarker');
    }
  }
});

Template.videoMarkerInput.events({
  'focus input#video-marker-input' (e, template){
    // on focus pause the videoMarker input
    console.log('focused in on the video marker currently at: ' + $('#video-marker-input').val());
    Session.set('userVideoMarker', $('#video-marker-input').val());
    Session.set('videoMarkerTouched', true);
  },
  'keyup input#video-marker-input' (e, template){
    console.log('keyup on input');
    Session.set('videoMarkerTouched', true);
    Session.set('userVideoMarker', $('#video-marker-input').val());
    if(e.which === 13){
      var textContent = template.$('#video-marker-input').val();
      var videoMarkerArray = textContent.split(':').reverse();
      var videoMarker = moment.duration({hours: videoMarkerArray[2], minutes: videoMarkerArray[1], seconds: videoMarkerArray[0]}).asSeconds();
      videoMarker = moment.duration(videoMarker, "seconds").format("h:mm:ss", {trim: false});
      template.$('#video-marker-input').val(videoMarker);
    }
  },
  'blur input#video-marker-input' (e, template){
    var textContent = template.$('#video-marker-input').val();
    var videoMarkerArray = textContent.split(':').reverse();
    var videoMarker = moment.duration({hours: videoMarkerArray[2], minutes: videoMarkerArray[1], seconds: videoMarkerArray[0]}).asSeconds();
    videoMarker = moment.duration(videoMarker, "seconds").format("h:mm:ss", {trim: false});
    template.$('#video-marker-input').val(videoMarker);
  }
});


text:
import os
import sys

def solve(path):
    count = 0

    for root, _, files in os.walk(path):
        for filename in files:
            with open(os.path.join(root, filename)) as f:
                for line in f:
                    count += line.lower().count("crap")

    return count

def main():
    if len(sys.argv) != 2:
        print("Usage: python %s path" % sys.argv[0])
    else:
        print(solve(sys.argv[1]))

if __name__ == '__main__':
    main()


text:
import argparse

argparser = argparse.ArgumentParser()

argparser.add_argument("target")
argparser.add_argument("locales", nargs=argparse.REMAINDER)

options = argparser.parse_args()

if "en-US" in options.locales:
  options.locales.remove("en-US");

if not options.locales:
  raise Exception("Must specify at least one locale");

with open(options.target, "wt") as f:
  print("""# Copyright (c) 2016 Vivaldi Technologies AS. All rights reserved
import argparse
import os

LOCALES = [
  "%(locales)s"
]

argparser = argparse.ArgumentParser()
argparser.add_argument("--android", action="store_true")
argparser.add_argument("filename")
argparser.add_argument("prefix_path", default="", nargs="?")
options = argparser.parse_args()

print("-"*40)
print("<output>")
format = "%%(path)s%%(filename)s_%%(locale)s.%%(ext)s"
if options.android:
  format = "%%(path)s-%%(locale)s/%%(filename)s.%%(ext)s"
for locale in LOCALES:
  spec_locale = locale if locale != "nb" else "no"
  params = dict(
    path = options.prefix_path + "/" if options.prefix_path and not options.android else options.prefix_path,
    locale = locale,
    spec_locale = spec_locale,
    ext = "xml" if options.android else "pak",
    filename = options.filename,
    type = "android" if options.android else "data_package",
  )
  print( ('  <output filename="' + format + '" type="%%(type)s" lang="%%(spec_locale)s" />') %% params)
print("</output>")
print("-"*40)
""" % dict(locales = '",\n  "'.join(sorted(list(set(options.locales))))), file=f)


text:
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>W26389_text</title>
        <link rel="stylesheet" type="text/css" href="style.css" />

                «

    <p class="styleSans334.0000<enum PANGO_WEIGHT_NORMAL of type PangoWeight><enum PANGO_STYLE_NORMAL of type PangoStyle>">Page 2 Q SF N 2466 (04—2010)
GEOLOGICAL MARKERS PLUG BACK INFORMATION
Formation TVD (Ft)
Kibbey Limestone 8557
8711 Base Last Salt 9338 Mission Canyon 9448 Lodgepole 10030 10338
1 0866
10875 10887
1 0906

Carrington Shale Scallion Member Upper Bakken Middle Bakken
11102

Drill Stem Test
siDae 7 7 Top (Ft) Bottom (Ft) BH Temp (°F) HZSpp ' Shu-in1PSlG Sui-in(PG) Drill Pipe Recovery
Sample Chamber Recovery
Tesate if Top (Ft) Bottom (Ft) BH Temp (°F) CL ppm HZS ppm Shun1Sl St—i (PG)


text:
package org.rlcommunity.environment.octopus.components;

import org.rlcommunity.environment.octopus.config.*;
import org.rlcommunity.environments.octopus.odeframework.*;

import java.util.*;

/**
 *
A two-particle system that is constrained to rotate about its geometric
 * center.

 */
public class ArmBase implements ODEEquationPart {

    private static final int STATE_LENGTH = 2;

    private RotationConstrainedNode upper, lower;

    private Vector2D center;
    private double radius;
    private double inertia;

    private double angularPosition, angularVelocity;

    private double posTorque, negTorque;

    private double assumedTime;

    public ArmBase(NodePairSpec pairSpec) {
        upper = new RotationConstrainedNode(pairSpec.getUpper());
        lower = new RotationConstrainedNode(pairSpec.getLower());

        center = upper.getPosition().add(lower.getPosition()).scale(0.5);

        Vector2D radVector = upper.getPosition().subtract(center);
        radius = radVector.norm();
        inertia = radius * radius * (upper.getMass() + lower.getMass());

        angularPosition = Math.atan2(radVector.getY(), radVector.getX());

        /* override the supplied initial velocities of the nodes; they might not
         * respect the constraint */
        upper.setVelocity(Vector2D.ZERO);
        lower.setVelocity(Vector2D.ZERO);
        angularVelocity = 0;

        posTorque = 0.0;
        negTorque = 0.0;
    }

    public void setAction(double posTorque, double negTorque) {
        this.posTorque = posTorque;
        this.negTorque = negTorque;
    }

    public Node getUpperNode() {
        return upper;
    }

    public Node getLowerNode() {
        return lower;
    }

    public ODEState getCurrentODEState() {
        while(angularPosition>Math.PI)angularPosition-=2.0d*Math.PI;
        while(angularPosition<-Math.PI)angularPosition+=2.0d*Math.PI;
        return new ODEState(new double[] {angularPosition, angularVelocity});
    }

    public ODEState getODEStateDerivative() {
        double torque = Constants.get().getTorqueCoefficient()
            * (posTorque - negTorque);
        for (Node n: Arrays.asList(upper, lower)) {
            Vector2D radius = n.getPosition().subtract(center);
            torque += radius.crossMag(n.getNetForce());
        }
        double angularAccel = torque / inertia;
        return new ODEState(new double[] {angularVelocity, angularAccel});
    }

    public void assumeTimeAndState(double time, ODEState state) {
        this.assumedTime = time;

        double[] s = state.getArray();
        angularPosition = s[0];

        angularVelocity = s[1];

        Vector2D radVector = Vector2D.polar(radius, angularPosition);
        upper.setPosition(center.add(radVector));
        lower.setPosition(center.subtract(radVector));

        /* equivalent to standard "omega cross r" formula */
        upper.setVelocity(radVector.rotate90().scale(angularVelocity));
        lower.setVelocity(radVector.rotate270().scale(angularVelocity));
    }

    public int getStateLength() {
        return STATE_LENGTH;
    }

    private class RotationConstrainedNode extends Node {

        private final ODEState EMPTY_STATE = new ODEState(new double[0]);

        private RotationConstrainedNode(NodeSpec spec) {
            super(spec);
        }

        public void setPosition(Vector2D position) {
            this.position = position;
        }

        public void setVelocity(Vector2D velocity) {
            this.velocity = velocity;
        }

        public int getStateLength() {
            return 0;
        }

        public ODEState getCurrentODEState() {
            return EMPTY_STATE;
        }

        public ODEState getODEStateDerivative() {
            return EMPTY_STATE;
        }

        public void assumeTimeAndState(double time, ODEState state) {
            /* does nothing */
        }
    }

    public void setODEState(double time, ODEState state) {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public double[] getODEStateDerivativeArray() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

}


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>pdb</groupId>
    <artifactId>pdb.pipes</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>pdb.pipes.base</artifactId>
  <packaging>jar</packaging>

</project>


text:
package cmcc.iot.onenet.javasdk.api.triggers;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.http.HttpResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.databind.ObjectMapper;

import cmcc.iot.onenet.javasdk.api.AbstractAPI;
import cmcc.iot.onenet.javasdk.exception.OnenetApiException;
import cmcc.iot.onenet.javasdk.http.HttpPostMethod;
import cmcc.iot.onenet.javasdk.request.RequestInfo.Method;
import cmcc.iot.onenet.javasdk.response.BasicResponse;
import cmcc.iot.onenet.javasdk.response.triggers.NewTriggersResponse;
import cmcc.iot.onenet.javasdk.utils.Config;

public class AddTriggersApi extends AbstractAPI{
	private final Logger logger = LoggerFactory.getLogger(this.getClass());
	private String title;
	private String dsid;
	private List<String> devids;
	private List<String>dsuuids;
	private String desturl;
	private String type;
	private Integer threshold;
	private HttpPostMethod HttpMethod;

	/**
	 * @param title
	 * @param dsid
	 * @param devids
	 * @param dsuuids
	 * @param desturl
	 * @param type
	 * @param threshold
	 * @param key
	 */
	public AddTriggersApi(String title, String dsid, List<String> devids, List<String> dsuuids, String desturl,
			String type, Integer threshold,String key) {
		super();
		this.title = title;
		this.dsid = dsid;
		this.devids = devids;
		this.dsuuids = dsuuids;
		this.desturl = desturl;
		this.type = type;
		this.threshold = threshold;
		this.key=key;
		this.method = Method.POST;
        Map<String, Object> headmap = new HashMap<String, Object>();
        HttpMethod=  new HttpPostMethod(method);
        headmap.put("api-key", key);
        HttpMethod.setHeader(headmap);
        this.url=Config.getString("test.url")+"/triggers";
        // body参数
        Map<String, Object> bodymap = new HashMap<String, Object>();
        if (title != null) {
            bodymap.put("title", title);
        }
        if (dsid != null) {
            bodymap.put("ds_id", dsid);
        }
        if (devids != null) {
            bodymap.put("dev_ids", devids);
        }
        if (dsuuids != null) {
            bodymap.put("ds_uuids", dsuuids);
        }
        if (desturl != null) {
            bodymap.put("url", desturl);
        }
        if (type != null) {
            bodymap.put("type", type);
        }
        if (threshold != null) {
            bodymap.put("threshold", threshold);
        }
        String json=null;
        ObjectMapper remapper = new ObjectMapper();
        try {
            json = remapper.writeValueAsString(bodymap);
        } catch (Exception e) {
            logger.error("json error {}", e.getMessage());
            throw new OnenetApiException(e.getMessage());
        }
        ((HttpPostMethod)HttpMethod).setEntity(json);
        HttpMethod.setcompleteUrl(url,null);
	}

	public BasicResponse<NewTriggersResponse> executeApi(){
		BasicResponse response=null;
		try {
			HttpResponse httpResponse=HttpMethod.execute();
			response = mapper.readValue(httpResponse.getEntity().getContent(),BasicResponse.class);
			response.setJson(mapper.writeValueAsString(response));
			Object newData = mapper.readValue(mapper.writeValueAsString(response.getDataInternal()), NewTriggersResponse.class);
			response.setData(newData);
			return response;
		} catch (Exception e) {
			logger.error("json error {}", e.getMessage());
			throw new OnenetApiException(e.getMessage());
		}
		finally {
			try {
				HttpMethod.httpClient.close();
			} catch (Exception e) {
				logger.error("http close error: {}", e.getMessage());
				throw new OnenetApiException(e.getMessage());
			}
		}
	}
}


text: Message of Directive: {{directiveMessage}}


text:
"use strict";

const path = require("path");
const runPrettier = require("../run-prettier.js");

describe("support absolute filename", () => {
  runPrettier("cli/ignore-absolute-path", [
    path.resolve(__dirname, "../cli/ignore-absolute-path/ignored/module.js"),
    path.resolve(__dirname, "../cli/ignore-absolute-path/depth1/ignored/*.js"),
    path.resolve(__dirname, "../cli/ignore-absolute-path/regular-module.js"),
    "-l",
  ]).test({
    status: 1,
  });
});


text:
<?php

class CloudTest extends TestCase
{
    public function testThemeList()
    {
        self::setFromEnv();

        $themes = \SpringSignage\Api\Cloud::getThemes();

        $this->assertArrayHasKey('data', (array)$themes);
        $this->assertGreaterThanOrEqual(2, count((array)$themes));
    }

    public function testDomainList()
    {
        self::setFromEnv();

        $domains = \SpringSignage\Api\Cloud::getDomains();

        $this->assertArrayHasKey('data', (array)$domains);
        $this->assertGreaterThanOrEqual(3, count((array)$domains));
    }

    public function testInstanceList()
    {
        self::setFromEnv();

        $instances = \SpringSignage\Api\Cloud::getInstances();

        $this->assertArrayHasKey('data', (array)$instances);
    }
}


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>org.aksw.owl2sparql</groupId>
	<artifactId>owl2sparql-core</artifactId>
	<version>0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>owl2sparql-core</name>
	<description>A simple OWL to SPARQL converter</description>
	<url>https://github.com/AKSW/OWL2SPARQL</url>
	<inceptionYear>2015</inceptionYear>

	<organization>
		<name>AKSW</name>
		<url>http://aksw.org</url>
	</organization>

	<developers>
		<developer>
			<name>Lorenz Buehmann</name>
			<email>buehmann@informatik.uni-leipzig.de</email>
			<roles>
				<role>lead developer</role>
			</roles>
			<organizationUrl>http://aksw.org</organizationUrl>
		</developer>
	</developers>

	<licenses>
		<license>
			<name>The Apache Software License, Version 2.0</name>
			<url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
			<distribution>repo</distribution>
			<comments>A business-friendly OSS license</comments>
		</license>
	</licenses>

	<scm>
		<connection>scm:git:git@github.com:AKSW/owl2sparql.git</connection>
		<tag>HEAD</tag>
	</scm>

	<distributionManagement>
		<repository>
			<id>maven.aksw.internal</id>
			<name>AKSW Internal Release Repository</name>
			<url>http://maven.aksw.org/archiva/repository/internal</url>
		</repository>
		<snapshotRepository>
			<id>maven.aksw.snapshots</id>
			<name>AKSW Snapshot Repository</name>
			<url>http://maven.aksw.org/archiva/repository/snapshots</url>
		</snapshotRepository>
	</distributionManagement>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
	</properties>

	<dependencies>
		<dependency>
			<groupId>net.sourceforge.owlapi</groupId>
			<artifactId>owlapi-distribution</artifactId>
			<version>4.2.4</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>19.0</version>
		</dependency>
		<dependency>
			<groupId>org.apache.jena</groupId>
			<artifactId>jena-arq</artifactId>
			<version>2.13.0</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.3</version>
				<configuration>
					<source>${maven.compiler.source}</source>
					<target>${maven.compiler.target}</target>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-javadoc-plugin</artifactId>
				<version>2.10.3</version>
				<executions>
					<execution>
						<id>attach-javadoc</id>
						<phase>verify</phase>
						<goals>
							<goal>jar</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-source-plugin</artifactId>
				<version>2.4</version>
				<executions>
					<execution>
						<id>attach-sources</id>
						<phase>verify</phase>
						<goals>
							<goal>jar-no-fork</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.codehaus.mojo</groupId>
				<artifactId>license-maven-plugin</artifactId>
				<version>1.8</version>
				<configuration>
					<licenseName>apache_v2</licenseName>
					<addJavaLicenseAfterPackage>false</addJavaLicenseAfterPackage>
					<failOnMissingHeader>true</failOnMissingHeader>
					<failOnNotUptodateHeader>true</failOnNotUptodateHeader>
					<roots>
						<root>src/main/java</root>
						<root>src/test/java</root>
					</roots>
				</configuration>
				<executions>
					<execution>
						<phase>validate</phase>
						<goals>
							<goal>check-file-header</goal>
						</goals>
					</execution>
				</executions>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-release-plugin</artifactId>
				<version>2.5.2</version>
				<configuration>
					<useReleaseProfile>false</useReleaseProfile>
					<autoVersionSubmodules>true</autoVersionSubmodules>
				</configuration>
			</plugin>
		</plugins>
	</build>

	<issueManagement>
		<system>GitHub</system>
		<url>https://github.com/AKSW/OWL2SPARQL/issues</url>
	</issueManagement>
</project>


text:
<?xml version="1.0" encoding="utf-8"?>
<resources>

    <string name="app_name">RxFacebookApp</string>
    <string name="title_section1">Section 1</string>
    <string name="title_section2">Section 2</string>
    <string name="title_section3">Section 3</string>
    <string name="hello_world">Hello world!</string>
    <string name="action_settings">Settings</string>

    <!-- sromku -->
    <!-- string name="app_id">728615400528729</string -->
    <!-- RxF4c36ook -->
    <!-- string name="app_id">1587345544879203</string -->
    <!-- RxF4c36ook-test -->
    <string name="app_id">1587349598212131</string>
</resources>


text:
"use strict";

import { first } from "./utilities/array";
import { parseParts } from "./utilities/lookAhead";
import { EMPTY_STRING } from "./constants";

export default class Definition {
  constructor(parts) {
    this.parts = parts;
  }

  getParts() {
    return this.parts;
  }

  getFirstPart() {
    const firstPart = first(this.parts);

    return firstPart;
  }

  getPartsLength() {
    const partsLength = this.parts.length;

    return partsLength;
  }

  addPart(part) {
    this.parts.push(part);
  }

  parse(nodes, state, callback) {
    let parsed;

    const index = 0;

    parsed = parseParts(this.parts, nodes, index, state, callback);

    return parsed;
  }

  asString() {
    const partsString = this.parts.reduce((partsString, part) => {
          const partString = part.asString();

          if (partsString === EMPTY_STRING) {
            partsString = partString; ///
          } else {
            partsString = `${partsString} ${partString}`;
          }

          return partsString;
        }, EMPTY_STRING),
        string = partsString; ///

    return string;
  }
}