bagman 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.*.sw?
+.DS_Store

data/Gemfile

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

data/License

@@ -0,0 +1,20 @@
+Copyright (C) 2011 by PLUS2 Pty. Ltd., Ben Askins and Lachie Cox
+
+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/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/Readme.md

@@ -0,0 +1,23 @@
+# Bagman
+
+Add a bag of attributes to ActiveRecord models.
+
+We built Bagman for a project. We wanted fast prototyping and development, and some level of escape from the schema on relational databases.
+
+It works by serialising and deserialising a JSON string to a `text` field in the database.
+
+Deep getters and setters are provided by `AngryHash`.
+
+## Basic usage
+
+`TODO`
+
+## Encryption - the crypto pocket.
+
+`TODO`
+
+## License
+
+Copyright (C) 2011 by PLUS2 Pty. Ltd., Ben Askins <ben.askins@gmail.com> and Lachie Cox <lachiec@gmail.com>.
+
+Bagman is licensed under the MIT license (enclosed).

data/bagman.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bagman/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bagman"
+  s.version     = Bagman::VERSION
+  s.authors     = ["Lachie Cox", "Ben Askins"]
+  s.email       = ["lachiec@gmail.com", "ben.askins@gmail.com"]
+  s.homepage    = "http://github.com/plus2/bagman"
+  s.summary     = %q{Add a bag of attributes to ActiveRecord models.}
+  s.description = %q{We built Bagman for a project. We wanted fast prototyping and development, and some level of escape from the schema on relational databases.}
+
+  s.rubyforge_project = "bagman"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/bagman.rb

@@ -0,0 +1,8 @@
+require 'bagman/version'
+
+module Bagman
+  autoload :SimpleColumn, 'bagman/simple_column'
+  autoload :Bag         , 'bagman/bag'
+  autoload :Document    , 'bagman/document'
+  autoload :Extension   , 'bagman/extension'
+end

data/lib/bagman/active_record.rb

@@ -0,0 +1,48 @@
+module Bagman
+  module ConnectionAdapters
+    module TableDefinition
+      def bag_for(klass_symbol)
+        klass = klass_symbol.to_s.classify.constantize
+        raise "#{klass} doesn't have a bag" unless klass.respond_to?(:bag)
+        Bagman::TableBuilder.build_table(self, klass.bag)
+      end
+    end
+  end
+
+  module TableBuilder
+    def self.build_table(table, bag)
+      table.text :bag
+
+      # build indexed columns
+      bag.columns.each do |column|
+        table.send(column.type, column.index_name) if column.index?
+      end
+    end
+
+    # add indexes for indexed columns
+    def self.add_indexes(table, table_name, bag)
+      bag.columns.each do |column|
+        table.add_index(table_name, column.index_name) if column.index?
+      end
+    end
+  end
+end
+
+
+module ActiveRecord
+  module ConnectionAdapters
+    module SchemaStatements 
+      def bag_for_table(table)
+        klass = table.to_s.classify.constantize
+        raise "#{klass} doesn't have a bag" unless klass.respond_to?(:bag)
+        klass.bag
+      end
+
+      def add_bag_indexes_for(table_name)
+        Bagman::TableBuilder.add_indexes(self, table_name, bag_for_table(table_name.singularize.to_sym))
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, Bagman::ConnectionAdapters::TableDefinition)

data/lib/bagman/bag.rb

@@ -0,0 +1,156 @@
+module Bagman
+  class Bag
+    attr_reader :target_class, :top_level_mixin, :columns
+
+    def initialize(target_class,&blk)
+      @target_class = target_class
+      @top_level_mixin = Module.new do
+        include AngryHash::Extension
+      end
+
+      @columns = []
+
+      instance_eval(&blk)
+    end
+
+    alias :fields :columns
+
+
+    def field(name,*args,&blk)
+      options = args.extract_options!
+      type    = args.shift || :string
+
+      if options[:unbagged]
+        # no-op
+        # unbagged_field(name, type, options, &blk)
+      elsif options[:encrypted]
+        crypto_field(name, type, options, &blk)
+      else
+        bag_field(name, type, options, &blk)
+      end
+    end
+
+    
+    def bag_field(name, type, options, &blk)
+      @columns << (column = SimpleColumn.new(name, :bag, type, options))
+
+      target_class.send :define_method, name do
+        column.type_cast( self.bag[name] )
+      end
+
+      if type == :boolean
+        target_class.send :define_method, "#{name}?" do
+          column.type_cast( self.bag[name] )
+        end
+      end
+
+      target_class.send :define_method, "#{name}=" do |value|
+        if index_name = column.index_name
+          write_attribute(index_name, value)
+        end
+
+        self.bag[name] = if s = options[:serialize]
+                           s[value]
+                         elsif value.is_a? Date
+                           value.to_s(:db)
+                         else
+                           value.to_s
+                         end
+      end
+    end
+
+
+    def crypto_field(name, type, options, &blk)
+      name = name.to_s
+      @columns << (column = SimpleColumn.new(name, :crypto, type, options))
+
+      target_class.send :define_method, name do
+        column.type_cast( self.crypto_pocket[name] )
+      end
+
+      target_class.send :define_method, "#{name}_before_type_cast" do
+        self.crypto_pocket[name]
+      end
+
+      if options[:shadow]
+        target_class.send :define_method, "#{name}_shadow" do
+          read_attribute(name)
+        end
+      end
+
+
+      target_class.send :define_method, "#{name}=" do |value|
+        # we need to flag bag as dirty, or we're never saved.
+        self.bag_will_change!
+
+        self.crypto_pocket[name] = final_value = Bagman::Bag.serialise_value(value, options)
+
+        if pepper = options[:shadow]
+          shadowed = case pepper
+                     when String
+                       Gibberish::SHA256( pepper + '--' + final_value )
+                     when Symbol
+                       send(pepper, final_value)
+                     else
+                       Gibberish::SHA256( final_value )
+                     end
+
+          write_attribute(name, shadowed) 
+        end
+      end
+    end
+
+
+    def unbagged_field(name, type, options, &blk)
+    end
+
+
+
+    def self.serialise_value(value, options)
+      if s = options[:serialize]
+        s[value]
+      elsif value.is_a? Date
+        value.to_s(:db)
+      else
+        value.to_s
+      end
+    end
+    
+
+    def collection(name,type,options={},&blk)
+      @top_level_mixin.module_eval do
+        extend_array name, type
+      end
+
+      target_class.send :define_method, name do
+        self.bag[name]
+      end
+
+      target_class.send :define_method, "#{name}=" do |value|
+        if value.is_a? Hash
+          value = value.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
+        end
+        self.bag[name] = value
+      end
+    end
+
+
+    ## Indices
+    def index(*)
+    end
+
+    ## Materialise
+    def materialise(*)
+    end
+
+    ## Validations
+    def validates_presence_of(*)
+    end
+
+    def validates_storage_type_of(*)
+    end
+
+    def validate(*)
+    end
+  end
+end

data/lib/bagman/document.rb

@@ -0,0 +1,131 @@
+module Bagman
+  module Document
+
+    extend ActiveSupport::Concern
+
+
+    CryptoPocketKey = '_crypto'
+
+
+    included do
+      before_save :serialize_bag
+    end
+
+    def bag
+      @bag ||= decode_or_initialize_bag
+    end
+
+
+    def bag=(bag)
+      @bag = AngryHash[bag]
+    end
+
+
+    def decode_or_initialize_bag
+       begin
+         AngryHash[ ActiveSupport::JSON.decode( read_attribute('bag') ) ]
+       rescue
+         initialize_bag(AngryHash.new)
+       end.tap {|h|
+         h.extend self.class.bag.top_level_mixin
+       }
+    end
+
+
+    def initialize_bag(bag)
+      bag.tap do |b|
+        self.class.bag.columns.select { |c| c.options.has_key?(:default) }.each do |column|
+          b[column.name] = column.options[:default]
+        end
+      end 
+    end
+
+
+    def serialize_bag
+      if @bag
+        encrypt_crypto_pocket
+        write_attribute(:bag, ActiveSupport::JSON.encode(@bag))
+      end
+    end
+
+
+
+    ###################
+    #  crypto pocket  #
+    ###################
+
+    def crypto_pocket
+      @crypto_pocket ||= decrypt_crypto_pocket
+    end
+
+
+    def crypto_pocket=(bag)
+      @crypto_pocket = AngryHash[bag] if bag
+    end
+
+
+    def decrypt_crypto_pocket
+      if crypto_pocket = bag[CryptoPocketKey]
+        ActiveSupport::JSON.decode( encryptor.dec(crypto_pocket) )
+      else
+        {}
+      end
+    rescue
+      {}
+    end
+
+
+    def encrypt_crypto_pocket
+      if @crypto_pocket.is_a?(Hash)
+        bag[CryptoPocketKey] = encryptor.enc(@crypto_pocket.to_json)
+      end
+    end
+
+
+    def encryptor
+      @encryptor ||= begin
+                       cfg = Davidson.app_config
+                       password = cfg.crypto.password || cfg.missing!('crypto.password')
+                       Gibberish::AES.new(password)
+                     end
+    end
+      
+
+
+    # Fills a bag with data from a source document, setting only those values present in the target document
+    def fill_bag_from(source)
+      self.class.bag.columns.each do |column|
+        column_name = column.name
+        if source.respond_to?(column_name) && self.send(column_name).blank?
+          self.send("#{column_name}=", source.send(column_name)) 
+        end
+      end
+    end
+
+
+    def reload(*args)
+      @bag = nil
+      super
+    end
+
+
+    def as_json(opts={})
+      bag.dup.tap {|b|
+        b.id = id
+      }
+    end
+
+
+    module ClassMethods
+      def bag(&blk)
+        if block_given?
+          @bag = Bag.new(self, &blk)
+        else
+          @bag
+        end
+      end
+    end
+  end
+
+end
+

data/lib/bagman/extension.rb

@@ -0,0 +1,31 @@
+require 'angry_hash/extension'
+
+module Bagman
+  module Extension
+    include AngryHash::Extension
+
+    def self.included(base)
+      base.extend AngryHash::Extension::ClassMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def field(name,*args,&blk)
+        options = args.extract_options!
+        type    = args.shift || :string
+
+        column = SimpleColumn.new(name, :extended, type)
+
+        define_method name do
+          column.type_cast( self[name] )
+          # TODO typecasting, racial profiling
+        end
+
+        define_method "#{name}=" do |value|
+          self[name] = value.to_s
+        end
+      end
+    end
+
+  end
+end

data/lib/bagman/simple_column.rb

@@ -0,0 +1,51 @@
+require 'active_record/connection_adapters/abstract/schema_definitions'
+
+module Bagman
+  class SimpleColumn < ActiveRecord::ConnectionAdapters::Column
+
+    attr_reader :name, :options, :type
+
+    def initialize(name, role, type, options={})
+      @name, @role, @type, @options = name, role, type, options
+    end
+
+    def type_cast(value)
+      case type
+      when Class
+        type.new(value)
+      else
+        super
+      end
+    end
+
+    def index_name
+      case options[:index]
+      when TrueClass
+        "index_#{name}"
+      when String,Symbol
+        options[:index]
+      end
+    end
+
+    def index?
+      !! index_name
+    end
+
+    def self.string_to_date(string)
+      dd_mm_yyyy_to_date(string) || super
+    end
+
+    def self.dd_mm_yyyy_to_date(string)
+      Date.strptime(string, "%d/%m/%Y") rescue nil
+    end
+
+    def self.string_to_time(string)
+      dd_mm_yyyy_to_time(string) || super
+    end
+
+    def self.dd_mm_yyyy_to_time(string)
+      DateTime.strptime(string, "%d/%m/%Y") rescue nil
+    end
+
+  end
+end

data/lib/bagman/version.rb

@@ -0,0 +1,3 @@
+module Bagman
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: bagman
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lachie Cox
+- Ben Askins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-19 00:00:00 Z
+dependencies: []
+
+description: We built Bagman for a project. We wanted fast prototyping and development, and some level of escape from the schema on relational databases.
+email: 
+- lachiec@gmail.com
+- ben.askins@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- License
+- Rakefile
+- Readme.md
+- bagman.gemspec
+- lib/bagman.rb
+- lib/bagman/active_record.rb
+- lib/bagman/bag.rb
+- lib/bagman/document.rb
+- lib/bagman/extension.rb
+- lib/bagman/simple_column.rb
+- lib/bagman/version.rb
+homepage: http://github.com/plus2/bagman
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: bagman
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Add a bag of attributes to ActiveRecord models.
+test_files: []
+