menilite 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8bd4f42ddb852546849eaf34e1ad3247d19b7365
+  data.tar.gz: 572240d87bfb87dc8c75747a427e3e6e4ed08afe
+SHA512:
+  metadata.gz: 6c3cfffbe205a5c878560d0fa28aee2d357ce4351b277c8f134dcdf6c6257d0a3aae86f0eb500eb37e1ee54cfece83c3d66a4c211179bde49f596afaff4fd30b
+  data.tar.gz: 157c094db9e46ecf109730510cdcbfa8c82d7592d99d0f37a47708c20fa78d3b096349a331f44e0566c64de2bb731db383fa67e98a8304b01b2b175810f8c68a

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in menilite.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# Menilite
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/menilite`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'menilite'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install menilite
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/menilite.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "menilite"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/menilite.rb

@@ -0,0 +1,16 @@
+require "menilite/version"
+
+if RUBY_ENGINE == "opal"
+  require 'menilite/model'
+  require 'menilite/controller'
+  require 'menilite/client/store'
+else
+  require 'opal'
+  require 'menilite/model'
+  require 'menilite/controller'
+  require 'menilite/router'
+  require 'menilite/server/activerecord_store'
+
+  Opal.append_path File.expand_path('../', __FILE__).untaint
+  Opal.append_path File.expand_path('../../vendor', __FILE__).untaint
+end

data/lib/menilite/client/store.rb

@@ -0,0 +1,84 @@
+require 'browser/http'
+
+module Menilite
+  class Store
+    def initialize
+      @tables = {}
+    end
+
+    def self.instance
+      @instance ||= Store.new
+    end
+
+    def register(model_class)
+      @tables[model_class] = {}
+    end
+
+    def [](model_class)
+      @tables[model_class]
+    end
+
+    def find(model_class, id)
+      return self[model_class][id] if self[model_class][id]
+
+      res = Browser::HTTP.get!("api/#{model_class.to_s}/#{id}")
+      model = model_class.new(res.json)
+      @tables[model_class][id] = model
+    end
+
+    def save(model)
+      is_array = model.is_a?(Array)
+      models = is_array ? model : [ model ]
+      model_class = models.first.class
+      table = @tables[model_class]
+      Browser::HTTP.post("api/#{model_class.to_s}", models.to_json) do
+        on :success do |res|
+          results = res.json.map do |value|
+            if table.has_key?(value[:id])
+              table[value[:id]].update(value)
+              table[value[:id]]
+            else
+              table[value[:id]] = model_class.new(value)
+            end
+          end
+
+          yield(is_array ? results : results.first) if block_given?
+        end
+
+        on :failure do |res|
+          puts ">> Error: #{res.error}"
+          puts ">>>> save: #{model.inspect}"
+        end
+      end
+    end
+
+    def fetch(model_class, filter: nil, order: nil, &block)
+      tables = @tables
+      params = filter && (?? + filter.map {|k,v| "#{k}=#{v}" }.join(?&))
+      params = (params ? params + ?& : ??) + "order=#{[order].flatten.join(?,)}" if order
+      Browser::HTTP.get("api/#{model_class}#{params}") do
+        on :success do |res|
+          tables[model_class] = res.json.map {|value| [value[:id], model_class.new(value)] }.to_h
+          yield tables[model_class].values if block_given?
+        end
+
+        on :failure do |res|
+          puts ">> Error: #{res.error}"
+          puts ">>>> save: #{model.inspect}"
+        end
+      end
+    end
+
+    def delete(mdoel_class)
+      @tables[model_class] = {}
+    end
+
+    def max(model_class, field_name)
+      res = Browser::HTTP.get!("api/#{model_class}?order=#{field_name}")
+      if res.json.last
+        model = model_class.new(res.json.last)
+        model.fields[field_name]
+      end
+    end
+  end
+end

data/lib/menilite/controller.rb

@@ -0,0 +1,66 @@
+if RUBY_ENGINE == 'opal'
+  require 'browser/http'
+  require 'opal-parser'
+end
+
+module Menilite
+  class Controller
+    unless RUBY_ENGINE == 'opal'
+      def initialize(session, settings)
+        @settings = settings
+        @session = session
+      end
+    end
+
+    def session
+      @session
+    end
+
+    def settings
+      @settings
+    end
+
+    class << self
+      def action_info
+        @action_info ||= {}
+      end
+
+      def before_action_handlers
+        @before_action_handlers ||= []
+      end
+
+      ActionInfo = Struct.new(:name, :args, :options)
+
+      def action(name, options = {}, &block)
+        action_info[name.to_s] = ActionInfo.new(name, block.parameters, options)
+        if RUBY_ENGINE == 'opal'
+          method = Proc.new do |*args, &callback| # todo: should adopt keyword parameters
+            action_url = self.respond_to?(:namespace) ? "api/#{self.class.namespace}/#{name}" : "api/#{name}"
+            post_data = {}
+            post_data[:args] = args
+            Browser::HTTP.post(action_url, post_data.to_json) do
+              on :success do |res|
+                callback.call(:success, res) if callback
+              end
+
+              on :failure do |res|
+                callback.call(:failure, res) if callback
+              end
+            end
+          end
+          self.instance_eval do
+            define_singleton_method(name, method)
+          end
+        else
+          self.instance_eval do
+            define_method(name, block)
+          end
+        end
+      end
+
+      def before_action(options = {}, &block)
+        before_action_handlers << { proc: block, options: options }
+      end
+    end
+  end
+end

data/lib/menilite/model.rb

@@ -0,0 +1,282 @@
+require 'securerandom'
+if RUBY_ENGINE == 'opal'
+  require 'browser/http'
+  require 'opal-parser'
+end
+
+class String
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+end
+
+module Menilite
+  class Model
+    attr_reader :fields
+
+    def initialize(fields = {})
+      self.class.init
+
+      if RUBY_ENGINE == 'opal'
+        fields = fields.clone
+      else
+        fields = fields.map{|k,v| [k.to_sym, v] }.to_h
+      end
+
+      defaults = self.class.field_info.map{|k, d| [d.name, d.params[:default]] if d.params.has_key?(:default) }.compact.to_h
+      @guid = fields.delete(:id) || SecureRandom.uuid
+      @fields = defaults.merge(fields)
+      @listeners = {}
+    end
+
+    def id
+      @guid
+    end
+
+    def save(&block)
+      self.class.store.save(self, &block)
+      self
+    end
+
+    def update(data)
+      case data
+      when self.class
+        @fields.merge(data.fields)
+      when Hash
+        @fields.merge(data)
+      when String
+        @fields.merge(JSON.parse(json))
+      end
+    end
+
+    def update!(data, &block)
+      self.update(data)
+      self.save(&block)
+    end
+
+    def on(event, *field_names, &block)
+      field_names.each {|file_name| set_listener(event, file_name, &block) }
+    end
+
+    def handle_event(event, field_name, value)
+      get_listeners(event, field_name).each do |listener|
+        listener.call(value)
+      end
+      value
+    end
+
+    class << self
+      def init
+        if Model.subclasses.has_key?(self) && !Model.subclasses[self]
+          store.register(self)
+          Model.subclasses[self] = true
+        end
+      end
+
+      def field_info
+        @field_info ||= {}
+      end
+
+      def action_info
+        @action_info ||= {}
+      end
+
+      def save(collection, &block)
+        self.init
+        self.store.save(collection, &block)
+      end
+
+      def create(fields={}, &block)
+        self.init
+        self.new(fields).save(&block)
+      end
+
+      def delete_all
+        self.init
+        store.delete(self)
+      end
+
+      def fetch(filter: nil, order: nil)
+        self.init
+        filter = filter.map{|k, v| type_convert(k, v)  }.to_h if filter
+        store.fetch(self, filter: filter, order: order) do |list|
+          yield list if block_given?
+          list
+        end
+      end
+
+      def type_convert(key, value)
+        field_info = self.field_info[key.to_s] || self.field_info[key.to_s.sub(/_id\z/,'')]
+        raise "no such field #{key} in #{self}" unless field_info
+        converted = case field_info.type
+                    when :boolean
+                      value.is_a?(String) ? (value == 'true' ? true : false) : value
+                    else
+                      value
+                    end
+        [key, converted]
+      end
+
+      def store
+        Store.instance
+      end
+
+      def subclasses
+        @subclasses ||= {}
+      end
+
+      def inherited(child)
+        subclasses[child] = false
+      end
+
+      FieldInfo = Struct.new(:name, :type, :params)
+
+      def field(name, type = :string, params = {})
+        params.merge!(client: true, server: true)
+
+        if RUBY_ENGINE == 'opal'
+          return unless params[:client]
+        else
+          return unless params[:server]
+        end
+
+        field_info[name.to_s] = FieldInfo.new(name, type, params)
+
+        self.instance_eval do
+          if type == :reference
+            field_name = "#{name}_id"
+
+            define_method(name) do
+              id = @fields[field_name.to_sym]
+              model_class = Object.const_get(name.to_s.camel_case)
+              model_class[id]
+            end
+
+            define_method(name.to_s + "=") do |value|
+              @fields[field_name.to_sym] = value.id
+            end
+          else
+            field_name = name.to_s
+          end
+
+          define_method(field_name) do
+            @fields[field_name.to_sym]
+          end
+
+          define_method(field_name + "=") do |value|
+            unless type_validator(type).call(value, name)
+              raise 'type error'
+            end
+            @fields[field_name.to_sym] = value
+            handle_event(:change, field_name.to_sym, value)
+          end
+        end
+      end
+
+      ActionInfo = Struct.new(:name, :args, :options)
+
+      def action(name, options = {}, &block)
+        action_info[name.to_s] = ActionInfo.new(name, block.parameters, options)
+        if RUBY_ENGINE == 'opal'
+          method = Proc.new do |model, *args, &callback| # todo: should adopt keyword parameters
+            action_url = options[:on_create] || options[:class] ? "api/#{self}/#{name}" : "api/#{self}/#{model.id}/#{name}"
+            post_data = {}
+            post_data[:model] = model.to_h if options[:on_create]
+            post_data[:args] = args
+            Browser::HTTP.post(action_url, post_data.to_json) do
+              on :success do |res|
+                callback.call(:success, res) if callback
+              end
+
+              on :failure do |res|
+                callback.call(:failure, res) if callback
+              end
+            end
+          end
+          self.instance_eval do
+            if options[:class]
+              define_singleton_method(name) {|*args, &callback| method.call(self, *args, &callback) }
+            else
+              define_method(name) {|*args, &callback| method.call(self, *args, &callback) }
+            end
+          end
+        else
+          self.instance_eval do
+            if options[:class]
+              define_singleton_method(name, block)
+            else
+              define_method(name, block)
+            end
+          end
+        end
+      end
+
+      def find(id)
+        self.init
+
+        case id
+        when String
+          self[id]
+        when Hash
+          self.fetch(filter:id).first
+        end
+
+      end
+
+      def [](id)
+        self.init
+        store.find(self, id)
+      end
+
+      def max(field_name)
+        self.init
+        store.max(self, field_name)
+      end
+    end
+
+    def type_validator(type)
+      case type
+        when :string
+          -> (value, name) { value.is_a? String }
+        when :int
+          -> (value, name) { value.is_a? Integer }
+        when :boolean
+          -> (value, name) { value == true || value == false }
+        when :date
+          -> (value, name) { value.is_a? Date }
+        when :time
+          -> (value, name) { value.is_a? Time }
+        when :reference
+          -> (value, name) { valiedate_reference(value, name) }
+      end
+    end
+
+    def valiedate_reference(value, name)
+      return false unless value.is_a? String
+
+      model_class = Object.const_get(name.camel_case)
+      not model_class[value].nil?
+    end
+
+    def to_h
+      @fields.merge(id: @guid)
+    end
+
+    def to_json(arg)
+      @fields.merge(id: @guid).to_json
+    end
+
+    private
+
+    def get_listeners(event, field_name)
+      @listeners[event].try {|l1| l1[field_name] || [] } || []
+    end
+
+    def set_listener(event, field_name, &block)
+      @listeners[event] ||= {}
+      @listeners[event][field_name] ||= []
+      @listeners[event][field_name] << block
+    end
+  end
+end

data/lib/menilite/router.rb

@@ -0,0 +1,104 @@
+require 'sinatra/base'
+require 'sinatra/json'
+require 'json'
+
+class Class
+  def subclass_of?(klass)
+    raise ArgumentError.new unless klass.is_a?(Class)
+
+    if self == klass
+      true
+    else
+      if self.superclass
+        self.superclass.subclass_of?(klass)
+      else
+        false
+      end
+    end
+  end
+end
+
+module Menilite
+  class Router
+    def initialize(*classes)
+      @classes = classes
+    end
+
+    def before_action_handlers(klass, action)
+      @handlers ||= @classes.select{|c| c.subclass_of?(Menilite::Controller) }.map{|c| c.before_action_handlers }.flatten
+      @handlers.reject do |c|
+        [c[:options][:expect]].flatten.any? do |expect|
+          (classname, _, name) = expect.to_s.partition(?#)
+          (classname == klass.name) && (name.empty? || name == action.to_s)
+        end
+      end
+    end
+
+    def routes(settings)
+      classes = @classes
+      router = self
+      Sinatra.new do
+        enable :sessions
+
+        classes.each do |klass|
+          case
+          when klass.subclass_of?(Menilite::Model)
+            klass.init
+            resource_name = klass.name
+            get "/#{resource_name}" do
+              router.before_action_handlers(klass, 'index').each {|h| self.instance_eval(&h[:proc]) }
+              order = params.delete('order')&.split(?,)
+              data = klass.fetch(filter: params, order: order)
+              json data.map(&:to_h)
+            end
+
+            get "/#{resource_name}/:id" do
+              router.before_action_handlers(klass, 'get').each {|h| self.instance_eval(&h[:proc]) }
+              json klass[params[:id]].to_h
+            end
+
+            post "/#{resource_name}" do
+              router.before_action_handlers(klass, 'post').each {|h| self.instance_eval(&h[:proc]) }
+              data = JSON.parse(request.body.read)
+              results = data.map do |model|
+                instance = klass.new model.map{|key, value| [key.to_sym, value] }.to_h
+                instance.save
+                instance
+              end
+
+              json results.map(&:to_h)
+            end
+
+            klass.action_info.each do |name, action|
+              path = action.options[:on_create] || action.options[:class] ? "/#{resource_name}/#{action.name}" : "/#{resource_name}/#{action.name}/:id"
+
+              post path do
+                router.before_action_handlers(klass, action.name).each {|h| self.instance_eval(&h[:proc]) }
+                data = JSON.parse(request.body.read)
+                result = if action.options[:on_create]
+                           klass.new(data["model"]).send(action.name, *data["args"])
+                         elsif action.options[:class]
+                           klass.send(action.name, *data["args"])
+                         else
+                           klass[params[:id]].send(action.name, *data["args"])
+                         end
+                json result
+              end
+            end
+          when klass.subclass_of?(Menilite::Controller)
+            klass.action_info.each do |name, action|
+              path = klass.respond_to?(:namespace) ? "/#{klass.namespace}/#{action.name}" : "/#{action.name}"
+              post path  do
+                router.before_action_handlers(klass, action.name).each {|h| self.instance_eval(&h[:proc]) }
+                data = JSON.parse(request.body.read)
+                controller = klass.new(session, settings)
+                result = controller.send(action.name, *data["args"])
+                json result
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/menilite/server/activerecord_store.rb

@@ -0,0 +1,116 @@
+require 'sinatra/activerecord'
+
+module Menilite
+  module ActiveRecord
+    def self.create_model(model_class)
+      klass = Class.new(::ActiveRecord::Base) do
+        model_class.field_info.select{|name, field| field.type == :reference }.each do |name, field|
+          belongs_to field.name, primary_key: 'guid', foreign_key: name + '_guid', class_name: name.capitalize
+          #klass.instance_eval { define_method(name + '_id') { send(name + '_guid') } }
+        end
+      end
+      self.const_set(model_class.to_s, klass)
+    end
+  end
+
+  class Store
+    def initialize
+      @tables = {}
+      @armodels = {}
+    end
+
+    def self.instance
+      @instance ||= Menilite::Store.new
+    end
+
+    def register(model_class)
+      @tables[model_class] = {}
+      @armodels[model_class] = Menilite::ActiveRecord.create_model(model_class)
+    end
+
+    def armodel(model_class)
+      @armodels[model_class]
+    end
+
+    def find(model_class, id)
+      ar_obj = @armodels[model_class].find_by(guid: id)
+      to_model(ar_obj, model_class) if ar_obj
+    end
+
+    def save(model)
+      is_array = model.is_a?(Array)
+      models = is_array ? model : [ model ]
+      model_class = models.first.class
+
+      models.each do |m|
+        ar_obj = @armodels[model_class].find_by(guid: m.id)
+        if ar_obj
+          ar_obj.update!(attributes(m))
+        else
+          @armodels[model_class].create!(attributes(m))
+        end
+      end
+
+      yield model if block_given?
+    end
+
+    def fetch(model_class, filter: nil, order: nil)
+      assoc = @armodels[model_class].all
+
+      assoc = assoc.where(filter_condition(model_class, filter)) if filter
+      assoc = assoc.order([order].flatten.map(&:to_sym)) if order
+
+      yield assoc.map {|ar| to_model(ar, model_class) } || [] if block_given?
+    end
+
+    def delete(model_class)
+      @armodels[model_class].delete_all
+    end
+
+    def max(model_class, field_name)
+      fetch(model_class).max(field_name.to_sym)
+    end
+
+    def to_model(ar_obj, model_class)
+      model_class.new(fields(ar_obj, model_class))
+    end
+
+    private
+
+    def [](model_class)
+      @tables[model_class]
+    end
+
+    def filter_condition(model_class, filter)
+      references = model_class.field_info.values.select{|i| i.type == :reference}
+      filter.clone.tap do |hash|
+        references.each do |r|
+          hash["#{r.name}_guid".to_sym] = hash.delete("#{r.name}_id".to_sym) if hash.has_key?("#{r.name}_id".to_sym)
+        end
+
+        hash[:guid] = hash.delete(:id) if hash.has_key?(:id)
+      end
+    end
+
+    def attributes(model)
+      references = model.class.field_info.values.select{|i| i.type == :reference}
+      model.to_h.tap do |hash|
+        references.each do |r|
+          hash["#{r.name}_guid".to_sym] = hash.delete("#{r.name}_id".to_sym)
+        end
+
+        hash[:guid] = hash.delete(:id)
+      end
+    end
+
+    def fields(ar_obj, model_class)
+      references = model_class.field_info.values.select{|i| i.type == :reference}
+      ar_obj.attributes.tap do |hash|
+        references.each do |r|
+          hash["#{r.name}_id"] = hash.delete("#{r.name}_guid")
+        end
+        hash["id"] = hash.delete("guid")
+      end
+    end
+  end
+end

data/lib/menilite/server/store.rb

@@ -0,0 +1,73 @@
+require 'json'
+
+module Menilite
+  class Store
+    DEFAULT_DB_DIR = './.store'
+
+    def initialize(db_dir = DEFAULT_DB_DIR)
+      @tables = {}
+      @db_dir = db_dir
+      Dir.mkdir(@db_dir) unless Dir.exist?(@db_dir)
+    end
+
+    def self.instance
+      @instance ||= Store.new
+    end
+
+    def register(model_class)
+      @tables[model_class] = {}
+    end
+
+    def [](model_class)
+      @tables[model_class]
+    end
+
+    def find(model_class, id)
+      return self[model_class][id] if self[model_class][id]
+
+      fetch(model_class)
+      @tables[model_class][id]
+    end
+
+    def save(model)
+      is_array = model.is_a?(Array)
+      models = is_array ? model : [ model ]
+      model_class = models.first.class
+
+      models.each do |m|
+        @tables[model_class][m.id] = m
+      end
+
+      File.open(filename(model_class), "w") do |file|
+        file.write @tables[model_class].values.to_json
+      end
+
+      yield model if block_given?
+    end
+
+    def fetch(model_class, filter: nil, order: nil)
+      File.open filename(model_class) do |file|
+        records = JSON.parse(file.read)
+        records.select! {|r| filter.all? {|k,v| r[k.to_s] == v } } if filter
+        records.sort_by!{|r| [order].flatten.map{|o| r[o.to_s] } } if order
+        @tables[model_class] = records.map {|m| [m["id"], model_class.new(m)] }.to_h
+      end
+
+      yield @tables[model_class].values || [] if block_given?
+    end
+
+    def delete(model_class)
+      filename = self.filename(model_class)
+      File.delete(filename) if File.exist?(filename)
+    end
+
+    def max(model_class, field_name)
+      fetch(model_class)
+      @tables[model_class].reduce(nil) {|v, max| v.fields[field_name] < max ? max : v.fields[field_name] }
+    end
+
+    def filename(model_class)
+      @db_dir + "/#{model_class}.db"
+    end
+  end
+end

data/lib/menilite/version.rb

@@ -0,0 +1,3 @@
+module Menilite
+  VERSION = "0.1.0"
+end

data/menilite.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'menilite/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "menilite"
+  spec.version       = Menilite::VERSION
+  spec.authors       = ["youchan"]
+  spec.email         = ["youchan01@gmail.com"]
+
+  spec.summary       = %q{Isomorphic models between client side opal and server side ruby.}
+  spec.description   = %q{This is isomorphic models for sharing between client side and server side.}
+  spec.homepage      = "https://github.com/youchan/menilite"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_runtime_dependency "sinatra-activerecord"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: menilite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- youchan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This is isomorphic models for sharing between client side and server
+  side.
+email:
+- youchan01@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/menilite.rb
+- lib/menilite/client/store.rb
+- lib/menilite/controller.rb
+- lib/menilite/model.rb
+- lib/menilite/router.rb
+- lib/menilite/server/activerecord_store.rb
+- lib/menilite/server/store.rb
+- lib/menilite/version.rb
+- menilite.gemspec
+homepage: https://github.com/youchan/menilite
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Isomorphic models between client side opal and server side ruby.
+test_files: []