welltreat-store-framework 0.2.0

data/README.md

@@ -0,0 +1,25 @@
+Well Treat Store Framework
+===========
+
+Build store just like your another web site building project
+
+Features
+===========
+
+Micro framework
+
+Relation
+
+Filter
+
+Dynamic Filter
+
+Dynamic Attributes
+
+Validations
+
+TODOS
+=====
+
+* Abstract persistent api
+* Expose

data/lib/generators/flexi_model/install/install_generator.rb

@@ -0,0 +1,20 @@
+module FlexiModel
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+
+      # Implement the required interface for Rails::Generators::Migration.
+      def self.next_migration_number(dirname) #:nodoc:
+        next_migration_number = current_migration_number(dirname) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def generate_install
+        Dir.glob(File.join(File.dirname(__FILE__), 'templates/*.rb')).each do |file|
+          migration_template file, "db/migrate/#{file.split('/').last}"
+        end
+      end
+    end
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_collections.rb

@@ -0,0 +1,17 @@
+class CreateFlexiModelCollections < ActiveRecord::Migration
+  def change
+    create_table "flexi_model_collections" 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'
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_collections_fields.rb

@@ -0,0 +1,11 @@
+class CreateFlexiModelCollectionsFields < ActiveRecord::Migration
+  def change
+    create_table 'flexi_model_collections_fields', :force => true 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]
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_fields.rb

@@ -0,0 +1,18 @@
+class CreateFlexiModelFields < ActiveRecord::Migration
+  def change
+    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], name: 'index_ns_name_ft_pi'
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_records.rb

@@ -0,0 +1,12 @@
+class CreateFlexiModelRecords < ActiveRecord::Migration
+  def change
+    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]
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_values.rb

@@ -0,0 +1,18 @@
+class CreateFlexiModelValues < ActiveRecord::Migration
+  def change
+    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]
+    add_index 'flexi_model_values', [:field_id]
+
+  end
+end

data/lib/welltreat_store_framework/configuration.rb

@@ -0,0 +1,17 @@
+module WelltreatStoreFramework
+  class Configuration
+    attr_accessor :store_path, :haml_options, :database_config,
+                  :database_schema_file, :auto_reload, :sprockets_enabled
+
+    def initialize
+      @auto_reload = false
+      @store_path = nil
+      @sprockets_enabled = false
+      @haml_options = {
+          encoding: 'utf-8',
+          format: :html5
+      }
+      @database_connection = nil
+    end
+  end
+end

data/lib/welltreat_store_framework/controller.rb

@@ -0,0 +1,131 @@
+module WelltreatStoreFramework
+  module Controller
+    extend ActiveSupport::Concern
+
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def serve(request)
+    end
+
+    [:notice, :alert, :success].map(&:to_s).each do |_kind|
+      module_eval <<-CODE
+        def set_flash_#{_kind}(session, msg)
+          _flash_from(session)[:#{_kind}] = msg
+        end
+
+        def get_flash_#{_kind}(session)
+          _flash_from(session)[:#{_kind}]
+        end
+      CODE
+    end
+
+    def _flash_from(session)
+      session[:flash] ||= { }
+    end
+
+    class Request
+      attr_accessor :path, :params, :headers, :rack_request, :env
+
+      def initialize(attrs = { })
+        @headers      = { }
+        @params       = { }
+        @path         = nil
+        @rack_request = nil
+        attrs.each do |k, v|
+          self.send(:"#{k.to_s}=", v)
+        end
+      end
+
+      def get_header(k)
+        self.headers[k]
+      end
+
+      def [](k)
+        self.params[k]
+      end
+
+      class << self
+        def initialize_from_env(env)
+          request = Rack::Request.new(env)
+          self.new(
+              :params       => request.params,
+              :headers      => env,
+              :rack_request => request,
+              :path         => request.path,
+              :env          => env
+          )
+        end
+      end
+
+      private
+
+      def set_param(k, v)
+        self.params[k] = v
+      end
+    end
+
+    class Response
+
+      STATUS_OK = 200
+      attr_accessor :status, :headers, :content, :values,
+                    :controller_name, :template, :layout
+
+      def initialize
+        @status   = STATUS_OK
+        @headers  = { 'Content-Type' => 'text/html' }
+        @content  = nil
+        @template = nil
+        @layout   = :default
+        @values   = { }
+      end
+
+      def add_header(k, v)
+        case k.to_s
+          when 'content_type', 'format'
+            @headers['Content-Type'] = v
+          else
+            @headers[k] = v
+        end
+      end
+
+      def get_header(k)
+        @headers[k]
+      end
+
+      def set(k, v)
+        @values[k] = v
+      end
+
+      def get(k)
+        @values[k]
+      end
+
+      def [](k)
+        self.get(k)
+      end
+
+      def exists?(k)
+        @values.include?(k)
+      end
+
+      def present?(k)
+        exists?(k) && get(k).present?
+      end
+
+      def redirect_to(path, status = 302)
+        self.status = status
+        self.add_header("Location", path)
+        self.content = ''
+      end
+
+      def redirect?
+        [301, 302, 303, 307].include? self.status
+      end
+
+    end
+  end
+end

data/lib/welltreat_store_framework/core.rb

@@ -0,0 +1,66 @@
+module WelltreatStoreFramework
+  class Core
+    @@configuration = WelltreatStoreFramework::Configuration.new
+    cattr_accessor :configuration
+
+    @@stores = nil
+    cattr_accessor :stores
+
+    class << self
+
+      # Reset internal cached data
+      def reset!
+        self.stores        = nil
+        self.configuration = WelltreatStoreFramework::Configuration.new
+      end
+
+      # Configure through passing block. block will be yield with
+      # configuration instance
+      def setup(&block)
+        block.call(self.configuration)
+      end
+
+      # Find all stores from the configured path
+      # return an array of instance StoreApp
+      def find_stores(partition_object = nil)
+        self.stores ||= _detect_stores(partition_object)
+      end
+
+      # Find store by the given name
+      # Return StoreApp instance
+      def find_store_by_name(name, partition_object = nil)
+        find_stores(partition_object)[name]
+      end
+
+      # Establish database connection
+      def connect_database!
+        ActiveRecord::Base.establish_connection configuration.database_config
+
+        if configuration.database_schema_file.present?
+          puts "Importing database schema - "
+          require configuration.database_schema_file
+        end
+      end
+
+      private
+      def _detect_stores(partition_object = nil)
+        _stores = { }
+        Dir.glob(File.join(configuration.store_path, '*')).each do |_path|
+          _name          = _path.split('/').last
+          _stores[_name] = StoreApp.new.tap do |inst|
+            inst.partition_object = partition_object
+            inst.path             = _path
+            inst.name             = _name
+            inst.config_path      = File.join(_path, 'config')
+            inst.controllers_path = File.join(_path, 'controllers')
+            inst.models_path      = File.join(_path, 'models')
+            inst.views_path       = File.join(_path, 'views')
+            inst.assets_path      = File.join(_path, 'assets')
+          end
+        end
+
+        _stores
+      end
+    end
+  end
+end

data/lib/welltreat_store_framework/haml_renderer/lorem_helper.rb

@@ -0,0 +1,29 @@
+module WelltreatStoreFramework
+  module HamlRenderer
+    module LoremHelper
+      extend ActiveSupport::Concern
+
+      def lorem
+        Lorem
+      end
+
+      class Lorem
+        TEXTS = %{Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat. Duis autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et accumsan et iusto odio dignissim qui blandit praesent luptatum zzril delenit augue duis dolore te feugait nulla facilisi. Nam liber tempor cum soluta nobis eleifend option congue nihil imperdiet doming id quod mazim placerat facer possim assum. Typi non habent claritatem insitam; est usus legentis in iis qui facit eorum claritatem. Investigationes demonstraverunt lectores legere me lius quod ii legunt saepius. Claritas est etiam processus dynamicus, qui sequitur mutationem consuetudium lectorum. Mirum est notare quam littera gothica, quam nunc putamus parum claram, anteposuerit litterarum formas humanitatis per seacula quarta decima et quinta decima. Eodem modo typi, qui nunc nobis videntur parum clari, fiant sollemnes in futurum.}
+
+        class << self
+          def name
+            TEXTS.split(',').shuffle.first[0..20]
+          end
+
+          def sentence
+            TEXTS.split(',').shuffle.first
+          end
+
+          def paragraph
+            TEXTS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/welltreat_store_framework/haml_renderer/partial.rb

@@ -0,0 +1,31 @@
+module WelltreatStoreFramework
+  module HamlRenderer
+    module Partial
+      extend ActiveSupport::Concern
+
+      # Render partial template
+      #   template - Template file name
+      #              By default look for relative path to current action path
+      #              Otherwise check by relative path to views path
+      #
+      #   variables - Define local variables
+      #
+      # Return string content
+      def partial(template, variables = { })
+        _template_key = [
+            self.response.controller_name,
+            self.response.layout.to_s,
+            self.response.template.to_s,
+            template.to_s
+        ].join('_')
+        _file = self.app._full_partial_template_path(self.response, template)
+
+        # Set local variables
+        variables.each { |k, v| self.set_local(k, v) } if variables.present?
+
+        # Render partial
+        self.app._singleton_haml_instance(_template_key, _file).render(self)
+      end
+    end
+  end
+end

data/lib/welltreat_store_framework/haml_renderer/paths.rb

@@ -0,0 +1,51 @@
+module WelltreatStoreFramework
+  module HamlRenderer
+    module Paths
+      extend ActiveSupport::Concern
+
+      def asset_path(*_paths)
+        UrlJoin.new('/assets').join(_paths)
+      end
+
+      def image_path(_path)
+        if _path.to_s.match(/^\//)
+          _path
+        elsif sprockets_enabled?
+          asset_path _path
+        else
+          asset_path 'images', _path
+        end
+      end
+
+      def stylesheet_path(_path)
+        _path = _path.to_s
+        _path << '.css' unless _path.to_s.match(/\.css$/)
+
+        if _path.to_s.match(/^\//)
+          _path
+        elsif sprockets_enabled?
+          asset_path _path
+        else
+          asset_path 'stylesheets', _path
+        end
+      end
+
+      def javascript_path(_path)
+        _path = _path.to_s
+        _path << '.js' unless _path.to_s.match(/\.js$/)
+
+        if _path.to_s.match(/^\//)
+          _path
+        elsif sprockets_enabled?
+          asset_path _path
+        else
+          asset_path 'javascripts', _path
+        end
+      end
+
+      def sprockets_enabled?
+        WelltreatStoreFramework::Core.configuration.sprockets_enabled
+      end
+    end
+  end
+end

data/lib/welltreat_store_framework/haml_renderer/tags_helper.rb

@@ -0,0 +1,74 @@
+module WelltreatStoreFramework
+  module HamlRenderer
+    module TagsHelper
+      extend ActiveSupport::Concern
+
+      # Render image tag
+      def image_tag(_path, attrs = { })
+        attrs[:src] = self.image_path(_path.to_s)
+        content_tag 'img', nil, attrs
+      end
+
+      # Render link tag
+      def link_to(label, link, attrs = { })
+        attrs[:href] = link
+        content_tag 'a', label, attrs
+      end
+
+      # Render stylesheet tags
+      def stylesheet_link_tag(*_files)
+        _files.map { |_f| stylesheet_path(_f) }.map do |_css_path|
+          content_tag('link', nil, {
+              rel: 'stylesheet',
+              type: 'text/css',
+              href: _css_path
+          })
+        end.join('')
+      end
+
+      # Render stylesheet tags
+      def javascript_include_tag(*_files)
+        _files.map { |_f| javascript_path(_f) }.map do |_js_path|
+          content_tag('script', '', {
+              type: 'text/javascript',
+              src: _js_path
+          })
+        end.join('')
+      end
+
+      # Truncate text
+      def truncate(text, options = {})
+        length = options[:length] || 100
+        text[0..length - 1]
+      end
+
+      def strip_tags(text, options = {})
+        text.gsub(/<\/?[\w\d\s\-_'="]+>/, '')
+      end
+
+      def content_tag(tag_name, content, attrs = { })
+        html = "<#{tag_name} #{_generate_attributes(attrs)}"
+
+        if content
+          html << ">"
+          html << ERB::Util.html_escape(content)
+          html << "</#{tag_name}>"
+
+        elsif block_given?
+          html << ">"
+          html << ERB::Util.html_escape(yield)
+          html << "</#{tag_name}>"
+        else
+          html << ' />'
+        end
+
+        html
+      end
+
+      private
+      def _generate_attributes(_attrs)
+        _attrs.map { |k, v| "#{k}='#{v}'" }.join(' ')
+      end
+    end
+  end
+end

data/lib/welltreat_store_framework/haml_renderer.rb

@@ -0,0 +1,163 @@
+require 'welltreat_store_framework/haml_renderer/paths'
+require 'welltreat_store_framework/haml_renderer/partial'
+require 'welltreat_store_framework/haml_renderer/tags_helper'
+require 'welltreat_store_framework/haml_renderer/lorem_helper'
+
+module WelltreatStoreFramework
+  module HamlRenderer
+    extend ActiveSupport::Concern
+
+    # Render HAML template and set content in response.content variable
+    def render!(request, response, options)
+      return if response.redirect?
+      return if response.content.present?
+
+      _layout_key    = response.layout.to_s
+      _template_key  = [
+          response.controller_name,
+          response.layout.to_s,
+          response.template.to_s,
+      ].join('_')
+      _template_file = _full_template_path(response)
+      _layout_file   = _full_layout_path(response)
+
+      raise StoreApp::TemplateNotFound.new(_template_key) if _template_file.nil?
+
+      # Render view with layout
+      context = Context.new(self, request, response, options)
+
+      # Render sub view
+      context.set :body, _singleton_haml_instance(_template_key, _template_file).render(context)
+
+      # Render layout
+      response.content = _singleton_haml_instance(_layout_key, _layout_file).render(context)
+    end
+
+    def _singleton_haml_instance(_key, _file)
+      raise StoreApp::TemplateNotFound.new(_file) if _file.nil? || !File.exist?(_file)
+
+      if WelltreatStoreFramework::Core.configuration.auto_reload
+        Haml::Engine.new(File.read(_file), filename: _file)
+      else
+        _haml_engines[_key] ||=
+            Haml::Engine.new(File.read(_file), filename: _file)
+      end
+    end
+
+    def _haml_engines
+      @_haml_engines ||= { }
+    end
+
+    def _full_layout_path(response)
+      Dir.glob(File.join(self.views_path,
+                         'layouts',
+                         "#{response.layout.to_s}.*"
+               )).first
+    end
+
+    def _full_template_path(response)
+      Dir.glob(File.join(self.views_path,
+                         response.controller_name.to_s.underscore,
+                         "#{response.template.to_s}.*"
+               )).first
+    end
+
+    def _full_partial_template_path(response, _partial)
+      Dir.glob(File.join(self.views_path,
+                         response.controller_name.to_s.underscore,
+                         "#{_partial.to_s}.*"
+               )).first ||
+          Dir.glob(File.join(self.views_path,
+                             "#{_partial.to_s}.*"
+                   )).first
+    end
+
+    class Context
+      include Paths, Partial, TagsHelper, LoremHelper
+
+      attr_accessor :request, :response, :options
+
+      def initialize(app, request, response, options)
+        @app      = app
+        @request  = request
+        @response = response
+        @options  = options || { }
+        @locals   = { }
+      end
+
+      def app;
+        @app
+      end
+
+      def set_local(k, v)
+        @locals[k] = v
+      end
+
+      def get_local(k)
+        @locals[k]
+      end
+
+      def local_exists?(k)
+        @locals.include?(k)
+      end
+
+      def local_present?(k)
+        local_exists?(k) && get_local(k).present?
+      end
+
+      def session
+        options[:session]
+      end
+
+      def notice
+        get_flash :notice
+      end
+
+      def alert
+        get_flash :alert
+      end
+
+      def success
+        get_flash :success
+      end
+
+      def flash_exist?
+        notice || alert || success
+      end
+
+      def get_flash(k)
+        @flash_values    ||= { }
+        @flash_values[k] ||= flash[k]
+        flash[k] = nil if @flash_values[k].present?
+
+        @flash_values[k]
+      end
+
+      def set_flash(k, v)
+        flash[k] = v
+      end
+
+      def flash
+        options[:session][:flash] ||= { }
+      end
+
+      delegate :exists?, :present?, :set, :get, :to => :response
+    end
+
+    class UrlJoin
+      def initialize(*_base_paths)
+        @paths = []
+        join(_base_paths)
+      end
+
+      def join(*_paths)
+        @paths += _paths
+        self
+      end
+
+      def to_s
+        @paths.join('/')
+      end
+    end
+  end
+end