bank 0.1.8

data/lib/bank/collection.rb

@@ -0,0 +1,94 @@
+require 'attr_protected'
+require 'forwardable'
+
+require 'bank/sequel'
+require 'bank/collection_config'
+require 'bank/serialize'
+
+module Bank
+  RecordNotFound        = Class.new(RuntimeError)
+  UnknownConversionType = Class.new(RuntimeError)
+
+  class Collection
+    class << self
+      extend Forwardable
+
+      def_delegators :db, *DatasetMethods
+
+      def config
+        @_config ||= CollectionConfig.new
+      end
+
+      def db
+        Result.new(config.db, self)
+      end
+
+      def scope(name, blk)
+        define_singleton_method(name) { |*args| instance_exec *args, &blk }
+      end
+
+      def find_by(key, value)
+        where(key => value).first
+      end
+
+      def save(model)
+        pkey = config.primary_key
+
+        if new?(model)
+          model.send(:"#{pkey}=", db.insert(Serialize.pack(config, model)))
+        else
+          db.where(pkey => model.send(pkey)).
+            update(Serialize.pack(config, model))
+        end
+
+        return model
+      end
+
+      def create(attrs)
+        save(config.model.new(attrs))
+      end
+
+      def update(*args, &blk)
+        model = find(*args)
+
+        blk.call(model)
+        save(model)
+        model
+      end
+
+      def find(key)
+        result = key.nil? ? nil : where(config.primary_key => key).first
+
+        raise RecordNotFound,
+          "no record found in collection with id `#{key.inspect}'" if result.nil?
+
+        return result
+      end
+
+      def delete(key)
+        db.where(config.primary_key => key).delete
+      end
+
+      def convert(attrs)
+        case attrs
+        when Array
+          attrs.map(&method(:convert))
+        when Hash
+          config.model.new(Serialize.unpack(config, attrs))
+        else
+          raise UnknownConversionType, "unable to convert #{attrs.inspect}"
+        end
+      end
+
+      def join_as(table, *args, &blk)
+        select(*config.model._fields.map { |f| :"#{table}__#{f}"}).join(*args, &blk)
+      end
+
+    private
+
+      def new?(model)
+        model.send(config.primary_key).nil?
+      end
+    end
+  end
+end

data/lib/bank/collection_config.rb

@@ -0,0 +1,49 @@
+require 'attr_protected'
+require 'bank/database'
+
+module Bank
+  class CollectionConfig
+    attr_protected :_model_block
+    attr_writer :packer, :unpacker
+
+    def model(&block)
+      if block_given?
+        self._model_block = block
+      else
+        @_model ||= _model_block.call
+      end
+    end
+
+    def packer
+      @packer ||= identity
+    end
+
+    def unpacker
+      @unpacker ||= identity
+    end
+
+    def db(&block)
+      if block_given?
+        @_db_block = block
+        @_db = nil
+      else
+        value = @_db_block.call
+        @_db ||= value.is_a?(Symbol) ? Database[value] : value
+      end
+    end
+
+    def primary_key(value = nil)
+      if value
+        @_primary_key = value
+      else
+        @_primary_key ||= :id
+      end
+    end
+
+  private
+
+    def identity
+      ->(i) { i }
+    end
+  end
+end

data/lib/bank/database.rb

@@ -0,0 +1,23 @@
+require 'attr_protected'
+
+require 'bank/result'
+
+module Bank
+  class Database
+    class << self
+      attr_protected :db
+
+      def self.db
+        db.dup
+      end
+
+      def use_db(db)
+        self.db = db
+      end
+
+      def [](name)
+        self.db[name]
+      end
+    end
+  end
+end

data/lib/bank/model.rb

@@ -0,0 +1,65 @@
+require 'attr_protected'
+
+module Bank
+  class Model
+    class << self
+      attr_protected :_fields, :_defaults
+
+      def fields(*fields)
+        attr_accessor *fields
+        self._fields = fields
+      end
+
+      def _fields
+        @_fields ||= []
+      end
+
+      def defaults(defaults)
+        self._defaults = defaults
+      end
+
+      def _defaults
+        @_defaults ||= {}
+      end
+    end
+
+    def initialize(attrs = {})
+      set(attrs)
+      _defaults.each { |key, val| set(key, val) if !get(key) }
+    end
+
+    def to_hash
+      _fields.reduce({}) do |acc, field|
+        acc.merge(field => get(field))
+      end
+    end
+
+    def get(attr)
+      instance_variable_get(:"@#{attr}")
+    end
+
+    def set(attr, value = nil)
+      if attr.is_a?(Hash)
+        attr.each { |key, value| set(key, value) }
+      else
+        public_send(:"#{attr}=", value)
+      end
+
+      return self
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.to_hash == to_hash
+    end
+
+  private
+
+    def _fields
+      self.class._fields
+    end
+
+    def _defaults
+      self.class._defaults
+    end
+  end
+end

data/lib/bank/result.rb

@@ -0,0 +1,61 @@
+require 'attr_protected'
+require 'forwardable'
+
+require 'bank/sequel'
+
+module Bank
+  class Result
+    include Enumerable
+    extend Forwardable
+
+    attr_protected :db, :collection
+
+    def_delegators :db, *[:update, :insert, :delete, :max, :min, :count]
+    def_delegators :all, :inspect, :empty?
+
+    def initialize(db, collection)
+      self.db = db
+      self.collection = collection
+    end
+
+    def each(&blk)
+      raw.each { |result| blk.call(collection.convert(result)) }
+    end
+
+    def raw
+      db.all
+    end
+
+    def all
+      collection.convert(raw)
+    end
+
+    # db overrides for Enumerable-clashing methods
+    def select(*args, &block)   new(db.select(*args, &block)) end
+    def group_by(*args, &block) new(db.group_by(*args, &block)) end
+    def grep(*args, &block)     new(db.grep(*args, &block)) end
+
+    def method_missing(*args, &blk)
+      DatasetMethods.include?(args[0]) ? new(db.send(*args, &blk)) : super
+    end
+
+    def respond_to?(method)
+      DatasetMethods.include?(method) || super
+    end
+
+    def ==(other)
+      self.all == other
+    end
+    alias_method :eql?, :==
+
+    def inspect
+      all.inspect
+    end
+
+  private
+
+    def new(db)
+      self.class.new(db, collection)
+    end
+  end
+end

data/lib/bank/sequel.rb

@@ -0,0 +1,17 @@
+module Bank
+
+  DatasetMethods = [:select, :select_all, :select_append, :select_group,
+        :select_more, :join, :left_join, :right_join, :full_join,
+        :natural_join, :natural_left_join, :natural_right_join,
+        :natural_full_join, :cross_join, :inner_join, :left_outer_join,
+        :right_outer_join, :full_outer_join, :join_table, :where, :filter,
+        :exclude, :exclude_where, :and, :or, :grep, :invert, :unfiltered,
+        :group, :group_by, :group_and_count, :select_group, :ungrouped,
+        :having, :exclude_having, :invert, :unfiltered, :order, :order_by,
+        :order_append, :order_prepend, :order_more, :reverse, :reverse_order,
+        :unordered, :limit, :offset, :unlimited, :union, :intersect, :except,
+        :for_update, :lock_style, :with, :with_recursive, :clone, :distinct,
+        :naked, :qualify, :server, :with_sql, :count,
+        :insert, :update, :delete, :max, :min]
+
+end

data/lib/bank/serialize.rb

@@ -0,0 +1,101 @@
+module Bank
+  module Serialize
+    def self.pack(*args)
+      Packer.new(*args).call
+    end
+
+    def self.unpack(*args)
+      Unpacker.new(*args).call
+    end
+
+    class Packer
+      attr_protected :config, :model
+
+      def initialize(config, model)
+        self.config = config
+        self.model = model
+      end
+
+      def call
+        attrs = normalize(model.to_hash)
+
+        config.packer.call(attrs)
+        set_timestamps(attrs, model)
+
+        model.set(Serialize.unpack(config, attrs.dup))
+        attrs
+      end
+
+    private
+
+      def set_timestamps(attrs, model)
+        now = Time.now
+
+        attrs[:updated_at] = now if model.respond_to?(:updated_at=)
+        attrs[:created_at] = now if model.respond_to?(:created_at=) &&
+          !model.send(config.primary_key)
+      end
+
+      def normalize(attrs)
+        attrs = attrs.dup
+
+        columns.select { |column, opts|
+          !attrs[column].nil? && opts[:type] == :integer
+        }.each { |column, opts| attrs[column] = attrs[column].to_i }
+
+        columns.select { |column, opts|
+          !attrs[column].nil? && opts[:type] == :boolean
+        }.each { |column, opts| attrs[column] = attrs[column] ? 1 : 0 }
+
+        attrs
+      end
+
+      def columns
+        @columns ||= Database.db.schema(config.db)
+      end
+    end
+
+    class Unpacker
+      attr_protected :config, :attrs
+
+      def initialize(config, attrs)
+        self.config = config
+        self.attrs = attrs
+      end
+
+      def call
+        columns.select { |column, opts|
+          opts[:type] == :datetime && ![nil, 0].include?(attrs[column])
+        }.each { |column, opts| attrs[column] = drop_usecs(attrs[column]) }
+
+        columns.select { |column, opts|
+          opts[:type] == :date && ![nil, 0].include?(attrs[column])
+        }.each { |column, opts|
+          attrs[column] = Date.parse(attrs[column]) if attrs[column].is_a?(String)
+        }
+
+        columns.select { |column, opts|
+          !attrs[column].nil? && opts[:type] == :boolean
+        }.each { |column, opts| attrs[column] = [1, true].include?(attrs[column]) }
+
+        config.unpacker.call(attrs)
+        attrs
+      end
+
+      def drop_usecs(time)
+        if time.is_a?(String)
+          Time.at(Time.parse(time).to_i)
+        elsif time.is_a?(DateTime)
+          Time.at(time.to_time.to_i)
+        else
+          Time.at(time.to_i)
+        end
+      end
+
+      def columns
+        @columns ||= Database.db.schema(config.db)
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: bank
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+  prerelease: 
+platform: ruby
+authors:
+- Brian Pratt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.7'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.7'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.7.0
+- !ruby/object:Gem::Dependency
+  name: attr_protected
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 10.1.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: wraps Sequel to provide a non-ORM data-mapping interface
+email: brian@8thlight.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bank/collection.rb
+- lib/bank/collection_config.rb
+- lib/bank/database.rb
+- lib/bank/model.rb
+- lib/bank/result.rb
+- lib/bank/sequel.rb
+- lib/bank/serialize.rb
+homepage: https://github.com/pratt121/bank
+licenses:
+- WTFPL
+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.23.2
+signing_key: 
+specification_version: 3
+summary: simple interface for persistence built on Sequel
+test_files: []