dm-is-reflective 1.1.0 → 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4a92f58af6a1c63b6bb445e06fdc573239ef558
+  data.tar.gz: 4577c3ed73a122c4ddd09e62c8c0e64802e49540
+SHA512:
+  metadata.gz: f271c3864848cfb098e7f7b32887831700617668c001a56f25f0be1a0497d0e488db5f8970ad7e96ee9ab9aecb4fd333b4fa71c70de48afd435929c266751f5c
+  data.tar.gz: a139f550d6b69b36ddb824eec2ca59b4ec157d1289d39cdcc31f268a5d50a7abb90abcb1b48a05f7cdb0784edfb31b28440078adaef7f3b721ccb82d5f7e1944

data/.travis.yml

@@ -0,0 +1,15 @@
+before_install:
+  - 'git submodule update --init'
+  - mysql -e 'create database myapp_test;'
+  - psql -c 'create database myapp_test;' -U postgres
+
+script: 'ruby -r bundler/setup -S rake test'
+
+env:
+  - 'RBXOPT=-X19'
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - rbx-head
+  - jruby-head

data/CHANGES.md

@@ -1,5 +1,13 @@
 # CHANGES
 
+## dm-is-reflective 1.2.0, 2013-05-14
+
+* We got a bunch of internal renaming.
+* Added DataMapper::Resource#to_source.
+* Added an executable which generates sources for you.
+* Fixed MySQL issues with setting up with a hash rather than URI.
+* Fixed SQLite issues without loading dm-migrations.
+
 ## dm-is-reflective 1.1.0, 2013-01-11
 
 * The need for dm-migrations is now removed.

data/Gemfile

@@ -1,3 +1,7 @@
 
-source 'http://rubygems.org'
+source 'https://rubygems.org'
+
 gemspec
+
+gem 'rake'
+gem 'bacon'

data/README.md

@@ -1,4 +1,4 @@
-# dm-is-reflective
+# dm-is-reflective [![Build Status](https://secure.travis-ci.org/godfat/dm-is-reflective.png?branch=master)](http://travis-ci.org/godfat/dm-is-reflective)
 
 by Lin Jen-Shin ([godfat](http://godfat.org))
 
@@ -21,99 +21,116 @@ It creates mappings between existing columns and model's properties.
 ## INSTALLATION:
 
 ``` shell
-    gem install dm-is-reflective
+gem install dm-is-reflective
 ```
 
 ``` ruby
-    gem 'dm-is-reflective',
-      :git => 'git://github.com/godfat/dm-is-reflective.git',
-      :submodules => true
+gem 'dm-is-reflective',
+  :git => 'git://github.com/godfat/dm-is-reflective.git',
+  :submodules => true
 ```
 
 ## SYNOPSIS:
 
+### Generating sources from a DATABASE_URI
+
+We also have an executable to generate sources for you.
+
+```
+Usage: dm-is-reflective DATABASE_URI
+  -s, --scope SCOPE       SCOPE where the models should go (default: Object)
+  -o, --output DIRECTORY  DIRECTORY where the output goes (default: dm-is-reflective)
+  -h, --help              Print this message
+  -v, --version           Print the version
+```
+
+### API
+
 ``` ruby
-    require 'dm-is-reflective' # this would require 'dm-core'
-    dm = DataMapper.setup :default, 'sqlite:db/dev.sqlite3'
-
-    class User
-      include DataMapper::Resource
-      is :reflective
-
-      # map all, returning an array of properties indicating fields it mapped
-      reflect /.*/  # e.g. => [#<Property:#<Class:0x18f89b8>:id>,
-                    #          #<Property:#<Class:0x18f89b8>:title>,
-                    #          #<Property:#<Class:0x18f89b8>:body>,
-                    #          #<Property:#<Class:0x18f89b8>:user_id>]
-
-      # map all (with no argument at all)
-      reflect
-
-      # mapping for field name ended with _at, and started with salt_
-      reflect /_at$/, /^salt_/
-
-      # mapping id and email
-      reflect :id, :email
-
-      # mapping all fields with type String, and id
-      reflect String, :id
-
-      # mapping login, and all fields with type Integer
-      reflect :login, Integer
-    end
-
-    # there's no guarantee of the order in storages array
-    dm.storages
-    # => ['users']
-
-    # there's no guarantee of the order in fields array
-    User.fields
-    # => [[:created_at,  DateTime, {:required => false}],
-          [:email,       String,   {:required => false, :length => 255,
-                                    :default  => 'nospam@nospam.tw'}],
-          [:id,          Serial,   {:required => true, :serial => true,
-                                    :key      => true}],
-          [:salt_first,  String,   {:required => false, :length => 50}],
-          [:salt_second, String,   {:required => false, :length => 50}]]
-
-    dm.fields('users').sort_by{ |field| field.first.to_s } ==
-           User.fields.sort_by{ |field| field.first.to_s }
-    # => true
-
-    dm.storages_and_fields
-    # => {'users' => [[:id,          Serial,   {:required => true,
-                                                :serial   => true,
-                                                :key      => true}],
-                      [:email,       String,   {:required => false,
-                                                :default  =>
-                                                  'nospam@nospam.tw'}],
-                      [:created_at,  DateTime, {:required => false}],
-                      [:salt_first,  String,   {:required => false,
-                                                :length   => 50}],
-                      [:salt_second, String,   {:required => false,
-                                                :length   => 50}]]}
-
-    # there's no guarantee of the order in returned array
-    dm.auto_genclass!
-    # => [DataMapper::Is::Reflective::User,
-          DataMapper::Is::Reflective::SchemaInfo,
-          DataMapper::Is::Reflective::Session]
-
-    # you can change the scope of generated models:
-    dm.auto_genclass! :scope => Object
-    # => [User, SchemaInfo, Session]
-
-    # you can generate classes for tables you specified only:
-    dm.auto_genclass! :scope => Object, :storages => /^phpbb_/
-    # => [PhpbbUser, PhpbbPost, PhpbbConfig]
-
-    # you can generate classes with String too:
-    dm.auto_genclass! :storages => ['users', 'config'], :scope => Object
-    # => [User, Config]
-
-    # you can generate a class only:
-    dm.auto_genclass! :storages => 'users'
-    # => [DataMapper::Is::Reflective::User]
+require 'dm-is-reflective' # this would require 'dm-core'
+dm = DataMapper.setup :default, 'sqlite::memory:'
+
+class User
+  include DataMapper::Resource
+  is :reflective
+
+  # map all, returning an array of properties indicating fields it mapped
+  reflect /.*/  # e.g. => [#<Property:#<Class:0x18f89b8>:id>,
+                #          #<Property:#<Class:0x18f89b8>:title>,
+                #          #<Property:#<Class:0x18f89b8>:body>,
+                #          #<Property:#<Class:0x18f89b8>:user_id>]
+
+  # map all (with no argument at all)
+  reflect
+
+  # mapping for field name ended with _at, and started with salt_
+  reflect /_at$/, /^salt_/
+
+  # mapping id and email
+  reflect :id, :email
+
+  # mapping all fields with type String, and id
+  reflect String, :id
+
+  # mapping login, and all fields with type Integer
+  reflect :login, Integer
+end
+
+# there's no guarantee of the order in storages array
+dm.storages
+# => ['users']
+
+# there's no guarantee of the order in fields array
+User.fields
+# => [[:created_at,  DateTime, {:required => false}],
+      [:email,       String,   {:required => false, :length => 255,
+                                :default  => 'nospam@nospam.tw'}],
+      [:id,          Serial,   {:required => true, :serial => true,
+                                :key      => true}],
+      [:salt_first,  String,   {:required => false, :length => 50}],
+      [:salt_second, String,   {:required => false, :length => 50}]]
+
+dm.fields('users').sort_by{ |field| field.first.to_s } ==
+       User.fields.sort_by{ |field| field.first.to_s }
+# => true
+
+dm.storages_and_fields
+# => {'users' => [[:id,          Serial,   {:required => true,
+                                            :serial   => true,
+                                            :key      => true}],
+                  [:email,       String,   {:required => false,
+                                            :default  =>
+                                              'nospam@nospam.tw'}],
+                  [:created_at,  DateTime, {:required => false}],
+                  [:salt_first,  String,   {:required => false,
+                                            :length   => 50}],
+                  [:salt_second, String,   {:required => false,
+                                            :length   => 50}]]}
+
+# there's no guarantee of the order in returned array
+dm.auto_genclass!
+# => [DataMapper::Is::Reflective::User,
+      DataMapper::Is::Reflective::SchemaInfo,
+      DataMapper::Is::Reflective::Session]
+
+# you can change the scope of generated models:
+dm.auto_genclass! :scope => Object
+# => [User, SchemaInfo, Session]
+
+# you can generate classes for tables you specified only:
+dm.auto_genclass! :scope => Object, :storages => /^phpbb_/
+# => [PhpbbUser, PhpbbPost, PhpbbConfig]
+
+# you can generate classes with String too:
+dm.auto_genclass! :storages => ['users', 'config'], :scope => Object
+# => [User, Config]
+
+# you can generate a class only:
+dm.auto_genclass! :storages => 'users'
+# => [DataMapper::Is::Reflective::User]
+
+# you can also generate the source from models:
+puts User.to_source
 ```
 
 ## CONTRIBUTORS:

data/Rakefile

@@ -15,7 +15,7 @@ task 'gem:spec' do
   Gemgem.spec = Gemgem.create do |s|
     require     'dm-is-reflective/version'
     s.name    = 'dm-is-reflective'
-    s.version = DataMapper::Is::Reflective::VERSION
+    s.version = DmIsReflective::VERSION
 
     %w[dm-core dm-do-adapter].each{ |g| s.add_runtime_dependency(g) }
     %w[dm-migrations
@@ -26,16 +26,3 @@ task 'gem:spec' do
 
   Gemgem.write
 end
-
-desc 'auto_migrate database'
-task 'auto_migrate' do
-  require 'dm-migrations'
-  require './test/abstract'
-  require './test/test_dm-is-reflective'
-  include Abstract
-  [:SqliteTest, :PostgresTest, :MysqlTest].each do |db|
-    next unless Object.const_defined?(db)
-    Object.const_get(db).setup_data_mapper
-    [User, Comment, SuperUser].each(&:auto_migrate!)
-  end
-end

data/bin/dm-is-reflective

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'dm-is-reflective/runner'
+DmIsReflective::Runner.run

data/dm-is-reflective.gemspec

@@ -2,43 +2,55 @@
 
 Gem::Specification.new do |s|
   s.name = "dm-is-reflective"
-  s.version = "1.1.0"
+  s.version = "1.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Lin Jen-Shin (godfat)"]
-  s.date = "2013-01-11"
+  s.date = "2013-05-14"
   s.description = "DataMapper plugin that helps you manipulate an existing database.\nIt creates mappings between existing columns and model's properties."
   s.email = ["godfat (XD) godfat.org"]
+  s.executables = ["dm-is-reflective"]
   s.files = [
   ".gitignore",
   ".gitmodules",
+  ".travis.yml",
   "CHANGES.md",
   "Gemfile",
   "LICENSE",
   "README.md",
   "Rakefile",
   "TODO.md",
+  "bin/dm-is-reflective",
   "dm-is-reflective.gemspec",
   "lib/dm-is-reflective.rb",
-  "lib/dm-is-reflective/is/adapters/data_objects_adapter.rb",
-  "lib/dm-is-reflective/is/adapters/mysql_adapter.rb",
-  "lib/dm-is-reflective/is/adapters/postgres_adapter.rb",
-  "lib/dm-is-reflective/is/adapters/sqlite_adapter.rb",
-  "lib/dm-is-reflective/is/reflective.rb",
+  "lib/dm-is-reflective/adapters/data_objects_adapter.rb",
+  "lib/dm-is-reflective/adapters/mysql_adapter.rb",
+  "lib/dm-is-reflective/adapters/postgres_adapter.rb",
+  "lib/dm-is-reflective/adapters/sqlite_adapter.rb",
+  "lib/dm-is-reflective/reflective.rb",
+  "lib/dm-is-reflective/runner.rb",
+  "lib/dm-is-reflective/test.rb",
   "lib/dm-is-reflective/version.rb",
   "task/.gitignore",
   "task/gemgem.rb",
-  "test/abstract.rb",
   "test/setup_db.sh",
-  "test/test_dm-is-reflective.rb"]
+  "test/test_mysql.rb",
+  "test/test_postgres.rb",
+  "test/test_sqlite.rb",
+  "test/test_to_source.rb"]
   s.homepage = "https://github.com/godfat/dm-is-reflective"
+  s.licenses = ["Apache License 2.0"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
+  s.rubygems_version = "2.0.3"
   s.summary = "DataMapper plugin that helps you manipulate an existing database."
-  s.test_files = ["test/test_dm-is-reflective.rb"]
+  s.test_files = [
+  "test/test_mysql.rb",
+  "test/test_postgres.rb",
+  "test/test_sqlite.rb",
+  "test/test_to_source.rb"]
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<dm-core>, [">= 0"])

data/lib/dm-is-reflective.rb

@@ -1,12 +1,11 @@
 
-gem 'dm-core', '>=1.0.0'
 require 'dm-core'
 require 'dm-do-adapter'
 
-require 'dm-is-reflective/is/reflective'
-require 'dm-is-reflective/is/adapters/data_objects_adapter'
+require 'dm-is-reflective/reflective'
+require 'dm-is-reflective/adapters/data_objects_adapter'
 
-DataMapper::Model.append_extensions(DataMapper::Is::Reflective)
+DataMapper::Model.append_extensions(DmIsReflective)
 
 DataMapper::Adapters::DataObjectsAdapter.__send__(:include,
-  DataMapper::Is::Reflective::DataObjectsAdapter)
+  DmIsReflective::DataObjectsAdapter)

data/lib/dm-is-reflective/adapters/data_objects_adapter.rb

@@ -0,0 +1,136 @@
+
+module DmIsReflective::DataObjectsAdapter
+  include DataMapper
+
+  # returns all tables' name in the repository.
+  #  e.g.
+  #       ['comments', 'users']
+  def storages
+    reflective_auto_load_adapter_extension
+    storages # call the overrided method
+  end
+
+  # returns all fields, with format [[name, type, attrs]]
+  #  e.g.
+  #       [[:created_at,  DateTime, {:required => false}],
+  #        [:email,       String,   {:required => false, :size => 255,
+  #                                  :default => 'nospam@nospam.tw'}],
+  #        [:id, DataMapper::Property::Serial,  {:required => true, :serial => true,
+  #                                  :key => true}],
+  #        [:salt_first,  String,   {:required => false, :size => 50}],
+  #        [:salt_second, String,   {:required => false, :size => 50}]]
+  def fields storage
+    reflective_query_storage(storage).map{ |field|
+      attr = reflective_attributes(field)
+      type = reflective_lookup_primitive(reflective_primitive(field))
+      pick = if attr[:serial] && type == Integer
+               Property::Serial
+             else
+               type
+             end
+      [reflective_field_name(field).to_sym, pick, attr]
+    }
+  end
+
+  # returns a hash with storage names in keys and
+  # corresponded fields in values. e.g.
+  #   {'users' => [[:id,          Integer,  {:required => true,
+  #                                          :serial => true,
+  #                                          :key => true}],
+  #                [:email,       String,   {:required => false,
+  #                                          :default => 'nospam@nospam.tw'}],
+  #                [:created_at,  DateTime, {:required => false}],
+  #                [:salt_first,  String,   {:required => false, :size => 50}],
+  #                [:salt_second, String,   {:required => false, :size => 50}]]}
+  # see AbstractAdapter#storages and AbstractAdapter#fields for detail
+  def storages_and_fields
+    storages.inject({}){ |result, storage|
+      result[storage] = fields(storage)
+      result
+    }
+  end
+
+  # automaticly generate model class(es) and reflect
+  # all fields with reflect /.*/ for you.
+  #  e.g.
+  #       dm.auto_genclass!
+  #       # => [DataMapper::Is::Reflective::User,
+  #       #     DataMapper::Is::Reflective::SchemaInfo,
+  #       #     DataMapper::Is::Reflective::Session]
+  #
+  # you can change the scope of generated models:
+  #  e.g.
+  #       dm.auto_genclass! :scope => Object
+  #       # => [User, SchemaInfo, Session]
+  #
+  # you can generate classes for tables you specified only:
+  #  e.g.
+  #       dm.auto_genclass! :scope => Object, :storages => /^phpbb_/
+  #       # => [PhpbbUser, PhpbbPost, PhpbbConfig]
+  #
+  # you can generate classes with String too:
+  #  e.g.
+  #       dm.auto_genclass! :storages => ['users', 'config'], :scope => Object
+  #       # => [User, Config]
+  #
+  # you can generate a class only:
+  #  e.g.
+  #       dm.auto_genclass! :storages => 'users'
+  #       # => [DataMapper::Is::Reflective::User]
+  def auto_genclass! opts = {}
+    opts[:scope] ||= DmIsReflective
+    opts[:storages] ||= /.*/
+    opts[:storages] = [opts[:storages]].flatten
+
+    storages.map{ |storage|
+
+      mapped = opts[:storages].each{ |target|
+        case target
+          when Regexp;
+            break storage if storage =~ target
+
+          when Symbol, String;
+            break storage if storage == target.to_s
+
+          else
+            raise ArgumentError.new("invalid argument: #{target.inspect}")
+        end
+      }
+
+      reflective_genclass(mapped, opts[:scope]) if mapped.kind_of?(String)
+    }.compact
+  end
+
+  private
+  def reflective_query_storage storage
+    reflective_auto_load_adapter_extension
+    reflective_query_storage(storage) # call the overrided method
+  end
+
+  def reflective_genclass storage, scope
+    model = Class.new
+    model.__send__(:include, Resource)
+    model.is(:reflective)
+    model.storage_names[:default] = storage
+    scope.const_set(Inflector.classify(storage), model)
+    model.__send__(:reflect, /.*/)
+    model.finalize if model.respond_to?(:finalize)
+    model
+  end
+
+  def reflective_lookup_primitive primitive
+    raise TypeError.new("#{primitive} not found for #{self.class}")
+  end
+
+  def reflective_auto_load_adapter_extension
+    # TODO: can we fix this shit in dm-mysql-adapter?
+    name = options[:adapter] || options['adapter']
+    # TODO: can we fix this adapter name in dm-sqlite-adapter?
+    adapter = name.sub(/\Asqlite3\Z/, 'sqlite')
+
+    require "dm-is-reflective/adapters/#{adapter}_adapter"
+    class_name = "#{Inflector.camelize(adapter)}Adapter"
+    Adapters.const_get(class_name).__send__(:include,
+      DmIsReflective.const_get(class_name))
+  end
+end