const wrongValue = (arg) => {
     const acceptedValues = optionsBook[arg[0]].acceptedValues;
     if (contains(arg[0], optionsToCheck)) {
         return !contains(arg[1], acceptedValues);
     }
     return false;
 };
Exemple #2
0
 .filter(([keyword, not]) => {
   const lowerCase = !H.includesUpperCase(keyword)
   const hasMatch = lowerCase
     ? R.contains(keyword, lowTitle)
     : R.contains(keyword, title)
   return not
     ? !hasMatch
     : hasMatch
 }).length > 0
Exemple #3
0
export function items(suffix, lang) {
  if (!nconf.get('CHAMPIONGG_API')) return Promise.resolve(T('champgg_setup', lang));

  const suffix_split = suffix.split(' ');
  const position = R.last(suffix_split).toLowerCase();
  const champ = R.join(' ', R.slice(1, -1, suffix_split));
  const champ_reg = _verifyName(champ);

  if (position === champ) return Promise.resolve(`${T('lol_specify_position', lang)} ${T('lol_positions', lang)}`);

  const options = {
    url: `http://api.champion.gg/champion/${champ_reg}/items/finished/mostWins`
  };

  if (!R.contains(position, R.keys(positions))) return Promise.resolve(`${T('lol_unknown_position', lang)} **${position}**. ${T('lol_positions', lang)}`);
  let gg_position = positions[position];

  return _makeRequest(options)
    .then(body => {
      const results = R.zipObj(R.pluck('role')(body), body);
      if (!R.contains(gg_position, R.keys(results))) throw new Warning(`${T('no_item_sets', lang)} **${champ}** **${position}**.`);
      return results[gg_position];
    })
    .then(item_data => {
      const champ_data = lol_champs[champ_reg];
      if (!item_data.items.length) throw new Warning(`${T('no_item_sets', lang)} **${champ}** **${position}**.`);

      item_data.names = R.map(item_id => lol_items[item_id], item_data.items);
      item_data.champ_name = champ_data.name;
      item_data.image = champ_data.image;
      return phantom('lol_items', item_data, 500, 300);
    })
    .then(buf => ({upload: buf, filename: `items_${champ}_${gg_position}.png`}));
}
  new Yadda.FeatureFileSearch([testFeaturesDir]).each(function eachFeatureFile(file) {
    //if YADDA_FEATURE_GLOB exists then check if featureFile in YADDA_FEATURE_GLOB
    if (tstGlob.length > 0 && !R.contains(file, tstGlob)) {
      return;
    }

    featureFile(file, function featureFile(feature) {
      var libraries = testUtils.getLibraries(testFeaturesDir, testLibrariesDir, file, feature);
      var loadedLibraries = testUtils.requireLibraries(libraries);
      //initiate yadda and execute each scenario
      var yadda = new Yadda.Yadda(loadedLibraries, worldContext);
      scenarios(feature.scenarios, function scenario(scenarioParam) {
        //before test setup
        testUtils.before(before, worldContext);
        //run steps
        /*eslint max-nested-callbacks:0 */
        steps(scenarioParam.steps, function step(stepParam, done) {
          yadda.yadda(stepParam, done);
        });
        //after test teardown
        testUtils.after(after, worldContext);
      });
    });

    //afterAll
    testUtils.afterAll(after, worldContext, currentBrowser);
  });
Exemple #5
0
 triggerHook: (hookName: string, args: ?Object) => {
   if (!R.contains(hookName, this.newHooks)) {
     logger.debug(`trying to trigger the hook ${hookName} which not registered by this extension`);
     return;
   }
   HooksManagerInstance.triggerHook(hookName, args);
 },
Exemple #6
0
  constructor ({
    id: optsId,
    aliases: optsAliases = [],
    parameters: optsParameters = [],
    categories: optsCategories = [],
    description: optsDescription = ''
  }) {
    this._id = optsId
    this._aliases = optsAliases
    this._parameters = optsParameters
    this._categories = optsCategories
    this._description = optsDescription

    this._parent = null
    this._parentList = []
    this._finalized = false
    this._id = R.toLower(this._id)

    if (R.is(String, this._aliases)) {
      this._aliases = [this._aliases]
    }

    this._aliases = R.map(R.toLower, this._aliases)
    
    if (!R.contains(this._id, this._aliases)) {
      this._aliases.push(this._id)
    }

    if (R.is(String, this._parameters)) {
      this._parameters = [this._parameters]
    }
  }
Exemple #7
0
 R.forEach(line => {
   const var_name = line.expression.left.property.name;
   if (R.contains(var_name, ['championData', 'champion'])) {
     const data = escodegen.generate(line.expression.right, {format: {json: true}});
     parsed_data[var_name] = JSON.parse(data);
   }
 }, esprima.parse(script_tag).body);
Exemple #8
0
export function best(suffix, lang) {
  if (!nconf.get('CHAMPIONGG_API')) return Promise.resolve(T('champgg_setup', lang));

  const position = R.last(suffix.split(' ')).toLowerCase();

  if (!position || position === 'best') return Promise.resolve(`${T('lol_specify_position', lang)} ${T('lol_positions', lang)}`);
  if (!R.contains(position, R.keys(positions))) return Promise.resolve(`${T('lol_unknown_position', lang)} **${position}**. ${T('lol_positions', lang)}`);
  const gg_position = positions[position];

  const options = {
    url: `http://api.champion.gg/stats/role/${gg_position}/bestPerformance`,
    qs: {
      limit: 10,
      page: 1
    }
  };

  return _makeRequest(options)
    .then(R.prop('data'))
    .then(data => {
      return R.addIndex(R.map)((champ, idx) => `*${getOrdinal(idx + 1)}*. **${champ.name}** with a ${champ.general.winPercent}% winrate.`, data);
    })
    .then(R.prepend(`Sick! Here's the top 10 **statistically** best for **${gg_position}**:\n`))
    .then(R.join('\n'));
}
const selector = (
  standardId,
  risks,
  usersByIds,
  riskTypesByIds,
  departmentsByIds,
  standardsByIds,
) => compose(
  map(compose(
    over(lenses.type, id => riskTypesByIds[id]),
    over(lenses.originator, id => getUserWithFullName(usersByIds[id])),
    over(lenses.owner, id => getUserWithFullName(usersByIds[id])),
    over(lenses.departments, map(compose(
      renameKeys({ name: 'title' }),
      id => departmentsByIds[id],
    ))),
    over(lenses.standards, map(id => standardsByIds[id])),
    over(lenses.analysis, compose(
      over(lenses.executor, id => getUserWithFullName(usersByIds[id])),
      over(lenses.completedBy, id => getUserWithFullName(usersByIds[id])),
    )),
    renameKeys({
      ownerId: 'owner',
      originatorId: 'originator',
      typeId: 'type',
      departmentsIds: 'departments',
      standardsIds: 'standards',
    }),
  )),
  filter(where({ standardsIds: contains(standardId) })),
)(risks);
Exemple #10
0
export const isModuleDisabled = (name) => {
  if(!name) {
    throw new Error('Please submit a valid name');
  }
  const disabledModules = getKey('disabledModules') || [];
  return R.contains(name, disabledModules);
};
  render: function () {
    const node = this.props.node

    return (
      <div style={{paddingLeft: '20px'}}>
        {map(
          a => <TreeNodeAttribute attribute={a} owner={node} />,
          filter(
            pipe(
              prop('name'),
              toLower,
              contains(__, [
                'def',
                'diffusecolor',
                'orientation',
                'position',
                'render',
                'rotation',
                'scale',
                'translation',
                'url'
              ])
            ),
            node.attributes
          )
        )}
      </div>
    )
  }
 wordlist.forEach(function (word) {
   if (word.startsWith('#') && !R.contains(word, hashlist)) {
     word = word.trim();
     word = word.replace(/,\s*$/, '');
     hashlist.push(word);
   }
 });
export function onAdd(thread, id, tagId, communityId, selectedIds) {
  if (!R.contains(tagId, selectedIds)) {
    const args = { id, tagId, communityId }
    args.thread = R.toUpper(thread)
    sr71$.mutate(S.setTag, args)
  }
}
Exemple #14
0
export function best(bot, msg, suffix) {
  if (!nconf.get('CHAMPIONGG_API')) {
    return bot.sendMessage(msg.channel, T('champgg_setup', msg.author.lang));
  }

  const position = R.last(suffix.split(' ')).toLowerCase();

  if (!position || position === 'best') return bot.sendMessage(msg.channel, `${T('lol_specify_position', msg.author.lang)} ${T('lol_positions', msg.author.lang)}`);
  if (!R.contains(position, R.keys(positions))) return bot.sendMessage(msg.channel, `${T('lol_unknown_position', msg.author.lang)} **${position}**. ${T('lol_positions', msg.author.lang)}`);
  const gg_position = positions[position];

  const options = {
    url: `http://api.champion.gg/stats/role/${gg_position}/bestPerformance`,
    qs: {
      limit: 10,
      page: 1
    }
  };

  return _makeRequest(options)
    .then(R.prop('data'))
    .then(data => {
      return R.addIndex(R.map)((champ, idx) => `*${getOrdinal(idx + 1)}*. **${champ.name}** with a ${champ.general.winPercent}% winrate.`, data);
    })
    .then(R.prepend(`Sick! Here's the top 10 **statistically** best for **${gg_position}**:\n`))
    .then(R.join('\n'))
    .then(text => bot.sendMessage(msg.channel, text))
    .catch(err => {
      sentry(err, 'leagueoflegends', 'best');
      bot.sendMessage(msg.channel, `Error: ${err.message}`);
    });
}
const SuggestIcon = ({ round, suggestion: { raw, logo, cmd } }) => {
  /* const lowerRaw = R.toLower(raw) */
  if (cmd === 'theme') {
    return (
      <ThemeIconWrapper>
        <ThemeDot bg={themeCoverMap[raw]} />
      </ThemeIconWrapper>
    )
  }
  // doraemon cat icon, it's smaller then normal icons
  if (raw === 'doraemon_help') {
    return (
      <Wrapper>
        <DoraemonIcon src={logo} />
      </Wrapper>
    )
  }
  // normal icons
  return (
    <React.Fragment>
      {logo ? (
        <Wrapper>
          <Icon
            round={round}
            src={logo || DEFAULT_ICON}
            nonFill={R.contains(raw, NON_FILL_COMMUNITY)}
          />
        </Wrapper>
      ) : null}
    </React.Fragment>
  )
}
Exemple #16
0
  var stopTracking = function stopTracking() {
    var ms = (performanceNow() - start).toFixed(0);

    if (!R.contains(action.type, MIDDLEWARE_ACTION_IGNORE)) {
      client.sendCommand('redux.action.done', { type: type, ms: ms, action: action });
    }
  };
function validate (opts) {
  if (opts.category && !R.contains(opts.category, R.values(c.category))) {
    throw Error('Invalid category ' + opts.category);
  }

  opts.collection = opts.collection || c.collection.TOP_FREE_IOS;
  if (!R.contains(opts.collection, R.values(c.collection))) {
    throw Error(`Invalid collection ${opts.collection}`);
  }

  opts.num = opts.num || 50;
  if (opts.num > 200) {
    throw Error('Cannot retrieve more than 200 apps');
  }

  opts.country = opts.country || 'us';
}
var exitIfNotDevMode = function () {
    var isDevMode = R.anyPass([
        R.has('mod'),
        R.pipe(R.prop('_'), R.contains('tdd'))
    ]);

    if (!isDevMode(argv)) process.exit();
};
 var props = r.reduce(function(acc, prop) {
     var key = prop.key.name;
     var val = recast.print(prop.value).code;
     if (!r.contains(key, ignore)) {
         acc += "this." + key + " = " + val + ";\n";
     }
     return acc;
 }, "", findReactClassProps(ast)[0]);
Exemple #20
0
 literal: function(node) {
   var str = '' + node.options.value;
   if (!R.contains('.', str)) {
     str += '.0';
   }
   return { c: function() { return str; },
            subs: [] };
 },
Exemple #21
0
/**
 * Use BFS to find a path between two nodes in the circuit graph.
 *
 * @param startNode - Node to begin searching from.
 * @param destNode - Node to find path to.
 * @param circuit
 * @param circuit.nodes - Nodes in the graph.
 * @param circuit.models - Edges of the graph.
 * @param opts - Extra options.
 * @param opts.exclude - Don't look for paths through models with these IDs.
 * @param opts.types - If defined, only look for paths through these types.
 */
function isPathBetween(
  startNode, destNode,
  {nodes, models},
  {exclude, types} = {
    exclude: [],
    types: null
  }) {

  const visited = [],
        q = [];

  visited[startNode] = true;
  q.push(startNode);

  if (startNode === destNode) { return true; }

  while (q.length !== 0) {
    const n = q.shift();
    const tConnectors = nodes[n];

    for (let i = 0; i < tConnectors.length; i++) {
      const con = tConnectors[i];
      const id = con.viewID;

      if (R.contains(id, exclude)) {
        continue; // ignore paths through excluded models
      } else if (types && !R.contains(models[id].typeID, types)) {
        continue; // ignore paths that aren't through the given types
      }
      const connectedNodes = models[id].nodes;
      for (let j = 0; j < connectedNodes.length; j++) {
        const connectedNode = connectedNodes[j];
        if (connectedNode === destNode) {
          return true;
        }

        if (!visited[connectedNode]) {
          visited[connectedNode] = true;
          q.push(connectedNode);
        }
      }
    }
  }
  return false;
}
 {categories.map(c => (
   <CategoryTag
     key={uid.gen()}
     active={R.contains(c.id, selectedids)}
     onClick={logic.onAdd.bind(this, communityId, c.id, selectedids)}
   >
     {c.title}
   </CategoryTag>
 ))}
Exemple #23
0
function uninstallVersion(version) {
    if (R.contains(version, getInstalledVersions())) {
        return util.deleteDir(path.join(paths.PSVM_VERSIONS, version));
    } else {
        return new Promise(function (resolve, reject) {
            reject('Version to uninstall not found');
        })
    }
}
 updateValidationVisibility = (keySet: Array<string>) => {
   const { dispatch, profiles } = this.props
   const username = SETTINGS.user.username
   if (!profiles[username].edit) {
     dispatch(updateValidationVisibility(username, keySet))
   } else if (!R.contains(keySet, profiles[username].edit.visibility)) {
     dispatch(updateValidationVisibility(username, keySet))
   }
 }
 appendOrRemovePredicate = predicate => {
   const removePredicate = n => R.eqProps('name', n, predicate)
   R.contains(predicate.name, R.pluck('name', this.state.predicates))
     ? this.setState({
         ...this.state,
         predicates: R.reject(removePredicate, this.state.predicates)
       })
     : this.setState({ ...this.state, predicates: R.append(predicate, this.state.predicates) })
 }
Exemple #26
0
  render: (cursor) => {
    let profileCursor = cursor.cursor('userProfile')
    let user = profileCursor.get('user').toJS()
    let currentHash = cursor.cursor('router').get('currentHash')
    let soundCloud = user.soundCloud || {}
    let profileTabs = [
      new UserTab('Projects'),
      new UserTab('Plans'),
      new UserTab('About'),
      new UserTab('Media', null, !R.isEmpty(soundCloud.uploads || [])),
      new UserTab('Workshops', null, !S.isBlank(user.workshopsInfo)),
    ]
    let activeTab = R.contains(currentHash, R.map((tab) => {
      return tab.name
    }, profileTabs)) ? currentHash : 'projects'

    logger.debug(`Rendering profile of user '${user.username}', active tab '${activeTab}':`, user)
    logger.debug(`State:`, profileCursor.toJS())
    let tabContents
    if (activeTab === 'about') {
      tabContents = About(user)
    } else if (activeTab === 'projects') {
      tabContents = Projects(user)
    } else if (activeTab === 'plans') {
      tabContents = ProjectPlans({user, cursor,})
    } else if (activeTab === 'media') {
      tabContents = Media(user)
    } else if (activeTab === 'workshops') {
      tabContents = Workshops(user)
    }

    return h('#user-pad', [
      h('.pure-g', [
        h('.pure-u-1-4', [
          VCard(user),
        ]),
        h('.pure-u-3-4', [
          h('ul.tabs', {role: 'tablist',}, R.map((profileTab) => {
            return h(`li.${S.join('.', profileTab.getClasses(activeTab))}`, [
              profileTab.enabled ? h('a', {
                role: 'tab',
                href: profileTab.url,
              }, [
                profileTab.icon != null ? h(`span.icon-${profileTab.icon}`, nbsp) : null,
                h('span', profileTab.title),
              ]) : h('div', [
                profileTab.icon != null ? h(`span.icon-${profileTab.icon}`, nbsp) : null,
                h('span', profileTab.title),
              ]),
            ])
          }, profileTabs)),
          h('#tab-contents', [tabContents,]),
        ]),
      ]),
    ])
  },
      .then((deployments) => {
        const getInstances = R.compose(R.flatten, R.map((d) => {
          return getTagsFromInstances(d.Instances);
        }));

        const insts = getInstances(deployments);
        deployments = R.map(R.prop(constants.DEPLOYMENT_TAG), insts);

        return R.contains(name, deployments);
      });
      .then((prs) => {
        const getInstances = R.compose(R.flatten, R.map((d) => {
          return getTagsFromInstances(d.Instances);
        }));

        const insts = getInstances(prs);
        prs = R.map(R.prop(constants.PR_TAG), insts);

        return R.contains(pr, prs);
      });
Exemple #29
0
export const responseToProblem = (response) => {
  if (response instanceof Error) {
    // first check if the error message is Network Error (set by axios at 0.12) on platforms other than NodeJS.
    if (response.message === 'Network Error') return NETWORK_ERROR
    // then check the specific error code
    return R.cond([
      [R.contains(R.__, TIMEOUT_ERROR_CODES), R.always(TIMEOUT_ERROR)],
      [R.contains(R.__, NODEJS_CONNECTION_ERROR_CODES), R.always(CONNECTION_ERROR)],
      [R.T, R.always(UNKNOWN_ERROR)]
    ])(response.code)
  }
  if (R.isNil(response) || !R.has('status')) return UNKNOWN_ERROR
  return R.cond([
    [in200s, R.always(NONE)],
    [in400s, R.always(CLIENT_ERROR)],
    [in500s, R.always(SERVER_ERROR)],
    [R.T, R.always(UNKNOWN_ERROR)]
  ])(response.status || 0)
}
Exemple #30
0
client.reduxMiddleware = (store) => (next) => (action) => {
  const {type} = action
  const start = performanceNow()
  const result = next(action)
  const ms = (performanceNow() - start).toFixed(0)
  if (!R.contains(action.type, MIDDLEWARE_ACTION_IGNORE)) {
    client.sendCommand('redux.action.done', {type, ms, action})
  }
  return result
}