datoki 1.0.1

data/specs/datoki.rb

@@ -0,0 +1,556 @@
+
+describe 'record_errors' do
+
+  it "prevents failing with an exception" do
+    r = Class.new {
+      include Datoki
+      record_errors
+      field(:title) { varchar }
+    }.create
+
+    r.errors.should == {:title=>{:msg=>'Title is required.', :value=>nil}}
+  end
+
+end # === describe record_errors ====================================
+
+describe 'No type' do
+
+  it "requires type to be specified" do
+    should.raise(RuntimeError) {
+      Class.new {
+        include Datoki
+        field(:title) {  }
+      }
+    }.message.should.match /Type not specified/
+  end
+
+end # === describe 'No type' ========================================
+
+describe :varchar do # ================================================
+
+  it "requires field by default" do
+    should.raise(Datoki::Invalid) {
+      Class.new {
+        include Datoki
+        field(:title) { varchar }
+      }.create
+    }.message.should.match /Title is required/i
+  end
+
+  it "raises RuntimeError if allow :null and :min = 0" do
+    should.raise(RuntimeError) {
+      Class.new {
+        include Datoki
+        field(:name) { varchar nil, 0, 50 }
+      }
+    }.message.should.match /varchar can't be both: allow :null && :min = 0/
+  end
+
+  it "fails when varchar is less than min: varchar x, y" do
+    should.raise(Datoki::Invalid) {
+      Class.new {
+        include Datoki
+        field(:title) { varchar 3, 255 }
+      }.create :title => '1'
+    }.message.should.match /Title must be between 3 and 255 characters/i
+  end
+
+  it "fails when varchar is longer than max" do
+    should.raise(Datoki::Invalid) {
+      Class.new {
+        include Datoki
+        field(:title) { varchar 0, 5 }
+      }.create :title => '123456'
+    }.message.should.match /Title must be between 0 and 5 characters/
+  end
+
+  it "fails when varchar does not match pattern: match /../" do
+    should.raise(Datoki::Invalid) {
+      Class.new {
+        include Datoki
+        field :title do
+          varchar
+          match /\A[a-zA-Z0-9]+\z/i, "Title must be only: alphanumeric"
+        end
+      }.create :title => '$! title'
+    }.message.should.match /Title must be only: alphanumeric/
+  end
+
+  it "allows varchar to be nil" do
+    r = Class.new {
+      include Datoki
+      field(:title) {
+        varchar nil, 1, 123
+      }
+    }.create()
+    r.clean_data[:title].should == nil
+  end
+
+  it "sets field to return value of :set_to" do
+    Class.new {
+      include Datoki
+      field(:title) {
+        varchar
+        set_to :custom_error
+        def custom_error
+          'Custom title'
+        end
+      }
+    }.
+    create(:title => 'My Title').
+    clean_data[:title].should.match /Custom title/
+  end
+
+  it "strips varchars by default" do
+    Class.new {
+      include Datoki
+      field(:title) { varchar }
+    }.
+    create(:title => ' my title ').
+    clean_data[:title].should == 'my title'
+  end
+
+  it "can prevent varchar from being stripped" do
+    Class.new {
+      include Datoki
+      field(:title) {
+        varchar
+        disable :strip
+      }
+    }.
+    create(:title => ' my title ').
+    clean_data[:title].should == ' my title '
+  end
+
+end # === describe Datoki ===
+
+describe Numeric do
+
+  it "fails if number is outside the range" do
+    should.raise(Datoki::Invalid) {
+      Class.new {
+        include Datoki
+        field(:age) { smallint 1, 150 }
+      }.create :age=>0
+    }.message.should.match /age must be between 1 and 150/i
+  end
+
+  it "raises an exception if value is a non-numeric varchar." do
+    should.raise(Datoki::Invalid) {
+      Class.new {
+        include Datoki
+        field(:age) { smallint 1, 150 }
+      }.create :age=>'twenty-two'
+    }.message.should.match /age must be numeric/i
+  end
+
+  it "allows nil" do
+    Class.new {
+      include Datoki
+      field(:age) { smallint nil, 1, 99 }
+    }.create(:age=>nil).
+    clean_data[:age].should == nil
+  end
+
+  it "allows nil in an array" do
+    Class.new {
+      include Datoki
+      field(:age) { smallint [nil, 1,2,3,4] }
+    }.create(:age=>nil).
+    clean_data[:age].should == nil
+  end
+
+  it "allows to specify an Array of possible values" do
+    Class.new {
+      include Datoki
+      field(:age) { smallint [1,2,3,4] }
+    }.create(:age=>2).
+    clean_data[:age].should == 2
+  end
+
+  it "fails if value is not in Array of possible values" do
+    should.raise(Datoki::Invalid) {
+      Class.new {
+        include Datoki
+        field(:num) { smallint [1,2,3,4] }
+      }.create :num=>0
+    }.message.should.match /Num can only be: 1, 2, 3, 4/
+  end
+
+end # === describe Numeric
+
+describe "on :create" do
+
+  it "after all fields have been cleaned" do
+    Class.new {
+
+      include Datoki
+
+      on :create, def collect_values
+        clean_data[:values] = clean_data.values.join ', '
+      end
+
+      field(:title) { varchar }
+
+      field(:body) { varchar }
+
+    }.
+    create(:title=>'my title', :body=>'my body').
+    clean_data[:values].should == 'my title, my body'
+  end
+
+  it "runs after validation for a field" do
+    Class.new {
+      include Datoki
+      field(:body) {
+        on :create, def add_stuff
+          clean_data[:body] << ' with new stuff'
+        end
+
+        varchar
+      }
+    }.
+    create(:body=>'the body').
+    clean_data[:body].should == 'the body with new stuff'
+  end
+
+end # === describe on :create
+
+describe "on :update" do
+
+  it "runs after data has been cleaned" do
+    r = Class.new {
+      include Datoki
+      on :update, def do_something
+        clean_data[:vals] = clean_data.values.join ' -- '
+      end
+
+      field(:title) { varchar }
+      field(:body) { varchar }
+    }.new(:title=>'old title')
+    r.update title: ' new title ', :body=>'  new body  '
+    r.clean_data[:vals].should == 'new title -- new body'
+  end
+
+end # === describe on :update
+
+describe "Datoki.db" do
+
+  before {
+
+    CACHE[:datoki_db_test] ||= reset_db <<-EOF
+      CREATE TABLE "datoki_test" (
+        id serial NOT NULL PRIMARY KEY,
+        title varchar(123) NOT NULL,
+        body  text DEFAULT 'hello'
+      );
+    EOF
+
+    @klass = Class.new {
+      include Datoki
+      record_errors
+      table "datoki_test"
+      field(:id) { integer; primary_key }
+      field(:title) { varchar 1, 123 }
+      field(:body) { text nil, 1, 123 }
+    }
+  }
+
+  it 'raises Schema_Conflict if a field is found that allows null, but not specifed to do so' do
+    should.raise(Datoki::Schema_Conflict) {
+      Class.new {
+        include Datoki
+        table :datoki_test
+        field(:id) { integer; primary_key }
+        field(:title) { varchar 1, 123 }
+        field(:body) { text 1, 123 }
+      }
+    }.message.should.match /:allow_null: true != false/
+  end
+
+  it "requires field if value = null and default = null and :allow_null = false" do
+    r = @klass.create :title=>nil, :body=>"hiya"
+    r.errors.should == {:title=>{:msg=>'Title is required.', :value=>nil}}
+  end
+
+  it "requires a value if: :text field, value = (empty string), min = 1, allow null" do
+    r = @klass.create :title=>"The title", :body=>'   '
+    r.errors.should == {:body=>{:msg=>'Body is required.', :value=>""}}
+  end
+
+  it "does not turn strip.empty? strings into nulls" do
+    r = @klass.create :title=>"The title", :body=>'   '
+    r.clean_data[:body].should == ''
+  end
+
+  it "imports field names into class" do
+    @klass.fields.keys.should == [:id, :title, :body]
+  end
+
+  it "imports field types into class" do
+    @klass.fields.values.map { |meta| meta[:type] }.should == [:integer, :varchar, :text]
+  end
+
+  it "removes field from :clean_data if set to nil and database has a default value" do
+    r = @klass.create :title=>'hello', :body=>nil
+    r.clean_data.keys.should == [:title]
+  end
+
+end # === describe Datoki.db
+
+describe "Datoki.db Schema_Conflict" do
+
+  before {
+    CACHE[:schema_conflict] ||= begin
+                                  reset_db <<-EOF
+                                    CREATE TABLE "datoki_test" (
+                                      id     serial NOT NULL PRIMARY KEY,
+                                      title  varchar(123),
+                                      body   varchar(255) NOT NULL,
+                                      created_at  timestamp with time zone NOT NULL DEFAULT timezone('UTC'::text, now())
+                                    );
+                                  EOF
+                                end
+  }
+
+  it "raises Schema_Conflict when specified to allow nil, but db doesn not" do
+    should.raise(Datoki::Schema_Conflict) {
+      Class.new {
+        include Datoki
+        table :datoki_test
+        field(:body) { varchar nil, 1, 255 }
+      }
+    }.message.should.match /:allow_null: false != true/i
+  end
+
+  it "raises Schema_Conflict when there is a :max_length conflict" do
+    should.raise(Datoki::Schema_Conflict) {
+      Class.new {
+        include Datoki
+        table :datoki_test
+        field(:title) { varchar nil, 1, 200 }
+      }
+    }.message.should.match /:max: 123 != 200/i
+  end
+
+end # === describe Datoki.db
+
+describe "Datoki.db :varchar" do
+
+  before {
+    CACHE[:datoki_db_varchar] ||= reset_db <<-EOF
+      CREATE TABLE "datoki_test" (
+        id serial NOT NULL PRIMARY KEY,
+        title varchar(123) NOT NULL,
+        body  text
+      );
+    EOF
+    @klass = Class.new {
+      include Datoki
+      table "datoki_test"
+      field(:id) { primary_key }
+      field(:title) { varchar 1, 123 }
+      field(:body) { text nil, 1, 3000 }
+    }
+  }
+
+  it "imports max length" do
+    @klass.fields[:title][:max].should == 123
+  end
+
+  it "sets :min = 1 (by default, during import, if NOT NULL)" do
+    @klass.fields[:title][:min].should == 1
+  end
+
+  it "sets :min = 1 (by default, during import, if :allow_null = true)" do
+    @klass.fields[:body][:min].should == 1
+  end
+
+end # === describe Datoki.db :varchar
+
+describe 'Datoki.db number' do
+
+  before {
+    CACHE[:datoki_db_number] ||= begin
+                                    reset_db <<-EOF
+                                      CREATE TABLE "datoki_test" (
+                                        id serial NOT NULL PRIMARY KEY,
+                                        parent_id smallint NOT NULL,
+                                        title varchar(123) NOT NULL,
+                                        body  text
+                                      );
+                                    EOF
+                                  end
+  }
+
+  it "does not set :min = 1" do
+    Class.new {
+      include Datoki
+      table "datoki_test"
+      field(:parent_id) { smallint }
+    }.
+    fields[:parent_id][:min].should == nil
+  end
+
+end # === Datoki.db number
+
+describe 'Datoki.db :new' do
+
+  before {
+    CACHE[:datoki_db_new] ||= begin
+                                reset_db <<-EOF
+                                  CREATE TABLE "datoki_test" (
+                                    id serial NOT NULL PRIMARY KEY,
+                                    parent_id smallint NOT NULL,
+                                    title varchar(123) NOT NULL,
+                                    body  text
+                                  );
+                                EOF
+                              end
+  }
+
+  it "raises Schema_Conflict if field has not been defined, but exists in the db schema" do
+    should.raise(Datoki::Schema_Conflict) {
+      Class.new {
+        include Datoki
+        table :datoki_test
+        field(:id) { primary_key }
+        field(:parent_id) { smallint }
+        field(:body) { text nil, 1, 222 }
+      }.new
+    }.message.should.match /:title has not been defined/
+  end
+
+end # === describe Datoki.db :new
+
+
+describe :href do
+
+  before {
+    CACHE[:datoki_db_href] ||= begin
+                                reset_db <<-EOF
+                                  CREATE TABLE "datoki_test" (
+                                    id       serial       NOT NULL PRIMARY KEY,
+                                    homepage varchar(255) NOT NULL
+                                  );
+                                EOF
+                              end
+
+    @klass = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:id) { primary_key }
+      field(:homepage) { href }
+    }
+  }
+
+  it "sets :type to :varchar" do
+    @klass.fields[:homepage][:type].should == :varchar
+  end
+
+  it "sets :max to 255" do
+    @klass.fields[:homepage][:max].should == 255
+  end
+
+  it "sets :min to 0" do
+    @klass.fields[:homepage][:min].should == 0
+  end
+
+  it "sets allow :null to false" do
+    @klass.fields[:homepage][:allow][:null].should == false
+  end
+
+  it "sets :html_escape to :href" do
+    @klass.fields[:homepage][:html_escape].should == :href
+  end
+
+  it "accepts a :min and :max" do
+    CACHE[:datoki_db_href] = nil
+    reset_db <<-EOF
+      CREATE TABLE "datoki_test" (
+        id       serial       NOT NULL PRIMARY KEY,
+        homepage varchar(123) NOT NULL
+      );
+    EOF
+    k = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:id) { primary_key }
+      field(:homepage) { href 5, 123 }
+    }
+    k.fields[:homepage][:min].should == 5
+    k.fields[:homepage][:max].should == 123
+  end
+
+  it "sets :min = 1 when null is allowed." do
+    CACHE[:datoki_db_href] = nil
+    reset_db <<-EOF
+      CREATE TABLE "datoki_test" (
+        id       serial       NOT NULL PRIMARY KEY,
+        homepage varchar(222)
+      );
+    EOF
+    k = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:id) { primary_key }
+      field(:homepage) { href nil }
+    }
+    k.fields[:homepage][:min].should == 1
+    k.fields[:homepage][:max].should == 222
+  end
+
+end # === describe :href
+
+
+describe :html_escape do
+
+  before {
+    CACHE[:datoki_db_escape] ||= begin
+                                   reset_db <<-EOF
+                                    CREATE TABLE "datoki_test" (
+                                      id serial NOT NULL PRIMARY KEY,
+                                      parent_id smallint NOT NULL,
+                                      title varchar(123) NOT NULL,
+                                      url   varchar(255) NOT NULL,
+                                      body  text         NOT NULL
+                                    );
+                                   EOF
+                                 end
+
+    @klass = Class.new {
+      include Datoki
+      table :datoki_test
+      field(:id) { primary_key }
+      field(:parent_id) { smallint }
+      field(:title) { varchar 1, 123 }
+      field(:url) { href }
+      field(:body) { text 1, 244 }
+    }
+  }
+
+  it "returns a hash of all defined fields" do
+    @klass.html_escape.should == {
+      :id        => :number,
+      :parent_id => :number,
+      :title     => :string,
+      :url       => :href,
+      :body      => :string
+    }
+  end
+
+  it "sets :href for urls" do
+    @klass.html_escape[:url].should == :href
+  end
+
+end # === describe :html_escape
+
+
+
+
+
+
+
+
+
+

data/specs/lib/helpers.rb

@@ -0,0 +1,25 @@
+
+require 'Bacon_Colored'
+require 'datoki'
+require 'pry'
+require 'sequel'
+
+DB = Sequel.connect ENV['DATABASE_URL']
+DB.cache_schema = false
+
+Datoki.db DB
+CACHE = {}
+
+def reset_db sql = nil
+  DB << "DROP TABLE IF EXISTS \"datoki_test\";"
+  sql ||= <<-EOF
+    CREATE TABLE "datoki_test" (
+      id    serial       NOT NULL PRIMARY KEY,
+      title varchar(123) NOT NULL,
+      body  text
+    );
+  EOF
+  DB << sql
+end # === def reset_db
+
+reset_db

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: datoki
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- da99
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: Bacon_Colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '4.12'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.17'
+description: "\n    My way of dealing with postgresql 9.3+ databases.\n  "
+email:
+- i-hate-spam-1234567@mailinator.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- VERSION
+- datoki.gemspec
+- lib/datoki.rb
+- specs/datoki.rb
+- specs/lib/helpers.rb
+homepage: https://github.com/da99/datoki
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A gem to manage PGsql records.
+test_files: []