kilt-cms 1.0.0 → 1.1.0

data/lib/kilt/upload/s3.rb

@@ -0,0 +1,24 @@
+module Kilt
+  module Upload
+    module S3
+      def self.upload type, file_reference
+        Kilt::Utils.ensure_s3_bucket_exists
+        if file_reference
+          begin
+            s3 = AWS::S3.new(
+              :access_key_id     => Kilt.config.s3.key,
+              :secret_access_key => Kilt.config.s3.secret)   
+            bucket = s3.buckets[Kilt.config.s3.bucket]
+            new_file = bucket.objects["#{type}/#{file_reference.original_filename}"]
+            new_file.write(Pathname.new(file_reference.tempfile), :acl => :public_read)
+            file_reference.original_filename
+          rescue
+            ''
+          end
+        else
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/kilt/utils.rb

@@ -16,11 +16,7 @@ module Kilt
     end
     
     def self.database
-      @database ||= if @db_type == :active_record
-                      Kilt::DB::ActiveRecord.new
-                    else
-                      Kilt::DB::RethinkDb.new current_db_config
-                    end
+      Kilt::DB::ActiveRecord.new
     end
 
     def self.current_db_config

data/lib/kilt_object.rb

@@ -1,3 +1,8 @@
-class KiltObject < ActiveRecord::Base
-  serialize :data, Hash
+# if no activerecord, then this class makes no sense
+if Object.const_defined? 'ActiveRecord'
+
+  class KiltObject < ActiveRecord::Base
+    serialize :data, Hash
+  end
+
 end

data/lib/kilt_view_model.rb

@@ -0,0 +1,44 @@
+class KiltViewModel
+
+  def self.build input
+    this_is_a_collection(input) ? build_view_models_from(input)
+                                : build_a_view_model_from(input)
+  end
+
+  def initialize subject = {}
+    @subject = subject
+  end
+
+  def [] id
+    @subject[id.to_s] || @subject[id.to_s.to_sym]
+  end
+
+  def method_missing(meth, *args, &blk)
+    @subject[meth.to_s] || @subject[meth]
+  end
+
+  class << self
+
+    private
+
+    def build_a_view_model_from record
+      eval("#{record['type']}_view_model".classify).new record
+    rescue
+      KiltViewModel.new record
+    end
+
+    def this_is_a_collection input
+      input.is_a?(Array) || input.is_a?(Kilt::ObjectCollection)
+    end
+
+    def build_view_models_from records
+      records.map { |r| build_a_view_model_from r }
+             .sort_by do |x|
+               sequence = x.sequence.to_s.to_i
+               sequence.to_s == x.sequence.to_s ? sequence : 99999999999
+             end
+    end
+
+  end
+
+end

data/test/dummy/config/kilt/config.yml

@@ -1,4 +1,4 @@
-name: Dummy
+name: Test Kilt CMS App
 storage:
   strategy: local
 objects:
@@ -14,4 +14,13 @@ objects:
       image: image
       vimeo_video: vimeo
       youtube_video: youtube
-      other: file
+      other: file
+  satchel:
+    fields:
+      name: text
+      weight: number
+      description: longtext
+  dictionary:
+    fields:
+      name: text
+    

data/test/dummy/config/kilt/creds.yml.example

@@ -7,5 +7,9 @@ s3:
   secret: <S3 secret>
   bucket: <S3 bucket>
 auth:
-  username: <Username>
-  password: <Password>
+  username: admin
+  password: changeme
+default_auth:
+  username: admin
+  password: changeme
+  note: "Feel free to remove default_auth when you change your username/password"

data/test/generators/kilt/backend_generator_spec.rb

@@ -44,13 +44,6 @@ describe Kilt::Generators::BackendGenerator do
       generator.generate
     end
 
-    it "should copy the rethinkdb credential file to the app" do
-      root_result = Object.new
-      root.stubs(:join).with('config', 'kilt', 'creds.yml.rethinkdb.example').returns root_result
-      generator.expects(:copy_file).with 'creds.yml.rethinkdb.example', root_result
-      generator.generate
-    end
-
     it "should copy the kilt.rb file as an app initializer" do
       root_result = Object.new
       root.stubs(:join).with('config', 'initializers', 'kilt.rb').returns root_result

data/test/kilt/upload_spec.rb

@@ -0,0 +1,309 @@
+require File.expand_path(File.dirname(__FILE__) + '/../minitest_helper')
+
+describe Kilt::Upload do
+
+  let(:config)  { Struct.new(:storage).new storage }
+  let(:storage) { Struct.new(:strategy).new strategy }
+
+  before do
+    Kilt.stubs(:config).returns config
+  end
+
+  describe "do" do
+
+    let(:type) { Object.new  }
+
+    let(:root) { Object.new }
+
+    let(:file_reference) do
+      Struct.new(:original_filename, :read, :tempfile).new SecureRandom.uuid, nil, Object.new
+    end
+
+    before do
+      Rails.stubs(:root).returns root
+      root.stubs(:join).returns nil
+    end
+
+    describe "using the local strategy" do
+
+      let(:strategy) { 'local' }
+
+      before do
+        Kilt::Utils.stubs(:ensure_local_storage_dir_exists)
+        File.stubs(:open)
+        root.stubs(:join).returns Object.new
+      end
+
+      it "should ensure that the local storage dir exists" do
+        File.stubs(:open)
+        Kilt::Utils.expects(:ensure_local_storage_dir_exists)
+        Kilt::Upload.do type, file_reference
+      end
+
+      it "should write the file to local storage" do
+        location = Object.new
+        root.stubs(:join)
+            .with('public', 'uploads', type, file_reference.original_filename)
+            .returns location
+
+        File.expects(:open).with location, 'wb'
+
+        Kilt::Upload.do type, file_reference
+      end
+
+      it "should return the original file reference" do
+        result = Kilt::Upload.do type, file_reference
+        result.must_be_same_as file_reference.original_filename
+      end
+
+      describe "given no file reference" do
+        it "should no try to write a file" do
+          File.stubs(:open).raises 'An error'
+          Kilt::Upload.do type, nil
+          # no error should be thrown
+        end
+
+        it "should return an empty string" do
+          Kilt::Upload.do(type, nil).must_equal ''
+        end
+      end
+
+    end
+
+    describe "actually writing the file locally" do
+
+      let(:strategy) { 'local' }
+
+      let(:test_file) { "test/test_s3.txt" }
+
+      before do
+        File.delete(test_file) if File.exists? test_file
+      end
+
+      after do
+        File.delete(test_file) if File.exists? test_file
+      end
+
+      it "should write the file" do
+        Kilt::Utils.stubs(:ensure_local_storage_dir_exists)
+
+        random_content = SecureRandom.uuid
+        file_reference.stubs(:read).returns random_content
+        root.stubs(:join).returns test_file
+
+        Kilt::Upload.do type, file_reference
+
+        File.open(test_file).read.must_equal random_content
+      end
+
+    end
+
+    describe "uploading a file to s3" do
+
+      let(:strategy) { 's3' }
+
+      let(:type) { SecureRandom.uuid  }
+
+      let(:s3_config) do
+        Struct.new(:key, :secret, :bucket)
+              .new(Object.new, Object.new, Object.new)
+      end
+
+      let(:s3)       { Object.new }
+      let(:bucket)   { Object.new }
+      let(:buckets)  { Object.new }
+      let(:objects)  { Object.new }
+      let(:the_file) { Object.new }
+
+      let(:the_location_of_the_temp_file) { Object.new }
+
+      before do
+        Kilt::Utils.stubs(:ensure_s3_bucket_exists)
+        config.stubs(:s3).returns s3_config
+
+        AWS::S3.stubs(:new)
+               .with(access_key_id:     s3_config.key,
+                     secret_access_key: s3_config.secret)
+               .returns s3
+
+        s3.stubs(:buckets).returns buckets
+        buckets.stubs(:[]).with(s3_config.bucket).returns bucket
+
+        bucket.stubs(:objects).returns objects
+
+        objects.stubs(:[])
+               .with("#{type}/#{file_reference.original_filename}")
+               .returns the_file
+
+        Pathname.stubs(:new)
+                .with(file_reference.tempfile)
+                .returns the_location_of_the_temp_file
+
+        the_file.stubs(:write)
+      end
+
+      it "should ensure that the s3 bucket exists" do
+        Kilt::Utils.expects(:ensure_s3_bucket_exists)
+        Kilt::Upload.do type, file_reference
+      end
+
+      it "should write the file to the bucket" do
+        the_file.expects(:write).with(the_location_of_the_temp_file, { acl: :public_read } )
+        Kilt::Upload.do type, file_reference
+      end
+
+      it "should return the original filename" do
+        result = Kilt::Upload.do type, file_reference
+        result.must_be_same_as file_reference.original_filename
+      end
+
+      describe "when the s3 write fails" do
+
+        before do
+          the_file.expects(:write).raises 'error'
+        end
+
+        it "should eat the error" do
+          # this better not fail
+          Kilt::Upload.do type, file_reference
+        end
+
+        it "should return an empty string" do
+          result = Kilt::Upload.do type, file_reference
+          result.must_equal ''
+        end
+
+      end
+
+      describe "when there is an error getting the s3 object" do
+        before do
+          AWS::S3.stubs(:new).raises 'error'
+        end
+
+        it "should eat the error" do
+          # this better not fail
+          Kilt::Upload.do type, file_reference
+        end
+
+        it "should return an empty string" do
+          result = Kilt::Upload.do type, file_reference
+          result.must_equal ''
+        end
+      end
+
+    end
+
+    describe "when no file reference is passed with a s3 type" do
+
+      let(:strategy) { 's3' }
+
+      before do
+        Kilt::Utils.stubs(:ensure_s3_bucket_exists)
+      end
+
+      it "should ensure that the s3 bucket exists" do
+        Kilt::Utils.expects(:ensure_s3_bucket_exists)
+        Kilt::Upload.do type, nil
+      end
+
+      it "should not attempt to hit s3" do
+        AWS::S3.expects(:new).never
+        Kilt::Upload.do type, nil
+      end
+
+      it "should return an empty string" do
+        result = Kilt::Upload.do type, nil
+        result.must_equal ''
+      end
+
+    end
+
+  end
+
+  describe "uploading different fields" do
+
+    let(:strategy)       { Object.new }
+    let(:file_reference) { Object.new }
+
+    [:image, :file].each do |type|
+
+      describe type do
+
+        it "should call the do method and return the result" do
+          expected_result = Object.new
+
+          Kilt::Upload.stubs(:do)
+                      .with(type.to_s, file_reference)
+                      .returns expected_result
+
+          result = Kilt::Upload.send type, file_reference
+
+          result.must_be_same_as expected_result
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "uploadable fields" do
+
+    let(:strategy) { nil }
+
+    describe "and no config was set" do
+
+      before do
+        config.stubs(:uploadable_fields).returns nil
+      end
+
+      it "should return file and image" do
+        fields = Kilt::Upload.uploadable_fields
+        fields.count.must_equal 2
+        fields.include?('file').must_equal true
+        fields.include?('image').must_equal true
+      end
+    end
+
+    describe "and the fields were overridden by config" do
+
+      before do
+        config.stubs(:uploadable_fields).returns 'a, b, c'
+      end
+
+      it "should return file and image" do
+        fields = Kilt::Upload.uploadable_fields
+        fields.include?('file').must_equal true
+        fields.include?('image').must_equal true
+      end
+
+      it "should return the fields" do
+        fields = Kilt::Upload.uploadable_fields
+        fields.include?('a').must_equal true
+        fields.include?('b').must_equal true
+        fields.include?('c').must_equal true
+      end
+
+    end
+
+    describe "and some edge cases" do
+
+      before do
+        config.stubs(:uploadable_fields).returns 'r, r, r, file, image, q, s'
+      end
+
+      it "should return every type only once" do
+        fields = Kilt::Upload.uploadable_fields
+        fields.count.must_equal 5
+        fields.include?('r').must_equal true
+        fields.include?('q').must_equal true
+        fields.include?('s').must_equal true
+        fields.include?('file').must_equal true
+        fields.include?('image').must_equal true
+      end
+
+    end
+
+  end
+
+end