jets 1.4.10 → 1.4.11

data/vendor/dynomite/lib/dynomite/migration/dsl/base_secondary_index.rb

@@ -1,73 +0,0 @@
-# Base class for LocalSecondaryIndex and GlobalSecondaryIndex
-class Dynomite::Migration::Dsl
-  class BaseSecondaryIndex
-    include Common
-
-    attr_accessor :action, :key_schema, :attribute_definitions
-    attr_accessor :index_name
-    def initialize(action, index_name=nil, &block)
-      @action = action.to_sym
-      # for gsi action can be: :create, :update, :delete
-      # for lsi action is always: :create
-      @index_name = index_name
-      @block = block
-
-      # Dsl fills these atttributes in as methods are called within
-      # the block
-      @key_schema = []
-      @attribute_definitions = []
-      # default provisioned_throughput
-      @provisioned_throughput = {
-        read_capacity_units: 5,
-        write_capacity_units: 5
-      }
-    end
-
-    def index_name
-      @index_name || conventional_index_name
-    end
-
-    def conventional_index_name
-      # @partition_key_identifier and @sort_key_identifier are set as immediately
-      # when the partition_key and sort_key methods are called in the dsl block.
-      # Usually look like this:
-      #
-      #   @partition_key_identifier: post_id:string
-      #   @sort_key_identifier: updated_at:string
-      #
-      # We strip the :string portion in case it is provided
-      #
-      partition_key = @partition_key_identifier.split(':').first
-      sort_key = @sort_key_identifier.split(':').first if @sort_key_identifier
-      [partition_key, sort_key, "index"].compact.join('-')
-    end
-
-    def evaluate
-      return if @evaluated
-      @block.call(self) if @block
-      @evaluated = true
-    end
-
-    def params
-      evaluate # lazy evaluation: wait until as long as possible before evaluating code block
-
-      params = { index_name: index_name } # required for all actions
-
-      if @action == :create
-        params[:key_schema] = @key_schema # required for create action
-        # hardcode to ALL for now
-        params[:projection] = { # required
-          projection_type: "ALL", # accepts ALL, KEYS_ONLY, INCLUDE
-          # non_key_attributes: ["NonKeyAttributeName"],
-        }
-      end
-
-      if self.is_a?(GlobalSecondaryIndex) && [:create, :update].include?(@action)
-        # provisioned_throughput is required for gsi index definition
-        params[:provisioned_throughput] = @provisioned_throughput
-      end
-
-      params
-    end
-  end
-end

data/vendor/dynomite/lib/dynomite/migration/dsl/global_secondary_index.rb

@@ -1,4 +0,0 @@
-class Dynomite::Migration::Dsl
-  class GlobalSecondaryIndex < BaseSecondaryIndex
-  end
-end

data/vendor/dynomite/lib/dynomite/migration/dsl/local_secondary_index.rb

@@ -1,8 +0,0 @@
-class Dynomite::Migration::Dsl
-  class LocalSecondaryIndex < BaseSecondaryIndex
-    def initialize(index_name=nil, &block)
-      # Can only create local secondary index when creating a table
-      super(:create, index_name, &block)
-    end
-  end
-end

data/vendor/dynomite/lib/dynomite/migration/dsl.rb

@@ -1,194 +0,0 @@
-class Dynomite::Migration
-  class Dsl
-    autoload :Common, "dynomite/migration/common"
-    autoload :BaseSecondaryIndex, "dynomite/migration/dsl/base_secondary_index"
-    autoload :LocalSecondaryIndex, "dynomite/migration/dsl/local_secondary_index"
-    autoload :GlobalSecondaryIndex, "dynomite/migration/dsl/global_secondary_index"
-
-    include Dynomite::DbConfig
-    include Common
-
-    attr_accessor :key_schema, :attribute_definitions
-    attr_accessor :table_name
-    def initialize(method_name, table_name, &block)
-      @method_name = method_name
-      @table_name = table_name
-      @block = block
-
-      # Dsl fills in atttributes in as methods are called within the block.
-      # Attributes for both create_table and updated_table:
-      @attribute_definitions = []
-      @provisioned_throughput = {
-        read_capacity_units: 5,
-        write_capacity_units: 5
-      }
-
-      # Attributes for create_table only:
-      @key_schema = []
-
-      # Attributes for update_table only:
-      @gsi_indexes = []
-      @lsi_indexes = []
-    end
-
-    # t.gsi(:create) do |i|
-    #   i.partition_key = "category:string"
-    #   i.sort_key = "created_at:string" # optional
-    # end
-    def gsi(action=:create, index_name=nil, &block)
-      gsi_index = GlobalSecondaryIndex.new(action, index_name, &block)
-      @gsi_indexes << gsi_index # store @gsi_index for the parent Dsl to use
-    end
-    alias_method :global_secondary_index, :gsi
-
-    # t.lsi(:create) do |i|
-    #   i.partition_key = "category:string"
-    #   i.sort_key = "created_at:string" # optional
-    # end
-    def lsi(action=:create, index_name=nil, &block)
-      # dont need action create but have it to keep the lsi and gsi method consistent
-      lsi_index = LocalSecondaryIndex.new(index_name, &block)
-      @lsi_indexes << lsi_index # store @lsi_index for the parent Dsl to use
-    end
-    alias_method :local_secondary_index, :lsi
-
-    def evaluate
-      return if @evaluated
-      @block.call(self) if @block
-      @evaluated = true
-    end
-
-    # http://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/dynamo-example-create-table.html
-    # build the params up from dsl in memory and provides params to the
-      # executor
-    def params
-      evaluate # lazy evaluation: wait until as long as possible before evaluating code block
-
-      # Not using send because think its clearer in this case
-      case @method_name
-      when :create_table
-        params_create_table
-      when :update_table
-        params_update_table
-      end
-    end
-
-    def params_create_table
-      merge_lsi_attribute_definitions!
-      merge_gsi_attribute_definitions!
-
-      params = {
-        table_name: namespaced_table_name,
-        key_schema: @key_schema,
-        attribute_definitions: @attribute_definitions,
-        provisioned_throughput: @provisioned_throughput
-      }
-
-      params[:local_secondary_indexes] = lsi_secondary_index_creates unless @lsi_indexes.empty?
-      params[:global_secondary_indexes] = gsi_secondary_index_creates unless @gsi_indexes.empty?
-      params
-    end
-
-    def params_update_table
-      merge_gsi_attribute_definitions!
-
-      params = {
-        table_name: namespaced_table_name,
-        attribute_definitions: @attribute_definitions,
-        # update table take values only some values for the "parent" table
-        # no key_schema, update_table does not handle key_schema for the "parent" table
-      }
-      # only set "parent" table provisioned_throughput if user actually invoked
-      # it in the dsl
-      params[:provisioned_throughput] =  @provisioned_throughput if @provisioned_throughput_set_called
-      params[:global_secondary_index_updates] = global_secondary_index_updates
-      params
-    end
-
-    # Goes thorugh all the lsi_indexes that have been built up in memory.
-    # Find the lsi object that creates an index and then grab the
-    # attribute_definitions from it.
-    def merge_lsi_attribute_definitions!
-      lsi = @lsi_indexes.first # DynamoDB only supports adding one index at a time anyway. The reason @lsi_indexes is an Array is because we're sharing the same class code for LSI and GSI
-      if lsi
-        lsi.evaluate # force early evaluate since we need the params to
-          # add: gsi_attribute_definitions + lsi_attrs
-        lsi_attrs = lsi.attribute_definitions
-      end
-      all_attrs = if lsi_attrs
-                    @attribute_definitions + lsi_attrs
-                  else
-                    @attribute_definitions
-                  end
-      @attribute_definitions = all_attrs.uniq
-    end
-
-    # maps each lsi to the hash structure expected by dynamodb update_table
-    # under the global_secondary_index_updates key:
-    #
-    #   { create: {...} }
-    #   { update: {...} }
-    #   { delete: {...} }
-    def lsi_secondary_index_creates
-      @lsi_indexes.map do |lsi|
-        lsi.params
-      end
-    end
-
-    # maps each lsi to the hash structure expected by dynamodb update_table
-    # under the global_secondary_index_updates key:
-    #
-    #   { create: {...} }
-    #   { update: {...} }
-    #   { delete: {...} }
-    def gsi_secondary_index_creates
-      @gsi_indexes.map do |gsi|
-        gsi.params
-      end
-    end
-
-    # Goes thorugh all the gsi_indexes that have been built up in memory.
-    # Find the gsi object that creates an index and then grab the
-    # attribute_definitions from it.
-    def merge_gsi_attribute_definitions!
-      gsi_attrs = []
-
-      gsi = @gsi_indexes.find { |i| i.action == :create }
-      if gsi
-        gsi.evaluate # force early evaluate since we need the params to
-          # add: gsi_attribute_definitions + gsi_attrs
-        gsi_attrs = gsi.attribute_definitions
-      end
-
-      # Merge existing attributes for update table
-      all_gsi_attrs = @method_name == :update_table ?
-        gsi_attribute_definitions + gsi_attrs :
-        gsi_attrs
-
-      all_attrs = (@attribute_definitions + all_gsi_attrs).uniq
-      @attribute_definitions = all_attrs
-    end
-
-    # maps each gsi to the hash structure expected by dynamodb update_table
-    # under the global_secondary_index_updates key:
-    #
-    #   { create: {...} }
-    #   { update: {...} }
-    #   { delete: {...} }
-    def global_secondary_index_updates
-      @gsi_indexes.map do |gsi|
-        { gsi.action => gsi.params }
-      end
-    end
-
-    # >> resp = Post.db.describe_table(table_name: "demo-dev-posts")
-    # >> resp.table.attribute_definitions.map(&:to_h)
-    # => [{:attribute_name=>"id", :attribute_type=>"S"}]
-    def gsi_attribute_definitions
-      return @gsi_attribute_definitions if @gsi_attribute_definitions
-
-      resp = db.describe_table(table_name: namespaced_table_name)
-      @gsi_attribute_definitions = resp.table.attribute_definitions.map(&:to_h)
-    end
-  end
-end

data/vendor/dynomite/lib/dynomite/migration/executor.rb

@@ -1,38 +0,0 @@
-class Dynomite::Migration
-  class Executor
-    include Dynomite::DbConfig
-
-    # Examples:
-    #  Executor.new(:create_table, params) or
-    #  Executor.new(:update_table, params)
-    #
-    # The params are generated frmo the dsl.params
-    attr_accessor :table_name
-    def initialize(table_name, method_name, params)
-      @table_name = table_name
-      @method_name = method_name # create_table or update_table
-      @params = params
-    end
-
-    def run
-      begin
-        # Examples:
-        #   result = db.create_table(@params)
-        #   result = db.update_table(@params)
-
-        # Leaving this verbose output in here until this DSL is more hardened to help debug
-        unless ENV['DYNOMITE_ENV'] == 'test'
-          puts "Calling #{@method_name} with params:"
-          pp @params
-        end
-
-        return if ENV['DYNOMITE_DRY'] # dry run flag
-        result = db.send(@method_name, @params)
-
-        puts "DynamoDB Table: #{@table_name} Status: #{result.table_description.table_status}"
-      rescue Aws::DynamoDB::Errors::ServiceError => error
-        puts "Unable to #{@method_name.to_s.gsub('_',' ')}: #{error.message}".colorize(:red)
-      end
-    end
-  end
-end

data/vendor/dynomite/lib/dynomite/migration/generator.rb

@@ -1,68 +0,0 @@
-require "active_support/core_ext/string"
-
-class Dynomite::Migration
-  # jets dynamodb:generate posts --partition-key id:string
-  class Generator
-    include Dynomite::DbConfig
-
-    attr_reader :migration_name, :table_name
-    def initialize(migration_name, options)
-      @migration_name = migration_name
-      @options = options
-    end
-
-    def generate
-      puts "Generating migration for #{@table_name}" unless @options[:quiet]
-      return if @options[:noop]
-      create_migration
-    end
-
-    def create_migration
-      FileUtils.mkdir_p(File.dirname(migration_path))
-      IO.write(migration_path, migration_code)
-      puts "Migration file created: #{migration_path}. \nTo run:"
-      puts "  jets dynamodb:migrate #{migration_path}"
-    end
-
-    def migration_code
-      path = File.expand_path("../templates/#{table_action}.rb", __FILE__)
-      result = Dynomite::Erb.result(path,
-        migration_class_name: migration_class_name,
-        table_name: table_name,
-        partition_key: @options[:partition_key],
-        sort_key: @options[:sort_key],
-        provisioned_throughput: @options[:provisioned_throughput] || 5,
-      )
-    end
-
-    def table_action
-      @options[:table_action] || conventional_table_action
-    end
-
-    def conventional_table_action
-      @migration_name.include?("update") ? "update_table" : "create_table"
-    end
-
-    def table_name
-      @options[:table_name] || conventional_table_name
-    end
-
-    # create_posts => posts
-    # update_posts => posts
-    def conventional_table_name
-      @migration_name.sub(/^(create|update)_/, '')
-    end
-
-    def migration_class_name
-      "#{@migration_name}_migration".classify # doesnt include timestamp
-    end
-
-    def migration_path
-      "#{Dynomite.app_root}dynamodb/migrate/#{timestamp}-#{@migration_name}_migration.rb"
-    end
-
-    def timestamp
-      @timestamp ||= Time.now.strftime("%Y%m%d%H%M%S")
-    end
-  end
-end

data/vendor/dynomite/lib/dynomite/migration/templates/create_table.rb

@@ -1,32 +0,0 @@
-class <%= @migration_class_name %> < Dynomite::Migration
-  def up
-    create_table :<%= @table_name %> do |t|
-      t.partition_key "<%= @partition_key %>" # required
-<% if @sort_key # so extra spaces are not added when generated -%>
-      t.sort_key  "<%= @sort_key %>" # optional
-<% end -%>
-      t.provisioned_throughput(<%= @provisioned_throughput %>) # sets both read and write, defaults to 5 when not set
-
-      # Instead of using partition_key and sort_key you can set the
-      # key schema directly also
-      # t.key_schema([
-      #     {attribute_name: "id", :key_type=>"HASH"},
-      #     {attribute_name: "created_at", :key_type=>"RANGE"}
-      #   ])
-      # t.attribute_definitions([
-      #   {attribute_name: "id", attribute_type: "N"},
-      #   {attribute_name: "created_at", attribute_type: "S"}
-      # ])
-
-      # other ways to set provisioned_throughput
-      # t.provisioned_throughput(:read, 10)
-      # t.provisioned_throughput(:write, 10)
-      # t.provisioned_throughput(
-      #   read_capacity_units: 5,
-      #   write_capacity_units: 5
-      # )
-    end
-  end
-end
-
-# More examples: https://github.com/tongueroo/dynomite/tree/master/docs

data/vendor/dynomite/lib/dynomite/migration/templates/update_table.rb

@@ -1,26 +0,0 @@
-class <%= @migration_class_name %> < Dynomite::Migration
-  def up
-    update_table :<%= @table_name %> do |t|
-      t.gsi(:create) do |i|
-        i.partition_key "<%= @partition_key %>" # required
-<% if @sort_key # so extra spaces are not added when generated -%>
-        t.sort_key  "<%= @sort_key %>" # optional
-<% end -%>
-
-        i.provisioned_throughput(5)
-      end
-
-      # Examples:
-      # t.gsi(:update, "update-me-index") do |i|
-      #   i.provisioned_throughput(10)
-      # end
-
-      # t.gsi(:delete, "delete-me-index")
-
-      # Must use :create, :update, :delete one at a time in separate migration files.
-      # DynamoDB imposes this.
-    end
-  end
-end
-
-# More examples: https://github.com/tongueroo/dynomite/tree/master/docs

data/vendor/dynomite/lib/dynomite/migration.rb

@@ -1,27 +0,0 @@
-module Dynomite
-  class Migration
-    autoload :Dsl, "dynomite/migration/dsl"
-    autoload :Generator, "dynomite/migration/generator"
-    autoload :Executor, "dynomite/migration/executor"
-
-    def up
-      puts "Should defined an up method for your migration: #{self.class.name}"
-    end
-
-    def create_table(table_name, &block)
-      execute_with_dsl_params(table_name, :create_table, &block)
-    end
-
-    def update_table(table_name, &block)
-      execute_with_dsl_params(table_name, :update_table, &block)
-    end
-
-  private
-    def execute_with_dsl_params(table_name, method_name, &block)
-      dsl = Dsl.new(method_name, table_name, &block)
-      params = dsl.params
-      executor = Executor.new(table_name, method_name, params)
-      executor.run
-    end
-  end
-end

data/vendor/dynomite/lib/dynomite/version.rb

@@ -1,3 +0,0 @@
-module Dynomite
-  VERSION = "1.1.0"
-end

data/vendor/dynomite/lib/dynomite.rb

@@ -1,23 +0,0 @@
-$:.unshift(File.expand_path("../", __FILE__))
-require "dynomite/version"
-
-module Dynomite
-  ATTRIBUTE_TYPES = {
-    'string' => 'S',
-    'number' => 'N',
-    'binary' => 'B',
-    's' => 'S',
-    'n' => 'N',
-    'b' => 'B',
-  }
-
-  autoload :Migration, "dynomite/migration"
-  autoload :Dsl, "dynomite/dsl"
-  autoload :DbConfig, "dynomite/db_config"
-  autoload :Item, "dynomite/item"
-  autoload :Core, "dynomite/core"
-  autoload :Erb, "dynomite/erb"
-  autoload :Log, "dynomite/log"
-
-  extend Core
-end

data/vendor/dynomite/spec/fixtures/app_root/config/dynamodb.yml

@@ -1,7 +0,0 @@
-# Throwing this in here to make tests easier to write
-development:
-  endpoint: http://localhost:8000
-
-test:
-  table_namespace: 'testnamespace'
-  endpoint: http://localhost:8000

data/vendor/dynomite/spec/fixtures/dynamodb/migrate/20190108061826-comments_migration.rb

@@ -1,30 +0,0 @@
-class CommentsMigration < Dynomite::Migration
-  def up
-    create_table :comments do |t|
-      t.partition_key "post_id:string" # required
-      t.sort_key  "created_at:string" # optional
-      t.provisioned_throughput(5) # sets both read and write, defaults to 5 when not set
-
-      # Instead of using partition_key and sort_key you can set the
-      # key schema directly also
-      # t.key_schema([
-      #     {attribute_name: "id", :key_type=>"HASH"},
-      #     {attribute_name: "created_at", :key_type=>"RANGE"}
-      #   ])
-      # t.attribute_definitions([
-      #   {attribute_name: "id", attribute_type: "N"},
-      #   {attribute_name: "created_at", attribute_type: "S"}
-      # ])
-
-      # other ways to set provisioned_throughput
-      # t.provisioned_throughput(:read, 10)
-      # t.provisioned_throughput(:write, 10)
-      # t.provisioned_throughput(
-      #   read_capacity_units: 5,
-      #   write_capacity_units: 5
-      # )
-    end
-  end
-end
-
-# More examples: https://github.com/tongueroo/dynomite/tree/master/docs

data/vendor/dynomite/spec/lib/dynomite/item_spec.rb

@@ -1,102 +0,0 @@
-require "spec_helper"
-
-class Post < Dynomite::Item
-end
-class Comment < Dynomite::Item
-  partition_key "post_id" # defaults to id
-end
-
-describe Dynomite::Item do
-  describe "general" do
-    it "loads attributes" do
-      post = Post.new(title: "my title", desc: "my desc")
-      expect(post.attrs).to eq("title" => "my title", "desc" => "my desc")
-
-      post.attrs(title: "my title2")
-      expect(post.attrs).to eq("title" => "my title2", "desc" => "my desc")
-    end
-
-    it "table_name" do
-      expect(Post.table_name).to eq "testnamespace-posts"
-      expect(Comment.table_name).to eq "testnamespace-comments"
-      # hack to quickly test blank and namespaces
-      old_namespace = Comment.instance_variable_get(:@table_namespace)
-      Comment.instance_variable_set(:@table_namespace, '')
-      expect(Comment.table_name).to eq "comments"
-      Comment.instance_variable_set(:@table_namespace, old_namespace)
-    end
-
-    it "partition_key" do
-      expect(Post.partition_key).to eq "id"
-      expect(Comment.partition_key).to eq "post_id"
-    end
-  end
-
-  describe "CRUD-ish" do
-    before(:each) { Post.db = db }
-    let(:db) { double(:db) }
-
-    let(:find_resp) do
-      fake_attributes = {"id" => "myid", "title" => "my title"}
-      resp = double(:resp)
-      expect(resp).to receive(:item).and_return(fake_attributes)
-      resp
-    end
-    it "find" do
-      expect(Post.db).to receive(:get_item).and_return(find_resp)
-
-      post = Post.find("myid")
-
-      expect(post.attrs).to eq("id" => "myid", "title" => "my title")
-    end
-
-    it "replace" do
-      # Not returning a resp with receive because it is not useful
-      # Dynanmodb doesnt provide much useful info there.
-      expect(Post.db).to receive(:put_item)
-
-      post = Post.new(title: "my title")
-      post.replace
-      attrs = post.attrs
-
-      expect(attrs[:title]).to eq "my title"
-      expect(attrs[:id].size).to eq 40 # generated unique id
-    end
-
-    it "replace with hash" do
-      # Not returning a resp with receive because it is not useful
-      # Dynanmodb doesnt provide much useful info there.
-      expect(Post.db).to receive(:put_item)
-
-      post = Post.new(title: "my title")
-      post.replace(title: "my title 2")
-      attrs = post.attrs
-
-      expect(attrs[:title]).to eq "my title 2"
-      expect(attrs[:id].size).to eq 40 # generated unique id
-    end
-
-    it "delete" do
-      allow(Post.db).to receive(:delete_item)
-
-      Post.delete("myid")
-
-      expect(Post.db).to have_received(:delete_item)
-    end
-
-    let(:scan_resp) do
-      fake_attributes = [{"id" => "myid", "title" => "my title"}]
-      resp = double(:resp)
-      expect(resp).to receive(:items).and_return(fake_attributes)
-      resp
-    end
-    it "scan" do
-      allow(Post.db).to receive(:scan).and_return(scan_resp)
-
-      post = Post.scan
-
-      expect(Post.db).to have_received(:scan)
-    end
-  end
-end
-