conjoin 0.0.1 → 0.0.2

data/lib/conjoin/tasks.rb

@@ -0,0 +1,4 @@
+dir = Gem::Specification.find_by_name('cuba-tracks').gem_dir
+
+Dir.glob("#{dir}/lib/cuba/tasks/**/*.rb").each { |r| require r  }
+Dir.glob("#{dir}/lib/cuba/tasks/**/*.rake").each { |r| import r  }

data/lib/conjoin/tasks/migrate.rake

@@ -0,0 +1,70 @@
+namespace :db do
+  desc "create the database from config/database.yml from the current Sinatra env"
+  task :create do
+    ActiveRecordTasks.create()
+  end
+
+  desc "drops the data from config/database.yml from the current Sinatra env"
+  task :drop do
+    ActiveRecordTasks.drop()
+  end
+
+  desc "load the seed data from db/seeds.rb or run specific seed rake db:seed[file/path]"
+  task :seed, :file do |t, args|
+    ActiveRecordTasks.seed args[:file]
+  end
+
+  desc "create the database and load the schema"
+  task :setup do
+    ActiveRecordTasks.setup()
+  end
+
+  desc "create an ActiveRecord migration"
+  task :create_migration do
+    ActiveRecordTasks.create_migration(ENV["NAME"], ENV["VERSION"])
+  end
+
+  desc "migrate the database (use version with VERSION=n)"
+  task :migrate do
+    ActiveRecordTasks.migrate(ENV["VERSION"])
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  desc "roll back the migration (use steps with STEP=n)"
+  task :rollback do
+    ActiveRecordTasks.rollback(ENV["STEP"])
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  namespace :schema do
+    desc "dump schema into file"
+    task :dump do
+      ActiveRecordTasks.dump_schema()
+    end
+
+    desc "load schema into database"
+    task :load do
+      ActiveRecordTasks.load_schema()
+    end
+  end
+
+  namespace :test do
+    task :purge do
+      ActiveRecordTasks.with_config_environment 'test' do
+        ActiveRecordTasks.purge()
+      end
+    end
+
+    task :load => :purge do
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+      ActiveRecordTasks.with_config_environment 'test' do
+        ActiveRecordTasks.load_schema()
+      end
+    end
+
+    desc 'Prepare test database from development schema'
+    task :prepare do
+      Rake::Task["db:test:load"].invoke
+    end
+  end
+end

data/lib/conjoin/tasks/migrate.rb

@@ -0,0 +1,142 @@
+require 'active_record'
+require 'active_support/core_ext/string/strip'
+require 'fileutils'
+require 'highline/import'
+
+module ActiveRecordTasks
+  extend self
+
+  def create
+    silence_activerecord do
+      ActiveRecord::Tasks::DatabaseTasks.create(config)
+    end
+  end
+
+  def drop
+    silence_activerecord do
+      ActiveRecord::Tasks::DatabaseTasks.drop(config)
+    end
+  end
+
+  def seed file = false
+    if ENV['RACK_ENV'] == 'production'
+      continue = ask("Running seeds could override data, proceed y/N? ", String)
+    else
+      continue = 'y'
+    end
+
+    if %w(yes y Y).include? continue
+      silence_activerecord do
+        load("db/seeds.rb")
+        if not file
+          Seeds.run
+        else
+          load("db/seeds/#{file}.rb")
+        end
+      end
+    else
+      say 'Aborting!'
+    end
+  end
+
+  def setup
+    silence_activerecord do
+      create()
+      load_schema()
+      seed()
+    end
+  end
+
+  def create_migration(migration_name, version = nil)
+    raise "No NAME specified. Example usage: `rake db:create_migration NAME=create_users`" if migration_name.nil?
+
+    migration_number = version || Time.now.utc.strftime("%Y%m%d%H%M%S")
+    migration_file = File.join(migrations_dir, "#{migration_number}_#{migration_name}.rb")
+    migration_class = migration_name.split("_").map(&:capitalize).join
+
+    FileUtils.mkdir_p(migrations_dir)
+    File.open(migration_file, 'w') do |file|
+      file.write <<-MIGRATION.strip_heredoc
+        class #{migration_class} < ActiveRecord::Migration
+          def change
+          end
+        end
+      MIGRATION
+    end
+  end
+
+  def migrate(version = nil)
+    silence_activerecord do
+      migration_version = version ? version.to_i : version
+      ActiveRecord::Migrator.migrate(migrations_dir, migration_version)
+    end
+  end
+
+  def rollback(step = nil)
+    silence_activerecord do
+      migration_step = step ? step.to_i : 1
+      ActiveRecord::Migrator.rollback(migrations_dir, migration_step)
+    end
+  end
+
+  def dump_schema(file_name = 'db/schema.rb')
+    silence_activerecord do
+      ActiveRecord::Migration.suppress_messages do
+        # Create file
+        out = File.new(file_name, 'w')
+
+        # Load schema
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, out)
+
+        out.close
+      end
+    end
+  end
+
+  def purge
+    if config
+      ActiveRecord::Tasks::DatabaseTasks.purge(config)
+    else
+      raise ActiveRecord::ConnectionNotEstablished
+    end
+  end
+
+  def load_schema(file_name = 'db/schema.rb')
+    load(file_name)
+  end
+
+  private
+
+  def config
+    db = URI.parse ENV['DATABASE_URL']
+
+    {
+      adapter: db.scheme == 'postgres' ? 'postgresql' : db.scheme,
+      encoding: 'utf8',
+      reconnect: true,
+      database: db.path[1..-1],
+      host: db.host,
+      port: db.port,
+      pool: ENV['DATABASE_POOL'] || 5,
+      username: db.user,
+      password: db.password
+    }
+  end
+
+  def connect_to_active_record
+    ActiveRecord::Base.establish_connection config
+  end
+
+  def migrations_dir
+    ActiveRecord::Migrator.migrations_path
+  end
+
+  def silence_activerecord(&block)
+    connect_to_active_record
+
+    old_logger = ActiveRecord::Base.logger
+    ActiveRecord::Base.logger = nil
+    yield if block_given?
+    ActiveRecord::Base.logger = old_logger
+  end
+end

data/lib/conjoin/version.rb

@@ -1,3 +1,3 @@
 module Conjoin
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/conjoin/widgets.rb

@@ -0,0 +1,323 @@
+require "observer"
+
+module Conjoin
+  module Widgets
+    class << self
+      attr_accessor :app
+    end
+
+    def self.setup app
+      self.app = app
+      app.settings[:widgets_root] = "#{app.root}/app/widgets"
+      app.settings[:widgets] ||= {}
+
+      Dir["#{app.root}/app/widgets/**/*.rb"].each  { |rb| require rb  }
+    end
+
+    def widgets list = false
+      widget_name, incoming_event, event = load_widgets
+
+      if incoming_event
+        res.headers["Content-Type"] = "text/javascript; charset=utf-8"
+        event.trigger incoming_event.to_sym, widget_name, req.params
+        res.write "$('head > meta[name=csrf-token]').attr('content', '#{csrf_token}');"
+        res.write '$(document).trigger("page:change");'
+      end
+
+      true
+    end
+
+    def widgets_root
+      settings[:widgets_root]
+    end
+
+    def render_widget *args
+      load_widgets unless req.env[:loaded_widgets]
+
+      if args.first.kind_of? Hash
+        opts = args.first
+        name = req.env[:widget_name]
+      else
+        name = args.first
+        opts = args.length > 1 ? args.last : {}
+      end
+
+      # set the current state (the method that will get called on render_widget)
+      state = opts[:state] || 'display'
+
+      widget = req.env[:loaded_widgets][name]
+
+      if widget.method(state).parameters.length > 0
+        widget.send state, opts
+      else
+        widget.send state
+      end
+    end
+    alias_method :widget_render, :render_widget
+
+    def widget_div opts = {}, &block
+      defaults = {
+        id: "#{req.env[:widget_name]}_#{req.env[:widget_state]}"
+      }.merge opts
+
+      name = req.env[:widget_name]
+      widget = req.env[:loaded_widgets][name]
+
+      html = block.call(widget)
+
+      mab do
+        div defaults do
+          text! html
+        end
+      end
+    end
+
+    def url_for_event event, options = {}
+      widget_name = req.env[:widget_name]
+      "#{path_for('widgets')}?widget_event=#{event}&widget_name=#{widget_name}&" + URI.encode_www_form(options)
+    end
+
+    def load_widgets
+      req.env[:loaded_widgets] ||= {}
+
+      event = Events.new res, req, settings
+
+      if incoming_event = req.params["widget_event"]
+        widget_name = req.params["widget_name"]
+        opts = { from_event: true }
+      else
+        opts = {}
+      end
+
+      settings[:widgets].each do |name, widget|
+        req.env[:loaded_widgets][name] = widget.constantize.new(self, res, req, settings, event, name, opts)
+      end
+
+      [widget_name, incoming_event, event]
+    end
+
+    module ClassMethods
+      def has_widgets *list
+        list.each do |widget|
+          settings[:widgets].merge! widget
+        end
+      end
+
+      def widgets_root= path
+        settings[:widgets_root] = path
+      end
+
+      def widgets_root
+        settings[:widgets_root]
+      end
+    end
+
+    class Events < Struct.new(:res, :req, :settings)
+      include Observable
+
+      def trigger event, widget_name, user_data = {}
+        # data = OpenStruct.new({
+        #   settings: settings,
+        #   data: user_data
+        # })
+        data = user_data.to_ostruct
+
+        # THIS IS WHAT WILL MAKE SURE EVENTS ARE TRIGGERED
+        changed
+        ##################################################
+
+        notify_observers event, widget_name, data
+      end
+    end
+
+    class Base
+      JS_ESCAPE = { '\\' => '\\\\', '</' => '<\/', "\r\n" => '\n', "\n" => '\n', "\r" => '\n', '"' => '\\"', "'" => "\\'" }
+      attr_accessor :app, :res, :req, :settings, :event, :folder, :options
+
+      def initialize app, res, req, settings, event, folder, options
+        @app      = app
+        @res      = res
+        @req      = req
+        @settings = settings
+        @event    = event
+        @folder   = folder
+        @options  = options
+
+        # add the widget to the req widgets
+        req.env[:widgets] ||= {}
+        unless req.env[:widgets][folder]
+          req.env[:widgets][folder] = {}
+        end
+
+        event.add_observer self, :trigger_event
+      end
+
+      def current_user
+        app.current_user
+      end
+
+      def id_for state
+        "#{req.env[:widget_name]}_#{state}"
+      end
+
+      def page_change
+        res.headers["Content-Type"] = "text/javascript; charset=utf-8"
+        res.write '$(document).trigger("page:change");'
+      end
+
+      def replace state, opts = {}
+        @options[:replace] = true
+
+        if !state.is_a? String
+          content = render state, opts
+          selector = '#' + id_for(state)
+        else
+          if !opts.key?(:content) and !opts.key?(:with)
+            content = render opts
+          else
+            content = opts[:content] || opts[:with]
+          end
+          selector = state
+        end
+
+        res.write '$("' + selector + '").replaceWith("' + escape(content) + '");'
+        # scroll to the top of the page just as if we went to the url directly
+        res.write 'window.scrollTo(0, 0);'
+      end
+
+      def hide selector
+        res.write '$("' + selector + '").hide();'
+      end
+
+      def append selector, opts = {}
+        content = render opts
+        res.write '$("' + selector + '").append("'+ escape(content) +'");'
+      end
+
+      def add_after selector, opts = {}
+        content = render opts
+        res.write '$("' + selector + '").after("'+ escape(content) +'");'
+      end
+
+      def attrs_for selector, opts = {}
+        res.write '$("' + selector + '").attr('+ (opts.to_json) +');'
+      end
+
+      def escape js
+        js.to_s.gsub(/(\\|<\/|\r\n|\\3342\\2200\\2250|[\n\r"'])/) {|match| JS_ESCAPE[match] }
+      end
+
+      def trigger_event event, widget_name, data = {}
+        if events = self.class.events
+          events.each do |class_event, opts|
+            if class_event == event && (widget_name == folder.to_s or opts[:for].to_s == widget_name)
+              event = opts[:with] if opts[:with]
+
+              if method(event).parameters.length > 0
+                send(event, data)
+              else
+                send(event)
+              end
+            end
+          end
+        end
+      end
+
+      def render *args
+        if args.first.kind_of? Hash
+          locals = args.first
+          # if it's a partial we add an underscore infront of it
+          state = view = locals[:state] || "#{locals[:partial]}".gsub(/([a-zA-Z_]+)$/, '_\1')
+        else
+          state = view = args.first
+          locals = args.length > 1 ? args.last : {}
+        end
+
+        unless view
+          state = view = caller[0][/`.*'/][1..-2]
+
+          if (options.key?(:from_event) and !options.key?(:replace))
+            @options[:cache] = false
+          end
+        end
+
+        if locals.key?(:state) and state.to_s == view
+          return send state
+        end
+
+        tmpl_engine = settings[:render][:template_engine]
+
+        if (req_helper_methods = req.env[:widgets][folder][:req_helper_methods]) \
+        and (!options.key?(:cache))
+          locals.merge! req_helper_methods
+        else
+          req.env[:widgets][folder][:req_helper_methods] = {}
+
+          helper_methods.each do |method|
+            req.env[:widgets][folder][:req_helper_methods][method] = locals[method] = self.send method
+          end
+        end
+
+        req.env[:widget_name]  = folder
+        req.env[:widget_state] = state
+
+        locals[:w] = locals[:widget] = self
+
+        app.render "#{app.widgets_root}/#{folder}/#{view}.#{tmpl_engine}", locals
+      end
+
+      private
+
+      def helper_methods
+        self.class.available_helper_methods || []
+      end
+
+      class << self
+        attr_accessor :events, :available_helper_methods
+
+        def respond_to event, opts = {}
+          @events ||= []
+          @events << [event, opts]
+        end
+
+        def responds_to *events
+          @events ||= []
+          events.each do |event|
+            @events << [event, {}]
+          end
+        end
+
+        def helper_method method
+          @available_helper_methods ||= []
+          @available_helper_methods << method
+        end
+
+        def helper_methods *methods
+          methods.each do |method|
+            helper_method method
+          end
+        end
+      end
+    end
+
+    class Routes < Struct.new(:settings)
+      def app
+        App.settings = settings
+        App.plugin Conjoin::Cuba::Render
+        App.plugin Conjoin::Auth
+        App.plugin Conjoin::Assets
+        App.plugin Conjoin::I18N
+        App.plugin Conjoin::FormBuilder
+        App.plugin Conjoin::Widgets
+
+        App
+      end
+    end
+
+    class App < Conjoin::Cuba
+      define do
+        on(default, widgets) {}
+      end
+    end
+  end
+end