text:
require 'integration/spec_helper'
context 'when a single cluster is defined' do
  before(:all) do
    @cluster_name = fetch_and_verify_cluster('BOSH_VSPHERE_CPI_CLUSTER')
    @datastore_pattern = fetch_and_verify_datastore('BOSH_VSPHERE_CPI_DATASTORE_PATTERN', @cluster_name)
    @second_datastore = fetch_and_verify_datastore('BOSH_VSPHERE_CPI_SECOND_DATASTORE', @cluster_name)
    @shared_datastore = fetch_and_verify_datastore('BOSH_VSPHERE_CPI_SHARED_DATASTORE', @cluster_name)
    verify_non_overlapping_datastores(
      cpi_options,
      @datastore_pattern,
      'BOSH_VSPHERE_CPI_DATASTORE_PATTERN',
      @second_datastore,
      'BOSH_VSPHERE_CPI_SECOND_DATASTORE'
    )
  end

  let(:network_spec) do
    {
      'static' => {
        'ip' => "169.254.#{rand(1..254)}.#{rand(4..254)}",
        'netmask' => '255.255.254.0',
        'cloud_properties' => {'name' => @vlan},
        'default' => ['dns', 'gateway'],
        'dns' => ['169.254.1.2'],
        'gateway' => '169.254.1.3'
      }
    }
  end
  let(:vm_type) do
    {
      'ram' => 512,
      'disk' => 2048,
      'cpu' => 1,
    }
  end

  context 'randomization for datastore selection is set to zero' do
    # Mocking out stable random to a constant 1 to ensure algorithm scores
    # datastores in descending order of free space.
    module VSphereCloud::SelectionPipeline::StableRandom
      def self.[](object)
        1
      end
    end
    let(:all_datastore_cpi) do
      options = cpi_options(
        datacenters: [{
          datastore_pattern: '.*',
          persistent_datastore_pattern: '.*',
        }],
      )
      VSphereCloud::Cloud.new(options)
    end

    it 'should pick the datastore with most amount of free space' do
      cluster_resource = all_datastore_cpi.datacenter.find_cluster(@cluster_name)
      max_free_space_datastore = cluster_resource.mob.datastore.sort_by do |ds|
        ds.summary.free_space
      end.reverse.map(&:name).first
      begin
        @vm_id = all_datastore_cpi.create_vm(
          'agent-007',
          @stemcell_id,
          vm_type,
          network_spec,
          [],
          {}
        )
        expect(@vm_id).to_not be_nil
        expect(all_datastore_cpi.has_vm?(@vm_id)).to be(true)
        vm_mob=all_datastore_cpi.client.find_vm_by_name(all_datastore_cpi.datacenter.mob, @vm_id)
        @disk_id = all_datastore_cpi.create_disk(2048, {}, @vm_id)
        expect(@disk_id).to_not be_nil
        expect(all_datastore_cpi.has_disk?(@disk_id)).to be(true)
        disk = all_datastore_cpi.datacenter.find_disk(VSphereCloud::DirectorDiskCID.new(@disk_id))
        expect(disk.datastore.name).to match(max_free_space_datastore)
        expect(vm_mob.datastore.map(&:name)).to contain_exactly(max_free_space_datastore)
      ensure
        delete_vm(all_datastore_cpi, @vm_id)
        delete_disk(all_datastore_cpi, @disk_id)
      end
    end
  end
  context 'given CPIs that are configured to use different datastores' do

    let(:first_datastore_cpi) do
      options = cpi_options(
        datacenters: [{
          datastore_pattern: @datastore_pattern,
          persistent_datastore_pattern: @datastore_pattern,
        }],
      )
      VSphereCloud::Cloud.new(options)
    end
    let(:second_datastore_cpi) do
      options = cpi_options(
        datacenters: [{
          datastore_pattern: @second_datastore,
          persistent_datastore_pattern: @second_datastore,
        }],
      )
      VSphereCloud::Cloud.new(options)
    end

    before do
      @vm_id = first_datastore_cpi.create_vm(
        'agent-007',
        @stemcell_id,
        vm_type,
        network_spec,
        [],
        {}
      )

      expect(@vm_id).to_not be_nil
      expect(first_datastore_cpi.has_vm?(@vm_id)).to be(true)

      @disk_id = first_datastore_cpi.create_disk(2048, {}, @vm_id)
      expect(@disk_id).to_not be_nil
      expect(first_datastore_cpi.has_disk?(@disk_id)).to be(true)
      disk = first_datastore_cpi.datacenter.find_disk(VSphereCloud::DirectorDiskCID.new(@disk_id))
      expect(disk.datastore.name).to match(@datastore_pattern)
    end

    after do
      delete_vm(first_datastore_cpi, @vm_id)
      delete_disk(first_datastore_cpi, @disk_id)
    end

    it 'can exercise lifecycle with the cpi configured with a non-overlapping datastore pattern' do
      begin
        expect(second_datastore_cpi.has_disk?(@disk_id)).to be(true)

        first_datastore_cpi.attach_disk(@vm_id, @disk_id)

        second_datastore_cpi.detach_disk(@vm_id, @disk_id)

        expect(second_datastore_cpi.has_disk?(@disk_id)).to be(true)
      ensure
        second_datastore_cpi.delete_vm(@vm_id)
        second_datastore_cpi.delete_disk(@disk_id)
      end
    end

    it '#attach_disk can move the disk to the new datastore pattern' do
      second_datastore_cpi.attach_disk(@vm_id, @disk_id)

      disk = second_datastore_cpi.datacenter.find_disk(VSphereCloud::DirectorDiskCID.new(@disk_id))
      expect(disk.cid).to eq(@disk_id)
      expect(disk.datastore.name).to match(@second_datastore)

      second_datastore_cpi.detach_disk(@vm_id, @disk_id)
    end
  end
end


text:
var get = Ember.get, set = Ember.set, merge = Ember.merge;

function mustImplement(name) {
  return function() {
    throw new Ember.Error("Your adapter " + this.toString() + " does not implement the required method " + name);
  };
}

import SerializerForMixin from './serializers/serializer_for_mixin';

export default Ember.Object.extend(SerializerForMixin, {
  mergedProperties: ['configs'],

  init: function() {
    this._super.apply(this, arguments);
    this.configs = {};
    this.container = this.setupContainer(this.container);
  },

  setupContainer: function(container) {
    return container;
  },

  configFor: function(type) {
    var configs = get(this, 'configs'),
        typeKey = get(type, 'typeKey');

    return configs[typeKey] || {};
  },

  newSession: function() {
    var Session = this.container.lookupFactory('session:base');
    return Session.create({
      adapter: this
    });
  },

  load: mustImplement("load"),

  query: mustImplement("find"),

  refresh: mustImplement("refresh"),

  flush: mustImplement("flush"),

  remoteCall: mustImplement("remoteCall"),

  serialize: function(model, opts) {
    return this.serializerForModel(model).serialize(model, opts);
  },

  deserialize: function(typeKey, data, opts) {
    return this.serializerFor(typeKey).deserialize(data, opts);
  },

  merge: function(model, session) {
    if(!session) {
      session = this.container.lookup('session:main');
    }
    return session.merge(model);
  },

  mergeData: function(data, typeKey, session) {
    if(!typeKey) {
      typeKey = this.defaultSerializer;
    }

    var serializer = this.serializerFor(typeKey),
        deserialized = serializer.deserialize(data);

    if(get(deserialized, 'isModel')) {
      return this.merge(deserialized, session);
    } else {
      return Ember.EnumerableUtils.map(deserialized, function(model) {
        return this.merge(model, session);
      }, this);
    }
  },

  mergeError: Ember.aliasMethod('mergeData'),

  willMergeModel: Ember.K,

  didMergeModel: Ember.K,

  // This can be overridden in the adapter sub-classes
  isDirtyFromRelationships: function(model, cached, relDiff) {
    return relDiff.length > 0;
  },

  shouldSave: function(model) {
    return true;
  },

  reifyClientId: function(model) {
    this.idManager.reifyClientId(model);
  }

});

redpajama_set_name: RedPajamaGithub


text:
{-# LANGUAGE OverloadedStrings #-}

module Nauva.Catalog.Theme.Typeface
    ( h2Typeface
    , h3Typeface
    , h4Typeface

    , paragraphTypeface
    , blockquoteTypeface
    , meta14Typeface

    , system14Typeface

    , mono12Typeface
    , mono14Typeface
    ) where

import Nauva.View

themeFontFamily :: CSSValue
themeFontFamily = "'Roboto', sans-serif"

-------------------------------------------------------------------------------
-- Headings

h2Typeface :: Typeface
h2Typeface = Typeface
    { tfName       = "h2"
    , tfFontFamily = themeFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "27.648px"
    , tfLineHeight = "1.2"
    }

h3Typeface :: Typeface
h3Typeface = Typeface
    { tfName       = "h3"
    , tfFontFamily = themeFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "23.04px"
    , tfLineHeight = "1.2"
    }

h4Typeface :: Typeface
h4Typeface = Typeface
    { tfName       = "h4"
    , tfFontFamily = themeFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "19.2px"
    , tfLineHeight = "1.2"
    }

-------------------------------------------------------------------------------
-- Copy

paragraphTypeface :: Typeface
paragraphTypeface = Typeface
    { tfName       = "paragraph"
    , tfFontFamily = themeFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "16px"
    , tfLineHeight = "1.44"
    }

blockquoteTypeface :: Typeface
blockquoteTypeface = Typeface
    { tfName       = "blockquote"
    , tfFontFamily = themeFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "19.2px"
    , tfLineHeight = "1.44"
    }

meta14Typeface :: Typeface
meta14Typeface = Typeface
    { tfName       = "paragraph"
    , tfFontFamily = themeFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "14px"
    , tfLineHeight = "1.2"
    }

-------------------------------------------------------------------------------
-- System

systemFontFamily :: CSSValue
systemFontFamily = "-apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, Helvetica, Arial, sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\""

system14Typeface :: Typeface
system14Typeface = Typeface
    { tfName       = "system14"
    , tfFontFamily = systemFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "14px"
    , tfLineHeight = "1.44"
    }

-------------------------------------------------------------------------------
-- Monospace

monoFontFamily :: CSSValue
monoFontFamily = "'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, Courier, monospace"

mono12Typeface :: Typeface
mono12Typeface = Typeface
    { tfName       = "mono12"
    , tfFontFamily = monoFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "12px"
    , tfLineHeight = "1.44"
    }

mono14Typeface :: Typeface
mono14Typeface = Typeface
    { tfName       = "mono14"
    , tfFontFamily = monoFontFamily
    , tfFontWeight = "400"
    , tfFontSize   = "14px"
    , tfLineHeight = "1.44"
    }


text:
// Copyright 2018 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.worker;

import static com.google.common.truth.Truth.assertThat;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.devtools.build.lib.testutil.TestUtils;
import com.google.devtools.build.lib.vfs.FileSystem;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.lib.vfs.PathFragment;
import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
import java.io.IOException;
import java.nio.charset.Charset;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Tests for {@link WorkerExecRoot}. */
@RunWith(JUnit4.class)
public class WorkerExecRootTest {
  private FileSystem fileSystem;
  private Path testRoot;
  private Path workspaceDir;
  private Path sandboxDir;
  private Path execRoot;

  @Before
  public final void setupTestDirs() throws IOException {
    fileSystem = new InMemoryFileSystem();
    testRoot = fileSystem.getPath(TestUtils.tmpDir());
    testRoot.createDirectoryAndParents();

    workspaceDir = testRoot.getRelative("workspace");
    workspaceDir.createDirectory();
    sandboxDir = testRoot.getRelative("sandbox");
    sandboxDir.createDirectory();
    execRoot = sandboxDir.getRelative("execroot");
    execRoot.createDirectory();
  }

  @Test
  public void cleanFileSystem() throws Exception {
    Path workerSh = workspaceDir.getRelative("worker.sh");
    FileSystemUtils.writeContentAsLatin1(workerSh, "#!/bin/bash");

    WorkerExecRoot workerExecRoot =
        new WorkerExecRoot(
            execRoot,
            ImmutableMap.of(PathFragment.create("worker.sh"), workerSh),
            ImmutableSet.of(PathFragment.create("very/output.txt")),
            ImmutableSet.of(PathFragment.create("worker.sh")));
    workerExecRoot.createFileSystem();

    // Pretend to do some work inside the execRoot.
    execRoot.getRelative("tempdir").createDirectory();
    FileSystemUtils.createEmptyFile(execRoot.getRelative("very/output.txt"));
    FileSystemUtils.createEmptyFile(execRoot.getRelative("temp.txt"));
    // Modify the worker.sh so that we're able to detect whether it gets rewritten or not.
    FileSystemUtils.writeContentAsLatin1(workerSh, "#!/bin/sh");

    // Reuse the same execRoot.
    workerExecRoot.createFileSystem();

    assertThat(execRoot.getRelative("worker.sh").exists()).isTrue();
    assertThat(
            FileSystemUtils.readContent(
                execRoot.getRelative("worker.sh"), Charset.defaultCharset()))
        .isEqualTo("#!/bin/sh");
    assertThat(execRoot.getRelative("tempdir").exists()).isFalse();
    assertThat(execRoot.getRelative("very/output.txt").exists()).isFalse();
    assertThat(execRoot.getRelative("temp.txt").exists()).isFalse();
  }
}


text:
'use strict'

var sqlite3 = require('sqlite3').verbose();
var db = new sqlite3.Database('./dane.sqlite3');
var select = "Select definition From headwords where word = (?)";
var insert = "Insert into headwords (word, definition) values ((?), (?))";

exports.getWord = function(res, w) {
  var stmt = db.prepare(select);
  stmt.all(w, function(err, rows) {
      console.log(JSON.stringify(rows));
      res.json(rows);
  });
}

exports.setWord = function(res, w, d) {
  var stmt = db.prepare(insert);
  stmt.all(w, d, function(err, rows){
    console.log(JSON.stringify(rows));
    res.redirect('/form.html');
  });
}


text:
"""
#;+
#; NAME:
#; utils
#;    Version 1.0
#;
#; PURPOSE:
#;    Module for spectral utilities
#;       Primarily overloads of Spectrum1D
#;   07-Sep-2014 by JXP
#;-
#;------------------------------------------------------------------------------
"""
from __future__ import print_function, absolute_import, division, unicode_literals

import numpy as np
import os
import astropy as apy

from astropy import units as u
from astropy import constants as const
from astropy.io import fits

#from specutils import Spectrum1D
#from specutils.wcs import BaseSpectrum1DWCS, Spectrum1DLookupWCS
#from specutils.wcs.specwcs import Spectrum1DPolynomialWCS

from xastropy.xutils import xdebug as xdb

'''
DEPRECATED
'''


text:
@interface GMTwoButtonTableCell : UITableViewCell {
    UIButton *firstButton;
    UIButton *secondButton;
}

@property (retain) UIButton *firstButton;
@property (retain) UIButton *secondButton;

@end


text:
namespace EF6Sample
{

using System;
    using System.Collections.Generic;

public partial class D3
{

    public D3()
    {

        this.D31 = new HashSet<D31>();

        this.D32 = new HashSet<D32>();

        this.D33 = new HashSet<D33>();

    }

    public System.Guid primaryKey { get; set; }

    public string Name { get; set; }

    public System.Guid D0 { get; set; }

    public string S1 { get; set; }

    public string S2 { get; set; }

    public string S3 { get; set; }

    public string S4 { get; set; }

    public string S5 { get; set; }

    public virtual D0 D01 { get; set; }

    public virtual ICollection<D31> D31 { get; set; }

    public virtual ICollection<D32> D32 { get; set; }

    public virtual ICollection<D33> D33 { get; set; }

}

}


text:
package com.mangopay.core.APIs;

import com.mangopay.MangoPayApi;
import com.mangopay.core.*;
import java.net.*;
import java.util.*;
import java.util.logging.*;

/**
 * API for OAuth.
 */
public class ApiOAuth extends ApiBase {

    /**
     * Instantiates new ApiOAuth object.
     * @param root Root/parent instance that holds the OAuthToken and Configuration instance.
     */
    public ApiOAuth(MangoPayApi root) { super(root); }

    /**
     * Gets the new token used for requests authentication.
     * @return OAuth object with token information.
     */
    public OAuthToken createToken() throws Exception {

        String urlMethod = this.getRequestUrl("authentication_oauth");
        String requestType = this.getRequestType("authentication_oauth");
        Map<String, String> requestData = new HashMap<String, String>(){{
            put("grant_type", "client_credentials");
        }};

        RestTool rest = new RestTool(this._root, false);
        AuthenticationHelper authHlp = new AuthenticationHelper(_root);

        try {
            rest.addRequestHttpHeader("Host", (new URL(_root.Config.BaseUrl)).getHost());
        } catch (MalformedURLException ex) {
            Logger.getLogger(ApiOAuth.class.getName()).log(Level.SEVERE, null, ex);
        }
        try {
            rest.addRequestHttpHeader("Authorization", "Basic " + authHlp.getHttpHeaderBasicKey());
        } catch (Exception ex) {
            Logger.getLogger(ApiOAuth.class.getName()).log(Level.SEVERE, null, ex);
        }
        rest.addRequestHttpHeader("Content-Type", "application/x-www-form-urlencoded");
        OAuthToken response = rest.request(OAuthToken.class, urlMethod, requestType, requestData);

        return response;
    }
}


text:
let Astronomy = null;
let Mongo = null;
function init(_mongo, _astronomy) {

  Astronomy = _astronomy;
  Mongo = _mongo;

  let mongoWidget = new Mongo.Collection('mongoWidgets');
  let astroWidget = Astronomy.create({

    name: 'Widget',
    collection: mongoWidget,
    fields: {
      title: String,
      size: Number,
      content: String,
    },
    helpers: {
      fullText() {
        var full = this.title + ' ' + this.content;
        return full;
      }
    },
    behaviors: {
      softremove: {
        // The field name with a flag for marking a document as removed.
        removedFieldName: 'removed',
        // A flag indicating if a 'removedAt' field should be present in a document.
        hasRemovedAtField: true,
        // The field name storing the removal date.
        removedAtFieldName: 'removedAt'
      }
    }

  });

  return { astroWidget, mongoWidget };

}

export const Widget = {
  new: init,
};


text:
<?php

namespace Application\Migrations;

use Doctrine\DBAL\Migrations\AbstractMigration,
    Doctrine\DBAL\Schema\Schema;

/**
 * Auto-generated Migration: Please modify to your need!
 */
class Version20120607091940 extends AbstractMigration
{
    public function up(Schema $schema)
    {
        // this up() migration is autogenerated, please modify it to your needs
        $this->abortIf($this->connection->getDatabasePlatform()->getName() != "mysql");

        $this->addSql("ALTER TABLE inscripcion CHANGE sede sede INT NOT NULL");
        $this->addSql("ALTER TABLE inscripcion ADD CONSTRAINT FK_935E99F02C395692 FOREIGN KEY (sexo) REFERENCES opcion_sexo(id)");
    }

    public function down(Schema $schema)
    {
        // this down() migration is autogenerated, please modify it to your needs
        $this->abortIf($this->connection->getDatabasePlatform()->getName() != "mysql");

        $this->addSql("ALTER TABLE inscripcion DROP FOREIGN KEY FK_935E99F02C395692");
        $this->addSql("ALTER TABLE inscripcion CHANGE sede sede TINYINT(1) DEFAULT NULL");
    }
}


text:
{% load hashing_tag %}
{% load static %}
{% load settings_value %}
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="utf-8">
    {% comment %} <title>MyUW: {{ page_title|default:'MyUW'}}</title> {% endcomment %}

    {% if is_hybrid %}
    <!-- disable zooming for hybrid -->
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=0"/>
    {% else %}
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    {% endif %}
    <meta name="description" content="">

    <!-- TODO: Add google fonts here -->

    <!-- favicon -->
    <link rel="shortcut icon" href="{% static 'images/favicon.ico' %}" type="image/x-icon">

    <!-- ios icons -->
    <link rel="apple-touch-icon-precomposed" sizes="180x180"
        href="{% static 'images/apple-touch-icon-180x180-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" sizes="152x152"
        href="{% static 'images/apple-touch-icon-152x152-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" sizes="144x144"
        href="{% static 'images/apple-touch-icon-144x144-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" sizes="120x120"
        href="{% static 'images/apple-touch-icon-120x120-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" sizes="114x114"
        href="{% static 'images/apple-touch-icon-114x114-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" sizes="76x76"
        href="{% static 'images/apple-touch-icon-76x76-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" sizes="72x72"
        href="{% static 'images/apple-touch-icon-72x72-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" sizes="57x57"
        href="{% static 'images/apple-touch-icon-57x57-precomposed.png' %}">
    <link rel="apple-touch-icon-precomposed" href="{% static 'images/apple-touch-icon-precomposed.png' %}">

    <!-- android icons -->
    <link rel="shortcut icon" sizes="196x196" href="{% static 'images/android-196x196.png' %}">

    <!-- google fonts -->
    <link rel="preconnect" href="https://fonts.googleapis.com">
    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
    <link href="https://fonts.googleapis.com/css2?family=Encode+Sans:wght@700&family=Open+Sans:ital,wght@0,400;0,700;1,400&family=Roboto:wght@400;700&display=swap" rel="stylesheet">

    <script>
        // Check if this browser is Internet Explorer 11 and lower
        if (window.navigator.userAgent.match(/MSIE|Trident/) !== null) {
            // Notify the user that we do not support this browser
            alert("We have detected that your browser is Internet Explorer 11 or lower.\n" +
                "Please switch to another supported browser such as Chrome, Firefox, Safari, and Edge.");
        }
    </script>

    <script id="static_url" type="application/json">
        "{% settings_value 'STATIC_URL' %}"
    </script>
    {{ user|json_script:'user' }}
    {{ disable_actions|json_script:'disable_actions' }}
    {{ banner_messages|json_script:'banner_messages' }}
    {{ persistent_messages|json_script:'persistent_messages' }}
    {{ display_onboard_message|json_script:'display_onboard_message' }}
    {{ display_pop_up|json_script:'display_pop_up' }}
    {{ card_display_dates|json_script:'card_display_dates' }}

    <script>
    // TODO: Replace this with a object in the context and a json_script.
    window.term_data = {
        today: '{{ today|date:"l, F j, Y" }}',
        year: '{{ year }}',
        quarter: '{{ quarter }}',
        breakYear: '{{ break_year }}',
        breakQuarter: '{{ break_quarter }}',
        isFinals: {{ is_finals|yesno:"true, false"}},
        isBreak: {{ is_break|yesno:"true, false"}},
        todayDate: new Date({{ today|date:"Y" }}, {{ today|date:"n" }}-1, {{ today|date:"j"}}),
        firstDay: new Date({{ first_day|date:"Y" }}, {{ first_day|date:"n" }}-1, {{ first_day|date:"j"}}),
        lastDay: new Date({{ last_day|date:"Y" }}, {{ last_day|date:"n" }}-1, {{ last_day|date:"j"}}),
    };
    window.next_term = {
      year: '{{ next_year }}',
      quarter: '{{ next_quarter }}',
    };
    </script>
    {% block django_json_data %}
    {% endblock django_json_data %}

    {% block vue_script %}
    {% endblock vue_script %}
</head>

<body data-gtag="{{ google_analytics_key }}"
  data-hashid="{% hash_netid user.netid %}"
  data-tracking-enabled="{{ google_tracking_enabled|lower }}"
  class="myuw-font-open-sans">
    {% csrf_token %}
    <!-- Testing uw-alert with: http://127.0.0.1:8000/#uwalert-red -->
    <script src="//www.washington.edu/static/alert.js" type="text/javascript"></script>

    <div id="vue_root" hidden>
        {% block body_content %}
        {% endblock body_content %}
    </div>

</body>

</html>


text:
<?xml version="1.0" encoding="UTF-8"?>
<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>eu.mais-h.mathsync</groupId>
    <artifactId>parent</artifactId>
    <version>0.6.2</version>
  </parent>
  <artifactId>core-uber</artifactId>

  <name>Core library - shaded dependencies</name>

  <dependencies>
    <dependency>
      <groupId>eu.mais-h.mathsync</groupId>
      <artifactId>core</artifactId>
      <version>${project.version}</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>2.3</version>
        <executions>
          <execution>
            <id>create-uber-jar</id>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
            <configuration>
              <relocations>
                <relocation>
                  <pattern>org</pattern>
                  <shadedPattern>eu.mais_h.mathsync.shaded</shadedPattern>
                </relocation>
              </relocations>
            </configuration>
          </execution>
        </executions>
      </plugin>
       <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-jar-plugin</artifactId>
          <executions>
            <execution>
              <id>empty-javadoc-jar</id>
              <phase>package</phase>
              <goals>
                <goal>jar</goal>
              </goals>
              <configuration>
                <classifier>javadoc</classifier>
              </configuration>
            </execution>
          </executions>
        </plugin>
    </plugins>
  </build>
</project>


text:
CKEDITOR.plugins.setLang( 'div', 'ro', {
	IdInputLabel: 'Id',
	advisoryTitleInputLabel: 'Titlul consultativ',
	cssClassInputLabel: 'Clasele cu stilul paginii (CSS)',
	edit: 'Modifică Div-ul',
	inlineStyleInputLabel: 'Stil Inline',
	langDirLTRLabel: 'stânga-dreapta (LTR)',
	langDirLabel: 'Direcţia cuvintelor',
	langDirRTLLabel: 'dreapta-stânga (RTL)',
	languageCodeInputLabel: 'Codul limbii',
	remove: 'Șterge Div-ul',
	styleSelectLabel: 'Stil',
	title: 'Crează un container Div',
	toolbar: 'Crează un container Div'
} );