kilt-cms 0.9.13 → 1.0.0

data/lib/kilt/db/active_record.rb

@@ -0,0 +1,50 @@
+module Kilt
+
+  module DB
+
+    class ActiveRecord
+
+      def find(slug)
+        object = KiltObject.where(slug: slug).first
+        object ? object.data : nil
+      end
+
+      def find_all_by_type type
+        KiltObject.where(object_type: "#{type.singularize.to_s}")
+                  .map { |x| x.data }
+      end
+
+      def create(object)
+        KiltObject.create!(unique_id:   object['unique_id'],
+                           slug:        object['slug'],
+                           object_type: object['type'],
+                           data:        object.values)
+        true
+      rescue
+        false
+      end
+
+      def update(current)
+        object = KiltObject.where(unique_id: current['unique_id']).first
+        return false unless object
+        object.slug = current['slug']
+        object.data = current.values
+        object.save
+      end
+
+      def delete(slug)
+        object = KiltObject.where(slug: slug).first
+        object.delete if object
+        true
+      rescue
+        false
+      end
+
+      def setup!
+      end
+
+    end
+
+  end
+
+end

data/lib/kilt/db/rethink_db.rb

@@ -0,0 +1,108 @@
+module Kilt
+
+  module DB
+
+    class RethinkDb
+
+      def initialize(options)
+        @options = options
+      end
+
+      def find(slug)
+        results = execute { slug_query(slug).limit(1) }
+        return nil unless results
+        results = results.to_a
+        return nil if results.first.is_a? Array
+        results.first
+      end
+
+      def find_all_by_type type
+        execute { type_query(type) }.to_a
+      end
+
+      def create(object)
+        result = execute { objects_table.insert(object.values) }
+        result['errors'] == 0
+      end
+
+      def update(object)
+        result = execute do
+          unique_id_query(object['unique_id']).update(object.values)
+        end
+        result['errors'] == 0
+      end
+
+      def delete(slug)
+        result = execute { slug_query(slug).delete() }
+        result['errors'] == 0
+      end
+
+      def delete_all
+        execute do
+          @r.db(Kilt.config.test.db.db).table('objects').delete()
+        end
+      end
+
+      # Make a db call
+      def execute(&block)
+        setup_the_database
+        block.call.run(@connection)
+      end
+
+      def setup!
+        if @options[:host] && @options[:port]
+          begin
+            # See if the db exists and create it otherwise
+            dbs = execute { @r.db_list }.to_a
+            if !dbs.to_a.include? @options[:db]
+              execute { @r.db_create(@options[:db]) }
+            end
+
+            # See if the table exists and create it otherwise
+            tables = execute { @r.db(@options[:db]).table_list }.to_a
+            if !tables.to_a.include? "objects"
+              execute { @r.db(@options[:db]).table_create("objects", :primary_key => "unique_id") }
+            end
+          rescue
+            raise Kilt::CantSetupDatabaseError
+          end
+        else
+          raise Kilt::NoDatabaseConfigError
+        end
+      end
+
+      private
+
+      def setup_the_database
+        unless @r && @connection
+          begin
+            @r = RethinkDB::RQL.new
+            @connection = @r.connect(:host => @options[:host], :port => @options[:port], :db => @options[:db])
+          rescue
+            raise Kilt::CantConnectToDatabaseError
+          end
+        end
+      end
+
+      def objects_table
+        setup_the_database
+        @r.table('objects')
+      end
+
+      def slug_query(slug)
+        objects_table.filter( { 'slug' => "#{slug}" } )
+      end
+
+      def type_query(type)
+        objects_table.filter( {'type' => "#{type.singularize.to_s}" } )
+      end
+
+      def unique_id_query(unique_id)
+        objects_table.filter( { 'unique_id' => "#{unique_id}" } )
+      end
+
+    end
+
+  end
+
+end

data/lib/kilt/form.rb

@@ -8,10 +8,14 @@ module Kilt
                     end
     
     def self.method_missing(method, *args)
-      locals = { object: args[0], field_name: args[1], index: args[2], options: args[3] }
+      locals = { object: args[0], field_name: args[1], index: args[2], options: args[4], view: args[3] }
       render_view method, locals
     rescue
-      render_view '_default', locals
+      render_view 'default', locals
+    end
+
+    def self.render_field(view, data)
+      Kilt::Form.prep_field(data[:value], data[:object], data[:key], data[:index], view)
     end
     
     def self.prep_field(method, *args)
@@ -38,9 +42,7 @@ module Kilt
     private
 
     def self.render_view name, locals
-      data = { :file    =>  "#{name.to_s}.html.erb",
-               :locals  => locals }
-      ActionView::Base.new(TEMPLATES_DIR).render data
+      locals[:view].send(:render, { partial: "kilt/form/#{name}", locals: locals } )
     end
     
   end

data/lib/kilt/formatting.rb

@@ -0,0 +1,39 @@
+module Kilt
+
+  module Formatting
+
+    def self.singular_name_of object
+      simple_name_of(object)
+        .split('_')
+        .map { |x| x.capitalize }
+        .join(' ')
+    end
+
+    def self.plural_name_of object
+      singular_name_of(object).pluralize
+    end
+
+    class << self
+
+      private
+
+      def simple_name_of object
+        type = if object.is_a? Symbol
+                 object.to_s
+               elsif object.is_a? String
+                 object
+               else
+                 object.type.to_s
+               end
+
+        name_of_type_in_config(type) || type
+      end
+
+      def name_of_type_in_config type
+        kilt_type = Kilt.send(type)
+        return nil unless kilt_type
+        kilt_type['name']
+      end
+    end
+  end
+end

data/lib/kilt/object.rb

@@ -4,41 +4,21 @@ module Kilt
 
     def initialize(type, values = {})
       @type = type
-      @values = values
-
+      initialize_values values
       assemble_fields
     end
 
     def fill(params)
-      puts params
-      # Take the params passed in and match them up to the fields
-      @fields.each do |key, value|
-        if params[key] || params["#{key}-hidden"]
-          field_type = value.downcase
-          if ['file', 'image'].include? field_type
-            if params["#{key}-hidden"] && params["#{key}-hidden"] == 'clear' && !params[key]
-              @values[key.to_s] = ''
-            elsif params[key]
-              @values[key.to_s] = Kilt::Upload.send(field_type, params[key])
-            end
-          else
-            @values[key.to_s] = params[key]
-          end
-        end
-      end
-
-      # Add some extra fields
-      if !@slug
-        @values['slug'] = Utils.slugify(@values['name'])
+      fields_that_should_be_set_given(params).each do |field, field_type|
+        self[field] = the_value_for field, field_type, params
       end
-      
-      @values['type'] = @type
-
     end
 
     def [](key)
       # Return the values of the object as a hash
-      @values[key.to_s].html_safe if @values[key.to_s]
+      value = @values[key.to_s]
+      return nil unless value
+      value.respond_to?(:html_safe) ? value.html_safe : value
     end
 
     def []=(key, value)
@@ -56,11 +36,32 @@ module Kilt
     private
 
     def assemble_fields
-      # Get the fields from the config, and add the name field
-      @fields = Kilt.send(@type).fields.map { |key, value| [key, value] }
-      if !Kilt.send(@type).fields.to_h.has_key? :name
-        @fields.insert(0, ['name', 'text'])
+      @fields = Kilt.send(@type).fields.to_h
+      @fields['name'] = 'text' unless @fields[:name]
+    end
+
+    def the_value_for(key, field_type, params)
+      if params["#{key}-hidden"] == 'clear' && !params[key]
+        ''
+      elsif ['file', 'image'].include? field_type
+        Kilt::Upload.send field_type, params[key]
+      else
+        params[key]
       end
     end
+
+    def fields_that_should_be_set_given params
+      @fields.map    { |k, v| [k, v.downcase] }
+             .select { |k, v| params[k] || (params["#{k}-hidden"].to_s != '') }
+    end
+
+    def initialize_values values
+      @values = values
+
+      @values.keys
+             .select { |x| x.is_a? Symbol }
+             .each   { |k| @values[k.to_s] = @values[k] }
+    end
+
   end
-end
+end

data/lib/kilt/utils.rb

@@ -1,46 +1,33 @@
 module Kilt
   class Utils
     
-    # Set up the database
     def self.setup_db
-      if Kilt.config.db.host && Kilt.config.db.port
-        begin
-          db = r.connect(:host => Kilt.config.db.host, :port => Kilt.config.db.port).repl
-        rescue
-          raise Kilt::CantConnectToDatabaseError 
-        end
-        
-        begin
-          
-          # See if the db exists and create it otherwise
-          dbs = r.db_list.run
-          if !dbs.to_a.include? Kilt.config.db.db
-            r.db_create(Kilt.config.db.db).run
-          end
-          
-          # See if the table exists and create it otherwise
-          tables = r.db(Kilt.config.db.db).table_list.run
-          if !tables.to_a.include? "objects"
-            r.db(Kilt.config.db.db).table_create("objects", :primary_key => "unique_id").run
-          end
-      
-        rescue
-          raise Kilt::CantSetupDatabaseError
-        ensure
-          db.close
-        end
-        
-      else
-        raise Kilt::NoDatabaseConfigError
+      return unless current_db_config
+      if db_type = current_db_config[:type]
+        use_db(db_type.to_sym)
       end
+      database.setup!
+    end
+
+    def self.use_db db_type
+      return if @db_type == db_type
+      @db_type = db_type
+      @database = nil
     end
     
-    # Make a db call
-    def self.db(&block)
-      db = r.connect(:host => Kilt.config.db.host, :port => Kilt.config.db.port).repl
-      results = block.call()
-      db.close
-      results
+    def self.database
+      @database ||= if @db_type == :active_record
+                      Kilt::DB::ActiveRecord.new
+                    else
+                      Kilt::DB::RethinkDb.new current_db_config
+                    end
+    end
+
+    def self.current_db_config
+      current_environment = (ENV['RAILS_ENV'].to_s == '' ? 'development' : ENV['RAILS_ENV']).to_sym
+      Kilt.config[current_environment][:db]
+    rescue
+      Kilt.config[:db]
     end
     
     # Ensure we have local storage dirs
@@ -89,7 +76,7 @@ module Kilt
       ret.gsub! /\s*&\s*/, " and "
 
       #replace all non alphanumeric, underscore or periods with dash
-      ret.gsub! /\s*[^A-Za-z0-9\.\_]\s*/, '-'  
+      ret.gsub! /\s*[^A-Za-z0-9]\s*/, '-'  
 
       #convert double dash to single
       ret.gsub! /-+/, "-"
@@ -107,11 +94,17 @@ module Kilt
       ret.gsub! /_/, " "   
       ret.capitalize
     end
+
+    def self.config_is_valid?
+      Kilt.config.empty? == false && current_db_config
+      #!(Kilt.config.empty? || !Kilt.config.db)
+      #!Kilt.config.empty? && Kilt.config.db
+    end
     
     # Print a list of objects, functions, etc.
     def self.tips
       lines = []
-      if !Kilt.config.empty? && Kilt.config.db
+      if config_is_valid?
         lines << ''
         
         # Store the first type so we can use it down below
@@ -163,4 +156,4 @@ module Kilt
     end
     
   end
-end
+end

data/lib/kilt_object.rb

@@ -0,0 +1,3 @@
+class KiltObject < ActiveRecord::Base
+  serialize :data, Hash
+end

data/test/dummy/config/application.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../boot', __FILE__)
 
 # Pick the frameworks you want:
-# require "active_record/railtie"
+require "active_record/railtie"
 require "action_controller/railtie"
 require "sprockets/railtie"
 require "rails/test_unit/railtie"

data/test/dummy/config/database.yml

@@ -0,0 +1,5 @@
+development:
+  adapter: postgresql
+  encoding: unicode
+  database: kilttest
+  host: 127.0.0.1

data/test/dummy/config/initializers/kilt.rb

@@ -11,4 +11,4 @@ Settings.reload!
 Kilt.config = Settings
 
 # Ensure we have a database set up
-Kilt::Utils.setup_db
+Kilt::Utils.setup_db