meta_content 0.0.4

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+.DS_Store
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in meta_content.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Brian Leonard
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# MetaContent
+
+Store document values in MySQL in a separate key/value table.
+I'm sure this exists already, but we couldn't find one.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'meta_content'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install meta_content
+
+## Migration
+
+```ruby
+class CreateTaskMeta < ActiveRecord::Migration
+  def up
+    create_table :tasks_meta do |t|
+      t.integer :object_id, :null => false
+      t.string  :namespace, :null => false
+      t.string  :lookup,    :null => false
+      t.string  :value
+      t.integer :int_value
+    end
+
+    add_index :tasks_meta, [:object_id, :namespace, :lookup], unique: true
+    add_index :tasks_meta, :object_id
+  end
+  
+  def down
+    drop_table :tasks_meta
+  end
+end
+```
+
+## Model
+
+```ruby
+class Task < ActiveRecord::Base
+
+  meta do
+    string  :name
+    integer :price
+    float   :hours, :default => 1.0
+  end
+  
+  meta :timing do
+    datetime :start_at
+    string :description
+    boolean :flexible, :default => false
+  end
+  
+end
+```
+
+## Usage
+
+This gives getters and setters for everything defined:
+
+```ruby
+task = Task.new
+
+task.name = "Store meta info"
+task.price = 20
+task.hours = 3.2
+
+task.timing_start_at = 3.hours.from_now
+task.timing_description = "Tonight or otherwise by Friday"
+task.timing_flexible = true
+
+task.save!
+```
+
+Everything gets saved in the `tasks_meta` table. Updating and saving updates those rows.
+overall, it works like they were regular columns.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/meta_content/dsl.rb

@@ -0,0 +1,62 @@
+module MetaContent
+  class Dsl
+
+    def initialize(klass, namespace)
+      @klass = klass
+      @namespace = namespace
+    end
+
+    %w(integer int float number date datetime time boolean bool symbol sym string).each do |type|
+      class_eval <<-CODE
+        def #{type}(*fields)
+          options = fields.extract_options!
+          options[:type] = :#{type}
+          fields.each do |f|
+            field(f, options)
+          end
+        end
+      CODE
+    end
+
+    def field(*fields)
+      options = fields.extract_options!
+      options[:namespace] = @namespace
+      fields.each do |field|
+        create_accessors_for_meta_field(field, options)
+      end
+    end
+
+    protected
+
+    def create_accessors_for_meta_field(field, options = {})
+      given_namespace = options[:namespace]
+      implied_namespace = given_namespace || :class
+
+      @klass.meta_content_fields[implied_namespace] ||= {}
+      @klass.meta_content_fields[implied_namespace][field] = options.except(:namespace)
+
+      method_name = [given_namespace, field].compact.join('_')
+
+      @klass.class_eval <<-EV, __FILE__, __LINE__+1
+        def #{method_name}
+          read_meta(:#{implied_namespace}, :#{field})
+        end
+
+        def #{method_name}=(val)
+          write_meta(:#{implied_namespace}, :#{field}, val)
+        end
+        
+        def #{method_name}?
+          ![nil, 0, false, ""].include?(#{method_name})
+        end
+
+        def #{method_name}_changed?
+          changes = meta_changes
+          changes[0].keys.include?(:#{method_name}) ||
+          changes[1].keys.include?(:#{method_name})
+        end
+      EV
+    end
+
+  end
+end

data/lib/meta_content/query.rb

@@ -0,0 +1,70 @@
+module MetaContent
+  class Query
+    
+    def initialize(record)
+      @record = record
+    end
+
+    def h(val)
+      ActiveRecord::Base.sanitize(val)
+    end
+    
+    def select_all
+      sql = "SELECT #{qtn}.namespace, #{qtn}.lookup, #{qtn}.value, #{qtn}.int_value FROM #{qtn} WHERE #{qtn}.object_id = #{h(pk)}"
+      results = {}
+      execute(sql).each do |row|
+        results[row[0]] ||= {}
+        results[row[0]][row[1]] = row[2]
+      end
+      results
+    end
+
+    def update_all(changes)
+      sql = "INSERT INTO #{qtn}(namespace,object_id,lookup,value,int_value) VALUES "
+      values = changes.map do |namespace, namespaced_changes|
+        namespaced_changes.map do |k, change|
+          "(#{h(namespace)},#{h(pk)},#{h(k)},#{h(change.value)},#{h(change.int_value)})"
+        end
+      end.flatten
+      sql << values.join(',')
+      sql << " ON DUPLICATE KEY UPDATE value = VALUES(value), int_value = VALUES(int_value)"
+      execute(sql) if values.any?
+    end
+
+    def delete_all(deletes)
+      deletes.each do |namespace, keys|
+        next unless keys.any?
+        key_clause = keys.map{|k| h(k) }.join(',')
+        sql = "DELETE FROM #{qtn} WHERE #{qtn}.object_id = #{h(pk)} AND #{qtn}.namespace = #{h(namespace)} AND #{qtn}.lookup IN (#{key_clause})"
+        execute(sql)
+      end
+    end
+
+    protected
+
+    def qtn
+      "`#{klass.table_name}_meta`"
+    end
+
+    def pk
+      @record.id
+    end
+
+    def klass
+      @record.class
+    end
+
+    def connection
+      if klass.respond_to? :meta_content_connection
+        klass.meta_content_connection
+      else
+        klass.connection
+      end
+    end
+    
+    def execute(sql)
+      connection.execute(sql)
+    end
+
+  end
+end

data/lib/meta_content/sanitizer.rb

@@ -0,0 +1,155 @@
+module MetaContent
+  class Sanitizer
+
+    def initialize(record)
+      @record = record
+    end
+
+    def from_database(raw_results)
+      sanitized_results = HashWithIndifferentAccess.new
+      raw_results.each do |namespace, results|
+        results.each do |k,v|
+          options = schema[namespace] || {}
+          options = options[k]
+          next unless options
+          sanitized_results[namespace] ||= {}
+          sanitized_results[namespace][k] = sanitize_from_database(v, options[:type] || :string)
+        end
+      end
+      sanitized_results
+    end
+    
+    def to_database(changes)
+      sanitized_results = HashWithIndifferentAccess.new
+      changes.each do |namespace, namespaced_changes|
+        namespaced_changes.map do |k,v|
+          options = schema[namespace] || {}
+          options = options[k]
+          next unless options
+          
+          sanitized_results[namespace] ||= {}
+          sanitized_results[namespace][k] = sanitize_to_database(v, options[:type] || :string)
+        end
+      end
+      sanitized_results
+    end
+    
+    def sanitize(value, type)
+      return nil if value.nil?
+      # simulate writing and reading from database
+      change = sanitize_to_database(value, type)
+      sanitize_from_database(change.value, type)
+    end
+
+    protected
+    
+    def sanitize_from_database(value, type)
+      return nil if value.nil?
+      
+      case type
+      when :integer, :fixnum, :int
+        value.to_i
+      when :float, :number
+        value.to_f
+      when :date
+        Date.parse(value)
+      when :datetime, :time
+        Time.parse(value)
+      when :boolean, :bool
+        value == "true"
+      when :symbol, :sym
+        value.to_sym
+      else
+        value.to_s
+      end
+    end
+
+    def sanitize_to_database(value, type)
+      int_value = nil
+      float_value = nil
+      case type
+      when :integer, :fixnum, :int
+        begin
+          if value.respond_to? :strftime
+            int_value = value.strftime("%s").to_i
+          else
+            int_value = value.to_i
+          end
+        rescue StandardError => e
+          int_value = 0
+        end
+        str_value = int_value.to_s
+      when :float, :number
+        begin
+          float_value = value.to_f
+        rescue StandardError => e
+          float_value = 0.0
+        end
+        str_value = float_value.to_s
+      when :datetime, :time
+        value = parse_time(value)
+        
+        if value.respond_to? :strftime
+          str_value = value.strftime("%Y-%m-%dT%H:%M:%S%:z")
+          int_value = value.strftime("%s").to_i # epoch time
+        else
+          str_value = nil
+        end
+      when :date
+        value = parse_time(value)
+        
+        if value.respond_to? :strftime
+          str_value = value.strftime("%Y-%m-%d")
+          int_value = value.strftime("%s").to_i # epoch time
+        else
+          str_value = nil
+        end
+      when :boolean, :bool
+        if value != true && value != false
+          value = ["1", "true", "yes"].include?(value.to_s)
+        end
+        
+        if value == true
+          str_value = "true"
+          int_value = 1
+        else
+          str_value = "false"
+          int_value = 0
+        end
+      when :symbol, :sym
+        str_value = value.to_s
+      else
+        str_value = value.to_s
+      end
+      
+      int_value   ||= float_value.to_i if float_value
+      int_value   ||= str_value.length if str_value
+      float_value ||= int_value.to_f
+      
+      Change.new(str_value, int_value, float_value)
+    end
+
+    def parse_time(value)
+      result = nil
+      if value.is_a? String
+        result = Time.parse(value) rescue nil  # don't care if it blows up, nbd
+        value = value.to_i if value.to_i > 0 && result.nil?
+      end
+      result ||= Time.at(value) if value.is_a? Integer
+      result || value
+    end
+
+    def klass
+      @record.class
+    end
+
+    def schema
+      klass.meta_content_fields
+    end
+
+
+    class Change < Struct.new(:value, :int_value, :float_value)
+      
+    end
+  end
+end

data/lib/meta_content/version.rb

@@ -0,0 +1,3 @@
+module MetaContent
+  VERSION = "0.0.4"
+end

data/lib/meta_content.rb

@@ -0,0 +1,122 @@
+require "meta_content/version"
+
+module MetaContent
+  extend ActiveSupport::Concern
+
+  autoload :Dsl,        'meta_content/dsl'
+  autoload :Query,      'meta_content/query'
+  autoload :Sanitizer,  'meta_content/sanitizer'
+
+  included do
+    class_attribute :meta_content_fields
+    self.meta_content_fields = HashWithIndifferentAccess.new
+
+    after_save :store_meta
+  end
+
+  module ClassMethods
+
+    def meta(namespace = nil, &block)
+      dsl = MetaContent::Dsl.new(self, namespace)
+      dsl.instance_eval(&block)
+    end
+
+  end
+
+  def reload(*args)
+    @meta = nil
+    super
+  end
+
+  def meta
+    @meta ||= retrieve_meta
+  end
+
+
+  protected
+
+  def retrieve_meta
+    return @meta unless @meta.nil?
+    return {} if new_record?
+
+    meta_sanitizer.from_database(meta_query.select_all)
+  end
+
+  def store_meta
+    updates, deletes = meta_changes
+    updates = meta_sanitizer.to_database(updates)
+    meta_query.update_all(updates)
+    meta_query.delete_all(deletes)
+  end
+
+  def meta_query
+    @meta_query ||= ::MetaContent::Query.new(self)
+  end
+
+  def meta_sanitizer
+    @meta_sanitizer ||= ::MetaContent::Sanitizer.new(self)
+  end
+
+  def meta_changes
+    return [{}, {}] if @meta.nil?
+
+    was     = self.send(:attribute_was, :meta) || {}
+    is      = self.meta
+
+    updates = {}
+    deletes = {}
+
+    is.each do |namespace,namespaced_is|
+      namespaced_was = was[namespace] || {}
+      deletes[namespace] = namespaced_was.keys - namespaced_is.keys
+      updates[namespace] ||= {}
+      
+      namespaced_is.each do |k,v|
+        if v == nil
+          deletes[namespace] << k
+        elsif was[k] != v
+          updates[namespace][k] = v
+        end
+      end
+    end
+
+    [updates, deletes]
+  end
+
+  def default_meta(namespace, field)
+    options = field_meta(namespace, field)
+    options.fetch(:default, nil)
+  end
+  
+  def field_meta(namespace, field)
+    options = namespace_meta(namespace)
+    options.fetch(field, {})
+  end
+  
+  def namespace_meta(namespace)
+    self.class.meta_content_fields.fetch(namespace, {})
+  end
+  
+  def read_namespace(namespace)
+    self.meta.fetch(namespace, {})
+  end
+
+  def read_meta(namespace, field)
+    namespaced_meta = read_namespace(namespace)
+    namespaced_meta.fetch(field, default_meta(namespace, field))
+  end
+
+  def write_meta(namespace, field, value)
+    self.meta[namespace] ||= {}
+    unless self.meta[namespace][field] == value
+      attribute_name = namespace.to_s == 'class' ? field : [namespace, field].join('_')
+      attribute_will_change!(attribute_name)
+      attribute_will_change!(:meta)
+
+      type = field_meta(namespace, field)[:type]
+      self.meta[namespace][field] = meta_sanitizer.sanitize(value, type || :string)
+    end
+  end
+
+
+end

data/meta_content.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'meta_content/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "meta_content"
+  gem.version       = MetaContent::VERSION
+  gem.authors       = ["Mike Nelson", "Brian Leonard"]
+  gem.email         = ["mike@mikeonrails.com", "brian@bleonard.com"]
+  gem.description   = %q{Store your data in a key/value table in MySQL}
+  gem.summary       = %q{Store your data in a key/value table in MySQL}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: meta_content
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Mike Nelson
+- Brian Leonard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-30 00:00:00.000000000 Z
+dependencies: []
+description: Store your data in a key/value table in MySQL
+email:
+- mike@mikeonrails.com
+- brian@bleonard.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/meta_content.rb
+- lib/meta_content/dsl.rb
+- lib/meta_content/query.rb
+- lib/meta_content/sanitizer.rb
+- lib/meta_content/version.rb
+- meta_content.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Store your data in a key/value table in MySQL
+test_files: []