mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-migrations-0.9.7/lib/sql/table_creator.rb

@@ -0,0 +1,81 @@
+module SQL
+  class TableCreator
+    attr_accessor :table_name, :opts
+
+    def initialize(adapter, table_name, opts = {}, &block)
+      @adapter = adapter
+      @table_name = table_name.to_s
+      @opts = opts
+
+      @columns = []
+
+      self.instance_eval &block
+    end
+
+    def quoted_table_name
+      @adapter.send(:quote_table_name, table_name)
+    end
+
+    def column(name, type, opts = {})
+      @columns << Column.new(@adapter, name, type, opts)
+    end
+
+    def to_sql
+      "CREATE TABLE #{quoted_table_name} (#{@columns.map{ |c| c.to_sql }.join(', ')})"
+    end
+
+    # A helper for using the native NOW() SQL function in a default
+    def now
+      SqlExpr.new('NOW()')
+    end
+
+    # A helper for using the native UUID() SQL function in a default
+    def uuid
+      SqlExpr.new('UUID()')
+    end
+
+    class SqlExpr
+      attr_accessor :sql
+      def initialize(sql)
+        @sql = sql
+      end
+
+      def to_s
+        @sql.to_s
+      end
+    end
+
+    class Column
+      attr_accessor :name, :type
+
+      def initialize(adapter, name, type, opts = {})
+        @adapter = adapter
+        @name = name.to_s
+        @opts = opts
+        @type = build_type(type)
+      end
+
+      def build_type(type_class)
+        schema = {:name => @name, :quote_column_name => quoted_name}.merge(@opts)
+        schema[:serial?] ||= schema[:serial]
+        schema[:nullable?] ||= schema[:nullable] || !schema[:not_null]
+        if type_class.is_a?(String)
+          schema[:primitive] = type_class
+        else
+          schema = @adapter.class.type_map[type_class].merge(schema)
+        end
+        @adapter.property_schema_statement(schema)
+      end
+
+      def to_sql
+        type
+      end
+
+      def quoted_name
+        @adapter.send(:quote_column_name, name)
+      end
+    end
+
+  end
+
+end

data/lib/gems/dm-migrations-0.9.7/lib/sql/table_modifier.rb

@@ -0,0 +1,53 @@
+module SQL
+  class TableModifier
+    attr_accessor :table_name, :opts, :statements, :adapter
+
+    def initialize(adapter, table_name, opts = {}, &block)
+      @adapter = adapter
+      @table_name = table_name.to_s
+      @opts = (opts)
+
+      @statements = []
+
+      self.instance_eval &block
+    end
+
+    def add_column(name, type, opts = {})
+      column = SQL::TableCreator::Column.new(@adapter, name, type, opts)
+      @statements << "ALTER TABLE #{quoted_table_name} ADD COLUMN #{column.to_sql}"
+    end
+
+    def drop_column(name)
+      # raise NotImplemented for SQLite3. Can't ALTER TABLE, need to copy table.
+      # We'd have to inspect it, and we can't, since we aren't executing any queries yet.
+      # TODO instead of building the SQL queries when executing the block, create AddColumn,
+      # AlterColumn and DropColumn objects that get #to_sql'd
+      if name.is_a?(Array)
+        name.each{ |n| drop_column(n) }
+      else
+        @statements << "ALTER TABLE #{quoted_table_name} DROP COLUMN #{quote_column_name(name)}"
+      end
+    end
+    alias drop_columns drop_column
+
+    def rename_column(name, new_name, opts = {})
+      # raise NotImplemented for SQLite3
+      @statements << "ALTER TABLE #{quoted_table_name} RENAME COLUMN #{quote_column_name(name)} TO #{quote_column_name(new_name)}"
+    end
+
+    def change_column(name, type, opts = {})
+      # raise NotImplemented for SQLite3
+      @statements << "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quote_column_name(name)} TYPE #{type}"
+    end
+
+    def quote_column_name(name)
+      @adapter.send(:quote_column_name, name.to_s)
+    end
+
+    def quoted_table_name
+      @adapter.send(:quote_table_name, table_name)
+    end
+
+  end
+
+end

data/lib/gems/dm-migrations-0.9.7/lib/sql.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/sql/table_creator'
+require File.dirname(__FILE__) + '/sql/table_modifier'
+
+require File.dirname(__FILE__) + '/sql/sqlite3'
+require File.dirname(__FILE__) + '/sql/mysql'
+require File.dirname(__FILE__) + '/sql/postgresql'
+
+module SQL
+
+end

data/lib/gems/dm-observer-0.9.7/lib/dm-observer/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Observer
+    VERSION = "0.9.7"
+  end
+end

data/lib/gems/dm-observer-0.9.7/lib/dm-observer.rb

@@ -0,0 +1,91 @@
+module DataMapper
+  # Observers allow you to add callback hooks to DataMapper::Resource objects
+  # in a separate class. This is great for separating out logic that is not
+  # really part of the model, but needs to be triggered by a model, or models.
+  module Observer
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      attr_accessor :observing
+
+      def initialize
+        self.observing = []
+      end
+
+      # Assign an Array of Class names to watch.
+      #   observe User, Article, Topic
+      def observe(*args)
+        # puts "#{self.to_s} observing... #{args.collect{|c| Extlib::Inflection.classify(c.to_s)}.join(', ')}"
+        self.observing = args
+      end
+
+      def before(sym, &block)
+        self.observing.each do |klass|
+          klass.before(sym.to_sym, &block)
+        end
+      end
+
+      def after(sym, &block)
+        self.observing.each do |klass|
+          klass.after(sym.to_sym, &block)
+        end
+      end
+
+      def before_class_method(sym, &block)
+        self.observing.each do |klass|
+          klass.before_class_method(sym.to_sym, &block)
+        end
+      end
+
+      def after_class_method(sym, &block)
+        self.observing.each do |klass|
+          klass.after_class_method(sym.to_sym, &block)
+        end
+      end
+
+    end # ClassMethods
+
+  end # Observer
+end # DataMapper
+
+if $0 == __FILE__
+  require 'rubygems'
+
+  gem 'dm-core', '~>0.9.7'
+  require 'dm-core'
+
+  FileUtils.touch(File.join(Dir.pwd, "migration_test.db"))
+  DataMapper.setup(:default, "sqlite3://#{Dir.pwd}/migration_test.db")
+
+  class Foo
+    include DataMapper::Resource
+
+    property :id, Integer, :serial => true
+    property :bar, Text
+  end
+
+  Foo.auto_migrate!
+
+  class FooObserver
+    include DataMapper::Observer
+
+    observe :foo
+
+    before :save do
+      raise "Hell!" if self.bar.nil?
+      puts "hi"
+    end
+
+    after :save do
+      puts "bye"
+    end
+
+  end
+
+  Foo.new(:bar => "hello").save
+
+end

data/lib/gems/dm-serializer-0.9.7/lib/dm-serializer/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Serializer
+    VERSION = "0.9.7"
+  end
+end

data/lib/gems/dm-serializer-0.9.7/lib/dm-serializer.rb

@@ -0,0 +1,183 @@
+require Pathname('rexml/document')
+
+begin
+  require 'faster_csv'
+rescue LoadError
+  nil
+end
+
+begin
+  require Pathname('json/ext')
+rescue LoadError
+  require Pathname('json/pure')
+end
+
+module DataMapper
+  module Serialize
+
+    # Serialize a Resource to JavaScript Object Notation (JSON; RFC 4627)
+    #
+    # @return <String> a JSON representation of the Resource
+    def to_json(options = {})
+      result = '{ '
+      fields = []
+
+      # FIXME: this should go into bunch of protected methods shared with other serialization methods
+      only_properties     = Array(options[:only])
+      excluded_properties = Array(options[:exclude])
+      exclude_read_only   = options[:without_read_only_attributes] || false
+
+      propset = self.class.properties(repository.name).reject do |p|
+        next if only_properties.include? p.name
+        excluded_properties.include?(p.name) || !(only_properties.empty? || only_properties.include?(p.name))
+      end
+
+      fields += propset.map do |property|
+        "#{property.name.to_json}: #{send(property.getter).to_json}"
+      end
+
+      if self.respond_to?(:serialize_properties)
+        self.serialize_properties.each do |k,v|
+          fields << "#{k.to_json}: #{v.to_json}"
+        end
+      end
+
+      if self.class.respond_to?(:read_only_attributes) && exclude_read_only
+        self.class.read_only_attributes.each do |property|
+          fields << "#{property.to_json}: #{send(property).to_json}"
+        end
+      end
+
+      # add methods
+      (options[:methods] || []).each do |meth|
+        if self.respond_to?(meth)
+          fields << "#{meth.to_json}: #{send(meth).to_json}"
+        end
+      end
+
+      # Note: if you want to include a whole other model via relation, use :methods
+      # comments.to_json(:relationships=>{:user=>{:include=>[:first_name],:methods=>[:age]}})
+      # add relationships
+      (options[:relationships] || {}).each do |rel,opts|
+        if self.respond_to?(rel)
+          fields << "#{rel.to_json}: #{send(rel).to_json(opts)}"
+        end
+      end
+
+      result << fields.join(', ')
+      result << ' }'
+      result
+    end
+
+    # Serialize a Resource to comma-separated values (CSV).
+    #
+    # @return <String> a CSV representation of the Resource
+    def to_csv(writer = '')
+      FasterCSV.generate(writer) do |csv|
+        row = []
+        self.class.properties(repository.name).each do |property|
+         row << send(property.name).to_s
+        end
+        csv << row
+      end
+    end
+
+    # Serialize a Resource to XML
+    #
+    # @return <REXML::Document> an XML representation of this Resource
+    def to_xml(opts = {})
+
+      to_xml_document(opts).to_s
+    end
+
+    # Serialize a Resource to YAML
+    #
+    # @return <YAML> a YAML representation of this Resource
+    def to_yaml(opts = {})
+      YAML::quick_emit(object_id,opts) do |out|
+        out.map(nil,to_yaml_style) do |map|
+          self.class.properties(repository.name).each do |property|
+            value = send(property.name.to_sym)
+            map.add(property.name, value.is_a?(Class) ? value.to_s : value)
+          end
+          (instance_variable_get("@yaml_addes") || []).each do |k,v|
+            map.add(k.to_s,v)
+          end
+        end
+      end
+    end
+
+    protected
+
+    # Return the name of this Resource - to be used as the root element name.
+    # This can be overloaded.
+    #
+    # @return <String> name of this Resource
+    def xml_element_name
+      Extlib::Inflection.underscore(self.class.name)
+    end
+
+    # Return a REXML::Document representing this Resource
+    #
+    # @return <REXML::Document> an XML representation of this Resource
+    def to_xml_document(opts={}, doc=nil)
+      doc ||= REXML::Document.new
+      root = doc.add_element(xml_element_name)
+
+      #TODO old code base was converting single quote to double quote on attribs
+
+      self.class.properties(repository.name).each do |property|
+          value = send(property.name)
+          node = root.add_element(property.name.to_s)
+          unless property.type == String
+            node.attributes["type"] = property.type.to_s.downcase
+          end
+          node << REXML::Text.new(value.to_s) unless value.nil?
+      end
+      doc
+    end
+
+  end # module Serialize
+
+  module Resource
+    include Serialize
+  end # module Resource
+
+  class Collection
+    def to_yaml(opts = {})
+      to_a.to_yaml(opts)
+    end
+
+    def to_json(opts = {})
+      "[" << map {|e| e.to_json(opts)}.join(",") << "]"
+    end
+
+    def to_xml(opts = {})
+      to_xml_document(opts).to_s
+    end
+
+    def to_csv
+      result = ""
+      each do |item|
+        result << item.to_csv + "\n"
+      end
+      result
+    end
+
+    protected
+    def xml_element_name
+      Extlib::Inflection.tableize(self.model.to_s)
+    end
+
+    def to_xml_document(opts={})
+      doc = REXML::Document.new
+      root = doc.add_element(xml_element_name)
+      root.attributes["type"] = 'array'
+      each do |item|
+        item.send(:to_xml_document, opts, root)
+      end
+      doc
+    end
+  end
+
+end # module DataMapper

data/lib/gems/dm-timestamps-0.9.7/lib/dm-timestamps/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Timestamps
+    VERSION = "0.9.7"
+  end
+end

data/lib/gems/dm-timestamps-0.9.7/lib/dm-timestamps.rb

@@ -0,0 +1,57 @@
+require 'rubygems'
+
+gem 'dm-core', '~>0.9.7'
+require 'dm-core'
+
+module DataMapper
+  module Timestamp
+    TIMESTAMP_PROPERTIES = {
+      :updated_at => lambda { |r| r.updated_at = DateTime.now },
+      :updated_on => lambda { |r| r.updated_on = Date.today   },
+      :created_at => lambda { |r| r.created_at = DateTime.now if r.new_record? && r.created_at.nil? },
+      :created_on => lambda { |r| r.created_on = Date.today   if r.new_record? && r.created_on.nil?},
+    }
+
+    def self.included(model)
+      model.before :save, :set_timestamp_properties
+      model.send :extend, ClassMethods
+    end
+
+    private
+
+    def set_timestamp_properties
+      if dirty?
+        self.class.properties.slice(*TIMESTAMP_PROPERTIES.keys).compact.each do |property|
+          TIMESTAMP_PROPERTIES[property.name][self] unless attribute_dirty?(property.name)
+        end
+      end
+    end
+
+    module ClassMethods
+      def timestamps(*args)
+        if args.empty? then raise ArgumentError, "You need to pass at least one argument." end
+
+        args.each do |ts|
+          case ts
+          when :at
+            property :created_at, DateTime
+            property :updated_at, DateTime
+          when :on
+            property :created_on, Date
+            property :updated_on, Date
+          else
+            unless TIMESTAMP_PROPERTIES.keys.include?(ts)
+              raise InvalidTimestampName, "Invalid timestamp property '#{ts}'."
+            end
+
+            property ts, DateTime
+          end
+        end
+      end
+    end
+
+    class InvalidTimestampName < RuntimeError; end
+  end # module Timestamp
+
+  Resource::append_inclusions Timestamp
+end

data/lib/gems/dm-types-0.9.7/lib/dm-types/bcrypt_hash.rb

@@ -0,0 +1,31 @@
+
+require 'bcrypt'
+
+module DataMapper
+  module Types
+    class BCryptHash < DataMapper::Type
+      primitive String
+      size 60
+
+      def self.load(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String)
+          BCrypt::Password.new(value)
+        else
+          raise ArgumentError.new("+value+ must be nil or a String")
+        end
+      end
+
+      def self.dump(value, property)
+        if value.nil?
+          nil
+        elsif value.is_a?(String)
+          BCrypt::Password.create(value, :cost => BCrypt::Engine::DEFAULT_COST)
+        else
+          raise ArgumentError.new("+value+ must be nil or a String")
+        end
+      end
+    end # class BCryptHash
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/csv.rb

@@ -0,0 +1,28 @@
+module DataMapper
+  module Types
+    class Csv < DataMapper::Type
+      primitive String
+      size 65535
+      lazy true
+
+      def self.load(value, property)
+        case value
+        when String then FasterCSV.parse(value)
+        when Array then value
+        else nil
+        end
+      end
+
+      def self.dump(value, property)
+        case value
+        when Array then
+          FasterCSV.generate do |csv|
+            value.each { |row| csv << row }
+          end
+        when String then value
+        else nil
+        end
+      end
+    end # class Csv
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/enum.rb

@@ -0,0 +1,70 @@
+module DataMapper
+  module Types
+    class Enum < DataMapper::Type(Integer)
+      def self.inherited(target)
+        target.instance_variable_set("@primitive", self.primitive)
+      end
+
+      def self.flag_map
+        @flag_map
+      end
+
+      def self.flag_map=(value)
+        @flag_map = value
+      end
+
+      def self.new(*flags)
+        enum = Class.new(Enum)
+        enum.flag_map = {}
+
+        flags.each_with_index do |flag, i|
+          enum.flag_map[i + 1] = flag
+        end
+
+        enum
+      end
+
+      def self.[](*flags)
+        new(*flags)
+      end
+
+      def self.load(value, property)
+        self.flag_map[value]
+      end
+
+      def self.dump(value, property)
+        case value
+        when Array then value.collect { |v| self.dump(v, property) }
+        else            self.flag_map.invert[value]
+        end
+      end
+
+      def self.typecast(value, property)
+        # Attempt to typecast using the class of the first item in the map.
+        return value if value.nil?
+        case self.flag_map[1]
+          when Symbol then value.to_sym
+          when String then value.to_s
+          when Fixnum then value.to_i
+          else               value
+        end
+      end
+    end # class Enum
+  end # module Types
+
+  if defined?(Validate)
+    module Validate
+      module AutoValidate
+        alias :orig_auto_generate_validations :auto_generate_validations
+        def auto_generate_validations(property)
+          orig_auto_generate_validations(property)
+          return unless property.options[:auto_validation]
+
+          if property.type.ancestors.include?(Types::Enum)
+           validates_within property.name, options_with_message({:set => property.type.flag_map.values}, property, :within)
+          end
+        end
+      end
+    end
+  end
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/epoch_time.rb

@@ -0,0 +1,27 @@
+module DataMapper
+  module Types
+    class EpochTime < DataMapper::Type
+      primitive Integer
+
+      def self.load(value, property)
+        case value
+        when Integer
+          Time.at(value)
+        else
+          value
+        end
+      end
+
+      def self.dump(value, property)
+        case value
+        when Integer
+          value
+        when Time
+          value.to_i
+        when DateTime
+          Time.parse(value.to_s).to_i
+        end
+      end
+    end # class EpochTime
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-types-0.9.7/lib/dm-types/file_path.rb

@@ -0,0 +1,27 @@
+require 'pathname'
+
+module DataMapper
+  module Types
+    class FilePath < DataMapper::Type
+      primitive String
+
+      def self.load(value, property)
+        if value.nil?
+          nil
+        else
+          Pathname.new(value)
+        end
+      end
+
+      def self.dump(value, property)
+        return nil if value.nil?
+        value.to_s
+      end
+
+      def self.typecast(value, property)
+        # Leave alone if a Pathname is given.
+        value.kind_of?(Pathname) ? value : load(value, property)
+      end
+    end # class FilePath
+  end # module Types
+end # module DataMapper