revelry_data 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3279b32fff31dc2456be44d33a8beae8b6164459
+  data.tar.gz: 21c143bf59b92b2e65fe0db741508d8519ce2e97
+SHA512:
+  metadata.gz: cd499614bda1ab94ce81ecaa62397d15818dc66088fb3ebf32d5d69abd48aae9a92554954ed91cb54b3fbc62063eb629746e05d0b9612843b864a7b6ccac295d
+  data.tar.gz: 72cd5a587b878f51d351a9a4bad7facdd74ea3e659b05125384ed2ce9cf44369784e9357a7b8a03a8a5fb261930a0440dd7e8dd718f9fac54f863fe3c9e3dde1

data/LICENSE

@@ -0,0 +1,29 @@
+BSD License
+
+Copyright (c) 2013-2015, Robert Prehn and Revelry Labs, LLC
+All rights reserved.
+
+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.
+
+ * Neither the name Revelry nor the names of its contributors may be used to
+   endorse or promote products derived from this software without specific
+   prior written permission.
+
+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 HOLDER 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.

data/README.md

@@ -0,0 +1,78 @@
+# RevelryData
+
+Revelry Data is a library for managing data within React applications using
+JSON API and Flux architecture. It goes beyond most Flux implementations by
+having opinions on how data interchange with the server should work.
+
+Currently, only the Store portion of Flux is truly implemented. Dispatcher and
+Action Creator portions are on the drawing board, but for now, methods on the
+store are acting as the actions, and we expect you to not twiddle data in the
+store directly from your components.
+
+## Documentation
+
+We are actively commenting the library with jsDoc style comments, and are
+building the doc site for Revelry Data. In the meanwhile, the library is
+thoroughly commented.
+
+## Concepts
+
+### Stores
+
+A store is a thing that holds data. This data might be something you persist to
+the server or not. The store also hold all the logic for manipulating the data.
+You should not directly _write_ data to the store from your components. Your
+component only _reads_ data from the store for display and dispatches actions
+when it needs data updated (currently, actions are just methods on the store
+object, so you can add your own by adding more methods).
+
+Stores generally hold one or more models or collections.
+
+### Resources and Resource Types
+
+When this library says "Resource", it means in the sense of "API Resource" and
+"REST API". It is a bit of data, with a type, that is meant to be read from the
+server and/or saved to the server. Our resources are set up as per the [JSON
+API](http://jsonapi.org/format/) format.
+
+### Models
+
+Just like in any MVC Framework, Models are objects which hold all the data that
+represents one "thing" or resource. Our models are just
+[Backbone models](http://backbonejs.org/#Model).
+
+### Collections
+
+Collections hold a list of related models of the same type. We use
+[Backbone collections](http://backbonejs.org/#Collection).
+
+### Paths
+
+Many of the methods available in the base store reference data using "paths."
+Paths are strings which describe how to find the data in the store. They look
+like the JS code you would use to access a bit of data in the store. For
+example, the path `'beer'` on `store` goes to `store.beer`. The path `beer.IBUs`
+goes to `store.beer.IBUs`. If you had a collection called `beers` on `store`,
+you could access the first beer's IBUs like `'beers.models[0].IBUs'`.
+
+Technically, these are [JSONPaths](https://www.npmjs.com/package/JSONPath), but
+you probably just need to know what is in the paragraph above to get around.
+
+### Relationships
+
+We manage the relationships between models using the
+[JSON API](http://jsonapi.org/format/) format. This means we do not nest related
+resources within the model itself. Instead we keep a reference to the related
+item in the special `.relationships` area of the model. This reference is an
+object containing just the id and type of the related item. We can use this
+information to look up the item in a collection of its type.
+
+## Getting Started
+
+TBD
+
+## Testing
+
+```
+RAILS_ENV=test bake spec spec:javascript
+```

data/Rakefile

@@ -0,0 +1,29 @@
+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    = 'RevelryData'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+load APP_RAKEFILE
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/app/assets/javascripts/revelry_data/components/forms/StoreForm.es6

@@ -0,0 +1,63 @@
+// A form that works with stores to do AJAXy submission & backbone
+// validation
+Rev.registerComponent('StoreForm', class extends React.Component {
+  constructor(props) {
+    super(props)
+    this.onSubmit = this.onSubmit.bind(this)
+  }
+
+  static get propTypes() {
+    return {
+      store: React.PropTypes.object.isRequired,
+      path: React.PropTypes.string.isRequired
+    }
+  }
+
+  static get mixins() {
+    return [Rev.Mixins.StoreToModel]
+  }
+
+  get model() {
+    return JSONPath({json: this.props.store, path: this.props.path})[0]
+  }
+
+  render() {
+    return  <Rev.Components.Form method="POST"
+              onSubmit={ this.onSubmit }
+              action={ this.formAction() }
+              className={ this.props.className }
+              encType="multipart/form-data"
+            >
+              { this.props.children  }
+            </Rev.Components.Form>
+  }
+
+  formAction() {
+    if(this.props.action) {
+      return this.props.action
+    }
+    return this.model.url()
+  }
+
+  formMethod() {
+    if(this.props.method) {
+      return this.props.method
+    }
+
+    if(this.model) {
+      if(this.model.isNew()) {
+        return 'POST'
+      } else {
+        return 'PATCH'
+      }
+    }
+
+    return 'POST'
+  }
+
+  onSubmit(e) {
+    this.props.store.resetErrors()
+    e.preventDefault()
+    this.props.store.save(this.props.path)
+  }
+})

data/app/assets/javascripts/revelry_data/components/forms/StoreInput.es6

@@ -0,0 +1,51 @@
+Rev.registerComponent('StoreInput', class extends React.Component {
+  static get mixins() {
+    return [ Rev.App.Mixins.StoreInputMixin, Backbone.Events ]
+  }
+
+  static get propTypes() {
+    store: React.PropTypes.object.isRequired
+    field: React.PropTypes.string.isRequired
+    name: React.PropTypes.string
+    baseName: React.PropTypes.string
+  }
+
+  constructor(props) {
+    super(props)
+    this.onFieldChange = this.onFieldChange.bind(this)
+    this.isCheckbox = this.isCheckbox.bind(this)
+    this.onBlur = this.onBlur.bind(this)
+  }
+
+  errors() {
+    return this.props.store.errors[this.props.field]
+  }
+
+  render() {
+    var t
+    var form_params = {
+      defaultValue: this.defaultValue(),
+      value: this.value(),
+      name: this.name()
+    }
+
+    if(this.props.type == 'select' || this.props.type == 'textarea') {
+      t = this.props.type
+    }
+
+    if(this.isCheckbox()) {
+      form_params['defaultChecked'] = this.value()
+    }
+
+    return <Rev.Components.Input
+      key={this.props.field}
+      dom={t}
+      {...form_params}
+      {...this.props}
+      onChange={ this.onFieldChange }
+      error={ this.errors() }
+      onBlur={ this.onBlur }>
+      { this.props.children }
+    </Rev.Components.Input>
+  }
+})

data/app/assets/javascripts/revelry_data/mixins/StoreInputMixin.es6

@@ -0,0 +1,62 @@
+Rev.appMixin('StoreInputMixin', {
+  componentDidMount: function() {
+    if(this.props.defaultValue) {
+      this.props.store.set(this.props.field, this.props.defaultValue)
+    }
+  },
+
+  defaultValue: function() {
+    return this.value() || this.props.defaultValue
+  },
+
+  value: function() {
+    return this.props.store.get(this.props.field)
+  },
+
+  headPathPart: function() {
+    return this.props.field.split('.')[0]
+  },
+
+  tailPathParts: function() {
+    var parts = this.props.field.split('.')
+    parts.shift()
+    return parts
+  },
+
+  railsPath: function() {
+    return (this.props.baseName || this.headPathPart()) + '[' + this.tailPathParts().join('][')  +']'
+  },
+
+  name: function() {
+    return this.props.name || this.railsPath()
+  },
+
+  isCheckbox: function() {
+    return this.props.type == 'checkbox'
+  },
+
+  onFieldChange: function(e) {
+    this.props.store.resetErrorFor(this.props.field)
+    if(this.isCheckbox()) {
+      this.props.store.set(this.props.field, e.target.checked)
+    } else {
+      this.props.store.set(this.props.field, e.target.value)
+    }
+  },
+
+  onBlur: function(e) {
+    var validator = this.props.store["validate#{ _.str.classify(this.props.field) }"]
+    if(typeof validator !== 'undefined') {
+      error = validator.bind(this.props.model)()
+      if(error) {
+        response = { responseJSON: { errors: {} } }
+        response.responseJSON.errors[this.props.field] = [ error ]
+        this.props.model.trigger('error', this.props.model, response, {})
+      }
+    }
+
+    if(this.props.onBlur) {
+      this.props.onBlur(e)
+    }
+  }
+})

data/app/assets/javascripts/revelry_data/mixins/StoreToModel.es6

@@ -0,0 +1,7 @@
+// Temporarily bridge the gap between the old ModelForm API and the slightly
+// different StoreForm API
+Rev.registerMixin('StoreToModel', {
+  fullFieldName(end) {
+    return `${this.props.path}.${end}`
+  }
+})

data/app/assets/javascripts/revelry_data/models/BaseCollection.es6

@@ -0,0 +1,39 @@
+//= require ./CollectionQueryParameters
+
+class BaseCollection extends Backbone.Collection {
+  constructor(model, options) {
+    super(model, options)
+    this.queryParameters = new CollectionQueryParameters(this)
+  }
+
+  // Returns the collection class for a resource name, using our model
+  // convention, i.e.
+  // 'foos' -> App.Models.Foo.Collection
+  static collectionClassForResource(resourceName) {
+    return BaseModel.modelClassForResource(resourceName).Collection
+  }
+
+  // Return a collection class with intelligent defaults based on the resource
+  // name, i.e. model class and urls set from the resource name
+  // The class can be further extended through the typical mechanisms
+  static forResource(resourceName) {
+    return class extends BaseCollection {
+      get model() {
+        return BaseModel.modelClassForResource(resourceName)
+      }
+      //jsonapi-resources dasherizes multi-word resources by default
+      url() { return `/${_.str.dasherize(resourceName)}.json` }
+    }
+  }
+
+  handleLinks(topLevelLinks) {
+    this.queryParameters.handleLinks(topLevelLinks)
+  }
+
+  fetch(options = {}) {
+    if(!options.data) {
+      options.data = this.queryParameters.fetchData
+    }
+    super.fetch(options)
+  }
+}

data/app/assets/javascripts/revelry_data/models/BaseModel.es6

@@ -0,0 +1,97 @@
+class BaseModel extends Backbone.Model {
+  // Return a model class for a given resource name, based on our mapping
+  // convention:
+  // 'foos' -> App.Model.Foo
+  static modelClassForResource(resourceName) {
+    return App.Models[_.str.classify(_.singularize(resourceName))]
+  }
+
+  // Return a model with intelligent defaults set for a given resource name i.e.
+  // automatically set 'type' and 'urlRoot' based on the name
+  static forResource(resourceName) {
+    return class extends BaseModel {
+      constructor(attributes, options) {
+        super(attributes, options)
+        //jsonapi-resources dasherizes multi-word resources by default
+        this.urlRoot = `/${_.str.dasherize(resourceName)}`
+      }
+
+      defaults() {
+        return {
+          type: resourceName
+        }
+      }
+    }
+  }
+
+  // Create a model class from a JSON API link (with the right URL)
+  static classFromLink(related) {
+    return class extends BaseModel {
+      url() {
+        return `${related.links.self}.json`
+      }
+
+      toJSON() {
+        return {data: {id: related.data.id, type: related.data.type}}
+      }
+    }
+  }
+
+  // Create a model instance from a link (useful for saving updates to the
+  // link)
+  static fromLink(related) {
+    return new (this.classFromLink(related))(related)
+  }
+
+  // Extend Backbone base behavior with JSON API behavior. In this case,
+  // warn if the model does not include a type attribute, as this is required
+  // in JSON API
+  constructor(attributes, options) {
+    var parsedAttrs
+    if(attributes) {
+      parsedAttrs = _.chain(attributes)
+                     .extend(attributes.attributes)
+                     .compactObject()
+                     .value()
+    }
+    super(parsedAttrs, options)
+    if(!this.get('type')) {
+      console.warn('type attribute of model is required')
+    }
+  }
+
+  formatPostfix(opts) {
+    if(opts.format == 'html') {
+      return ''
+    } else {
+      return `.${opts.format}`
+    }
+  }
+
+  // Add .json to the end of the base URL to avoid any issues with the browser
+  // history (otherwise, certain browsers will occasionally dump out raw JSON)
+  // when you use the back arrow
+  url(opts) {
+    opts = opts || {format: 'json'}
+    var base =
+        _.result(this, 'urlRoot') ||
+        _.result(this.collection, 'url') ||
+        urlError()
+    if (this.isNew()) return base + this.formatPostfix(opts)
+    return base.replace(/([^\/])$/, '$1/') + encodeURIComponent(this.id) + this.formatPostfix(opts)
+  }
+
+  // Wrap the JSON representation in 'data' to make JSON API happy
+  toJSON(options) {
+    var key = {id: this.id, type: this.get('type'), relationships: this.get('relationships')}
+    var inner = _(super.toJSON(options)).omit('links', 'id', 'type', 'attributes', 'relationships')
+    return { data: _.extend({attributes: inner}, key) }
+  }
+
+  sync(method, model, options) {
+    if(!options.contentType) {
+      options.contentType = 'application/vnd.api+json'
+    }
+    super.sync(method, model, options)
+  }
+}