spyro 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b17cc91748c789c340ec83c1770b37dbc215d088
+  data.tar.gz: dbd5bca264895e282867fb877eb6cd0bf5734cf4
+SHA512:
+  metadata.gz: e2ab546e75cd3f076aaf7b6482b7e9f750425f1594d3fc9a64993144d85825eb15c7ea7b097d6f4bbccf1ad9ec141738ac8ff45fbe68bf033f7a11fead0ac583
+  data.tar.gz: 26cece3c4ff8ebbc52f4f42c7837229d5a39c68175775d83834aeec06adbbde7dcb6ee7c3fd09c1dcbc90fea13843f6882bd7014458ca664bf300bc1a8c2ad5e

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Andre Aubin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Spyro
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Spyro'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/OLDjavascripts/application.js

@@ -0,0 +1,25 @@
+
+var Spyro = {}
+
+Spyro.truc = "machin";
+
+console.log(this);
+
+var e = function(w) {
+  w.Spyro = Spyro;
+  window.Spyro = Spyro;
+  console.log("w", window);
+}(window);
+
+//= require react
+//= require react_ujs
+//= require lodash
+//= require pluralize
+//= require moment
+//= require moment.twitter
+
+//= require components/base/field
+//= require_tree ./components/base/inputs
+//= require components/base/base
+//= require_tree components/base
+

data/app/assets/OLDjavascripts/components.es6

@@ -0,0 +1,10 @@
+
+
+console.log(Spyro, Spyro.truc)
+//= require components/base/field
+//= require_tree ./components/base/inputs
+//= require components/base/base
+
+//= require components/country
+//= require components/user
+//= require_tree ./components

data/app/assets/OLDjavascripts/components/base/base.es6

@@ -0,0 +1,197 @@
+
+let Spyro = (Spyro || {});
+let Field = Spyro.Field
+let Text = Spyro.Text
+
+let e = function() {
+
+  class Base extends React.Component {
+    constructor(props) {
+      super(props);
+      this.handleTextChange = this.handleTextChange.bind(this)
+      this.handleEdition = this.handleEdition.bind(this)
+      this.save = this.save.bind(this)
+      this.modelName = _.snakeCase(this.constructor.name)
+      this.created = (_.keys(props).includes("id"))
+      this._setupProperties(props)
+
+      console.log("Constructor")
+    }
+
+    _setupProperties(props) {
+      let urlBase = `/${pluralize.plural(this.modelName)}`
+      if (this.created)
+      {
+        urlBase += `/${props.id}`
+      }
+
+      if (this.state === undefined)
+      {
+        this.state = {}
+      }
+      this.state = _.extend({attributes: props, editing: false, url: urlBase}, this.state)
+      return true;
+    }
+
+    componentDidMount () {
+      console.log("mounted")
+    }
+
+    handleTextChange (e) {
+      let new_attributes = this.state.attributes
+      new_attributes[e.target.attributes.getNamedItem("data-field").value] = e.target.value
+      this.setState({attributes: new_attributes});
+      e.target.focus();
+      return true;
+    }
+
+    handleEdition (e) {
+      // console.log(this)
+      if (this) {
+        this.setState({editing: (this.state.editing ? false : true)});
+      }
+    }
+
+    render () {
+      let className = `${this.modelName} object-component`
+      return (
+        <div className={className}>
+          {(this.state.editing ? this.updateForm() : this.displayDom())}
+        </div>
+      );
+    }
+
+    displayDom () {
+      console.log(this.state)
+      console.log(this.constructor.propTypes)
+      let self = this
+      let fieldsDom = _.map(this.state.attributes, (value, name) => {
+        return this._domForItem(name, value)
+        return (<p key={name}>
+          <b>{name}</b>:
+          <span onClick={this.handleEdition} className={className}>{value}</span>
+        </p>)
+      })
+      return (
+        <div>
+          {fieldsDom}
+        </div>
+      );
+    }
+
+    _domForItem(name, item) {
+
+      console.log("Looking for array: ", Object.prototype.toString.call(item) === '[object Array]', item)
+      console.log("Looking for object: ",Object.prototype.toString.call(item) === '[object Object]', item)
+      if (Object.prototype.toString.call(item) === '[object Array]')
+      {
+        return _.map(item, (e) => { return this._domForItem(name, e)})
+      }
+      else if (Object.prototype.toString.call(item) === '[object Object]')
+      {
+        let objectName = _.startCase(name).replace(/s$/, '').replace(' ', '');
+        console.log("Object name: ", objectName)
+        if (typeof(window[objectName]) === "function")
+        {
+          let Component = window[objectName]
+          console.log("component: ", Component)
+          return (<Component {...item} />)
+        }
+      }
+      let className = `${this.modelName}-edit-field-${item}`;
+
+      return (
+        <p key={name}>
+          <b>{name}</b>:
+          <span onClick={this.handleEdition} className={className}>{item}</span>
+        </p>
+      )
+    }
+
+    fieldFor(name, value, addons = {})
+    {
+      if (this.constructor.Types && this.constructor.Types[name])
+      {
+        let dataType =  this.constructor.Types[name]
+        let CustomField = Field[_.startCase(dataType).replace(/s$/, '').replace(' ', '')]
+        console.log("CustomField: ", CustomField)
+        return (<CustomField name={name} value={value} {...addons} />)
+      }
+      else
+      {
+        console.log("Text: ", Text)
+        return (<Text name={name} value={value} {...addons} />)
+      }
+    }
+
+    updateForm () {
+      let fieldsDom = _.map(this.state.attributes, (value, name) => {
+        let className = `${this.modelName}-edit-field-${value} input__field`;
+        let inputName = `${this.modelName}[${name}]`;
+        return (this.fieldFor(name, value, {onChange: this.handleTextChange, 'data-field': name, className: className}))
+        // return <Field name={name} value={value} className={className} />
+        // return <p key={name}><b>{name}</b>: <input type="text" onChange={this.handleTextChange} data-field={name} name={inputName} value={value} className={className}/></p>
+      })
+      return (
+        <form action={this.state.url} onSubmit={this.save} method={this._updateMethod()}>
+          {fieldsDom}
+          <button type="submit">Save</button>
+          <button onClick={this.handleEdition} type="button">Back</button>
+        </form>
+      );
+    }
+
+    save (e = false) {
+      if (e) {
+        e.preventDefault()
+      }
+      let action = `${this.state.url}.json`
+      let method = this._updateMethod()
+      let data = {}
+      data[this.modelName] = this.state.attributes
+      $.signedAjax({
+        method: method,
+        url: action,
+        data: data
+      })
+      .success((data) =>
+      {
+        console.log("SUCCESS ! ", data)
+        console.log(this)
+        this.handleEdition()
+      })
+      .error((a, b, c) => {
+        console.warn("ERROR", a, b, c)
+      })
+    }
+
+    refresh () {
+
+    }
+
+    _fetch (url) {
+
+    }
+
+    _url () {
+
+    }
+
+    _updateMethod () {
+      return (this.created ? this._method().update : this._method().create)
+    }
+
+    _method () {
+      return {
+        show: "GET",
+        index: "GET",
+        update: "PATCH",
+        create: "POST",
+        destroy: "DELETE"
+      }
+    }
+  }
+
+  Spyro.Base = Base
+}()
+

data/app/assets/OLDjavascripts/components/base/collection.es6

@@ -0,0 +1,199 @@
+
+let Spyro = (Spyro || {});
+let Field = Spyro.Field
+let Text = Spyro.Text
+
+class Collection extends React.Component {
+  constructor(props) {
+    super(props);
+    console.log("ON CONSTRUCT", props)
+    this.url = props.url || document.location.pathname
+    this.state = {
+      collection: props.collection || [],
+      columns: this.refreshColumns(props.collection) || [],
+      page: props.page || 1,
+      order: props.order || "id",
+      orderDirection: props.orderDirection || "asc",
+      search: "",
+    }
+    this.searchableFields = props.searchableFields || _.intersection(this.state.columns, ["name", "title"])
+    this.perPage = props.perPage || (this.state.collection.length > 0 ? this.state.collection.length : 30)
+    this.model = props.model || document.location.pathname.split("/").slice(-1)
+    this.actions = props.actions || true
+    this.exclude = props.exclude || []
+
+    // Si on a pas donné de collection initiale, on va la fetcher
+    if (this.state.collection.length === 0)
+    {
+      this.load((d) =>
+      {
+        this.setState({columns: this.refreshColumns(this.state.collection)})
+      })
+    }
+  }
+
+  refreshColumns(collection = false) {
+    if (!collection)
+    {
+      return [];
+    }
+    else if (collection && collection.length > 0)
+    {
+      return _.keys(collection[0])
+    }
+  }
+
+  getCurrentParams () {
+    let additionalParams = {}
+    if (!this.state)
+      return {}
+    if (this.state.order)
+      additionalParams[(this.state.orderDirection == "asc" ? "sort" : "rev_sort")] = this.state.order
+    if (this.state.search && this.state.search != "")
+    {
+      console.log(this.searchableFields)
+      let searchFields = this.searchableFields.map((e) => `in:${e}`).join(" ")
+      additionalParams["search"] = `${searchFields} ${this.state.search}`
+    }
+    return _.extend({
+      page: this.state.page,
+    }, additionalParams)
+  }
+
+  load (callback = false) {
+    // console.log("load with params: ", this.getCurrentParams())
+    $.signedAjax({
+      method: 'GET',
+      data: this.getCurrentParams(),
+      url: this.url,
+      dataType: 'json'
+    })
+    .success((data) =>
+    {
+      // console.log("SUCCESS ! ", data)
+      // console.log(this)
+      this.setState({collection: data})
+      if (callback)
+        callback(data)
+    })
+    .error((a, b, c) => {
+      console.warn("ERROR", a, b, c)
+      if (callback)
+        callback(data)
+    })
+  }
+
+  destroy (id) {
+    if (id) {
+      $.signedAjax({
+        method: 'DELETE',
+        url: `${this.url}/${id}`,
+        dataType: 'json'
+      })
+      .success((data) => { this.setState({collection: _.reject(this.state.collection, {id: id})}) })
+      .error((a, b, c) => { console.warn("ERROR", a, b, c) })
+    }
+  }
+
+  nextPage () {
+    this.setState({page: this.state.page + 1})
+  }
+
+  previousPage () {
+    this.setState({page: this.state.page - 1})
+  }
+
+  setOrder (field) {
+    // console.log("ordeer: ", field)
+    if (this.state.order == field)
+    {
+      this.setState({orderDirection: (this.state.orderDirection == "asc" ? "desc" : "asc"), page: 1})
+    }
+    else
+    {
+      this.setState({order: field, page: 1})
+    }
+  }
+
+  // ====================== Lifecycle hooks =====================
+
+  componentDidUpdate (props, state)
+  {
+    let requestFields = ['page', 'order', 'orderDirection', 'search']
+
+    console.log("[MAP] new props !", props, state)
+    if (_.filter(requestFields, ((e) => state[e] != this.state[e])).length > 0)
+    {
+      this.load()
+    }
+  }
+
+  componentDidMount () {
+    console.log("mounted")
+    loadImages(document);
+  }
+
+  // ==================== Rendering functions ====================
+
+
+  renderSearch () {
+    let onSearch = ((e) => this.setState({search: e.target.value}))
+    return <input type="search" placeholder="search..." onChange={onSearch} />
+  }
+
+  renderHeader (columns, actions) {
+    // console.log("renderHeader: ", columns)
+    let _columns = _.without(columns, ...this.exclude)
+    if (actions)
+      _columns = _columns.concat(["actions"])
+    return (_columns.map((e) => {
+      let changeOrder = ((ev) => this.setOrder(e))
+      let sortActive = (this.state.order == e && this.state.orderDirection)
+      return <th onClick={changeOrder} data-field={_.kebabCase(e)} data-sort={sortActive}>{e}</th>
+    }))
+  }
+
+  renderActions (item) {
+    let url = `${this.url}/${item.id}`
+    let editUrl = `${url}/edit`
+    let deleteWrapper = ((e) => this.destroy(item.id))
+    return (
+      <span className="item-actions">
+        <a href={url} title="show"><i className="material-icons">visibility</i></a>
+        <a href={editUrl} title="edit"><i className="material-icons">create</i></a>
+        <a onClick={deleteWrapper} title="delete"><i className="material-icons">delete</i></a>
+      </span>
+    )
+  }
+
+  renderRow (item) {
+    // console.log("render row: ", item)
+    let columns = _.omit(item, this.exclude)
+    if (this.actions)
+      columns["actions"] = this.renderActions(columns)
+    return (_.map(columns, function(v, k) {
+      return <td data-field={_.kebabCase(k)}><Element name={k} value={v} /></td>
+    }))
+  }
+
+  render () {
+    let className = `${this.model} object-collection`
+    let content = this.state.collection.map((e) => {
+      return (<tr>{this.renderRow(e)}</tr>)
+    })
+    return (
+      <div className={className}>
+        {this.renderSearch()}
+        <Pagination nextPage={this.nextPage.bind(this)} previousPage={this.previousPage.bind(this)} total={this.state.collection.length} perPage={this.perPage} page={this.state.page}/>
+        <table>
+          <thead><tr>{this.renderHeader(this.state.columns, this.actions)}</tr></thead>
+          <tbody>{content}</tbody>
+        </table>
+        <Pagination nextPage={this.nextPage.bind(this)} previousPage={this.previousPage.bind(this)} total={this.state.collection.length} perPage={this.perPage} page={this.state.page}/>
+        <a onClick={this.load.bind(this)}>Refresh all</a>
+      </div>
+    );
+  }
+}
+
+