text:
<bill session="115" type="hr" number="32" updated="2017-09-11T03:02:44Z">
  <state datetime="2017-01-06">REFERRED</state>
  <status>
    <introduced datetime="2017-01-06"/>
  </status>
  <introduced datetime="2017-01-06"/>
  <titles>
    <title type="official" as="introduced">Recognizing July 28, 2017, as "World Hepatitis Day".</title>
    <title type="display">Recognizing July 28, 2017, as "World Hepatitis Day".</title>
  </titles>
  <sponsor bioguide_id="M001188"/>
  <cosponsors/>
  <actions>
    <action datetime="2017-01-06">
      <text>Introduced in House</text>
    </action>
    <action datetime="2017-01-06" state="REFERRED">
      <text>Referred to the House Committee on Energy and Commerce.</text>
    </action>
    <action datetime="2017-01-25">
      <text>Referred to the Subcommittee on Health.</text>
    </action>
  </actions>
  <committees>
    <committee subcommittee="" code="HSIF" name="House Energy and Commerce" activity="Referral"/>
    <committee subcommittee="Health" code="HSIF14" name="House Energy and Commerce" activity="Referral"/>
  </committees>
  <relatedbills>
    <bill type="sr" session="115" relation="unknown" number="236"/>
  </relatedbills>
  <subjects>
    <term name="Health"/>
    <term name="Commemorative events and holidays"/>
    <term name="Digestive and metabolic diseases"/>
    <term name="Health care coverage and access"/>
    <term name="Health programs administration and funding"/>
    <term name="Health promotion and preventive care"/>
    <term name="Infectious and parasitic diseases"/>
    <term name="World health"/>
  </subjects>
  <amendments/>
  <summary date="2017-01-06T05:00:00Z" status="Introduced in House">Recognizes World Hepatitis Day.

Expresses support for broad access to hepatitis treatments and for raising awareness of the risks and consequences of undiagnosed hepatitis infections.

Calls for a robust governmental and public health response to protect the health of the 5 million people in the United States and 400 million people worldwide who suffer from chronic viral hepatitis.</summary>
  <committee-reports/>
</bill>


text:
namespace net {
class IOBuffer;
}  // namespace net

namespace chromeos {
namespace file_system_provider {

// Wraps the file stream reader implementation with a prefetching buffer.
// Reads data from the internal file stream reader in chunks of size at least
// |preloading_buffer_length| bytes (or less for the last chunk, because of
// EOF). Up to |max_bytes_to_read| of bytes can be requested in total.
//
// The underlying internal file stream reader *must not* return any values
// synchronously. Instead, results must be returned by a callback, including
// errors.
class BufferingFileStreamReader : public storage::FileStreamReader {
 public:
  BufferingFileStreamReader(
      std::unique_ptr<storage::FileStreamReader> file_stream_reader,
      int preloading_buffer_length,
      int64_t max_bytes_to_read);

  ~BufferingFileStreamReader() override;

  // storage::FileStreamReader overrides.
  int Read(net::IOBuffer* buf,
           int buf_len,
           net::CompletionOnceCallback callback) override;
  int64_t GetLength(net::Int64CompletionOnceCallback callback) override;

 private:
  // Copies data from the preloading buffer and updates the internal iterator.
  // Returns number of bytes successfully copied.
  int CopyFromPreloadingBuffer(scoped_refptr<net::IOBuffer> buffer,
                               int buffer_length);

  // Preloads data from the internal stream reader and calls the |callback|.
  void Preload(net::CompletionOnceCallback callback);

  void OnReadCompleted(net::CompletionOnceCallback callback, int result);

  // Called when preloading of a buffer chunk is finished. Updates state of the
  // preloading buffer and copied requested data to the |buffer|.
  void OnPreloadCompleted(scoped_refptr<net::IOBuffer> buffer,
                          int buffer_length,
                          net::CompletionOnceCallback callback,
                          int result);

  std::unique_ptr<storage::FileStreamReader> file_stream_reader_;
  int preloading_buffer_length_;
  int64_t max_bytes_to_read_;
  int64_t bytes_read_;
  scoped_refptr<net::IOBuffer> preloading_buffer_;
  int preloading_buffer_offset_;
  int preloaded_bytes_;

  base::WeakPtrFactory<BufferingFileStreamReader> weak_ptr_factory_{this};
  DISALLOW_COPY_AND_ASSIGN(BufferingFileStreamReader);
};

}  // namespace file_system_provider
}  // namespace chromeos

#endif  // CHROME_BROWSER_CHROMEOS_FILE_SYSTEM_PROVIDER_FILEAPI_BUFFERING_FILE_STREAM_READER_H_

redpajama_set_name: RedPajamaGithub


text:
package co.edu.unicartagena.platf.model;

/**
 *
 * @author Gustavo Pacheco <ryctabo@gmail.com>
 * @version 1.0
 */
public enum RegisterKey {

    PERSON_NAME("person_name"),

    EMAIL("email"),

    PASSWORD("password"),

    YEAR("year");

    private final String name;

    private RegisterKey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

}


text:
class AddDepthToSpreeTaxons < ActiveRecord::Migration[4.2]
  def up
    if !Spree::Taxon.column_names.include?('depth')
      add_column :spree_taxons, :depth, :integer

      say_with_time 'Update depth on all taxons' do
        Spree::Taxon.reset_column_information
        Spree::Taxon.all.each(&:save)
      end
    end
  end

  def down
    remove_column :spree_taxons, :depth
  end
end


text:
import { Transform } from 'stream'

export default class AdjustBrowserField extends Transform {
  constructor(include, options={objectMode: true}) {
    super(options)
    this._include = include
  }
  _transform(entry, err, cb) {
    // entry: { filename: <absoluteFilePath>, parsed: <parsedJson> }
    if (entry.parsed && entry.parsed.browser) {
      let changed = false
      Object.keys(entry.parsed.browser).forEach((key) => {
        if (this._include.indexOf(key) !== -1) {
          delete entry.parsed.browser[key]
          changed = true
        }
      })
      if (changed === true) this.push(entry)
    }
    cb()
  }
}


text:
"""Gradients for operators defined in sparse_ops.py."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from tensorflow.python.framework import ops
from tensorflow.python.framework import sparse_tensor
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gen_sparse_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import sparse_ops

# TODO(b/31222613): This op may be differentiable, and there may be
# latent bugs here.
ops.NotDifferentiable("SparseAddGrad")
ops.NotDifferentiable("SparseConcat")
ops.NotDifferentiable("SparseToDense")

@ops.RegisterGradient("SparseReorder")
def _SparseReorderGrad(op, unused_output_indices_grad, output_values_grad):
  """Gradients for the SparseReorder op.

  Args:
    op: the SparseReorder op
    unused_output_indices_grad: the incoming gradients of the output indices
    output_values_grad: the incoming gradients of the output values

  Returns:
    Gradient for each of the 3 input tensors:
      (input_indices, input_values, input_shape)
    The gradients for input_indices and input_shape is None.
  """
  input_indices = op.inputs[0]
  input_shape = op.inputs[2]

  num_entries = array_ops.shape(input_indices)[0]
  entry_indices = math_ops.range(num_entries)
  sp_unordered = sparse_tensor.SparseTensor(
      input_indices, entry_indices, input_shape)
  sp_ordered = sparse_ops.sparse_reorder(sp_unordered)
  inverted_permutation = array_ops.invert_permutation(sp_ordered.values)

  return (None,
          array_ops.gather(output_values_grad, inverted_permutation),
          None)

@ops.RegisterGradient("SparseAdd")
def _SparseAddGrad(op, *grads):
  """The backward operator for the SparseAdd op.

  The SparseAdd op calculates A + B, where A, B, and the sum are all represented
  as `SparseTensor` objects.  This op takes in the upstream gradient w.r.t.
  non-empty values of the sum, and outputs the gradients w.r.t. the non-empty
  values of A and B.

  Args:
    op: the SparseAdd op
    *grads: the incoming gradients, one element per output of `op`

  Returns:
    Gradient for each of the 6 input tensors of SparseAdd:
      (a_indices, a_values, a_shape, b_indices, b_values, b_shape, thresh)
    The gradients for the indices, shapes, and the threshold are None.
  """
  val_grad = grads[1]
  a_indices = op.inputs[0]
  b_indices = op.inputs[3]
  sum_indices = op.outputs[0]
  # NOTE: we do not need to take `thresh` into account, since it simply affects
  # the non-zero elements of the sum, and we will peek into `sum_indices` in the
  # gradient op.

  # pylint: disable=protected-access
  a_val_grad, b_val_grad = gen_sparse_ops._sparse_add_grad(val_grad, a_indices,
                                                           b_indices,
                                                           sum_indices)
  a_val_grad.set_shape(op.inputs[1].get_shape())
  b_val_grad.set_shape(op.inputs[4].get_shape())
  # (a_indices, a_values, a_shape, b_indices, b_values, b_shape, thresh)
  return (None, a_val_grad, None, None, b_val_grad, None, None)

@ops.RegisterGradient("SparseTensorDenseAdd")
def _SparseTensorDenseAddGrad(op, out_grad):
  sp_indices = op.inputs[0]
  # (sparse_indices, sparse_values, sparse_shape, dense)
  return (None, array_ops.gather_nd(out_grad, sp_indices), None, out_grad)

@ops.RegisterGradient("SparseReduceSum")
def _SparseReduceSumGrad(op, out_grad):
  """Similar to gradient for the Sum Op (i.e. tf.reduce_sum())."""
  sp_indices = op.inputs[0]
  sp_shape = op.inputs[2]
  output_shape_kept_dims = math_ops.reduced_shape(sp_shape, op.inputs[3])
  out_grad_reshaped = array_ops.reshape(out_grad, output_shape_kept_dims)
  scale = sp_shape // math_ops.to_int64(output_shape_kept_dims)
  # (sparse_indices, sparse_values, sparse_shape, reduction_axes)
  return (None, array_ops.gather_nd(out_grad_reshaped, sp_indices // scale),
          None, None)

@ops.RegisterGradient("SparseTensorDenseMatMul")
def _SparseTensorDenseMatMulGrad(op, grad):
  """Gradients for the dense tensor in the SparseTensorDenseMatMul op.

  If either input is complex, no gradient is provided.

  Args:
    op: the SparseTensorDenseMatMul op
    grad: the incoming gradient

  Returns:
    Gradient for each of the 4 input tensors:
      (sparse_indices, sparse_values, sparse_shape, dense_tensor)
    The gradients for indices and shape are None.

  Raises:
    TypeError: When the two operands don't have the same type.
  """
  sp_t = sparse_tensor.SparseTensor(*op.inputs[:3])
  adj_a = op.get_attr("adjoint_a")
  adj_b = op.get_attr("adjoint_b")

  a_type = sp_t.values.dtype.base_dtype
  b_type = op.inputs[3].dtype.base_dtype
  if a_type != b_type:
    raise TypeError("SparseTensorDenseMatMul op received operands with "
                    "different types: ", a_type, " and ", b_type)
  if a_type in (ops.dtypes.complex64, ops.dtypes.complex128):
    raise NotImplementedError("SparseTensorDenseMatMul op does not support "
                              "complex gradients.")

  # gradient w.r.t. dense
  b_grad = sparse_ops.sparse_tensor_dense_matmul(sp_t, grad,
                                                 adjoint_a=not adj_a)
  if adj_b:
    b_grad = array_ops.transpose(b_grad)

  # gradient w.r.t. sparse values
  a_indices = op.inputs[0]
  b = op.inputs[3]

  rows = a_indices[:, 0]
  cols = a_indices[:, 1]

  # TODO(zongheng, ebrevdo): add conjugates in the right places when complex
  # values are allowed.
  # TODO(zongheng): these gather calls could potentially duplicate rows/cols in
  # memory.  If there is a need, we should look into implementing this more
  # intelligently to avoid duplicating data.
  parts_a = array_ops.gather(grad, rows if not adj_a else cols)
  parts_b = array_ops.gather(b if not adj_b else array_ops.transpose(b),
                             cols if not adj_a else rows)
  a_values_grad = math_ops.reduce_sum(parts_a * parts_b, reduction_indices=1)

  # gradients w.r.t. (a_indices, a_values, a_shape, b)
  return (None, a_values_grad, None, b_grad)

@ops.RegisterGradient("SparseDenseCwiseAdd")
def _SparseDenseCwiseAddGrad(unused_op, unused_grad):
  raise NotImplementedError("Gradient for SparseDenseCwiseAdd is currently not"
                            " implemented yet.")

def _SparseDenseCwiseMulOrDivGrad(op, grad, is_mul):
  """Common code for SparseDenseCwise{Mul,Div} gradients."""
  x_indices = op.inputs[0]
  x_shape = op.inputs[2]
  y = op.inputs[3]

  y_shape = math_ops.to_int64(array_ops.shape(y))
  num_added_dims = array_ops.expand_dims(
      array_ops.size(x_shape) - array_ops.size(y_shape), 0)
  augmented_y_shape = array_ops.concat_v2(
      [array_ops.ones(num_added_dims, ops.dtypes.int64), y_shape], 0)

  scaling = x_shape // augmented_y_shape
  scaled_indices = x_indices // scaling
  scaled_indices = array_ops.slice(
      scaled_indices, array_ops.concat_v2([[0], num_added_dims], 0), [-1, -1])
  dense_vals = array_ops.gather_nd(y, scaled_indices)

  if is_mul:
    dx = grad * dense_vals
    dy_val = grad * op.inputs[1]
  else:
    dx = grad / dense_vals
    dy_val = grad * (-op.inputs[1] / math_ops.square(dense_vals))
  # indices can repeat after scaling, so we can't use sparse_to_dense().
  dy = sparse_ops.sparse_add(
      array_ops.zeros_like(y),
      sparse_tensor.SparseTensor(scaled_indices, dy_val, y_shape))

  # (sp_indices, sp_vals, sp_shape, dense)
  return (None, dx, None, dy)

@ops.RegisterGradient("SparseDenseCwiseMul")
def _SparseDenseCwiseMulGrad(op, grad):
  """Gradients for SparseDenseCwiseMul."""
  return _SparseDenseCwiseMulOrDivGrad(op, grad, True)

@ops.RegisterGradient("SparseDenseCwiseDiv")
def _SparseDenseCwiseDivGrad(op, grad):
  """Gradients for SparseDenseCwiseDiv."""
  return _SparseDenseCwiseMulOrDivGrad(op, grad, False)

@ops.RegisterGradient("SparseSoftmax")
def _SparseSoftmaxGrad(op, grad):
  """Gradients for SparseSoftmax.

  The calculation is the same as SoftmaxGrad:

    grad_x = grad_softmax * softmax - sum(grad_softmax * softmax) * softmax

  where we now only operate on the non-zero values present in the SparseTensors.

  Args:
    op: the SparseSoftmax op.
    grad: the upstream gradient w.r.t. the non-zero SparseSoftmax output values.

  Returns:
    Gradients w.r.t. the input (sp_indices, sp_values, sp_shape).
  """
  indices, shape = op.inputs[0], op.inputs[2]
  out_vals = op.outputs[0]
  sp_output = sparse_tensor.SparseTensor(indices, out_vals, shape)
  sp_grad = sparse_tensor.SparseTensor(indices, grad, shape)
  sp_product = sparse_tensor.SparseTensor(
      indices, sp_output.values * sp_grad.values, shape)

  # [..., B, 1], dense.
  sum_reduced = -sparse_ops.sparse_reduce_sum(sp_product, [-1], keep_dims=True)
  # sparse [..., B, C] + dense [..., B, 1] with broadcast; outputs sparse.
  sp_sum = sparse_ops.sparse_dense_cwise_add(sp_grad, sum_reduced)

  grad_x = sp_sum.values * sp_output.values
  return [None, grad_x, None]

@ops.RegisterGradient("SparseSparseMaximum")
def _SparseSparseMaximumGrad(unused_op, unused_grad):
  raise NotImplementedError("Gradient for SparseSparseMaximum is currently not"
                            " implemented yet.")

@ops.RegisterGradient("SparseSparseMinimum")
def _SparseSparseMinimumGrad(unused_op, unused_grad):
  raise NotImplementedError("Gradient for SparseSparseMinimum is currently not"
                            " implemented yet.")


text:
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { inject, bindable, bindingMode, customElement } from 'aurelia-framework';
import { getLogger } from 'aurelia-logging';
import { MDCTemporaryDrawer } from '@material/drawer';
import * as util from '../util';
var MdcDrawerTemporary = (function () {
    function MdcDrawerTemporary(element) {
        this.element = element;
        this.open = false;
        this.log = getLogger('mdc-drawer-temporary');
    }
    MdcDrawerTemporary.prototype.bind = function () { };
    MdcDrawerTemporary.prototype.unbind = function () { };
    MdcDrawerTemporary.prototype.attached = function () {
        if (!MDCTemporaryDrawer.prototype.getDefaultFoundation_) {
            MDCTemporaryDrawer.prototype.getDefaultFoundation_ = MDCTemporaryDrawer.prototype.getDefaultFoundation;
            MDCTemporaryDrawer.prototype.getDefaultFoundation = function () {
                var foundation = this.getDefaultFoundation_();
                foundation.drawerClickHandler_ = function (e) {
                    if (e.target.tagName !== 'A') {
                        e.stopPropagation();
                    }
                };
                return foundation;
            };
        }
        this.mdcDrawer = new MDCTemporaryDrawer(this.elementDrawer);
        this.elementDrawer.addEventListener('MDCTemporaryDrawer:open', this.onOpenEvent.bind(this));
        this.elementDrawer.addEventListener('MDCTemporaryDrawer:close', this.onCloseEvent.bind(this));
        this.openChanged(this.open);
    };
    MdcDrawerTemporary.prototype.detached = function () {
        this.elementDrawer.removeEventListener('MDCTemporaryDrawer:open', this.onOpenEvent.bind(this));
        this.elementDrawer.removeEventListener('MDCTemporaryDrawer:close', this.onCloseEvent.bind(this));
        this.mdcDrawer.destroy();
    };
    MdcDrawerTemporary.prototype.openChanged = function (newValue) {
        var value = util.getBoolean(newValue);
        this.mdcDrawer.open = value;
    };
    MdcDrawerTemporary.prototype.onOpenEvent = function () {
        util.fireEvent(this.elementDrawer, 'on-open', {});
    };
    MdcDrawerTemporary.prototype.onCloseEvent = function () {
        util.fireEvent(this.elementDrawer, 'on-close', {});
        this.open = false;
    };
    __decorate([
        bindable({ defaultBindingMode: bindingMode.twoWay }),
        __metadata("design:type", Object)
    ], MdcDrawerTemporary.prototype, "open", void 0);
    MdcDrawerTemporary = __decorate([
        customElement('mdc-drawer-temporary'),
        inject(Element),
        __metadata("design:paramtypes", [Element])
    ], MdcDrawerTemporary);
    return MdcDrawerTemporary;
}());
export { MdcDrawerTemporary };


text:
<<<<<<< HEAD
Bloc Base Project
=================

A base for Bloc frontend projects.

## Configuration

Configuring this project should be consistent across Nitrous, Mac (local), and Vagrant.

Start by cloning the repository

```
$ git clone https://github.com/Bloc/base-frontend-project.git <your-frontend-project-name>
```

The project uses Grunt to run tasks (detailed below); start by installing the Grunt Command Line Interface (`grunt-cli`) globally on your machine.

```
$ npm install -g grunt-cli
```

Once that's complete, install the remaining project dependencies by running

```
$ npm install
```

## Grunt

This project base uses [Grunt](http://gruntjs.com/) to serve, build and watch project files in development. We've configured Grunt to work for you, but if you're interested in learning more about how Grunt works, look at Grunt's [Getting Started Guide](http://gruntjs.com/getting-started) or watch [Egghead's introduction to Grunt video](https://egghead.io/lessons/gruntjs-introduction-to-grunt).

## Running the application

Run the application using

```
$ grunt
```

The application runs on port 3000 (configured in the [`Gruntfile.js`](https://github.com/joelip/base-frontend-project/blob/master/server.js)). To change the port, modify the number highlighted below

```js
connect: {
  server: {
    options: {
      // Change this value here to the desired port number
      port: 3000,
      hostname: 'localhost',
      base: './dist',
      useAvailablePort: true
    }
  }
}
```

## Directory structure and Grunt

```
app/
 |__pages/
 |   |__index.html
 |__sass/
 |   |__styles.scss
 |__scripts/
 |   |__app.js
 |__templates/
 |   |__home.html
```

Grunt looks for files using a defined pattern so that it knows what to compile and copy and where to put it. To edit the files that Grunt watches, look at the array of files in the `watch` task in `Gruntfile.js`. The default watched files are

```js
  files: [
      './app/scripts/**/*.js',
      './app/sass/**/*.scss',
      './app/pages/**/*.html',
      './app/templates/**/*.html',
      'Gruntfile.js'
  ]
```

Add any files or directories to Grunt's watch task using the [Grunt conventions for performing file operations](http://gruntjs.com/configuring-tasks#files).

### Sass

Make sure that all of your Sass files are included in the `sass` directory. When you create new Sass files in addition to `styles.scss`, make sure that you include them in `styles.scss` with an `@import` statement. For example, if you create a `home.scss` file to match our `home.html` template, include it in `styles.scss` with

```sass
@import "home";
```

and it will be automatically populated in the compiled CSS file when you save any Sass file.

### Difference between Pages and Templates

The `pages` directory is where you should keep application layouts. That is, these are full pages where you'll put a base HTML structure that might hold a `ui-view` or another dynamic block of HTML based on differing routes, app states, etc.

Templates are partials, or smaller sets of HTML that will be populated into the pages. The distinction is similar to the differene between `index.html` and the HTML files in the `templates` directory in Bloc Jams.

## Grunt plugins

A list of the plugins used by Grunt and what they're used for.

#### Browserify

[Browserify](http://browserify.org/) allows you to access Node modules included a given JS file while in the browser.

#### Sass

[Grunt Sass](https://github.com/gruntjs/grunt-contrib-sass) for compiling Sass into CSS.

#### Autoprefixer

[Autoprefixer](https://github.com/nDmitry/grunt-autoprefixer) allows you to write CSS free of worrying about vendor prefixes. No need to add `-webkit`, `-moz`, `-ms`, etc to the beginning of your CSS3, because the Grunt Autoprefixer task takes care of it for you.

#### Watch

[Grunt watch](https://github.com/gruntjs/grunt-contrib-watch) watches an array of files for changes and then executes Grunt tasks when a change is detected. Watch is useful for tasks like continuous unit testing (every time you save a file, that new file is tested), refreshing your browser automatically when changes are reflected, or compiling preprocessing languages like Sass or Jade into CSS or HTML.

#### Copy

[Grunt copy](https://github.com/gruntjs/grunt-contrib-copy) allows you to copy files from development folders like images, fonts or other static assets and put them in the folder that will be served on the frontend of your application.

#### Clean

[Grunt clean](https://github.com/gruntjs/grunt-contrib-clean) "cleans" or removes all files in your destination folder (the folder where you'll put your officially served content for your application) so that logic in your stylesheets, templates or scripts isn't accidentally overridden by previous code in the directory.

#### Hapi

[Grunt Hapi](https://github.com/athieriot/grunt-hapi) is a task that runs a server using [`HapiJS`](http://hapijs.com/). Happy is a Node Web Application framework with robust configuration options. Using Hapi allows us to use Angular for our application routing instead of relying on a backend to handle template requests.


text:
function varargout = exitQuestion(varargin)
% EXITQUESTION MATLAB code for exitQuestion.fig
%      EXITQUESTION by itself, creates a new EXITQUESTION or raises the
%      existing singleton*.
%
%      H = EXITQUESTION returns the handle to a new EXITQUESTION or the handle to
%      the existing singleton*.
%
%      EXITQUESTION('CALLBACK',hObject,eventData,handles,...) calls the local
%      function named CALLBACK in EXITQUESTION.M with the given input arguments.
%
%      EXITQUESTION('Property','Value',...) creates a new EXITQUESTION or raises the
%      existing singleton*.  Starting from the left, property value pairs are
%      applied to the GUI before exitQuestion_OpeningFcn gets called.  An
%      unrecognized property name or invalid value makes property application
%      stop.  All inputs are passed to exitQuestion_OpeningFcn via varargin.
%
%      *See GUI Options on GUIDE's Tools menu.  Choose "GUI allows only one
%      instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES

% Edit the above text to modify the response to help exitQuestion

% Last Modified by GUIDE v2.5 24-May-2013 03:01:18

% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
                   'gui_Singleton',  gui_Singleton, ...
                   'gui_OpeningFcn', @exitQuestion_OpeningFcn, ...
                   'gui_OutputFcn',  @exitQuestion_OutputFcn, ...
                   'gui_LayoutFcn',  [] , ...
                   'gui_Callback',   []);
if nargin && ischar(varargin{1})
    gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
    gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT

% --- Executes just before exitQuestion is made visible.
function exitQuestion_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)
% varargin   command line arguments to exitQuestion (see VARARGIN)

% Choose default command line output for exitQuestion
handles.output = 'No';
imshow ('Settings/question.jpg');
% Update handles structure
guidata(hObject, handles);
set (hObject, 'Name', 'Выход?');
% Insert custom Title and Text if specified by the user
% Hint: when choosing keywords, be sure they are not easily confused
% with existing figure properties.  See the output of set(figure) for
% a list of figure properties.
if(nargin > 3)
    for index = 1:2:(nargin-3),
        if nargin-3==index, break, end
        switch lower(varargin{index})
         case 'title'
          set(hObject, 'Name', varargin{index+1});
         case 'string'
          set(handles.text1, 'String', varargin{index+1});
        end
    end
end

% Determine the position of the dialog - centered on the callback figure
% if available, else, centered on the screen
FigPos=get(0,'DefaultFigurePosition');
OldUnits = get(hObject, 'Units');
set(hObject, 'Units', 'pixels');
OldPos = get(hObject,'Position');
FigWidth = OldPos(3);
FigHeight = OldPos(4);
if isempty(gcbf)
    ScreenUnits=get(0,'Units');
    set(0,'Units','pixels');
    ScreenSize=get(0,'ScreenSize');
    set(0,'Units',ScreenUnits);

    FigPos(1)=1/2*(ScreenSize(3)-FigWidth);
    FigPos(2)=2/3*(ScreenSize(4)-FigHeight);
else
    GCBFOldUnits = get(gcbf,'Units');
    set(gcbf,'Units','pixels');
    GCBFPos = get(gcbf,'Position');
    set(gcbf,'Units',GCBFOldUnits);
    FigPos(1:2) = [(GCBFPos(1) + GCBFPos(3) / 2) - FigWidth / 2, ...
                   (GCBFPos(2) + GCBFPos(4) / 2) - FigHeight / 2];
end
FigPos(3:4)=[FigWidth FigHeight];
set(hObject, 'Position', FigPos);
set(hObject, 'Units', OldUnits);

set(handles.axes1, ...
    'Visible', 'off', ...
    'YDir'   , 'reverse');

% Make the GUI modal
set(handles.figure1,'WindowStyle','modal')

% UIWAIT makes exitQuestion wait for user response (see UIRESUME)
uiwait(handles.figure1);

% --- Outputs from this function are returned to the command line.
function varargout = exitQuestion_OutputFcn(hObject, eventdata, handles)
% varargout  cell array for returning output args (see VARARGOUT);
% hObject    handle to figure
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Get default command line output from handles structure
varargout{1} = handles.output;

% The figure can be deleted now
delete(handles.figure1);

% --- Executes on button press in onExit.
function onExit_Callback(hObject, eventdata, handles)
% hObject    handle to onExit (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

handles.output = get(hObject,'String');

% Update handles structure
guidata(hObject, handles);

% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);

% --- Executes on button press in pushbutton2.
function pushbutton2_Callback(hObject, eventdata, handles)
% hObject    handle to pushbutton2 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

handles.output = get(hObject,'String');

% Update handles structure
guidata(hObject, handles);

% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);

% --- Executes when user attempts to close figure1.
function figure1_CloseRequestFcn(hObject, eventdata, handles)
% hObject    handle to figure1 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

if isequal(get(hObject, 'waitstatus'), 'waiting')
    % The GUI is still in UIWAIT, us UIRESUME
    uiresume(hObject);
else
    % The GUI is no longer waiting, just close it
    delete(hObject);
end

% --- Executes on key press over figure1 with no controls selected.
function figure1_KeyPressFcn(hObject, eventdata, handles)
% hObject    handle to figure1 (see GCBO)
% eventdata  reserved - to be defined in a future version of MATLAB
% handles    structure with handles and user data (see GUIDATA)

% Check for "enter" or "escape"
if isequal(get(hObject,'CurrentKey'),'escape')
    % User said no by hitting escape
    handles.output = 'No';

    % Update handles structure
    guidata(hObject, handles);

    uiresume(handles.figure1);
end

if isequal(get(hObject,'CurrentKey'),'return')
    handles.output = 'Yes';
    uiresume(handles.figure1);
end


text:
package be.jabapage.stocklist.module;

import be.jabapage.stocklist.api.IGenericCRUDService;
import be.jabapage.stocklist.api.IItemService;
import be.jabapage.stocklist.api.IRestService;
import be.jabapage.stocklist.api.IStockEntryService;
import be.jabapage.stocklist.api.IUserService;
import be.jabapage.stocklist.api.translator.IKeyTranslator;
import be.jabapage.stocklist.api.translator.IListTranslator;
import be.jabapage.stocklist.api.translator.ITranslator;
import be.jabapage.stocklist.database.model.Item;
import be.jabapage.stocklist.database.model.StockEntry;
import be.jabapage.stocklist.database.model.User;
import be.jabapage.stocklist.gui.ItemColumnGenerator;
import be.jabapage.stocklist.gui.StockEntryFieldFactory;
import be.jabapage.stocklist.impl.GenericCRUDService;
import be.jabapage.stocklist.impl.ItemService;
import be.jabapage.stocklist.impl.RestService;
import be.jabapage.stocklist.impl.StockEntryService;
import be.jabapage.stocklist.impl.UserService;
import be.jabapage.stocklist.impl.translator.ItemTranslator;
import be.jabapage.stocklist.impl.translator.KeyTranslator;
import be.jabapage.stocklist.impl.translator.ListTranslator;
import be.jabapage.stocklist.impl.translator.StockEntryTranslator;
import be.jabapage.stocklist.impl.translator.UserTranslator;

import com.google.inject.AbstractModule;
import com.google.inject.TypeLiteral;
import com.google.inject.multibindings.MapBinder;
import com.google.inject.name.Names;
import com.sun.jersey.api.core.PackagesResourceConfig;
import com.sun.jersey.api.core.ResourceConfig;
import com.vaadin.ui.FormFieldFactory;
import com.vaadin.ui.Table.ColumnGenerator;

public class StockListModule extends AbstractModule {

	@Override
	protected void configure() {
		bindGeneralCrudServices();
		bindTranslators();
		bindServices();
		bindRestServices();
		bind(FormFieldFactory.class).to(StockEntryFieldFactory.class);
		MapBinder<String, ColumnGenerator> stockEntryMapBinder = MapBinder.newMapBinder(binder(), String.class, ColumnGenerator.class);
		stockEntryMapBinder.addBinding("item description").to(ItemColumnGenerator.class);

		ResourceConfig rc = new PackagesResourceConfig("be.jabapage.stocklist.rest");
		for (Class<?> resource : rc.getClasses()) {
			bind(resource);
		}
	}

	private void bindServices() {
		bind(IStockEntryService.class).to(StockEntryService.class);
		bind(IItemService.class).to(ItemService.class);
		bind(IUserService.class).to(UserService.class);
		bind(new TypeLiteral<IGenericCRUDService<StockEntry>>() {}).to(StockEntryService.class);
		bind(new TypeLiteral<IGenericCRUDService<Item>>() {}).to(ItemService.class);
		bind(new TypeLiteral<IGenericCRUDService<User>>() {}).to(UserService.class);
	}

	private void bindRestServices() {
		bind(new TypeLiteral<IRestService<be.jabapage.stocklist.rest.model.User>>() {}).to(new TypeLiteral<RestService<be.jabapage.stocklist.rest.model.User, User>>() {});
		bind(new TypeLiteral<IRestService<be.jabapage.stocklist.rest.model.Item>>() {}).to(new TypeLiteral<RestService<be.jabapage.stocklist.rest.model.Item, Item>>() {});
		bind(new TypeLiteral<IRestService<be.jabapage.stocklist.rest.model.StockEntry>>() {}).to(new TypeLiteral<RestService<be.jabapage.stocklist.rest.model.StockEntry, StockEntry>>() {});
	}

	private void bindGeneralCrudServices() {
		bind(new TypeLiteral<IGenericCRUDService<StockEntry>>() {}).annotatedWith(Names.named("crud")).toInstance(new GenericCRUDService<StockEntry>(StockEntry.class, new KeyTranslator()));
		bind(new TypeLiteral<IGenericCRUDService<Item>>() {}).annotatedWith(Names.named("crud")).toInstance(new GenericCRUDService<Item>(Item.class, new KeyTranslator()));
		bind(new TypeLiteral<IGenericCRUDService<User>>() {}).annotatedWith(Names.named("crud")).toInstance(new GenericCRUDService<User>(User.class, new KeyTranslator()));
	}

	private void bindTranslators() {
		bind(IKeyTranslator.class).to(KeyTranslator.class);
		bind(new TypeLiteral<ITranslator<be.jabapage.stocklist.rest.model.User, User>>() {}).to(UserTranslator.class);
		bind(new TypeLiteral<IListTranslator<be.jabapage.stocklist.rest.model.User, User>> () {}).to(new TypeLiteral<ListTranslator<be.jabapage.stocklist.rest.model.User, User>> () {});
		bind(new TypeLiteral<ITranslator<be.jabapage.stocklist.rest.model.Item, Item>>() {}).to(ItemTranslator.class);
		bind(new TypeLiteral<IListTranslator<be.jabapage.stocklist.rest.model.Item, Item>> () {}).to(new TypeLiteral<ListTranslator<be.jabapage.stocklist.rest.model.Item, Item>> () {});
		bind(new TypeLiteral<ITranslator<be.jabapage.stocklist.rest.model.StockEntry, StockEntry>>() {}).to(StockEntryTranslator.class);
		bind(new TypeLiteral<IListTranslator<be.jabapage.stocklist.rest.model.StockEntry, StockEntry>> () {}).to(new TypeLiteral<ListTranslator<be.jabapage.stocklist.rest.model.StockEntry, StockEntry>> () {});
	}

}


text:
- Accept regex or prefix

- Get the jargon and concepts right

- Make into separate package

- Use ngInjector

- Make it easy to completely disable

- Provider tests

    * Enabled or disabled

    * Y


text:
'use strict';

var stampit = require('stampit');

var repeaterBase = require('./repeater_base');
var log = require('./log');

var repeaterNull = stampit().state({
    name: 'Null repeater'
});

module.exports = stampit.compose(repeaterBase, repeaterNull);


text:
<?xml version="1.0" encoding="utf-8"?>
<!-- *************************GO-LICENSE-START******************************
 * Copyright 2014 ThoughtWorks, Inc.
 *
 * 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.
 *************************GO-LICENSE-END******************************* -->

<cruise xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="cruise-config.xsd" schemaVersion="3">
  <server artifactsdir="logs">
  </server>
  <pipelines>
    <pipeline name="pipeline">
      <materials>
        <p4 port="perforce:9999">
          <view>

          </view>
        </p4>
      </materials>
      <stage name="Stage">
        <jobs>
          <job name="Job">
          </job>
        </jobs>
      </stage>
    </pipeline>
  </pipelines>
</cruise>


text:
#include "pybind11_tests.h"
#include <pybind11/chrono.h>
#include <chrono>

struct different_resolutions {
    using time_point_h = std::chrono::time_point<
        std::chrono::system_clock, std::chrono::hours>;
    using time_point_m = std::chrono::time_point<
        std::chrono::system_clock, std::chrono::minutes>;
    using time_point_s = std::chrono::time_point<
        std::chrono::system_clock, std::chrono::seconds>;
    using time_point_ms = std::chrono::time_point<
        std::chrono::system_clock, std::chrono::milliseconds>;
    using time_point_us = std::chrono::time_point<
        std::chrono::system_clock, std::chrono::microseconds>;
    time_point_h timestamp_h;
    time_point_m timestamp_m;
    time_point_s timestamp_s;
    time_point_ms timestamp_ms;
    time_point_us timestamp_us;
};

TEST_SUBMODULE(chrono, m) {
    using system_time = std::chrono::system_clock::time_point;
    using steady_time = std::chrono::steady_clock::time_point;

    using timespan = std::chrono::duration<int64_t, std::nano>;
    using timestamp = std::chrono::time_point<std::chrono::system_clock, timespan>;

    // test_chrono_system_clock
    // Return the current time off the wall clock
    m.def("test_chrono1", []() { return std::chrono::system_clock::now(); });

    // test_chrono_system_clock_roundtrip
    // Round trip the passed in system clock time
    m.def("test_chrono2", [](system_time t) { return t; });

    // test_chrono_duration_roundtrip
    // Round trip the passed in duration
    m.def("test_chrono3", [](std::chrono::system_clock::duration d) { return d; });

    // test_chrono_duration_subtraction_equivalence
    // Difference between two passed in time_points
    m.def("test_chrono4", [](system_time a, system_time b) { return a - b; });

    // test_chrono_steady_clock
    // Return the current time off the steady_clock
    m.def("test_chrono5", []() { return std::chrono::steady_clock::now(); });

    // test_chrono_steady_clock_roundtrip
    // Round trip a steady clock timepoint
    m.def("test_chrono6", [](steady_time t) { return t; });

    // test_floating_point_duration
    // Roundtrip a duration in microseconds from a float argument
    m.def("test_chrono7", [](std::chrono::microseconds t) { return t; });
    // Float durations (issue #719)
    m.def("test_chrono_float_diff", [](std::chrono::duration<float> a, std::chrono::duration<float> b) {
        return a - b; });

    m.def("test_nano_timepoint", [](timestamp start, timespan delta) -> timestamp {
        return start + delta;
    });

    // Test different resolutions
    py::class_<different_resolutions>(m, "different_resolutions")
        .def(py::init<>())
        .def_readwrite("timestamp_h", &different_resolutions::timestamp_h)
        .def_readwrite("timestamp_m", &different_resolutions::timestamp_m)
        .def_readwrite("timestamp_s", &different_resolutions::timestamp_s)
        .def_readwrite("timestamp_ms", &different_resolutions::timestamp_ms)
        .def_readwrite("timestamp_us", &different_resolutions::timestamp_us)
        ;
}


text:
import * as t from "../../../types";

export function shouldVisit(node) {
  return t.isImportDeclaration(node) || t.isExportDeclaration(node);
}

export function ImportDeclaration(node, parent, scope, file) {
  if (node.source) {
    node.source.value = file.resolveModuleSource(node.source.value);
  }
}

export { ImportDeclaration as ExportAllDeclaration };

export function ExportDefaultDeclaration(node, parent, scope) {
  ImportDeclaration.apply(this, arguments);

  var declar = node.declaration;

  var getDeclar = function () {
    declar._ignoreUserWhitespace = true;
    return declar;
  };

  if (t.isClassDeclaration(declar)) {
    // export default class Foo {};
    node.declaration = declar.id;
    return [getDeclar(), node];
  } else if (t.isClassExpression(declar)) {
    // export default class {};
    var temp = scope.generateUidIdentifier("default");
    declar = t.variableDeclaration("var", [
      t.variableDeclarator(temp, declar)
    ]);
    node.declaration = temp;
    return [getDeclar(), node];
  } else if (t.isFunctionDeclaration(declar)) {
    // export default function Foo() {}
    node._blockHoist = 2;
    node.declaration = declar.id;
    return [getDeclar(), node];
  }
}

export function ExportNamedDeclaration(node, parent, scope) {
  ImportDeclaration.apply(this, arguments);

  var declar = node.declaration;

  var getDeclar = function () {
    declar._ignoreUserWhitespace = true;
    return declar;
  };

  if (t.isClassDeclaration(declar)) {
    // export class Foo {}
    node.specifiers  = [t.exportSpecifier(declar.id, declar.id)];
    node.declaration = null;
    return [getDeclar(), node];
  } else if (t.isFunctionDeclaration(declar)) {
    // export function Foo() {}
    node.specifiers  = [t.exportSpecifier(declar.id, declar.id)];
    node.declaration = null;
    node._blockHoist = 2;
    return [getDeclar(), node];
  } else if (t.isVariableDeclaration(declar)) {
    // export var foo = "bar";
    var specifiers = [];
    var bindings = this.get("declaration").getBindingIdentifiers();
    for (var key in bindings) {
      var id = bindings[key];
      specifiers.push(t.exportSpecifier(id, id));
    }
    return [declar, t.exportNamedDeclaration(null, specifiers)];
  }
}

export function Program(node) {
  var imports = [];
  var rest = [];

  for (var i = 0; i < node.body.length; i++) {
    var bodyNode = node.body[i];
    if (t.isImportDeclaration(bodyNode)) {
      imports.push(bodyNode);
    } else {
      rest.push(bodyNode);
    }
  }

  node.body = imports.concat(rest);
}


text:
<template name="home">
	HOME
</template>


text:
. ./autoscaling_vars.sh

# get instance configuration
resId=$(curl -s http://169.254.169.254/latest/meta-data/reservation-id); echo Reservation: $resId
instId=$(curl -s http://169.254.169.254/latest/meta-data/instance-id); echo InstanceId: $instId
privateIp=$(curl -s http://169.254.169.254/latest/meta-data/local-ipv4); echo PrivateIP: $privateIp
publicIp=$(curl -s http://169.254.169.254/latest/meta-data/public-ipv4); echo PublicIP: $publicIp
macs=$(curl -s http://169.254.169.254/latest/meta-data/network/interfaces/macs/)
subnetCIDR=$(curl -s http://169.254.169.254/latest/meta-data/network/interfaces/macs/$macs/subnet-ipv4-cidr-block/); echo Subnet CIDR: $subnetCIDR

# create database
admintools -t create_db -s $privateIp -d $database_name -p $password

# configure database for autoscaling
./database_configure.sh

# Add first log entry for bootstrap node
time=$( date +"%Y-%m-%d %H:%M:%S")
echo "$privateIp|$time|$time|0|$resId|$instId|$privateIp||$publicIp|SUCCESS|0|Initial Bootstrap node" | vsql -c "COPY autoscale.launches FROM STDIN"


text:
// Template Source: BaseEntity.java.tt
// ------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
// ------------------------------------------------------------------------------

package com.microsoft.graph.models;
import com.microsoft.graph.serializer.ISerializer;
import com.microsoft.graph.serializer.IJsonBackedObject;
import com.microsoft.graph.serializer.AdditionalDataManager;
import java.util.EnumSet;

import com.google.gson.JsonObject;
import com.google.gson.annotations.SerializedName;
import com.google.gson.annotations.Expose;
import javax.annotation.Nullable;
import javax.annotation.Nonnull;

// **NOTE** This file was generated by a tool and any changes will be overwritten.

/**
 * The class for the Configuration Manager Client Enabled Features.
 */
public class ConfigurationManagerClientEnabledFeatures implements IJsonBackedObject {

    /** the OData type of the object as returned by the service */
    @SerializedName("@odata.type")
    @Expose
    @Nullable
    public String oDataType;

    private transient AdditionalDataManager additionalDataManager = new AdditionalDataManager(this);

    @Override
    @Nonnull
    public final AdditionalDataManager additionalDataManager() {
        return additionalDataManager;
    }

    /**
     * The Compliance Policy.
     * Whether compliance policy is managed by Intune
     */
    @SerializedName(value = "compliancePolicy", alternate = {"CompliancePolicy"})
    @Expose
	@Nullable
    public Boolean compliancePolicy;

    /**
     * The Device Configuration.
     * Whether device configuration is managed by Intune
     */
    @SerializedName(value = "deviceConfiguration", alternate = {"DeviceConfiguration"})
    @Expose
	@Nullable
    public Boolean deviceConfiguration;

    /**
     * The Inventory.
     * Whether inventory is managed by Intune
     */
    @SerializedName(value = "inventory", alternate = {"Inventory"})
    @Expose
	@Nullable
    public Boolean inventory;

    /**
     * The Modern Apps.
     * Whether modern application is managed by Intune
     */
    @SerializedName(value = "modernApps", alternate = {"ModernApps"})
    @Expose
	@Nullable
    public Boolean modernApps;

    /**
     * The Resource Access.
     * Whether resource access is managed by Intune
     */
    @SerializedName(value = "resourceAccess", alternate = {"ResourceAccess"})
    @Expose
	@Nullable
    public Boolean resourceAccess;

    /**
     * The Windows Update For Business.
     * Whether Windows Update for Business is managed by Intune
     */
    @SerializedName(value = "windowsUpdateForBusiness", alternate = {"WindowsUpdateForBusiness"})
    @Expose
	@Nullable
    public Boolean windowsUpdateForBusiness;

    /**
     * Sets the raw JSON object
     *
     * @param serializer the serializer
     * @param json the JSON object to set this object to
     */
    public void setRawObject(@Nonnull final ISerializer serializer, @Nonnull final JsonObject json) {

    }
}


text:
/*******************************************************************************
 The block below describes the properties of this module, and is read by
 the Projucer to automatically generate project code that uses it.
 For details about the syntax and how to create or use a module, see the
 JUCE Module Format.txt file.

 BEGIN_JUCE_MODULE_DECLARATION

  ID:               juce_audio_plugin_client
  vendor:           juce
  version:          4.2.4
  name:             JUCE audio plugin wrapper classes
  description:      Classes for building VST, VST3, AudioUnit, AAX and RTAS plugins.
  website:          http://www.juce.com/juce
  license:          GPL/Commercial

  dependencies:     juce_gui_basics, juce_audio_basics, juce_audio_processors

 END_JUCE_MODULE_DECLARATION

*******************************************************************************/

#ifndef JUCE_AUDIO_PLUGIN_CLIENT_H_INCLUDED
#define JUCE_AUDIO_PLUGIN_CLIENT_H_INCLUDED

#include <juce_gui_basics/juce_gui_basics.h>
#include <juce_audio_basics/juce_audio_basics.h>
#include <juce_audio_processors/juce_audio_processors.h>

/** Config: JUCE_FORCE_USE_LEGACY_PARAM_IDS

    Enable this if you want to force JUCE to use a continuous parameter
    index to identify a parameter in a DAW (this was the default in old
    versions of JUCE). This is index is usually used by the DAW to save
    automation data and enabling this may mess up user's DAW projects.
*/
#ifndef JUCE_FORCE_USE_LEGACY_PARAM_IDS
 #define JUCE_FORCE_USE_LEGACY_PARAM_IDS 0
#endif

namespace juce
{
 #include "utility/juce_PluginHostType.h"
}

#endif   // JUCE_AUDIO_PLUGIN_CLIENT_H_INCLUDED


text:
import TypeDescriptor from './TypeDescriptor';
import {IDbRef} from '../../IDatabase';
import JelString from '../../types/JelString';
import Runtime from '../../Runtime';
import Context from '../../Context';
import TypeChecker from '../TypeChecker';
import JelObject from '../../JelObject';
import SerializablePrimitive from '../../SerializablePrimitive';
import JelBoolean from '../JelBoolean';
import BaseTypeRegistry from '../../BaseTypeRegistry';
import Class from '../Class';

/**
 * Declares a property that is a String. By default, empty strings are not allowed.
 */
export default class StringType extends TypeDescriptor implements SerializablePrimitive {
  static clazz: Class|undefined;

  static readonly instance = new StringType(false);
  static readonly allowEmpty = new StringType(true);

  constructor(public allowEmpty = false) {
    super('StringType');
  }

  get clazz(): Class {
    return StringType.clazz!;
  }

  // note: constants and types are not checked yet. That would become async.
  checkType(ctx: Context, value: JelObject|null): JelBoolean {
    return JelBoolean.valueOf((value instanceof JelString) && (this.allowEmpty || !!value.length));
  }

  serializeType(): string {
    if (this.allowEmpty)
      return 'StringType.allowEmpty';
    else
      return 'string';
  }

  serializeToString() : string {
		return this.serializeType();
	}

  equals(ctx: Context, other: TypeDescriptor|null): JelBoolean {
    return JelBoolean.valueOf(other instanceof StringType && this.allowEmpty == other.allowEmpty);
  }

  static create_jel_mapping = true;
  static create(ctx: Context, ...args: any[]): any {
    if (TypeChecker.optionalRealBoolean(args[0], 'allowEmpty'))
      return StringType.allowEmpty;
    else
      return StringType.instance;
  }
}

BaseTypeRegistry.register('StringType', StringType);


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

// Pour en savoir plus sur le modèle d'élément Contrôle utilisateur, consultez la page http://go.microsoft.com/fwlink/?LinkId=234236

namespace Gitter.UserControls
{
    public sealed partial class ChatMessageControl : UserControl
    {
        public ChatMessageControl()
        {
            this.InitializeComponent();
        }
    }
}


text:
/*
 * Decompiled with CFR 0_119.
 */
package wcData;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.util.Set;
import script.InternalScriptError;
import script.dataObjects.ArrayObject;
import script.dataObjects.DataObject;
import script.dataObjects.FloatObject;
import script.dataObjects.IntObject;
import script.names.VarSpace;
import wcData.BlizzardDataInputStream;
import wcData.BlizzardDataOutputStream;
import wcData.MapHandle;
import wcData.VarSpaceReader;
import wcData.VarSpaceWriter;

public class MapInfoIO {
    private String headerVersion;
    private int w3iVersion;
    private int headerUnknownInt;
    private String mapName;
    private int flags;
    private int maxPlayers;
    String tileSet;
    private String[] prologScreen = new String[4];
    private byte[] restOfW3I;
    private int lengthOfRestOfW3I;
    private MapHandle h;

    public MapInfoIO(MapHandle hh) {
        this.h = hh;
    }

    public void fromFiles(File header, File w3iIn) throws IOException, InternalScriptError {
        BlizzardDataInputStream head = new BlizzardDataInputStream(new FileInputStream(header));
        BlizzardDataInputStream w3i = new BlizzardDataInputStream(new FileInputStream(w3iIn));
        VarSpaceWriter out = new VarSpaceWriter(this.h, w3i, this.h.getMapSpace()).writeStruct("info", "InfoSection");
        VarSpaceWriter misc = out.writeStruct("misc", "MiscInfoSection");
        this.headerVersion = head.readCharsAsString(4);
        this.headerUnknownInt = head.readInt();
        this.mapName = head.readString();
        this.flags = head.readInt();
        this.maxPlayers = head.readInt();
        this.w3iVersion = w3i.readInt();
        out.writeInt("numSaves");
        out.writeInt("editorVersion");
        out.writeString("name");
        out.writeString("author");
        out.writeString("description");
        out.writeString("playersRecommended");
        out.writeArray("cameraBounds", 8, FloatObject.class);
        out.writeArray("cameraBoundComplements", 4, IntObject.class);
        out.writeInt("playableWidth");
        out.writeInt("playableHeight");
        VarSpaceWriter flags = out.writeStruct("flags", "StructMapFlags");
        flags.writeBitfield(4, new Object[]{"hideMinimapInPreviewScreens", "modifyAllyPriorities", "meleeMap", "playableMapSizeWasLargeAndHasNeverBeenReducedToMedium", "maskedAreasArePartiallyVisible", "fixedPlayerSettingsForCustomForces", "useCustomForces", "useCustomTechtree", "useCustomAbilities", "useCustomUpgrades", "mapPropertiesMenuOpenedAtLeastOnceSinceMapCreation", "showWaterWavesOnCliffShores", "showWaterWavesOnRollingShores", "unknown1", "unknown2", "unknown3"});
        this.tileSet = w3i.readCharsAsString(1);
        VarSpaceWriter cur = out.writeStruct("loadScreen", "LoadScreenSection");
        cur.writeInt("presetNum");
        cur.writeString("customPath");
        cur.writeString("text");
        cur.writeString("title");
        cur.writeString("subtitle");
        misc.writeInt("usedGameDataSet");
        int i = 0;
        while (i < 4) {
            this.prologScreen[i] = w3i.readString();
            ++i;
        }
        VarSpaceWriter sFX = out.writeStruct("effects", "EffectsInfoSection");
        sFX.writeInt("useTerrainFog");
        sFX.writeFloat("fogStartZ");
        sFX.writeFloat("fogEndZ");
        sFX.writeFloat("fogDensity");
        cur = sFX.writeStruct("fogColor", "Color");
        cur.writeByte("red", false);
        cur.writeByte("green", false);
        cur.writeByte("blue", false);
        cur.writeByte("alpha", false);
        sFX.writeInt("globalWeatherId");
        sFX.writeString("customSoundEnvironment");
        sFX.writeNCharsAsString("customLightEnvironment", 1);
        cur = sFX.writeStruct("waterTinting", "Color");
        cur.writeByte("red", false);
        cur.writeByte("green", false);
        cur.writeByte("blue", false);
        cur.writeByte("alpha", false);
        int numPlayers = w3i.readInt();
        cur = null;
        if (numPlayers > 0) {
            cur = out.writeArray("players");
        }
        int i2 = 0;
        while (i2 < numPlayers) {
            VarSpaceWriter player = cur.writeStruct(i2, "Info_player");
            player.writeInt("number");
            player.writeInt("typ");
            player.writeInt("race");
            player.writeBool("fixedStartPosition");
            player.writeString("name");
            player.writeFloat("startX");
            player.writeFloat("startY");
            VarSpaceWriter arry = player.writeArray("allyLowPriorityFlags");
            arry.writeBitfield(4, new Object[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
            arry = player.writeArray("allyHighPriorityFlags");
            arry.writeBitfield(4, new Object[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
            ++i2;
        }
        int numForces = w3i.readInt();
        cur = null;
        if (numForces > 0) {
            cur = out.writeArray("forces");
        }
        int i3 = 0;
        while (i3 < numForces) {
            VarSpaceWriter force = cur.writeStruct(i3, "Info_force");
            Object[] arrobject = new Object[6];
            arrobject[0] = "allied";
            arrobject[1] = "alliedVictory";
            arrobject[3] = "shareVision";
            arrobject[4] = "shareUnitControl";
            arrobject[5] = "shareAdvancedUnitControl";
            force.writeBitfield(4, arrobject);
            VarSpaceWriter arry = force.writeArray("playersInForce");
            arry.writeBitfield(4, new Object[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31});
            force.writeString("name");
            ++i3;
        }
        this.restOfW3I = new byte[4096];
        this.lengthOfRestOfW3I = w3i.read(this.restOfW3I);
        head.close();
        w3i.close();
    }

    public void toFiles(File header, File w3iFile) throws IOException, InternalScriptError {
        VarSpaceReader arry;
        RandomAccessFile f = new RandomAccessFile(header, "rw");
        BlizzardDataOutputStream w3i = new BlizzardDataOutputStream(w3iFile);
        VarSpaceReader out = new VarSpaceReader(this.h, w3i, this.h.getMapSpace()).writeStruct("info");
        VarSpaceReader misc = out.writeStruct("misc");
        w3i.writeInt(this.w3iVersion);
        out.writeInt("numSaves");
        out.writeInt("editorVersion");
        out.writeString("name");
        out.writeString("author");
        out.writeString("description");
        out.writeString("playersRecommended");
        out.writeArray("cameraBounds", FloatObject.class);
        out.writeArray("cameraBoundComplements", IntObject.class);
        out.writeInt("playableWidth");
        out.writeInt("playableHeight");
        VarSpaceReader flags = out.writeStruct("flags");
        int flagsBits = flags.writeBitfield(4, new Object[]{"hideMinimapInPreviewScreens", "modifyAllyPriorities", "meleeMap", "playableMapSizeWasLargeAndHasNeverBeenReducedToMedium", "maskedAreasArePartiallyVisible", "fixedPlayerSettingsForCustomForces", "useCustomForces", "useCustomTechtree", "useCustomAbilities", "useCustomUpgrades", "mapPropertiesMenuOpenedAtLeastOnceSinceMapCreation", "showWaterWavesOnCliffShores", "showWaterWavesOnRollingShores", "unknown1", "unknown2", "unknown3"});
        w3i.writeNByteString(this.tileSet, 1);
        VarSpaceReader cur = out.writeStruct("loadScreen");
        cur.writeInt("presetNum");
        cur.writeString("customPath");
        cur.writeString("text");
        cur.writeString("title");
        cur.writeString("subtitle");
        misc.writeInt("usedGameDataSet");
        int i = 0;
        while (i < 4) {
            w3i.writeString(this.prologScreen[i]);
            ++i;
        }
        VarSpaceReader sFX = out.writeStruct("effects");
        sFX.writeInt("useTerrainFog");
        sFX.writeFloat("fogStartZ");
        sFX.writeFloat("fogEndZ");
        sFX.writeFloat("fogDensity");
        cur = sFX.writeStruct("fogColor");
        cur.writeByte("red");
        cur.writeByte("green");
        cur.writeByte("blue");
        cur.writeByte("alpha");
        sFX.writeInt("globalWeatherId");
        sFX.writeString("customSoundEnvironment");
        sFX.writeNCharsAsString("customLightEnvironment", 1);
        cur = sFX.writeStruct("waterTinting");
        cur.writeByte("red");
        cur.writeByte("green");
        cur.writeByte("blue");
        cur.writeByte("alpha");
        cur = out.writeArray("players");
        w3i.writeInt(cur.getVarSpaceSize());
        for (Object i2 : cur.getVarSpaceKeys()) {
            VarSpaceReader player = cur.writeStruct(i2);
            player.writeInt("number");
            player.writeInt("typ");
            player.writeInt("race");
            player.writeBool("fixedStartPosition");
            player.writeString("name");
            player.writeFloat("startX");
            player.writeFloat("startY");
            arry = player.writeArray("allyLowPriorityFlags");
            arry.writeBitfield(4, new Object[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
            arry = player.writeArray("allyHighPriorityFlags");
            arry.writeBitfield(4, new Object[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
        }
        cur = out.writeArray("forces");
        w3i.writeInt(cur.getVarSpaceSize());
        for (Object i2 : cur.getVarSpaceKeys()) {
            VarSpaceReader force = cur.writeStruct(i2);
            Object[] arrobject = new Object[6];
            arrobject[0] = "allied";
            arrobject[1] = "alliedVictory";
            arrobject[3] = "shareVision";
            arrobject[4] = "shareUnitControl";
            arrobject[5] = "shareAdvancedUnitControl";
            force.writeBitfield(4, arrobject);
            arry = force.writeArray("playersInForce");
            arry.writeBitfield(4, new Object[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31});
            force.writeString("name");
        }
        w3i.write(this.restOfW3I, 0, this.lengthOfRestOfW3I);
        w3i.close();
        f.writeBytes(this.headerVersion);
        byte[] b = BlizzardDataOutputStream.convertIntToByteArray(this.headerUnknownInt);
        f.write(b);
        f.writeBytes(out.getVarSpace().get("name").toString());
        f.writeByte(0);
        b = BlizzardDataOutputStream.convertIntToByteArray(flagsBits);
        f.write(b);
        b = BlizzardDataOutputStream.convertIntToByteArray(this.maxPlayers);
        f.write(b);
        int toWrite = 512 - (int)f.getFilePointer();
        while (toWrite > 0) {
            --toWrite;
            f.writeByte(0);
        }
        f.close();
    }
}


text:
[![Build Status](https://travis-ci.org/rikcarve/consul-hystrix.svg?branch=master)](https://travis-ci.org/rikcarve/consul-hystrix)
[![codecov](https://codecov.io/gh/rikcarve/consul-hystrix/branch/master/graph/badge.svg)](https://codecov.io/gh/rikcarve/consul-hystrix)

## Overview
Show how to use consul for service discovery together with hystrix for resilience

## Usage
### Service Discovery
Inject ServiceUriProvider:
```java
    @Inject
    @DiscoverableService(serviceName = SERVICE_NAME)
    private ServiceUriProvider service;
```

Use createUri to resolve host:port:
```java
    service.createUri(PATH)
```

### Hystrix
use fallback for notifying ServicecUriProvider an error and make a second call with a new server:
```java
    @Override
    protected String getFallback() {
        service.notifyError();
        return client.target(service.createUri(PATH)).request().get(String.class);
    }
```


text:
#nullable enable
using Core2D.Modules.Renderer.Avalonia.Media;
using A = Avalonia;
using AP = Avalonia.Platform;

namespace Core2D.Modules.Renderer.Avalonia.Nodes.Markers;

internal class RectangleMarker : MarkerBase
{
    public A.Rect Rect { get; set; }

    public override void Draw(object? dc)
    {
        if (dc is not AP.IDrawingContextImpl context)
        {
            return;
        }

        if (ShapeViewModel is null)
        {
            return;
        }

        using var rotationDisposable = context.PushPreTransform(Rotation);

        if (ShapeViewModel.IsFilled)
        {
            context.DrawRectangle(Brush, null, Rect);
        }

        if (ShapeViewModel.IsStroked)
        {
            context.DrawRectangle(null, Pen, Rect);
        }
    }
}


text:
const path = require('path')
const merge = require('webpack-merge')
const common = require('../../webpack.umd.js')

module.exports = merge(common, {
  context: path.resolve(__dirname, './src'),
  output: {
    path: path.resolve(__dirname, './umd'),
    library: 'FelaDom',
  },

  externals: {
    fela: 'Fela',
  },
})


text:
<!DOCTYPE html>
<html>
<head>
    <title><%= pkg.name %>-<%= pkg.version %></title>
    <!--  (c) 2017 CA Technologies.  All Rights Reserved. -->
    <!--  Build Date: <%= new Date() %> -->

    <script type="text/javascript">
        var APP_BUILD_DATE = "<%= new Date() %>";
        var CHECKSUM = [%= checksum %];
    </script>

    <script type="text/javascript" src="/apps/<%= sdk %>/sdk.js"></script>
    <!-- our highcharts (needed so that we can add patterns)
    <script type="text/javascript" src="/apps/<%= sdk %>/lib/analytics/analytics-all.js"></script>
    -->

    <script type="text/javascript">
        Rally.onReady(function() {
            <%= ugly_contents %>

               Rally.launchApp('<%= className %>', {
                   name: '<%= pkg.name %>'
               });
        });
    </script>

    <style type="text/css">
<%= style_contents %>
    </style>

</head>
<body></body>
</html>


text:
NAMESPACE(SPlay)

bool			Platform::ms_bInitialized	= false;
bool			Platform::ms_bBound			= false;
Timer*			Platform::ms_pTimer			= NULL;
Window*			Platform::ms_pWindow		= NULL;
SPlayInstance*	Platform::ms_pInstance		= NULL;
tinystl::string Platform::ms_strStoragePath;

bool initializePlatform()
{
	return	Platform::initialize();
}

// Close platform
void closePlatform()
{
	Platform::close();
}

// Get storage path
const tinystl::string& getStoragePath()
{
	return	Platform::getStoragePath();
}

bool Platform::initialize()
{
	Log::instance()->logMessage("Set storage");

	setStoragePath();

	Log::instance()->logMessage("Create window");

	ms_pWindow	= Window::create();

	if (NULL == ms_pWindow)
	{
		return	false;
	}

	Log::instance()->logMessage("Create display");

	if (ms_pInstance != NULL)
	{
		ms_pInstance->callOnMainThread(PP_MakeCompletionCallback(&Platform::createDisplayCallback, 0), 0);
	}

	if (NULL == System::ms_pDisplay)
	{
		return	false;
	}

	Log::instance()->logMessage("Create timer");

	ms_pTimer	= Timer::create();

	if (NULL == ms_pTimer)
	{
		return	false;
	}

	Log::instance()->logMessage("Create input");

	System::ms_pInput	= Input::create();

	if (NULL == System::ms_pInput)
	{
		return	false;
	}

#if 0
	Log::instance()->logMessage("Initialize sound");

	if (false == initializeSound())
	{
		return	false;
	}
#endif

	ms_bInitialized	= true;

	return	true;
}

void Platform::close()
{
	// Delete window
	delete	ms_pWindow;

	ms_pWindow	= NULL;

	// Delete timer
	delete	ms_pTimer;

	ms_pTimer	= NULL;

	// Delete display
	delete	System::ms_pDisplay;

	System::ms_pDisplay	= NULL;

	// Close sound system
	closeSound();

	// Delete input
	delete	System::ms_pInput;

	System::ms_pInput	= NULL;
}

void Platform::createDisplayCallback(void* _pData, int32_t _iValue)
{
	System::ms_pDisplay	= createDisplay();
}

void Platform::runLoop()
{
	Log::instance()->logMessage("Running");

	while (true)
	{
		PSEvent*	pEvent	= PSEventTryAcquire();

		while (pEvent != NULL)
		{
			PSEventRelease(pEvent);

			pEvent	= PSEventTryAcquire();
		}

		if (true == ms_bBound)
		{
			if (false == ms_bInitialized)
			{
				SPlay::System::initialize();
			}

			else
			{
				// Get the elapsed time
				float	fElapsed	= ms_pTimer->getElapsedFloat();

				System::getInput()->update();

#if 0
				if (false == System::getGame()->update(fElapsed))
				{
					break;
				}

				redraw();
#endif
			}
		}
	}
}

void Platform::redraw()
{
	System::getDisplay()->render();
}

const tinystl::string& Platform::getStoragePath()
{
	return	ms_strStoragePath;
}

void Platform::setStoragePath()
{
	ms_strStoragePath	= "./";
}

ENDNAMESPACE


text:
<?php
require_once(APPPATH.'controllers/admin/Base_Controller.php');

class Subtypes extends Base_Controller {

    private $limit = 12;
    private $images = array();
    private $model = 'types_model';
    public function __construct()
    {
        parent::__construct();
        $this->load->helper('language');
        $this->load->helper('views');
        check_language();
        $this->lang->load('subtypes', session_site_lang());
    }

    public function index()
    {
        $this->load->model('subtypes_model');
        $search_subtype = $this->input->get('search', TRUE);
        $subtypes = $this->subtypes_model->all($this->limit, $search_subtype);
        $total_rows = $this->subtypes_model->count($search_subtype);
        $this->load->helper('pagination');
        $page_links = pagination($total_rows, $this->limit, base_url('admin/subtypes'));
        load_main_views('subtypes/index', array('subtypes' => $subtypes, 'page_links' => $page_links));
    }

    public function add()
    {
        $this->load->model('categories_model');
        $categories = $this->categories_model->get_all_categories();
        $types = array();
        if (!empty($categories))
        {
            $this->load->model('types_model');
            $types = $this->types_model->belong_to_category(0, $categories[0]->id);
        }
        load_main_views('subtypes/subtype', compact('categories', 'types'));
    }

    public function edit($id)
    {
        $this->load->model('subtypes_model');
        $subtype = $this->subtypes_model->find($id);
        $categories = array();
        $types = array();
        if (!is_null($subtype))
        {
            $this->load->model(array('categories_model', 'types_model'));
            $categories = $this->categories_model->get_all_categories();
            $types = $this->types_model->belong_to_category(0, $subtype->category_id);
        }
        load_main_views('subtypes/subtype', compact('subtype', 'categories', 'types'));
    }

    public function form_validation_rules()
    {
        $this->config->set_item('language', session_site_lang());
        $this->load->helper('security');
        $this->load->library('form_validation');
        $this->form_validation->set_rules('producing_year', 'lang:producing_year', 'trim|required|numeric|xss_clean');
        $this->form_validation->set_rules('type', 'lang:type', 'trim|required|numeric|xss_clean');
        $this->form_validation->set_rules('factory', 'lang:factory', 'trim|required|xss_clean');
    }

    public function store()
    {
        if ($this->input->is_ajax_request())
        {
            $this->form_validation_rules();
            if ($this->form_validation->run() == FALSE)
            {
                $data['status'] = FALSE;
                $data['messages'] = validation_errors();
            }
            else
            {
                if ($this->update_subtype_label())
                {
                    $data['status'] = TRUE;
                    $data['messages'] = $this->lang->line('create_success');
                }
                else
                {
                    $data['status'] = FALSE;
                    $data['messages'] = $this->lang->line('create_failure');
                }
            }
            echo json_encode($data);
        }
    }

    public function update($id)
    {
        if ($this->input->is_ajax_request())
        {
            $this->form_validation_rules();
            if ($this->form_validation->run() == FALSE)
            {
                $data['status'] = FALSE;
                $data['messages'] = validation_errors();
            }
            else
            {
                if ($this->update_subtype_label($id))
                {
                    $data['status'] = TRUE;
                    $data['messages'] = $this->lang->line('update_success');
                }
                else
                {
                    $data['status'] = FALSE;
                    $data['messages'] = $this->lang->line('update_failure');
                }
            }
            echo json_encode($data);
        }
    }

    public function update_subtype_label($id = NULL)
    {
        $subtype_data = array(
            'type_id' => $this->input->post('type'),
            'producing_year' => $this->input->post('producing_year'),
            'factory' => $this->input->post('factory'),
            'is_active' => ACTIVE
            );
        if (!is_null($id)) $subtype_data['id'] = $id;
        $this->load->model('subtypes_model');
        return (is_null($id)) ? $this->subtypes_model->insert($subtype_data) : $this->subtypes_model->update($subtype_data);
    }

    public function update_status($id)
    {
        $response_data = array();
        if ($this->input->is_ajax_request())
        {
            $is_active = $this->input->get('is_active', TRUE);
            $this->load->model('subtypes_model');
            $subtype_data = array('id' => $id, 'is_active'=> $is_active);
            $result = $this->subtypes_model->update($subtype_data);
            if ($result)
            {
                $response_data['status'] = TRUE;
                $response_data['messages'] = $this->lang->line('update_success_msg');
            }
            else
            {
                $response_data['status'] = FALSE;
                $response_data['messages'] = $this->lang->line('update_failed_msg');
            }
        }
        echo json_encode($response_data);
    }

}


text:
import { PackageFileFilter } from "core/packages";
import { IPackageClientOptions } from "core/packages";

export enum ProviderSupport {
  Releases = 'releases',
  Prereleases = 'prereleases',
  InstalledStatuses = 'installedStatuses'
}

export interface IProviderOptions extends IPackageClientOptions {
  supports: Array<ProviderSupport>;
  selector: PackageFileFilter;
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Cladonia carneola var. bacilliformis Nyl.

### Remarks
null


text:
CakePHP plugin for Opauth
=========================
Original source https://github.com/uzyn/cakephp-opauth

CakePHP 2.x plugin for [Opauth](https://github.com/uzyn/opauth).

Opauth is a multi-provider authentication framework.

Requirements
---------
CakePHP v2.x
Opauth >= v0.2 _(submoduled with this package)_
[Expandable](https://github.com/LubosRemplik/CakePHP-Expandable-Plugin)

Installation
------------
1.	Use [composer](https://getcomposer.org/doc/00-intro.md).
	Add following to the `composer.json` file:

		"require": {
			"lubos/opauth": "~1.0"
		}

	And run `php composer.phar update`

1. Download Opauth library as a submodule.

   ```bash
   git submodule init
   git submodule update
   ```

1. Add this line to the bottom of your app's `Config/bootstrap.php`:

   ```php
   <?php
   CakePlugin::load('Opauth', array('routes' => true, 'bootstrap' => true));
   ```
   Overwrite any Opauth configurations you want after the above line.

1. Load [strategies](https://github.com/uzyn/opauth/wiki/list-of-strategies) onto `Strategy/` directory.

   Append configuration for strategies at your app's `Config/bootstrap.php` as follows:
   ```php
   <?php
   CakePlugin::load('Opauth', array('routes' => true, 'bootstrap' => true));

   // Using Facebook strategy as an example
   Configure::write('Opauth.Strategy.Facebook', array(
       'app_id' => 'YOUR FACEBOOK APP ID',
       'app_secret' => 'YOUR FACEBOOK APP SECRET',
	   'redirect' => '/'
   ));
   ```

1. Go to `http://path_to_your_cake_app/auth/facebook` to authenticate with Facebook, and similarly for other strategies that you have loaded.

1. After validateion you will be redirected to Opauth.Strategy.Facebook.redirect url

### Note:
If your CakePHP app **does not** reside at DocumentRoot (eg. `http://localhost`), but at a directory below DocumentRoot (eg. `http://localhost/your-cake-app`),
add this line to your app's `APP/Config/bootstrap.php`, replacing `your-cake-app` with your actual path :

```php
<?php // APP/Config/bootstrap.php
Configure::write('Opauth.path', '/your-cake-app/auth/');
Configure::write('Opauth.callback_url', '/your-cake-app/auth/callback');
```


text:
/*
 * @author max
 */
package com.intellij.lang;

import com.intellij.openapi.util.Key;
import com.intellij.openapi.util.KeyedExtensionCollector;
import com.intellij.util.containers.ContainerUtil;
import gnu.trove.THashSet;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.util.List;
import java.util.Set;

public class LanguageExtension<T> extends KeyedExtensionCollector<T, Language> {
  private final T myDefaultImplementation;
  private final /* non static!!! */ Key<T> IN_LANGUAGE_CACHE;

  public LanguageExtension(@NonNls final String epName) {
    this(epName, null);
  }

  public LanguageExtension(@NonNls final String epName, @Nullable final T defaultImplementation) {
    super(epName);
    myDefaultImplementation = defaultImplementation;
    IN_LANGUAGE_CACHE = Key.create("EXTENSIONS_IN_LANGUAGE_"+epName);
  }

  @NotNull
  @Override
  protected String keyToString(@NotNull final Language key) {
    return key.getID();
  }

  @SuppressWarnings("ConstantConditions")
  public T forLanguage(@NotNull Language l) {
    T cached = l.getUserData(IN_LANGUAGE_CACHE);
    if (cached != null) return cached;

    List<T> extensions = forKey(l);
    T result;
    if (extensions.isEmpty()) {
      Language base = l.getBaseLanguage();
      result = base == null ? myDefaultImplementation : forLanguage(base);
    }
    else {
      result = extensions.get(0);
    }
    if (result == null) return null;
    result = l.putUserDataIfAbsent(IN_LANGUAGE_CACHE, result);
    return result;
  }

  /**
   *  @see #allForLanguageOrAny(Language)
   */
  @NotNull
  public List<T> allForLanguage(@NotNull Language l) {
    List<T> list = forKey(l);
    if (list.isEmpty()) {
      Language base = l.getBaseLanguage();
      if (base != null) {
        return allForLanguage(base);
      }
    }
    return list;
  }

  @NotNull
  public List<T> allForLanguageOrAny(@NotNull Language l) {
    List<T> providers = allForLanguage(l);
    if (l == Language.ANY) return providers;
    return ContainerUtil.concat(providers, allForLanguage(Language.ANY));
  }

  protected T getDefaultImplementation() {
    return myDefaultImplementation;
  }

  @NotNull
  protected Key<T> getLanguageCache() {
    return IN_LANGUAGE_CACHE;
  }

  @NotNull
  protected Set<String> getAllBaseLanguageIdsWithAny(@NotNull Language key) {
    Set<String> allowed = new THashSet<String>();
    while (key != null) {
      allowed.add(keyToString(key));
      key = key.getBaseLanguage();
    }
    allowed.add("any");
    return allowed;
  }

}


text:
<?php declare(strict_types=1);

namespace App\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\FormBuilderInterface;

class NieuwsType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options)
    {
        $builder
            ->add('seizoen', SeizoenSelectorType::class)
            ->add('titel')
            ->add('content', TextareaType::class, ['attr' => ['rows' => 32, 'cols' => 32]]);
    }
}


text:
- Name: Ina Todorova
- Location: Eindhoven, NL


text:
package com.appmojo.sdk;

import com.appmojo.sdk.base.AMAdNetwork;

interface AMView {

    void loadAd(AMAdRequest adRequest);

    void reloadAd();

    void setPlacementUid(String placementUid);

    String getPlacementUid();

    @AMAdNetwork.Network
    String getAdNetwork();

    AMListener getListener();

    String getCurrentAdUnitId();

    void destroy();

}


text:
package pb.log;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import javax.swing.JTextArea;
import javax.swing.SwingUtilities;

/**
 * 将System.out和System.err重定向到其他输出单元上
 * @author      proteanBear(马强)
 * @version     1.00 2011/12/02
 */
public class PrintUtil
{
    private  static void updateTextArea(final JTextArea textArea,final String text)
    {
        SwingUtilities.invokeLater(new Runnable()
        {
            public void run()
            {
                textArea.append(text);
            }
        });
    }

    public  static void redirectSystemStreams(final JTextArea textArea)
    {
        OutputStream out = new OutputStream()
        {
            @Override
            public void write(int b) throws IOException
            {
                updateTextArea(textArea ,String.valueOf((char) b));
            }

            @Override
            public void write(byte[] b, int off, int len) throws IOException
            {
                updateTextArea(textArea,new String(b, off, len));
            }

            @Override
            public void write(byte[] b) throws IOException
            {
                write(b, 0, b.length);
            }
        };

        System.setOut(new PrintStream(out, true));
        System.setErr(new PrintStream(out, true));
    }
}


text:
get '/events' do
  @events = Event.all
  erb :"events/all_events"
end

get '/events/new' do
  if current_user
    @event = Event.new
    if request.xhr?
      erb :"events/new_event", layout: false
    else
      erb :"events/new_event"
    end
  else
    "Please login in first to create an event"
  end
end

get '/events/:id' do
  @event = Event.where(id: params[:id]).first
  @attendees = Attendee.where(event_id: params[:id])
  erb :"events/your_event"
end

get '/events/:id/show' do
  @event = Event.where(id: params[:id]).first
  @creator = User.where(id: @event.user_id).first if @event

  if @event
    erb :"events/show_event", layout: false
  else
    "This is not the event you are looking for. Move along."
  end
end

post '/events' do
  @event = Event.new(
    title: params[:title],
    date: params[:date],
    time: params[:time],
    location: params[:location],
    description: params[:description],
    user_id: params[:user],
    cost: params[:cost],
  )
  if @event.save
    if request.xhr?
      # @event.to_json
      erb :"events/your_event", layout: false
    else
      "You just saved an event!"
      # params.inspect
      redirect to("/events/#{@event.id}")
    end
  else
    status 400
    erb :"events/new_event"
  end
end


text:
class AddCategoryToIssue < ActiveRecord::Migration[5.1]
  def up
    add_column :issues, :category, :integer
    ActiveRecord::Base.connection.execute("UPDATE issues SET category = 0 WHERE id IN (SELECT DISTINCT issue_id FROM bounties)")
  end

  def down
    remove_column :issues, :category
  end
end


text:
<?php namespace Neomerx\JsonApi\Settings;

use \Neomerx\JsonApi\Settings\Traits\HasTypeTrait;
use \Neomerx\JsonApi\Settings\Traits\HasReferenceTrait;
use \Neomerx\JsonApi\Settings\Traits\HasAttributesTrait;
use \Neomerx\JsonApi\Settings\Traits\CollectionRepresentationTypeTrait;

class DataLinkCollectionRepresentation
{
    use HasAttributesTrait, HasReferenceTrait, HasTypeTrait, CollectionRepresentationTypeTrait;
}


text:
from simphony.models import Subcircuit

from gdsfactory.simulation.simphony.components.coupler_ring import coupler_ring
from gdsfactory.simulation.simphony.components.straight import (
    straight as straight_function,
)
from gdsfactory.simulation.simphony.plot_circuit import plot_circuit
from gdsfactory.simulation.simphony.types import ModelFactory

def ring_double(
    wg_width: float = 0.5,
    gap: float = 0.2,
    length_x: float = 4,
    radius: float = 5,
    length_y: float = 2,
    coupler: ModelFactory = coupler_ring,
    straight: ModelFactory = straight_function,
) -> Subcircuit:
    r"""Return double bus ring Model made of two couplers (ct: top, cb: bottom).

    connected with two vertical straights (yl: left, wr: right)

    .. code::

         --==ct==--
          |      |
          wl     wr length_y
          |      |
         --==cb==-- gap

          length_x

           ---=========---
        o2    length_x    o3
             /         \
            /           \
           |             |
           o3           o2 ___
                            |
          wl            wr  | length_y
                           _|_
           o2            o3
           |             |
            \           /
             \         /
           ---=========---
        o1    length_x    o4

    .. plot::
      :include-source:

      import gdsfactory as gf

      c = gf.components.ring_double(width=0.5, gap=0.2, length_x=4, radius=5, length_y=2)
      c.plot()

    .. plot::
        :include-source:

        import gdsfactory.simulation.simphony as gs
        import gdsfactory.simulation.simphony.components as gc

        c = gc.ring_double()
        gs.plot_circuit(c)
    """
    wg1 = straight(length=length_y) if callable(straight) else straight
    wg2 = straight(length=length_y) if callable(straight) else straight
    halfring1 = (
        coupler(length_x=length_x, radius=radius, gap=gap, wg_width=wg_width)
        if callable(coupler)
        else coupler
    )
    halfring2 = (
        coupler(length_x=length_x, radius=radius, gap=gap, wg_width=wg_width)
        if callable(coupler)
        else coupler
    )
    halfring1["o2"].connect(wg1["o1"])
    halfring2["o3"].connect(wg1["o2"])
    halfring1["o3"].connect(wg2["o1"])
    halfring2["o2"].connect(wg2["o2"])
    halfring2["o1"].rename("o3")
    halfring2["o4"].rename("o2")

    return halfring1.circuit.to_subcircuit()

if __name__ == "__main__":
    import matplotlib.pyplot as plt

    c = ring_double()
    plot_circuit(c)
    plt.show()


text:
/**
 * @author Mat Groves http://matgroves.com/ @Doormat23
 */

/**
* @class PixiFastShader
* @constructor
* @param gl {WebGLContext} the current WebGL drawing context
*/
PIXI.PixiFastShader = function(gl)
{
    /**
     * @property _UID
     * @type Number
     * @private
     */
    this._UID = PIXI._UID++;

    /**
     * @property gl
     * @type WebGLContext
     */
    this.gl = gl;

    /**
     * The WebGL program.
     * @property program
     * @type Any
     */
    this.program = null;

    /**
     * The fragment shader.
     * @property fragmentSrc
     * @type Array
     */
    this.fragmentSrc = [
        'precision lowp float;',
        'varying vec2 vTextureCoord;',
        'varying float vColor;',
        'uniform sampler2D uSampler;',
        'void main(void) {',
        '   gl_FragColor = texture2D(uSampler, vTextureCoord) * vColor ;',
        '}'
    ];

    /**
     * The vertex shader.
     * @property vertexSrc
     * @type Array
     */
    this.vertexSrc = [
        'attribute vec2 aVertexPosition;',
        'attribute vec2 aPositionCoord;',
        'attribute vec2 aScale;',
        'attribute float aRotation;',
        'attribute vec2 aTextureCoord;',
        'attribute float aColor;',

        'uniform vec2 projectionVector;',
        'uniform vec2 offsetVector;',
        'uniform mat3 uMatrix;',

        'varying vec2 vTextureCoord;',
        'varying float vColor;',

        'const vec2 center = vec2(-1.0, 1.0);',

        'void main(void) {',
        '   vec2 v;',
        '   vec2 sv = aVertexPosition * aScale;',
        '   v.x = (sv.x) * cos(aRotation) - (sv.y) * sin(aRotation);',
        '   v.y = (sv.x) * sin(aRotation) + (sv.y) * cos(aRotation);',
        '   v = ( uMatrix * vec3(v + aPositionCoord , 1.0) ).xy ;',
        '   gl_Position = vec4( ( v / projectionVector) + center , 0.0, 1.0);',
        '   vTextureCoord = aTextureCoord;',
      //  '   vec3 color = mod(vec3(aColor.y/65536.0, aColor.y/256.0, aColor.y), 256.0) / 256.0;',
        '   vColor = aColor;',
        '}'
    ];

    /**
     * A local texture counter for multi-texture shaders.
     * @property textureCount
     * @type Number
     */
    this.textureCount = 0;

    this.init();
};

PIXI.PixiFastShader.prototype.constructor = PIXI.PixiFastShader;

/**
* Initialises the shader.
*
* @method init
*/
PIXI.PixiFastShader.prototype.init = function()
{
    var gl = this.gl;

    var program = PIXI.compileProgram(gl, this.vertexSrc, this.fragmentSrc);

    gl.useProgram(program);

    // get and store the uniforms for the shader
    this.uSampler = gl.getUniformLocation(program, 'uSampler');

    this.projectionVector = gl.getUniformLocation(program, 'projectionVector');
    this.offsetVector = gl.getUniformLocation(program, 'offsetVector');
    this.dimensions = gl.getUniformLocation(program, 'dimensions');
    this.uMatrix = gl.getUniformLocation(program, 'uMatrix');

    // get and store the attributes
    this.aVertexPosition = gl.getAttribLocation(program, 'aVertexPosition');
    this.aPositionCoord = gl.getAttribLocation(program, 'aPositionCoord');

    this.aScale = gl.getAttribLocation(program, 'aScale');
    this.aRotation = gl.getAttribLocation(program, 'aRotation');

    this.aTextureCoord = gl.getAttribLocation(program, 'aTextureCoord');
    this.colorAttribute = gl.getAttribLocation(program, 'aColor');

    // Begin worst hack eva //

    // WHY??? ONLY on my chrome pixel the line above returns -1 when using filters?
    // maybe its somthing to do with the current state of the gl context.
    // Im convinced this is a bug in the chrome browser as there is NO reason why this should be returning -1 especially as it only manifests on my chrome pixel
    // If theres any webGL people that know why could happen please help :)
    if(this.colorAttribute === -1)
    {
        this.colorAttribute = 2;
    }

    this.attributes = [this.aVertexPosition, this.aPositionCoord,  this.aScale, this.aRotation, this.aTextureCoord, this.colorAttribute];

    // End worst hack eva //

    this.program = program;
};

/**
* Destroys the shader.
*
* @method destroy
*/
PIXI.PixiFastShader.prototype.destroy = function()
{
    this.gl.deleteProgram( this.program );
    this.uniforms = null;
    this.gl = null;

    this.attributes = null;
};


text:
title: Статические файлы
description: У Nuxt.js есть специальный каталог для статическмх файлов под названием static.
---

> У Nuxt.js есть специальный каталог для статическмх файлов под названием `static`.

Если вы не хотите использовать [Webpacked Assets](/guide/assets) из папки `assets`, то можно создать и использовать папку 'static' в корневом каталоге проекта.

Nuxt.js автоматически сделает доступными эти файлы через `/`.

Эта опция полезна для таких файлов, как 'robots.txt' или 'sitemap.xml'.

В коде проекта эти файлы будут доступны также через `/`:

```html
<!-- Статическое изображение из папки `static`-->
<img src="/my-image.png"/>

<!-- Статическое изображение через Webpack из папки `assets`-->
<img src="/assets/my-image-2.png"/>
```


text:
var readerFrameNode = null;
var feedsContainerNode = null;
var hiddenNodes = [];

const GMAIL_STYLES = [
  "#reader-frame {",
  "  width: 100%;",
  "  border: 0;",
  "}",

  ".reader-embedded #ft {",
    "display: none",
  "}",

  // Make currently selected item appear normal
  ".reader-embedded table.cv * {",
  "  background: #fff;",
  "  font-weight: normal",
  "}",

  // Make the feeds link appear selected
  ".reader-embedded #feeds-container {",
  "  background: #c3d9ff;",
  "  -moz-border-radius: 5px 0 0 5px;",
  "  font-weight: bold;",
  "  color: #00c;",
  "}",
].join("\n");

const READER_STYLES = [
  "body {",
  "  background: #fff",
  "}",

  "#nav,",
  "#logo-container,",
  "#global-info,",
  "#viewer-header {",
  "  display: none !important;",
  "}",
  "",
  "#main {",
  "  margin-top: 0;",
  "}",
  "",
  "#chrome {",
  "  margin-left: 0;",
  "}"
].join("\n");

const READER_UNREAD_COUNT_URL =
  "http://www.google.com/reader/api/0/unread-count?" +
  "all=true&output=json&client=gm";

const READER_LIST_VIEW_URL =
  "http://www.google.com/reader/view/user/-/state/com.google/reading-list?" +
  "gmail-embed=true&view=list";

if (document.location.hostname == "mail.google.com") {
  injectGmail();
} else if (document.location.hostname == "www.google.com" &&
           document.location.search.indexOf("gmail-embed") != -1) {
  injectReader();
}

function injectGmail() {
  if (!getNode("nds") || !getNode("ds_inbox")) return;

  GM_addStyle(GMAIL_STYLES);

  var feedsNode = newNode("span");
  feedsNode.className = "lk";
  feedsNode.innerHTML =
      'Feeds ' +
      '';
  feedsNode.onclick = showReaderFrame;

  feedsContainerNode = newNode("div");
  feedsContainerNode.className = "nl";
  feedsContainerNode.id = "feeds-container";
  feedsContainerNode.appendChild(feedsNode);

  var navNode = getNode("nds");

  navNode.insertBefore(feedsContainerNode, navNode.childNodes[2]);

  window.addEventListener("resize", resizeReaderFrame, false);

  updateUnreadCount();

  window.setInterval(updateUnreadCount, 5 * 60 * 1000);

  window.setInterval(checkFeedsParent, 1000);
}

function checkFeedsParent() {
  var navNode = getNode("nds");

  if (feedsContainerNode.parentNode != navNode) {
    navNode.insertBefore(feedsContainerNode, navNode.childNodes[2]);
  }
}

function updateUnreadCount() {
  var unreadCountNode = getNode("reader-unread-count");

  if (!unreadCountNode) return;

  GM_xmlhttpRequest({
    method: "GET",
    url: READER_UNREAD_COUNT_URL,
    onload: function(details) {
      var data = eval("(" + details.responseText + ")");
      var isUnread = false;

      for (var i = 0, unreadCountPair;
           unreadCountPair = data.unreadcounts[i];
           i++) {
        if (unreadCountPair.id.indexOf("reading-list") != -1) {
          var count = unreadCountPair.count;
          if (count == 0) break;

          unreadCountNode.innerHTML =
              " (" + count + (count == data.max ? "+" : "") + ") ";
          isUnread = true;
          break;
        }
      }

      if (!isUnread) {
        unreadCountNode.innerHTML = "";
      }
    }
  });
}

function resizeReaderFrame() {
  if (!readerFrameNode) return;

  readerFrameNode.style.height =
      (window.innerHeight - readerFrameNode.offsetTop) + "px";
}

function showReaderFrame(event) {
  var container = getNode("co");

  addClass(document.body, "reader-embedded");

  hiddenNodes = [];

  for (var i = container.firstChild; i; i = i.nextSibling) {
    hiddenNodes.push(i);
    i.style.display = "none";
  }

  readerFrameNode = newNode("iframe");
  readerFrameNode.src = READER_LIST_VIEW_URL;
  readerFrameNode.id = "reader-frame";

  container.appendChild(readerFrameNode);

  container.parentNode.style.paddingRight = "0";
  container.parentNode.style.paddingBottom = "0";

  resizeReaderFrame();

  // Make clicks outside the content area hide it
  getNode("nav").addEventListener("click", hideReaderFrame, false);

  // Since we're in a child of the "nav" element, the above handler will get
  // triggered immediately unless we stop this event from propagating
  event.stopPropagation();

  return false;
}

function hideReaderFrame() {
  var container = getNode("co");

  container.removeChild(readerFrameNode);
  readerFrameNode = null;

  for (var i=0; i < hiddenNodes.length; i++) {
    hiddenNodes[i].style.display = "";
  }
  getNode("nav").removeEventListener("click", hideReaderFrame, false);

  removeClass(document.body, "reader-embedded");

  container.parentNode.style.paddingRight = "1ex";
  container.parentNode.style.paddingBottom = "1ex";

  return true;
}

function injectReader() {
  GM_addStyle(READER_STYLES);
}

// Shorthand
function newNode(type) {return unsafeWindow.document.createElement(type);}
function newText(text) {return unsafeWindow.document.createTextNode(text);}
function getNode(id) {return unsafeWindow.document.getElementById(id);}

function hasClass(node, className) {
  return className in getClassMap(node);
}

function addClass(node, className) {
  if (hasClass(node, className)) return;

  node.className += " " + className;
}

function removeClass(node, className) {
  var classMap = getClassMap(node);

  if (!(className in classMap)) return;

  delete classMap[className];
  var newClassList = [];

  for (var className in classMap) {
    newClassList.push(className);
  }

  node.className = newClassList.join(" ");
}

function getClassMap(node) {
  var classMap = {};
  var classNames = node.className.split(/\s+/);

  for (var i = 0; i < classNames.length; i++) {
    classMap[classNames[i]] = true;
  }

  return classMap;
}


text:
BACK-END WEB DEVELOPMENT
============================

![GeneralAssemb.ly](https://github.com/generalassembly/ga-ruby-on-rails-for-devs/raw/master/images/ga.png "GeneralAssemb.ly")

##Day 0: Course Orientation

---

#Meet your instruction team
* Bill Transue
* Andrei Bondarev
* Mikael Davis

---

##Pre-work

Have you...

* Created a Github account?
* Familiar with HTML/CSS?
* Installed anything yet?

---

##Today's install agenda

* Mac specific tools:
	- Command Line Tools
	- Homebrew
* Windows specific software:
	- VirtualBox
	- Ubuntu
* git (install and configure)
* RVM and Ruby (through RVM)
* Sublime Text
* Install Markdown viewer (Mou for Mac and Markdown Preview for Windows/Mac)

---

##Install Fest!

Make sure you have access to our GitHub repo here:

[https://github.com/ga-students/BEWD_DC_1](https://github.com/ga-students/BEWD_DC_1)

Then follow the instructions for your platform here:

[https://github.com/ga-students/BEWD_DC_1/tree/master/00_Install_Fest](https://github.com/ga-students/BEWD_DC_1/tree/master/00_Install_Fest)

---

#Got Git? RVM? Ruby? ...

		git version
		rvm -v
		ruby -v

---

![Octocat](../assets/GitHub/octocat.png)

#GitHub: Login
  * A place for sharing
  * Organized into "repositories" or "repos"
  * [http://github.com](http://github.com)

---

# Feeling adventurous?
## GitHub: Clone
![Clone](../assets/GitHub/clone.png)

$ git clone git@github.com:ga-students/BEWD_DC_1.git

"Copy this repository to the current directory on my machine."

---

#Next Class

*	Terminal Commands
*	Using GitHub
*	Intro to Web Development

---

#For more on...

Command Line:

* [http://www.ee.surrey.ac.uk/Teaching/Unix/](http://www.ee.surrey.ac.uk/Teaching/Unix/)
* [http://cli.learncodethehardway.org/book/](http://cli.learncodethehardway.org/book/)
* [http://www.davidbaumgold.com/tutorials/command-line/](http://www.davidbaumgold.com/tutorials/command-line/)

Git:

* [http://git-scm.com/videos](http://git-scm.com/videos)
* [http://git-scm.com/documentation](http://git-scm.com/documentation)

HTML/CSS

* [https://dash.generalassemb.ly/](https://dash.generalassemb.ly/)