text:
ALTER TABLE cerveja
   ADD foto TEXT,
   ADD content_type TEXT;

redpajama_set_name: RedPajamaGithub


text:
<?php
namespace Df\Config\Source;
/**
 * 2019-07-06
 * The built-in @see \Magento\Config\Model\Config\Source\Yesno class can not be used
 * as `source_model` for an attribute, because it does not inherit from any class
 * and does not implement the `setAttribute` method,
 * so the @see \Magento\Eav\Model\Entity\Attribute\AbstractAttribute::getSource() method
 * fails with the error:
 * 		«Call to undefined method Magento\Config\Model\Config\Source\Yesno::setAttribute()»
 * https://github.com/magento/magento2/blob/2.3.2/app/code/Magento/Eav/Model/Entity/Attribute/AbstractAttribute.php#L652
 * That is why I implemented my own YesNo class which supports the `setAttribute` method,
 * because it has the @see \Magento\Framework\DataObject class as an ancestor.
 * @used-by \KingPalm\B2B\Setup\UpgradeData::_process()
 */
final class YN extends \Df\Config\SourceBase {
	/**
	 * 2019-07-06
	 * @override
	 * @see \Magento\Framework\Option\ArrayInterface::toOptionArray()
	 * @used-by \Magento\Config\Model\Config\Structure\Element\Field::_getOptionsFromSourceModel()
	 * @return array(array('label' => string, 'value' => int|string))
	 */
	function toOptionArray():array {return df_yes_no();}
}


text:
#ifndef _SAMPLES_AREACHART_WXAREACHARTFRAME_H_
#define _SAMPLES_AREACHART_WXAREACHARTFRAME_H_

#include <wx/frame.h>

class wxAreaChartFrame : public wxFrame
{
public:
    wxAreaChartFrame(const wxString& title);
};

#endif


text:
package activitytest.com.example.bottomnavigationbartest.base;

import android.app.Activity;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import activitytest.com.example.bottomnavigationbartest.ActivityCollector;
import activitytest.com.example.bottomnavigationbartest.ui.view.CommonFilterPop;

/**
 * Created by pc on 2017/4/22.
 */

public class BaseActivity extends AppCompatActivity {

    //筛选pop
    private CommonFilterPop mPopupWindow;
    //当前上下文实例
    protected Activity activity;

    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        Log.d("BaseAcitivity",getClass().getSimpleName());
        ActivityCollector.addActivity(this);
        this.activity = this;
    }

    @Override
    protected void onDestroy(){
        super.onDestroy();
        ActivityCollector.removeActivity(this);
    }
}


text:
// Karma configuration
// Generated on Thu Nov 14 2013 18:54:35 GMT+0100 (CET)

module.exports = function(config) {
  config.set({

    // base path, that will be used to resolve files and exclude
    basePath: '',

    // frameworks to use
    frameworks: ['jasmine'],

    // list of files / patterns to load in the browser
    files: [
      'bower_components/angular/angular.js',
      'bower_components/angular-mocks/angular-mocks.js',
      'src/commangular.js',
      'src/commangular-mock/commangular-mock.js',
      'test/**/*.js'

    ],

    // list of files to exclude
    exclude: [

    ],

    // test results reporter to use
    // possible values: 'dots', 'progress', 'junit', 'growl', 'coverage'
    reporters: ['progress'],

    // web server port
    port: 9876,

    // enable / disable colors in the output (reporters and logs)
    colors: true,

    // level of logging
    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
    logLevel: config.LOG_INFO,

    // enable / disable watching file and executing tests whenever any file changes
    autoWatch: true,

    // Start these browsers, currently available:
    // - Chrome
    // - ChromeCanary
    // - Firefox
    // - Opera (has to be installed with `npm install karma-opera-launcher`)
    // - Safari (only Mac; has to be installed with `npm install karma-safari-launcher`)
    // - PhantomJS
    // - IE (only Windows; has to be installed with `npm install karma-ie-launcher`)
    browsers: ['Chrome'],

    plugins : [

	  'karma-chrome-launcher',
	  'karma-firefox-launcher',
	  'karma-jasmine'
],

    // If browser does not capture in given timeout [ms], kill it
    captureTimeout: 60000,

    // Continuous Integration mode
    // if true, it capture browsers, run tests and exit
    singleRun: false
  });
};


text:
var searchData=
[
  ['handle',['Handle',['../structrocksdb_1_1Cache_1_1Handle.html',1,'rocksdb::Cache']]],
  ['handler',['Handler',['../classrocksdb_1_1WriteBatch_1_1Handler.html',1,'rocksdb::WriteBatch']]],
  ['histogramdata',['HistogramData',['../structrocksdb_1_1HistogramData.html',1,'rocksdb']]],
  ['http_5fmessage',['http_message',['../structhttp__message.html',1,'']]]
];


text:
const path = require('path')
const globby = require('globby')
const sucrase = require('@rollup/plugin-sucrase')
const { externalizeRelative } = require('./scripts/lib/new-rollup')

/*
needs locales-all to run first

compiles from *SRC* files.
we use sucrase to transpile the ts files.
normally we wouldn't use sucrase because it produces JS that's too advanced for the browsers we want to support,
but the locale files are simple so it'll be fine.
*/

let srcLocaleFiles = globby.sync('packages/core/src/locales/*.ts')
let bundleDirs = globby.sync('packages?(-premium)/bundle', { onlyDirectories: true })
let sucraseInstance = sucrase({
  transforms: ['typescript']
})

module.exports = [

  // locales-all.js, for CORE
  {
    input: 'packages/core/src/locales-all.ts',
    output: {
      format: 'cjs',
      exports: 'named',
      file: 'packages/core/locales-all.js'
    },
    plugins: [
      externalizeRelative(), // resulting bundle will import the individual locales
      sucraseInstance,
      dumbDownFuncs()
    ]
  },

  // locales-all.js, for BUNDLES
  {
    input: 'packages/core/src/locales-all.ts',
    output: bundleDirs.map((bundleDir) => ({
      format: 'iife',
      name: 'FullCalendar', // for bundleWrapLocalesAll
      file: path.join(bundleDir, 'locales-all.js')
    })).concat({
      format: 'iife',
      name: 'FullCalendar', // for bundleWrapLocalesAll
      file: path.join('packages/core/locales-all.global.js') // FOR CORE
    }),
    plugins: [
      sucraseInstance,
      dumbDownFuncs(),
      bundleWrapLocalesAll()
    ]
  },

  // locales/*.js, for CORE
  ...srcLocaleFiles.map((srcLocaleFile) => ({
    input: srcLocaleFile,
    output: {
      format: 'cjs',
      exports: 'named',
      file: path.join('packages/core/locales', path.basename(srcLocaleFile, '.ts') + '.js')
    },
    plugins: [
      sucraseInstance,
      dumbDownFuncs()
    ]
  })),

  // locales/*.js, for BUNDLES
  ...srcLocaleFiles.map((srcLocaleFile) => ({
    input: srcLocaleFile,
    output: bundleDirs.map((bundleDir) => ({
      format: 'iife',
      name: 'FullCalendar', // for bundleWrapLocalesAll
      file: path.join(bundleDir, 'locales', path.basename(srcLocaleFile, '.ts') + '.js')
    })).concat({
      format: 'iife',
      name: 'FullCalendar', // for bundleWrapLocalesAll
      file: path.join('packages/core/locales', path.basename(srcLocaleFile, '.ts') + '.global.js') // FOR CORE
    }),
    plugins: [
      sucraseInstance,
      dumbDownFuncs(),
      bundleWrapLocalesEach()
    ]
  }))

]

function bundleWrapLocalesAll() {
  return {
    renderChunk(code) {
      return code.replace(/^var FullCalendar = \(/, '[].push.apply(FullCalendar.globalLocales, ') // needs to be by-reference. can't reassign
    }
  }
}

function bundleWrapLocalesEach() {
  return {
    renderChunk(code) {
      return code.replace(/^var FullCalendar = /, 'FullCalendar.globalLocales.push')
    }
  }
}

// for IE11: https://github.com/fullcalendar/fullcalendar/issues/6014
function dumbDownFuncs() {
  return {
    renderChunk(code) {
      return code.replace(/(\w+)(\([\w, ]\)\s*{)/g, '$1: function$2')
    }
  }
}


text:
#ifndef PICO_H_
#define PICO_H_

/** \file pico.h
*  \defgroup pico_base pico_base
*
* Core types and macros for the Pico SDK. This header is intended to be included by all source code
*/

#include "pico/types.h"
#include "pico/version.h"
#include "pico/config.h"
#include "pico/platform.h"
#include "pico/assert.h"
#include "pico/error.h"

#endif


text:
<?php

namespace Drupal\Tests\file\Kernel\Migrate\d7;

use Drupal\Core\StreamWrapper\PublicStream;
use Drupal\Core\StreamWrapper\StreamWrapperInterface;

/**
 * A trait to setup the file migration.
 */
trait FileMigrationSetupTrait {

  /**
   * Prepare the file migration for running.
   */
  protected function fileMigrationSetup() {
    $this->installSchema('file', ['file_usage']);
    $this->installEntitySchema('file');
    $this->container->get('stream_wrapper_manager')->registerWrapper('public', PublicStream::class, StreamWrapperInterface::NORMAL);

    $fs = \Drupal::service('file_system');
    // The public file directory active during the test will serve as the
    // root of the fictional Drupal 7 site we're migrating.
    $fs->mkdir('public://sites/default/files', NULL, TRUE);
    file_put_contents('public://sites/default/files/cube.jpeg', str_repeat('*', 3620));

    /** @var \Drupal\migrate\Plugin\Migration $migration */
    $migration = $this->getMigration('d7_file');
    // Set the source plugin's source_base_path configuration value, which
    // would normally be set by the user running the migration.
    $source = $migration->getSourceConfiguration();
    $source['constants']['source_base_path'] = $fs->realpath('public://');
    $migration->set('source', $source);
    $this->executeMigration($migration);
  }

}


text:
namespace base {
namespace trace_event {
class TracedValue;
}
}

namespace exo {
class Buffer;
class SurfaceDelegate;
class SurfaceObserver;

// This class represents a rectangular area that is displayed on the screen.
// It has a location, size and pixel contents.
class Surface : public aura::Window, public ui::CompositorObserver {
 public:
  Surface();
  ~Surface() override;

  // Type-checking downcast routine.
  static Surface* AsSurface(aura::Window* window);

  // Set a buffer as the content of this surface. A buffer can only be attached
  // to one surface at a time.
  void Attach(Buffer* buffer);

  // Describe the regions where the pending buffer is different from the
  // current surface contents, and where the surface therefore needs to be
  // repainted.
  void Damage(const gfx::Rect& rect);

  // Request notification when the next frame is displayed. Useful for
  // throttling redrawing operations, and driving animations.
  using FrameCallback = base::Callback<void(base::TimeTicks frame_time)>;
  void RequestFrameCallback(const FrameCallback& callback);

  // This sets the region of the surface that contains opaque content.
  void SetOpaqueRegion(const SkRegion& region);

  // This sets the scaling factor used to interpret the contents of the buffer
  // attached to the surface. Note that if the scale is larger than 1, then you
  // have to attach a buffer that is larger (by a factor of scale in each
  // dimension) than the desired surface size.
  void SetBufferScale(float scale);

  // Functions that control sub-surface state. All sub-surface state is
  // double-buffered and will be applied when Commit() is called.
  void AddSubSurface(Surface* sub_surface);
  void RemoveSubSurface(Surface* sub_surface);
  void SetSubSurfacePosition(Surface* sub_surface, const gfx::Point& position);
  void PlaceSubSurfaceAbove(Surface* sub_surface, Surface* reference);
  void PlaceSubSurfaceBelow(Surface* sub_surface, Surface* sibling);

  // Surface state (damage regions, attached buffers, etc.) is double-buffered.
  // A Commit() call atomically applies all pending state, replacing the
  // current state. Commit() is not guaranteed to be synchronous. See
  // CommitSurfaceHierarchy() below.
  void Commit();

  // This will synchronously commit all pending state of the surface and its
  // descendants by recursively calling CommitSurfaceHierarchy() for each
  // sub-surface with pending state.
  void CommitSurfaceHierarchy();

  // Returns true if surface is in synchronized mode.
  bool IsSynchronized() const;

  // Returns the preferred size of surface.
  gfx::Size GetPreferredSize() const;

  // Set the surface delegate.
  void SetSurfaceDelegate(SurfaceDelegate* delegate);

  // Returns true if surface has been assigned a surface delegate.
  bool HasSurfaceDelegate() const;

  // Surface does not own observers. It is the responsibility of the observer
  // to remove itself when it is done observing.
  void AddSurfaceObserver(SurfaceObserver* observer);
  void RemoveSurfaceObserver(SurfaceObserver* observer);
  bool HasSurfaceObserver(const SurfaceObserver* observer) const;

  // Returns a trace value representing the state of the surface.
  scoped_refptr<base::trace_event::TracedValue> AsTracedValue() const;

  bool HasPendingDamageForTesting() const { return !pending_damage_.IsEmpty(); }

  // Overridden from ui::CompositorObserver:
  void OnCompositingDidCommit(ui::Compositor* compositor) override;
  void OnCompositingStarted(ui::Compositor* compositor,
                            base::TimeTicks start_time) override;
  void OnCompositingEnded(ui::Compositor* compositor) override;
  void OnCompositingAborted(ui::Compositor* compositor) override;
  void OnCompositingLockStateChanged(ui::Compositor* compositor) override {}
  void OnCompositingShuttingDown(ui::Compositor* compositor) override;

 private:
  bool needs_commit_surface_hierarchy() const {
    return needs_commit_surface_hierarchy_;
  }

  // This returns true when the surface has some contents assigned to it.
  bool has_contents() const { return !!current_buffer_; }

  // This is true when Attach() has been called and new contents should take
  // effect next time Commit() is called.
  bool has_pending_contents_;

  // The buffer that will become the content of surface when Commit() is called.
  base::WeakPtr<Buffer> pending_buffer_;

  // The damage region to schedule paint for when Commit() is called.
  // TODO(reveman): Use SkRegion here after adding a version of
  // ui::Layer::SchedulePaint that takes a SkRegion.
  gfx::Rect pending_damage_;

  // These lists contains the callbacks to notify the client when it is a good
  // time to start producing a new frame. These callbacks move to
  // |frame_callbacks_| when Commit() is called. Later they are moved to
  // |active_frame_callbacks_| when the effect of the Commit() is reflected in
  // the compositor's active layer tree. The callbacks fire once we're notified
  // that the compositor started drawing that active layer tree.
  std::list<FrameCallback> pending_frame_callbacks_;
  std::list<FrameCallback> frame_callbacks_;
  std::list<FrameCallback> active_frame_callbacks_;

  // The opaque region to take effect when Commit() is called.
  SkRegion pending_opaque_region_;

  // The buffer scaling factor to take effect when Commit() is called.
  float pending_buffer_scale_;

  // The stack of sub-surfaces to take effect when Commit() is called.
  // Bottom-most sub-surface at the front of the list and top-most sub-surface
  // at the back.
  using SubSurfaceEntry = std::pair<Surface*, gfx::Point>;
  using SubSurfaceEntryList = std::list<SubSurfaceEntry>;
  SubSurfaceEntryList pending_sub_surfaces_;

  // The buffer that is currently set as content of surface.
  base::WeakPtr<Buffer> current_buffer_;

  // This is true if a call to Commit() as been made but
  // CommitSurfaceHierarchy() has not yet been called.
  bool needs_commit_surface_hierarchy_;

  // This is true when the contents of the surface should be updated next time
  // the compositor successfully ends compositing.
  bool update_contents_after_successful_compositing_;

  // The compsitor being observer or null if not observing a compositor.
  ui::Compositor* compositor_;

  // This can be set to have some functions delegated. E.g. ShellSurface class
  // can set this to handle Commit() and apply any double buffered state it
  // maintains.
  SurfaceDelegate* delegate_;

  // Surface observer list. Surface does not own the observers.
  base::ObserverList<SurfaceObserver, true> observers_;

  DISALLOW_COPY_AND_ASSIGN(Surface);
};

}  // namespace exo

#endif  // COMPONENTS_EXO_SURFACE_H_


text:
// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).
//
// This file implements the "bridge" between Java and C++ and enables
// calling c++ rocksdb::WriteBatch methods testing from Java side.
#include <memory>

#include "db/memtable.h"
#include "db/write_batch_internal.h"
#include "include/org_rocksdb_WriteBatch.h"
#include "include/org_rocksdb_WriteBatchTest.h"
#include "include/org_rocksdb_WriteBatchTestInternalHelper.h"
#include "include/org_rocksdb_WriteBatch_Handler.h"
#include "options/cf_options.h"
#include "rocksdb/db.h"
#include "rocksdb/env.h"
#include "rocksdb/memtablerep.h"
#include "rocksdb/status.h"
#include "rocksdb/write_batch.h"
#include "rocksdb/write_buffer_manager.h"
#include "rocksjni/portal.h"
#include "table/scoped_arena_iterator.h"
#include "util/string_util.h"
#include "util/testharness.h"

/*
 * Class:     org_rocksdb_WriteBatchTest
 * Method:    getContents
 * Signature: (J)[B
 */
jbyteArray Java_org_rocksdb_WriteBatchTest_getContents(JNIEnv* env,
                                                       jclass /*jclazz*/,
                                                       jlong jwb_handle) {
  auto* b = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle);
  assert(b != nullptr);

  // todo: Currently the following code is directly copied from
  // db/write_bench_test.cc.  It could be implemented in java once
  // all the necessary components can be accessed via jni api.

  rocksdb::InternalKeyComparator cmp(rocksdb::BytewiseComparator());
  auto factory = std::make_shared<rocksdb::SkipListFactory>();
  rocksdb::Options options;
  rocksdb::WriteBufferManager wb(options.db_write_buffer_size);
  options.memtable_factory = factory;
  rocksdb::MemTable* mem = new rocksdb::MemTable(
      cmp, rocksdb::ImmutableCFOptions(options),
      rocksdb::MutableCFOptions(options), &wb, rocksdb::kMaxSequenceNumber,
      0 /* column_family_id */);
  mem->Ref();
  std::string state;
  rocksdb::ColumnFamilyMemTablesDefault cf_mems_default(mem);
  rocksdb::Status s =
      rocksdb::WriteBatchInternal::InsertInto(b, &cf_mems_default, nullptr);
  int count = 0;
  rocksdb::Arena arena;
  rocksdb::ScopedArenaIterator iter(
      mem->NewIterator(rocksdb::ReadOptions(), &arena));
  for (iter->SeekToFirst(); iter->Valid(); iter->Next()) {
    rocksdb::ParsedInternalKey ikey;
    ikey.clear();
    bool parsed = rocksdb::ParseInternalKey(iter->key(), &ikey);
    if (!parsed) {
      assert(parsed);
    }
    switch (ikey.type) {
      case rocksdb::kTypeValue:
        state.append("Put(");
        state.append(ikey.user_key.ToString());
        state.append(", ");
        state.append(iter->value().ToString());
        state.append(")");
        count++;
        break;
      case rocksdb::kTypeMerge:
        state.append("Merge(");
        state.append(ikey.user_key.ToString());
        state.append(", ");
        state.append(iter->value().ToString());
        state.append(")");
        count++;
        break;
      case rocksdb::kTypeDeletion:
        state.append("Delete(");
        state.append(ikey.user_key.ToString());
        state.append(")");
        count++;
        break;
      case rocksdb::kTypeSingleDeletion:
        state.append("SingleDelete(");
        state.append(ikey.user_key.ToString());
        state.append(")");
        count++;
        break;
      case rocksdb::kTypeRangeDeletion:
        state.append("DeleteRange(");
        state.append(ikey.user_key.ToString());
        state.append(", ");
        state.append(iter->value().ToString());
        state.append(")");
        count++;
        break;
      case rocksdb::kTypeLogData:
        state.append("LogData(");
        state.append(ikey.user_key.ToString());
        state.append(")");
        count++;
        break;
      default:
        assert(false);
        state.append("Err:Expected(");
        state.append(std::to_string(ikey.type));
        state.append(")");
        count++;
        break;
    }
    state.append("@");
    state.append(rocksdb::NumberToString(ikey.sequence));
  }
  if (!s.ok()) {
    state.append(s.ToString());
  } else if (rocksdb::WriteBatchInternal::Count(b) != count) {
    state.append("Err:CountMismatch(expected=");
    state.append(std::to_string(rocksdb::WriteBatchInternal::Count(b)));
    state.append(", actual=");
    state.append(std::to_string(count));
    state.append(")");
  }
  delete mem->Unref();

  jbyteArray jstate = env->NewByteArray(static_cast<jsize>(state.size()));
  if (jstate == nullptr) {
    // exception thrown: OutOfMemoryError
    return nullptr;
  }

  env->SetByteArrayRegion(
      jstate, 0, static_cast<jsize>(state.size()),
      const_cast<jbyte*>(reinterpret_cast<const jbyte*>(state.c_str())));
  if (env->ExceptionCheck()) {
    // exception thrown: ArrayIndexOutOfBoundsException
    env->DeleteLocalRef(jstate);
    return nullptr;
  }

  return jstate;
}

/*
 * Class:     org_rocksdb_WriteBatchTestInternalHelper
 * Method:    setSequence
 * Signature: (JJ)V
 */
void Java_org_rocksdb_WriteBatchTestInternalHelper_setSequence(
    JNIEnv* /*env*/, jclass /*jclazz*/, jlong jwb_handle, jlong jsn) {
  auto* wb = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle);
  assert(wb != nullptr);

  rocksdb::WriteBatchInternal::SetSequence(
      wb, static_cast<rocksdb::SequenceNumber>(jsn));
}

/*
 * Class:     org_rocksdb_WriteBatchTestInternalHelper
 * Method:    sequence
 * Signature: (J)J
 */
jlong Java_org_rocksdb_WriteBatchTestInternalHelper_sequence(JNIEnv* /*env*/,
                                                             jclass /*jclazz*/,
                                                             jlong jwb_handle) {
  auto* wb = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle);
  assert(wb != nullptr);

  return static_cast<jlong>(rocksdb::WriteBatchInternal::Sequence(wb));
}

/*
 * Class:     org_rocksdb_WriteBatchTestInternalHelper
 * Method:    append
 * Signature: (JJ)V
 */
void Java_org_rocksdb_WriteBatchTestInternalHelper_append(JNIEnv* /*env*/,
                                                          jclass /*jclazz*/,
                                                          jlong jwb_handle_1,
                                                          jlong jwb_handle_2) {
  auto* wb1 = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle_1);
  assert(wb1 != nullptr);
  auto* wb2 = reinterpret_cast<rocksdb::WriteBatch*>(jwb_handle_2);
  assert(wb2 != nullptr);

  rocksdb::WriteBatchInternal::Append(wb1, wb2);
}


text:
class Track < ApplicationRecord
  belongs_to :site

  has_many :track_playlists
  has_many :playlists, through: :track_playlists

  validates :site, :url, presence: true
  validates :url, format: { with: /https:\/\/.*youtu\.be|https:\/\/.*youtube\.|https:\/\/.*soundcloud\.|https:\/\/.*bandcamp\./,
    message: "must be valid soundcloud/youtube/bancamp url" }

  before_validation :set_site
  before_save :fetch_track_information

  def self.add_to_playlist track_url, playlist_id
    playlist = Playlist.find_by(id: playlist_id)
    track = Track.create(url: track_url)
    if playlist && track.errors.empty?
      playlist.tracks << track
      return playlist
    else
      return false
    end
  end

  private

  def set_site
    return if site || url.blank?
    if self.url.match(/https:\/\/.*soundcloud\./)
      self.site = Site.find_by(name: 'SoundCloud')
    elsif self.url.match(/https:\/\/.*youtu\.be|https:\/\/.*youtube\./)
      self.site = Site.find_by(name: 'YouTube')
    end
  end

  def fetch_track_information
    return if name || artist_name
    if site_id == 1
      fetch_soundcloud_info
    else
      fetch_youtube_info
    end
  end

  def fetch_soundcloud_info
    begin
      doc = Nokogiri::HTML(open(url))
      if doc
        self.artist_name = doc.css('h1').first.children[2].children[0].text
        self.name = doc.css('h1').first.children.first.children[0].text
      end
    rescue => e
      logger.info "URL not found in fetch_soundcloud_info"
    end
    self.artist_name = "Unknown" if artist_name.nil?
    self.name = "Unknown" if name.nil?
  end

  def fetch_youtube_info
    begin
      video_response = JSON.parse(RestClient.get("https://www.googleapis.com/youtube/v3/videos?part=snippet&id=#{get_youtube_id}&key=#{ENV['YOUTUBE_API_KEY']}").body)
      channel_id = video_response['items'][0]['snippet']['channelId']
      title = video_response['items'][0]['snippet']['title']

      channel_response = JSON.parse(RestClient.get("https://www.googleapis.com/youtube/v3/channels?part=snippet&id=#{channel_id}&key=#{ENV['YOUTUBE_API_KEY']}").body)
      channel_name = channel_response['items'][0]['snippet']['title']

      self.artist_name = channel_name
      self.name = title
    rescue => e
      self.artist_name = 'Unknown'
      self.name = 'Unknown'
    end
  end

  def get_youtube_id
    if url.include?('youtu.be')
      url.split('/').last
    else
      url.split('=').last
    end
  end
end


text:
FROM       alpine:3.2
MAINTAINER David Cuadrado <dacuad@facebook.com>
EXPOSE     9001

ENV  GOPATH /go
ENV APPPATH $GOPATH/src/github.com/lowstz/mongodb_exporter
COPY . $APPPATH
RUN apk add --update -t build-deps go git mercurial libc-dev gcc libgcc \
    && cd $APPPATH && go get -d && go build -o /bin/mongodb_exporter \
    && apk del --purge build-deps && rm -rf $GOPATH

ENTRYPOINT [ "/bin/mongodb_exporter" ]


text: export { default } from 'ember-fhir/models/procedure-request-requester';


text:
package com.orientechnologies.orient.core.iterator;

import java.util.HashSet;
import java.util.Set;

import com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx;
import com.orientechnologies.orient.core.metadata.schema.OClass;
import com.orientechnologies.orient.core.metadata.schema.OSchema;
import com.orientechnologies.orient.core.metadata.schema.OType;
import com.orientechnologies.orient.core.metadata.schema.clusterselection.ODefaultClusterSelectionStrategy;
import com.orientechnologies.orient.core.record.impl.ODocument;
import com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

/**
 * @author Artem Loginov
 */
@Test
public class ClassIteratorTest {
  private static final boolean       RECREATE_DATABASE = true;
  private static ODatabaseDocumentTx db                = null;
  private Set<String>                names;

  @BeforeMethod
  public void setUp() throws Exception {
    initializeDatabase();

    // Insert some data
    names = new HashSet<String>();
    names.add("Adam");
    names.add("Bob");
    names.add("Calvin");
    names.add("Daniel");

    for (String name : names) {
      createPerson(name);
    }
  }

  @AfterClass
  public void tearDown() throws Exception {
    if (!db.isClosed())
      db.close();
  }

  @Test
  public void testIteratorShouldReuseRecordWithoutNPE() {

    // Use class iterator.
    // browseClass() returns all documents in RecordID order
    // (including subclasses, which shouldn't exist for Person)
    final ORecordIteratorClass<ODocument> personIter = db.browseClass("Person");

    // Setting this to true causes the bug. Setting to false it works fine.
    personIter.setReuseSameRecord(true);

    int docNum = 0;
    // Explicit iterator loop.
    while (personIter.hasNext()) {
      final ODocument personDoc = personIter.next();
      Assert.assertTrue(names.contains(personDoc.field("First")));
      Assert.assertTrue(names.remove(personDoc.field("First")));
      System.out.printf("Doc %d: %s\n", docNum++, personDoc.toString());
    }

    Assert.assertTrue(names.isEmpty());
  }

  @Test
  public void testIteratorShouldReuseRecordWithoutNPEUsingForEach() throws Exception {
    // Use class iterator.
    // browseClass() returns all documents in RecordID order
    // (including subclasses, which shouldn't exist for Person)
    final ORecordIteratorClass<ODocument> personIter = db.browseClass("Person");

    // Setting this to true causes the bug. Setting to false it works fine.
    personIter.setReuseSameRecord(true);

    // Shorthand iterator loop.
    int docNum = 0;
    for (final ODocument personDoc : personIter) {
      Assert.assertTrue(names.contains(personDoc.field("First")));
      Assert.assertTrue(names.remove(personDoc.field("First")));

      System.out.printf("Doc %d: %s\n", docNum++, personDoc.toString());
    }

    Assert.assertTrue(names.isEmpty());
  }

  @Test
  public void testDescendentOrderIteratorWithMultipleClusters() throws Exception {
    final OClass personClass = db.getMetadata().getSchema().getClass("Person");

    // empty old cluster but keep it attached
    personClass.truncate();

    // reload the data in a new 'test' cluster
    int testClusterId = db.addCluster("test");
    personClass.addClusterId(testClusterId);
    personClass.setClusterSelection(new ODefaultClusterSelectionStrategy());
    personClass.setDefaultClusterId(testClusterId);

    for (String name : names) {
      createPerson(name);
    }

    // Use descending class iterator.
    final ORecordIteratorClass<ODocument> personIter =
        new ORecordIteratorClassDescendentOrder<ODocument>(
db, db, "Person", true,
        false, LOCKING_STRATEGY.DEFAULT);

    personIter.setRange(null, null); // open range

    int docNum = 0;
    // Explicit iterator loop.
    while (personIter.hasNext()) {
      final ODocument personDoc = personIter.next();
      Assert.assertTrue(names.contains(personDoc.field("First")));
      Assert.assertTrue(names.remove(personDoc.field("First")));
      System.out.printf("Doc %d: %s\n", docNum++, personDoc.toString());
    }

    Assert.assertTrue(names.isEmpty());
  }

  private static void initializeDatabase() {
    db = new ODatabaseDocumentTx("memory:" + ClassIteratorTest.class.getSimpleName());
    if (db.exists() && RECREATE_DATABASE) {
      db.open("admin", "admin");
      db.drop();
      System.out.println("Dropped database.");
    }
    if (!db.exists()) {
      db.create();
      System.out.println("Created database.");

      final OSchema schema = db.getMetadata().getSchema();

      // Create Person class
      final OClass personClass = schema.createClass("Person");
      personClass.createProperty("First", OType.STRING).setMandatory(true).setNotNull(true).setMin("1");

      System.out.println("Created schema.");
    } else {
      db.open("admin", "admin");
    }
  }

  private static void createPerson(final String first) {
    // Create Person document
    final ODocument personDoc = db.newInstance("Person");
    personDoc.field("First", first);
    personDoc.save();
  }
}


text:
package com.intel.analytics.bigdl.nn

import com.intel.analytics.bigdl.tensor.Tensor
import org.scalatest.{Matchers, FlatSpec}
import com.intel.analytics.bigdl.numeric.NumericFloat

@com.intel.analytics.bigdl.tags.Parallel
class DenseToSparseSpec extends FlatSpec with Matchers  {
  "A DenseToSparse forward" should "generate correct output" in {
    val dts = DenseToSparse()
    val denseTensor = Tensor.range(1, 12, 1)
    val output = dts.forward(denseTensor)
    val exceptedOutput = Tensor.sparse(Array(Array.range(0, 12)),
      Array.range(1, 13).map(_.toFloat), Array(12))
    output should be (exceptedOutput)
  }

  "A DenseToSparse backward" should "generate correct output" in {
    val dts = DenseToSparse()
    val input = Tensor.range(1, 12, 1)
    val sparseTensor = Tensor.sparse(Array(Array.range(0, 12)),
      Array.range(1, 13).map(_.toFloat), Array(12))
    val output = dts.backward(input, sparseTensor)
    val exceptedOutput = Tensor.range(1, 12, 1)
    output should be (exceptedOutput)
  }

}


text:
// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.

using System.Linq;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
using Microsoft.CodeAnalysis.OrganizeImports;
using Roslyn.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Organizing
{
    public class OrganizeUsingsTests
    {
        protected async Task CheckAsync(string initial, string final, bool specialCaseSystem, CSharpParseOptions options = null)
        {
            using (var workspace = await TestWorkspace.CreateCSharpAsync(initial))
            {
                var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
                var newRoot = await (await OrganizeImportsService.OrganizeImportsAsync(document, specialCaseSystem)).GetSyntaxRootAsync();
                Assert.Equal(final.NormalizeLineEndings(), newRoot.ToFullString());
            }
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task EmptyFile()
        {
            await CheckAsync(string.Empty, string.Empty, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task SingleUsingStatement()
        {
            var initial = @"using A;";
            var final = initial;
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task AliasesAtBottom()
        {
            var initial =
@"using A = B;
using C;
using D = E;
using F;";

            var final =
@"using C;
using F;
using A = B;
using D = E;
";

            await CheckAsync(initial, final, false);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task UsingStaticsBetweenUsingsAndAliases()
        {
            var initial =
@"using static System.Convert;
using A = B;
using C;
using Z;
using D = E;
using static System.Console;
using F;";

            var final =
@"using C;
using F;
using Z;
using static System.Console;
using static System.Convert;
using A = B;
using D = E;
";

            await CheckAsync(initial, final, false);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task NestedStatements()
        {
            var initial =
@"using B;
using A;

namespace N
{
  using D;
  using C;

  namespace N1
  {
    using F;
    using E;
  }

  namespace N2
  {
    using H;
    using G;
  }
}

namespace N3
{
  using J;
  using I;

  namespace N4
  {
    using L;
    using K;
  }

  namespace N5
  {
    using N;
    using M;
  }
}";

            var final =
@"using A;
using B;

namespace N
{
  using C;
  using D;

  namespace N1
  {
    using E;
    using F;
  }

  namespace N2
  {
    using G;
    using H;
  }
}

namespace N3
{
  using I;
  using J;

  namespace N4
  {
    using K;
    using L;
  }

  namespace N5
  {
    using M;
    using N;
  }
}";
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task SpecialCaseSystem()
        {
            var initial =
@"using M2;
using M1;
using System.Linq;
using System;";

            var final =
@"using System;
using System.Linq;
using M1;
using M2;
";
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task SpecialCaseSystemWithUsingStatic()
        {
            var initial =
@"using M2;
using M1;
using System.Linq;
using System;
using static Microsoft.Win32.Registry;
using static System.BitConverter;";

            var final =
@"using System;
using System.Linq;
using M1;
using M2;
using static System.BitConverter;
using static Microsoft.Win32.Registry;
";
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotSpecialCaseSystem()
        {
            var initial =
@"using M2;
using M1;
using System.Linq;
using System;";

            var final =
@"using M1;
using M2;
using System;
using System.Linq;
";

            await CheckAsync(initial, final, false);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotSpecialCaseSystemWithUsingStatics()
        {
            var initial =
@"using M2;
using M1;
using System.Linq;
using System;
using static Microsoft.Win32.Registry;
using static System.BitConverter;";

            var final =
@"using M1;
using M2;
using System;
using System.Linq;
using static Microsoft.Win32.Registry;
using static System.BitConverter;";
            await CheckAsync(initial, final, false);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task IndentationAfterSorting()
        {
            var initial =
@"namespace A
{
    using V.W;
    using U;
    using X.Y.Z;

    class B { }
}

namespace U { }
namespace V.W { }
namespace X.Y.Z { }";

            var final =
@"namespace A
{
    using U;
    using V.W;
    using X.Y.Z;

    class B { }
}

namespace U { }
namespace V.W { }
namespace X.Y.Z { }";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotTouchCommentsAtBeginningOfFile1()
        {
            var initial =
@"// Copyright (c) Microsoft Corporation.  All rights reserved.

using B;
// I like namespace A
using A;

namespace A { }
namespace B { }";

            var final =
@"// Copyright (c) Microsoft Corporation.  All rights reserved.

// I like namespace A
using A;
using B;

namespace A { }
namespace B { }";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotTouchCommentsAtBeginningOfFile2()
        {
            var initial =
@"

using B;
/* I like namespace A */
using A;

namespace A { }
namespace B { }";

            var final =
@"/* Copyright (c) Microsoft Corporation.  All rights reserved. */

/* I like namespace A */
using A;
using B;

namespace A { }
namespace B { }";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotTouchCommentsAtBeginningOfFile3()
        {
            var initial =
@"// Copyright (c) Microsoft Corporation.  All rights reserved.

using B;
/// I like namespace A
using A;

namespace A { }
namespace B { }";

            var final =
@"// Copyright (c) Microsoft Corporation.  All rights reserved.

/// I like namespace A
using A;
using B;

namespace A { }
namespace B { }";

            await CheckAsync(initial, final, true);
        }

        [WorkItem(2480, "https://github.com/dotnet/roslyn/issues/2480")]
        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoTouchCommentsAtBeginningOfFile1()
        {
            var initial =
@"// Copyright (c) Microsoft Corporation.  All rights reserved.
using B;
// I like namespace A
using A;

namespace A { }
namespace B { }";

            var final =
@"// Copyright (c) Microsoft Corporation.  All rights reserved.
// I like namespace A
using A;
using B;

namespace A { }
namespace B { }";

            await CheckAsync(initial, final, true);
        }

        [WorkItem(2480, "https://github.com/dotnet/roslyn/issues/2480")]
        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoTouchCommentsAtBeginningOfFile2()
        {
            var initial =
@"/* Copyright (c) Microsoft Corporation.  All rights reserved. */
using B;
/* I like namespace A */
using A;

namespace A { }
namespace B { }";

            var final =
@"/* Copyright (c) Microsoft Corporation.  All rights reserved. */
/* I like namespace A */
using A;
using B;

namespace A { }
namespace B { }";

            await CheckAsync(initial, final, true);
        }

        [WorkItem(2480, "https://github.com/dotnet/roslyn/issues/2480")]
        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoTouchCommentsAtBeginningOfFile3()
        {
            var initial =
@"/// Copyright (c) Microsoft Corporation.  All rights reserved.
using B;
/// I like namespace A
using A;

namespace A { }
namespace B { }";

            var final =
@"/// I like namespace A
using A;
/// Copyright (c) Microsoft Corporation.  All rights reserved.
using B;

namespace A { }
namespace B { }";

            await CheckAsync(initial, final, true);
        }

        [WorkItem(2480, "https://github.com/dotnet/roslyn/issues/2480")]
        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task CommentsNotAtTheStartOfTheFile1()
        {
            var initial =
@"namespace N
{
    // attached to System.Text
    using System.Text;
    // attached to System
    using System;
}";

            var final =
@"namespace N
{
    // attached to System
    using System;
    // attached to System.Text
    using System.Text;
}";

            await CheckAsync(initial, final, true);
        }

        [WorkItem(2480, "https://github.com/dotnet/roslyn/issues/2480")]
        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task CommentsNotAtTheStartOfTheFile2()
        {
            var initial =
@"namespace N
{
    // not attached to System.Text

    using System.Text;
    // attached to System
    using System;
}";

            var final =
@"namespace N
{
    // not attached to System.Text

    // attached to System
    using System;
    using System.Text;
}";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotSortIfEndIfBlocks()
        {
            var initial =
@"using D;
#if MYCONFIG
using C;
#else
using B;
#endif
using A;

namespace A { }
namespace B { }
namespace C { }
namespace D { }";

            var final = initial;
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task ExternAliases()
        {
            var initial =
@"extern alias Z;
extern alias Y;
extern alias X;
using C;
using U = C.L.T;
using O = A.J;
using A;
using W = A.J.R;
using N = B.K;
using V = B.K.S;
using M = C.L;
using B;

namespace A
{
    namespace J
    {
        class R { }
    }

}
namespace B
{
    namespace K
    {
        struct S { }
    }
}
namespace C
{
    namespace L
    {
        struct T { }
    }
}";

            var final =
@"extern alias X;
extern alias Y;
extern alias Z;
using A;
using B;
using C;
using M = C.L;
using N = B.K;
using O = A.J;
using U = C.L.T;
using V = B.K.S;
using W = A.J.R;

namespace A
{
    namespace J
    {
        class R { }
    }

}
namespace B
{
    namespace K
    {
        struct S { }
    }
}
namespace C
{
    namespace L
    {
        struct T { }
    }
}";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DuplicateUsings()
        {
            var initial =
@"using A;
using A;";

            var final = initial;

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task InlineComments()
        {
            var initial =
@"/*00*/using/*01*/D/*02*/;/*03*/
/*04*/using/*05*/C/*06*/;/*07*/
/*08*/using/*09*/A/*10*/;/*11*/
/*12*/using/*13*/B/*14*/;/*15*/
/*16*/";

            var final =
@"/*08*/using/*09*/A/*10*/;/*11*/
/*12*/using/*13*/B/*14*/;/*15*/
/*04*/using/*05*/C/*06*/;/*07*/
/*00*/using/*01*/D/*02*/;/*03*/
/*16*/";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task AllOnOneLine()
        {
            var initial =
@"using C; using B; using A;";

            var final =
@"using A;
using B;
using C; ";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task InsideRegionBlock()
        {
            var initial =
@"#region Using directives
using C;
using A;
using B;
#endregion

class Class1
{
}";
            var final =
@"#region Using directives
using A;
using B;
using C;
#endregion

class Class1
{
}";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task NestedRegionBlock()
        {
            var initial =
@"using C;
#region Z
using A;
#endregion
using B;";

            var final = initial;

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task MultipleRegionBlocks()
        {
            var initial =
@"#region Using directives
using C;
#region Z
using A;
#endregion
using B;
#endregion";

            var final = initial;

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task InterleavedNewlines()
        {
            var initial =
@"using B;

using A;

using C;

class D { }";

            var final =
@"using A;
using B;
using C;

class D { }";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task InsideIfEndIfBlock()
        {
            var initial =
@"#if !X
using B;
using A;
using C;
#endif";

            var final =
@"#if !X
using A;
using B;
using C;
#endif";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task IfEndIfBlockAbove()
        {
            var initial =
@"#if !X
using C;
using B;
using F;
#endif
using D;
using A;
using E;";

            var final = initial;
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task IfEndIfBlockMiddle()
        {
            var initial =
@"using D;
using A;
using H;
#if !X
using C;
using B;
using I;
#endif
using F;
using E;
using G;";

            var final = initial;
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task IfEndIfBlockBelow()
        {
            var initial =
@"using D;
using A;
using E;
#if !X
using C;
using B;
using F;
#endif";

            var final = initial;
            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task Korean()
        {
            var initial =
@"using 하;
using 파;
using 타;
using 카;
using 차;
using 자;
using 아;
using 사;
using 바;
using 마;
using 라;
using 다;
using 나;
using 가;";

            var final =
@"using 가;
using 나;
using 다;
using 라;
using 마;
using 바;
using 사;
using 아;
using 자;
using 차;
using 카;
using 타;
using 파;
using 하;
";

            await CheckAsync(initial, final, true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotSpecialCaseSystem1()
        {
            var initial =
@"using B;
using System.Collections.Generic;
using C;
using _System;
using SystemZ;
using D.System;
using System;
using System.Collections;
using A;";

            var final =
@"using _System;
using A;
using B;
using C;
using D.System;
using System;
using System.Collections;
using System.Collections.Generic;
using SystemZ;
";

            await CheckAsync(initial, final, specialCaseSystem: false);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task DoNotSpecialCaseSystem2()
        {
            var initial =
@"extern alias S;
extern alias R;
extern alias T;
using B;
using System.Collections.Generic;
using C;
using _System;
using SystemZ;
using Y = System.UInt32;
using Z = System.Int32;
using D.System;
using System;
using N = System;
using M = System.Collections;
using System.Collections;
using A;";

            var final =
@"extern alias R;
extern alias S;
extern alias T;
using _System;
using A;
using B;
using C;
using D.System;
using System;
using System.Collections;
using System.Collections.Generic;
using SystemZ;
using M = System.Collections;
using N = System;
using Y = System.UInt32;
using Z = System.Int32;
";

            await CheckAsync(initial, final, specialCaseSystem: false);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task CaseSensitivity1()
        {
            var initial =
@"using Bb;
using B;
using bB;
using b;
using Aa;
using a;
using A;
using aa;
using aA;
using AA;
using bb;
using BB;
using bBb;
using bbB;
using あ;
using ア;
using ア;
using ああ;
using あア;
using あア;
using アあ;
using cC;
using Cc;
using アア;
using アア;
using アあ;
using アア;
using アア;
using BBb;
using BbB;
using bBB;
using BBB;
using c;
using C;
using bbb;
using Bbb;
using cc;
using cC;
using CC;

// If Kana is sensitive あ != ア, if Kana is insensitive あ == ア.
// If Width is sensitiveア != ア, if Width is insensitive ア == ア.";

            var final =
@"using a;
using A;
using aa;
using aA;
using Aa;
using AA;
using b;
using B;
using bb;
using bB;
using Bb;
using BB;
using bbb;
using bbB;
using bBb;
using bBB;
using Bbb;
using BbB;
using BBb;
using BBB;
using c;
using C;
using cc;
using cC;
using cC;
using Cc;
using CC;
using ア;
using ア;
using あ;
using アア;
using アア;
using アア;
using アア;
using アあ;
using アあ;
using あア;
using あア;
using ああ;

// If Kana is sensitive あ != ア, if Kana is insensitive あ == ア.
// If Width is sensitiveア != ア, if Width is insensitive ア == ア.";
            await CheckAsync(initial, final, specialCaseSystem: true);
        }

        [Fact, Trait(Traits.Feature, Traits.Features.Organizing)]
        public async Task CaseSensitivity2()
        {
            var initial =
@"using あ;
using ア;
using ア;
using ああ;
using あア;
using あア;
using アあ;
using アア;
using アア;
using アあ;
using アア;
using アア;";

            var final =
@"using ア;
using ア;
using あ;
using アア;
using アア;
using アア;
using アア;
using アあ;
using アあ;
using あア;
using あア;
using ああ;
";

            await CheckAsync(initial, final, specialCaseSystem: true);
        }
    }
}


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

  <groupId>com.etsy.sahale</groupId>
  <artifactId>flowtracker</artifactId>
  <version>0.5.4-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>flowtracker</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.basedir>.</project.basedir>
    <!-- Users should adjust to match their own distribution and build -->
    <scala.version>2.9.3</scala.version>
    <!-- Users should adjust to match their own distribution and build -->
    <hadoop.version>2.5.0-cdh5.3.0</hadoop.version>
    <!-- Users should adjust to match their own distribution and build -->
    <cascading.version>2.6.1</cascading.version>
  </properties>

  <repositories>
    <repository>
      <id>sonatype-oss</id>
      <url>http://oss.sonatype.org/content/repositories/releases/</url>
    </repository>

    <repository>
      <id>conjars.org</id>
      <url>http://conjars.org/repo</url>
    </repository>

    <repository>
      <id>cloudera</id>
      <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
    </repository>
  </repositories>

  <pluginRepositories>
    <pluginRepository>
      <id>sonatype-oss</id>
      <url>http://oss.sonatype.org/content/repositories/releases/</url>
    </pluginRepository>
  </pluginRepositories>

  <distributionManagement>
    <snapshotRepository>
      <id>snapshots</id>
      <name>Archiva Internal Snapshot Repository</name>
      <url>http://ivy.etsycorp.com/repository/snapshots/</url>
    </snapshotRepository>
  </distributionManagement>

  <build>
    <resources>
      <resource>
        <directory>${project.basedir}/src/main/resources</directory>
        <filtering>true</filtering>
      </resource>
    </resources>
    <testResources>
      <testResource>
        <directory>${project.basedir}/src/test/resources</directory>
      </testResource>
    </testResources>

      <plugins>
        <!-- Raise the default heap and thread stack sizes because scalac is a piece of crap -->
        <plugin>
          <groupId>org.scala-tools</groupId>
          <artifactId>maven-scala-plugin</artifactId>
          <version>2.9.1</version>
          <executions>
            <execution>
              <goals>
                <goal>compile</goal>
                <goal>testCompile</goal>
              </goals>
            </execution>
          </executions>
          <configuration>
          </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.4</version>
            <configuration>
              <tarLongFileMode>gnu</tarLongFileMode>
            </configuration>
            <executions>
              <execution>
                <id>assemble-fatjar</id>
                <configuration>
                  <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                  </descriptorRefs>
                </configuration>
                <phase>package</phase>
                <goals>
                  <goal>single</goal>
                </goals>
              </execution>
            </executions>
        </plugin>

        <!-- disable surefire -->
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.7</version>
          <configuration>
            <skipTests>true</skipTests>
          </configuration>
        </plugin>
        <!-- enable scalatest -->
        <plugin>
          <groupId>org.scalatest</groupId>
          <artifactId>scalatest-maven-plugin</artifactId>
          <version>1.0-RC2</version>
          <configuration>
            <reportsDirectory>${project.build.directory}/surefire-reports</reportsDirectory>
            <junitxml>.</junitxml>
            <filereports>WDF TestSuite.txt</filereports>
          </configuration>
          <executions>
            <execution>
              <id>test</id>
              <goals>
                <goal>test</goal>
              </goals>
            </execution>
          </executions>
        </plugin>
      </plugins>
  </build>

  <dependencies>
    <!-- hadoop-client is a nice single-import for CDH distributions.
         If you use vanilla Apache Hadoop distribution on your cluster,
         you might need to add additional dependency tags for packages like
         hadoop-common, hadoop-hdfs, and hadoop-mapreduce. See your individual
         Hadoop distro documentation for details.
      -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-client</artifactId>
      <version>${hadoop.version}</version>
    </dependency>

    <dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>${scala.version}</version>
    </dependency>

    <dependency>
      <groupId>com.esotericsoftware.kryo</groupId>
      <artifactId>kryo</artifactId>
      <version>2.21</version>
    </dependency>

    <dependency>
      <groupId>cascading.kryo</groupId>
      <artifactId>cascading.kryo</artifactId>
      <version>0.4.7</version>
    </dependency>

   <dependency>
      <groupId>io.backchat.jerkson</groupId>
      <artifactId>jerkson_2.9.2</artifactId>
      <version>0.7.0</version>
    </dependency>

    <dependency>
      <groupId>cascading</groupId>
      <artifactId>cascading-core</artifactId>
      <version>${cascading.version}</version>
    </dependency>

    <dependency>
      <groupId>cascading</groupId>
      <artifactId>cascading-platform</artifactId>
      <version>${cascading.version}</version>
    </dependency>

    <dependency>
      <groupId>cascading</groupId>
      <artifactId>cascading-hadoop</artifactId>
      <version>${cascading.version}</version>
    </dependency>

    <dependency>
      <groupId>org.apache.httpcomponents</groupId>
      <artifactId>httpclient</artifactId>
      <version>4.1.1</version>
    </dependency>

    <dependency>
      <groupId>commons-httpclient</groupId>
      <artifactId>commons-httpclient</artifactId>
      <version>3.0.1</version>
    </dependency>

    <dependency>
      <groupId>com.twitter</groupId>
      <artifactId>scalding-core_2.9.2</artifactId>
      <version>0.8.5</version>
    </dependency>

    <!-- Test dependencies. subject to change/still under construction -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.scalatest</groupId>
      <artifactId>scalatest_2.9.3</artifactId>
      <version>2.0.M5b</version>
      <scope>test</scope>
    </dependency>

  </dependencies>

</project>


text:
var x = {
    a: < <T>(x: T) => T > ((x: any) => 1),
    b: <T>(x: T) => { x }
}
x.a<string>(1); // bug was that this caused 'Could not find symbol T' on return type T in the type assertion on x.a's definition
x.b<string>(); // error

//// [typeAssertionToGenericFunctionType.js]
var x = {
    a: (function (x) { return 1; }),
    b: function (x) {
        x;
    }
};
x.a(1); // bug was that this caused 'Could not find symbol T' on return type T in the type assertion on x.a's definition
x.b(); // error


text:
readonly WD_VERSION=0.5.0

# colors
readonly WD_BLUE="\033[96m"
readonly WD_GREEN="\033[92m"
readonly WD_YELLOW="\033[93m"
readonly WD_RED="\033[91m"
readonly WD_NOC="\033[m"

## functions

# helpers
wd_yesorno()
{
    # variables
    local question="${1}"
    local prompt="${question} "
    local yes_RETVAL="0"
    local no_RETVAL="3"
    local RETVAL=""
    local answer=""

    # read-eval loop
    while true ; do
        printf $prompt
        read -r answer

        case ${answer:=${default}} in
            "Y"|"y"|"YES"|"yes"|"Yes" )
                RETVAL=${yes_RETVAL} && \
                    break
                ;;
            "N"|"n"|"NO"|"no"|"No" )
                RETVAL=${no_RETVAL} && \
                    break
                ;;
            * )
                echo "Please provide a valid answer (y or n)"
                ;;
        esac
    done

    return ${RETVAL}
}

wd_print_msg()
{
    if [[ -z $wd_quiet_mode ]]
    then
        local color=$1
        local msg=$2

        if [[ $color == "" || $msg == "" ]]
        then
            print " ${WD_RED}*${WD_NOC} Could not print message. Sorry!"
        else
            print " ${color}*${WD_NOC} ${msg}"
        fi
    fi
}

wd_print_usage()
{
    command cat <<- EOF
Usage: wd [command] [point]

Commands:
    <point>         Warps to the directory specified by the warp point
    <point> <path>  Warps to the directory specified by the warp point with path appended
    add <point>     Adds the current working directory to your warp points
    add             Adds the current working directory to your warp points with current directory's name
    rm <point>      Removes the given warp point
    rm              Removes the given warp point with current directory's name
    show <point>    Print path to given warp point
    show            Print warp points to current directory
    list            Print all stored warp points
    ls  <point>     Show files from given warp point (ls)
    path <point>    Show the path to given warp point (pwd)
    clean           Remove points warping to nonexistent directories (will prompt unless --force is used)

    -v | --version  Print version
    -d | --debug    Exit after execution with exit codes (for testing)
    -c | --config   Specify config file (default ~/.warprc)
    -q | --quiet    Suppress all output
    -f | --force    Allows overwriting without warning (for add & clean)

    help            Show this extremely helpful text
EOF
}

wd_exit_fail()
{
    local msg=$1

    wd_print_msg "$WD_RED" "$msg"
    WD_EXIT_CODE=1
}

wd_exit_warn()
{
    local msg=$1

    wd_print_msg "$WD_YELLOW" "$msg"
    WD_EXIT_CODE=1
}

wd_getdir()
{
    local name_arg=$1

    point=$(wd_show "$name_arg")
    dir=${point:28+$#name_arg+7}

    if [[ -z $name_arg ]]; then
        wd_exit_fail "You must enter a warp point"
        break
    elif [[ -z $dir ]]; then
        wd_exit_fail "Unknown warp point '${name_arg}'"
        break
    fi
}

# core

wd_warp()
{
    local point=$1
    local sub=$2

    if [[ $point =~ "^\.+$" ]]
    then
        if [[ $#1 < 2 ]]
        then
            wd_exit_warn "Warping to current directory?"
        else
            (( n = $#1 - 1 ))
            cd -$n > /dev/null
        fi
    elif [[ ${points[$point]} != "" ]]
    then
        if [[ $sub != "" ]]
        then
            cd ${points[$point]/#\~/$HOME}/$sub
        else
            cd ${points[$point]/#\~/$HOME}
        fi
    else
        wd_exit_fail "Unknown warp point '${point}'"
    fi
}

wd_add()
{
    local point=$1
    local force=$2
    cmdnames=(add rm show list ls path clean help)

    if [[ $point == "" ]]
    then
        point=$(basename "$PWD")
    fi

    if [[ $point =~ "^[\.]+$" ]]
    then
        wd_exit_fail "Warp point cannot be just dots"
    elif [[ $point =~ "[[:space:]]+" ]]
    then
        wd_exit_fail "Warp point should not contain whitespace"
    elif [[ $point =~ : ]] || [[ $point =~ / ]]
    then
        wd_exit_fail "Warp point contains illegal character (:/)"
    elif (($cmdnames[(Ie)$point]))
    then
        wd_exit_fail "Warp point name cannot be a wd command (see wd -h for a full list)"
    elif [[ ${points[$point]} == "" ]] || [ ! -z "$force" ]
    then
        wd_remove "$point" > /dev/null
        printf "%q:%s\n" "${point}" "${PWD/#$HOME/~}" >> "$WD_CONFIG"
        if (whence sort >/dev/null); then
            local config_tmp=$(mktemp "${TMPDIR:-/tmp}/wd.XXXXXXXXXX")
            # use 'cat' below to ensure we respect $WD_CONFIG as a symlink
            command sort -o "${config_tmp}" "$WD_CONFIG" && command cat "${config_tmp}" >| "$WD_CONFIG" && command rm "${config_tmp}"
        fi

        wd_export_static_named_directories

        wd_print_msg "$WD_GREEN" "Warp point added"

        # override exit code in case wd_remove did not remove any points
        # TODO: we should handle this kind of logic better
        WD_EXIT_CODE=0
    else
        wd_exit_warn "Warp point '${point}' already exists. Use 'add --force' to overwrite."
    fi
}

wd_remove()
{
    local point_list=$1

    if [[ "$point_list" == "" ]]
    then
        point_list=$(basename "$PWD")
    fi

    for point_name in $point_list ; do
        if [[ ${points[$point_name]} != "" ]]
        then
            local config_tmp=$(mktemp "${TMPDIR:-/tmp}/wd.XXXXXXXXXX")
            # Copy and delete in two steps in order to preserve symlinks
            if sed -n "/^${point_name}:.*$/!p" "$WD_CONFIG" >| "$config_tmp" && command cp "$config_tmp" "$WD_CONFIG" && command rm "$config_tmp"
            then
                wd_print_msg "$WD_GREEN" "Warp point removed"
            else
                wd_exit_fail "Something bad happened! Sorry."
            fi
        else
            wd_exit_fail "Warp point was not found"
        fi
    done
}

wd_list_all()
{
    wd_print_msg "$WD_BLUE" "All warp points:"

    entries=$(sed "s:${HOME}:~:g" "$WD_CONFIG")

    max_warp_point_length=0
    while IFS= read -r line
    do
        arr=(${(s,:,)line})
        key=${arr[1]}

        length=${#key}
        if [[ length -gt max_warp_point_length ]]
        then
            max_warp_point_length=$length
        fi
    done <<< "$entries"

    while IFS= read -r line
    do
        if [[ $line != "" ]]
        then
            arr=(${(s,:,)line})
            key=${arr[1]}
            val=${line#"${arr[1]}:"}

            if [[ -z $wd_quiet_mode ]]
            then
                printf "%${max_warp_point_length}s  ->  %s\n" "$key" "$val"
            fi
        fi
    done <<< "$entries"
}

wd_ls()
{
    wd_getdir "$1"
    ls "${dir/#\~/$HOME}"
}

wd_path()
{
    wd_getdir "$1"
    echo "$(echo "$dir" | sed "s:~:${HOME}:g")"
}

wd_show()
{
    local name_arg=$1
    # if there's an argument we look up the value
    if [[ -n $name_arg ]]
    then
        if [[ -z $points[$name_arg] ]]
        then
            wd_print_msg "$WD_BLUE" "No warp point named $name_arg"
        else
            wd_print_msg "$WD_GREEN" "Warp point: ${WD_GREEN}$name_arg${WD_NOC} -> $points[$name_arg]"
        fi
    else
        # hax to create a local empty array
        local wd_matches
        wd_matches=()
        # do a reverse lookup to check whether PWD is in $points
        PWD="${PWD/$HOME/~}"
        if [[ ${points[(r)$PWD]} == "$PWD" ]]
        then
            for name in ${(k)points}
            do
                if [[ $points[$name] == "$PWD" ]]
                then
                    wd_matches[$(($#wd_matches+1))]=$name
                fi
            done

            wd_print_msg "$WD_BLUE" "$#wd_matches warp point(s) to current directory: ${WD_GREEN}$wd_matches${WD_NOC}"
        else
            wd_print_msg "$WD_YELLOW" "No warp point to $(echo "$PWD" | sed "s:$HOME:~:")"
        fi
    fi
}

wd_clean() {
    local force=$1
    local count=0
    local wd_tmp=""

    while read -r line
    do
        if [[ $line != "" ]]
        then
            arr=(${(s,:,)line})
            key=${arr[1]}
            val=${arr[2]}

            if [ -d "${val/#\~/$HOME}" ]
            then
                wd_tmp=$wd_tmp"\n"`echo "$line"`
            else
                wd_print_msg "$WD_YELLOW" "Nonexistent directory: ${key} -> ${val}"
                count=$((count+1))
            fi
        fi
    done < "$WD_CONFIG"

    if [[ $count -eq 0 ]]
    then
        wd_print_msg "$WD_BLUE" "No warp points to clean, carry on!"
    else
        if [ ! -z "$force" ] || wd_yesorno "Removing ${count} warp points. Continue? (y/n)"
        then
            echo "$wd_tmp" >! "$WD_CONFIG"
            wd_print_msg "$WD_GREEN" "Cleanup complete. ${count} warp point(s) removed"
        else
            wd_print_msg "$WD_BLUE" "Cleanup aborted"
        fi
    fi
}

wd_export_static_named_directories() {
  if [[ ! -z $WD_EXPORT ]]
  then
    command grep '^[0-9a-zA-Z_-]\+:' "$WD_CONFIG" | sed -e "s,~,$HOME," -e 's/:/=/' | while read -r warpdir ; do
        hash -d "$warpdir"
    done
  fi
}

local WD_CONFIG=${WD_CONFIG:-$HOME/.warprc}
local WD_QUIET=0
local WD_EXIT_CODE=0
local WD_DEBUG=0

# Parse 'meta' options first to avoid the need to have them before
# other commands. The `-D` flag consumes recognized options so that
# the actual command parsing won't be affected.

zparseopts -D -E \
    c:=wd_alt_config -config:=wd_alt_config \
    q=wd_quiet_mode -quiet=wd_quiet_mode \
    v=wd_print_version -version=wd_print_version \
    d=wd_debug_mode -debug=wd_debug_mode \
    f=wd_force_mode -force=wd_force_mode

if [[ ! -z $wd_print_version ]]
then
    echo "wd version $WD_VERSION"
fi

if [[ ! -z $wd_alt_config ]]
then
    WD_CONFIG=$wd_alt_config[2]
fi

# check if config file exists
if [ ! -e "$WD_CONFIG" ]
then
    # if not, create config file
    touch "$WD_CONFIG"
else
    wd_export_static_named_directories
fi

# disable extendedglob for the complete wd execution time
setopt | grep -q extendedglob
wd_extglob_is_set=$?
[[ $wd_extglob_is_set ]] && setopt noextendedglob

# load warp points
typeset -A points
while read -r line
do
    arr=(${(s,:,)line})
    key=${arr[1]}
    # join the rest, in case the path contains colons
    val=${(j,:,)arr[2,-1]}

    points[$key]=$val
done < "$WD_CONFIG"

# get opts
args=$(getopt -o a:r:c:lhs -l add:,rm:,clean,list,ls:,path:,help,show -- $*)

# check if no arguments were given, and that version is not set
if [[ ($? -ne 0 || $#* -eq 0) && -z $wd_print_version ]]
then
    wd_print_usage

# check if config file is writeable
elif [ ! -w "$WD_CONFIG" ]
then
    # do nothing
    # can't run `exit`, as this would exit the executing shell
    wd_exit_fail "\'$WD_CONFIG\' is not writeable."

else
    # parse rest of options
    local wd_o
    for wd_o
    do
        case "$wd_o"
            in
            "-a"|"--add"|"add")
                wd_add "$2" "$wd_force_mode"
                break
                ;;
            "-e"|"export")
                wd_export_static_named_directories
                break
                ;;
            "-r"|"--remove"|"rm")
                # Passes all the arguments as a single string separated by whitespace to wd_remove
                wd_remove "${@:2}"
                break
                ;;
            "-l"|"list")
                wd_list_all
                break
                ;;
            "-ls"|"ls")
                wd_ls "$2"
                break
                ;;
            "-p"|"--path"|"path")
                wd_path "$2"
                break
                ;;
            "-h"|"--help"|"help")
                wd_print_usage
                break
                ;;
            "-s"|"--show"|"show")
                wd_show "$2"
                break
                ;;
            "-c"|"--clean"|"clean")
                wd_clean "$wd_force_mode"
                break
                ;;
            *)
                wd_warp "$wd_o" "$2"
                break
                ;;
            --)
                break
                ;;
        esac
    done
fi

## garbage collection
# if not, next time warp will pick up variables from this run
# remember, there's no sub shell

[[ $wd_extglob_is_set ]] && setopt extendedglob

unset wd_extglob_is_set
unset wd_warp
unset wd_add
unset wd_remove
unset wd_show
unset wd_list_all
unset wd_print_msg
unset wd_yesorno
unset wd_print_usage
unset wd_alt_config
unset wd_quiet_mode
unset wd_print_version
unset wd_export_static_named_directories
unset wd_o

unset args
unset points
unset val &> /dev/null # fixes issue #1

if [[ -n $wd_debug_mode ]]
then
    exit $WD_EXIT_CODE
else
    unset wd_debug_mode
fi


text:
layout: article
title: New Member
date: '2013-09-21T08:23:00.000-04:00'
author: bohanan.jp
tags:
- news
- worship
modified_time: '2013-09-21T08:23:00.541-04:00'
thumbnail: http://1.bp.blogspot.com/-qYTvdiOJu6k/UjxkLQkIdWI/AAAAAAAAAX0/7cgs6ukeGYE/s72-c/DSCF8205.JPG
blogger_id: tag:blogger.com,1999:blog-2749744699161548108.post-8666788515310525251
blogger_orig_url: http://christonthemountaintop.blogspot.com/2013/09/new-member.html
---

Welcome to Vivian (left), introduced by Molly (right) on this past Sunday! "Do you claim Jesus Christ as your Savior and promise to serve him as your Lord?"


text:
require 'helper'

class SplitterTest < Test::Unit::TestCase
  def test_truth
    assert true
  end
end

class Test_TaxonifiSplitterLexer < Test::Unit::TestCase

  def test_that_vanilla_new_succeed
    assert lexer = Taxonifi::Splitter::Lexer.new("foo")
  end

  def test_that_lexer_can_only_be_passed_valid_token_lists
    assert_raises Taxonifi::Splitter::SplitterError do
      lexer = Taxonifi::Splitter::Lexer.new("foo", :bar)
    end
  end

  def test_that_lexer_can_be_created_with_token_list_subsets
    assert lexer = Taxonifi::Splitter::Lexer.new("foo")
  end

end


text:
var createPlatformAloneOrdersReport = function(data) {
    for (order of data) order.values = order.values.sort(compareProductArray);
        dust.render("report/orders/alone/orderPanel.dust", {order: data}, function(err, out) {
            $("#OrderOnlyPlatformReport").empty();
            $("#orders-only-in-platform-header").text("Orders only in "+dumpTools.platform.name+" - "+data.length);
            $("#OrderOnlyPlatformReport").append(out);
        });
    };


text:
title: InstallerUI::getInstance — Autoconfiguration/Installation Support
package: install
packageTitle: Autoconfiguration/Installation Support
layout: default
className: InstallerUI
type: method
---

# InstallerUI::getInstance

## Synopsis

public static function InstallerUI::getInstance()


text:
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* All files in libchula are Copyright (C) 2014 Alvaro Lopez Ortega.
 *
 *   Authors:
 *     * Alvaro Lopez Ortega <alvaro@alobbs.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *
 *     * Redistributions in binary form must reproduce the above
 *       copyright notice, this list of conditions and the following
 *       disclaimer in the documentation and/or other materials provided
 *       with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#define CHULA_H_INSIDE

#include <libchula/cstrings.h>
#include <libchula/avl.h>
#include <libchula/avl_generic.h>
#include <libchula/buffer.h>
#include <libchula/common.h>
#include <libchula/crc32.h>
#include <libchula/debug.h>
#include <libchula/list.h>
#include <libchula/log.h>
#include <libchula/logger_fd.h>
#include <libchula/macros.h>
#include <libchula/md5.h>
#include <libchula/sha1.h>
#include <libchula/sha512.h>
#include <libchula/util.h>
#include <libchula/chula-ret.h>

#undef CHULA_H_INSIDE