lazy_lazer 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac56f2a5b77e424495125e8c02d57f80ebd62321
-  data.tar.gz: fa414d8416214f8230f4874ce26c99f73e23ca53
+  metadata.gz: f0bb53bdbc623da087097264074c47c222d9ab6e
+  data.tar.gz: 1101bfd58d2f18f34f5ede3921051fe7a38a760a
 SHA512:
-  metadata.gz: 3005fa813fe2ac2a222e3a5b3bf8aac1a326fda3f220622eeaaea44b336576fbace2ee1c33d5496ab407f9a17d0808a39acd3e34630276d38ba4f39778025fb0
-  data.tar.gz: 4c8284663d754812c1fd0d456d8371bf7dd0a5bb5e0fe4b78553fac2633bfcd9e543249dc5fd68b9e7644a20a27988bd54db62e35e914bc5a87ce777dd678858
+  metadata.gz: c9de14b8ec203392509baee6eee477dc556b9e693c4939ad7db35ef1dde161ecf354dd90ea85d59ab11f1967dcc8288e3fa90e3dd19d519dd411971a8872438e
+  data.tar.gz: 6ce926069ff709433528540c92e2ba6a1e0b161d76a533659d96f12e9137f49518a8761aca9b01064b95b720cf9b5fc49e2c15bbbcd7287fe13e6f4b59b6a048

data/.rubocop.yml

@@ -1,24 +1,16 @@
+# Rubocop configuration based on the Relaxed Ruby Style (with some changes).
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.4
 
+# I just want to convert stuff to boolean.
+Style/DoubleNegation:
+  Enabled: false
+
+# Widescreen monitors are now a thing.
 Metrics/LineLength:
   Max: 100
 
-# Dumb, but also brand new.
-Style/NumericPredicate:
-  Enabled: false
-
-# Stop rubocop from complaining about large `describe` blocks.
+# Allow long describe blocks.
 Metrics/BlockLength:
   Exclude:
-    - spec/**/*_spec.rb
-
-# Lower severity of complexity metrics.
-Metrics/AbcSize:
-  Severity: refactor
-Metrics/CyclomaticComplexity:
-  Severity: refactor
-Metrics/PerceivedComplexity:
-  Severity: refactor
-Metrics/MethodLength:
-  Severity: refactor
+    - 'spec/**/*_spec.rb'

data/CONTRIBUTING.md

@@ -16,8 +16,7 @@ hi there thanks for contributing to lazy_lazer
 
 **tests**
 
-- lazy_lazer is maximum test-driven development
-- there are ~110 lines of source code and ~230 lines of tests
+- lazy_lazer is test-driven (just for external classes tho)
 - consider running `./bin/guard` during development
 - run `rake` and make sure that it passes
 

data/Guardfile

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-guard :rspec, cmd: 'bundle exec rspec --format progress' do
+guard :rspec, cmd: 'bundle exec rspec --format progress --fail-fast' do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { 'spec' }
   watch('spec/spec_helper.rb')  { 'spec' }

data/README.md

@@ -8,10 +8,11 @@ require 'lazy_lazer'
 class User
   include LazyLazer
 
-  property :id, required: true
+  property :id, :required
   property :email, default: 'unknown@example.com'
-  property :created_at, from: 'creation_time_utc', with: ->(time) { Time.at(time) }
+  property :created_at, from: :creation_time_utc, with: ->(t) { Time.at(t) }
   property :age, with: :to_i
+  property :twitter_handle, :nil
   property :favorite_ice_cream
 
   def lazer_reload
@@ -22,10 +23,11 @@ end
 
 user = User.new(id: 152, creation_time_utc: 1500000000, age: '21')
 
-user.id          #=> 152
-user.email       #=> "unknown@example.com"
-user.created_at  #=> 2017-07-14 03:40:00 +0100
-user.age         #=> 21
+user.id             #=> 152
+user.email          #=> "unknown@example.com"
+user.created_at     #=> 2017-07-14 03:40:00 +0100
+user.age            #=> 21
+user.twitter_handle #=> nil
 
 user.favorite_ice_cream         #=> "chocolate"
 user.favorite_ice_cream         #=> "chocolate"
@@ -33,12 +35,10 @@ user.reload.favorite_ice_cream  #=> "vanilla"
 ```
 
 <p align="center">
-licensed under
-<a href="https://github.com/avinashbot/lazy_lazer/blob/master/LICENSE.txt">mit</a>
--
-created for
-<a href="https://github.com/avinashbot/redd">redd</a>
--
-logo font is
-<a href="https://www.behance.net/gallery/3588289/Zaguatica">zaguatica</a>
+<a href="http://www.rubydoc.info/github/avinashbot/lazy_lazer/master">documentation</a> -
+<a href="https://github.com/avinashbot/lazy_lazer/blob/master/CONTRIBUTING.md">contributing</a> -
+<a href="https://github.com/avinashbot/lazy_lazer/blob/master/LICENSE.txt">mit licensed</a>
+<br>
+created for <a href="https://github.com/avinashbot/redd">redd</a> -
+logo font is <a href="https://www.behance.net/gallery/3588289/Zaguatica">zaguatica</a>
 </p>

data/Rakefile

@@ -5,7 +5,7 @@ require 'rubocop/rake_task'
 require 'rspec/core/rake_task'
 
 RuboCop::RakeTask.new do |task|
-  task.options = ['--fail-level', 'convention']
+  task.options = ['-D', '-E', '-S']
 end
 RSpec::Core::RakeTask.new(:spec)
 

data/lazy_lazer.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 # frozen_string_literal: true
 
 lib = File.expand_path('../lib', __FILE__)
@@ -24,10 +23,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler', '~> 1.15'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '~> 0.47'
-  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'rake', '~> 12.1'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+  spec.add_development_dependency 'rubocop', '~> 0.50'
+  spec.add_development_dependency 'pry', '~> 0.11'
   spec.add_development_dependency 'guard', '~> 2.14'
   spec.add_development_dependency 'guard-rspec', '~> 4.7'
 end

data/lib/lazy_lazer/errors.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
 module LazyLazer
+  # The base class for all model errors.
+  class ModelError < StandardError; end
+
   # This is raised when a required attribute isn't included.
-  class RequiredAttribute < StandardError; end
+  class RequiredAttribute < ModelError; end
 
   # Raised when a missing attribute is called but a default isn't present.
-  class MissingAttribute < StandardError; end
+  class MissingAttribute < ModelError; end
 end

data/lib/lazy_lazer/internal_model.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module LazyLazer
+  # A delegator for internal operations.
+  class InternalModel
+    # Create an internal model with a reference to a public model.
+    # @param key_metadata [Hash<Symbol, KeyMetadata>] a reference to a property hash
+    # @param parent [LazyLazer] a reference to a LazyLazer model
+    def initialize(key_metadata, parent)
+      @key_metadata = key_metadata
+      @parent = parent
+      @source_hash = {}
+      @cache_hash = {}
+    end
+
+    # Verify that all the keys marked as required are present.
+    # @raise RequiredAttribute if a required attribute is missing
+    # @return [void]
+    def verify_required!
+      @key_metadata.each do |key_name, meta|
+        next if !meta.required? || @source_hash.key?(meta.source_key)
+        raise RequiredAttribute, "#{@parent} requires `#{key_name}`"
+      end
+    end
+
+    # Converts all unconverted keys and packages them as a hash.
+    # @return [Hash] the converted hash
+    def to_h
+      todo = @key_metadata.keys - @cache_hash.keys
+      todo.each_with_object(@cache_hash) { |key, cache| cache[key] = load_key_from_source(key) }.dup
+    end
+
+    # Get the value of a key (fetching it from the cache if possible)
+    # @param key_name [Symbol] the name of the key
+    # @return [Object] the returned value
+    # @raise MissingAttribute if the attribute wasn't found and there isn't a default
+    def fetch(key_name)
+      @cache_hash[key_name] ||= load_key_from_source(key_name)
+    end
+
+    # Merge a hash into the model.
+    # @param attributes [Hash<Symbol, Object>] the attributes to merge
+    # @return [nil]
+    def merge!(attributes)
+      @cache_hash.clear
+      @source_hash.merge!(attributes)
+      nil
+    end
+
+    private
+
+    # Load the key and apply transformations to it, skipping the cache.
+    # @param key_name [Symbol] the key name
+    # @return [Object] the returned value
+    # @raise MissingAttribute if the attribute wasn't found and there isn't a default
+    def load_key_from_source(key_name)
+      meta = ensure_metadata_exists(key_name)
+      ensure_key_is_loaded(meta.source_key, meta.runtime_required?)
+      raw_value = @source_hash.fetch(meta.source_key) { fetch_default(meta.default) }
+      transform_value(raw_value, meta.transform)
+    end
+
+    # Ensure the metadata is found.
+    # @param key_name [Symbol] the property name
+    # @return [KeyMetadata] the key metadata, if found
+    # @raise MissingAttribute if the key metadata wasn't found
+    def ensure_metadata_exists(key_name)
+      return @key_metadata[key_name] if @key_metadata.key?(key_name)
+      raise MissingAttribute, "`#{key_name}` isn't defined for #{@parent}"
+    end
+
+    # Reloads the model if a key isn't loaded and possibly errors if the key still isn't there.
+    # @param source_key [Symbol] the key that should be loaded
+    # @param runtime_required [Boolean] whether to raise an error if the key is not loaded
+    # @return [void]
+    # @raise MissingAttribute if runtime_required is true and the key can't be loaded.
+    def ensure_key_is_loaded(source_key, runtime_required)
+      @parent.reload if !@source_hash.key?(source_key) && !@parent.fully_loaded?
+      return if @source_hash.key?(source_key) || !runtime_required
+      raise MissingAttribute, "`#{source_key} is missing for #{@parent}`"
+    end
+
+    # Apply a transformation to a value.
+    # @param value [Object] a value
+    # @param transform [nil, Proc, Symbol] a transform type
+    # @return [Object] the transformed value
+    def transform_value(value, transform)
+      case transform
+      when nil
+        value
+      when Proc
+        @parent.instance_exec(value, &transform)
+      when Symbol
+        value.public_send(transform)
+      end
+    end
+
+    # Run the default proc and return its value, if applicable.
+    # @param default [Proc, Object] a proc to run, or an object to return
+    # @return [Object] the processed value
+    def fetch_default(default)
+      return @parent.instance_exec(&default) if default.is_a?(Proc)
+      default
+    end
+  end
+end

data/lib/lazy_lazer/key_metadata.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module LazyLazer
+  # Simple PORO for key metadata. Yay value objects!
+  class KeyMetadata
+    # @return [Symbol] the key to fetch the value from
+    attr_reader :source_key
+
+    # @return [Proc, Object] the default value or generator
+    attr_reader :default
+
+    # @return [Proc, Symbol, nil] the method or proc that transforms the return value
+    attr_reader :transform
+
+    # Load attributes from a {LazyLazer::ClassMethods#property} method signature.
+    # @see LazyLazer::ClassMethods#property
+    def self.from_options(key_name, *boolean_options, **options)
+      boolean_options.each_with_object(options) { |sym, hsh| hsh[sym] = true }
+      KeyMetadata.new(
+        source_key: options[:from] || key_name,
+        required: !!options[:required],
+        runtime_required: !options.key?(:default) && !options[:nil],
+        transform: options[:with],
+        default: options[:default]
+      )
+    end
+
+    # Create a new KeyMetadata value object with all the properties.
+    # @param source_key [Symbol] the key to fetch the value from
+    # @param required [Boolean] whether the key must exist when creating the model
+    # @param runtime_required [Boolean] whether the key must exist when loaded
+    # @param default [Proc, Object] the default value or generator
+    # @param transform [Proc, Symbol, nil] the method or proc that transforms the return value
+    def initialize(source_key:, required:, runtime_required:, default:, transform:)
+      @source_key = source_key
+      @required = required
+      @runtime_required = runtime_required
+      @default = default
+      @transform = transform
+      freeze
+    end
+
+    # @return [Boolean] whether the key must exist when creating the model
+    def required?
+      @required
+    end
+
+    # @return [Boolean] whether the key must exist when loaded
+    def runtime_required?
+      @runtime_required
+    end
+  end
+end

data/lib/lazy_lazer/version.rb

@@ -2,5 +2,5 @@
 
 module LazyLazer
   # The gem's semantic version number.
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/lazy_lazer.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
-require_relative 'lazy_lazer/version'
 require_relative 'lazy_lazer/errors'
+require_relative 'lazy_lazer/internal_model'
+require_relative 'lazy_lazer/key_metadata'
+require_relative 'lazy_lazer/version'
 
-# The LazyLazer root that's included
+# LazyLazer.
+# Include this module into your class to infuse it with lazer powers.
+#
+# @see LazyLazer::ClassMethods your model's class methods
+# @see LazyLazer::InstanceMethods your model's instance methods
 module LazyLazer
   # Hook into `include LazyLazer`.
   # @param base [Module] the object to include the methods in
@@ -11,22 +17,7 @@ module LazyLazer
   def self.included(base)
     base.extend(ClassMethods)
     base.include(InstanceMethods)
-    base.instance_variable_set(
-      :@lazer_metadata,
-      properties: [],
-      required: {},
-      default: {},
-      from: {},
-      with: {}
-    )
-  end
-
-  # Get the source key from an instance
-  # @param instance [Object] the instance
-  # @param key [Symbol] the property key
-  # @return [Symbol] the source key if found or the passed key if not found
-  def self.source_key(instance, key)
-    instance.class.lazer_metadata[:from].fetch(key, key)
+    base.instance_variable_set(:@lazer_metadata, {})
   end
 
   # The methods to extend the class with.
@@ -35,7 +26,7 @@ module LazyLazer
     # @param klass [Class] the subclass
     # @return [void]
     def inherited(klass)
-      klass.instance_variable_set(:@lazer_metadata, @lazer_metadata)
+      klass.instance_variable_set(:@lazer_metadata, @lazer_metadata.dup)
     end
 
     # @return [Hash<Symbol, Hash>] the lazer configuration for this model
@@ -45,19 +36,28 @@ module LazyLazer
 
     # Define a property.
     # @param name [Symbol] the name of the property method
+    # @param bool_options [Array<Symbol>] options that are set to true
     # @param options [Hash] the options to create the property with
     # @option options [Boolean] :required (false) whether existence of this property should be
     #   checked on model creation
+    # @option options [Boolean] :nil (false) shortcut for default: nil
     # @option options [Object, Proc] :default the default value to return if not provided
-    # @option options [Symbol] :from the key in the source object to get the property from
-    # @option options [Proc, Symbol] :with an optional transformation to apply to the value
-    # @note both :required and :default can't be provided
+    # @option options [Symbol] :from (name) the key in the source object to get the property from
+    # @option options [Proc, Symbol, nil] :with an optional transformation to apply to the value
     # @return [Symbol] the name of the created property
-    def property(name, **options)
-      raise 'both :required and :default cannot be given' if options[:required] && options[:default]
+    #
+    # @example
+    #   class MyModel
+    #     include LazyLazer
+    #
+    #     property :id, :required
+    #     property :timestamp, with: ->(i) { Time.at(i) }
+    #     property :created_at, default: ->() { Time.now }
+    #     property :camel_case, from: :camelCase
+    #   end
+    def property(name, *bool_options, **options)
       sym_name = name.to_sym
-      @lazer_metadata[:properties] << sym_name
-      options.each_pair { |option, value| @lazer_metadata[option][sym_name] = value }
+      @lazer_metadata[sym_name] = KeyMetadata.from_options(sym_name, *bool_options, **options)
       define_method(sym_name) { read_attribute(sym_name) }
     end
   end
@@ -67,119 +67,84 @@ module LazyLazer
     # Create a new instance of the class from a set of source attributes.
     # @param attributes [Hash] the model attributes
     # @return [void]
+    # @raise RequiredAttribute if an attribute marked as required wasn't found
     def initialize(attributes = {})
-      # Check that all required attributes exist.
-      self.class.lazer_metadata[:required].keys.each do |property|
-        key = LazyLazer.source_key(self, property)
-        raise RequiredAttribute, "#{self} requires `#{key}`" unless attributes.key?(key)
-      end
-
-      @_lazer_source = attributes.dup
-      @_lazer_cache = {}
+      @_lazer_model = InternalModel.new(self.class.lazer_metadata, self)
+      @_lazer_model.merge!(attributes)
+      @_lazer_model.verify_required!
+      @_lazer_writethrough = {}
+      @_lazer_loaded = false
     end
 
     # Converts all the attributes that haven't been converted yet and returns the final hash.
-    # @param strict [Boolean] whether to fully load all attributes
     # @return [Hash] a hash representation of the model
-    def to_h(strict = true)
-      if strict
-        todo = self.class.lazer_metadata[:properties] - @_lazer_cache.keys
-        todo.each { |k| read_attribute(k) }
-      end
-      @_lazer_cache
-    end
-
-    # @abstract Provides reloading behaviour for lazy loading.
-    # @return [Hash] the result of reloading the hash
-    def lazer_reload
-      self.fully_loaded = true
-      {}
+    def to_h
+      @_lazer_model.to_h
     end
 
     # Reload the object. Calls {#lazer_reload}, then merges the results into the internal store.
     # Also clears out the internal cache.
     # @return [self] the updated object
     def reload
-      new_attributes = lazer_reload
-      @_lazer_source.merge!(new_attributes)
-      @_lazer_cache = {}
+      new_attributes = lazer_reload.to_h
+      @_lazer_model.merge!(new_attributes)
       self
     end
 
     # Return the value of the attribute.
-    # @param name [Symbol] the attribute name
+    # @param key_name [Symbol] the attribute name
+    # @return [Object] the returned value
     # @raise MissingAttribute if the key was not found
-    def read_attribute(name)
-      # Returns the cached attribute.
-      return @_lazer_cache[name] if @_lazer_cache.key?(name)
-
-      # Converts the property into the lookup key.
-      source_key = LazyLazer.source_key(self, name)
-
-      # Reloads if a key that should be there isn't.
-      reload if !@_lazer_source.key?(source_key) &&
-                self.class.lazer_metadata[:properties].include?(name) &&
-                !fully_loaded?
-
-      # Complains if even after reloading, the key is missing (and there's no default).
-      if !@_lazer_source.key?(source_key) && !self.class.lazer_metadata[:default].key?(name)
-        raise MissingAttribute, "`#{source_key}` missing for #{self}"
-      end
-
-      # Gets the value or gets the default.
-      value_or_default = @_lazer_source.fetch(source_key) do
-        default = self.class.lazer_metadata[:default][name]
-        default.is_a?(Proc) ? instance_exec(&default) : default
-      end
-
-      # Transforms the result using :with, if found.
-      transformer = self.class.lazer_metadata[:with][name]
-      coerced =
-        case transformer
-        when Symbol
-          value_or_default.public_send(transformer)
-        when Proc
-          instance_exec(value_or_default, &transformer)
-        else
-          value_or_default
-        end
-
-      # Add to cache and return the result.
-      @_lazer_cache[name] = coerced
+    def read_attribute(key_name)
+      symbol_key = key_name.to_sym
+      return @_lazer_writethrough[symbol_key] if @_lazer_writethrough.key?(symbol_key)
+      @_lazer_model.fetch(symbol_key)
     end
 
-    # Return the value of the attribute, returning nil if not found
-    # @param name [Symbol] the attribute name
-    def [](name)
-      read_attribute(name)
+    # Return the value of the attribute, returning nil if not found.
+    # @param key_name [Symbol] the attribute name
+    # @return [Object] the returned value
+    def [](key_name)
+      read_attribute(key_name)
     rescue MissingAttribute
       nil
     end
 
     # Update an attribute.
-    # @param attribute [Symbol] the attribute to update
+    # @param key_name [Symbol] the attribute to update
     # @param value [Object] the new value
-    def write_attribute(attribute, value)
-      @_lazer_cache[attribute] = value
+    # @return [Object] the written value
+    def write_attribute(key_name, value)
+      @_lazer_writethrough[key_name] = value
     end
 
     # Update multiple attributes at once.
     # @param new_attributes [Hash<Symbol, Object>] the new attributes
+    # @return [self] the updated object
     def assign_attributes(new_attributes)
       new_attributes.each { |key, value| write_attribute(key, value) }
+      self
     end
     alias attributes= assign_attributes
 
     # @return [Boolean] whether the object is done with lazy loading
     def fully_loaded?
-      @_lazer_fully_loaded ||= false
+      @_lazer_loaded
     end
 
     private
 
-    # @param state [Boolean] the new state
-    def fully_loaded=(state)
-      @_lazer_fully_loaded = state
+    # @abstract Provides reloading behaviour for lazy loading.
+    # @return [Hash] the result of reloading the hash
+    def lazer_reload
+      fully_loaded!
+      {}
+    end
+
+    # Mark the model as fully loaded.
+    # @return [void]
+    def fully_loaded!
+      @_lazer_loaded = true
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lazy_lazer
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Avinash Dwarapu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-21 00:00:00.000000000 Z
+date: 2017-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,56 +30,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.1'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.50'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.47'
+        version: '0.50'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -124,13 +124,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/_guard-core
 - bin/console
 - bin/guard
 - bin/setup
 - lazy_lazer.gemspec
 - lib/lazy_lazer.rb
 - lib/lazy_lazer/errors.rb
+- lib/lazy_lazer/internal_model.rb
+- lib/lazy_lazer/key_metadata.rb
 - lib/lazy_lazer/version.rb
 - logo.png
 homepage: https://github.com/avinashbot/lazy_lazer

data/bin/_guard-core

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application '_guard-core' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require 'pathname'
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
-                                           Pathname.new(__FILE__).realpath)
-
-require 'rubygems'
-require 'bundler/setup'
-
-load Gem.bin_path('guard', '_guard-core')