yogo-db 0.2.0

data/features/support/env.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'yogo-db'

data/features/yogo-db.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/lib/yogo-db.rb

@@ -0,0 +1,4 @@
+# Load Application pieces
+require 'yogo/rack/model_lookup'
+require 'yogo/schema_app'
+require 'yogo/data_app'

data/lib/yogo/data/default_methods.rb

@@ -0,0 +1,89 @@
+module Yogo
+  module Data
+    module DefaultMethods
+      
+      def self.included(base)
+        base.send(:extend,  ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module ClassMethods
+        def schema
+          class_variable_get(:@@schema)
+        end
+
+        def parse_json(body)
+          json = JSON.parse(body)
+          props = labeled_properties
+          ret = {}
+          # I don't think we care about other items passed back.
+          json['data'].each_pair do |key,value|
+            property = props.select{|p| p.options['label'] == key || p.name.to_s == key}
+            return nil unless property.length == 1
+            # raise Exception, "There shouldn't be more the one property with the same label"
+            ret[property.first.name] = value
+          end
+          return ret
+        end
+        
+        def labeled_properties
+          properties.select{|p| !p.options['label'].nil? }
+        end
+
+        def unlabeled_properties
+          properties.select{|p| p.options['label'].nil? }        
+        end
+      end
+
+      module InstanceMethods
+        def to_url
+          raise Exception, "Need to save before item has a url" if new?
+          "/data/" << self.model.name << "/" << yogo_id.to_s
+        end
+
+        def attributes_by_label
+          attributes = {}
+          properties.each do |property|
+            label = property.options['label']
+            next if label.nil?
+            name = property.name
+            next unless model.public_method_defined?(name)
+            attributes[label] = __send__(name)
+          end
+          return attributes
+        end
+
+        def labeled_properties
+          self.class.labeled_properties
+        end
+
+        def unlabeled_properties
+          self.class.unlabeled_properties
+        end
+
+        def to_json(*args)
+          options = args.first || {}
+          options = options.to_h if options.respond_to?(:to_h)
+
+          result = as_json(*args)
+
+          if options.fetch(:to_json, true)
+            result.to_json
+          else
+            result
+          end
+        end
+
+        def as_json(*a)
+          data = labeled_properties.reduce({}){ |result, property| result.merge(property.name => __send__(property.name)) }
+          default_data = unlabeled_properties.reduce({}){ |result, property| result.merge(property.name => __send__(property.name)) }
+          default_data.merge({
+            :url => self.to_url,
+            :data => data
+          })
+        end
+      end
+      
+    end
+  end
+end

data/lib/yogo/data_app.rb

@@ -0,0 +1,50 @@
+require 'sinatra'
+
+module Yogo
+  class DataApp < ::Sinatra::Base
+    before do
+      content_type :json
+    end
+
+    get '/data/:model_id/?' do
+      { :content => env['yogo.resource'].all.to_json(:to_json => false) }.to_json
+    end
+
+    get '/data/:model_id/:id' do
+      resource = env['yogo.resource']
+      item = resource.get(params[:id])
+
+      { :content => item }.to_json
+    end
+
+    post '/data/:model_id' do
+      resource = env['yogo.resource']
+      opts     = resource.parse_json(request.body.read) rescue nil
+
+      halt(401, 'Invalid Format') if opts.nil?
+
+      item = resource.new(opts)
+
+      halt(500, 'Could not save item') unless item.save
+
+      response['Location'] = item.to_url
+      response.status = 201
+    end
+
+    put '/schema/:model_id/:id' do
+      resource = env['yogo.resource']
+      item     = resource.get(params[:id])
+      opts     = resource.parse_json(request.body.read) rescue nil
+      halt(401, 'Invalid Format') if opts.nil?
+
+      halt(500, 'Could not update schema') unless item.update(opts)
+
+      { :content => item }.to_json
+    end
+
+    delete '/schema/:model_id/:id' do
+      env['yogo.resource'].get(params[:id]).destroy
+    end
+
+  end
+end

data/lib/yogo/model/schema.rb

@@ -0,0 +1,138 @@
+require 'dm-types'
+require 'yogo/datamapper/model/configuration'
+require 'yogo/operations'
+
+class Schema
+  include ::DataMapper::Resource
+  # include Yogo::DataMapper::Model::Configuration
+  include Dataflow
+  
+  # Common::Properties::UUIDKey[self]
+  property :id, ::DataMapper::Property::UUID, {:key => true, :default => lambda{|*args| UUIDTools::UUID.timestamp_create}}
+
+  property :name,                       String,     :required => true, :key => true, :unique => true
+  
+  property :operation_definitions,      Yaml,       :lazy => false, :default => []
+  
+  before :save, :reset_data_model
+  before :destroy, :destroy_data_model_bucket
+  
+  # How do we know what variables need to be constantized.
+  # Also, we might have more or fewer then 3 parameters in the operation
+  # def operation_definitions
+  #   @__operation_definitions ||= attribute_get(:op_defs)
+  # end
+  
+  # Set only the operations we want, don't add to them
+  def operations=(ops)
+    # Clear the current operations
+    self.operation_definitions = []
+    # Load operations with the set given
+    ops.each{|op| operation(*op) }
+  end
+  
+  def operation(op_name, *args)
+    op_def = replace_nil_items([op_name.to_s, args].flatten)
+    
+    unless self.operation_definitions.include?(op_def)
+      # We need to dup this else the model doesn't get marked as dirty and won't save.
+      self.operation_definitions =  self.operation_definitions.dup << op_def
+    end
+  end
+  
+  def data_model
+    @data_model ||= by_need { gen_model }
+  end
+  
+  def to_url
+    "/schema/#{self.name}"
+  end
+  
+  def to_json(*args)
+    options = args.first || {}
+    options = options.to_h if options.respond_to?(:to_h)
+    
+    result = as_json(*args)
+    
+    if options.fetch(:to_json, true)
+      result.to_json
+    else
+      result
+    end
+  end
+  
+  def as_json(*a)
+    {
+      :guid => self.to_url,
+      :name => self.name,
+      :operations => self.operation_definitions,
+    }
+  end
+  
+  REQUIRED_JSON_KEYS=[:name, :operations]
+  
+  def self.parse_json(body)
+    json = JSON.parse(body)
+
+    ret = { :name => json['name'], :operations => json['operations'] }
+
+    return nil if REQUIRED_JSON_KEYS.any? { |r| ret[r].nil? }
+    
+    ret
+  end
+  
+  def to_proc
+    base_op = Yogo::DataMapper::Model::Operations['add/default_properties']
+    # base_op = Yogo::DataMapper::Model::Operations['add/yogo_methods']
+    ops = operation_definitions.map{|op_def| Yogo::DataMapper::Model::Operations[op_def.first] }
+    partial_ops = []
+    ops.each_with_index do |op, i|
+      next unless op
+      partial_ops[i] = op.partial(X, *operation_definitions[i][1..-1])
+    end
+    partial_ops << Yogo::DataMapper::Model::Operations['add/yogo_methods']
+    partial_ops.compact!
+    partial_ops.reduce(base_op){|composed, partial_op| composed * partial_op}
+
+  end
+  
+  private
+  
+  def gen_model
+    id = attribute_get(:id)
+    model_name = attribute_get(:name)
+    base_model = ::DataMapper::Model.new do
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+
+        def self.default_storage_name
+          "#{id}"
+        end
+          
+        def self.name
+          "#{model_name}"
+        end
+      RUBY
+    end
+
+    base_model.class_variable_set(:@@schema, self)
+    self.to_proc[base_model]
+    base_model.auto_upgrade!
+    return base_model
+  end
+  
+  def reset_data_model
+    @data_model = nil
+  end
+  
+  def destroy_data_model_bucket
+    data_model.auto_migrate_down!
+  end
+  
+  def generate_column_uuid
+    "col_#{UUIDTools::UUID.timestamp_create.to_s.gsub('-', '_')}"
+  end
+  
+  def replace_nil_items(array)
+    array.map{|i| i.nil? ? generate_column_uuid : i }
+  end
+end # Configuration

data/lib/yogo/operations.rb

@@ -0,0 +1,2 @@
+require 'yogo/operations/basic'
+require 'yogo/operations/file'

data/lib/yogo/operations/basic.rb

@@ -0,0 +1,31 @@
+require 'yogo/operation'
+require 'yogo/data/default_methods'
+
+# Move into DataMapper::Property extension file
+unless ::DataMapper::Property.accepted_options.include?('label')
+  ::DataMapper::Property.accept_options('label')
+end
+
+module Operations
+  Yogo::DataMapper::Model::Operations['add/yogo_methods'] = Yogo::Op.on(::DataMapper::Model) do |model|
+
+    # model.define some properties
+
+    model.send(:include, Yogo::Data::DefaultMethods)
+
+    model
+
+  end
+
+  Yogo::DataMapper::Model::Operations['add/yogo_id_property'] =
+          Yogo::DataMapper::Model::Operations['add/property'].partial(X, :yogo_id, 'Serial', {})
+  Yogo::DataMapper::Model::Operations['add/created_at_property'] =
+          Yogo::DataMapper::Model::Operations['add/property'].partial(X, :created_at, 'DateTime', {})
+  Yogo::DataMapper::Model::Operations['add/updated_at_property'] =
+          Yogo::DataMapper::Model::Operations['add/property'].partial(X, :updated_at, 'DateTime', {})
+
+  Yogo::DataMapper::Model::Operations['add/default_properties'] =
+    Yogo::DataMapper::Model::Operations['add/yogo_id_property'] *
+    Yogo::DataMapper::Model::Operations['add/created_at_property'] *
+    Yogo::DataMapper::Model::Operations['add/updated_at_property']
+end

data/lib/yogo/operations/file.rb

@@ -0,0 +1,44 @@
+# Operation to add a file type here
+
+Yogo::DataMapper::Model::Operations['add/file'] = Yogo::Op.on(::DataMapper::Model) do |model, name, options|
+
+  uploader = Class.new(CarrierWave::Uploader::Base)
+  uploader.storage(:file)
+  uploader.class_eval %{
+    def store_dir
+      File.join('assets', '#{model.schema.id}', '#{name}')
+    end
+    
+    def filename
+      # Digest::MD5.hexdigest(self.read)
+      UUIDTools::UUID.timestamp_create
+    end
+  }, __FILE__, __LINE__+1
+
+  # model.define some properties
+  model.class_eval do
+    without_auto_validations do
+      # property :content_type,       String
+      # property :description,        String
+      property "#{name}_asset_file".to_sym,         String, options
+      property "#{name}_original_filename".to_sym,  String
+    end
+    
+    mount_uploader name.to_sym, uploader, :mount_on => "#{name}_asset_file".to_sym
+    after "#{name}=".to_sym, "write_#{name}_identifier".to_sym
+    after "#{name}=".to_sym, "set_#{name}_original_filename".to_sym
+  end
+
+  model.class_eval %{
+    private 
+  
+    def set_#{name}_original_filename
+      original_filename = #{name}.send(:original_filename)
+      attribute_set(:#{name}_original_filename, original_filename)
+    end
+  }, __FILE__, __LINE__+1
+
+
+  model
+
+end

data/lib/yogo/rack/model_lookup.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require 'dm-core'
+require 'yogo/model/schema'
+
+module Yogo
+  module Rack
+    class ModelLookup
+      def initialize(app, options = {})
+        paths = options[:paths] || ['data']
+        @app = app
+        @scope = options[:scope] || lambda { |*args| return Schema }
+        @base_regexp = /^\/(#{paths.join('|')})\/((\w|-|\s)+)/
+      end
+
+      def call(env)
+        if env['PATH_INFO'] =~ @base_regexp
+          model_id = $2
+          env['yogo.schema'], env['yogo.resource'] = get_model(model_id, env)
+          return [ 404, {'Content-Type' => 'text/plain'}, ["#{model_id} not found"] ] if env['yogo.schema'].nil?
+        end
+
+        @app.call(env)
+      end
+
+      private
+
+      def get_model(model_id, env)
+        config = @scope.call(env).first(:name => model_id)
+
+        unless config.nil?
+          return config, config.data_model
+        end
+      end
+
+    end # ModelLookup
+  end # Rack
+end # Yogo

data/lib/yogo/schema_app.rb

@@ -0,0 +1,43 @@
+require 'sinatra'
+
+module Yogo
+  class SchemaApp < ::Sinatra::Base
+    before do
+      content_type :json
+    end
+
+    get '/schema/?' do
+      { :content => Schema.all.to_json(:to_json => false) }.to_json
+    end
+
+    get '/schema/:model_id/?' do
+      { :content => env['yogo.schema'] }.to_json
+    end
+
+    post '/schema/?' do
+      opts = Schema.parse_json(request.body.read) rescue nil
+      halt(401, 'Invalid Format') if opts.nil?
+      schema = Schema.new(opts)
+
+      halt(500, 'Could not save schema') unless schema.save
+
+      response['Location'] = schema.to_url
+      response.status = 201
+    end
+
+    put '/schema/:model_id' do
+      schema = env['yogo.schema']
+      opts = Schema.parse_json(request.body.read) rescue nil
+      halt(401, 'Invalid Format') if opts.nil?
+
+      halt(500, 'Could not update schema') unless schema.update(opts)
+
+      { :content => schema }.to_json
+    end
+
+    delete '/schema/:model_id' do
+      env['yogo.schema'].destroy
+    end
+
+  end
+end