bank 0.1.8 → 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dcd4669440a5807e03aa5ced145d885fb80327aa
+  data.tar.gz: 4feeba3b5ba82f62ee5298ea925908eca3502887
+SHA512:
+  metadata.gz: a4272e7927e06b10a2d2da64f5e71faeda152b084f84a4d6dfa40982f3c46b3661c60cf55def5b69a4ec68622aded7e00841c469de2975256b7d28da3509d13d
+  data.tar.gz: edde837f718323d43c472572544218318106f8e220161d85050a74166b6e20e8b2118e5d8a899534146d065d60a4aff33df05b27f8b015b3a4573c46e9f89de4

data/lib/bank/collection.rb

@@ -9,86 +9,85 @@ module Bank
   RecordNotFound        = Class.new(RuntimeError)
   UnknownConversionType = Class.new(RuntimeError)
 
-  class Collection
-    class << self
-      extend Forwardable
+  module Collection
+    extend Forwardable
 
-      def_delegators :db, *DatasetMethods
+    def_delegators :db, *DatasetMethods
 
-      def config
-        @_config ||= CollectionConfig.new
-      end
-
-      def db
-        Result.new(config.db, self)
-      end
+    def initialize(&block)
+      instance_exec &block
+    end
 
-      def scope(name, blk)
-        define_singleton_method(name) { |*args| instance_exec *args, &blk }
-      end
+    def config
+      @_config ||= CollectionConfig.new
+    end
 
-      def find_by(key, value)
-        where(key => value).first
-      end
+    def db
+      Result.new(config.db, self)
+    end
 
-      def save(model)
-        pkey = config.primary_key
+    def find_by(key, value)
+      where(key => value).first
+    end
 
-        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
+    def save(model)
+      pkey = config.primary_key
 
-        return model
+      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
 
-      def create(attrs)
-        save(config.model.new(attrs))
-      end
+      return model
+    end
 
-      def update(*args, &blk)
-        model = find(*args)
+    def create(attrs)
+      save(config.model.new(attrs))
+    end
 
-        blk.call(model)
-        save(model)
-        model
-      end
+    def update(*args, &blk)
+      model = find(*args)
 
-      def find(key)
-        result = key.nil? ? nil : where(config.primary_key => key).first
+      blk.call(model)
+      save(model)
+      model
+    end
 
-        raise RecordNotFound,
-          "no record found in collection with id `#{key.inspect}'" if result.nil?
+    def find(key)
+      result = key.nil? ? nil : where(config.primary_key => key).first
 
-        return result
-      end
+      raise RecordNotFound,
+        "no record found in collection with id `#{key.inspect}'" if result.nil?
 
-      def delete(key)
-        db.where(config.primary_key => key).delete
-      end
+      return result
+    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 delete(key)
+      db.where(config.primary_key => key).delete
+    end
 
-      def join_as(table, *args, &blk)
-        select(*config.model._fields.map { |f| :"#{table}__#{f}"}).join(*args, &blk)
+    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
 
-    private
+    def join_select(table, *args, &blk)
+      select(*config.model._fields.map { |f| :"#{table}__#{f}"}).
+        join(*args, &blk)
+    end
 
-      def new?(model)
-        model.send(config.primary_key).nil?
-      end
+  private
+
+    def new?(model)
+      model.send(config.primary_key).nil?
     end
   end
 end

data/lib/bank/collection_config.rb

@@ -1,25 +1,24 @@
 require 'attr_protected'
-require 'bank/database'
 
 module Bank
   class CollectionConfig
-    attr_protected :_model_block
-    attr_writer :packer, :unpacker
+    attr_protected :_model_block, :_packers, :_unpackers
+
+    IDENTITY = ->(i) { i }
 
     def model(&block)
-      if block_given?
-        self._model_block = block
-      else
-        @_model ||= _model_block.call
-      end
+      block_given? ? self._model_block = block : @_model ||= _model_block.call
     end
 
-    def packer
-      @packer ||= identity
+    def packer(blk)   packers << blk   end
+    def unpacker(blk) unpackers << blk end
+
+    def packers
+      @_packers ||= Bank.config.default_packers
     end
 
-    def unpacker
-      @unpacker ||= identity
+    def unpackers
+      @_unpackers ||= Bank.config.default_unpackers
     end
 
     def db(&block)
@@ -28,22 +27,20 @@ module Bank
         @_db = nil
       else
         value = @_db_block.call
-        @_db ||= value.is_a?(Symbol) ? Database[value] : value
+        @_db ||= value.is_a?(Symbol) ? Bank[value] : value
       end
     end
 
     def primary_key(value = nil)
-      if value
-        @_primary_key = value
-      else
-        @_primary_key ||= :id
-      end
+      value ?  @_primary_key = value : @_primary_key ||= :id
     end
 
-  private
+    def columns
+      @_columns ||= Bank.db.schema(db)
+    end
 
-    def identity
-      ->(i) { i }
+    def columns_of_type(type)
+      columns.select { |col, opts| opts[:type] == type }
     end
   end
 end

data/lib/bank/config.rb

@@ -0,0 +1,19 @@
+module Bank
+  class Config
+    def default_packers
+      [
+        Serialize::PackTimeStamps,
+        Serialize::PackIntegers,
+        Serialize::PackBooleans
+      ]
+    end
+
+    def default_unpackers
+      [
+        Serialize::UnpackTime,
+        Serialize::UnpackDate,
+        Serialize::UnpackBoolean
+      ]
+    end
+  end
+end

data/lib/bank/model.rb

@@ -1,31 +1,35 @@
 require 'attr_protected'
 
 module Bank
-  class Model
-    class << self
-      attr_protected :_fields, :_defaults
+  module Model
+    class Config
+      attr_protected :_fields, :_defaults, :_model
 
-      def fields(*fields)
-        attr_accessor *fields
-        self._fields = fields
+      def initialize(model)
+        self._model = model
+        self._fields = []
+        self._defaults = {}
       end
 
-      def _fields
-        @_fields ||= []
+      def fields(*fields)
+        self._fields = fields
+        _model.send(:attr_accessor, *fields)
       end
 
-      def defaults(defaults)
+      def defaults(defaults = {})
         self._defaults = defaults
       end
+    end
 
-      def _defaults
-        @_defaults ||= {}
+    def self.included(base)
+      base.define_singleton_method(:config) do
+        @_config ||= Bank::Model::Config.new(self)
       end
     end
 
     def initialize(attrs = {})
       set(attrs)
-      _defaults.each { |key, val| set(key, val) if !get(key) }
+      _defaults.reject { |key, _| get(key) }.each { |key, val| set(key, val) }
     end
 
     def to_hash
@@ -52,14 +56,14 @@ module Bank
       other.is_a?(self.class) && other.to_hash == to_hash
     end
 
-  private
+    private
 
     def _fields
-      self.class._fields
+      self.class.config._fields
     end
 
     def _defaults
-      self.class._defaults
+      self.class.config._defaults
     end
   end
 end

data/lib/bank/result.rb

@@ -11,7 +11,7 @@ module Bank
     attr_protected :db, :collection
 
     def_delegators :db, *[:update, :insert, :delete, :max, :min, :count]
-    def_delegators :all, :inspect, :empty?
+    def_delegators :all, :inspect, :empty?, :==, :eql?
 
     def initialize(db, collection)
       self.db = db
@@ -43,15 +43,6 @@ module Bank
       DatasetMethods.include?(method) || super
     end
 
-    def ==(other)
-      self.all == other
-    end
-    alias_method :eql?, :==
-
-    def inspect
-      all.inspect
-    end
-
   private
 
     def new(db)

data/lib/bank/sequel.rb

@@ -1,17 +1,73 @@
 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]
+  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

@@ -1,101 +1,62 @@
 module Bank
   module Serialize
-    def self.pack(*args)
-      Packer.new(*args).call
-    end
+    def self.pack(config, model)
+      attrs = model.to_hash
 
-    def self.unpack(*args)
-      Unpacker.new(*args).call
+      config.packers.each { |p| p.call(attrs, config) }
+      model.set(Serialize.unpack(config, attrs.dup))
+      attrs
     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
+    def self.unpack(config, attrs)
+      config.unpackers.each {|p| p.call(attrs, config) }
+      attrs
     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]) }
+    PackTimeStamps = ->(attrs, config) do
+      now, model = Time.now, config.model.new
 
-        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)
-        }
+      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
 
-        columns.select { |column, opts|
-          !attrs[column].nil? && opts[:type] == :boolean
-        }.each { |column, opts| attrs[column] = [1, true].include?(attrs[column]) }
+    PackIntegers = ->(attrs, config) do
+      config.columns_of_type(:integer).each { |column, opts|
+        attrs[column] = attrs[column].to_i if attrs[column]
+      }
+    end
 
-        config.unpacker.call(attrs)
-        attrs
-      end
+    PackBooleans = ->(attrs, config) do
+      config.columns_of_type(:boolean).each { |column, opts|
+        attrs[column] = attrs[column] ? 1 : 0
+      }
+    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
+    UnpackTime = ->(attrs, config) do
+      config.columns_of_type(:datetime).each { |column, opts|
+        time = attrs[column]
+        attrs[column] = case time
+                        when String
+                          Time.at(Time.parse(time).to_i)
+                        when 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
+    UnpackDate = ->(attrs, config) do
+      config.columns_of_type(:date).each { |col, _|
+          attrs[col] = Date.parse(attrs[col]) if attrs[col].is_a?(String)
+      }
     end
 
+    UnpackBoolean = ->(attrs, config) do
+      config.columns.select { |col, opts|
+        !attrs[col].nil? && opts[:type] == :boolean
+      }.each { |col, opts| attrs[col] = [1, true].include?(attrs[col]) }
+    end
   end
 end

metadata

@@ -1,102 +1,93 @@
 --- !ruby/object:Gem::Specification
 name: bank
 version: !ruby/object:Gem::Version
-  version: 0.1.8
-  prerelease: 
+  version: 0.1.9
 platform: ruby
 authors:
 - Brian Pratt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-25 00:00:00.000000000 Z
+date: 2015-01-31 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
@@ -107,7 +98,7 @@ extra_rdoc_files: []
 files:
 - lib/bank/collection.rb
 - lib/bank/collection_config.rb
-- lib/bank/database.rb
+- lib/bank/config.rb
 - lib/bank/model.rb
 - lib/bank/result.rb
 - lib/bank/sequel.rb
@@ -115,26 +106,25 @@ files:
 homepage: https://github.com/pratt121/bank
 licenses:
 - WTFPL
+metadata: {}
 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
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: simple interface for persistence built on Sequel
 test_files: []

data/lib/bank/database.rb

@@ -1,23 +0,0 @@
-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