welltreat-store-framework 0.2.0

data/lib/welltreat_store_framework/rack_server.rb

@@ -0,0 +1,56 @@
+module WelltreatStoreFramework
+  class RackServer
+    class AppObj
+      attr_accessor :id
+
+      def initialize(id)
+        self.id = id
+      end
+    end
+
+    attr_accessor :store_name, :partition_id, :app
+
+    def initialize(store_name, partition_id)
+      self.store_name   = store_name
+      self.partition_id = partition_id
+    end
+
+    def call(env)
+      _store = _find_store(env)
+      if _store
+        _store.call(env)
+      else
+        raise "Store - #{self.store_name} for partition - #{self.partition_id} not found."
+      end
+    end
+
+    private
+
+    def _find_store(env)
+      request = Rack::Request.new(env)
+      if 'development' == ENV['ENVIRONMENT'] || 'true' == request.params['reload']
+        puts "Reloading application..."
+
+        if self.app
+          puts "Previous base module id #<#{self.app.base.object_id}>"
+          self.app = nil
+        end
+      end
+
+      self.app ||= _load_store
+    end
+
+    def _load_store
+      store = WelltreatStoreFramework::Core.
+          find_store_by_name(self.store_name, AppObj.new(self.partition_id))
+
+      return store if store.nil?
+
+      store.tap do |_s|
+        _s.start
+        WelltreatStoreFramework::Core.connect_database!
+      end
+
+    end
+  end
+end

data/lib/welltreat_store_framework/store_app.rb

@@ -0,0 +1,282 @@
+module WelltreatStoreFramework
+  class StoreApp
+
+    # Declare exceptions
+    class ControllerNotFound < StandardError
+      attr_accessor :controller_name
+
+      def initialize(_c_name)
+        super "Controller - #{_c_name} not found."
+        self.controller_name = _c_name
+      end
+    end
+
+    class ActionNotFound < StandardError
+      attr_accessor :action_name, :controller_name
+
+      def initialize(_a_name, _c_name)
+        super "Action - #{_a_name} from controller - #{_c_name} not found."
+        self.action_name     = _a_name
+        self.controller_name = _c_name
+      end
+    end
+
+    class ExecutionError < StandardError;
+    end
+
+    class TemplateNotFound < StandardError
+      attr_accessor :file
+
+      def initialize(_file)
+        super "Template - #{_file} not found."
+        self.file = _file
+      end
+    end
+
+    class TemplateRenderingError < StandardError;
+    end
+
+    # Include haml support
+    if defined?(Haml)
+      require 'welltreat_store_framework/haml_renderer'
+      include WelltreatStoreFramework::HamlRenderer
+    else
+      raise "No such haml found. Use gem 'haml' in your Gemfile"
+    end
+
+
+    # Declare attribute accessors
+    attr_accessor :name, :path, :config_path, :routes_path,
+                  :controllers_path, :models_path, :views_path, :assets_path,
+                  :views, :started, :partition_object
+
+    # Default constructor with attribute hash, if attribute hash is passed
+    # it will set value through setter accessors
+    def initialize(attrs = { })
+      if attrs.present?
+        attrs.each do |k, v|
+          self.send(:"#{k}=", v)
+        end
+      end
+    end
+
+    # Start application
+    # Return true if successful otherwise false
+    def start
+      _bootstrap!
+      self.started = true
+    end
+
+    # Dispose and stop application
+    # Return true if successful otherwise false
+    def stop
+      if self.started
+        _dispose!
+        self.started = false
+        true
+      else
+        false
+      end
+    end
+
+    # Stop and start application
+    def restart
+      if self.started
+        self.stop
+        self.start
+        true
+      else
+        false
+      end
+    end
+
+    def base;
+      _base_module
+    end
+
+    def models
+      base::Models
+    end
+
+    def controllers
+      base::Controllers
+    end
+
+
+    # Handle request for the specified path and request
+    # Return status and html content string
+    def dispatch(path, request, response, options)
+      if WelltreatStoreFramework::Core.configuration.auto_reload
+        restart
+      end
+
+      begin
+        case path
+          when '/'
+            _execute_action(:Home, :index, request, response, options)
+          else
+            _controller_name, _action, _id = self.send(:_extract_path, path)
+            request.send(:set_param, :id, _id)
+
+            _execute_action(_controller_name, _action, request, response, options)
+        end
+
+        # Handle 404
+      rescue WelltreatStoreFramework::StoreApp::ControllerNotFound
+        _execute_action(:Home, :not_found, request, response, options)
+
+      rescue WelltreatStoreFramework::StoreApp::ActionNotFound
+        _execute_action(:Home, :not_found, request, response, options)
+      end
+    end
+
+    # Make it rack compatible
+    def call(env)
+      request  = WelltreatStoreFramework::Controller::Request.initialize_from_env(env)
+      response = WelltreatStoreFramework::Controller::Response.new
+      options = {
+          session: env['rack.session']
+      }
+
+      dispatch request.path, request, response, options
+      render! request, response, options
+
+      [response.status, response.headers, [response.content]]
+    end
+
+    private
+    def _execute_action(_controller_name, _action, request, response, options)
+      _controller_inst = _find_controller_inst(_controller_name)
+      _check_action_existence!(_controller_inst, _action)
+
+      # Set default template
+      response.template        = _action
+      response.controller_name = _controller_name
+
+      # Execute action
+      _controller_inst.send(_action, request, response, options)
+    end
+
+    def _check_action_existence!(_controller_inst, _action)
+      raise ActionNotFound.new(_action, _controller_inst.class.name) unless _controller_inst.respond_to?(_action)
+    end
+
+    def _find_controller_inst(controller_name)
+      _check_controller_existence!(controller_name)
+      _singleton_instance(_base_module::Controllers::const_get(controller_name))
+    end
+
+    def _check_controller_existence!(controller_name)
+      _controller = _all_controllers.select { |c| c == controller_name }.first
+      raise ControllerNotFound.new(controller_name) if _controller.nil?
+    end
+
+    def _singleton_instance(clazz)
+      @_instances             ||= { }
+      @_instances[clazz.name] ||= clazz.new(self)
+    end
+
+    def _all_controllers
+      @_all_controllers ||= _base_module::Controllers.constants
+    end
+
+    def _all_controllers=(v)
+      @_all_controllers = v
+    end
+
+    def _extract_path(path)
+      _parts = path.split('/')[1..9999]
+
+      _controller_name = _parts.first.to_s.camelize.to_sym
+      _action          = if _parts.length > 1
+        _parts[1]
+      else
+        :index
+      end
+
+      _id = if _parts.length > 2
+        _parts.last
+      else
+        nil
+      end
+
+      [_controller_name, _action, _id]
+    end
+
+    def _dispose!
+      @_instances = nil
+      self.class.send(:remove_const, self.send(:_base_module_name))
+      self._base_module     = nil
+      self._all_controllers = nil
+    end
+
+    def _bootstrap!
+      _base_module
+    end
+
+    def _base_module
+      @_base_module ||= _create_base_module
+    end
+
+    def _base_module=(mod)
+      @_base_module = mod
+    end
+
+    def _base_module_name
+      self.send(:_base_module).name.split('::').last
+    end
+
+    def _create_base_module
+      mod_name   = "#{self.name.capitalize}AppStack".underscore.classify
+      base_const = eval <<-CODE, nil, "dynamic/#{mod_name}", __LINE__ + 1
+        module #{mod_name}
+
+          module Controllers
+            AppStack.load_classes(self, "#{self.controllers_path}")
+          end
+
+          module Models
+            AppStack.load_classes(self, "#{self.models_path}")
+          end
+        end
+
+        #{mod_name}
+      CODE
+
+      AppStack.generate_partition_object_getter(self, [base_const::Models])
+
+      base_const
+    end
+
+
+    # Provide utilities for bootstrapping new app stack
+    class AppStack
+      class << self
+
+        def generate_partition_object_getter(store, _modules)
+          if store.partition_object
+            _modules.each do |_mod|
+              _mod.constants.each do |_const|
+                _class = _mod.const_get(_const)
+                if _class.respond_to?(:set_flexi_partition_id)
+                  _class.send(:set_flexi_partition_id, store.partition_object.id)
+                end
+              end
+            end
+          end
+        end
+
+        def load_classes(_mod, _path)
+          if _path.match(/\.rb$/)
+            _mod.module_eval File.read(_path), _path, 0
+          else
+            Dir.glob(File.join(_path, "*.rb")).each do |_file|
+              _mod.module_eval File.read(_file), _file, 0
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/welltreat_store_framework.rb

@@ -0,0 +1,9 @@
+require 'active_support/core_ext'
+require 'welltreat_store_framework/store_app'
+require 'welltreat_store_framework/configuration'
+require 'welltreat_store_framework/core'
+require 'welltreat_store_framework/controller'
+
+module WelltreatStoreFramework
+  extend ActiveSupport::Concern
+end

data/sample/hello-store/assets/javascripts/app.js

@@ -0,0 +1 @@
+alert('Hi there');

data/sample/hello-store/controllers/home.rb

@@ -0,0 +1,15 @@
+class Home
+  include WelltreatStoreFramework::Controller
+
+  def index(request, response)
+    response.set :title, "Hello World"
+    response.set :name, "Hasan"
+
+    response.set :products, app.models::Product.all
+  end
+
+  def not_found(request, response)
+    response.content = "<h1>Page Not found</h1>"
+    response.status = 404
+  end
+end

data/sample/hello-store/controllers/products.rb

@@ -0,0 +1,18 @@
+class Products
+  include WelltreatStoreFramework::Controller
+
+  class ProductNotFound < StandardError; end
+
+  def index(request, response)
+    response.set :products, [{name: 'Product 1'}, {name: 'Product 2'}]
+  end
+
+  def show(request, response)
+    if request[:id].present?
+      response.set :product, app.models::Product.find(request[:id])
+      response.set :title, response.get(:product).name
+    else
+      raise ProductNotFound
+    end
+  end
+end

data/sample/hello-store/models/product.rb

@@ -0,0 +1,9 @@
+class Product
+  include FlexiModel
+
+  flexi_field :name, :string
+  flexi_field :description, :text
+  flexi_field :price, :float
+  flexi_field :available, :boolean
+
+end

data/sample/hello-store/views/home/index.haml

@@ -0,0 +1,14 @@
+%h4 Hi there #{get :name}
+
+- if present?(:products)
+  %h5 List of products
+  .product
+    - get(:products).each do |product|
+      %h6= product.name
+      %small= product.price
+      %p= product.description
+      - if product.available?
+        It's in stock
+      - else
+        It's outta stock
+

data/sample/hello-store/views/layouts/default.html.haml

@@ -0,0 +1,10 @@
+!!!5
+%html
+  %head
+    %title= get :title
+    %script{type: 'text/javascript', src: javascript_path('app')}
+
+  %body
+    %h1 Basic Layout
+    %blockquote
+      = get :body

data/sample/hello-store/views/products/_product.html.haml

@@ -0,0 +1 @@
+%strong= get_local(:prod)[:name]

data/sample/hello-store/views/products/index.haml

@@ -0,0 +1,4 @@
+%h5 Hi it's from products index
+
+- get(:products).each do |prod|
+  = partial '_product', prod: prod

data/sample/hello-store/views/products/show.html.haml

@@ -0,0 +1,10 @@
+%h1= get :title
+
+.product_details
+  %h4= get(:product).name
+  %small= get(:product).price
+  %p= get(:product).description
+  - if get(:product).available?
+    It's in stock
+  - else
+    It's outta stock

data/spec/fixtures/schema.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended to check this file into your version control system.
+
+ActiveRecord::Schema.define(:version => 20120318055757) do
+
+  create_table "flexi_model_collections", :force => true do |t|
+    t.string 'name'
+    t.string 'singular_label'
+    t.string 'plural_label'
+    t.string 'namespace'
+    t.integer 'partition_id'
+
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  add_index "flexi_model_collections", [:namespace, :name]
+  add_index "flexi_model_collections", [:namespace, :name, :partition_id],
+            name: 'index_ns_name_pi', unique: true
+
+  create_table 'flexi_model_fields', :force => true do |t|
+    t.string 'name'
+    t.string 'singular_label'
+    t.string 'plural_label'
+    t.string 'namespace'
+    t.integer 'partition_id'
+
+    t.string 'field_type'
+    t.text 'default_value'
+  end
+
+  add_index 'flexi_model_fields', [:namespace, :name]
+  add_index 'flexi_model_fields', [:namespace, :name, :field_type]
+  add_index 'flexi_model_fields', [:namespace, :name, :field_type, :partition_id],
+            unique: true,
+            name: 'index_ns_name_ft_pi'
+
+  create_table 'flexi_model_collections_fields', :force => true, :id => false do |t|
+    t.integer 'collection_id'
+    t.integer 'field_id'
+  end
+
+  add_index 'flexi_model_collections_fields', [:collection_id]
+  add_index 'flexi_model_collections_fields', [:field_id]
+
+  create_table 'flexi_model_records', :force => true do |t|
+    t.integer 'collection_id'
+    t.string 'namespace'
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  add_index 'flexi_model_records', [:namespace, :collection_id]
+
+  create_table 'flexi_model_values', :force => true do |t|
+    t.integer 'record_id'
+    t.integer 'field_id'
+    t.boolean 'bool_value'
+    t.integer 'int_value'
+    t.decimal 'dec_value'
+    t.string 'str_value'
+    t.text 'txt_value'
+    t.datetime 'dt_value'
+  end
+
+  add_index 'flexi_model_values', [:record_id, :field_id]
+
+end

data/spec/lib/welltreat_store_framework/configuration_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe WelltreatStoreFramework::Configuration do
+
+end