trusty-cms 4.1.2 → 4.1.7

data/lib/trusty_cms/task_support.rb

@@ -8,15 +8,17 @@ module TrustyCms
           ActiveRecord::Base.establish_connection(env_connection)
         end
       end
+
       def config_export(path = "#{Rails.root}/config/trusty_config.yml")
-        self.establish_connection
+        establish_connection
         FileUtils.mkdir_p(File.dirname(path))
-        if File.open(File.expand_path(path), 'w') { |f| YAML.dump(TrustyCms::Config.to_hash.to_yaml,f) }
+        if File.open(File.expand_path(path), 'w') { |f| YAML.dump(TrustyCms::Config.to_hash.to_yaml, f) }
           puts "TrustyCms::Config saved to #{path}"
         end
       end
+
       def config_import(path = "#{Rails.root}/config/trusty_config.yml", clear = nil)
-        self.establish_connection
+        establish_connection
         if File.exist?(path)
           begin
             TrustyCms::Config.transaction do
@@ -40,12 +42,13 @@ module TrustyCms
       # Write the combined content of files in dir into cache_file in the same dir.
       #
       def cache_files(dir, files, cache_file)
-        cache_content = files.collect { |f|
-          File.read(File.join(dir, f)) }.join("\n\n")
+        cache_content = files.collect do |f|
+          File.read(File.join(dir, f))
+        end .join("\n\n")
 
         cache_path = File.join(dir, cache_file)
         File.delete(cache_path) if File.exists?(cache_path)
-        File.open(cache_path, "w+") { |f| f.write(cache_content) }
+        File.open(cache_path, 'w+') { |f| f.write(cache_content) }
       end
 
       # Reads through the layout file and returns an array of JS filenames

data/public/dispatch.fcgi

@@ -18,7 +18,7 @@
 #   # Custom log path, normal GC behavior.
 #   RailsFCGIHandler.process! '/var/log/myapp_fcgi_crash.log'
 #
-require File.dirname(__FILE__) + "/../config/environment"
+require File.dirname(__FILE__) + '/../config/environment'
 require 'fcgi_handler'
 
 RailsFCGIHandler.process!

data/public/dispatch.rb

@@ -1,10 +1,10 @@
 #!/home/rails/bin/ruby
 
-require File.dirname(__FILE__) + "/../config/environment" unless defined?(Rails.root)
+require File.dirname(__FILE__) + '/../config/environment' unless defined?(Rails.root)
 
 # If you're using RubyGems and mod_ruby, this require should be changed to an absolute path one, like:
 # "/usr/local/lib/ruby/gems/1.8/gems/rails-0.8.0/lib/dispatcher" -- otherwise performance is severely impaired
-require "dispatcher"
+require 'dispatcher'
 
 ADDITIONAL_LOAD_PATHS.reverse.each { |dir| $:.unshift(dir) if File.directory?(dir) } if defined?(Apache::RubyRun)
 Dispatcher.dispatch

data/script/extension

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-require File.expand_path('../../config/boot',  __FILE__)
+require File.expand_path('../config/boot', __dir__)
 require 'trusty_cms/extension/script'
 
 TrustyCms::Extension::Script.execute ARGV

data/script/rails

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
 
-APP_PATH = File.expand_path('../../config/application',  __FILE__)
-require File.expand_path('../../config/boot',  __FILE__)
+APP_PATH = File.expand_path('../config/application', __dir__)
+require File.expand_path('../config/boot', __dir__)
 require 'rails/commands'

data/spec/spec/dummy/node_modules/yaml/browser/dist/tags/core.js

@@ -0,0 +1,126 @@
+import Scalar from '../schema/Scalar';
+import { stringifyNumber } from '../stringify';
+import failsafe from './failsafe';
+import { boolOptions, nullOptions } from './options';
+export var nullObj = {
+  identify: function identify(value) {
+    return value == null;
+  },
+  createNode: function createNode(schema, value, ctx) {
+    return ctx.wrapScalars ? new Scalar(null) : null;
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:null',
+  test: /^(?:~|[Nn]ull|NULL)?$/,
+  resolve: function resolve() {
+    return null;
+  },
+  options: nullOptions,
+  stringify: function stringify() {
+    return nullOptions.nullStr;
+  }
+};
+export var boolObj = {
+  identify: function identify(value) {
+    return typeof value === 'boolean';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:bool',
+  test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+  resolve: function resolve(str) {
+    return str[0] === 't' || str[0] === 'T';
+  },
+  options: boolOptions,
+  stringify: function stringify(_ref) {
+    var value = _ref.value;
+    return value ? boolOptions.trueStr : boolOptions.falseStr;
+  }
+};
+export var octObj = {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'OCT',
+  test: /^0o([0-7]+)$/,
+  resolve: function resolve(str, oct) {
+    return parseInt(oct, 8);
+  },
+  stringify: function stringify(_ref2) {
+    var value = _ref2.value;
+    return '0o' + value.toString(8);
+  }
+};
+export var intObj = {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  test: /^[-+]?[0-9]+$/,
+  resolve: function resolve(str) {
+    return parseInt(str, 10);
+  },
+  stringify: stringifyNumber
+};
+export var hexObj = {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'HEX',
+  test: /^0x([0-9a-fA-F]+)$/,
+  resolve: function resolve(str, hex) {
+    return parseInt(hex, 16);
+  },
+  stringify: function stringify(_ref3) {
+    var value = _ref3.value;
+    return '0x' + value.toString(16);
+  }
+};
+export var nanObj = {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  test: /^(?:[-+]?\.inf|(\.nan))$/i,
+  resolve: function resolve(str, nan) {
+    return nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+  },
+  stringify: stringifyNumber
+};
+export var expObj = {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  format: 'EXP',
+  test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
+  resolve: function resolve(str) {
+    return parseFloat(str);
+  },
+  stringify: function stringify(_ref4) {
+    var value = _ref4.value;
+    return Number(value).toExponential();
+  }
+};
+export var floatObj = {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/,
+  resolve: function resolve(str, frac1, frac2) {
+    var frac = frac1 || frac2;
+    var node = new Scalar(parseFloat(str));
+    if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length;
+    return node;
+  },
+  stringify: stringifyNumber
+};
+export default failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]);

data/spec/spec/dummy/node_modules/yaml/browser/dist/tags/failsafe/index.js

@@ -0,0 +1,4 @@
+import map from './map';
+import seq from './seq';
+import str from './string';
+export default [map, seq, str];

data/spec/spec/dummy/node_modules/yaml/browser/dist/tags/failsafe/map.js

@@ -0,0 +1,56 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import YAMLMap from '../../schema/Map';
+import parseMap from '../../schema/parseMap';
+
+function createMap(schema, obj, ctx) {
+  var map = new YAMLMap(schema);
+
+  if (obj instanceof Map) {
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = obj[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var _step$value = _slicedToArray(_step.value, 2),
+            key = _step$value[0],
+            value = _step$value[1];
+
+        map.items.push(schema.createPair(key, value, ctx));
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  } else if (obj && _typeof(obj) === 'object') {
+    for (var _i = 0, _Object$keys = Object.keys(obj); _i < _Object$keys.length; _i++) {
+      var _key = _Object$keys[_i];
+      map.items.push(schema.createPair(_key, obj[_key], ctx));
+    }
+  }
+
+  if (typeof schema.sortMapEntries === 'function') {
+    map.items.sort(schema.sortMapEntries);
+  }
+
+  return map;
+}
+
+export default {
+  createNode: createMap,
+  default: true,
+  nodeClass: YAMLMap,
+  tag: 'tag:yaml.org,2002:map',
+  resolve: parseMap
+};

data/spec/spec/dummy/node_modules/yaml/browser/dist/tags/failsafe/seq.js

@@ -0,0 +1,43 @@
+import parseSeq from '../../schema/parseSeq';
+import YAMLSeq from '../../schema/Seq';
+
+function createSeq(schema, obj, ctx) {
+  var seq = new YAMLSeq(schema);
+
+  if (obj && obj[Symbol.iterator]) {
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = obj[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var it = _step.value;
+        var v = schema.createNode(it, ctx.wrapScalars, null, ctx);
+        seq.items.push(v);
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  }
+
+  return seq;
+}
+
+export default {
+  createNode: createSeq,
+  default: true,
+  nodeClass: YAMLSeq,
+  tag: 'tag:yaml.org,2002:seq',
+  resolve: parseSeq
+};

data/spec/spec/dummy/node_modules/yaml/browser/dist/tags/failsafe/string.js

@@ -0,0 +1,28 @@
+import { stringifyString } from '../../stringify';
+import { strOptions } from '../options';
+export var resolveString = function resolveString(doc, node) {
+  // on error, will return { str: string, errors: Error[] }
+  var res = node.strValue;
+  if (!res) return '';
+  if (typeof res === 'string') return res;
+  res.errors.forEach(function (error) {
+    if (!error.source) error.source = node;
+    doc.errors.push(error);
+  });
+  return res.str;
+};
+export default {
+  identify: function identify(value) {
+    return typeof value === 'string';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:str',
+  resolve: resolveString,
+  stringify: function stringify(item, ctx, onComment, onChompKeep) {
+    ctx = Object.assign({
+      actualString: true
+    }, ctx);
+    return stringifyString(item, ctx, onComment, onChompKeep);
+  },
+  options: strOptions
+};

data/spec/spec/dummy/node_modules/yaml/browser/dist/tags/index.js

@@ -0,0 +1,36 @@
+import core, { nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj } from './core';
+import failsafe from './failsafe';
+import json from './json';
+import yaml11 from './yaml-1.1';
+import map from './failsafe/map';
+import seq from './failsafe/seq';
+import binary from './yaml-1.1/binary';
+import omap from './yaml-1.1/omap';
+import pairs from './yaml-1.1/pairs';
+import set from './yaml-1.1/set';
+import { floatTime, intTime, timestamp } from './yaml-1.1/timestamp';
+export var schemas = {
+  core: core,
+  failsafe: failsafe,
+  json: json,
+  yaml11: yaml11
+};
+export var tags = {
+  binary: binary,
+  bool: boolObj,
+  float: floatObj,
+  floatExp: expObj,
+  floatNaN: nanObj,
+  floatTime: floatTime,
+  int: intObj,
+  intHex: hexObj,
+  intOct: octObj,
+  intTime: intTime,
+  map: map,
+  null: nullObj,
+  omap: omap,
+  pairs: pairs,
+  seq: seq,
+  set: set,
+  timestamp: timestamp
+};

data/spec/spec/dummy/node_modules/yaml/browser/dist/tags/json.js

@@ -0,0 +1,76 @@
+import map from './failsafe/map';
+import seq from './failsafe/seq';
+import Scalar from '../schema/Scalar';
+import { resolveString } from './failsafe/string';
+var schema = [map, seq, {
+  identify: function identify(value) {
+    return typeof value === 'string';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:str',
+  resolve: resolveString,
+  stringify: function stringify(value) {
+    return JSON.stringify(value);
+  }
+}, {
+  identify: function identify(value) {
+    return value == null;
+  },
+  createNode: function createNode(schema, value, ctx) {
+    return ctx.wrapScalars ? new Scalar(null) : null;
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:null',
+  test: /^null$/,
+  resolve: function resolve() {
+    return null;
+  },
+  stringify: function stringify(value) {
+    return JSON.stringify(value);
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'boolean';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:bool',
+  test: /^true|false$/,
+  resolve: function resolve(str) {
+    return str === 'true';
+  },
+  stringify: function stringify(value) {
+    return JSON.stringify(value);
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  test: /^-?(?:0|[1-9][0-9]*)$/,
+  resolve: function resolve(str) {
+    return parseInt(str, 10);
+  },
+  stringify: function stringify(value) {
+    return JSON.stringify(value);
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
+  resolve: function resolve(str) {
+    return parseFloat(str);
+  },
+  stringify: function stringify(value) {
+    return JSON.stringify(value);
+  }
+}];
+
+schema.scalarFallback = function (str) {
+  throw new SyntaxError("Unresolved plain scalar ".concat(JSON.stringify(str)));
+};
+
+export default schema;