sethyates-content_manager 0.4.0 → 1.0.0

data/lib/content/adapters/cabinet_adapter.rb

@@ -0,0 +1,62 @@
+require 'rufus/tokyo'
+
+module Content
+  module Adapters
+    class CabinetAdapter < Base
+      def initialize(options = {})
+        file = options[:database] || options["database"] || "db/content.tct"
+        mode = options[:mode] || options["mode"] || "create"
+        @connection = Rufus::Tokyo::Table.new(file, mode)
+      end
+
+      def prepare_query(klass, query_options)
+      end
+      
+      def run_query(klass, query_options)
+        results = nil
+        ms = Benchmark.ms do
+          query_options[:limit] ||= 1000
+          results = @connection.query { |q|
+            (query_options[:conditions] || {}).each { |cond| q.add_condition cond[0], :eq, cond[1] }
+            (query_options[:order] || []).each {|order| q.order_by order }
+          }.collect {|r| r.symbolize_keys }
+        end
+        log_select(query_options, klass, ms)
+        results
+      end
+
+      def count(klass, query_options)
+        run_query(klass, query_options).length
+      end
+      
+      def get_record_by_id(klass, id)
+        record = nil
+        ms = Benchmark.ms do
+          record = @connection[id.to_s].symbolize_keys
+        end
+        log_select({:conditions => {:__id => id, :content_type => klass.name.to_s}}, klass, ms)
+        record
+      end
+
+      def save_record(klass, id, attributes)
+        ms = Benchmark.ms do
+          @connection[id.to_s] = attributes.stringify_keys
+        end
+        log_update(id, attributes, klass, ms)
+        true
+      end
+
+      def delete_record_by_id(klass, id)
+        ms = Benchmark.ms do
+          @connection.delete id
+        end
+        log_delete(id, klass, ms)
+        true
+      end
+
+      def genuid
+        @connection.genuid
+      end
+    end
+  end
+end

data/lib/content/adapters/tyrant_adapter.rb

@@ -0,0 +1,73 @@
+require 'tokyo_tyrant'
+
+module Content
+  module Adapters
+    class TyrantAdapter < Base
+      def initialize(options = {})
+        host = options[:host] || options["host"] || "localhost"
+        port = options[:port] || options["port"] || 1978
+        @connection = TokyoTyrant::Table.new(host, port)
+        @logger = ActiveRecord::Base.logger
+      end
+
+      def prepare_query(klass, query_options)
+        query_options[:limit] ||= 1000
+        query_options[:offset] || -1
+        returning @connection.query do |q|
+          (query_options[:conditions] || {}).each { |key, value| q.condition(key, :streq, value) }
+          (query_options[:order] || []).each { |order| q.order_by(order, :strasc) }
+          q.limit(query_options[:limit], query_options[:offset])
+        end
+      end
+
+      def run_query(klass, query_options)
+        results = nil
+        ms = Benchmark.ms do
+          query = prepare_query klass, query_options
+          results = query.get
+        end
+        log_select(query_options, klass, ms)
+        results
+      end
+
+      def count(klass, query_options)
+        results = nil
+        ms = Benchmark.ms do
+          query = prepare_query klass, query_options
+          results = query.searchcount
+        end
+        log_count(query_options, klass, ms)
+        results
+      end
+
+      def get_record_by_id(klass, id)
+        record = nil
+        ms = Benchmark.ms do
+          record = @connection[id]
+        end
+        log_select({:conditions => {:__id => id, :content_type => klass.name.to_s}}, klass, ms)
+        record
+      end
+
+      def save_record(klass, id, attributes)
+        ms = Benchmark.ms do
+          @connection[id] = attributes
+        end
+        log_update(id, attributes, klass, ms)
+        true
+      end
+
+      def delete_record_by_id(klass, id)
+        ms = Benchmark.ms do
+          @connection.delete id
+        end
+        log_delete(id, klass, ms)
+        true
+      end
+
+      def genuid
+        @connection.genuid
+      end
+    end
+  end
+end

data/lib/content/item.rb

@@ -0,0 +1,178 @@
+module Content
+	class Item
+    extend ItemAssociationClassMethods
+    extend ItemFinderClassMethods
+    extend ItemClassMethods
+    
+    fields :status, :version, :url, :heading, :summary, :content_type
+    belongs_to :template
+
+    def initialize(attrs = {})
+      @attributes = { :content_type => self.class.name.to_s }
+      @attributes.merge!(attrs.symbolize_keys) unless attrs.nil?
+      @new_record = !@attributes.has_key?(:__id)
+      yield(self) if block_given?
+    end
+
+    def save
+      create_or_update
+    end
+
+    def create_or_update
+      raise ActiveRecord::ReadOnlyRecord if readonly?
+      result = new_record? ? create : update
+      result != false
+    end
+
+    def create
+      self[:__id] = self.class.connection.genuid if self[:__id].nil?
+      if new_record? or changed?
+        saved_attributes = {}
+        self.class.ignored_attributes.each {|k| self["#{k.to_s.singularize}_ids"] = self[k].collect(&:id) if instance_variable_get("@#{k}_loaded".to_sym) }
+        @attributes.each {|k,v| saved_attributes[k] = v.is_a?(String) ? v : v.to_json unless self.class.ignored_attributes.include? k }
+        self.class.connection.save_record(self.class, self.id, saved_attributes)
+        @new_record = false
+        changed_attributes.clear
+      end
+      self
+    end
+    alias update create
+    alias respond_to_without_attributes? respond_to?
+
+    def save!
+      save
+      nil
+    end
+
+    def destroy
+      self.class.connection.delete_record_by_id self.class, id
+    end
+
+    def readonly?
+      false
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def changed?
+      !changed_attributes.empty?
+    end
+
+    def [](key)
+      read_attribute key
+    end
+
+    def []=(key, value)
+      write_attribute key, value
+    end
+
+    def read_attribute(attr_name)
+      @attributes[attr_name.to_sym]
+    end
+
+    def write_attribute(attr_name, value)
+      sym = attr_name.to_sym
+      if !new_record? and (@attributes[sym].nil? or @attributes[sym] != value)
+        attribute_will_change!(sym)
+      end
+      if value.nil?
+        @attributes.delete sym
+      else
+        @attributes[sym] = value
+      end
+    end
+
+    def query_attribute(attr_name)
+      value = read_attribute(attr_name.to_sym)
+      if Numeric === value || value !~ /[^0-9]/
+        !value.to_i.zero?
+      else
+        return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+        !value.blank?
+      end
+    end
+
+    def update_attributes(attrs)
+      unless attrs.nil?
+        attrs.each do |key, value|
+          self[key.to_sym] = value
+        end
+      end
+      save
+    end
+
+    def method_missing(name, *arguments)
+      if arguments.length == 0
+        self[name] if @attributes.has_key? name
+      elsif arguments.length == 1 and name.to_s.match(/^(.+)=$/)
+        self[$1.to_sym] = arguments.first
+      else
+        super
+      end
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    def to_yaml
+      @attributes.to_yaml
+    end
+
+    def to_json
+      @attributes.to_json
+    end
+    
+    def to_xml(options = {}) 
+      xml = Builder::XmlMarkup.new(:indent => options[:indent])
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.tag!(self.class.name.underscore.gsub('/', '-').dasherize) do |inner_xml|
+        self.class.serialized_attributes.each {|attr_name| inner_xml.tag! attr_name, @attributes[attr_name] unless @attributes[attr_name].nil? }
+        yield(inner_xml) if block_given?
+      end
+      xml.target!
+    end
+
+    def id
+      self[:__id].to_i unless self[:__id].nil?
+    end
+
+  private
+    def changed_attributes
+      @changed_attributes ||= {}
+    end
+	end
+end
+
+Content::Item.class_eval do
+  include Content::ItemDirtyMethods
+  include ActiveRecord::Validations
+  include ActiveRecord::Callbacks
+end
+
+
+# RDBQC*
+# STREQ - for string which is equal to the expression
+# STRINC - for string which is included in the expression
+# STRBW - for string which begins with the expression
+# STREW - for string which ends with the expression
+# STRAND - for string which includes all tokens in the expression
+# STROR - for string which includes at least one token in the expression
+# STROREQ - for string which is equal to at least one token in the expression
+# STRRX - for string which matches regular expressions of the expression
+# NUMEQ - for number which is equal to the expression
+# NUMGT - for number which is greater than the expression
+# NUMGE - for number which is greater than or equal to the expression
+# NUMLT - for number which is less than the expression
+# NUMLE - for number which is less than or equal to the expression
+# NUMBT - for number which is between two tokens of the expression
+# NUMOREQ - for number which is equal to at least one token in the expression
+# FTSPH - for full-text search with the phrase of the expression
+# FTSAND - for full-text search with all tokens in the expression
+# FTSOR - for full-text search with at least one token in the expression
+# FTSEX - for full-text search with the compound expression. 
+# All operations can be flagged by bitwise-or:
+# NEGATE - for negation
+# NOIDX - for using no index.

data/lib/content/item_association_class_methods.rb

@@ -0,0 +1,148 @@
+module Content
+  module ItemAssociationClassMethods
+    def ignored_attributes
+      @ignored_attributes ||= []
+    end
+
+    def serialized_attributes
+      @serialized_attributes ||= []
+    end
+
+    def has_many(name, options = {})
+      raise "name must be plural" unless name.to_s == name.to_s.pluralize
+      name_ids = "#{name.to_s.singularize}_ids".to_sym
+      ignored_attributes << name
+      serialized_attributes << name_ids
+
+      define_method(name_ids) do
+        if instance_variable_get("@#{name}_loaded".to_sym)
+          self[name_ids] = self[name].collect(&:id)
+          self[name] = nil
+          instance_variable_set("@#{name}_loaded".to_sym, false)
+        else
+          if self[name_ids].nil?
+            self[name_ids] = []
+          else
+            self[name_ids] = ActiveSupport::JSON.decode(self[name_ids]) if !self[name_ids].is_a?(Array) and self[name_ids].is_a? String
+          end
+        end
+        self[name_ids]
+      end
+
+      define_method("#{name_ids}=".to_sym) do |val|
+        self[name] = nil
+        instance_variable_set("@#{name}_loaded".to_sym, false)
+
+        if val.is_a? Content::Item
+          self[name_ids] = [val.id.to_i] 
+        elsif !val.is_a? Array
+          self[name_ids] = [val.to_i]
+        else
+          self[name_ids] = val
+        end
+      end
+
+      define_method(name) do
+        ary = self[name]
+        if ary.nil?
+          self[name] = ary = (self.send(name_ids) || []).collect {|id| self.class.find(id.to_i) }
+          instance_variable_set("@#{name}_loaded".to_sym, true)
+          self[name_ids] = nil
+        end
+        ary
+      end
+
+      define_method("#{name}=".to_sym) do |val|
+        if val.is_a? Array
+          instance_variable_set("@#{name}_loaded".to_sym, true)
+          self[name] = val
+          self[name_ids] = nil
+        elsif val.nil?
+          instance_variable_set("@#{name}_loaded".to_sym, false)
+          self[name] = nil
+          self[name_ids] = nil
+        end
+      end
+
+      define_method("#{name}_loaded".to_sym) do
+        instance_variable_get("@#{name}_loaded".to_sym)
+      end
+    end
+
+    def belongs_to(name, options = {})
+      raise "name must be singular" unless name.to_s == name.to_s.singularize
+      name_id = "#{name}_id".to_sym
+      ignored_attributes << name
+      serialized_attributes << name_id
+
+      define_method(name_id) do
+        self[name_id].to_i
+      end
+
+      define_method("#{name_id}=".to_sym) do |val|
+        if val.is_a? Content::Item
+          self[name] = val
+          self[name_id] = val.id.to_i 
+        else
+          self[name_id] = val.to_i
+        end
+      end
+
+      define_method(name) do
+        self[name] ||= self.class.find(self[name_id].to_i)
+      end
+
+      define_method("#{name}=".to_sym) do |val|
+        if val.is_a? Content::Item
+          val.save! if val.new_record?
+          self[name] = val
+          self[name_id] = val.id.to_i
+        end
+      end
+    end
+
+    alias :has_one :belongs_to
+
+    def field(name_or_ary, field_type = :string)
+      names = name_or_ary
+      names = [name_or_ary] unless name_or_ary.is_a? Array
+      names.each do |name|
+        serialized_attributes << name
+        field_klass = field_type.to_s.camelcase.constantize
+
+        define_method(name) do
+          self[name] = ActiveSupport::JSON.decode(self[name]) if !self[name].is_a?(field_klass) and self[name].is_a? String
+          self[name]
+        end
+
+        define_method("#{name}=".to_sym) do |val|
+          self[name] = val
+        end
+
+        define_method("#{name}_changed?".to_sym) do
+          self.changed_attributes.has_key? name
+        end
+
+        define_method("#{name}_change".to_sym) do
+          [self.changed_attributes[name], self[name]] if self.changed_attributes.has_key? name
+        end
+
+        define_method("#{name}_was".to_sym) do
+          if self.changed_attributes.has_key? name
+            self.changed_attributes[name]
+          else
+            self[name]
+          end
+        end
+      end
+    end
+
+    def fields(*names)
+      field names
+    end
+    
+    def index(name, index_type = :lexical)
+      self.connection.set_index name, index_type
+    end
+  end
+end