typero 0.9.0 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e78c338c182793ab2bffd1b4c5469d5285f57f55697402b6e80fb1881a3f7a8
-  data.tar.gz: 18a803b38ef8a24cb3756a43e5b5704082a08f4d805be57239cb054c28e6f132
+  metadata.gz: 0bcd151d7d7b875c6db7aec28c85c3abcf10596a4f596622050d7e18cdb81e9e
+  data.tar.gz: d54b9c76d6587e5872f19deba20febd7430e19022fe869a1360339c8156205d9
 SHA512:
-  metadata.gz: 1c02d8cec42f465c5cf34b0b69c856cf193f1c5e289898af0aefdebf1d61ed91c95148a1fa9ca1c047a07810c99bd518946dbfe323e0e53c4502b66b08910c85
-  data.tar.gz: de185fca3ac80a4e7e9d6b87778872b3b352f89678f334e24b0047480d401cbd0abf95bb8940ba0e29d9d3f485ef62521b38335f1f6cc3a7d1f59194383f4a67
+  metadata.gz: 5b639372e86d329ef150809f52f964a459c3faf369a86d219292a2af6b8364ed5c2745079d409944472ec59316cae690e0f1d554cecdeacb625bb5ccf4b39f29
+  data.tar.gz: 0e887a10b853325c7b27f3c90ab57b3c1987d38576e3f1128fb27eb4982d2aaefdbf6e5ded9e80a75c7085c5674686196b13653eed62db853d6d50fe0c15ad39

data/.version

@@ -1 +1 @@
-0.9.0
+0.9.5

data/lib/adapters/sequel.rb

@@ -1,62 +1,45 @@
 # frozen_string_literal: true
 
-module Sequel::Plugins::TyperoAttributes
+module Sequel::Plugins::Typero
   module ClassMethods
     def typero
-      Typero.new self
+      Typero.schema self
     end
   end
 
   module InstanceMethods
     # calling typero! on any object will validate all fields
-    def typero! field_name=nil
-      return unless Typero.defined?(self.class)
+    def validate
+      super
 
-      typero = self.class.typero
+      schema = Typero.schema(self.class) || return
 
-      typero.validate(self) do |name, err|
+      schema.validate(self) do |name, err|
         errors.add(name, err) unless (errors.on(name) || []).include?(err)
       end
 
       # this are rules unique to database, so we check them here
-      typero.rules.each do |field, rule|
-        self[field] ||= {} if rule[:type] == 'hash'
-
+      schema.rules.each do |field, rule|
         # check uniqe fields
-        if rule[:unique]
+        if unique = rule.dig(:meta, :unique)
           id    = self[:id] || 0
           value = self[field]
 
           # we only check if field is changed
           if value.present? && column_changed?(field) && self.class.xwhere('LOWER(%s)=LOWER(?) and id<>?' % field, value, id).first
-            error = rule[:unique].class == TrueClass ? %[Value '"#{value}"' for #{field} allready exists] : rule[:unique]
+            error = unique.class == TrueClass ? %[Value "#{value}" for field "#{field}" has been already used, please chose another value.] : unique
             errors.add(field, error) unless (errors.on(field) || []).include?(error)
           end
         end
 
         # check protected fields
-        if rule[:protected] && self[:id]
+        if prot = rule.dig(:meta, :protected) && self[:id]
           if column_changed?(field)
-            error = rule[:protected].class == TrueClass ? "value once defined can't be overwritten." : rule[:protected]
+            error = prot.class == TrueClass ? "value once defined can't be overwritten." : prot
             errors.add(field, error) unless (errors.on(field) || []).include?(error)
           end
         end
       end
-
-      # check single field if single field given
-      if field_name
-        raise ArgumentError.new 'Field :%s not found in %s' % [field_name, self] unless self[field_name]
-        return unless errors.on(field_name)
-
-        errors.on(field_name).join(', ')
-      end
-
-      true
-    end
-
-    def validate
-      typero!
-      super
     end
   end
 
@@ -65,5 +48,5 @@ module Sequel::Plugins::TyperoAttributes
   end
 end
 
-Sequel::Model.plugin :typero_attributes
+# Sequel::Model.plugin :typero
 

data/lib/typero/params.rb

@@ -2,7 +2,7 @@
 
 module Typero
   class Params
-    attr_reader :rules, :db_rules
+    attr_reader :db_rules
 
     def initialize &block
       @db_rules = []
@@ -10,10 +10,14 @@ module Typero
       instance_exec &block
     end
 
+    def rules
+      @rules.dup
+    end
+
     private
 
     # used in dsl to define schema field options
-    def set field, *args
+    def set field, *args, &block
       raise "Field name not given (Typero)" unless field
 
       if args.first.is_a?(Hash)
@@ -27,12 +31,25 @@ module Typero
 
       field = field.to_s
 
+      if field.include?('!')
+        if block
+          field = field.sub('!', '')
+          @block_type = field.to_sym
+          instance_exec &block
+          @block_type = nil
+          return
+        else
+          raise ArgumentError.new 'If you use ! you have to provide a block'
+        end
+      end
+
       # name? - opional name
       if field.include?('?')
         field = field.sub('?', '')
         opts[:required] = false
       end
 
+      opts[:required] = opts.delete(:req) unless opts[:req].nil?
       opts[:required] = true if opts[:required].nil?
 
       # array that allows duplicates
@@ -47,28 +64,41 @@ module Typero
         opts[:array] = true
       end
 
+      opts[:type] = @block_type if @block_type
+
       # Boolean
-      if opts[:type].is_a?(TrueClass)
+      if opts[:type].is_a?(TrueClass) || opts[:type] == :true
         opts[:required] = false
         opts[:default]  = true
         opts[:type]     = :boolean
-      elsif opts[:type].is_a?(FalseClass)
-        opts[:required] = false
-        opts[:default]  = false
+      elsif opts[:type].is_a?(FalseClass) || opts[:type] == :false || opts[:type] == :boolean
+        opts[:required] = false if opts[:required].nil?
+        opts[:default]  = false if opts[:default].nil?
         opts[:type]     = :boolean
       end
 
+      # model / schema
+      if opts[:type].class.ancestors.include?(Typero::Schema)
+        opts[:model] = opts.delete(:type)
+      end
       opts[:model] = opts.delete(:schema) if opts[:schema]
       opts[:type]  = :model if opts[:model]
 
+      if block_given?
+        opts[:type]  = :model
+        opts[:model] = Typero.schema &block
+      end
+
       opts[:type] ||= 'string'
       opts[:type]   = opts[:type].to_s.downcase.to_sym
 
       opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
 
       # chek alloed params, all optional should go in meta
-      result = opts.keys - Typero::Type::OPTS_KEYS
-      raise ArgumentError.new('Unallowed Type params found: "%s", allowed: %s' % [result.join(' and '), Typero::Type::OPTS_KEYS.sort]) if result.length > 0
+      opts.keys.each do |key|
+        type = Typero::Type.load opts[:type]
+        type.allowed_opt?(key) {|err| raise ArgumentError, err }
+      end
 
       field = field.to_sym
 
@@ -93,7 +123,7 @@ module Typero
     # set :emails, Array[:email]
     # email Array[:emails]
     def method_missing field, *args, &block
-      set field, *args
+      set field, *args, &block
     end
   end
 end

data/lib/typero/schema.rb

@@ -1,7 +1,5 @@
 module Typero
   class Schema
-    SCHEMAS = {}
-
     # accepts dsl block to
     def initialize &block
       raise "Params not defined" unless block_given?
@@ -10,42 +8,69 @@ module Typero
 
     # validates any instance object with hash variable interface
     # it also coarces values
-    def validate object
-      @object = object
-      @errors = {}
+    def validate object, options=nil
+      @options = options || {}
+      @object  = object
+      @errors  = {}
+
+      # remove undefined keys if Hash provided
+      if @options[:strict] && object.is_a?(Hash)
+        undefined = object.keys.map(&:to_s) - @schema.rules.keys.map(&:to_s)
+        object.delete_if { |k, _| undefined.include?(k.to_s) }
+      end
 
       @schema.rules.each do |field, opts|
+        # force filed as a symbol
+        field = field.to_sym
+
+        for k in opts.keys
+          opts[k] = @object.instance_exec(&opts[k]) if opts[k].is_a?(Proc)
+        end
+
         # set value to default if value is blank and default given
         @object[field] = opts[:default] if opts[:default] && @object[field].blank?
 
-        # get field value
-        value = @object[field]
+        if @object.respond_to?(:key?)
+          if @object.key?(field)
+            value = @object[field]
+          elsif @object.key?(field.to_s)
+            # invalid string key, needs fix
+            value = @object[field] = @object.delete(field.to_s)
+          end
+        else
+          value = @object[field]
+        end
 
         if opts[:array]
-          unless value.is_a?(Array)
-            opts[:delimiter] ||= /\s*,\s*/
+          unless value.respond_to?(:each)
+            opts[:delimiter] ||= /\s*[,\n]\s*/
             value = value.to_s.split(opts[:delimiter])
           end
 
           value = value
-            .map { |el| check_filed_value field, el, opts }
-            .map { |el| el.to_s == '' ? nil : el }
+            .flatten
+            .map { |el| el.to_s == '' ? nil : check_filed_value(field, el, opts) }
             .compact
 
           value = Set.new(value).to_a unless opts[:duplicates]
 
           opts[:max_count] ||= 100
-          add_error(field, 'Max number of array elements is %d, you have %d' % [opts[:max_count], value.length], opts) if value.length > opts[:max_count]
+          add_error(field, 'Max number of array elements is %d, you have %d' % [opts[:max_count], value.length], opts) if value && value.length > opts[:max_count]
+          add_error(field, 'Min number of array elements is %d, you have %d' % [opts[:min_count], value.length], opts) if value && opts[:min_count] && value.length < opts[:min_count]
 
           add_required_error field, value.first, opts
         else
+          value = nil if value.to_s == ''
+
+          # if value is not list of allowed values, raise error
+          allowed = opts[:allow] || opts[:allowed] || opts[:values]
+          if value && allowed && !allowed.map(&:to_s).include?(value.to_s)
+            add_error field, 'Value "%s" is not allowed' % value, opts
+          end
+
           value = check_filed_value field, value, opts
-          add_required_error field, value, opts
-        end
 
-        # if value is not list of allowed values, raise error
-        if opts[:allowed] && !opts[:values].include?(value)
-          add_error field, 'Value "%s" is not allowed' % value, opts
+          add_required_error field, value, opts
         end
 
         # present empty string values as nil
@@ -126,7 +151,13 @@ module Typero
       check = klass.constantize.new value, opts
       check.get
     rescue TypeError => e
-      add_error field, e.message, opts
+      if e.message[0] == '{'
+        for key, msg in JSON.parse(e.message)
+          add_error [field, key].join('.'), msg, opts
+        end
+      else
+        add_error field, e.message, opts
+      end
     end
   end
 end

data/lib/typero/type/type.rb

@@ -15,8 +15,24 @@ module Typero
     }
 
     # default shared allowed opts keys
-    OPTS_KEYS = [:type, :required, :array, :max_count, :default, :name, :meta, :model]
     OPTS      = {}
+    OPTS_KEYS = [
+      :allow,
+      :allowed,
+      :array,
+      :default,
+      :description,
+      :delimiter,
+      :max_count,
+      :meta,
+      :min_count,
+      :model,
+      :name,
+      :req,
+      :required,
+      :type,
+      :values
+    ]
 
     attr_reader :opts
 
@@ -38,17 +54,31 @@ module Typero
       end
 
       def opts key, desc
-        OPTS_KEYS.push key unless OPTS_KEYS.include?(key)
-
         OPTS[self] ||= {}
         OPTS[self][key] = desc
       end
+
+      def allowed_opt? name
+        return true if OPTS_KEYS.include?(name)
+
+        OPTS[self] ||= {}
+        return true if OPTS[self][name]
+
+        msg  = %[Unallowed param "#{name}" for type "#{to_s}" found. Allowed are "#{OPTS_KEYS.join(', ')}"]
+        msg += %[ + "#{OPTS[self].keys.join(', ')}"] if OPTS[self].keys.first
+
+        block_given? ? yield(msg) : raise(ArgumentError, msg)
+
+        false
+      end
     end
 
     ###
 
     def initialize value, opts={}, &block
-      value = value.sub(/^\s+/, '').sub(/\s+$/, '') if value.is_a?(String)
+      value = value.strip.rstrip if value.is_a?(String)
+
+      opts.keys.each {|key| self.class.allowed_opt?(key) }
 
       @value = value
       @opts  = opts
@@ -68,7 +98,11 @@ module Typero
         opts[:default].nil? ? default : opts[:default]
       else
         set
-        error_for(:not_in_range, opts[:values].join(', ')) if opts[:values] && !opts[:values].include?(@value)
+
+        if opts[:values] && !opts[:values].map(&:to_s).include?(@value.to_s)
+          error_for(:not_in_range, opts[:values].join(', '))
+        end
+
         value
       end
     end

data/lib/typero/type/types/date_type.rb

@@ -1,9 +1,15 @@
 class Typero::DateType < Typero::Type
+  opts :min, 'Smallest date-time allowed'
+  opts :max, 'Maximal date-time allowed'
+
   error :en, :min_date, 'Minimal allowed date is %s'
   error :en, :max_date, 'Maximal allowed date is %s'
 
   def set
-    value { |data| DateTime.parse(data) }
+    unless [Date].include?(value.class)
+      value { |data| DateTime.parse(data) }
+    end
+
     value { |data| DateTime.new(data.year, data.month, data.day) }
 
     check_date_min_max

data/lib/typero/type/types/datetime_type.rb

@@ -1,8 +1,13 @@
 require_relative 'date_type'
 
 class Typero::DatetimeType < Typero::DateType
+  opts :min, 'Smallest date allowed'
+  opts :max, 'Maximal date allowed'
+
   def set
-    value { |data| DateTime.parse(data) }
+    unless [Time, DateTime].include?(value.class)
+      value { |data| DateTime.parse(data) }
+    end
 
     check_date_min_max
   end

data/lib/typero/type/types/hash_type.rb

@@ -2,11 +2,18 @@ class Typero::HashType < Typero::Type
   error :en, :not_hash_type_error, 'value is not hash type'
 
   def set
-    error_for(:not_hash_type_error) unless value.is_a?(Hash)
+    if value.is_a?(String) && value[0,1] == '{'
+      @value = JSON.load(value)
+    end
+
+    @value ||= {}
+    @value.delete_if {|_, v| v.empty? }
+
+    error_for(:not_hash_type_error) unless @value.respond_to?(:keys) && @value.respond_to?(:values)
 
     if opts[:allow]
-      for key in value.keys
-        value.delete(key) unless opts[:allow].include?(key)
+      for key in @value.keys
+        @value.delete(key) unless opts[:allow].include?(key)
       end
     end
   end

data/lib/typero/type/types/locale_type.rb

@@ -0,0 +1,13 @@
+class Typero::LocaleType < Typero::Type
+  error :en, :locale_bad_format, 'Locale "%s" is in bad format (should be xx or xx-xx)'
+
+  def set
+    error_for(:locale_bad_format, value) unless value =~ /^[\w\-]{2,5}$/
+  end
+
+  def db_schema
+    [:string, { limit: 5 }]
+  end
+end
+
+

data/lib/typero/type/types/model_type.rb

@@ -2,14 +2,17 @@ class Typero::ModelType < Typero::Type
   def set
     value(&:to_h)
 
-    errors = []
+    errors = {}
+    schema = opts[:model].is_a?(Typero::Schema) ? opts[:model] : Typero.schema(opts[:model])
 
-    schema = Typero.schema(opts[:model])
-    schema.validate(value) do |field, error|
-      errors.push '%s (%s)' % [error, field]
+    # by default models in schems are strict true (remove undefined keys)
+    schema.validate value, strict: true do |field, error|
+      errors[field] = error
     end
 
-    raise TypeError.new errors.join(', ') if errors.first
+    @value.delete_if {|_, v| v.empty? }
+
+    raise TypeError.new errors.to_json if errors.keys.first
   end
 
   def db_schema

data/lib/typero/type/types/point_type.rb

@@ -4,12 +4,13 @@
 class Typero::PointType < Typero::Type
   def set
     if value.include?('/@')
+      # extract value from google maps link
       point = value.split('/@', 2).last.split(',')
       value { [point[0], point[1]].join(',') }
     end
 
     if !value.include?('POINT') && value.include?(',')
-      point = value.sub(/,\s*/, ' ')
+      point = value.sub(/\s*,\s*/, ' ')
       value { 'SRID=4326;POINT(%s)' % point }
     end
 

data/lib/typero/type/types/simple_point_type.rb

@@ -0,0 +1,20 @@
+# Same as point, but we keep data as a float in Array
+
+class Typero::SimplePointType < Typero::Type
+  def set
+    if value.include?('/@')
+      # extract value from google maps link
+      point = value.split('/@', 2).last.split(',')[0,2]
+      value { point }
+    end
+
+    if !value.include?('POINT') && value.include?(',')
+      value { value.split(/\s*,\s*/)[0,2] }
+    end
+  end
+
+  def db_schema
+    [:float, { array: true }]
+  end
+end
+

data/lib/typero/type/types/string_type.rb

@@ -7,6 +7,9 @@ class Typero::StringType < Typero::Type
     value(&:to_s)
     value(&:downcase) if opts[:downcase]
 
+    # this is database default for string type and it is good to define default unless defined
+    opts[:max] ||= 255
+
     error_for(:min_length_error, opts[:min], value.length) if opts[:min] && value.length < opts[:min]
     error_for(:max_length_error, opts[:max], value.length) if opts[:max] && value.length > opts[:max]
   end

data/lib/typero/type/types/time_type.rb

@@ -0,0 +1,5 @@
+require_relative 'datetime_type'
+
+class Typero::TimeType < Typero::DatetimeType
+end
+

data/lib/typero/type/types/timezone_type.rb

@@ -0,0 +1,15 @@
+class Typero::TimezoneType < Typero::Type
+  error :en, :invalid_time_zone, 'Invalid time zone'
+
+  def set
+    TZInfo::Timezone.get(value)
+  rescue TZInfo::InvalidTimezoneIdentifier
+    error_for :invalid_time_zone
+  end
+
+  def db_schema
+    [:string, { length: 50 }]
+  end
+
+end
+

data/lib/typero/typero.rb

@@ -19,45 +19,82 @@
 module Typero
   extend self
 
-  VERSION = File.read File.expand_path "../../.version", File.dirname(__FILE__)
+  VERSION ||= File.read File.expand_path "../../.version", File.dirname(__FILE__)
+  SCHEMAS ||= {}
 
   # check and coerce value
-  # Typero.set(:label, 'Foo bar') -> "foo-bar"
-  def set type, value, opts = {}, &block
-    check = Typero::Type.load(type).new value, opts
-    check.get
-  rescue TypeError => error
-    if block
-      block.call error
-      false
+  # Typero.type(:label) -> Typero::LabelType
+  # Typero.type(:label, 'Foo bar') -> "foo-bar"
+  def type klass_name, value = :_undefined, opts = {}, &block
+    klass = Typero::Type.load(klass_name)
+
+    if value == :_undefined
+      klass
     else
-      raise error
+      begin
+        check = klass.new value, opts
+        check.get
+      rescue TypeError => error
+        if block
+          block.call error
+          false
+        else
+          raise error
+        end
+      end
     end
   end
+  alias :set :type
+
+  # type schema
+  # Typero.schema(:blog) { ... }
+
+  # type schema with option
+  # Typero.schema(:blog, type: :model) { ... }
 
-  # load type schema
-  def schema name=nil, &block
-    # :user -> 'User'
-    name = name.to_s.classify if name
+  # get schema
+  # Typero.schema(:blog)
+
+  # get schema with options (as array)
+  # Typero.schema(:blog, :with_schema)
+
+  # get all schema names with type: model
+  # Typero.schema(type: :model)
+  def schema name = nil, opts = nil, &block
+    klass = name.to_s.classify if name && !name.is_a?(Hash)
 
     if block_given?
       Typero::Schema.new(&block).tap do |schema|
-        Typero::Schema::SCHEMAS[name] = schema if name
+        if klass
+          SCHEMAS[klass] = [schema, opts || {}]
+        end
       end
     else
-      raise ArgumentErorr.new('Schema name not given') unless name
+      # Schema not given, get schema
+      if name.is_a?(Hash)
+        # Typero.schema type: :model
+        out = []
 
-      schema   = Typero::Schema::SCHEMAS[name]
-      schema ||= class_finder name, :schema
-      schema || raise('Typero schema "%s" not defined' % name)
-    end
-  end
+        for key, _ in SCHEMAS
+          schema, opts = _
+          next unless opts[name.keys.first] == name.values.first
+          out.push key.classify
+        end
 
-  def export model, opts={}, &block
-    if block_given?
-      Exporter::EXPORTERS[model.to_s.classify] = block
-    else
-      Exporter.new(model, opts).render
+        out
+      elsif klass
+        # Typero.schema :user
+        schema   = SCHEMAS[klass]
+        schema ||= class_finder klass, :schema
+
+        if opts
+          schema
+        else
+          schema.respond_to?(:[]) ? schema[0] : schema
+        end
+      else
+        raise ArgumentError, 'Schema type not defined.'
+      end
     end
   end
 
@@ -78,13 +115,10 @@ module Typero
     for el in args
       for separator in ['_','/']
         klass = [name, el].join(separator).classify
-
-        begin
-          return klass.constantize
-        rescue NameError => e
-          nil
-        end
+        return klass.constantize if const_defined? klass
       end
     end
+
+    nil
   end
 end

data/lib/typero.rb

@@ -1,8 +1,9 @@
+# require 'hash_wia'
+
 # base libs
 require_relative 'typero/typero'
 require_relative 'typero/schema'
 require_relative 'typero/params'
-require_relative 'typero/exporter'
 require_relative 'typero/type/type'
 
 # checker types

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.5
 platform: ruby
 authors:
 - Dino Reic
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-02 00:00:00.000000000 Z
+date: 2022-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
@@ -34,7 +34,6 @@ files:
 - "./.version"
 - "./lib/adapters/sequel.rb"
 - "./lib/typero.rb"
-- "./lib/typero/exporter.rb"
 - "./lib/typero/params.rb"
 - "./lib/typero/schema.rb"
 - "./lib/typero/type/type.rb"
@@ -48,18 +47,22 @@ files:
 - "./lib/typero/type/types/image_type.rb"
 - "./lib/typero/type/types/integer_type.rb"
 - "./lib/typero/type/types/label_type.rb"
+- "./lib/typero/type/types/locale_type.rb"
 - "./lib/typero/type/types/model_type.rb"
 - "./lib/typero/type/types/oib_type.rb"
 - "./lib/typero/type/types/point_type.rb"
+- "./lib/typero/type/types/simple_point_type.rb"
 - "./lib/typero/type/types/string_type.rb"
 - "./lib/typero/type/types/text_type.rb"
+- "./lib/typero/type/types/time_type.rb"
+- "./lib/typero/type/types/timezone_type.rb"
 - "./lib/typero/type/types/url_type.rb"
 - "./lib/typero/typero.rb"
 homepage: https://github.com/dux/typero
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -74,8 +77,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Ruby type system
 test_files: []

data/lib/typero/exporter.rb

@@ -1,93 +0,0 @@
-module Typero
-  class Exporter
-    EXPORTERS ||= {}
-
-    attr_accessor :response
-
-    def initialize model, opts={}
-      opts = { user: opts } unless opts.is_a?(Hash)
-
-      opts[:exporter]      ||= model.class
-      opts[:depth]         ||= 1
-      opts[:current_depth] ||= 0
-
-      exporter = opts.delete(:exporter).to_s.classify
-
-      @model    = model
-      @opts     = opts
-      @block    = EXPORTERS[exporter] || raise('Exporter "%s" (:%s) not found' % [block, block.underscore])
-      @response = {}
-    end
-
-    def render
-      instance_exec &@block
-      @response
-    end
-
-    private
-
-    def export object, opts={}
-      if object.is_a?(Symbol)
-        return property object, export(model.send(object))
-      end
-
-      return if @opts[:current_depth] >= @opts[:depth]
-
-      @opts[:current_depth] += 1
-      out = self.class.new(object, @opts.merge(opts)).render
-      @opts[:current_depth] -= 1
-      out
-    end
-
-    def property name, data=:_undefined
-      if block_given?
-        data = yield if data == :_undefined
-        @response[name] = data
-      else
-        data = data == :_undefined ? model.send(name) : data
-
-        if data.respond_to?(:export_json)
-          data = data.export_json
-        elsif data.respond_to?(:to_h)
-          data = data.to_h
-        end
-
-        @response[name] = data
-      end
-    end
-    alias :prop :property
-
-    def hproperty name
-      @response[name] = model[name]
-    end
-    alias :hprop :hproperty
-
-    def namespace name, &block
-
-    end
-
-    def meta &block
-      namespace :meta, &block
-    end
-
-    def model
-      @model
-    end
-
-    # get current user from globals if globals defined
-    def user
-      if @opts[:user]
-        @opts[:user]
-      elsif defined?(User) && User.respond_to?(:current)
-        User.current
-      elsif defined?(Current) && Current.respond_to?(:user)
-        Current.user
-      elsif current_user = Thread.current[:current_user]
-        current_user
-      else
-        nil
-      end
-    end
-  end
-end
-