attache_rails 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c05f1c9700fcff236abe554ee5bff029d799dff
-  data.tar.gz: 688d2432bdb57cfa15cedafe56d0dec0deb461b5
+  metadata.gz: 0c5f0fbee1a5d05461d6a2653ee37c54b112280e
+  data.tar.gz: 185aee4a9db3412dc04ad22538c76a597a7f5472
 SHA512:
-  metadata.gz: 48a55b14c595316bd139959a225f6d5e9d93b5da87ca5fd95089c7b1b144f482af0143b6ff995e32d88fb4a30c2974b7f446c3845a783e25a080cbebf807eca6
-  data.tar.gz: 81d5d5005af6e89b301852a0af93a1aa3315d6f733ae64aa7bc6c7da323d8bb95dc5b894ef78799ef7da0b90ff44c87a0bc0e7491448022eb11e0b4360ad98b5
+  metadata.gz: a8b13faa02ed0ed274d854cdaca638979a7ddaee63f89edb95acd45470b0720e105c5132fd9999822cfa43d38409762cf94eb8ec9acf922c64cd80d29c126d06
+  data.tar.gz: c1a886578d9a3a7671a9ed463883d754d1a89c25376fbe86861b58e88c25069f23354a9d4cbcbb40cefbb92801398a72c6edc1914879b9ce79f1070ce5ff68bd

data/README.md

@@ -1,6 +1,9 @@
 # attache_rails
 
-Ruby on Rails integration for [attache server](https://github.com/choonkeat/attache)
+[![Gem Version](https://badge.fury.io/rb/attache_rails.svg)](https://badge.fury.io/rb/attache_rails)
+[![Build Status](https://travis-ci.org/choonkeat/attache_rails.svg?branch=master)](https://travis-ci.org/choonkeat/attache_rails)
+
+Ruby on Rails / ActiveRecord integration for [attache server](https://github.com/choonkeat/attache) using [attache/api](https://github.com/choonkeat/attache_api)
 
 ## Dependencies
 
@@ -8,6 +11,8 @@ Ruby on Rails integration for [attache server](https://github.com/choonkeat/atta
 
 ## Installation
 
+**WARNING: Please see upgrade notes below if you are upgrading from V2**
+
 Install the attache_rails package from Rubygems:
 
 ``` bash
@@ -44,7 +49,7 @@ $(document).on('cocoon:after-insert', AttacheRails.upgrade_fileinputs);
 
 ### Database
 
-To use `attache`, you only need to store the JSON attributes given to you after you've uploaded a file. So if you have an existing model, you only need to add a text column
+To use `attache`, you only need to store the JSON attributes given to you after you've uploaded a file. So if you have an existing model, you only need to add a text column (PostgreSQL users see below)
 
 ``` bash
 rails generate migration AddPhotoPathToUsers photo:text
@@ -133,6 +138,35 @@ or
 * If this variable is not set, then upload requests will not be signed & `ATTACHE_UPLOAD_DURATION` will be ignored
 * If this variable is set, it must be the same value as `SECRET_KEY` is set on the `attache` server
 
+### PostgreSQL
+
+Take advantage of the [json support](http://guides.rubyonrails.org/active_record_postgresql.html#json) by using the [`json` or `jsonb` column types](http://www.postgresql.org/docs/9.4/static/functions-json.html) instead
+
+``` bash
+rails generate migration AddPhotoPathToUsers photo:json
+```
+
+This opens up the possibility to query inside the column, e.g.
+
+``` ruby
+User.where("photo ->> 'content_type' = ?", 'image/png')
+```
+
+## Upgrading from v2
+
+`json` values in the database column has changed in v3. Previously, we are working with json *strings*, now we are working with json *objects*, aka `Hash`. i.e.
+
+- in previous version, `@user.photos` value could be something like `["{\"path\":\"dirname/file.jpg\"}"]`. Notice that it is an array of 1 `String`.
+- in v3, the value would be `[{"path"=>"dirname/file.jpg"}]`. Notice that it is an array of 1 `Hash`
+
+If you're upgrading from V2, we have a generator that will create a migration file to fixup the data
+
+```
+rails g attache_rails:upgrade_v2_to_v3
+```
+
+NOTE: It is highly recommended that developers verify the migration with a dump of the production data in a staging environment. Please take a look at the generated migration file.
+
 # License
 
 MIT

data/Rakefile

@@ -1 +1,5 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/attache_rails/model.rb

@@ -1,150 +1,52 @@
 require "cgi"
 require "uri"
 require "httpclient"
+require "attache/api"
 
 module AttacheRails
-  module Utils
-    class << self
-      def array(value)
-        Array.wrap(value).reject(&:blank?)
-      end
-
-      def attache_retry_doing(max_retries, retries = 0)
-        yield
-      rescue Exception
-        if (retries += 1) <= max_retries
-          sleep retries
-          retry
-        end
-        raise
-      end
-
-      def attache_upload_and_get_json(readable)
-        uri = URI.parse(ATTACHE_UPLOAD_URL)
-        original_filename = readable.try(:original_filename) ||
-                            readable.try(:path) && File.basename(readable.try(:path)) ||
-                            'noname'
-        uri.query = { file: original_filename, **attache_auth_options }.collect {|k,v|
-          CGI.escape(k.to_s) + "=" + CGI.escape(v.to_s)
-        }.join('&')
-        attache_retry_doing(3) { HTTPClient.post(uri, readable, {'Content-Type' => 'binary/octet-stream'}).body }
-      end
-
-      def attache_url_for(json_string, geometry)
-        JSON.parse(json_string).tap do |attrs|
-          prefix, basename = File.split(attrs['path'])
-          attrs['url'] = [ATTACHE_DOWNLOAD_URL, prefix, CGI.escape(geometry), CGI.escape(basename)].join('/')
-        end
-      end
-
-      def attache_auth_options
-        if ENV['ATTACHE_SECRET_KEY']
-          uuid = SecureRandom.uuid
-          expiration = (Time.now + ATTACHE_UPLOAD_DURATION).to_i
-          hmac = OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), ENV['ATTACHE_SECRET_KEY'], "#{uuid}#{expiration}")
-          { uuid: uuid, expiration: expiration, hmac: hmac }
-        else
-          {}
-        end
-      end
-
-      def attache_options(geometry, current_value, options)
-        {
-          multiple: options[:multiple],
-          class: 'enable-attache',
-          data: {
-            geometry: geometry,
-            value: [*current_value],
-            placeholder: [*options[:placeholder]],
-            uploadurl: ATTACHE_UPLOAD_URL,
-            downloadurl: ATTACHE_DOWNLOAD_URL,
-          }.merge(options[:data] || {}).merge(attache_auth_options),
-        }
-      end
-    end
-  end
   module Model
+    include Attache::API::Model
+
     def self.included(base)
+      # has_one_attache, has_many_attaches
       base.extend ClassMethods
+
+      # `discard` management
       base.class_eval do
         attr_accessor :attaches_discarded
-        after_commit  :attaches_discard!, if: :attaches_discarded
+        after_commit if: :attaches_discarded do |instance|
+          instance.attaches_discard!(instance.attaches_discarded)
+        end
       end
     end
 
-    def attaches_discard!(files = attaches_discarded)
-      files.reject!(&:blank?)
-      files.uniq!
-      if files.present?
-        logger.info "DELETE #{files.inspect}"
-        HTTPClient.post_content(
-          URI.parse(ATTACHE_DELETE_URL),
-          Utils.attache_auth_options.merge(paths: files.join("\n"))
-        )
+    module ClassMethods
+      def attache_setup_column(name)
+        case coltype = column_for_attribute(name).type
+        when :text, :string, :binary
+          serialize name, JSON
+        end
+      rescue Exception
       end
-    rescue Exception
-      raise if ENV['ATTACHE_DISCARD_FAILURE_RAISE_ERROR']
-      logger.warn [$!, $@]
-    end
 
-    module ClassMethods
       def has_one_attache(name)
-        serialize name, JSON
-        define_method "#{name}_options",    -> (geometry, options = {}) { Utils.attache_options(geometry, Utils.array(self.send("#{name}_attributes", geometry)), multiple: false, **options) }
-        define_method "#{name}_url",        -> (geometry) {               self.send("#{name}_attributes", geometry).try(:[], 'url') }
-        define_method "#{name}_attributes", -> (geometry) {               str = self.send(name); Utils.attache_url_for(str, geometry) if str; }
-        define_method "#{name}=",           -> (value)    {
-          new_value = (value.respond_to?(:read) ? Utils.attache_upload_and_get_json(value) : value)
-          okay = JSON.parse(new_value)['path'] rescue nil
-          super(Utils.array(okay ? new_value : nil).first)
-        }
-        define_method "#{name}_discard_was",-> do
-          new_value = self.send("#{name}")
-          old_value = self.send("#{name}_was")
-          obsoleted = Utils.array(old_value).collect {|x| JSON.parse(x)['path'] } - Utils.array(new_value).collect {|x| JSON.parse(x)['path'] }
-          self.attaches_discarded ||= []
-          self.attaches_discarded.push(*obsoleted)
-        end
-        after_update "#{name}_discard_was"
-        define_method "#{name}_discard",    -> do
-          self.attaches_discarded ||= []
-          if attrs = self.send("#{name}_attributes", 'original')
-            self.attaches_discarded.push(attrs['path'])
-          end
-        end
-        after_destroy "#{name}_discard"
+        attache_setup_column(name)
+        define_method "#{name}_options",    -> (geometry, options = {}) { Hash(class: 'enable-attache', multiple: false).merge(attache_field_options(self.send(name), geometry, options)) }
+        define_method "#{name}_url",        -> (geometry)               { attache_field_urls(self.send(name), geometry).try(:first) }
+        define_method "#{name}_attributes", -> (geometry)               { attache_field_attributes(self.send(name), geometry).try(:first) }
+        define_method "#{name}=",           -> (value)                  { super(attache_field_set(Array.wrap(value)).try(:first)) }
+        after_update                        ->                          { self.attaches_discarded ||= []; attache_mark_for_discarding(self.send("#{name}_was"), self.send("#{name}"), self.attaches_discarded) }
+        after_destroy                       ->                          { self.attaches_discarded ||= []; attache_mark_for_discarding(self.send("#{name}_was"), [], self.attaches_discarded) }
       end
 
       def has_many_attaches(name)
-        serialize name, JSON
-        define_method "#{name}_options",    -> (geometry, options = {}) { Utils.attache_options(geometry, self.send("#{name}_attributes", geometry), multiple: true, **options) }
-        define_method "#{name}_urls",       -> (geometry) {               self.send("#{name}_attributes", geometry).collect {|attrs| attrs['url'] } }
-        define_method "#{name}_attributes", -> (geometry) {
-          (self.send(name) || []).inject([]) do |sum, str|
-            sum + Utils.array(str.present? && Utils.attache_url_for(str, geometry))
-          end
-        }
-        define_method "#{name}=",           -> (array)    {
-          new_value = Utils.array(array).inject([]) {|sum,value|
-            hash = value.respond_to?(:read) ? Utils.attache_upload_and_get_json(value) : value
-            okay = JSON.parse(hash)['path'] rescue nil
-            okay ? sum + [hash] : sum
-          }
-          super(Utils.array new_value)
-        }
-        define_method "#{name}_discard_was",-> do
-          new_value = [*self.send("#{name}")]
-          old_value = [*self.send("#{name}_was")]
-          obsoleted = old_value.collect {|x| JSON.parse(x)['path'] } - new_value.collect {|x| JSON.parse(x)['path'] }
-          self.attaches_discarded ||= []
-          obsoleted.each {|path| self.attaches_discarded.push(path) }
-        end
-        after_update "#{name}_discard_was"
-        define_method "#{name}_discard",    -> do
-          self.attaches_discarded ||= []
-          self.send("#{name}_attributes", 'original').each {|attrs| self.attaches_discarded.push(attrs['path']) }
-        end
-        after_destroy "#{name}_discard"
+        attache_setup_column(name)
+        define_method "#{name}_options",    -> (geometry, options = {}) { Hash(class: 'enable-attache', multiple: true).merge(attache_field_options(self.send(name), geometry, options)) }
+        define_method "#{name}_urls",       -> (geometry)               { attache_field_urls(self.send(name), geometry) }
+        define_method "#{name}_attributes", -> (geometry)               { attache_field_attributes(self.send(name), geometry) }
+        define_method "#{name}=",           -> (value)                  { super(attache_field_set(Array.wrap(value))) }
+        after_update                        ->                          { self.attaches_discarded ||= []; attache_mark_for_discarding(self.send("#{name}_was"), self.send("#{name}"), self.attaches_discarded) }
+        after_destroy                       ->                          { self.attaches_discarded ||= []; attache_mark_for_discarding(self.send("#{name}_was"), [], self.attaches_discarded) }
       end
     end
   end

data/lib/attache_rails/version.rb

@@ -1,3 +1,3 @@
 module AttacheRails
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
 end

data/lib/generators/attache_rails/templates/upgrade_v2_to_v3_migration.rb.erb

@@ -0,0 +1,45 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  <%- ($has_one_attache + $has_many_attaches).each do |(klass, column)| -%>
+  class <%= klass %> < ActiveRecord::Base; serialize :<%= column %>, JSON; end
+  <%- end -%>
+
+  def self.up
+    # has_one_attache
+    <%- $has_one_attache.each do |(klass, column)| -%>
+    <%= klass %>.where.not(<%= column %>: [nil, ""]).find_each do |obj|
+      if obj[:<%= column %>].kind_of?(String)
+        obj.update(<%= column %>: JSON.parse(obj[:<%= column %>]))
+      end
+    end
+    <%- end -%>
+
+    # has_many_attaches
+    <%- $has_many_attaches.each do |(klass, column)| -%>
+    <%= klass %>.where.not(<%= column %>: [nil, ""]).find_each do |obj|
+      if obj[:<%= column %>].first.kind_of?(String)
+        obj.update(<%= column %>: obj[:<%= column %>].collect {|v| JSON.parse(v) })
+      end
+    end
+    <%- end -%>
+  end
+
+  def self.down
+    # has_one_attache
+    <%- $has_one_attache.each do |(klass, column)| -%>
+    <%= klass %>.where.not(<%= column %>: [nil, ""]).find_each do |obj|
+      if obj[:<%= column %>].kind_of?(Hash)
+        obj.update(<%= column %>: obj[:<%= column %>].to_json)
+      end
+    end
+    <%- end -%>
+
+    # has_many_attaches
+    <%- $has_many_attaches.each do |(klass, column)| -%>
+    <%= klass %>.where.not(<%= column %>: [nil, ""]).find_each do |obj|
+      if obj[:<%= column %>].first.kind_of?(Hash)
+        obj.update(<%= column %>: obj[:<%= column %>].collect {|v| v.to_json })
+      end
+    end
+    <%- end -%>
+  end
+end

data/lib/generators/attache_rails/upgrade_v2_to_v3_generator.rb

@@ -0,0 +1,55 @@
+require 'rails/generators/active_record'
+
+module AttacheRails
+  class UpgradeV2ToV3Generator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    def self.next_migration_number(dir)
+      ActiveRecord::Generators::Base.next_migration_number(dir)
+    end
+
+    def self.source_root
+      @source_root ||= File.expand_path('../templates', __FILE__)
+    end
+
+    def generate_migration
+      migration_template "upgrade_v2_to_v3_migration.rb.erb", "db/migrate/#{migration_file_name}"
+    end
+
+    def migration_name
+      "UpgradeAttacheFieldsFromV2ToV3"
+    end
+
+    def migration_file_name
+      "#{migration_name.underscore}.rb"
+    end
+
+    def migration_class_name
+      migration_name.camelize
+    end
+
+    $has_one_attache = []
+    $has_many_attaches = []
+
+    ActiveRecord::Base.class_eval do
+      def self.has_one_attache(name)
+        $has_one_attache.push([self.name, name])
+      end
+
+      def self.has_many_attaches(name)
+        $has_many_attaches.push([self.name, name])
+      end
+    end
+
+    # Rails::ConsoleMethods#reload!
+    ActionDispatch::Reloader.cleanup!
+    ActionDispatch::Reloader.prepare!
+
+    ActiveRecord::Base.connection.tables.each do |table|
+      if klass = table.classify.safe_constantize
+      else
+        puts "skipped #{table}"
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attache_rails
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - choonkeat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-29 00:00:00.000000000 Z
+date: 2015-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: attache_api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: httpclient
   requirement: !ruby/object:Gem::Requirement
@@ -115,6 +129,8 @@ files:
 - lib/attache_rails/engine.rb
 - lib/attache_rails/model.rb
 - lib/attache_rails/version.rb
+- lib/generators/attache_rails/templates/upgrade_v2_to_v3_migration.rb.erb
+- lib/generators/attache_rails/upgrade_v2_to_v3_generator.rb
 homepage: https://github.com/choonkeat/attache_rails
 licenses:
 - MIT