flappy-cli 0.3.0

data/lib/flappy/patches/concern.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+
+module ActiveSupport
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     class_methods do
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # It works, now Bar takes care of its dependencies
+  #   end
+  module Concern
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        return false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        fail MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
+
+        @_included_block = block
+      else
+        super
+      end
+    end
+
+    def class_methods(&class_methods_module_definition)
+      if const_defined?(:ClassMethods, false)
+        mod = const_get(:ClassMethods)
+      else
+        mod = const_set(:ClassMethods, Module.new)
+      end
+
+      mod.module_eval(&class_methods_module_definition)
+    end
+  end
+end

data/lib/flappy/patches/default_headers.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module RestClient
+  class Request
+    def default_headers
+      { content_type: :json, source: 'fir-cli', version: Flappy::VERSION }
+    end
+  end
+end

data/lib/flappy/patches/hash.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+class Hash
+  # Returns a copy of self with all blank keys removed.
+  #
+  #  hash = { name: 'Rob', age: '', title: nil }
+  #
+  #  hash.compact
+  #  # => { name: 'Rob' }
+  def compact
+    delete_if { |_, v| v.is_a?(FalseClass) ? false : v.blank? }
+  end
+
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys { |key| key.to_sym rescue key }
+  end
+
+  private
+
+    # support methods for deep transforming nested hashes and arrays
+    def _deep_transform_keys_in_object(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map { |e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+      end
+    end
+end

data/lib/flappy/patches/instance_variables.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+class Object
+  # Returns a hash with string keys that maps instance variable names without "@" to their
+  # corresponding values.
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #
+  #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
+  def instance_values
+    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+  end
+
+  # Returns an array of instance variable names as strings including "@".
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #
+  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
+  def instance_variable_names
+    instance_variables.map { |var| var.to_s }
+  end
+end

data/lib/flappy/patches/native_patch.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+class File
+  class << self
+    # A binary file is Mach-O dSYM
+    #
+    # @return [true, false]
+    def dsym?(file_path)
+      !(`file -b #{file_path}` =~ /dSYM/).nil?
+    end
+
+    # A file is ASCII text
+    #
+    # @return [true, false]
+    def text?(file_path)
+      !(`file -b #{file_path}` =~ /text/).nil?
+    end
+  end
+end
+
+class String
+  # Convert String encoding to UTF-8
+  #
+  # @return string
+  def to_utf8
+    encode(Encoding.find('UTF-8'), invalid: :replace, undef: :replace, replace: '')
+  end
+end

data/lib/flappy/patches/os_patch.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module OS
+  class << self
+
+    def windows?
+      !(/cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM).nil?
+    end
+
+    def mac?
+      !(/darwin/ =~ RUBY_PLATFORM).nil?
+    end
+
+    def unix?
+      !OS.windows?
+    end
+
+    def linux?
+      OS.unix? && !OS.mac?
+    end
+
+    def set_locale
+      system 'export LC_ALL=en_US.UTF-8'
+      system 'export LC_CTYPE=en_US.UTF-8'
+      system 'export LANG=en_US.UTF-8'
+    end
+  end
+end

data/lib/flappy/patches/try.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+class Object
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) #=> nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) #=> nil
+  #
+  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # in case of argument mismatch.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+. For example, using +try+ with
+  # +SimpleDelegator+ will delegate +try+ to the target instead of calling it on
+  # the delegator itself.
+  def try(*a, &b)
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
+  end
+
+  # Same as #try, but will raise a NoMethodError exception if the receiver is not +nil+ and
+  # does not implement the tried method.
+
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      if b.arity.zero?
+        instance_eval(&b)
+      else
+        yield self
+      end
+    else
+      public_send(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && @person.children.any? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*args)
+    nil
+  end
+
+  def try!(*args)
+    nil
+  end
+end

data/lib/flappy/patches.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require_relative './patches/blank'
+require_relative './patches/concern'
+require_relative './patches/hash'
+require_relative './patches/instance_variables'
+require_relative './patches/native_patch'
+require_relative './patches/os_patch'
+require_relative './patches/try'
+require_relative './patches/default_headers'
+
+

data/lib/flappy/util/archive_ipa.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+module Flappy
+  module ArchiveIpa
+    def archive_ipa(*args, options)
+
+      build_dir = Dir.pwd
+      ipa_dir = ''
+
+      if args.count == 2
+        build_dir = args.first.to_s
+        ipa_dir = args.last.to_s
+      elsif args.count == 1
+        build_dir = args.first.to_s
+      end
+
+      check_condition(build_dir, 'build dir can not be empty!')
+      build_dir = File.expand_path(build_dir) unless build_dir.blank?
+
+      unless ipa_dir.blank?
+        ipa_path = File.join(ipa_dir, Time.now.strftime('%Y%m%d%H%M%S') + '.ipa')
+      else
+        ipa_path = File.join(build_dir, Time.now.strftime('%Y%m%d%H%M%S') + '.ipa')
+      end
+
+      puts "build_dir: #{build_dir}\nipa_path: #{ipa_path}"
+
+      xcrun_cmd = archive_ipa_with_path(build_dir, ipa_path)
+
+      puts '>>>>>>>>>>>>>>>>>>>>>>>>>>>> Archiving......'
+      puts "archive cmd: #{xcrun_cmd}"
+
+      system(xcrun_cmd) unless xcrun_cmd.blank?
+
+      if $?.to_i != 0
+        puts '>>>>>>>>>>>>>>>>>>>>>>>>>>>> Archive failed'
+        exit 1
+      else
+        puts '>>>>>>>>>>>>>>>>>>>>>>>>>>>> Archive succeed'
+      end
+    end
+
+    def archive_ipa_with_path(build_dir, ipa_path)
+      check_condition(build_dir, 'build dir is empty!')
+      check_condition(ipa_path, 'ipa_path dir is empty!')
+
+      apps = Dir["#{build_dir}/**/*.app"].sort_by(&:size)
+
+      log_iOS("Found .app in build dir: #{apps}")
+      check_no_output_app(apps)
+
+      xcrun_cmd = "xcrun --sdk iphoneos PackageApplication -v #{apps.join(' ')} -o #{ipa_path}"
+    end
+  end
+end

data/lib/flappy/util/build_apk.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+module Flappy
+  module BuildApk
+
+    def build_apk(*args, options)
+
+      set_flavor(options)
+      check_not_set_flavor
+
+      initialize_build_common_options(args, options)
+
+      Dir.chdir(@build_dir)
+      File.new(File.join("#{@build_dir}","dependencies.txt"), "w")
+      @build_cmd = initialize_apk_build_cmd
+
+      logger_info_and_run_build_command
+
+      temp_cmd = initialize_get_dependencies_cmd;
+      logger_info_and_get_dependencies_command temp_cmd
+
+      output_apk
+      publish_build_app(options) if options.publish?
+
+      logger_info_blank_line
+    end
+
+    private
+
+    def set_flavor(options)
+      unless options.flavor.blank?
+        @flavor = options.flavor
+        build_type = options[:debug] ? 'Debug' : 'Release'
+        unless @flavor =~ /^assemble(.+)/
+          @flavor = "assemble#{@flavor}#{build_type}"
+        end
+      end
+    end
+
+    def initialize_apk_build_cmd
+      check_build_gradle_exist
+
+      cmd = "./gradlew build"
+      cmd = "./gradlew #{@flavor}" unless @flavor.blank?
+      cmd
+    end
+
+    def initialize_get_dependencies_cmd
+      #create dependencies.txt
+      cmd = "./gradlew -q  app:dependencies --configuration compile >  #{@build_dir}/dependencies.txt"
+      cmd
+    end
+
+    def gradle_build_path
+      "#{@build_dir}/build/outputs/apk"
+    end
+
+    def prefix_gradle_build_path
+      "#{@build_dir}/app/build/outputs/apk"
+    end
+
+    def cheniu_prefix_gradle_build_path
+      "#{@build_dir}/cheniu/build/outputs/apk"
+    end
+
+    def output_apk
+      @builded_apk ||= Dir["#{gradle_build_path}/*.apk"].find { |i| i =~ /release/ ||i =~ /debug/}
+      @builded_apk ||= Dir["#{prefix_gradle_build_path}/*.apk"].find { |i| i =~ /release/  || i =~ /debug/}
+      @builded_apk ||= Dir["#{@build_dir}/*.apk"].find { |i| i =~ /release/ || i =~ /debug/ }
+      @builded_apk ||= Dir["#{cheniu_prefix_gradle_build_path}/*.apk"].find { |i| i =~ /release/ || i =~ /debug/}
+
+      check_no_output_apk
+
+      apk_info = Flappy.apk_info(@builded_apk)
+
+      # binding.pry
+      @apk_name = @name.blank? ? "#{apk_info[:name]}-#{apk_info[:version]}" : @name
+
+      @builded_app_path = "#{@build_dir}/#{@apk_name}.apk"
+      FileUtils.cp(@builded_apk, @builded_app_path)
+    end
+
+    def check_no_output_apk
+      unless @builded_apk
+        logger.error 'Builded has no output apk'
+        exit 1
+      end
+    end
+
+    def check_not_set_flavor
+      unless @flavor
+        logger.error 'please set flavor'
+        exit 1
+      end
+    end
+
+    def check_build_gradle_exist
+      return if File.exist?("#{@build_dir}/build.gradle")
+
+      logger.error "The build.gradle isn't exit"
+      exit 1
+    end
+  end
+end

data/lib/flappy/util/build_common.rb

@@ -0,0 +1,90 @@
+module Flappy
+  module BuildCommon
+
+    def initialize_build_common_options(args, options)
+      @build_dir     = initialize_build_dir(args, options)
+      @output_path   = initialize_output_path(options)
+      @token         = options[:firToken] || current_token
+      @changelog     = options[:changelog].to_s
+      @short         = options[:short].to_s
+      @name          = options[:name].to_s
+      @proj          = options[:proj].to_s
+      @export_qrcode = options[:qrcode]
+    end
+
+    def initialize_build_dir(args, options)
+      build_dir = args.first.to_s
+      if File.extname(build_dir) == '.git'
+        args.shift && git_clone_build_dir(build_dir, options)
+      elsif build_dir.blank? || !File.exist?(build_dir)
+        Dir.pwd
+      else
+        args.shift && File.absolute_path(build_dir)
+      end
+    end
+
+    def git_clone_build_dir(ssh_url, options)
+      # project_name = File.basename(ssh_url, '.git')
+      # now_time = Time.now.strftime('%Y%m%d%H%M%S')
+      # work_space = "Flappy/Android/#{project_name}/#{now_time}"
+      # code_name = "#{now_time}_#{project_name}_store";
+      #
+      # repo_name = work_space + "/#{code_name}"
+
+      repo_name = File.basename(ssh_url, '.git') + "_#{Time.now.strftime('%Y%m%dT%H%M%S')}"
+      branch = options[:branch].blank? ? 'master' : options[:branch]
+      git_cmd = "git clone --depth=50 --branch=#{branch} #{ssh_url} #{repo_name}"
+
+      logger.info git_cmd
+      logger_info_dividing_line
+
+      if system(git_cmd)
+        File.absolute_path(repo_name)
+      else
+        logger.error 'Git clone failed'
+        exit 1
+      end
+    end
+
+    def initialize_output_path(options)
+      if options[:output].blank?
+        output_path = "#{@build_dir}"
+        FileUtils.mkdir_p(output_path) unless File.exist?(output_path)
+        output_path
+      else
+        output_path = options[:output].to_s
+        unless File.exist?(output_path)
+          logger.warn "The output path not exist and flappy-cli will autocreate it..."
+        end
+        File.absolute_path(output_path)
+      end
+    end
+
+    def publish_build_app(options)
+      logger_info_blank_line
+      publish @builded_app_path, options
+    end
+
+    def logger_info_and_run_build_command
+      puts @build_cmd if $DEBUG
+
+      logger.info 'Building......'
+      logger_info_dividing_line
+
+      logger.info `#{@build_cmd}`
+
+      if $?.to_i != 0
+        logger.error 'Build failed'
+        exit 1
+      end
+    end
+
+    def logger_info_and_get_dependencies_command(cmd)
+      logger.info cmd
+      logger_info_dividing_line
+      logger.info `#{cmd}`
+    end
+  end
+end
+
+